You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2025/03/05 13:57:26 UTC
(jena) 01/02: Reformat; fix comments
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 6c61eac941d98be140a05f3bfd4bea4bacd19da2
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Sun Mar 2 10:12:21 2025 +0000
Reformat; fix comments
---
.../algebra/optimize/TransformScopeRename.java | 104 +++++++--------
.../java/org/apache/jena/sparql/engine/Rename.java | 1 -
.../java/org/apache/jena/sparql/expr/ExprLib.java | 134 ++++++++++---------
.../java/org/apache/jena/sparql/expr/ExprVar.java | 142 ++++++++++-----------
.../org/apache/jena/sparql/expr/NodeValue.java | 46 +++----
.../apache/jena/sparql/graph/NodeTransform.java | 6 +-
.../jena/sparql/graph/NodeTransformExpr.java | 8 +-
.../apache/jena/sparql/graph/NodeTransformOp.java | 6 +-
.../QuerySyntaxSubstituteScope.java | 2 +-
.../syntaxtransform/TestQuerySyntaxSubstitute.java | 46 +++----
10 files changed, 229 insertions(+), 266 deletions(-)
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformScopeRename.java b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformScopeRename.java
index 18845c10a8..7b66675dee 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformScopeRename.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformScopeRename.java
@@ -18,101 +18,85 @@
package org.apache.jena.sparql.algebra.optimize;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.algebra.OpVisitorByTypeBase ;
-import org.apache.jena.sparql.algebra.TransformCopy ;
-import org.apache.jena.sparql.algebra.Transformer ;
-import org.apache.jena.sparql.algebra.op.OpModifier ;
-import org.apache.jena.sparql.algebra.op.OpProject ;
-import org.apache.jena.sparql.engine.Rename ;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.algebra.OpVisitorByTypeBase;
+import org.apache.jena.sparql.algebra.TransformCopy;
+import org.apache.jena.sparql.algebra.Transformer;
+import org.apache.jena.sparql.algebra.op.OpModifier;
+import org.apache.jena.sparql.algebra.op.OpProject;
+import org.apache.jena.sparql.engine.Rename;
-/** Rename variables so that names can be treated globally.
- * (project) and (group) can hide variables, but we only
- * need to account for OpProject because group is never
- * executed linearly.
+/**
+ * Rename variables so that names can be treated globally. (project) and (group) can
+ * hide variables, but we only need to account for OpProject because group is never
+ * executed linearly.
*/
-public class TransformScopeRename
-{
+public class TransformScopeRename {
// Is there an OpProject before any pattern algebra operators?
// We don't need to rename through this one.
// Track OpProject
- public static Op transform(Op op)
- {
- return new TransformScopeRename$(op).work() ;
+ public static Op transform(Op op) {
+ return new TransformScopeRename$(op).work();
}
- private static class TransformScopeRename$
- {
- private boolean outerMostOpProject = false ;
- private int projectRenameDepth = 0 ;
- private int projectCount = 0 ;
-
- private Op op ;
+ private static class TransformScopeRename$ {
+ private boolean outerMostOpProject = false;
+ private int projectRenameDepth = 0;
+ private int projectCount = 0;
- public TransformScopeRename$(Op op)
- {
- this.op = op ;
- {
- Op op2 = op ;
- while( op2 instanceof OpModifier )
- {
- // If already true ...
- if ( op2 instanceof OpProject )
- {
- outerMostOpProject = true ;
- break ;
- }
- op2 = ((OpModifier)op2).getSubOp() ;
+ private Op op;
+
+ public TransformScopeRename$(Op op) {
+ this.op = op;
+ Op op2 = op;
+ while (op2 instanceof OpModifier) {
+ // If already true ...
+ if ( op2 instanceof OpProject ) {
+ outerMostOpProject = true;
+ break;
}
+ op2 = ((OpModifier)op2).getSubOp();
}
// Set the project counter: renaming begins when this hits one.
// Set 2 to there is a project in the top-most OpModifers.
// This does not cause a rename so start renaming at depth .
// otherwise rename from depth 1.
if ( outerMostOpProject )
- projectRenameDepth = 2 ;
+ projectRenameDepth = 2;
else
projectRenameDepth = 1;
}
-
- public Op work()
- {
- return Transformer.transform(new RenameByScope(), op, new BeforeWalk(), new AfterWalk()) ;
- }
+ public Op work() {
+ return Transformer.transform(new RenameByScope(), op, new BeforeWalk(), new AfterWalk());
+ }
- private class BeforeWalk extends OpVisitorByTypeBase
- {
+ private class BeforeWalk extends OpVisitorByTypeBase {
@Override
- public void visit(OpProject opProject)
- {
- projectCount++ ;
+ public void visit(OpProject opProject) {
+ projectCount++;
}
}
- private class AfterWalk extends OpVisitorByTypeBase
- {
+ private class AfterWalk extends OpVisitorByTypeBase {
@Override
- public void visit(OpProject opProject)
- {
- --projectCount ;
+ public void visit(OpProject opProject) {
+ --projectCount;
}
}
- private class RenameByScope extends TransformCopy
- {
+ private class RenameByScope extends TransformCopy {
@Override
- public Op transform(OpProject opProject, Op subOp)
- {
+ public Op transform(OpProject opProject, Op subOp) {
// Need to find the right project
- // We already stripped outer modifier.
+ // We already stripped outer modifier.
if ( projectCount >= projectRenameDepth )
// Inner ones already done.
- subOp = Rename.renameVars(subOp, opProject.getVars()) ;
- return super.transform(opProject, subOp) ;
+ subOp = Rename.renameVars(subOp, opProject.getVars());
+ return super.transform(opProject, subOp);
}
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/Rename.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/Rename.java
index daad7e44f6..3e688ead04 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/Rename.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/Rename.java
@@ -139,7 +139,6 @@ public class Rename {
}
-
// ---- Transforms that do the renaming and unrenaming.
static class RenameNode implements NodeTransform {
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java
index 5e7b443212..139988ad29 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java
@@ -93,111 +93,103 @@ public class ExprLib
/** transform an expression that may involve aggregates into one that just uses the variable for the aggregate */
- public static Expr replaceAggregateByVariable(Expr expr)
- {
- return ExprTransformer.transform(replaceAgg, expr) ;
+ public static Expr replaceAggregateByVariable(Expr expr) {
+ return ExprTransformer.transform(replaceAgg, expr);
}
// /** transform expressions that may involve aggregates into one that just uses the variable for the aggregate */
// public static ExprList replaceAggregateByVariable(ExprList exprs)
// {
// return ExprTransformer.transform(replaceAgg, exprs) ;
-// }
+//}
- private static ExprTransform replaceAgg = new ExprTransformCopy()
- {
+ private static ExprTransform replaceAgg = new ExprTransformCopy() {
@Override
- public Expr transform(ExprAggregator eAgg)
- { return eAgg.getAggVar() ; }
- } ;
+ public Expr transform(ExprAggregator eAgg) {
+ return eAgg.getAggVar();
+ }
+ };
- /** Decide whether an expression is safe for using a graph substitution.
- * Need to be careful about value-like tests when the graph is not
- * matched in a value fashion.
+ /**
+ * Decide whether an expression is safe for using a graph substitution. Need to
+ * be careful about value-like tests when the graph is not matched in a value
+ * fashion.
*/
- public static boolean isAssignmentSafeEquality(Expr expr)
- {
- return isAssignmentSafeEquality(expr, false, false) ;
+ public static boolean isAssignmentSafeEquality(Expr expr) {
+ return isAssignmentSafeEquality(expr, false, false);
}
/**
- * @param graphHasStringEquality True if the graph triple matching equates xsd:string and plain literal
- * @param graphHasNumercialValueEquality True if the graph triple matching equates numeric values
+ * @param graphHasStringEquality True if the graph triple matching equates
+ * xsd:string and plain literal
+ * @param graphHasNumercialValueEquality True if the graph triple matching
+ * equates numeric values
*/
- public static boolean isAssignmentSafeEquality(Expr expr, boolean graphHasStringEquality, boolean graphHasNumercialValueEquality)
- {
+ public static boolean isAssignmentSafeEquality(Expr expr, boolean graphHasStringEquality, boolean graphHasNumercialValueEquality) {
if ( !(expr instanceof E_Equals) && !(expr instanceof E_SameTerm) )
- return false ;
+ return false;
// Corner case: sameTerm is false for string/plain literal,
// but true in the graph.
- ExprFunction2 eq = (ExprFunction2)expr ;
- Expr left = eq.getArg1() ;
- Expr right = eq.getArg2() ;
- Var var = null ;
- NodeValue constant = null ;
-
- if ( left.isVariable() && right.isConstant() )
- {
- var = left.asVar() ;
- constant = right.getConstant() ;
- }
- else if ( right.isVariable() && left.isConstant() )
- {
- var = right.asVar() ;
- constant = left.getConstant() ;
+ ExprFunction2 eq = (ExprFunction2)expr;
+ Expr left = eq.getArg1();
+ Expr right = eq.getArg2();
+ Var var = null;
+ NodeValue constant = null;
+
+ if ( left.isVariable() && right.isConstant() ) {
+ var = left.asVar();
+ constant = right.getConstant();
+ } else if ( right.isVariable() && left.isConstant() ) {
+ var = right.asVar();
+ constant = left.getConstant();
}
// Not between a variable and a constant
if ( var == null || constant == null )
- return false ;
+ return false;
- if ( ! constant.isLiteral() )
- // URIs, bNodes. Any bNode will have come from a substitution - not legal syntax in filters
- return true ;
+ if ( !constant.isLiteral() )
+ // URIs, bNodes. Any bNode will have come from a substitution - not legal
+ // syntax in filters
+ return true;
- if (expr instanceof E_SameTerm)
- {
+ if ( expr instanceof E_SameTerm ) {
if ( graphHasStringEquality && constant.isString() )
// Graph is not same term
- return false ;
+ return false;
if ( graphHasNumercialValueEquality && constant.isNumber() )
- return false ;
- return true ;
+ return false;
+ return true;
}
- // Final check for "=" where a FILTER = can do value matching when the graph does not.
- if ( expr instanceof E_Equals )
- {
- if ( ! graphHasStringEquality && constant.isString() )
- return false ;
- if ( ! graphHasNumercialValueEquality && constant.isNumber() )
- return false ;
- return true ;
+ // Final check for "=" where a FILTER = can do value matching when the graph
+ // does not.
+ if ( expr instanceof E_Equals ) {
+ if ( !graphHasStringEquality && constant.isString() )
+ return false;
+ if ( !graphHasNumercialValueEquality && constant.isNumber() )
+ return false;
+ return true;
}
// Unreachable.
- throw new ARQInternalErrorException() ;
+ throw new ARQInternalErrorException();
}
- /** Some "functions" are non-deterministic (unstable) -
- * calling them with the same arguments
- * does not yields the same answer each time.
- * Therefore how and when they are called
- * matters.
- *
- * Functions: RAND, UUID, StrUUID, BNode
- *
- * NOW() is safe.
+ /**
+ * Some "functions" are non-deterministic (unstable) - calling them with the same
+ * arguments does not yields the same answer each time. Therefore how and when
+ * they are called matters. Functions: RAND, UUID, StrUUID, BNode NOW() is safe.
*/
public static boolean isStable(Expr expr) {
try {
- Walker.walk(expr, exprVisitorCheckForNonFunctions) ;
- return true ;
- } catch ( ExprUnstable ex ) {
- return false ;
+ Walker.walk(expr, exprVisitorCheckForNonFunctions);
+ return true;
+ } catch (ExprUnstable ex) {
+ return false;
}
}
@@ -212,22 +204,24 @@ public class ExprLib
if ( exprFn instanceof Unstable )
throw new ExprUnstable();
}
- } ;
+ };
private static class ExprUnstable extends ExprException {
// Filling in the stack trace is the expensive part of
// an exception but we don't need it.
@Override
- public Throwable fillInStackTrace() { return this ; }
+ public Throwable fillInStackTrace() {
+ return this;
+ }
}
/** Go from a node to an expression. */
public static Expr nodeToExpr(Node n) {
if ( n.isVariable() )
- return new ExprVar(n) ;
+ return new ExprVar(n);
if ( n.isNodeTriple() )
return new ExprTripleTerm(n);
- return NodeValue.makeNode(n) ;
+ return NodeValue.makeNode(n);
}
public static Expr rewriteTriple(Triple t) {
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVar.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVar.java
index 0147fa18d2..79ee47a5d5 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVar.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprVar.java
@@ -18,118 +18,112 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.atlas.io.IndentedWriter ;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.query.Query ;
-import org.apache.jena.sparql.ARQInternalErrorException ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import org.apache.jena.atlas.io.IndentedWriter;
+import org.apache.jena.graph.Node;
+import org.apache.jena.query.Query;
+import org.apache.jena.sparql.ARQInternalErrorException;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** An expression that is a variable in an expression. */
-
+
public class ExprVar extends ExprNode
{
// AKA ExprFunction0
- protected Var varNode = null ;
-
- public ExprVar(String name) { varNode = Var.alloc(name) ; }
- public ExprVar(Node n)
- {
- if ( ! n.isVariable() )
- throw new ARQInternalErrorException("Attempt to create a NodeVar from a non variable Node: "+n) ;
- varNode = Var.alloc(n) ;
+ protected Var varNode = null;
+
+ public ExprVar(String name) { varNode = Var.alloc(name); }
+
+ public ExprVar(Node n) {
+ if ( !n.isVariable() )
+ throw new ARQInternalErrorException("Attempt to create a NodeVar from a non-variable Node: " + n);
+ varNode = Var.alloc(n);
}
-
- public ExprVar(Var v)
- {
- varNode = v ;
+
+ public ExprVar(Var v) {
+ varNode = v;
}
-
+
@Override
- public NodeValue eval(Binding binding, FunctionEnv env)
- {
- return eval(varNode, binding, env) ;
+ public NodeValue eval(Binding binding, FunctionEnv env) {
+ return eval(varNode, binding, env);
}
- static NodeValue eval(Var v, Binding binding, FunctionEnv env)
- {
+ static NodeValue eval(Var v, Binding binding, FunctionEnv env) {
if ( binding == null )
- throw new VariableNotBoundException("Not bound: (no binding): "+v) ;
- Node nv = binding.get(v) ;
+ throw new VariableNotBoundException("Not bound: (no binding): " + v);
+ Node nv = binding.get(v);
if ( nv == null )
- throw new VariableNotBoundException("Not bound: variable "+v) ;
+ throw new VariableNotBoundException("Not bound: variable " + v);
// Wrap as a NodeValue.
- return NodeValue.makeNode(nv) ;
+ return NodeValue.makeNode(nv);
}
-
+
@Override
- public Expr copySubstitute(Binding binding)
- {
- Var v = varNode ;
+ public Expr copySubstitute(Binding binding) {
+ Var v = varNode;
if ( binding == null || !binding.contains(v) )
- return new ExprVar(v) ;
+ return new ExprVar(v);
Node v2 = binding.get(v);
- return v2.isVariable() ? new ExprVar(v2) : eval(binding, null) ;
+ return v2.isVariable() ? new ExprVar(v2) : eval(binding, null);
}
-
+
@Override
- public Expr applyNodeTransform(NodeTransform transform)
- {
- Node node = transform.apply(varNode) ;
- if ( Var.isVar(node))
- return new ExprVar(Var.alloc(node)) ;
- return NodeValue.makeNode(node) ;
+ public Expr applyNodeTransform(NodeTransform transform) {
+ Node node = transform.apply(varNode);
+ if ( Var.isVar(node) )
+ return new ExprVar(Var.alloc(node));
+ return NodeValue.makeNode(node);
}
-
- public Expr copy(Var v) { return new ExprVar(v) ; }
-
-
+
+ public Expr copy(Var v) { return new ExprVar(v); }
+
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
-
- public Expr apply(ExprTransform transform) {
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+
+ public Expr apply(ExprTransform transform) {
if ( transform == null )
- throw new NullPointerException() ;
- return transform.transform(this) ; }
-
+ throw new NullPointerException();
+ return transform.transform(this); }
+
public void format(Query query, IndentedWriter out)
{
- out.print('?') ;
- out.print(varNode.getName()) ;
+ out.print('?');
+ out.print(varNode.getName());
}
-
+
@Override
- public int hashCode() { return varNode.hashCode() ; }
-
+ public int hashCode() { return varNode.hashCode(); }
+
@Override
public boolean equals(Expr other, boolean bySyntax) {
- if ( other == null ) return false ;
- if ( this == other ) return true ;
+ if ( other == null ) return false;
+ if ( this == other ) return true;
if ( ! ( other instanceof ExprVar ) )
- return false ;
- ExprVar nvar = (ExprVar)other ;
- return getVarName().equals(nvar.getVarName()) ;
+ return false;
+ ExprVar nvar = (ExprVar)other;
+ return getVarName().equals(nvar.getVarName());
}
-
+
@Override
- public boolean isVariable() { return true ; }
+ public boolean isVariable() { return true; }
/** @return Returns the name. */
@Override
- public String getVarName() { return varNode.getName() ; }
+ public String getVarName() { return varNode.getName(); }
@Override
- public ExprVar getExprVar() { return this ; }
+ public ExprVar getExprVar() { return this; }
@Override
- public Var asVar() { return varNode ; }
- public Node getAsNode() { return varNode ; }
-
-
- public String toPrefixString() { return varNode.toString() ; }
+ public Var asVar() { return varNode; }
+ public Node getAsNode() { return varNode; }
+
+
+ public String toPrefixString() { return varNode.toString(); }
// As an expression (aggregators override this).
- public String asSparqlExpr() { return varNode.toString() ; }
+ public String asSparqlExpr() { return varNode.toString(); }
// ??? Just use format?
@Override
- public String toString() { return varNode.toString() ; }
+ public String toString() { return varNode.toString(); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
index aaad999235..476eb64721 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
@@ -246,37 +246,33 @@ public abstract class NodeValue extends ExprNode
// ----------------------------------------------------------------
// ---- Construct NodeValue from graph nodes
- public static NodeValue makeNode(Node n)
- {
- return nodeToNodeValue(n);
+ public static NodeValue makeNode(Node node) {
+ return nodeToNodeValue(node);
}
- public static NodeValue makeNode(String lexicalForm, RDFDatatype dtype)
- {
+ public static NodeValue makeNode(String lexicalForm, RDFDatatype dtype) {
Node n = NodeFactory.createLiteralDT(lexicalForm, dtype);
return NodeValue.makeNode(n);
}
// Convenience - knows that lang tags aren't allowed with datatypes.
- public static NodeValue makeNode(String lexicalForm, String langTag, Node datatype)
- {
- String uri = (datatype==null) ? null : datatype.getURI();
- return makeNode(lexicalForm, langTag, uri);
+ public static NodeValue makeNode(String lexicalForm, String langTag, Node datatype) {
+ String uri = (datatype == null) ? null : datatype.getURI();
+ return makeNode(lexicalForm, langTag, uri);
}
- public static NodeValue makeNode(String lexicalForm, String langTag, String datatype)
- {
+ public static NodeValue makeNode(String lexicalForm, String langTag, String datatype) {
if ( datatype != null && datatype.equals("") )
datatype = null;
if ( langTag != null && datatype != null )
// raise??
- Log.warn(NodeValue.class, "Both lang tag and datatype defined (lexcial form '"+lexicalForm+"')");
+ Log.warn(NodeValue.class, "Both lang tag and datatype defined (lexcial form '" + lexicalForm + "')");
Node n = null;
if ( langTag != null )
n = NodeFactory.createLiteralLang(lexicalForm, langTag);
- else if ( datatype != null) {
+ else if ( datatype != null ) {
RDFDatatype dType = TypeMapper.getInstance().getSafeTypeByName(datatype);
n = NodeFactory.createLiteralDT(lexicalForm, dType);
} else
@@ -353,16 +349,16 @@ public abstract class NodeValue extends ExprNode
// ----------------------------------------------------------------
// ---- Expr interface
- @Override
- public NodeValue eval(Binding binding, FunctionEnv env)
- { return this; }
+ @Override
+ public NodeValue eval(Binding binding, FunctionEnv env) {
+ return this;
+ }
- // NodeValues are immutable so no need to duplicate.
- @Override
- public Expr copySubstitute(Binding binding)
- {
- return this;
- }
+ // NodeValues are immutable so no need to duplicate.
+ @Override
+ public Expr copySubstitute(Binding binding) {
+ return this;
+ }
@Override
public Expr applyNodeTransform(NodeTransform transform)
@@ -524,16 +520,14 @@ public abstract class NodeValue extends ExprNode
public boolean isTime() { return false; }
public boolean isDuration() { return false; }
- public boolean isYearMonthDuration()
- {
+ public boolean isYearMonthDuration() {
if ( ! isDuration() ) return false;
Duration dur = getDuration();
return ( dur.isSet(YEARS) || dur.isSet(MONTHS) ) &&
! dur.isSet(DAYS) && ! dur.isSet(HOURS) && ! dur.isSet(MINUTES) && ! dur.isSet(SECONDS);
}
- public boolean isDayTimeDuration()
- {
+ public boolean isDayTimeDuration() {
if ( ! isDuration() ) return false;
Duration dur = getDuration();
return !dur.isSet(YEARS) && ! dur.isSet(MONTHS) &&
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransform.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransform.java
index 90de6fe353..b10f1571fe 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransform.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransform.java
@@ -22,8 +22,6 @@ import java.util.function.Function;
import org.apache.jena.graph.Node ;
-/** Convert nodes to nodes - Vars may need to be translated into Vars. */
+/** Convert nodes to nodes */
@FunctionalInterface
-public interface NodeTransform extends Function<Node, Node>
-{
-}
+public interface NodeTransform extends Function<Node, Node> {}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformExpr.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformExpr.java
index 81a110289b..eda5da1da0 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformExpr.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformExpr.java
@@ -24,7 +24,8 @@ import org.apache.jena.sparql.algebra.walker.ApplyTransformVisitor;
import org.apache.jena.sparql.core.Var;
import org.apache.jena.sparql.expr.*;
-/** An {@link ExprTransform} that applies a {@link NodeTransform}
+/**
+ * An {@link ExprTransform} that applies a {@link NodeTransform}
* to {@link NodeValue} and {@link ExprVar} inside expressions.
* <p>
* This does not transform triple patterns in {@link ExprFunctionOp}
@@ -34,9 +35,8 @@ import org.apache.jena.sparql.expr.*;
*/
public class NodeTransformExpr extends ExprTransformCopy {
private final NodeTransform transform ;
- public NodeTransformExpr(NodeTransform transform)
- {
- this.transform = transform ;
+ public NodeTransformExpr(NodeTransform transform) {
+ this.transform = transform;
}
@Override
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformOp.java
index bb2380f187..fdb14e69d5 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformOp.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/NodeTransformOp.java
@@ -35,8 +35,8 @@ import org.apache.jena.sparql.core.Var ;
import org.apache.jena.sparql.core.VarExprList ;
import org.apache.jena.sparql.path.Path ;
-/** A {@link Transform} that applies a {@link NodeTransform}
- * to graph patterns.
+/**
+ * A {@link Transform} that applies a {@link NodeTransform} to graph patterns.
* <p>
* This does not transform expressions. That is done by {@link NodeTransformExpr}.
*
@@ -44,7 +44,7 @@ import org.apache.jena.sparql.path.Path ;
*/
class NodeTransformOp extends TransformCopy {
- // This finds everywhere that nodes can lurk in an algebra expression:
+ // This finds everywhere that nodes can occur in an algebra expression:
// BGPs, paths, triples, quads, service
// GRAPH, GRAPH{} (DatasetNames)
// OrderBy, GroupBy
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 923396daab..d700a8b7b1 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
@@ -61,7 +61,7 @@ public class QuerySyntaxSubstituteScope {
private static void checkAssignment(String context, Collection<Var> vars, Var assignedVar) {
if ( vars.contains(assignedVar) )
- reject("BIND", assignedVar);
+ reject(context, assignedVar);
}
private static void reject(String elementName, Var badVar) {
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 03af530ff9..16f7c473d7 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
@@ -37,79 +37,79 @@ public class TestQuerySyntaxSubstitute {
private static Map<Var, Node> substitutions2 = Map.of(Var.alloc("x"), NodeFactory.createURI("http://example/xxx"),
Var.alloc("y"), NodeFactory.createURI("http://example/yyy"));
- @Test public void syntaxSubstitue_01() {
- testSubstitue("SELECT * { ?x :p ?z }", substitutions1,
+ @Test public void syntaxSubstitute_01() {
+ testSubstitute("SELECT * { ?x :p ?z }", substitutions1,
"SELECT ?z (:xxx AS ?x) { :xxx :p ?z }"
);
}
- @Test public void syntaxSubstitue_02() {
- testSubstitue("SELECT ?x { ?x :p ?z }", substitutions1,
+ @Test public void syntaxSubstitute_02() {
+ testSubstitute("SELECT ?x { ?x :p ?z }", substitutions1,
"SELECT (:xxx AS ?x) { :xxx :p ?z }"
);
}
- @Test public void syntaxSubstitue_03() {
- testSubstitue("SELECT ?z { :a :p ?z }", substitutions1,
+ @Test public void syntaxSubstitute_03() {
+ testSubstitute("SELECT ?z { :a :p ?z }", substitutions1,
"SELECT ?z (:xxx AS ?x) { :a :p ?z }"
);
}
- @Test public void syntaxSubstitue_04() {
- testSubstitue("SELECT ?x ?z { ?x :p ?z }", substitutions1,
+ @Test public void syntaxSubstitute_04() {
+ testSubstitute("SELECT ?x ?z { ?x :p ?z }", substitutions1,
"SELECT (:xxx AS ?x) ?z { :xxx :p ?z }"
);
}
- @Test public void syntaxSubstitue_10() {
- testSubstitue("SELECT ?y ?x { ?x :p ?y }", substitutions2,
+ @Test public void syntaxSubstitute_10() {
+ testSubstitute("SELECT ?y ?x { ?x :p ?y }", substitutions2,
"SELECT (:yyy AS ?y) (:xxx AS ?x) { :xxx :p :yyy }"
);
}
- @Test public void syntaxSubstitue_11() {
- testSubstitue("SELECT ?y ?p ?x { ?x ?p ?y }", substitutions2,
+ @Test public void syntaxSubstitute_11() {
+ testSubstitute("SELECT ?y ?p ?x { ?x ?p ?y }", substitutions2,
"SELECT (:yyy AS ?y) ?p (:xxx AS ?x) { :xxx ?p :yyy }"
);
}
// GH-2799: Sub-queries not yet ready.
// // Sub-query visible variable.
-// @Test public void syntaxSubstitue_12() {
-// testSubstitue("SELECT * { ?s ?p ?o { SELECT ?x { ?x :p ?y } } }", substitutions1,
+// @Test public void syntaxSubstitute_12() {
+// testSubstitute("SELECT * { ?s ?p ?o { SELECT ?x { ?x :p ?y } } }", substitutions1,
// "SELECT (:yyy AS ?y) ?p (:xxx AS ?x) { ?s ?p ?o { SELECT * { :xxx :p ?y } }}"
// );
// }
//
// // Sub-query hidden variable.
-// @Test public void syntaxSubstitue_13() {
-// testSubstitue("SELECT * { ?s ?p ?o { SELECT ?y { ?x :p ?y } } }", substitutions1,
+// @Test public void syntaxSubstitute_13() {
+// testSubstitute("SELECT * { ?s ?p ?o { SELECT ?y { ?x :p ?y } } }", substitutions1,
// "SELECT ?s ?p ?o (:xxx AS ?x) { ?s ?p ?o { SELECT * { :xxx :p ?y } }}"
// );
// }
//
// // Multi-level variable.
-// @Test public void syntaxSubstitue_14() {
-// testSubstitue("SELECT * { ?x ?p ?o { SELECT * { ?x :p ?y } } }", substitutions2,
+// @Test public void syntaxSubstitute_14() {
+// testSubstitute("SELECT * { ?x ?p ?o { SELECT * { ?x :p ?y } } }", substitutions2,
// "" //"SELECT (:yyy AS ?y) ?p (:xxx AS ?x) { ?s ?p ?o { SELECT * { :xxx :p ?y } }}"
// );
// }
- @Test public void syntaxSubstitue_50() {
+ @Test public void syntaxSubstitute_50() {
assertThrows(QueryScopeException.class, ()->
- testSubstitue("SELECT (456 AS ?x) { ?y :p ?z }", substitutions1,
+ testSubstitute("SELECT (456 AS ?x) { ?y :p ?z }", substitutions1,
""
));
}
- @Test public void syntaxSubstitue_51() {
+ @Test public void syntaxSubstitute_51() {
assertThrows(QueryScopeException.class, ()->
- testSubstitue("SELECT * { ?y :p ?z BIND(789 AS ?x)}", substitutions1,
+ testSubstitute("SELECT * { ?y :p ?z BIND(789 AS ?x)}", substitutions1,
""
));
}
- private void testSubstitue(String qs, Map<Var, Node> substitutions, String outcome) {
+ private void testSubstitute(String qs, Map<Var, Node> substitutions, String outcome) {
String prologue = "PREFIX : <http://example/> ";
String queryString = prologue+qs;
Query query = QueryFactory.create(queryString);