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 <[email protected]> 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);
