GH-5286 Determine right hand side evaluation type for well designed queries statically

Author: jasperiq

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

@@ -20,9 +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.iterator.BadlyDesignedLeftJoinIterator;
-import org.eclipse.rdf4j.query.algebra.evaluation.iterator.HashJoinIteration;
-import org.eclipse.rdf4j.query.algebra.evaluation.iterator.LeftJoinIterator;
+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;
 
@@ -32,6 +30,7 @@ public final class LeftJoinQueryEvaluationStep implements QueryEvaluationStep {
 	private final QueryEvaluationStep left;
 	private final LeftJoin leftJoin;
 	private final Set<String> optionalVars;
+	private final QueryEvaluationStep wellDesignedRightEvaluationStep;
 
 	public static QueryEvaluationStep supply(EvaluationStrategy strategy, LeftJoin leftJoin,
 			QueryEvaluationContext context) {
@@ -85,7 +84,11 @@ public LeftJoinQueryEvaluationStep(QueryEvaluationStep right, QueryValueEvaluati
 		}
 
 		this.optionalVars = optionalVars;
-
+		this.wellDesignedRightEvaluationStep = determineRightEvaluationStep(
+				leftJoin,
+				right,
+				condition,
+				leftJoin.getBindingNames());
 	}
 
 	@Override
@@ -103,14 +106,37 @@ public CloseableIteration<BindingSet> evaluate(BindingSet bindings) {
 		if (containsNone) {
 			// left join is "well designed"
 			leftJoin.setAlgorithm(LeftJoinIterator.class.getSimpleName());
-			var rightEvaluationStep = LeftJoinIterator.determineRightEvaluationStep(leftJoin, right, condition, leftJoin.getBindingNames());
-			return LeftJoinIterator.getInstance(left, bindings, rightEvaluationStep);
+			return LeftJoinIterator.getInstance(left, bindings, wellDesignedRightEvaluationStep);
 		} else {
 			Set<String> problemVars = new HashSet<>(optionalVars);
 			problemVars.retainAll(bindings.getBindingNames());
 
 			leftJoin.setAlgorithm(BadlyDesignedLeftJoinIterator.class.getSimpleName());
-			return new BadlyDesignedLeftJoinIterator(left, right, condition, bindings, problemVars, leftJoin);
+			var rightEvaluationStep = determineRightEvaluationStep(leftJoin, right, condition, problemVars);
+			return new BadlyDesignedLeftJoinIterator(left, bindings, problemVars, rightEvaluationStep);
 		}
 	}
+
+	public static QueryEvaluationStep determineRightEvaluationStep(
+			LeftJoin join,
+			QueryEvaluationStep prepareRightArg,
+			QueryValueEvaluationStep joinCondition,
+			Set<String> scopeBindingNames) {
+		if (joinCondition == null) {
+			return prepareRightArg;
+		} else if (canEvaluateConditionBasedOnLeftHandSide(join)) {
+			return new LeftJoinPreFilterQueryEvaluationStep(
+					prepareRightArg,
+					new ScopeBindingsJoinConditionEvaluator(join.getAssuredBindingNames(), joinCondition));
+		} else {
+			return new LeftJoinPostFilterQueryEvaluationStep(
+					prepareRightArg,
+					new ScopeBindingsJoinConditionEvaluator(scopeBindingNames, joinCondition));
+		}
+	}
+
+	private static boolean canEvaluateConditionBasedOnLeftHandSide(LeftJoin leftJoin) {
+		var varNames = VarNameCollector.process(leftJoin.getCondition());
+		return leftJoin.getAssuredBindingNames().containsAll(varNames);
+	}
 }

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

@@ -40,9 +40,13 @@ public class BadlyDesignedLeftJoinIterator extends LeftJoinIterator {
 	 * Constructors *
 	 *--------------*/
 
-	public BadlyDesignedLeftJoinIterator(EvaluationStrategy strategy, LeftJoin join, BindingSet inputBindings,
-			Set<String> problemVars, QueryEvaluationContext context) throws QueryEvaluationException {
-		super(strategy, join, getFilteredBindings(inputBindings, problemVars), context);
+	public BadlyDesignedLeftJoinIterator(
+			EvaluationStrategy strategy,
+			LeftJoin join,
+			BindingSet inputBindings,
+			Set<String> problemVars,
+			QueryEvaluationStep rightEvaluationStep) throws QueryEvaluationException {
+		super(strategy, join, getFilteredBindings(inputBindings, problemVars), rightEvaluationStep);
 		this.inputBindings = inputBindings;
 		this.problemVars = problemVars;
 
@@ -53,13 +57,11 @@ public BadlyDesignedLeftJoinIterator(EvaluationStrategy strategy, LeftJoin join,
 	 *---------*/
 
 	public BadlyDesignedLeftJoinIterator(QueryEvaluationStep left,
-			QueryEvaluationStep right,
-			QueryValueEvaluationStep joinCondition,
 			BindingSet inputBindings,
 			Set<String> problemVars,
-			LeftJoin leftJoin)
+			QueryEvaluationStep rightEvaluationStep)
 			throws QueryEvaluationException {
-		super(left, right, joinCondition, getFilteredBindings(inputBindings, problemVars), problemVars, leftJoin);
+		super(left, getFilteredBindings(inputBindings, problemVars), rightEvaluationStep);
 		this.inputBindings = inputBindings;
 		this.problemVars = problemVars;
 	}

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

@@ -15,13 +15,10 @@
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.QueryEvaluationException;
 import org.eclipse.rdf4j.query.algebra.LeftJoin;
-import org.eclipse.rdf4j.query.algebra.evaluation.*;
-import org.eclipse.rdf4j.query.algebra.evaluation.impl.QueryEvaluationContext;
-import org.eclipse.rdf4j.query.algebra.helpers.collectors.VarNameCollector;
+import org.eclipse.rdf4j.query.algebra.evaluation.EvaluationStrategy;
+import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
 
 import java.util.NoSuchElementException;
-import java.util.Optional;
-import java.util.Set;
 
 public class LeftJoinIterator extends LookAheadIteration<BindingSet> {
 	/*-----------*
@@ -41,35 +38,21 @@ public LeftJoinIterator(
 			EvaluationStrategy strategy,
 			LeftJoin join,
 			BindingSet bindings,
-			QueryEvaluationContext context) throws QueryEvaluationException {
-		Set<String> scopeBindingNames = join.getBindingNames();
-
+			QueryEvaluationStep rightEvaluationStep) throws QueryEvaluationException {
 		leftIter = strategy.evaluate(join.getLeftArg(), bindings);
 
 		rightIter = null;
 
-		QueryEvaluationStep prepareRightArg = strategy.precompile(join.getRightArg(), context);
 		join.setAlgorithm(this);
-		var joinCondition = Optional.ofNullable(join.getCondition())
-				.map(condition -> strategy.precompile(condition, context));
-
-		rightEvaluationStep = determineRightEvaluationStep(
-				join,
-				prepareRightArg,
-				joinCondition.orElse(null),
-				scopeBindingNames);
+
+		this.rightEvaluationStep = rightEvaluationStep;
 	}
 
 	public LeftJoinIterator(
 			QueryEvaluationStep left,
-			QueryEvaluationStep right,
-			QueryValueEvaluationStep joinCondition,
 			BindingSet bindings,
-			Set<String> scopeBindingNames,
-			LeftJoin leftJoin) throws QueryEvaluationException {
-		this(
-				left.evaluate(bindings),
-				determineRightEvaluationStep(leftJoin, right, joinCondition, scopeBindingNames));
+			QueryEvaluationStep rightEvaluationStep) throws QueryEvaluationException {
+		this(left.evaluate(bindings), rightEvaluationStep);
 	}
 
 	public LeftJoinIterator(CloseableIteration<BindingSet> leftIter, QueryEvaluationStep rightEvaluationStep) {
@@ -153,31 +136,4 @@ protected void handleClose() throws QueryEvaluationException {
 			}
 		}
 	}
-
-	public static QueryEvaluationStep determineRightEvaluationStep(
-			LeftJoin join,
-			QueryEvaluationStep prepareRightArg,
-			QueryValueEvaluationStep joinCondition,
-			Set<String> scopeBindingNames) {
-		if (joinCondition == null) {
-			return prepareRightArg;
-		} else if (canEvaluateConditionBasedOnLeftHandSide(join)) {
-			return new LeftJoinPreFilterQueryEvaluationStep(
-					prepareRightArg,
-					new ScopeBindingsJoinConditionEvaluator(join.getAssuredBindingNames(), joinCondition));
-		} else {
-			return new LeftJoinPostFilterQueryEvaluationStep(
-					prepareRightArg,
-					new ScopeBindingsJoinConditionEvaluator(scopeBindingNames, joinCondition));
-		}
-	}
-
-	private static boolean canEvaluateConditionBasedOnLeftHandSide(LeftJoin leftJoin) {
-		if (!leftJoin.hasCondition()) {
-			return false;
-		}
-
-		var varNames = VarNameCollector.process(leftJoin.getCondition());
-		return leftJoin.getAssuredBindingNames().containsAll(varNames);
-	}
 }

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

@@ -5,14 +5,13 @@
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
 
-class LeftJoinPostFilterQueryEvaluationStep implements QueryEvaluationStep {
+public class LeftJoinPostFilterQueryEvaluationStep implements QueryEvaluationStep {
 
     private final QueryEvaluationStep wrapped;
 	private final ScopeBindingsJoinConditionEvaluator joinConditionEvaluator;
 
-    LeftJoinPostFilterQueryEvaluationStep(
-            QueryEvaluationStep wrapped,
-			ScopeBindingsJoinConditionEvaluator joinConditionEvaluator) {
+    public LeftJoinPostFilterQueryEvaluationStep(QueryEvaluationStep wrapped,
+                                                 ScopeBindingsJoinConditionEvaluator joinConditionEvaluator) {
 		this.wrapped = wrapped;
         this.joinConditionEvaluator = joinConditionEvaluator;
     }

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

@@ -4,14 +4,13 @@
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.algebra.evaluation.QueryEvaluationStep;
 
-class LeftJoinPreFilterQueryEvaluationStep implements QueryEvaluationStep {
+public class LeftJoinPreFilterQueryEvaluationStep implements QueryEvaluationStep {
 
 	private final QueryEvaluationStep wrapped;
 	private final ScopeBindingsJoinConditionEvaluator joinConditionEvaluator;
 
-    LeftJoinPreFilterQueryEvaluationStep(
-            QueryEvaluationStep wrapped,
-			ScopeBindingsJoinConditionEvaluator joinConditionEvaluator) {
+    public LeftJoinPreFilterQueryEvaluationStep(QueryEvaluationStep wrapped,
+                                                ScopeBindingsJoinConditionEvaluator joinConditionEvaluator) {
 		this.wrapped = wrapped;
         this.joinConditionEvaluator = joinConditionEvaluator;
     }

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

@@ -10,7 +10,7 @@
 
 import java.util.Set;
 
-class ScopeBindingsJoinConditionEvaluator {
+public class ScopeBindingsJoinConditionEvaluator {
 
 	/**
 	 * The set of binding names that are "in scope" for the filter. The filter must not include bindings that are (only)
@@ -19,7 +19,7 @@ class ScopeBindingsJoinConditionEvaluator {
     private final Set<String> scopeBindingNames;
     private final QueryValueEvaluationStep joinCondition;
 
-    ScopeBindingsJoinConditionEvaluator(Set<String> scopeBindingNames, QueryValueEvaluationStep joinCondition) {
+    public ScopeBindingsJoinConditionEvaluator(Set<String> scopeBindingNames, QueryValueEvaluationStep joinCondition) {
         this.scopeBindingNames = scopeBindingNames;
         this.joinCondition = joinCondition;
     }

tools/federation/src/main/java/org/eclipse/rdf4j/federated/evaluation/FederationEvalStrategy.java

@@ -12,6 +12,7 @@
 
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -116,6 +117,7 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.impl.EvaluationStatistics;
 import org.eclipse.rdf4j.query.algebra.evaluation.impl.QueryEvaluationContext;
 import org.eclipse.rdf4j.query.algebra.evaluation.impl.StrictEvaluationStrategy;
+import org.eclipse.rdf4j.query.algebra.evaluation.impl.evaluationsteps.LeftJoinQueryEvaluationStep;
 import org.eclipse.rdf4j.query.algebra.evaluation.iterator.BadlyDesignedLeftJoinIterator;
 import org.eclipse.rdf4j.query.algebra.evaluation.iterator.HashJoinIteration;
 import org.eclipse.rdf4j.query.algebra.evaluation.optimizer.ConstantOptimizer;
@@ -813,8 +815,21 @@ public CloseableIteration<BindingSet> evaluate(BindingSet bindings) {
 				} else {
 					Set<String> problemVarsClone = new HashSet<>(problemVars);
 					problemVarsClone.retainAll(bindings.getBindingNames());
-					return new BadlyDesignedLeftJoinIterator(FederationEvalStrategy.this, leftJoin, bindings,
-							problemVarsClone, context);
+					QueryEvaluationStep preCompiledRight = this.precompile(leftJoin.getRightArg(), context);
+					var joinCondition = Optional.ofNullable(leftJoin.getCondition())
+							.map(condition -> this.precompile(condition, context))
+							.orElse(null);
+					var rightEvaluationStep = LeftJoinQueryEvaluationStep.determineRightEvaluationStep(
+							leftJoin,
+							preCompiledRight,
+							joinCondition,
+							problemVars);
+					return new BadlyDesignedLeftJoinIterator(
+							FederationEvalStrategy.this,
+							leftJoin,
+							bindings,
+							problemVarsClone,
+							rightEvaluationStep);
 				}
 			};
 		}