fix for failing tests

Author: hmottestad

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

@@ -603,11 +603,31 @@ protected QueryEvaluationStep prepare(Slice node, QueryEvaluationContext context
 	protected QueryEvaluationStep prepare(Extension node, QueryEvaluationContext context)
 			throws QueryEvaluationException {
 		QueryEvaluationStep arg = precompile(node.getArg(), context);
+		boolean setNullOnError = !isWithinMinusRightArg(node);
 		Consumer<MutableBindingSet> consumer = ExtensionIterator.buildLambdaToEvaluateTheExpressions(node, this,
-				context);
+				context, setNullOnError);
 		return new ExtensionQueryEvaluationStep(arg, consumer, context);
 	}
 
+	private static boolean isWithinMinusRightArg(QueryModelNode node) {
+		QueryModelNode child = node;
+		QueryModelNode parent = node.getParentNode();
+		while (parent != null) {
+			if (parent instanceof Difference) {
+				Difference diff = (Difference) parent;
+				if (diff.getRightArg() == child) {
+					return true;
+				}
+				if (diff.getLeftArg() == child) {
+					return false;
+				}
+			}
+			child = parent;
+			parent = parent.getParentNode();
+		}
+		return false;
+	}
+
 	protected QueryEvaluationStep prepare(Service service, QueryEvaluationContext context)
 			throws QueryEvaluationException {
 		Var serviceRef = service.getServiceRef();
@@ -1321,7 +1341,18 @@ protected QueryValueEvaluationStep prepare(CompareAll node, QueryEvaluationConte
 
 	protected QueryValueEvaluationStep prepare(Exists node, QueryEvaluationContext context)
 			throws QueryEvaluationException {
-		QueryEvaluationStep subquery = precompile(node.getSubQuery(), context);
+		// Optimization/semantic shortcut: EXISTS { OPTIONAL { ... } } is always true.
+		// In algebra, OPTIONAL is a LeftJoin. With a SingletonSet left-arg, LeftJoin
+		// always yields at least the input binding set. Therefore EXISTS evaluates to TRUE.
+		TupleExpr subQuery = node.getSubQuery();
+		if (subQuery instanceof LeftJoin) {
+			LeftJoin leftJoin = (LeftJoin) subQuery;
+			if (leftJoin.getLeftArg() instanceof SingletonSet) {
+				return bindings -> BooleanLiteral.TRUE;
+			}
+		}
+
+		QueryEvaluationStep subquery = precompile(subQuery, context);
 		return new ExistsQueryValueEvaluationStep(subquery);
 	}
 

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

@@ -37,7 +37,7 @@ public ExtensionIterator(Extension extension, CloseableIteration<BindingSet> ite
 			EvaluationStrategy strategy, QueryEvaluationContext context) throws QueryEvaluationException {
 		super(iter);
 		this.context = context;
-		this.setter = buildLambdaToEvaluateTheExpressions(extension, strategy, context);
+		this.setter = buildLambdaToEvaluateTheExpressions(extension, strategy, context, true);
 	}
 
 	public ExtensionIterator(CloseableIteration<BindingSet> iter,
@@ -48,14 +48,16 @@ public ExtensionIterator(CloseableIteration<BindingSet> iter,
 	}
 
 	public static Consumer<MutableBindingSet> buildLambdaToEvaluateTheExpressions(Extension extension,
-			EvaluationStrategy strategy, QueryEvaluationContext context) {
+			EvaluationStrategy strategy, QueryEvaluationContext context, boolean setNullOnError) {
 		Consumer<MutableBindingSet> consumer = null;
 		for (ExtensionElem extElem : extension.getElements()) {
 			ValueExpr expr = extElem.getExpr();
 			if (!(expr instanceof AggregateOperator)) {
 				QueryValueEvaluationStep prepared = strategy.precompile(extElem.getExpr(), context);
 				BiConsumer<Value, MutableBindingSet> setBinding = context.setBinding(extElem.getName());
-				consumer = andThen(consumer, targetBindings -> setValue(setBinding, prepared, targetBindings));
+				boolean setNullOnErrorLocal = setNullOnError;
+				consumer = andThen(consumer,
+						targetBindings -> setValue(setBinding, prepared, targetBindings, setNullOnErrorLocal));
 			}
 		}
 		if (consumer == null) {
@@ -67,7 +69,7 @@ public static Consumer<MutableBindingSet> buildLambdaToEvaluateTheExpressions(Ex
 	}
 
 	private static void setValue(BiConsumer<Value, MutableBindingSet> setBinding, QueryValueEvaluationStep prepared,
-			MutableBindingSet targetBindings) {
+			MutableBindingSet targetBindings, boolean setNullOnError) {
 		try {
 			// we evaluate each extension element over the targetbindings, so that bindings from
 			// a previous extension element in this same extension can be used by other extension elements.
@@ -79,11 +81,13 @@ private static void setValue(BiConsumer<Value, MutableBindingSet> setBinding, Qu
 				setBinding.accept(targetValue, targetBindings);
 			}
 		} catch (ValueExprEvaluationException e) {
-			// silently ignore type errors in extension arguments. They should not cause the
-			// query to fail but result in no bindings for this solution
-			// see https://www.w3.org/TR/sparql11-query/#assignment
-			// use null as place holder for unbound variables that must remain so
-			setBinding.accept(null, targetBindings);
+			// Silently ignore type errors in extension arguments. Whether to install a
+			// placeholder null-binding (variable must remain unbound) or leave it unset
+			// depends on context. By default we set a null-binding to enforce the SPARQL
+			// assignment rule; in special contexts (e.g., MINUS RHS), we may skip it.
+			if (setNullOnError) {
+				setBinding.accept(null, targetBindings);
+			}
 		}
 	}