GH-5286 Generalize concepts for evaluation steps and condition

Author: jasperiq

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/QueryValueEvaluationStep.java

@@ -12,12 +12,14 @@
 package org.eclipse.rdf4j.query.algebra.evaluation;
 
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 import org.eclipse.rdf4j.model.Value;
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.QueryEvaluationException;
 import org.eclipse.rdf4j.query.algebra.ValueConstant;
 import org.eclipse.rdf4j.query.algebra.ValueExpr;
+import org.eclipse.rdf4j.query.algebra.evaluation.util.QueryEvaluationUtility;
 
 /**
  * A step in the query evaluation that works on ValueExpresions.
@@ -26,6 +28,18 @@ public interface QueryValueEvaluationStep {
 	Value evaluate(BindingSet bindings)
 			throws QueryEvaluationException;
 
+	default Predicate<BindingSet> asPredicate() {
+		return bs -> {
+			try {
+				Value value = evaluate(bs);
+				return QueryEvaluationUtility.getEffectiveBooleanValue(value).orElse(false);
+			} catch (ValueExprEvaluationException e) {
+				// Ignore, condition not evaluated successfully
+				return false;
+			}
+		};
+	}
+
 	/**
 	 * If an value expression results in a constant then it may be executed once per query invocation. This can reduce
 	 * computation time significantly.

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/evaluationsteps/LeftJoinQueryEvaluationStep.java

@@ -20,6 +20,7 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryValueEvaluationStep;
 import org.eclipse.rdf4j.query.algebra.evaluation.impl.QueryEvaluationContext;
+import org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps.values.ScopedQueryValueEvaluationStep;
 import org.eclipse.rdf4j.query.algebra.evaluation.iterator.*;
 import org.eclipse.rdf4j.query.algebra.helpers.TupleExprs;
 import org.eclipse.rdf4j.query.algebra.helpers.collectors.VarNameCollector;
@@ -125,13 +126,13 @@ public static QueryEvaluationStep determineRightEvaluationStep(
 		if (joinCondition == null) {
 			return prepareRightArg;
 		} else if (canEvaluateConditionBasedOnLeftHandSide(join)) {
-			return new LeftJoinPreFilterQueryEvaluationStep(
+			return new PreFilterQueryEvaluationStep(
 					prepareRightArg,
-					new ScopeBindingsJoinConditionEvaluator(join.getAssuredBindingNames(), joinCondition));
+					new ScopedQueryValueEvaluationStep(join.getAssuredBindingNames(), joinCondition));
 		} else {
-			return new LeftJoinPostFilterQueryEvaluationStep(
+			return new PostFilterQueryEvaluationStep(
 					prepareRightArg,
-					new ScopeBindingsJoinConditionEvaluator(scopeBindingNames, joinCondition));
+					new ScopedQueryValueEvaluationStep(scopeBindingNames, joinCondition));
 		}
 	}
 

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/iterator/LeftJoinPostFilterQueryEvaluationStep.java renamed to core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/evaluationsteps/PostFilterQueryEvaluationStep.java

@@ -1,20 +1,23 @@
-package org.eclipse.rdf4j.query.algebra.evaluation.iterator;
+package org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps;
+
+import java.util.function.Predicate;
 
 import org.eclipse.rdf4j.common.iteration.CloseableIteration;
 import org.eclipse.rdf4j.common.iteration.FilterIteration;
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryValueEvaluationStep;
 
-public class LeftJoinPostFilterQueryEvaluationStep implements QueryEvaluationStep {
+public class PostFilterQueryEvaluationStep implements QueryEvaluationStep {
 
-    private final QueryEvaluationStep wrapped;
-	private final ScopeBindingsJoinConditionEvaluator joinConditionEvaluator;
+	private final QueryEvaluationStep wrapped;
+	private final Predicate<BindingSet> condition;
 
-    public LeftJoinPostFilterQueryEvaluationStep(QueryEvaluationStep wrapped,
-                                                 ScopeBindingsJoinConditionEvaluator joinConditionEvaluator) {
+	public PostFilterQueryEvaluationStep(QueryEvaluationStep wrapped,
+			QueryValueEvaluationStep condition) {
 		this.wrapped = wrapped;
-        this.joinConditionEvaluator = joinConditionEvaluator;
-    }
+		this.condition = condition.asPredicate();
+	}
 
 	@Override
 	public CloseableIteration<BindingSet> evaluate(BindingSet leftBindings) {
@@ -28,12 +31,12 @@ public CloseableIteration<BindingSet> evaluate(BindingSet leftBindings) {
 
 			@Override
 			protected boolean accept(BindingSet bindings) {
-				return joinConditionEvaluator.evaluate(bindings);
+				return condition.test(bindings);
 			}
 
 			@Override
 			protected void handleClose() {
-				rightIteration.close();
+				// Nothing to close
 			}
 		};
 	}

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/evaluationsteps/PreFilterQueryEvaluationStep.java

@@ -0,0 +1,30 @@
+package org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps;
+
+import java.util.function.Predicate;
+
+import org.eclipse.rdf4j.common.iteration.CloseableIteration;
+import org.eclipse.rdf4j.query.BindingSet;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryValueEvaluationStep;
+
+public class PreFilterQueryEvaluationStep implements QueryEvaluationStep {
+
+	private final QueryEvaluationStep wrapped;
+	private final Predicate<BindingSet> condition;
+
+	public PreFilterQueryEvaluationStep(QueryEvaluationStep wrapped,
+			QueryValueEvaluationStep condition) {
+		this.wrapped = wrapped;
+		this.condition = condition.asPredicate();
+	}
+
+	@Override
+	public CloseableIteration<BindingSet> evaluate(BindingSet leftBindings) {
+		if (!condition.test(leftBindings)) {
+			// Usage of this method assume this instance is returned
+			return QueryEvaluationStep.EMPTY_ITERATION;
+		}
+
+		return wrapped.evaluate(leftBindings);
+	}
+}

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/evaluationsteps/values/ScopedQueryValueEvaluationStep.java

@@ -0,0 +1,43 @@
+package org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps.values;
+
+import java.util.Set;
+
+import org.eclipse.rdf4j.model.Value;
+import org.eclipse.rdf4j.query.Binding;
+import org.eclipse.rdf4j.query.BindingSet;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryBindingSet;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryValueEvaluationStep;
+
+public class ScopedQueryValueEvaluationStep implements QueryValueEvaluationStep {
+
+	/**
+	 * The set of binding names that are "in scope" for the filter. The filter must not include bindings that are (only)
+	 * included because of the depth-first evaluation strategy in the evaluation of the constraint.
+	 */
+	private final Set<String> scopeBindingNames;
+	private final QueryValueEvaluationStep wrapped;
+
+	public ScopedQueryValueEvaluationStep(Set<String> scopeBindingNames, QueryValueEvaluationStep condition) {
+		this.scopeBindingNames = scopeBindingNames;
+		this.wrapped = condition;
+	}
+
+	@Override
+	public Value evaluate(BindingSet bindings) {
+		BindingSet scopeBindings = createScopeBindings(scopeBindingNames, bindings);
+
+		return wrapped.evaluate(scopeBindings);
+	}
+
+	private BindingSet createScopeBindings(Set<String> scopeBindingNames, BindingSet bindings) {
+		QueryBindingSet scopeBindings = new QueryBindingSet(scopeBindingNames.size());
+		for (String scopeBindingName : scopeBindingNames) {
+			Binding binding = bindings.getBinding(scopeBindingName);
+			if (binding != null) {
+				scopeBindings.addBinding(binding);
+			}
+		}
+
+		return scopeBindings;
+	}
+}

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/iterator/LeftJoinIterator.java

@@ -10,6 +10,8 @@
  *******************************************************************************/
 package org.eclipse.rdf4j.query.algebra.evaluation.iterator;
 
+import java.util.NoSuchElementException;
+
 import org.eclipse.rdf4j.common.iteration.CloseableIteration;
 import org.eclipse.rdf4j.common.iteration.LookAheadIteration;
 import org.eclipse.rdf4j.query.BindingSet;
@@ -18,8 +20,6 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.EvaluationStrategy;
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
 
-import java.util.NoSuchElementException;
-
 public class LeftJoinIterator extends LookAheadIteration<BindingSet> {
 	/*-----------*
 	 * Variables *

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/iterator/LeftJoinPreFilterQueryEvaluationStep.java

@@ -0,0 +1,97 @@
+package org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+import org.eclipse.rdf4j.common.iteration.CloseableIteration;
+import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.impl.BooleanLiteral;
+import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+import org.eclipse.rdf4j.query.BindingSet;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryBindingSet;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryValueEvaluationStep;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class PostFilterQueryEvaluationStepTest {
+
+	private static final ValueFactory VALUE_FACTORY = SimpleValueFactory.getInstance();
+
+	private QueryBindingSet bindingSet;
+
+	@BeforeEach
+	void setUp() {
+		bindingSet = new QueryBindingSet(1);
+		bindingSet.addBinding("a", VALUE_FACTORY.createLiteral(42));
+	}
+
+	@Test
+	@DisplayName("when wrapped returns empty iteration, then LeftJoinPostFilterQueryEvaluationStep returns empty iteration")
+	void emptyIteration() {
+		QueryEvaluationStep wrapped = (bindings) -> QueryEvaluationStep.EMPTY_ITERATION;
+		QueryEvaluationStep postFilter = new PostFilterQueryEvaluationStep(
+				wrapped,
+				bindings -> BooleanLiteral.valueOf(true));
+
+		var result = postFilter.evaluate(bindingSet);
+
+		assertThat(result).isEqualTo(QueryEvaluationStep.EMPTY_ITERATION);
+	}
+
+	@Test
+	@DisplayName("when wrapped returns non-empty iteration, then LeftJoinPostFilterQueryEvaluationStep returns filtered iteration")
+	void filteredIteration() {
+		QueryEvaluationStep wrapped = new TestQueryEvaluationStep();
+		QueryValueEvaluationStep condition = bindings -> {
+			var shouldAccept = bindings.getValue("b")
+					.stringValue()
+					.equals("abc");
+			return BooleanLiteral.valueOf(shouldAccept);
+		};
+		QueryEvaluationStep postFilter = new PostFilterQueryEvaluationStep(wrapped, condition);
+
+		var result = postFilter.evaluate(bindingSet);
+
+		assertThat(result)
+				.toIterable()
+				.map(bindings -> bindings.getValue("b"))
+				.containsExactly(VALUE_FACTORY.createLiteral("abc"));
+	}
+
+	private static class TestQueryEvaluationStep implements QueryEvaluationStep {
+
+		private final Queue<String> values = new LinkedList<>();
+
+		private TestQueryEvaluationStep() {
+			values.add("abc");
+			values.add("xyz");
+		}
+
+		@Override
+		public CloseableIteration<BindingSet> evaluate(BindingSet bindings) {
+			return new CloseableIteration<>() {
+				@Override
+				public void close() {
+					// Nothing to close
+				}
+
+				@Override
+				public boolean hasNext() {
+					return !values.isEmpty();
+				}
+
+				@Override
+				public BindingSet next() {
+					var output = new QueryBindingSet(2);
+					bindings.forEach(output::addBinding);
+					output.addBinding("b", VALUE_FACTORY.createLiteral(values.poll()));
+					return output;
+				}
+			};
+		}
+	}
+}