GH-5676 shacl sail customizable inference

Author: hmottestad

core/model-vocabulary/src/main/java/org/eclipse/rdf4j/model/vocabulary/RSX.java

@@ -40,6 +40,9 @@ public class RSX {
 	/** <var>http://rdf4j.org/shacl-extensions#targetShape</var> */
 	public final static IRI targetShape = create("targetShape");
 
+	public final static IRI rdfsSubClassReasoning = create("rdfsSubClassReasoning");
+	public final static IRI includeInferredStatements = create("includeInferredStatements");
+
 	public final static IRI dataGraph = create("dataGraph");
 	public final static IRI shapesGraph = create("shapesGraph");
 

core/sail/inferencer/src/main/java/org/eclipse/rdf4j/sail/inferencer/fc/SchemaCachingRDFSInferencerConnection.java

@@ -114,7 +114,7 @@ void processForSchemaCache(Statement statement) {
 			sail.addSubPropertyOfStatement(
 					sail.getValueFactory().createStatement(subject, RDFS.SUBPROPERTYOF, RDFS.MEMBER));
 			schemaChange = true;
-		} else if (predicate.equals(RDF.TYPE)) {
+		} else if (predicate.equals(RDF.TYPE) && object instanceof Resource) {
 			if (!sail.hasType(((Resource) object))) {
 				sail.addType((Resource) object);
 				schemaChange = true;
@@ -276,11 +276,7 @@ private void addStatement(boolean actuallyAdd, Resource subject, IRI predicate,
 
 			}
 
-			if (predicate.equals(RDF.TYPE)) {
-				if (!(object instanceof Resource)) {
-					throw new SailException("Expected object to a a Resource: " + object.toString());
-				}
-
+			if (predicate.equals(RDF.TYPE) && object instanceof Resource) {
 				sail.resolveTypes((Resource) object)
 						.stream()
 						.peek(inferredType -> {

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

@@ -35,6 +35,7 @@ abstract class ShaclSailBaseConfiguration extends NotifyingSailWrapper {
 	private boolean validationEnabled = ShaclSailConfig.VALIDATION_ENABLED_DEFAULT;
 	private boolean cacheSelectNodes = ShaclSailConfig.CACHE_SELECT_NODES_DEFAULT;
 	private boolean rdfsSubClassReasoning = ShaclSailConfig.RDFS_SUB_CLASS_REASONING_DEFAULT;
+	private boolean includeInferredStatements = false;
 	private boolean serializableValidation = ShaclSailConfig.SERIALIZABLE_VALIDATION_DEFAULT;
 	private boolean performanceLogging = ShaclSailConfig.PERFORMANCE_LOGGING_DEFAULT;
 	private boolean eclipseRdf4jShaclExtensions = ShaclSailConfig.ECLIPSE_RDF4J_SHACL_EXTENSIONS_DEFAULT;
@@ -146,6 +147,25 @@ public void setRdfsSubClassReasoning(boolean rdfsSubClassReasoning) {
 		this.rdfsSubClassReasoning = rdfsSubClassReasoning;
 	}
 
+	/**
+	 * Check if inferred statements from the base sail should be used during SHACL validation when
+	 * {@link #isRdfsSubClassReasoning()} is disabled.
+	 *
+	 * @return <code>true</code> if inferred statements should be considered, <code>false</code> otherwise.
+	 */
+	public boolean isIncludeInferredStatements() {
+		return includeInferredStatements;
+	}
+
+	/**
+	 * Allow SHACL validation to use inferred statements from the base sail when RDFS subclass reasoning is disabled.
+	 *
+	 * @param includeInferredStatements default false
+	 */
+	public void setIncludeInferredStatements(boolean includeInferredStatements) {
+		this.includeInferredStatements = includeInferredStatements;
+	}
+
 	/**
 	 * Disable the SHACL validation on commit()
 	 */

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

@@ -51,6 +51,7 @@
 import org.eclipse.rdf4j.sail.memory.MemoryStore;
 import org.eclipse.rdf4j.sail.shacl.ShaclSail.TransactionSettings.ValidationApproach;
 import org.eclipse.rdf4j.sail.shacl.ast.ContextWithShape;
+import org.eclipse.rdf4j.sail.shacl.ast.Shape;
 import org.eclipse.rdf4j.sail.shacl.results.ValidationReport;
 import org.eclipse.rdf4j.sail.shacl.results.lazy.LazyValidationReport;
 import org.eclipse.rdf4j.sail.shacl.results.lazy.ValidationResultIterator;
@@ -497,20 +498,24 @@ private ValidationReport validate(List<ContextWithShape> shapes, boolean validat
 
 		try {
 			try (ConnectionsGroup connectionsGroup = getConnectionsGroup()) {
-				return performValidation(shapes, validateEntireBaseSail, connectionsGroup);
+				return performValidation(shapes, validateEntireBaseSail, connectionsGroup, this,
+						previousStateConnection);
 			}
 		} finally {
 			rdfsSubClassOfReasoner = null;
 		}
 
 	}
 
-	void prepareValidation(ValidationSettings validationSettings) throws InterruptedException {
+	void prepareValidation(ValidationSettings validationSettings, boolean requireRdfsSubClassReasoning)
+			throws InterruptedException {
 
 		assert isValidationEnabled();
 
-		if (sail.isRdfsSubClassReasoning()) {
+		if (requireRdfsSubClassReasoning) {
 			rdfsSubClassOfReasoner = RdfsSubClassOfReasoner.createReasoner(this, validationSettings);
+		} else {
+			rdfsSubClassOfReasoner = null;
 		}
 
 		if (sail.isShutdown()) {
@@ -528,15 +533,34 @@ void prepareValidation(ValidationSettings validationSettings) throws Interrupted
 	}
 
 	ConnectionsGroup getConnectionsGroup() {
+		return getConnectionsGroup(this, previousStateConnection, sail.isIncludeInferredStatements(),
+				sail.isRdfsSubClassReasoning());
+	}
+
+	ConnectionsGroup getConnectionsGroup(SailConnection baseConnection, SailConnection previousStateConnection,
+			boolean includeInferredStatements, boolean useRdfsSubClassReasoning) {
+		RdfsSubClassOfReasoner reasoner = useRdfsSubClassReasoning ? rdfsSubClassOfReasoner : null;
+		ConnectionsGroup.RdfsSubClassOfReasonerProvider provider = reasoner == null ? null : () -> reasoner;
 
-		return new ConnectionsGroup(new VerySimpleRdfsBackwardsChainingConnection(this, rdfsSubClassOfReasoner),
+		return new ConnectionsGroup(
+				new VerySimpleRdfsBackwardsChainingConnection(baseConnection, reasoner, includeInferredStatements),
 				previousStateConnection, addedStatements, removedStatements, stats,
-				this::getRdfsSubClassOfReasoner, transactionSettings, sail.sparqlValidation);
+				provider, transactionSettings, sail.sparqlValidation);
+	}
+
+	private boolean requiresRdfsSubClassReasoner(List<ContextWithShape> shapes) {
+		return shapes.stream()
+				.map(ContextWithShape::getShape)
+				.map(Shape::getRdfsSubClassReasoningOverride)
+				.anyMatch(Boolean.TRUE::equals);
 	}
 
 	private ValidationReport performValidation(List<ContextWithShape> shapes, boolean validateEntireBaseSail,
-			ConnectionsGroup connectionsGroup) throws InterruptedException {
+			ConnectionsGroup connectionsGroup, SailConnection baseConnection, SailConnection previousStateConnection)
+			throws InterruptedException {
 		long beforeValidation = 0;
+		boolean defaultIncludeInferredStatements = sail.isIncludeInferredStatements();
+		boolean defaultRdfsSubClassReasoning = sail.isRdfsSubClassReasoning();
 
 		if (sail.isPerformanceLogging()) {
 			beforeValidation = System.currentTimeMillis();
@@ -547,18 +571,36 @@ private ValidationReport performValidation(List<ContextWithShape> shapes, boolea
 
 			Stream<Callable<ValidationResultIterator>> callableStream = shapes
 					.stream()
-					.map(contextWithShapes -> new ShapeValidationContainer(
-							contextWithShapes.getShape(),
-							() -> contextWithShapes.getShape()
-									.generatePlans(connectionsGroup,
-											new ValidationSettings(contextWithShapes.getDataGraph(),
-													sail.isLogValidationPlans(), validateEntireBaseSail,
-													sail.isPerformanceLogging())),
-							sail.isGlobalLogValidationExecution(), sail.isLogValidationViolations(),
-							sail.getEffectiveValidationResultsLimitPerConstraint(), sail.isPerformanceLogging(),
-							sail.isLogValidationPlans(),
-							logger,
-							connectionsGroup))
+					.map(contextWithShapes -> {
+						Shape shape = contextWithShapes.getShape();
+						boolean shapeRdfsSubClassReasoning = shape
+								.usesRdfsSubClassReasoning(defaultRdfsSubClassReasoning);
+						boolean shapeIncludeInferredStatements = shape
+								.usesIncludeInferredStatements(defaultIncludeInferredStatements);
+
+						boolean closeConnectionsGroup = false;
+						ConnectionsGroup shapeConnectionsGroup = connectionsGroup;
+						if (shapeRdfsSubClassReasoning != defaultRdfsSubClassReasoning
+								|| shapeIncludeInferredStatements != defaultIncludeInferredStatements) {
+							shapeConnectionsGroup = getConnectionsGroup(baseConnection, previousStateConnection,
+									shapeIncludeInferredStatements, shapeRdfsSubClassReasoning);
+							closeConnectionsGroup = true;
+						}
+						ConnectionsGroup planConnectionsGroup = shapeConnectionsGroup;
+
+						return new ShapeValidationContainer(
+								shape,
+								() -> shape.generatePlans(planConnectionsGroup,
+										new ValidationSettings(contextWithShapes.getDataGraph(),
+												sail.isLogValidationPlans(), validateEntireBaseSail,
+												sail.isPerformanceLogging())),
+								sail.isGlobalLogValidationExecution(), sail.isLogValidationViolations(),
+								sail.getEffectiveValidationResultsLimitPerConstraint(), sail.isPerformanceLogging(),
+								sail.isLogValidationPlans(),
+								logger,
+								shapeConnectionsGroup,
+								closeConnectionsGroup);
+					})
 
 					.filter(ShapeValidationContainer::hasPlanNode)
 					.peek(s -> {
@@ -1071,24 +1113,28 @@ public void prepare() throws SailException {
 				return;
 			}
 
+			List<ContextWithShape> shapesToValidate = shapesAfterRefresh != null ? shapesAfterRefresh : currentShapes;
+			boolean requiresRdfsSubClassReasoner = sail.isRdfsSubClassReasoning()
+					|| requiresRdfsSubClassReasoner(shapesToValidate);
+
 			stats.setEmptyIncludingCurrentTransaction(ConnectionHelper.isEmpty(this));
 
 			prepareValidation(
-					new ValidationSettings(null, sail.isLogValidationPlans(), false, sail.isPerformanceLogging()));
+					new ValidationSettings(null, sail.isLogValidationPlans(), false, sail.isPerformanceLogging()),
+					requiresRdfsSubClassReasoner);
 
 			ValidationReport invalidTuples = null;
 			if (useSerializableValidation) {
 				synchronized (sail.singleConnectionMonitor) {
 					if (!sail.usesSingleConnection()) {
-						invalidTuples = serializableValidation(
-								shapesAfterRefresh != null ? shapesAfterRefresh : currentShapes);
+						invalidTuples = serializableValidation(shapesToValidate);
 					}
 				}
 			}
 
 			if (invalidTuples == null) {
 				invalidTuples = validate(
-						shapesAfterRefresh != null ? shapesAfterRefresh : currentShapes,
+						shapesToValidate,
 						shapesModifiedInCurrentTransaction || isBulkValidation());
 			}
 
@@ -1152,10 +1198,8 @@ private boolean isBulkValidation() {
 	private ValidationReport serializableValidation(List<ContextWithShape> shapesAfterRefresh)
 			throws InterruptedException {
 		try {
-			try (ConnectionsGroup connectionsGroup = new ConnectionsGroup(
-					new VerySimpleRdfsBackwardsChainingConnection(serializableConnection, rdfsSubClassOfReasoner), null,
-					addedStatements, removedStatements, stats, this::getRdfsSubClassOfReasoner, transactionSettings,
-					sail.sparqlValidation)) {
+			try (ConnectionsGroup connectionsGroup = getConnectionsGroup(serializableConnection, null,
+					sail.isIncludeInferredStatements(), sail.isRdfsSubClassReasoning())) {
 
 				connectionsGroup.getBaseConnection().begin(IsolationLevels.SNAPSHOT);
 				// actually force a transaction to start
@@ -1176,7 +1220,7 @@ private ValidationReport serializableValidation(List<ContextWithShape> shapesAft
 				serializableConnection.flush();
 
 				return performValidation(shapesAfterRefresh, shapesModifiedInCurrentTransaction || isBulkValidation(),
-						connectionsGroup);
+						connectionsGroup, serializableConnection, null);
 
 			} finally {
 				serializableConnection.rollback();