This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit 8b40273f36a1187dfd472a66b3e37f72e2f6243a Author: Andy Seaborne <[email protected]> AuthorDate: Fri Nov 14 21:07:11 2025 +0000 GH-3591: Remove initial binding --- .../jena/query/QueryExecutionDatasetBuilder.java | 19 -- .../apache/jena/query/QueryExecutionFactory.java | 40 +---- .../org/apache/jena/query/QuerySolutionMap.java | 32 +++- .../jena/sparql/exec/QueryExecDatasetBuilder.java | 7 - .../jena/sparql/exec/UpdateExecDatasetBuilder.java | 7 - .../jena/sparql/modify/UpdateEngineBase.java | 7 +- .../jena/sparql/modify/UpdateEngineFactory.java | 7 +- .../jena/sparql/modify/UpdateEngineMain.java | 29 ++- .../sparql/modify/UpdateEngineNonStreaming.java | 88 ++++----- .../jena/sparql/modify/UpdateEngineRegistry.java | 38 ++-- .../jena/sparql/modify/UpdateEngineWorker.java | 23 +-- .../jena/sparql/modify/UpdateProcessorBase.java | 15 +- .../modify/UpdateProcessorStreamingBase.java | 33 ++-- .../apache/jena/sparql/util/graph/GraphUtils.java | 4 +- .../java/org/apache/jena/update/UpdateAction.java | 155 ++-------------- .../jena/update/UpdateExecutionDatasetBuilder.java | 15 -- .../apache/jena/update/UpdateExecutionFactory.java | 12 -- .../org/apache/jena/update/UpdateStreaming.java | 41 +++-- .../java/org/apache/jena/sparql/api/TestAPI.java | 199 ++++++++------------- .../sparql/modify/AbstractTestUpdateGraph.java | 29 +-- .../shacl/engine/constraint/SparqlValidation.java | 3 +- .../apache/jena/shacl/validation/EvalSparql.java | 3 +- .../apache/jena/tdb1/modify/UpdateEngineTDB.java | 15 +- .../apache/jena/tdb2/modify/UpdateEngineTDB.java | 12 +- 24 files changed, 249 insertions(+), 584 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionDatasetBuilder.java b/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionDatasetBuilder.java index 882e105642..8dc58f02af 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionDatasetBuilder.java +++ b/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionDatasetBuilder.java @@ -103,25 +103,6 @@ public class QueryExecutionDatasetBuilder implements QueryExecutionBuilder { return this; } - /** @deprecated Prefer {@link #substitution(Binding)} which substitutes variables for values in the the query before execution. */ - @Deprecated(forRemoval = true) - public QueryExecutionDatasetBuilder initialBinding(Binding binding) { - builder.initialBinding(binding); - return this; - } - - /** - * @deprecated Prefer {@link #substitution(QuerySolution)} which substitutes variables for values in the the query before execution. - */ - @Deprecated(forRemoval = true) - public QueryExecutionDatasetBuilder initialBinding(QuerySolution querySolution) { - if ( querySolution != null ) { - Binding binding = BindingLib.toBinding(querySolution); - initialBinding(binding); - } - return this; - } - @Override public QueryExecutionDatasetBuilder substitution(QuerySolution querySolution) { if ( querySolution != null ) { diff --git a/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionFactory.java b/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionFactory.java index a3c98f7a98..dcc49b9df8 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/query/QueryExecutionFactory.java @@ -25,7 +25,6 @@ import org.apache.jena.rdf.model.Model; import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.DatasetGraphFactory; import org.apache.jena.sparql.core.GraphView; -import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.exec.QueryExecDataset; import org.apache.jena.sparql.exec.QueryExecDatasetBuilder; import org.apache.jena.sparql.exec.QueryExecutionCompat; @@ -179,34 +178,6 @@ public class QueryExecutionFactory return create(makeQuery(queryStr, lang), model); } - /** Create a QueryExecution over a Dataset given some initial values of variables. - * - * @param query Query - * @param dataset Target of the query - * @param querySolution Any initial binding of variables - * @return QueryExecution - * @deprecated Use {@code QueryExecution.dataset(dataset).query(query).substitution(querySolution).build()}. - */ - @Deprecated(forRemoval = true) - public static QueryExecution create(Query query, Dataset dataset, QuerySolution querySolution) { - checkArg(query); - return QueryExecution.dataset(dataset).query(query).substitution(querySolution).build(); - } - - /** Create a QueryExecution over a Model given some initial values of variables. - * - * @param query Query - * @param model Target of the query - * @param querySolution Any initial binding of variables - * @return QueryExecution - * @deprecated Use {@code QueryExecution#model(model).query(query).substitution(querySolution).build()}. - */ - @Deprecated(forRemoval = true) - public static QueryExecution create(Query query, Model model, QuerySolution querySolution) { - checkArg(query); - return QueryExecution.model(model).query(query).substitution(querySolution).build(); - } - // ---------------- Internal routines private static Query toQuery(Element pattern) { @@ -255,22 +226,13 @@ public class QueryExecutionFactory // dataset and datasetGraph can't both be set. // Null for both of them is allowed and assumes the query has a dataset description. private static QueryExecution make(Query query, Dataset dataset, DatasetGraph datasetGraph) { - return make$(query, dataset, datasetGraph, null); - } - - // This form of "make" has support for "initialBinding" (seed the execution) - // The preferred approach is to use "substitution" )(replace variables with RDF terms). - @SuppressWarnings("removal") - private static QueryExecution make$(Query query, Dataset dataset, DatasetGraph datasetGraph, Binding initialBinding) { QueryExecDatasetBuilder builder = QueryExecDataset.newBuilder().query(query); - if ( initialBinding != null ) - builder.initialBinding(initialBinding); if ( dataset == null && datasetGraph == null ) return QueryExecutionCompat.compatibility(builder, null, query, builder.getQueryString()); if ( dataset == null ) { builder.dataset(datasetGraph); dataset = DatasetFactory.wrap(datasetGraph); - } else { + } else { builder.dataset(dataset.asDatasetGraph()); } return QueryExecutionCompat.compatibility(builder, dataset, query, builder.getQueryString()); diff --git a/jena-arq/src/main/java/org/apache/jena/query/QuerySolutionMap.java b/jena-arq/src/main/java/org/apache/jena/query/QuerySolutionMap.java index 6a05a1a35d..fe99a45889 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/QuerySolutionMap.java +++ b/jena-arq/src/main/java/org/apache/jena/query/QuerySolutionMap.java @@ -21,7 +21,9 @@ package org.apache.jena.query; import java.util.HashMap ; import java.util.Iterator ; import java.util.Map ; +import java.util.stream.Collectors; +import org.apache.jena.graph.Node; import org.apache.jena.rdf.model.RDFNode ; import org.apache.jena.sparql.core.QuerySolutionBase ; import org.apache.jena.sparql.core.Var ; @@ -45,18 +47,20 @@ public class QuerySolutionMap extends QuerySolutionBase protected boolean _contains(String varName) { return map.containsKey(varName) ; } @Override - public Iterator<String> varNames() { return map.keySet().iterator() ; } + public Iterator<String> varNames() { return map.keySet().iterator() ; } - /** Add all of the solutions from one QuerySolutionMap into this QuerySolutionMap */ - public void addAll(QuerySolutionMap other) - { + /** + * Add all of the solutions from one QuerySolutionMap into this QuerySolutionMap + */ + public void addAll(QuerySolutionMap other) { map.putAll(other.map); } - /** Return a <code>Map<String, RDFNode></code> representing the current - * state of this <code>QuerySolutionMap</code>. The map is not connected - * to the <code>QuerySolutionMap</code> and later changes to either <code>Map</code> - * or <code>QuerySolutionMap</code> will not reflected in the other. + /** + * Return a <code>Map<String, RDFNode></code> representing the current + * state of this <code>QuerySolutionMap</code>. The map is not connected to the + * <code>QuerySolutionMap</code> and later changes to either <code>Map</code> or + * <code>QuerySolutionMap</code> will not reflected in the other. * * @return {@literal Map<String, RDFNode>} */ @@ -64,6 +68,18 @@ public class QuerySolutionMap extends QuerySolutionBase return Map.copyOf(map) ; } + /** Return a <code>Map<Var, Node></code> representing the current + * state of this <code>QuerySolutionMap</code>. The map is not connected + * to the <code>QuerySolutionMap</code> and later changes to either <code>Map</code> + * or <code>QuerySolutionMap</code> will not reflected in the other. + * + * @return {@literal Map<Var, Node>} + */ + public Map<Var, Node> asVarNodeMap() { + return map.entrySet().stream() + .collect(Collectors.toMap(e -> Var.alloc(e.getKey()), e -> e.getValue().asNode())); + } + /** Add all of the solutions from one QuerySolution into this QuerySolutionMap */ public void addAll(QuerySolution other) { diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/exec/QueryExecDatasetBuilder.java b/jena-arq/src/main/java/org/apache/jena/sparql/exec/QueryExecDatasetBuilder.java index 4c3d84b659..3c3fb75924 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/exec/QueryExecDatasetBuilder.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/exec/QueryExecDatasetBuilder.java @@ -155,13 +155,6 @@ public class QueryExecDatasetBuilder implements QueryExecMod, QueryExecBuilder { substitutionMap = new HashMap<>(); } - /** @deprecated Use {@link #substitution(Binding)} */ - @Deprecated(forRemoval = true) - public QueryExecDatasetBuilder initialBinding(Binding binding) { - this.initialBinding = binding; - return this; - } - @Override public QueryExecDatasetBuilder timeout(long timeout) { return timeout(timeout, TimeUnit.MILLISECONDS); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/exec/UpdateExecDatasetBuilder.java b/jena-arq/src/main/java/org/apache/jena/sparql/exec/UpdateExecDatasetBuilder.java index e160117783..4560944917 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/exec/UpdateExecDatasetBuilder.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/exec/UpdateExecDatasetBuilder.java @@ -148,13 +148,6 @@ public class UpdateExecDatasetBuilder implements UpdateExecBuilder { return this; } - /** @deprecated Use {@link #substitution(Binding)} */ - @Deprecated(forRemoval = true) - public UpdateExecDatasetBuilder initialBinding(Binding initialBinding) { - this.initialBinding = initialBinding; - return this; - } - @Override public UpdateExec build() { Objects.requireNonNull(dataset, "No dataset for update"); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineBase.java index c521ea63c8..0bdbd7cc4e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineBase.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineBase.java @@ -20,22 +20,17 @@ package org.apache.jena.sparql.modify; import org.apache.jena.sparql.ARQConstants ; import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.util.Context ; import org.apache.jena.sparql.util.NodeFactoryExtra ; public abstract class UpdateEngineBase implements UpdateEngine { protected final DatasetGraph datasetGraph ; - protected final Binding inputBinding; protected final Context context ; - public UpdateEngineBase(DatasetGraph datasetGraph, - Binding inputBinding, - Context context) + public UpdateEngineBase(DatasetGraph datasetGraph, Context context) { this.datasetGraph = datasetGraph ; - this.inputBinding = inputBinding ; this.context = setupContext(context, datasetGraph) ; } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineFactory.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineFactory.java index 9c0599781f..e435031c55 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineFactory.java @@ -19,17 +19,16 @@ package org.apache.jena.sparql.modify; import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.util.Context ; -/** +/** * Interface for factories that accept and process SPARQL update requests. */ public interface UpdateEngineFactory { /** Answer whether this factory can produce an UpdateEngine for the specified GraphStore */ public boolean accept(DatasetGraph datasetGraph, Context context) ; - + /** Create the update engine - having returned true to accept, should not fail */ - public UpdateEngine create(DatasetGraph datasetGraph, Binding inputBinding, Context context); + public UpdateEngine create(DatasetGraph datasetGraph, Context context); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineMain.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineMain.java index 45b23e387f..19c4e82b0b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineMain.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineMain.java @@ -21,10 +21,9 @@ package org.apache.jena.sparql.modify; import java.util.function.Consumer; import org.apache.jena.atlas.lib.Sink; -import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.modify.request.UpdateVisitor ; -import org.apache.jena.sparql.util.Context ; +import org.apache.jena.sparql.core.DatasetGraph; +import org.apache.jena.sparql.modify.request.UpdateVisitor; +import org.apache.jena.sparql.util.Context; /** * Default implementation of an update engine based on stream updates to a worker @@ -43,12 +42,11 @@ public class UpdateEngineMain extends UpdateEngineBase /** * Creates a new Update Engine * @param datasetGraph DatasetGraph the updates operate over - * @param inputBinding Initial binding to be applied to Update operations that can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify) * @param context Execution Context */ - public UpdateEngineMain(DatasetGraph datasetGraph, Binding inputBinding, Context context) + public UpdateEngineMain(DatasetGraph datasetGraph, Context context) { - super(datasetGraph, inputBinding, context) ; + super(datasetGraph, context); } @Override @@ -57,7 +55,7 @@ public class UpdateEngineMain extends UpdateEngineBase @Override public void finishRequest() {} - private UpdateSink updateSink = null ; + private UpdateSink updateSink = null; /* * Returns the {@link UpdateSink}. In this implementation, this is done by with @@ -73,7 +71,7 @@ public class UpdateEngineMain extends UpdateEngineBase updateSink = new UpdateVisitorSink(this.prepareWorker(), sink(q->datasetGraph.add(q)), sink(q->datasetGraph.delete(q))); - return updateSink ; + return updateSink; } /** @@ -81,7 +79,7 @@ public class UpdateEngineMain extends UpdateEngineBase * @return The update visitor to be used to apply the updates */ protected UpdateVisitor prepareWorker() { - return new UpdateEngineWorker(datasetGraph, inputBinding, context) ; + return new UpdateEngineWorker(datasetGraph, context); } /** Direct a sink to a Consumer. */ @@ -100,15 +98,14 @@ public class UpdateEngineMain extends UpdateEngineBase { @Override public boolean accept(DatasetGraph datasetGraph, Context context) { - return true ; + return true; } @Override - public UpdateEngine create(DatasetGraph datasetGraph, Binding inputBinding, - Context context) { - return new UpdateEngineMain(datasetGraph, inputBinding, context) ; + public UpdateEngine create(DatasetGraph datasetGraph, Context context) { + return new UpdateEngineMain(datasetGraph, context); } - } ; + }; - public static UpdateEngineFactory getFactory() { return factory ; } + public static UpdateEngineFactory getFactory() { return factory; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineNonStreaming.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineNonStreaming.java index e9c2855249..5fc4597bdf 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineNonStreaming.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineNonStreaming.java @@ -18,84 +18,84 @@ package org.apache.jena.sparql.modify; -import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.modify.request.UpdateVisitor ; -import org.apache.jena.sparql.util.Context ; -import org.apache.jena.update.Update ; -import org.apache.jena.update.UpdateRequest ; +import org.apache.jena.sparql.core.DatasetGraph; +import org.apache.jena.sparql.modify.request.UpdateVisitor; +import org.apache.jena.sparql.util.Context; +import org.apache.jena.update.Update; +import org.apache.jena.update.UpdateRequest; /** - * Example implementation of an update engine that does not stream data, instead it will build it up into an - * in-memory UpdateRequest, and then traverse it after all update operations have finished. + * Example implementation of an update engine that does not stream data, instead it + * will build it up into an in-memory UpdateRequest, and then traverse it after all + * update operations have finished. */ -public class UpdateEngineNonStreaming extends UpdateEngineMain -{ +public class UpdateEngineNonStreaming extends UpdateEngineMain { // This is the internal accumulator of update operations. // It is used to accumulate Updates so as not to alter // the UpdateRequest at the application level. - protected final UpdateRequest accRequests ; - protected final UpdateSink updateSink ; - + protected final UpdateRequest accRequests; + protected final UpdateSink updateSink; + /** * Creates a new Update Engine + * * @param datasetGraph Store the updates operate over - * @param inputBinding Initial binding to be applied to Update operations that can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify) * @param context Execution Context */ - public UpdateEngineNonStreaming(DatasetGraph datasetGraph, Binding inputBinding, Context context) - { - super(datasetGraph, inputBinding, context) ; + public UpdateEngineNonStreaming(DatasetGraph datasetGraph, Context context) { + super(datasetGraph, context); accRequests = new UpdateRequest(); - updateSink = new UpdateRequestSink(accRequests) - { + updateSink = new UpdateRequestSink(accRequests) { @Override - public void close() - { - // Override the close() method to call execute() when we're done accepting update operations + public void close() { + // Override the close() method to call execute() when we're done + // accepting update operations super.close(); execute(); } - } ; + }; } @Override - public void startRequest() {} - + public void startRequest() {} + @Override public void finishRequest() {} - + /** - * Returns an {@link UpdateSink} that adds all update operations into an internal {@link UpdateRequest} object. - * After the last update operation has been added, the {@link #execute()} method is called. + * Returns an {@link UpdateSink} that adds all update operations into an internal + * {@link UpdateRequest} object. After the last update operation has been added, + * the {@link #execute()} method is called. */ @Override - public UpdateSink getUpdateSink() { return updateSink ; } - + public UpdateSink getUpdateSink() { + return updateSink; + } + /** - * Called after all of the update operations have been added to {@link #accRequests}. + * Called after all of the update operations have been added to + * {@link #accRequests}. */ - protected void execute() - { - UpdateVisitor worker = this.prepareWorker() ; - for ( Update up : accRequests ) - { - up.visit(worker) ; + protected void execute() { + UpdateVisitor worker = this.prepareWorker(); + for ( Update up : accRequests ) { + up.visit(worker); } } - + private static UpdateEngineFactory factory = new UpdateEngineFactory() { @Override public boolean accept(DatasetGraph datasetGraph, Context context) { - return true ; + return true; } @Override - public UpdateEngine create(DatasetGraph datasetGraph, Binding inputBinding, - Context context) { - return new UpdateEngineNonStreaming(datasetGraph, inputBinding, context) ; + public UpdateEngine create(DatasetGraph datasetGraph, Context context) { + return new UpdateEngineNonStreaming(datasetGraph, context); } - } ; + }; - public static UpdateEngineFactory getFactory() { return factory ; } + public static UpdateEngineFactory getFactory() { + return factory; + } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineRegistry.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineRegistry.java index d45eef55f3..40ee4a8420 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineRegistry.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineRegistry.java @@ -18,19 +18,19 @@ package org.apache.jena.sparql.modify; -import java.util.ArrayList ; -import java.util.List ; +import java.util.ArrayList; +import java.util.List; -import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.util.Context ; +import org.apache.jena.sparql.core.DatasetGraph; +import org.apache.jena.sparql.util.Context; public class UpdateEngineRegistry { - List<UpdateEngineFactory> factories = new ArrayList<>() ; + List<UpdateEngineFactory> factories = new ArrayList<>(); // Singleton - private static UpdateEngineRegistry registry ; - static { init() ; } + private static UpdateEngineRegistry registry; + static { init(); } static public UpdateEngineRegistry get() { @@ -41,8 +41,8 @@ public class UpdateEngineRegistry private static void init() { - registry = new UpdateEngineRegistry() ; - registry.add(UpdateEngineMain.getFactory()) ; + registry = new UpdateEngineRegistry(); + registry.add(UpdateEngineMain.getFactory()); } /** Locate a suitable factory for this dataset from the default registry @@ -51,7 +51,7 @@ public class UpdateEngineRegistry * @return A QueryExecutionFactory or null if none accept the request */ public static UpdateEngineFactory findFactory(DatasetGraph graphStore, Context context) - { return get().find(graphStore, context) ; } + { return get().find(graphStore, context); } /** Locate a suitable factory for this dataset * @@ -63,34 +63,34 @@ public class UpdateEngineRegistry for ( UpdateEngineFactory f : factories ) { if ( f.accept(graphStore, context) ) - return f ; + return f; } - return null ; + return null; } /** Add a QueryExecutionFactory to the default registry */ - public static void addFactory(UpdateEngineFactory f) { get().add(f) ; } + public static void addFactory(UpdateEngineFactory f) { get().add(f); } /** Add a QueryExecutionFactory */ public void add(UpdateEngineFactory f) { // Add to low end so that newer factories are tried first - factories.add(0, f) ; + factories.add(0, f); } /** Remove a QueryExecutionFactory */ - public static void removeFactory(UpdateEngineFactory f) { get().remove(f) ; } + public static void removeFactory(UpdateEngineFactory f) { get().remove(f); } /** Remove a QueryExecutionFactory */ - public void remove(UpdateEngineFactory f) { factories.remove(f) ; } + public void remove(UpdateEngineFactory f) { factories.remove(f); } /** Allow <b>careful</b> manipulation of the factories list */ - public List<UpdateEngineFactory> factories() { return factories ; } + public List<UpdateEngineFactory> factories() { return factories; } /** Check whether a query engine factory is already registered in the default registry*/ - public static boolean containsFactory(UpdateEngineFactory f) { return get().contains(f) ; } + public static boolean containsFactory(UpdateEngineFactory f) { return get().contains(f); } /** Check whether a query engine factory is already registered */ - public boolean contains(UpdateEngineFactory f) { return factories.contains(f) ; } + public boolean contains(UpdateEngineFactory f) { return factories.contains(f); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineWorker.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineWorker.java index 3bc9b71039..330b2ea893 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineWorker.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateEngineWorker.java @@ -43,11 +43,11 @@ import org.apache.jena.riot.*; import org.apache.jena.riot.system.PrefixMap; import org.apache.jena.sparql.ARQInternalErrorException; import org.apache.jena.sparql.core.*; +import org.apache.jena.sparql.engine.Timeouts; +import org.apache.jena.sparql.engine.Timeouts.Timeout; import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.engine.binding.BindingRoot; import org.apache.jena.sparql.exec.*; -import org.apache.jena.sparql.engine.Timeouts; -import org.apache.jena.sparql.engine.Timeouts.Timeout; import org.apache.jena.sparql.graph.GraphFactory; import org.apache.jena.sparql.graph.GraphOps; import org.apache.jena.sparql.modify.request.*; @@ -64,7 +64,6 @@ public class UpdateEngineWorker implements UpdateVisitor { protected final DatasetGraph datasetGraph; protected final boolean autoSilent = true; // DROP and CREATE - protected final Binding inputBinding; // Used for UpdateModify only: substitution is better. protected final Context context; protected final Timeout timeout; @@ -76,9 +75,8 @@ public class UpdateEngineWorker implements UpdateVisitor protected final AtomicBoolean cancelSignal; protected volatile QueryExec activeQExec = null; - public UpdateEngineWorker(DatasetGraph datasetGraph, Binding inputBinding, Context context) { + public UpdateEngineWorker(DatasetGraph datasetGraph, Context context) { this.datasetGraph = datasetGraph; - this.inputBinding = inputBinding; this.context = context; this.timeout = Timeouts.extractUpdateTimeout(context); this.cancelSignal = Context.getOrSetCancelSignal(context); @@ -403,7 +401,7 @@ public class UpdateEngineWorker implements UpdateVisitor ThresholdPolicy<Binding> policy = ThresholdPolicyFactory.policyFromContext(datasetGraph.getContext()); DataBag<Binding> db = BagFactory.newDefaultBag(policy, SerializationFactoryFinder.bindingSerializationFactory()); try { - Iterator<Binding> bindings = evalBindings(query, dsg, inputBinding, context); + Iterator<Binding> bindings = evalBindings(query, dsg, context); try { if ( false ) { @@ -560,15 +558,14 @@ public class UpdateEngineWorker implements UpdateVisitor protected Iterator<Binding> evalBindings(Element pattern) { Query query = elementToQuery(pattern); - return evalBindings(query, datasetGraph, inputBinding, context); + return evalBindings(query, datasetGraph, context); } - @SuppressWarnings("removal") - protected Iterator<Binding> evalBindings(Query query, DatasetGraph dsg, Binding inputBinding, Context context) { + protected Iterator<Binding> evalBindings(Query query, DatasetGraph dsg, Context context) { // The UpdateProcessorBase already copied the context and made it safe // ... but that's going to happen again :-( if ( query == null ) { - Binding binding = (null != inputBinding) ? inputBinding : BindingRoot.create(); + Binding binding = BindingRoot.create(); return Iter.singletonIterator(binding); } @@ -576,12 +573,6 @@ public class UpdateEngineWorker implements UpdateVisitor // Not QueryExecDataset.dataset(...) because of initialBinding. QueryExecDatasetBuilder builder = QueryExecDatasetBuilder.create().dataset(dsg).query(query).context(context); - if ( inputBinding != null ) { - // Must use initialBinding - it puts the input in the results, unlike substitution. - builder.initialBinding(inputBinding); - // substitution does not put results in the output. - // builder.substitution(inputBinding); - } QueryExec qExec = builder.build(); setQExec(qExec); return qExec.select(); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorBase.java index d51b96e050..d5885e6755 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorBase.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorBase.java @@ -36,21 +36,11 @@ public class UpdateProcessorBase implements UpdateProcessor { protected final UpdateRequest request ; protected final DatasetGraph datasetGraph ; - protected final Binding inputBinding; protected final UpdateEngineFactory factory ; protected final Context context ; protected final Timeout timeout ; - @Deprecated - public UpdateProcessorBase(UpdateRequest request, - DatasetGraph datasetGraph, - Binding inputBinding, - Context context, - UpdateEngineFactory factory) { - this(request, datasetGraph, inputBinding, context, factory, null); - } - - public UpdateProcessorBase(UpdateRequest request, + public UpdateProcessorBase(UpdateRequest request, DatasetGraph datasetGraph, Binding inputBinding, Context context, @@ -59,7 +49,6 @@ public class UpdateProcessorBase implements UpdateProcessor { this.request = request ; this.datasetGraph = datasetGraph ; - this.inputBinding = inputBinding; this.context = context; Context.setCurrentDateTime(this.context) ; this.factory = factory ; @@ -72,7 +61,7 @@ public class UpdateProcessorBase implements UpdateProcessor @Override public void execute() { - UpdateEngine uProc = factory.create(datasetGraph, inputBinding, context); + UpdateEngine uProc = factory.create(datasetGraph, context); uProc.startRequest(); // context.get(ARQ.updateTimeout); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorStreamingBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorStreamingBase.java index 359fb32a34..502eea35ab 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorStreamingBase.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/modify/UpdateProcessorStreamingBase.java @@ -18,55 +18,54 @@ package org.apache.jena.sparql.modify; -import org.apache.jena.sparql.core.DatasetGraph ; +import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.Prologue; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.util.Context ; -import org.apache.jena.update.UpdateProcessorStreaming ; +import org.apache.jena.sparql.util.Context; +import org.apache.jena.update.UpdateProcessorStreaming; /** Class to hold the general state of a update request execution. * See query ExecutionContext */ public class UpdateProcessorStreamingBase implements UpdateProcessorStreaming { - protected final DatasetGraph datasetGraph ; - protected final Context context ; - + protected final DatasetGraph datasetGraph; + protected final Context context; + protected final UpdateEngine proc; protected final Prologue prologue; - public UpdateProcessorStreamingBase(DatasetGraph datasetGraph, Binding inputBinding, Prologue prologue, Context context, UpdateEngineFactory factory) + public UpdateProcessorStreamingBase(DatasetGraph datasetGraph, Prologue prologue, Context context, UpdateEngineFactory factory) { - this.datasetGraph = datasetGraph ; + this.datasetGraph = datasetGraph; this.prologue = prologue; this.context = context; - Context.setCurrentDateTime(this.context) ; - proc = factory.create(datasetGraph, inputBinding, context) ; + Context.setCurrentDateTime(this.context); + proc = factory.create(datasetGraph, context); } - + @Override public void startRequest() { - proc.startRequest() ; + proc.startRequest(); } @Override public void finishRequest() { - proc.finishRequest() ; + proc.finishRequest(); } @Override public UpdateSink getUpdateSink() { - return proc.getUpdateSink() ; + return proc.getUpdateSink(); } @Override public DatasetGraph getDatasetGraph() { - return datasetGraph ; + return datasetGraph; } @Override public Context getContext() { - return context ; + return context; } @Override diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/graph/GraphUtils.java b/jena-arq/src/main/java/org/apache/jena/sparql/util/graph/GraphUtils.java index 18e486231f..349e29eb63 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/util/graph/GraphUtils.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/graph/GraphUtils.java @@ -286,7 +286,7 @@ public class GraphUtils { QuerySolutionMap qsm = new QuerySolutionMap(); qsm.add("ATYPE", atype); - try( @SuppressWarnings("removal") QueryExecution qExec = QueryExecution.model(model).query(q).initialBinding(qsm).build() ) { + try( QueryExecution qExec = QueryExecution.model(model).query(q).substitution(qsm).build() ) { return (Resource)QueryExecUtils.getAtMostOne(qExec, "root"); } } @@ -299,7 +299,7 @@ public class GraphUtils { Query q = QueryFactory.create(s); QuerySolutionMap qsm = new QuerySolutionMap(); qsm.add("ATYPE", atype); - try( @SuppressWarnings("removal") QueryExecution qExec = QueryExecution.model(model).query(q).initialBinding(qsm).build() ) { + try( QueryExecution qExec = QueryExecution.model(model).query(q).substitution(qsm).build() ) { return QueryExecUtils.getAll(qExec, "root").stream().map(r->(Resource)r).toList(); } } diff --git a/jena-arq/src/main/java/org/apache/jena/update/UpdateAction.java b/jena-arq/src/main/java/org/apache/jena/update/UpdateAction.java index 987b76e7e6..cca3970c45 100644 --- a/jena-arq/src/main/java/org/apache/jena/update/UpdateAction.java +++ b/jena-arq/src/main/java/org/apache/jena/update/UpdateAction.java @@ -29,8 +29,6 @@ import org.apache.jena.rdf.model.Model; import org.apache.jena.sparql.ARQException; import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.DatasetGraphFactory; -import org.apache.jena.sparql.engine.binding.Binding; -import org.apache.jena.sparql.engine.binding.BindingLib; import org.apache.jena.sparql.exec.UpdateExec; import org.apache.jena.sparql.lang.UpdateParser; import org.apache.jena.sparql.modify.UpdateSink; @@ -81,31 +79,8 @@ public class UpdateAction { * @param dataset */ public static void readExecute(String filename, DatasetGraph dataset) { - readExecute(filename, dataset, null); - } - - /** - * Read a file containing SPARQL Update operations, and execute the operations. - * - * @param filename - * @param dataset - * @param inputBinding - */ - public static void readExecute(String filename, Dataset dataset, QuerySolution inputBinding) { - UpdateRequest req = UpdateFactory.read(filename); - execute(req, dataset, inputBinding); - } - - /** - * Read a file containing SPARQL Update operations, and execute the operations. - * - * @param filename - * @param datasetGraph - * @param inputBinding - */ - public static void readExecute(String filename, DatasetGraph datasetGraph, Binding inputBinding) { UpdateRequest req = UpdateFactory.read(filename); - execute$(req, datasetGraph, inputBinding); + execute$(req, dataset); } /** @@ -153,31 +128,6 @@ public class UpdateAction { execute(req, dataset); } - /** - * Parse a string containing SPARQL Update operations, and execute the - * operations. - * - * @param updateString - * @param dataset - * @param inputBinding - */ - public static void parseExecute(String updateString, Dataset dataset, QuerySolution inputBinding) { - parseExecute(updateString, dataset.asDatasetGraph(), BindingLib.asBinding(inputBinding)); - } - - /** - * Parse a string containing SPARQL Update operations, and execute the - * operations. - * - * @param updateString - * @param dataset - * @param inputBinding - */ - public static void parseExecute(String updateString, DatasetGraph dataset, Binding inputBinding) { - UpdateRequest req = UpdateFactory.create(updateString); - execute(req, dataset, inputBinding); - } - /** * Execute SPARQL Update operations. * @@ -215,7 +165,7 @@ public class UpdateAction { * @param dataset */ public static void execute(UpdateRequest request, DatasetGraph dataset) { - execute$(request, dataset, null); + execute$(request, dataset); } /** @@ -226,18 +176,7 @@ public class UpdateAction { * @param inputBinding */ public static void execute(UpdateRequest request, Dataset dataset, QuerySolution inputBinding) { - execute(request, dataset.asDatasetGraph(), BindingLib.asBinding(inputBinding)); - } - - /** - * Execute SPARQL Update operations. - * - * @param request - * @param datasetGraph - * @param inputBinding - */ - public static void execute(UpdateRequest request, DatasetGraph datasetGraph, Binding inputBinding) { - execute$(request, datasetGraph, inputBinding); + execute$(request, dataset.asDatasetGraph()); } private static DatasetGraph toDatasetGraph(Graph graph) { @@ -246,9 +185,8 @@ public class UpdateAction { // All non-streaming updates come through here. - private static void execute$(UpdateRequest request, DatasetGraph datasetGraph, Binding inputBinding) { - @SuppressWarnings("removal") - UpdateExec uProc = UpdateExec.newBuilder().update(request).dataset(datasetGraph).initialBinding(inputBinding).build(); + private static void execute$(UpdateRequest request, DatasetGraph datasetGraph) { + UpdateExec uProc = UpdateExec.newBuilder().update(request).dataset(datasetGraph).build(); if ( uProc == null ) throw new ARQException("No suitable update procesors are registered/able to execute your updates"); uProc.execute(); @@ -291,35 +229,13 @@ public class UpdateAction { * @param dataset */ public static void execute(Update update, DatasetGraph dataset) { - execute(update, dataset, null); - } - - /** - * Execute a single SPARQL Update operation. - * - * @param update - * @param dataset - * @param inputBinding - */ - public static void execute(Update update, Dataset dataset, QuerySolution inputBinding) { - execute(update, dataset.asDatasetGraph(), BindingLib.asBinding(inputBinding)); - } - - /** - * Execute a single SPARQL Update operation. - * - * @param update - * @param datasetGraph - * @param inputBinding - */ - public static void execute(Update update, DatasetGraph datasetGraph, Binding inputBinding) { - execute$(update, datasetGraph, inputBinding); + execute$(update, dataset); } - private static void execute$(Update update, DatasetGraph datasetGraph, Binding inputBinding) { + private static void execute$(Update update, DatasetGraph datasetGraph) { UpdateRequest request = new UpdateRequest(); request.add(update); - execute$(request, datasetGraph, inputBinding); + execute$(request, datasetGraph); } // Streaming Updates: @@ -336,18 +252,6 @@ public class UpdateAction { /** Parse update operations into a DatasetGraph by reading it from a file */ public static void parseExecute(UsingList usingList, DatasetGraph dataset, String fileName, String baseURI, Syntax syntax) { - parseExecute(usingList, dataset, fileName, (Binding)null, baseURI, syntax); - } - - /** Parse update operations into a DatasetGraph by reading it from a file */ - public static void parseExecute(UsingList usingList, DatasetGraph dataset, String fileName, QuerySolution inputBinding, String baseURI, - Syntax syntax) { - parseExecute(usingList, dataset, fileName, BindingLib.asBinding(inputBinding), baseURI, syntax); - } - - /** Parse update operations into a DatasetGraph by reading it from a file */ - public static void parseExecute(UsingList usingList, DatasetGraph dataset, String fileName, Binding inputBinding, String baseURI, - Syntax syntax) { InputStream in = null; if ( fileName.equals("-") ) in = System.in; @@ -356,7 +260,7 @@ public class UpdateAction { if ( in == null ) throw new UpdateException("File could not be opened: " + fileName); } - parseExecute(usingList, dataset, in, inputBinding, baseURI, syntax); + parseExecute(usingList, dataset, in, baseURI, syntax); if ( in != System.in ) IO.close(in); } @@ -408,46 +312,7 @@ public class UpdateAction { * @param syntax The update language syntax */ public static void parseExecute(UsingList usingList, DatasetGraph dataset, InputStream input, String baseURI, Syntax syntax) { - parseExecute(usingList, dataset, input, (Binding)null, baseURI, syntax); - } - - /** - * Parse update operations into a DatasetGraph by parsing from an InputStream. - * - * @param usingList A list of USING or USING NAMED statements that be added to - * all {@link UpdateWithUsing} queries - * @param dataset The dataset to apply the changes to - * @param input The source of the update request (must be UTF-8). - * @param inputBinding Initial binding to be applied to Update operations that - * can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify). May - * be <code>null</code> - * @param baseURI The base URI for resolving relative URIs (may be - * <code>null</code>) - * @param syntax The update language syntax - */ - public static void parseExecute(UsingList usingList, DatasetGraph dataset, InputStream input, QuerySolution inputBinding, - String baseURI, Syntax syntax) { - parseExecute(usingList, dataset, input, BindingLib.asBinding(inputBinding), baseURI, syntax); - } - - /** - * Parse update operations into a DatasetGraph by parsing from an InputStream. - * - * @param usingList A list of USING or USING NAMED statements that be added to - * all {@link UpdateWithUsing} queries - * @param dataset The dataset to apply the changes to - * @param input The source of the update request (must be UTF-8). - * @param inputBinding Initial binding to be applied to Update operations that - * can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify). May - * be <code>null</code> - * @param baseURI The base URI for resolving relative URIs (may be - * <code>null</code>) - * @param syntax The update language syntax - */ - public static void parseExecute(UsingList usingList, DatasetGraph dataset, InputStream input, Binding inputBinding, String baseURI, - Syntax syntax) { - @SuppressWarnings("removal") - UpdateProcessorStreaming uProc = UpdateStreaming.createStreaming(dataset, inputBinding); + UpdateProcessorStreaming uProc = UpdateStreaming.createStreaming(dataset); if ( uProc == null ) throw new ARQException("No suitable update procesors are registered/able to execute your updates"); diff --git a/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionDatasetBuilder.java b/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionDatasetBuilder.java index b0ce8acac2..4efd0dc08b 100644 --- a/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionDatasetBuilder.java +++ b/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionDatasetBuilder.java @@ -101,21 +101,6 @@ public class UpdateExecutionDatasetBuilder implements UpdateExecutionBuilder { return this; } -// public UpdateExecutionBuilder initialBinding(Binding initialBinding) { -// builder.initialBinding(initialBinding); -// return this; -// } - - /** @deprecated Prefer {@link #substitution(QuerySolution)}. */ - @Deprecated(forRemoval = true) - public UpdateExecutionDatasetBuilder initialBinding(QuerySolution querySolution) { - if ( querySolution == null ) - return this; - Binding binding = BindingLib.asBinding(querySolution); - builder.initialBinding(binding); - return this; - } - @Override public UpdateExecutionDatasetBuilder substitution(QuerySolution querySolution) { if ( querySolution == null ) diff --git a/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionFactory.java b/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionFactory.java index 9372de4e94..c9d2ddc1f5 100644 --- a/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/update/UpdateExecutionFactory.java @@ -84,18 +84,6 @@ public class UpdateExecutionFactory return UpdateExecution.dataset(dataset).update(updateRequest).build(); } - /** - * Create an UpdateExecution appropriate to the datasetGraph, or null if no - * available factory to make an UpdateExecution - * - * @param dataset - * @return UpdateExecution - */ - @Deprecated(forRemoval = true) - public static UpdateProcessorStreaming createStreaming(Dataset dataset) { - return UpdateStreaming.makeStreaming(dataset.asDatasetGraph(), null, null); - } - /** * Create an UpdateExecution that sends the update to a remote SPARQL Update * service. diff --git a/jena-arq/src/main/java/org/apache/jena/update/UpdateStreaming.java b/jena-arq/src/main/java/org/apache/jena/update/UpdateStreaming.java index feebfeac74..f3c69e313a 100644 --- a/jena-arq/src/main/java/org/apache/jena/update/UpdateStreaming.java +++ b/jena-arq/src/main/java/org/apache/jena/update/UpdateStreaming.java @@ -19,11 +19,8 @@ package org.apache.jena.update; import org.apache.jena.query.Dataset; -import org.apache.jena.query.QuerySolution; import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.Prologue; -import org.apache.jena.sparql.engine.binding.Binding; -import org.apache.jena.sparql.engine.binding.BindingLib; import org.apache.jena.sparql.modify.UpdateEngineFactory; import org.apache.jena.sparql.modify.UpdateEngineRegistry; import org.apache.jena.sparql.modify.UpdateProcessorStreamingBase; @@ -36,28 +33,34 @@ public class UpdateStreaming { * available factory to make an UpdateExecution * * @param dataset - * @param inputBinding Initial binding to be applied to Update operations that - * can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify) * @return UpdateExecution */ - @Deprecated(forRemoval = true) - public static UpdateProcessorStreaming createStreaming(Dataset dataset, QuerySolution inputBinding) { - return createStreaming(dataset.asDatasetGraph(), BindingLib.asBinding(inputBinding)); + public static UpdateProcessorStreaming createStreaming(Dataset dataset) { + return makeStreaming(dataset.asDatasetGraph(), null); } /** * Create an UpdateExecution appropriate to the datasetGraph, or null if no * available factory to make an UpdateExecution * - * @param datasetGraph - * @param inputBinding Initial binding to be applied to Update operations that - * can apply an initial binding (i.e. UpdateDeleteWhere, UpdateModify) + * @param dataset + * @param context (null means use merge of global and graph store context)) + * @return UpdateExecution + */ + public static UpdateProcessorStreaming createStreaming(Dataset dataset, Context context) { + return makeStreaming(dataset.asDatasetGraph(), context); + } + + + /** + * Create an UpdateExecution appropriate to the datasetGraph, or null if no + * available factory to make an UpdateExecution + * + * @param dataset * @return UpdateExecution - * @deprecated Use {@code UpdateExecution.dataset(dataset)... build()} */ - @Deprecated(forRemoval = true) - public static UpdateProcessorStreaming createStreaming(DatasetGraph datasetGraph, Binding inputBinding) { - return makeStreaming(datasetGraph, inputBinding, null); + public static UpdateProcessorStreaming createStreaming(DatasetGraph dataset) { + return makeStreaming(dataset, null); } /** @@ -68,16 +71,16 @@ public class UpdateStreaming { * @param context (null means use merge of global and graph store context)) * @return UpdateExecution */ - public static UpdateProcessorStreaming createStreaming(Dataset dataset, Context context) { - return makeStreaming(dataset.asDatasetGraph(), null, context); + public static UpdateProcessorStreaming createStreaming(DatasetGraph dataset, Context context) { + return makeStreaming(dataset, context); } // Everything for local updates comes through one of these two make methods - /*package*/ static UpdateProcessorStreaming makeStreaming(DatasetGraph datasetGraph, Binding inputBinding, Context context) { + /*package*/ static UpdateProcessorStreaming makeStreaming(DatasetGraph datasetGraph, Context context) { Prologue prologue = new Prologue(); Context cxt = Context.setupContextForDataset(context, datasetGraph); UpdateEngineFactory f = UpdateEngineRegistry.get().find(datasetGraph, cxt); - UpdateProcessorStreamingBase uProc = new UpdateProcessorStreamingBase(datasetGraph, inputBinding, prologue, cxt, f); + UpdateProcessorStreamingBase uProc = new UpdateProcessorStreamingBase(datasetGraph, prologue, cxt, f); return uProc; } } diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/api/TestAPI.java b/jena-arq/src/test/java/org/apache/jena/sparql/api/TestAPI.java index 686dad6f74..e00b75499e 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/api/TestAPI.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/api/TestAPI.java @@ -38,6 +38,7 @@ import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.DatasetGraphFactory; import org.apache.jena.sparql.core.Quad; import org.apache.jena.sparql.graph.GraphFactory; +import org.apache.jena.sparql.syntax.syntaxtransform.QueryTransformOps; import org.apache.jena.sparql.util.IsoMatcher; import org.apache.jena.vocabulary.OWL; import org.apache.jena.vocabulary.RDF; @@ -66,75 +67,48 @@ public class TestAPI d.addNamedModel(g1.getURI(), m); } - @SuppressWarnings("removal") - @Test public void testInitialBindingsConstruct1() - { + @Test + public void test_API1() { + String qs = "SELECT * {?s ?p ?o}"; + try (QueryExecution qExec = QueryExecution.model(m).query(qs).build()) { + ResultSet rs = qExec.execSelect(); + assertTrue(rs.hasNext(), () -> "No results"); + QuerySolution qSoln = rs.nextSolution(); + Resource qr = qSoln.getResource("s"); + Set<Statement> s1 = qr.getModel().listStatements().toSet(); + Set<Statement> s2 = m.listStatements().toSet(); + assertEquals(s1, s2); + } + } + + @Test + public void testSubstitutionConstruct1() { QuerySolutionMap init = new QuerySolutionMap(); init.add("z", m.createLiteral("zzz")); String qs = "CONSTRUCT {?s ?p ?z} {?s ?p 'x1'}"; - try ( QueryExecution qExec = QueryExecution.model(m) - .query(qs) - .initialBinding(init) - .build() ) { + try (QueryExecution qExec = QueryExecution.model(m).query(qs).substitution(init).build()) { Model r = qExec.execConstruct(); - assertTrue(r.size() > 0 , ()->"Empty model"); - Property p1 = m.createProperty(ns+"p1"); - assertTrue(r.contains(null,p1, init.get("z")), ()->"Empty model"); + assertTrue(r.size() > 0, () -> "Empty model"); + Property p1 = m.createProperty(ns + "p1"); + assertTrue(r.contains(null, p1, init.get("z")), () -> "Empty model"); } } - @SuppressWarnings("removal") - @Test public void testInitialBindingsConstruct2() - { + @Test + public void testSubstitutionConstruct2() { QuerySolutionMap init = new QuerySolutionMap(); init.add("o", m.createLiteral("x1")); String qs = "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }"; - try ( QueryExecution qExec = QueryExecution.model(m).query(qs) - .initialBinding(init) - .build() ) { + try (QueryExecution qExec = QueryExecution.model(m).query(qs).substitution(init).build()) { Model r = qExec.execConstruct(); - assertTrue(r.size() > 0 , ()->"Empty model"); - Property p1 = m.createProperty(ns+"p1"); - assertTrue(r.contains(null, p1, init.get("x1")), ()->"Empty model"); + assertTrue(r.size() > 0, () -> "Empty model"); + Property p1 = m.createProperty(ns + "p1"); + assertTrue(r.contains(null, p1, init.get("x1")), () -> "Empty model"); } } - // The original test (see commented out "assertSame) in the test is now bogus. - // DatasetImpl no longer caches the default model as that caused problems. - // - // This is testing that the model for the resource in the result is the - // same object as the model supplied to the query. - // "Same" here means "same contents" including blank nodes. - // - // it used to be that this tested whether they were the same object. - // That is dubious and no longer true even for DatasetImpl (the default mode - // is not cached but recreated on demand so there are no problems with - // transaction boundaries). - // - // Left as an active test so the assumption is tested (it has been true for - // many years). - // - // Using the Resource.getXXX and Resource.listXXX operations is dubious if - // there are named graphs and that has always been the case. - - @Test public void test_API1() - { - String qs = "SELECT * {?s ?p ?o}"; - try ( QueryExecution qExec = QueryExecution.model(m).query(qs) - .build() ) { - ResultSet rs = qExec.execSelect(); - assertTrue(rs.hasNext(), ()->"No results"); - QuerySolution qSoln = rs.nextSolution(); - Resource qr = qSoln.getResource("s"); - //assertSame("Not the same model as queried", qr.getModel(), m); - Set<Statement> s1 = qr.getModel().listStatements().toSet(); - Set<Statement> s2 = m.listStatements().toSet(); - assertEquals(s1,s2); - } - } - - @Test public void testInitialBindings0() - { + @Test + public void testSubstitution0() { QuerySolutionMap smap1 = new QuerySolutionMap(); QuerySolutionMap smap2 = new QuerySolutionMap(); smap1.add("o", m.createLiteral("y1")); @@ -149,70 +123,63 @@ public class TestAPI assertTrue(smap2.contains("o")); } - @SuppressWarnings("removal") - @Test public void testInitialBindings1() - { + @Test + public void testSubstitution1() { QuerySolutionMap init = new QuerySolutionMap(); init.add("o", m.createLiteral("y1")); String qs = "SELECT * {?s ?p ?o}"; - try ( QueryExecution qExec = QueryExecution.model(m).query(qs) - .initialBinding(init) - .build() ) { + try (QueryExecution qExec = QueryExecution.model(m).query(qs).substitution(init).build()) { int count = queryAndCount(qExec); - assertEquals(1, count, ()->"Initial binding didn't restrict query properly"); + assertEquals(1, count, () -> "Initial binding didn't restrict query properly"); } } - @SuppressWarnings("removal") - @Test public void testInitialBindings2() - { + @Test + public void testSubstitution2() { QuerySolutionMap init = new QuerySolutionMap(); init.add("z", m.createLiteral("zzz")); String qs = "SELECT * {?s ?p ?o}"; - try ( QueryExecution qExec = QueryExecution.model(m).query(qs) - .initialBinding(init) - .build() ) { + try (QueryExecution qExec = QueryExecution.model(m).query(qs).substitution(init).build()) { int count = queryAndCount(qExec); assertEquals(3, count, "Initial binding restricted query improperly"); } } - @SuppressWarnings("removal") - @Test public void testInitialBindings3() - { + @Test + public void testSubstitution3() { + // test requires the substitutions are returned. QuerySolutionMap init = new QuerySolutionMap(); init.add("z", m.createLiteral("zzz")); String qs = "SELECT * {?s ?p 'x1'}"; - try ( QueryExecution qExec = QueryExecution.model(m).query(qs) - .initialBinding(init) - .build() ) { + Query q = QueryFactory.create(qs); + Query q2 = QueryTransformOps.syntaxSubstitute(q, init.asVarNodeMap()); + + try (QueryExecution qExec = QueryExecution.model(m).query(q2).build()) { ResultSet rs = qExec.execSelect(); - QuerySolution qSoln= rs.nextSolution(); - assertTrue(qSoln.getLiteral("z").getLexicalForm().equals("zzz"), ()->"Initial setting not set correctly now"); + QuerySolution qSoln = rs.nextSolution(); + assertTrue(qSoln.getLiteral("z").getLexicalForm().equals("zzz"), () -> "Initial setting not set correctly now"); } } - @SuppressWarnings("removal") - @Test public void testInitialBindings4() - { + @Test public void testSubstitution4() { // Test derived from report by Holger Knublauch - String queryString = - "PREFIX : <"+ns+">\n" + - "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \n" + - "SELECT * \n" + - "WHERE { \n" + - " ?x :p1 ?z ." + - " NOT EXISTS { \n" + - " ?x rdfs:label ?z . \n" + - " }\n" + - "}"; + String queryString = "PREFIX : <"+ns+">\n" + + """ + PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> + SELECT * + WHERE { + ?x :p1 ?z . + NOT EXISTS { + ?x rdfs:label ?z . + } + }"""; Query query = QueryFactory.create(queryString, Syntax.syntaxARQ); QuerySolutionMap map = new QuerySolutionMap(); map.add("this", OWL.Thing); try ( QueryExecution qExec = QueryExecution.model(m).query(queryString) - .initialBinding(map) + .substitution(map) .build() ) { ResultSet rs = qExec.execSelect(); while(rs.hasNext()) { @@ -221,11 +188,7 @@ public class TestAPI } } - /** - * Initial binding substitution happens before optimization so initial bindings can make a semantically always false query into one that can return true - */ - @SuppressWarnings("removal") - @Test public void testInitialBindings5() { + @Test public void testSubstitution5() { // From JENA-500 Query query = QueryFactory.create( "ASK\n" + @@ -236,19 +199,15 @@ public class TestAPI Model model = ModelFactory.createDefaultModel(); model.add(OWL.Thing, RDF.type, OWL.Class); - QuerySolutionMap initialBinding = new QuerySolutionMap(); - initialBinding.add("a", ResourceFactory.createResource("http://constant";)); - try ( QueryExecution qExec = QueryExecution.model(model).query(query).initialBinding(initialBinding).build() ) { + QuerySolutionMap substitution = new QuerySolutionMap(); + substitution.add("a", ResourceFactory.createResource("http://constant";)); + try ( QueryExecution qExec = QueryExecution.model(model).query(query).substitution(substitution).build() ) { boolean result = qExec.execAsk(); assertTrue(result); } } - /** - * Initial binding substitution happens before optimization so initial bindings can make a semantically always false query into one that can return true - */ - @SuppressWarnings("removal") - @Test public void testInitialBindings6() { + @Test public void testSubstitution6() { // From JENA-500 Query query = QueryFactory.create( "ASK\n" + @@ -259,23 +218,23 @@ public class TestAPI Model model = ModelFactory.createDefaultModel(); model.add(OWL.Thing, RDF.type, OWL.Class); - QuerySolutionMap initialBinding = new QuerySolutionMap(); - initialBinding.add("a", ResourceFactory.createTypedLiteral(Boolean.TRUE)); - initialBinding.add("b", ResourceFactory.createTypedLiteral(Boolean.TRUE)); - try ( QueryExecution qExec = QueryExecution.model(model).query(query).initialBinding(initialBinding).build() ) { + QuerySolutionMap substitution = new QuerySolutionMap(); + substitution.add("a", ResourceFactory.createTypedLiteral(Boolean.TRUE)); + substitution.add("b", ResourceFactory.createTypedLiteral(Boolean.TRUE)); + try ( QueryExecution qExec = QueryExecution.model(model).query(query).substitution(substitution).build() ) { boolean result = qExec.execAsk(); assertTrue(result); } } - @Test public void testInitialBindings7() { + @Test public void testSubstitution7() { // JENA-1354 Query query = QueryFactory.create("SELECT DISTINCT ?x WHERE {}"); Dataset ds = DatasetFactory.create(); - QuerySolutionMap initialBinding = new QuerySolutionMap(); - initialBinding.add("a", ResourceFactory.createTypedLiteral(Boolean.TRUE)); + QuerySolutionMap substitution = new QuerySolutionMap(); + substitution.add("a", ResourceFactory.createTypedLiteral(Boolean.TRUE)); try ( QueryExecution qExec = QueryExecution - .dataset(ds).query(query).substitution(initialBinding).build() ) { + .dataset(ds).query(query).substitution(substitution).build() ) { assertFalse(qExec.execSelect().next().contains("a")); } } @@ -340,24 +299,6 @@ public class TestAPI } -// // Execute a test both with and without regex optimization enabled -// // Check the number of results -// private void XexecRegexTest(int expected, String queryString) -// { -// Object b = ARQ.getContext().get(ARQ.enableRegexConstraintsOpt); -// try { -// ARQ.getContext().set(ARQ.enableRegexConstraintsOpt, "false"); -// int count1 = queryAndCount(queryString); -// ARQ.getContext().set(ARQ.enableRegexConstraintsOpt, "true"); -// int count2 = queryAndCount(queryString); -// assertEquals("Different number of results", count1, count2); -// if ( expected >= 0 ) -// assertEquals("Unexpected number of results", expected, count1); -// } finally { -// ARQ.getContext().set(ARQ.enableRegexConstraintsOpt, b); -// } -// } - // ARQ Construct Quad Tests: // Two types of query strings: a) construct triple string; b) construct quad string; // Two kinds of query methods: 1) execTriples(); 2) execQuads(); diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/modify/AbstractTestUpdateGraph.java b/jena-arq/src/test/java/org/apache/jena/sparql/modify/AbstractTestUpdateGraph.java index 932360d5f9..0c4d8ff7ed 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/modify/AbstractTestUpdateGraph.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/modify/AbstractTestUpdateGraph.java @@ -36,9 +36,6 @@ import org.apache.jena.query.QueryException; import org.apache.jena.query.QueryFactory; import org.apache.jena.sparql.core.DatasetGraph; import org.apache.jena.sparql.core.Quad; -import org.apache.jena.sparql.core.Var; -import org.apache.jena.sparql.engine.binding.Binding; -import org.apache.jena.sparql.engine.binding.BindingFactory; import org.apache.jena.sparql.exec.UpdateExec; import org.apache.jena.sparql.graph.GraphFactory; import org.apache.jena.sparql.modify.request.*; @@ -251,31 +248,7 @@ public abstract class AbstractTestUpdateGraph extends AbstractTestUpdateBase assertFalse(graphContains(gStore.getGraph(graphIRI), t)); } - @Test - public void testModifyInitialBindings() { - DatasetGraph gStore = getEmptyDatasetGraph(); - defaultGraphData(gStore, data12()); - namedGraphData(gStore, graphIRI, GraphMemFactory.createDefaultGraph()); - - Binding initialBinding = BindingFactory.binding(Var.alloc("o"), o1); - - UpdateModify modify = new UpdateModify(); - Element element = QueryFactory.createElement("{ ?s <http://example/p> ?o }"); - modify.setElement(element); - - modify.getInsertAcc().addQuad(new Quad(graphIRI, triple1)); - modify.getDeleteAcc().addTriple(SSE.parseTriple("(?s <http://example/p> ?o)")); - modify.getDeleteAcc().addQuad(SSE.parseQuad("(<http://example/graph> ?s <http://example/p> ?o)")); - UpdateAction.execute(modify, gStore, initialBinding); - - assertFalse(graphEmpty(gStore.getGraph(graphIRI))); - assertFalse(graphEmpty(gStore.getDefaultGraph())); - assertTrue(graphContains(gStore.getGraph(graphIRI), triple1)); - assertTrue(graphContains(gStore.getDefaultGraph(), triple2)); - assertFalse(graphContains(gStore.getDefaultGraph(), triple1)); - } - - @Test + @Test public void testCopy() { // Use blank nodes (will expose any problems in serialization when spill // occurs) diff --git a/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/SparqlValidation.java b/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/SparqlValidation.java index 1ceffdbcf2..c6cc0f0b11 100644 --- a/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/SparqlValidation.java +++ b/jena-shacl/src/main/java/org/apache/jena/shacl/engine/constraint/SparqlValidation.java @@ -96,7 +96,6 @@ import org.apache.jena.sparql.util.ModelUtils; } /** return true if the validation is "conforms" */ - @SuppressWarnings("removal") private static boolean validateMap(ValidationContext vCxt, Graph data, Shape shape, Node focusNode, Path path, Node valueNode, Query _query, Map<Parameter, Node> parameterMap, @@ -133,7 +132,7 @@ import org.apache.jena.sparql.util.ModelUtils; DatasetGraph dsg = DatasetGraphFactory.createGeneral(model.getGraph()); // Dataset by links. dsg.addGraph(shapesGraphResource.asNode(), shape.getShapeGraph()); Dataset ds = DatasetFactory.wrap(dsg); - qExec = QueryExecution.create().query(query).dataset(ds).initialBinding(qsm).build(); + qExec = QueryExecution.create().query(query).dataset(ds).substitution(qsm).build(); } // ASK validator. diff --git a/jena-shacl/src/main/java/org/apache/jena/shacl/validation/EvalSparql.java b/jena-shacl/src/main/java/org/apache/jena/shacl/validation/EvalSparql.java index 67e6302d56..244a154058 100644 --- a/jena-shacl/src/main/java/org/apache/jena/shacl/validation/EvalSparql.java +++ b/jena-shacl/src/main/java/org/apache/jena/shacl/validation/EvalSparql.java @@ -50,7 +50,6 @@ public class EvalSparql { private static boolean USE_QueryTransformOps = true; - @SuppressWarnings("removal") public static Collection<Node> evalSparqlComponent(Graph data, Node node, SparqlComponent sparqlComponent) { checkForRequiredParams(data, node, sparqlComponent); @@ -70,7 +69,7 @@ public class EvalSparql { // Done with pre-binding. Model model = ModelFactory.createModelForGraph(data); QuerySolutionMap qsm = parametersToPreBinding(model, node, sparqlComponent.getParams()); - try ( QueryExecution qExec = QueryExecution.create().query(query).model(model).initialBinding(qsm).build() ) { + try ( QueryExecution qExec = QueryExecution.create().query(query).model(model).substitution(qsm).build() ) { return evalSparqlOneVar(qExec); } } diff --git a/jena-tdb1/src/main/java/org/apache/jena/tdb1/modify/UpdateEngineTDB.java b/jena-tdb1/src/main/java/org/apache/jena/tdb1/modify/UpdateEngineTDB.java index 7f1cba7613..4e06efc8ef 100644 --- a/jena-tdb1/src/main/java/org/apache/jena/tdb1/modify/UpdateEngineTDB.java +++ b/jena-tdb1/src/main/java/org/apache/jena/tdb1/modify/UpdateEngineTDB.java @@ -19,7 +19,6 @@ package org.apache.jena.tdb1.modify; import org.apache.jena.sparql.core.DatasetGraph ; -import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.modify.UpdateEngine ; import org.apache.jena.sparql.modify.UpdateEngineFactory ; import org.apache.jena.sparql.modify.UpdateEngineMain ; @@ -29,12 +28,8 @@ import org.apache.jena.tdb1.store.DatasetGraphTDB; public class UpdateEngineTDB extends UpdateEngineMain { - public UpdateEngineTDB(DatasetGraphTDB graphStore, Binding inputBinding, Context context) - { super(graphStore, inputBinding, context) ; } - - // ---- Factory - public static UpdateEngineFactory getFactory() { + public static UpdateEngineFactory getFactory() { return new UpdateEngineFactory() { @Override @@ -43,11 +38,15 @@ public class UpdateEngineTDB extends UpdateEngineMain } @Override - public UpdateEngine create(DatasetGraph graphStore, Binding inputBinding, Context context) { - return new UpdateEngineTDB((DatasetGraphTDB)graphStore, inputBinding, context) ; + public UpdateEngine create(DatasetGraph graphStore, Context context) { + return new UpdateEngineTDB((DatasetGraphTDB)graphStore, context) ; } } ; } public static void register() { UpdateEngineRegistry.get().add(getFactory()) ; } + + public UpdateEngineTDB(DatasetGraphTDB graphStore, Context context) + { super(graphStore, context) ; } + } diff --git a/jena-tdb2/src/main/java/org/apache/jena/tdb2/modify/UpdateEngineTDB.java b/jena-tdb2/src/main/java/org/apache/jena/tdb2/modify/UpdateEngineTDB.java index 8236c0d8c6..0d8a76998c 100644 --- a/jena-tdb2/src/main/java/org/apache/jena/tdb2/modify/UpdateEngineTDB.java +++ b/jena-tdb2/src/main/java/org/apache/jena/tdb2/modify/UpdateEngineTDB.java @@ -19,7 +19,6 @@ package org.apache.jena.tdb2.modify; import org.apache.jena.sparql.core.DatasetGraph; -import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.modify.UpdateEngine; import org.apache.jena.sparql.modify.UpdateEngineFactory; import org.apache.jena.sparql.modify.UpdateEngineMain; @@ -29,10 +28,6 @@ import org.apache.jena.tdb2.store.DatasetGraphTxn; public class UpdateEngineTDB extends UpdateEngineMain { - public UpdateEngineTDB(DatasetGraphTxn graphStore, Binding inputBinding, Context context) - { super(graphStore, inputBinding, context); } - - // ---- Factory public static UpdateEngineFactory getFactory() { return new UpdateEngineFactory() @@ -43,11 +38,14 @@ public class UpdateEngineTDB extends UpdateEngineMain } @Override - public UpdateEngine create(DatasetGraph dataset, Binding inputBinding, Context context) { - return new UpdateEngineTDB((DatasetGraphTxn)dataset, inputBinding, context); + public UpdateEngine create(DatasetGraph dataset, Context context) { + return new UpdateEngineTDB((DatasetGraphTxn)dataset, context); } }; } public static void register() { UpdateEngineRegistry.get().add(getFactory()); } + + public UpdateEngineTDB(DatasetGraphTxn graphStore, Context context) + { super(graphStore, context); } }
