Merge branch 'temp-main-to-merge' into merge-main-7

# Conflicts:
#	core/collection-factory/mapdb3/pom.xml
#	core/common/order/pom.xml
#	core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/ArrayBindingSet.java
#	core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/ArrayBindingBasedQueryEvaluationContext.java
#	core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/DefaultEvaluationStrategy.java
#	core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/iterator/FilterIterator.java
#	core/sail/shacl/src/main/java/org/eclipse/rdf4j/sail/shacl/ShaclSailConnection.java
#	testsuites/shacl/pom.xml
#	testsuites/sparql/src/main/java/org/eclipse/rdf4j/testsuite/sparql/RepositorySPARQLComplianceTestSuite.java

Author: hmottestad

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

@@ -10,12 +10,15 @@
  *******************************************************************************/
 package org.eclipse.rdf4j.query.algebra.evaluation;
 
+import java.util.AbstractSet;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.ConcurrentModificationException;
 import java.util.Iterator;
-import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
@@ -182,30 +185,21 @@ private int getIndex(String bindingName) {
 
 	@Override
 	public Set<String> getBindingNames() {
-		if (bindingNamesSetCache == null) {
-			int size = size();
-			if (size == 0) {
-				this.bindingNamesSetCache = Collections.emptySet();
-			} else if (size == 1) {
-				for (int i = 0; i < this.bindingNames.length; i++) {
-					if (whichBindingsHaveBeenSet[i]) {
-						this.bindingNamesSetCache = Collections.singleton(bindingNames[i]);
-						break;
-					}
+		final int size = ArrayBindingSet.this.size();
+		switch (size) {
+		case 0:
+			return Collections.emptySet();
+		case 1:
+			for (int i = 0; i < this.bindingNames.length; i++) {
+				if (whichBindingsHaveBeenSet[i]) {
+					return Collections.singleton(bindingNames[i]);
 				}
-				assert this.bindingNamesSetCache != null;
-			} else {
-				LinkedHashSet<String> bindingNamesSetCache = new LinkedHashSet<>(size * 2);
-				for (int i = 0; i < this.bindingNames.length; i++) {
-					if (whichBindingsHaveBeenSet[i]) {
-						bindingNamesSetCache.add(bindingNames[i]);
-					}
-				}
-				this.bindingNamesSetCache = Collections.unmodifiableSet(bindingNamesSetCache);
 			}
+			throw new ConcurrentModificationException(
+					"An bindingset has been modified during the getBindingNames call");
+		default:
+			return new MinimallyAllocatingSet(size);
 		}
-
-		return bindingNamesSetCache;
 	}
 
 	@Override
@@ -295,6 +289,53 @@ public List<String> getSortedBindingNames() {
 	/*------------------------------------*
 	 * Inner class ArrayBindingSetIterator *
 	 *------------------------------------*/
+	private static final class BindingToBindingNameIterator implements Iterator<String> {
+		private final Iterator<Binding> nested;
+
+		private BindingToBindingNameIterator(Iterator<Binding> nested) {
+			this.nested = nested;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return nested.hasNext();
+		}
+
+		@Override
+		public String next() {
+			return nested.next().getName();
+		}
+	}
+
+	private final class MinimallyAllocatingSet extends AbstractSet<String> {
+
+		private final int size;
+
+		private MinimallyAllocatingSet(int size) {
+			this.size = size;
+		}
+
+		@Override
+		public int size() {
+			return size;
+		}
+
+		@Override
+		public Iterator<String> iterator() {
+			Iterator<Binding> nested = ArrayBindingSet.this.iterator();
+			return new BindingToBindingNameIterator(nested);
+		}
+
+		@Override
+		public boolean add(String e) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean addAll(Collection<? extends String> c) {
+			throw new UnsupportedOperationException();
+		}
+	}
 
 	private class ArrayBindingSetIterator implements Iterator<Binding> {
 
@@ -305,6 +346,7 @@ public ArrayBindingSetIterator() {
 
 		@Override
 		public boolean hasNext() {
+			// If the current index is at at a set value then this wont advance again.
 			for (; index < values.length; index++) {
 				if (whichBindingsHaveBeenSet[index] && values[index] != null) {
 					return true;
@@ -321,12 +363,16 @@ public Binding next() {
 				}
 			}
 
-			String name = bindingNames[index];
-			Value value = values[index++];
-			if (value != null) {
-				return new SimpleBinding(name, value);
-			} else {
-				return null;
+			try {
+				String name = bindingNames[index];
+				Value value = values[index++];
+				if (value != null) {
+					return new SimpleBinding(name, value);
+				} else {
+					return null;
+				}
+			} catch (ArrayIndexOutOfBoundsException e) {
+				throw new NoSuchElementException();
 			}
 		}
 
@@ -347,11 +393,9 @@ public void addBinding(Binding binding) {
 			return;
 		}
 
-		assert !this.whichBindingsHaveBeenSet[index];
+		assert !this.whichBindingsHaveBeenSet[index] : "variable already bound: " + binding.getName();
 		this.values[index] = binding.getValue();
 		this.whichBindingsHaveBeenSet[index] = true;
-		clearCache();
-
 	}
 
 	@Override
@@ -362,7 +406,6 @@ public void setBinding(Binding binding) {
 		}
 		this.values[index] = binding.getValue();
 		this.whichBindingsHaveBeenSet[index] = true;
-		clearCache();
 	}
 
 	@Override

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

@@ -57,7 +57,7 @@ public final class ArrayBindingBasedQueryEvaluationContext implements QueryEvalu
 	private final BiConsumer<Value, MutableBindingSet>[] addBinding;
 	private final Comparator<Value> comparator;
 
-	boolean initialized;
+	private final boolean initialized;
 
 	ArrayBindingBasedQueryEvaluationContext(QueryEvaluationContext context, String[] allVariables,
 			Comparator<Value> comparator) {
@@ -118,7 +118,12 @@ public Predicate<BindingSet> hasBinding(String variableName) {
 
 		assert variableName != null && !variableName.isEmpty();
 		Function<ArrayBindingSet, Boolean> directHasVariable = defaultArrayBindingSet.getDirectHasBinding(variableName);
-		return new HasBinding(variableName, directHasVariable);
+		if (directHasVariable != null) {
+			return new HasBinding(variableName, directHasVariable);
+		} else {
+			// If the variable is not in the default set, it can never be part of this array binding
+			return (bs) -> false;
+		}
 	}
 
 	static private class HasBinding implements Predicate<BindingSet> {
@@ -156,16 +161,19 @@ public Function<BindingSet, Binding> getBinding(String variableName) {
 
 		Function<ArrayBindingSet, Binding> directAccessForVariable = defaultArrayBindingSet
 				.getDirectGetBinding(variableName);
-		return bs -> {
-			if (bs.isEmpty()) {
-				return null;
-			}
-			if (bs instanceof ArrayBindingSet) {
-				return directAccessForVariable.apply((ArrayBindingSet) bs);
-			} else {
-				return bs.getBinding(variableName);
-			}
-		};
+		if (directAccessForVariable != null) {
+			return (bs) -> {
+				if (bs.isEmpty()) {
+					return null;
+				} else if (bs instanceof ArrayBindingSet) {
+					return directAccessForVariable.apply((ArrayBindingSet) bs);
+				} else {
+					return bs.getBinding(variableName);
+				}
+			};
+		} else {
+			return (bs) -> null;
+		}
 	}
 
 	@Override
@@ -180,7 +188,12 @@ public Function<BindingSet, Value> getValue(String variableName) {
 
 		Function<ArrayBindingSet, Value> directAccessForVariable = defaultArrayBindingSet
 				.getDirectGetValue(variableName);
-		return new ValueGetter(variableName, directAccessForVariable);
+		if (directAccessForVariable != null) {
+			return new ValueGetter(variableName, directAccessForVariable);
+		} else {
+			// If the variable is not in the default set, it can never be part of this array binding
+			return (bs) -> null;
+		}
 	}
 
 	private static class ValueGetter implements Function<BindingSet, Value> {
@@ -219,13 +232,17 @@ public BiConsumer<Value, MutableBindingSet> setBinding(String variableName) {
 
 		BiConsumer<Value, ArrayBindingSet> directAccessForVariable = defaultArrayBindingSet
 				.getDirectSetBinding(variableName);
-		return (val, bs) -> {
-			if (bs instanceof ArrayBindingSet) {
-				directAccessForVariable.accept(val, (ArrayBindingSet) bs);
-			} else {
-				bs.setBinding(variableName, val);
-			}
-		};
+		if (directAccessForVariable != null) {
+			return (val, bs) -> {
+				if (bs instanceof ArrayBindingSet) {
+					directAccessForVariable.accept(val, (ArrayBindingSet) bs);
+				} else {
+					bs.setBinding(variableName, val);
+				}
+			};
+		} else {
+			return (val, bs) -> bs.setBinding(variableName, val);
+		}
 	}
 
 	@Override
@@ -240,13 +257,17 @@ public BiConsumer<Value, MutableBindingSet> addBinding(String variableName) {
 
 		BiConsumer<Value, ArrayBindingSet> wrapped = defaultArrayBindingSet
 				.getDirectAddBinding(variableName);
-		return (val, bs) -> {
-			if (bs instanceof ArrayBindingSet) {
-				wrapped.accept(val, (ArrayBindingSet) bs);
-			} else {
-				bs.addBinding(variableName, val);
-			}
-		};
+		if (wrapped != null) {
+			return (val, bs) -> {
+				if (bs instanceof ArrayBindingSet) {
+					wrapped.accept(val, (ArrayBindingSet) bs);
+				} else {
+					bs.addBinding(variableName, val);
+				}
+			};
+		} else {
+			return (val, bs) -> bs.addBinding(variableName, val);
+		}
 	}
 
 	@Override

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

@@ -17,6 +17,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 import org.eclipse.rdf4j.collection.factory.api.CollectionFactory;
@@ -616,29 +617,8 @@ protected QueryEvaluationStep prepare(Service service, QueryEvaluationContext co
 
 	protected QueryEvaluationStep prepare(Filter node, QueryEvaluationContext context) throws QueryEvaluationException {
 
-		QueryEvaluationStep arg = precompile(node.getArg(), context);
-		QueryValueEvaluationStep ves;
-		try {
-			ves = precompile(node.getCondition(), context);
-		} catch (QueryEvaluationException e) {
-			// If we have a failed compilation we always return false.
-			// Which means empty. so let's short circuit that.
-//			ves = new QueryValueEvaluationStep.ConstantQueryValueEvaluationStep(BooleanLiteral.FALSE);
-			return bs -> QueryEvaluationStep.EMPTY_ITERATION;
-		}
-		return bs -> {
-			CloseableIteration<BindingSet> evaluate = null;
-			try {
-				evaluate = arg.evaluate(bs);
-				return new FilterIterator(evaluate, ves, DefaultEvaluationStrategy.this);
-			} catch (Throwable t) {
-				if (evaluate != null) {
-					evaluate.close();
-				}
-				throw t;
-			}
+		return FilterIterator.supply(node, DefaultEvaluationStrategy.this, context);
 
-		};
 	}
 
 	protected QueryEvaluationStep prepare(Order node, QueryEvaluationContext context) throws QueryEvaluationException {
@@ -939,12 +919,13 @@ protected QueryValueEvaluationStep prepare(Var var, QueryEvaluationContext conte
 			return new ConstantQueryValueEvaluationStep(value);
 		} else {
 			java.util.function.Function<BindingSet, Value> getValue = context.getValue(var.getName());
+			Predicate<BindingSet> hasValue = context.hasBinding(var.getName());
 			return bindings -> {
-				Value value1 = getValue.apply(bindings);
-				if (value1 == null) {
+				if (hasValue.test(bindings)) {
+					return getValue.apply(bindings);
+				} else {
 					throw new ValueExprEvaluationException();
 				}
-				return value1;
 			};
 		}