GH-5310 Further distinguish between the count cases and the other

aggregate functions.

Also do fix the logging issue in the ConstantOptimizer.

Author: JervenBolleman

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

@@ -322,6 +322,11 @@ private List<Entry> emptySolutionSpecialCase(List<AggregatePredicateCollectorSup
 				for (var ag : aggregates) {
 					if (ag.agg instanceof WildCardCountAggregate) {
 						predicates.add(ALWAYS_TRUE_BINDING_SET);
+					} else if (ag.agg instanceof CountAggregate) {
+						// Counts are special, because they always return a number related to the number of solutions.
+						// which in the empty case should be 0. So we should never accept a value here.
+						// Even in the case that the Count is of a constant value.
+						predicates.add(ALWAYS_FALSE_VALUE);
 					} else {
 						predicates.add(ALWAYS_TRUE_VALUE);
 					}
@@ -397,6 +402,7 @@ private void operate(BindingSet bs, Predicate<?> predicate, Object t) {
 
 	private static final Predicate<BindingSet> ALWAYS_TRUE_BINDING_SET = t -> true;
 	private static final Predicate<Value> ALWAYS_TRUE_VALUE = t -> true;
+	private static final Predicate<Value> ALWAYS_FALSE_VALUE = t -> false;
 	private static final Supplier<Predicate<Value>> ALWAYS_TRUE_VALUE_SUPPLIER = () -> ALWAYS_TRUE_VALUE;
 
 	private AggregatePredicateCollectorSupplier<?, ?> create(GroupElem ge, ValueFactory vf)

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

@@ -22,6 +22,7 @@
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.Dataset;
 import org.eclipse.rdf4j.query.QueryEvaluationException;
+import org.eclipse.rdf4j.query.algebra.AggregateOperator;
 import org.eclipse.rdf4j.query.algebra.And;
 import org.eclipse.rdf4j.query.algebra.BinaryValueOperator;
 import org.eclipse.rdf4j.query.algebra.Bound;
@@ -223,7 +224,11 @@ protected void meetBinaryValueOperator(BinaryValueOperator binaryValueOp) {
 		protected void meetUnaryValueOperator(UnaryValueOperator unaryValueOp) {
 			super.meetUnaryValueOperator(unaryValueOp);
 
-			if (isConstant(unaryValueOp.getArg())) {
+			ValueExpr arg = unaryValueOp.getArg();
+			// This is not the place to optimize aggregates, as they are not
+			// evaluated in the same way as other unary value operators.
+			// They must be evaluated in the context of a group.
+			if (isConstant(arg) && !(unaryValueOp instanceof AggregateOperator)) {
 				try {
 					Value value = strategy.precompile(unaryValueOp, context).evaluate(EmptyBindingSet.getInstance());
 					unaryValueOp.replaceWith(new ValueConstant(value));

core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/ConstantOptimizerTest.java

@@ -150,6 +150,62 @@ public void testAggregateOptimization() throws RDF4JException {
 		assertEquals(1, ((Literal) bindings.getBinding("a").getValue()).intValue());
 	}
 
+	@Test
+	public void testAllAggregateOptimizations() throws RDF4JException {
+		String query = String.join("\n",
+				"PREFIX ex: <ex:>",
+				"SELECT",
+				"  (MAX(1) AS ?a)",
+				"  (MIN(1) AS ?b)",
+				"  (AVG(1) AS ?c)",
+				"  (COUNT(1) AS ?d)",
+				"  (COUNT(DISTINCT 1) AS ?e)",
+				"  (COUNT(*) AS ?f)",
+				"WHERE {",
+				"  ?x a ?z ;",
+				"  ex:someProperty ?val .",
+				"}"
+		);
+
+		ParsedQuery pq = QueryParserUtil.parseQuery(QueryLanguage.SPARQL, query, null);
+		EvaluationStrategy strategy = new DefaultEvaluationStrategy(new EmptyTripleSource(), null);
+		TupleExpr original = pq.getTupleExpr();
+
+		final AlgebraFinder finder = new AlgebraFinder();
+		original.visit(finder);
+		assertTrue(finder.groupElemFound);
+
+		// reset for re-use on optimized query
+		finder.reset();
+
+		QueryBindingSet constants = new QueryBindingSet();
+
+		TupleExpr optimized = optimize(pq.getTupleExpr().clone(), constants, strategy);
+
+		optimized.visit(finder);
+		assertThat(finder.functionCallFound).isFalse();
+
+		CloseableIteration<BindingSet> result = strategy.precompile(optimized)
+				.evaluate(
+						new EmptyBindingSet());
+		assertNotNull(result);
+		assertTrue(result.hasNext());
+
+		BindingSet bindings = result.next();
+		assertTrue(bindings.hasBinding("a"));
+		assertTrue(bindings.hasBinding("b"));
+		assertTrue(bindings.hasBinding("c"));
+		assertTrue(bindings.hasBinding("d"));
+		assertTrue(bindings.hasBinding("e"));
+		assertTrue(bindings.hasBinding("f"));
+		assertEquals(1, ((Literal) bindings.getBinding("a").getValue()).intValue());
+		assertEquals(1, ((Literal) bindings.getBinding("b").getValue()).intValue());
+		assertEquals(1, ((Literal) bindings.getBinding("c").getValue()).intValue());
+		assertEquals(0, ((Literal) bindings.getBinding("d").getValue()).intValue());
+		assertEquals(0, ((Literal) bindings.getBinding("e").getValue()).intValue());
+		assertEquals(0, ((Literal) bindings.getBinding("f").getValue()).intValue());
+	}
+
 	private class AlgebraFinder extends AbstractQueryModelVisitor<RuntimeException> {
 
 		public boolean logicalAndfound = false;

core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/iterator/GroupIteratorTest.java

@@ -13,6 +13,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -120,6 +121,19 @@ public void testMaxEmptySet_DefaultGroup() throws QueryEvaluationException {
 		}
 	}
 
+	@Test
+	public void testConstantCountEmptySet_DefaultGroup() throws QueryEvaluationException {
+		Group group = new Group(EMPTY_ASSIGNMENT);
+		group.addGroupElement(new GroupElem("count", new Count(new ValueConstant(VF.createLiteral("a")))));
+		try (GroupIterator gi = new GroupIterator(EVALUATOR, group, EmptyBindingSet.getInstance(), CONTEXT)) {
+
+			assertTrue(gi.hasNext());
+			BindingSet next = gi.next();
+			assertEquals(1, next.size());
+			assertEquals(0, ((Literal) next.getBinding("count").getValue()).intValue());
+		}
+	}
+
 	@Test
 	public void testMaxSet_DefaultGroup() throws QueryEvaluationException {
 		Group group = new Group(NONEMPTY_ASSIGNMENT);