Sketch based join optimisation

.gitignore

@@ -53,3 +53,5 @@ e2e/node_modules
 e2e/playwright-report
 e2e/test-results
 .aider*
+/.m2/
+

core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleValueFactory.java

@@ -49,6 +49,17 @@ public class SimpleValueFactory extends AbstractValueFactory {
 	private final static String uniqueIdPrefix = UUID.randomUUID().toString().replace("-", "");
 	private final static AtomicLong uniqueIdSuffix = new AtomicLong();
 
+	// Pre-built strings for lengths 0 through 9
+	private static final String[] RANDOMIZE_LENGTH = new String[10];
+
+	static {
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i <= 9; i++) {
+			RANDOMIZE_LENGTH[i] = sb.toString();
+			sb.append(i);
+		}
+	}
+
 	private static final DatatypeFactory datatypeFactory;
 
 	static {
@@ -130,7 +141,12 @@ public Triple createTriple(Resource subject, IRI predicate, Value object) {
 
 	@Override
 	public BNode createBNode() {
-		return createBNode(uniqueIdPrefix + uniqueIdSuffix.incrementAndGet());
+		long l = uniqueIdSuffix.incrementAndGet();
+		// reverse the string representation of the long to ensure that the BNode IDs are not monotonically increasing
+		StringBuilder sb = new StringBuilder(Long.toString(l));
+		sb.reverse();
+		sb.append(uniqueIdPrefix).append(RANDOMIZE_LENGTH[(int) (Math.abs(l % RANDOMIZE_LENGTH.length))]);
+		return createBNode(sb.toString());
 	}
 
 	/**

core/model/src/test/java/org/eclipse/rdf4j/model/impl/SimpleValueFactoryOverflowTest.java

@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Eclipse RDF4J contributors.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Distribution License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *******************************************************************************/
+
+package org.eclipse.rdf4j.model.impl;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.lang.reflect.Field;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Reproduces overflow in SimpleValueFactory#createBNode() when the atomic counter wraps to Long.MIN_VALUE, which
+ * results in a negative index into the RANDOMIZE_LENGTH array and throws ArrayIndexOutOfBoundsException.
+ */
+public class SimpleValueFactoryOverflowTest {
+
+	@Test
+	void overflowAtMinValue() throws Exception {
+		// Access the private static counter
+		Field f = SimpleValueFactory.class.getDeclaredField("uniqueIdSuffix");
+		f.setAccessible(true);
+		AtomicLong counter = (AtomicLong) f.get(null);
+
+		// Preserve original value to avoid leaking state across tests
+		long original = counter.get();
+
+		synchronized (SimpleValueFactory.class) {
+			try {
+				// Force next increment to wrap from Long.MAX_VALUE to Long.MIN_VALUE
+				counter.set(Long.MAX_VALUE);
+
+				SimpleValueFactory.getInstance().createBNode();
+			} finally {
+				// Restore the original value
+				counter.set(original);
+			}
+		}
+	}
+}

core/query/src/main/java/org/eclipse/rdf4j/query/explanation/Explanation.java

@@ -22,6 +22,8 @@
 @Experimental
 public interface Explanation {
 
+	Object tupleExpr();
+
 	/**
 	 * The different levels that the query explanation can be at.
 	 *

core/query/src/main/java/org/eclipse/rdf4j/query/explanation/ExplanationImpl.java

@@ -27,16 +27,23 @@
 public class ExplanationImpl implements Explanation {
 
 	private final GenericPlanNode genericPlanNode;
+	private final Object tupleExpr;
 
-	public ExplanationImpl(GenericPlanNode genericPlanNode, boolean timedOut) {
+	public ExplanationImpl(GenericPlanNode genericPlanNode, boolean timedOut, Object tupleExpr) {
 		this.genericPlanNode = genericPlanNode;
+		this.tupleExpr = tupleExpr;
 		if (timedOut) {
 			genericPlanNode.setTimedOut(timedOut);
 		}
 	}
 
 	ObjectMapper objectMapper = new ObjectMapper();
 
+	@Override
+	public Object tupleExpr() {
+		return tupleExpr;
+	}
+
 	@Override
 	public GenericPlanNode toGenericPlanNode() {
 		return genericPlanNode;

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

@@ -11,7 +11,6 @@
 package org.eclipse.rdf4j.query.algebra.evaluation;
 
 import java.util.Comparator;
-import java.util.EnumSet;
 import java.util.Set;
 
 import org.eclipse.rdf4j.common.annotation.Experimental;
@@ -22,7 +21,6 @@
 import org.eclipse.rdf4j.model.IRI;
 import org.eclipse.rdf4j.model.Resource;
 import org.eclipse.rdf4j.model.Statement;
-import org.eclipse.rdf4j.model.Triple;
 import org.eclipse.rdf4j.model.Value;
 import org.eclipse.rdf4j.model.ValueFactory;
 import org.eclipse.rdf4j.query.QueryEvaluationException;

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

@@ -353,7 +353,7 @@ public void meet(Var node) throws QueryEvaluationException {
 				// We can skip constants that are only used in StatementPatterns since these are never added to the
 				// BindingSet anyway
 				if (!(node.isConstant() && node.getParentNode() instanceof StatementPattern)) {
-					Var replacement = new Var(varNames.computeIfAbsent(node.getName(), k -> k), node.getValue(),
+					Var replacement = Var.of(varNames.computeIfAbsent(node.getName(), k -> k), node.getValue(),
 							node.isAnonymous(), node.isConstant());
 					node.replaceWith(replacement);
 				}

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

@@ -1232,8 +1232,32 @@ protected QueryValueEvaluationStep prepare(Coalesce node, QueryEvaluationContext
 
 	protected QueryValueEvaluationStep prepare(Compare node, QueryEvaluationContext context) {
 		boolean strict = QueryEvaluationMode.STRICT == getQueryEvaluationMode();
-		return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
-				.valueOf(QueryEvaluationUtil.compare(leftVal, rightVal, node.getOperator(), strict)), context);
+
+		Compare.CompareOp operator = node.getOperator();
+		switch (operator) {
+		case EQ:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareEQ(leftVal, rightVal, strict)), context);
+		case NE:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareNE(leftVal, rightVal, strict)), context);
+		case LT:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareLT(leftVal, rightVal, strict)), context);
+		case LE:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareLE(leftVal, rightVal, strict)), context);
+		case GE:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareGE(leftVal, rightVal, strict)), context);
+		case GT:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compareGT(leftVal, rightVal, strict)), context);
+		default:
+			return supplyBinaryValueEvaluation(node, (leftVal, rightVal) -> BooleanLiteral
+					.valueOf(QueryEvaluationUtil.compare(leftVal, rightVal, node.getOperator(), strict)), context);
+		}
+
 	}
 
 	private BiFunction<Value, Value, Value> mathOperationApplier(MathExpr node,

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

@@ -46,6 +46,16 @@ public class EvaluationStatistics {
 	private final static String uniqueIdPrefix = UUID.randomUUID().toString().replace("-", "");
 	private final static AtomicLong uniqueIdSuffix = new AtomicLong();
 
+	// Pre-built strings for lengths 0 through 9
+	private static final String[] RANDOMIZE_LENGTH = new String[10];
+	static {
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i <= 9; i++) {
+			RANDOMIZE_LENGTH[i] = sb.toString();
+			sb.append(i);
+		}
+	}
+
 	private CardinalityCalculator calculator;
 
 	public double getCardinality(TupleExpr expr) {
@@ -66,6 +76,10 @@ protected CardinalityCalculator createCardinalityCalculator() {
 		return new CardinalityCalculator();
 	}
 
+	public boolean supportsJoinEstimation() {
+		return false;
+	}
+
 	/*-----------------------------------*
 	 * Inner class CardinalityCalculator *
 	 *-----------------------------------*/
@@ -117,7 +131,11 @@ public void meet(ZeroLengthPath node) {
 
 		@Override
 		public void meet(ArbitraryLengthPath node) {
-			final Var pathVar = new Var("_anon_" + uniqueIdPrefix + uniqueIdSuffix.incrementAndGet(), true);
+			long suffix = uniqueIdSuffix.getAndIncrement();
+			final Var pathVar = Var.of(
+					"_anon_path_" + uniqueIdPrefix + suffix
+							+ RANDOMIZE_LENGTH[(int) (Math.abs(suffix % RANDOMIZE_LENGTH.length))],
+					true);
 			// cardinality of ALP is determined based on the cost of a
 			// single ?s ?p ?o ?c pattern where ?p is unbound, compensating for the fact that
 			// the length of the path is unknown but expected to be _at least_ twice that of a normal