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
The following commit(s) were added to refs/heads/main by this push:
new fde6757336 GH-3622: Substitute: Check there is a query pattern to
transform
fde6757336 is described below
commit fde6757336484a9d08406c34a3a49fa91a84344b
Author: Andy Seaborne <[email protected]>
AuthorDate: Sat Dec 6 09:27:13 2025 +0000
GH-3622: Substitute: Check there is a query pattern to transform
---
.../QuerySyntaxSubstituteScope.java | 11 +++++++-
.../syntax/syntaxtransform/QueryTransformOps.java | 32 +++++++++++++---------
.../syntaxtransform/TestQuerySyntaxSubstitute.java | 26 ++++++++++++++++++
3 files changed, 55 insertions(+), 14 deletions(-)
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QuerySyntaxSubstituteScope.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QuerySyntaxSubstituteScope.java
index d700a8b7b1..74ffa67e8f 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QuerySyntaxSubstituteScope.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QuerySyntaxSubstituteScope.java
@@ -19,6 +19,7 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
import java.util.Collection;
+import java.util.Objects;
import org.apache.jena.query.Query;
import org.apache.jena.sparql.core.Var;
@@ -35,11 +36,19 @@ public class QuerySyntaxSubstituteScope {
* For example, an assigned variables ({@code AS ?var}) can not be replace
by a value.
*/
public static void scopeCheck(Query query, Collection<Var> vars) {
+ Objects.requireNonNull(query);
+ Objects.requireNonNull(vars);
+ if ( vars.isEmpty() )
+ return;
checkLevel(query, vars);
- checkPattern(query.getQueryPattern(), vars);
+ // DESCRIBE might not have a pattern
+ if ( query.getQueryPattern() != null )
+ checkPattern(query.getQueryPattern(), vars);
}
public static void checkPattern(Element element, Collection<Var> vars) {
+ Objects.requireNonNull(element);
+ Objects.requireNonNull(vars);
ElementVisitor visitor = new SubstituteScopeVisitor(vars);
ElementWalker.walk(element, visitor);
}
diff --git
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
index 7de683b917..3ccad2c073 100644
---
a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
+++
b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/QueryTransformOps.java
@@ -42,14 +42,14 @@ import org.apache.jena.sparql.syntax.*;
public class QueryTransformOps {
/**
- * Replace variables in a query by RDF terms.
- * The replacements are added to the return queries SELECT clause (if a
SELECT query).
+ * Replace variables in a query by RDF terms. The replacements are added
to the
+ * return queries SELECT clause if the query is a SELECT query.
*
- * @throws QueryScopeException if the query contains variables used in a
- * way that does not allow substitution (.e.g {@code AS ?var} or used in
- * {@code VALUES}).
- *
- * @see #replaceVars(Query, Map) to replace variables without adding the
replacements to the SELECT clause.
+ * @throws QueryScopeException if the query contains variables used in a
way that
+ * does not allow substitution (.e.g {@code AS ?var} or used in
+ * {@code VALUES}).
+ * @see #replaceVars(Query, Map) to replace variables without adding the
+ * replacements to the SELECT clause.
*/
public static Query syntaxSubstitute(Query input, Map<Var, ? extends Node>
substitutions) {
Query query2 = transformSubstitute(input, substitutions);
@@ -68,13 +68,14 @@ public class QueryTransformOps {
}
/**
- * Transform a query based on a mapping from {@link Var} variable to
replacement {@link Node}.
- * The replacement can be a constant or another variable.
- * This operation does not record the substitution made.
+ * Transform a query based on a mapping from {@link Var} variable to
replacement
+ * {@link Node}. The replacement can be a constant or another variable.
+ * <p>
+ * To change the query to record the substitutions made, use
+ * {@link #syntaxSubstitute(Query,Map)}.
*
- * See {@link #syntaxSubstitute(Query,Map)}
- * @throws QueryScopeException if the query contains variables used in a
- * way that does not allow constant substitution.
+ * @throws QueryScopeException if the query contains variables used in a
way that
+ * does not allow constant substitution.
*/
public static Query replaceVars(Query query, Map<Var, ? extends Node>
substitutions) {
return transformSubstitute(query, substitutions);
@@ -98,6 +99,7 @@ public class QueryTransformOps {
if (! ( node instanceof Var ) )
varsForConst.add(var);
});
+ // Check the transformation is possible (e.g. no replacement of "AS
?var")
QuerySyntaxSubstituteScope.scopeCheck(query, varsForConst);
NodeTransform nodeTransform = new NodeTransformSubst(substitutions);
@@ -482,6 +484,10 @@ public class QueryTransformOps {
}
}
+ /**
+ * Return a new query object with copies of prefixes, base and dataset
description
+ * and shares patterns and results clause (SELECT query) with the original.
+ */
public static Query shallowCopy(Query query) {
QueryShallowCopy copy = new QueryShallowCopy();
query.visit(copy);
diff --git
a/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestQuerySyntaxSubstitute.java
b/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestQuerySyntaxSubstitute.java
index 8b6e54a721..6ac13458fd 100644
---
a/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestQuerySyntaxSubstitute.java
+++
b/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestQuerySyntaxSubstitute.java
@@ -104,6 +104,32 @@ public class TestQuerySyntaxSubstitute {
);
}
+ // ==== Other query forms
+
+ @Test public void syntaxSubstitute_describe_1() {
+ testSubstitute("DESCRIBE ?x", substitutions1, "DESCRIBE :xxx");
+ }
+
+ @Test public void syntaxSubstitute_describe_2() {
+ testSubstitute("DESCRIBE ?x {}", substitutions1, "DESCRIBE :xxx {}");
+ }
+
+ @Test public void syntaxSubstitute_describe_3() {
+ testSubstitute("DESCRIBE ?x ?y { ?x :p ?y }", substitutions1,
"DESCRIBE :xxx ?y { :xxx :p ?y }");
+ }
+
+ @Test public void syntaxSubstitute_construct_1() {
+ testSubstitute("CONSTRUCT {} WHERE {}", substitutions1, "CONSTRUCT {}
WHERE {}");
+ }
+
+ @Test public void syntaxSubstitute_construct_2() {
+ testSubstitute("CONSTRUCT { ?x :p ?y } WHERE {?x :p ?y }",
substitutions1, "CONSTRUCT { :xxx :p ?y } WHERE { :xxx :p ?y }");
+ }
+
+ @Test public void syntaxSubstitute_ask_1() {
+ testSubstitute("ASK { ?x :p ?y}" , substitutions1, "ASK { :xxx :p ?y
}");
+ }
+
// ==== Variable-variable renaming.
// This is always possible so no scoping checks are done.
