fixes based on review

Author: hmottestad

core/sail/shacl/src/main/java/org/eclipse/rdf4j/sail/shacl/ShaclSailConnection.java

@@ -1601,28 +1601,30 @@ private Boolean invokeBooleanStatementMethod(Statement statement, String methodN
 	}
 
 	/**
-	 * Reject legacy no-flag callbacks only when a shape explicitly disables inferred statements using
-	 * rsx:includeInferredStatements=false. In that case, inferred-vs-explicit classification is required for correct
+	 * Reject legacy no-flag callbacks whenever effective includeInferredStatements=false is active for at least one
+	 * validated shape (globally through ShaclSail#setIncludeInferredStatements(false) and/or via
+	 * rsx:includeInferredStatements=false). In that case, inferred-vs-explicit classification is required for correct
 	 * validation and stores must use statementAdded/Removed callbacks with the inferred boolean argument.
 	 */
 	private void validateLegacyCallbackInferredSupport(List<ContextWithShape> shapesToValidate) {
 		if (!legacyStatementAddedWithoutInferredFlagObserved && !legacyStatementRemovedWithoutInferredFlagObserved) {
 			return;
 		}
 
-		boolean hasExplicitIncludeInferredDisabled = shapesToValidate.stream()
+		boolean includeInferredStatementsEnabledByDefault = sail.isIncludeInferredStatements();
+		boolean requiresInferredClassification = shapesToValidate.stream()
 				.filter(ContextWithShape::hasShape)
 				.map(ContextWithShape::getShape)
-				.map(Shape::getIncludeInferredStatementsOverride)
-				.anyMatch(Boolean.FALSE::equals);
+				.anyMatch(shape -> !shape.usesIncludeInferredStatements(includeInferredStatementsEnabledByDefault));
 
-		if (!hasExplicitIncludeInferredDisabled) {
+		if (!requiresInferredClassification) {
 			return;
 		}
 
 		String callbackDetails = getObservedLegacyCallbacksWithoutInferredFlag();
 		String message = "Underlying Sail does not support shapes that explicitly set "
-				+ "rsx:includeInferredStatements=false because it emits deprecated "
+				+ "rsx:includeInferredStatements=false or globally configure "
+				+ "ShaclSail#setIncludeInferredStatements(false), because it emits deprecated "
 				+ "SailConnectionListener callbacks without inferred flags (" + callbackDetails + "). "
 				+ "Implement statementAdded(Statement, boolean inferred) and "
 				+ "statementRemoved(Statement, boolean inferred).";

core/sail/shacl/src/main/java/org/eclipse/rdf4j/sail/shacl/ShapeValidationContainer.java

@@ -39,6 +39,7 @@ class ShapeValidationContainer {
 	private final ConnectionsGroup connectionsGroup;
 	private final boolean closeConnectionsGroup;
 	private volatile CloseableIteration<? extends ValidationTuple> iterator;
+	private volatile boolean connectionsGroupClosed;
 
 	public ShapeValidationContainer(Shape shape, Supplier<PlanNode> planNodeSupplier, boolean logValidationExecution,
 			boolean logValidationViolations, long effectiveValidationResultsLimitPerConstraint,
@@ -113,13 +114,7 @@ public ShapeValidationContainer(Shape shape, Supplier<PlanNode> planNodeSupplier
 				this.planNode = planNode;
 			}
 		} catch (Throwable e) {
-			if (closeConnectionsGroup) {
-				try {
-					connectionsGroup.close();
-				} catch (Exception closeException) {
-					logger.debug("Error closing connections group after plan construction failure", closeException);
-				}
-			}
+			closeConnectionsGroup("after plan construction failure");
 			logger.warn("Error processing SHACL Shape {}", shape.getId(), e);
 			logger.warn("Error processing SHACL Shape\n{}", shape, e);
 			if (e instanceof Error) {
@@ -135,7 +130,11 @@ public Shape getShape() {
 	}
 
 	public boolean hasPlanNode() {
-		return !(planNode.isGuaranteedEmpty());
+		boolean hasPlanNode = !(planNode.isGuaranteedEmpty());
+		if (!hasPlanNode) {
+			closeConnectionsGroup("for guaranteed-empty plan");
+		}
+		return hasPlanNode;
 	}
 
 	public ValidationResultIterator performValidation() throws SailException {
@@ -166,17 +165,28 @@ public ValidationResultIterator performValidation() throws SailException {
 			}
 		} finally {
 			this.iterator = null;
-			if (closeConnectionsGroup) {
-				try {
-					connectionsGroup.close();
-				} catch (Exception closeException) {
-					logger.debug("Error closing connections group after validation", closeException);
-				}
-			}
+			closeConnectionsGroup("after validation");
 		}
 
 	}
 
+	private void closeConnectionsGroup(String context) {
+		if (!closeConnectionsGroup || connectionsGroupClosed) {
+			return;
+		}
+		synchronized (this) {
+			if (connectionsGroupClosed) {
+				return;
+			}
+			connectionsGroupClosed = true;
+		}
+		try {
+			connectionsGroup.close();
+		} catch (Exception closeException) {
+			logger.debug("Error closing connections group {}", context, closeException);
+		}
+	}
+
 	private long getTimeStamp() {
 		if (performanceLogging) {
 			return System.currentTimeMillis();

core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/RdfsReasoningShaclSailTest.java

@@ -209,6 +209,34 @@ public void legacyCallbacksWithoutInferenceMetadataFailWhenAShapeDisablesInferre
 		}
 	}
 
+	@Test
+	public void legacyCallbacksWithoutInferenceMetadataFailWhenGlobalIncludeInferredStatementsIsDisabled()
+			throws Exception {
+		SailRepository repo = createRepositoryWithLegacyCallbackForwarding(false);
+
+		IRI ontologyGraph = repo.getValueFactory().createIRI("urn:ontology");
+		IRI dataGraph = repo.getValueFactory().createIRI("urn:data");
+
+		loadTurtle(repo, ontologyTurtle(), ontologyGraph);
+		loadTurtle(repo, railcarBrakeShapeTurtle(null, null), RDF4J.SHACL_SHAPE_GRAPH);
+
+		IRI wagon1 = repo.getValueFactory().createIRI("urn:wagon1");
+		IRI freightWagon = repo.getValueFactory().createIRI("https://example.com/trains/FreightWagon");
+
+		try (RepositoryConnection conn = repo.getConnection()) {
+			conn.begin();
+			conn.add(wagon1, RDF.TYPE, freightWagon, dataGraph);
+			ShaclSailValidationException exception = assertThrows(ShaclSailValidationException.class,
+					() -> commitAndRethrow(conn));
+			assertTrue(exception.getMessage()
+					.contains("deprecated SailConnectionListener callbacks without inferred flags"));
+			assertTrue(exception.getMessage().contains("statementAdded(Statement, boolean inferred)"));
+			assertTrue(exception.getMessage().contains("statementRemoved(Statement, boolean inferred)"));
+		} finally {
+			repo.shutDown();
+		}
+	}
+
 	@Test
 	public void legacyCallbacksWithoutInferenceMetadataAreAcceptedWhenAllShapesIncludeInferredStatements()
 			throws Exception {

core/sail/shacl/src/test/java/org/eclipse/rdf4j/sail/shacl/ShapeValidationContainerLifecycleTest.java

@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2026 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
+ *******************************************************************************/
+// Some portions generated by Codex
+
+package org.eclipse.rdf4j.sail.shacl;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.eclipse.rdf4j.sail.shacl.ast.Shape;
+import org.eclipse.rdf4j.sail.shacl.ast.planNodes.PlanNode;
+import org.eclipse.rdf4j.sail.shacl.wrapper.data.ConnectionsGroup;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+
+class ShapeValidationContainerLifecycleTest {
+
+	@Test
+	void emptyPlanShouldCloseOwnedConnectionsGroup() {
+		Shape shape = mock(Shape.class);
+		PlanNode planNode = mock(PlanNode.class);
+		ConnectionsGroup connectionsGroup = mock(ConnectionsGroup.class);
+
+		when(planNode.isGuaranteedEmpty()).thenReturn(true);
+
+		ShapeValidationContainer container = new ShapeValidationContainer(
+				shape,
+				() -> planNode,
+				false,
+				false,
+				1,
+				false,
+				false,
+				LoggerFactory.getLogger(ShapeValidationContainerLifecycleTest.class),
+				connectionsGroup,
+				true);
+
+		assertFalse(container.hasPlanNode());
+		verify(connectionsGroup).close();
+	}
+}