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 2024/08/24 16:09:53 UTC
(jena) branch main updated (1ffb840a0e -> f63360c4f0)
This is an automated email from the ASF dual-hosted git repository.
andy pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/jena.git
from 1ffb840a0e Bump wait-on from 7.2.0 to 8.0.0 in /jena-fuseki2/jena-fuseki-ui
new e7567d8806 Update white space
new f63360c4f0 GH-2650: Fix for substitution into aggregates
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../org/apache/jena/sparql/expr/ExprFunction0.java | 60 ++++---
.../org/apache/jena/sparql/expr/ExprFunction1.java | 70 ++++-----
.../org/apache/jena/sparql/expr/ExprFunction2.java | 34 ++--
.../org/apache/jena/sparql/expr/ExprFunction3.java | 118 +++++++-------
.../org/apache/jena/sparql/expr/ExprFunctionN.java | 119 +++++++-------
.../apache/jena/sparql/expr/ExprFunctionOp.java | 78 ++++-----
.../ApplyElementTransformVisitor.java | 174 ++++++++++-----------
.../ElementTransformCleanGroupsOfOne.java | 66 ++++----
.../syntaxtransform/ElementTransformCopyBase.java | 88 +++++------
.../syntaxtransform/ElementTransformIdentity.java | 50 +++---
.../syntaxtransform/ElementTransformSubst.java | 112 ++++++-------
.../syntax/syntaxtransform/ElementTransformer.java | 38 ++---
.../ExprTransformApplyElementTransform.java | 22 +--
.../syntaxtransform/ExprTransformNodeElement.java | 69 ++++----
.../syntax/syntaxtransform/NodeTransformSubst.java | 20 +--
.../syntax/syntaxtransform/QueryTransformOps.java | 25 +--
.../syntaxtransform/TransformElementLib.java | 52 +++---
.../syntax/syntaxtransform/UpdateTransformOps.java | 170 ++++++++++----------
.../apache/jena/sparql/algebra/TestOpAsQuery.java | 42 +++--
.../syntaxtransform/TestSyntaxTransform.java | 21 +++
20 files changed, 708 insertions(+), 720 deletions(-)
(jena) 01/02: Update white space
Posted by an...@apache.org.
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 e7567d88067cefbfdaccb05baf4befe0e54ce5b7
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Tue Aug 20 21:59:33 2024 +0100
Update white space
---
.../org/apache/jena/sparql/expr/ExprFunction0.java | 60 ++++---
.../org/apache/jena/sparql/expr/ExprFunction1.java | 70 ++++-----
.../org/apache/jena/sparql/expr/ExprFunction2.java | 34 ++--
.../org/apache/jena/sparql/expr/ExprFunction3.java | 118 +++++++-------
.../org/apache/jena/sparql/expr/ExprFunctionN.java | 119 +++++++-------
.../apache/jena/sparql/expr/ExprFunctionOp.java | 78 ++++-----
.../ApplyElementTransformVisitor.java | 174 ++++++++++-----------
.../ElementTransformCleanGroupsOfOne.java | 66 ++++----
.../syntaxtransform/ElementTransformCopyBase.java | 88 +++++------
.../syntaxtransform/ElementTransformIdentity.java | 50 +++---
.../syntaxtransform/ElementTransformSubst.java | 112 ++++++-------
.../syntax/syntaxtransform/ElementTransformer.java | 38 ++---
.../ExprTransformApplyElementTransform.java | 22 +--
.../syntaxtransform/ExprTransformNodeElement.java | 4 +-
.../syntax/syntaxtransform/NodeTransformSubst.java | 20 +--
.../syntax/syntaxtransform/QueryTransformOps.java | 10 +-
.../syntaxtransform/TransformElementLib.java | 52 +++---
.../syntax/syntaxtransform/UpdateTransformOps.java | 170 ++++++++++----------
18 files changed, 624 insertions(+), 661 deletions(-)
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java
index 8175b1279b..e92e2b33b7 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction0.java
@@ -18,56 +18,52 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+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 constant (does not depend on evaluating a sub expression). */
public abstract class ExprFunction0 extends ExprFunction
{
- protected ExprFunction0(String fName) { this(fName, null) ; }
-
- protected ExprFunction0(String fName, String opSign)
- {
- super(fName, opSign) ;
+ protected ExprFunction0(String fName) { this(fName, null); }
+
+ protected ExprFunction0(String fName, String opSign) {
+ super(fName, opSign);
}
@Override
- public Expr getArg(int i) { return null ; }
-
+ public Expr getArg(int i) { return null; }
+
@Override
- public int hashCode() { return getFunctionSymbol().hashCode() ; }
+ public int hashCode() { return getFunctionSymbol().hashCode(); }
@Override
- public int numArgs() { return 0 ; }
-
+ public int numArgs() { return 0; }
+
// ---- Evaluation
-
+
@Override
- final public NodeValue eval(Binding binding, FunctionEnv env)
- {
- return eval(env) ;
+ final public NodeValue eval(Binding binding, FunctionEnv env) {
+ return eval(env);
}
-
- public abstract NodeValue eval(FunctionEnv env) ;
-
+
+ public abstract NodeValue eval(FunctionEnv env) ;
+
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- // Nothing to transform.
- return copy() ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ // Nothing to transform.
+ return copy();
}
-
- public abstract Expr copy() ;
-
+
+ public abstract Expr copy();
+
@Override
- final public Expr copySubstitute(Binding binding)
- {
- return copy() ;
+ final public Expr copySubstitute(Binding binding) {
+ return copy();
}
-
+
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform) { return transform.transform(this) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform) { return transform.transform(this); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
index 433552e68b..d0d0bef80d 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction1.java
@@ -18,81 +18,75 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.atlas.lib.Lib ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import org.apache.jena.atlas.lib.Lib;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** A function that has a single argument */
public abstract class ExprFunction1 extends ExprFunction
{
- protected final Expr expr ;
+ protected final Expr expr;
- protected ExprFunction1(Expr expr, String fName) { this(expr, fName, null) ; }
+ protected ExprFunction1(Expr expr, String fName) { this(expr, fName, null); }
- protected ExprFunction1(Expr expr, String fName, String opSign)
- {
- super(fName, opSign) ;
- this.expr = expr ;
+ protected ExprFunction1(Expr expr, String fName, String opSign) {
+ super(fName, opSign);
+ this.expr = expr;
}
- public Expr getArg() { return expr ; }
+ public Expr getArg() { return expr; }
@Override
- public Expr getArg(int i)
- {
+ public Expr getArg(int i) {
if ( i == 1 )
- return expr ;
- return null ;
+ return expr;
+ return null;
}
@Override
- public int hashCode()
- {
- return getFunctionSymbol().hashCode() ^ Lib.hashCodeObject(expr) ;
+ public int hashCode() {
+ return getFunctionSymbol().hashCode() ^ Lib.hashCodeObject(expr);
}
@Override
- public int numArgs() { return 1 ; }
+ public int numArgs() { return 1; }
// ---- Evaluation
@Override
- final public NodeValue eval(Binding binding, FunctionEnv env)
- {
- NodeValue s = evalSpecial(binding, env) ;
+ final public NodeValue eval(Binding binding, FunctionEnv env) {
+ NodeValue s = evalSpecial(binding, env);
if ( s != null )
- return s ;
+ return s;
- NodeValue x = eval(binding, env, expr) ;
- return eval(x, env) ;
+ NodeValue x = eval(binding, env, expr);
+ return eval(x, env);
}
// Ideally, we would only have the FunctionEnv form but that break compatibility.
- public NodeValue eval(NodeValue v, FunctionEnv env) { return eval(v) ; }
- public abstract NodeValue eval(NodeValue nv) ;
+ public NodeValue eval(NodeValue v, FunctionEnv env) { return eval(v); }
+ public abstract NodeValue eval(NodeValue nv);
// Allow special cases.
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; }
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null; }
@Override
- final public Expr copySubstitute(Binding binding)
- {
- Expr e = (expr == null ? null : expr.copySubstitute(binding)) ;
- return copy(e) ;
+ final public Expr copySubstitute(Binding binding) {
+ Expr e = (expr == null ? null : expr.copySubstitute(binding));
+ return copy(e);
}
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- Expr e = (expr == null ? null : expr.applyNodeTransform(transform)) ;
- return copy(e) ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ Expr e = (expr == null ? null : expr.applyNodeTransform(transform));
+ return copy(e);
}
- public abstract Expr copy(Expr expr) ;
+ public abstract Expr copy(Expr expr);
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr sub) { return transform.transform(this, sub) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, Expr sub) { return transform.transform(this, sub); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java
index 06cb6ea40f..4688bde81a 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction2.java
@@ -25,39 +25,39 @@ import org.apache.jena.sparql.graph.NodeTransform;
/** A function of two arguments */
-
+
public abstract class ExprFunction2 extends ExprFunction
{
protected final Expr expr1 ;
protected final Expr expr2 ;
protected ExprFunction2(Expr expr1, Expr expr2, String fName) { this(expr1, expr2, fName, null) ; }
-
+
protected ExprFunction2(Expr expr1, Expr expr2, String fName, String opSign)
{
super(fName, opSign) ;
this.expr1 = expr1 ;
this.expr2 = expr2 ;
}
-
+
public Expr getArg1() { return expr1 ; }
public Expr getArg2() { return expr2 ; }
-
+
@Override
public Expr getArg(int i)
{
if ( i == 1 )
- return expr1 ;
+ return expr1 ;
if ( i == 2 )
- return expr2 ;
+ return expr2 ;
return null ;
}
-
+
@Override
public int numArgs() { return 2 ; }
-
+
// ---- Evaluation
-
+
@Override
public int hashCode()
{
@@ -72,18 +72,18 @@ public abstract class ExprFunction2 extends ExprFunction
NodeValue s = evalSpecial(binding, env) ;
if ( s != null )
return s ;
-
+
NodeValue x = eval(binding, env, expr1) ;
NodeValue y = eval(binding, env, expr2) ;
return eval(x, y, env) ;
}
-
+
/** Special form evaluation (example, don't eval the arguments first) */
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; }
-
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; }
+
public NodeValue eval(NodeValue x, NodeValue y, FunctionEnv env) { return eval(x,y) ; }
- public abstract NodeValue eval(NodeValue x, NodeValue y) ;
+ public abstract NodeValue eval(NodeValue x, NodeValue y) ;
@Override
final public Expr copySubstitute(Binding binding)
@@ -92,7 +92,6 @@ public abstract class ExprFunction2 extends ExprFunction
Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)) ;
return copy(e1, e2) ;
}
-
@Override
final public Expr applyNodeTransform(NodeTransform transform)
@@ -102,11 +101,12 @@ public abstract class ExprFunction2 extends ExprFunction
return copy(e1, e2) ;
}
-
public abstract Expr copy(Expr arg1, Expr arg2) ;
@Override
public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr arg1, Expr arg2) { return transform.transform(this, arg1, arg2) ; }
+ public Expr apply(ExprTransform transform, Expr arg1, Expr arg2) {
+ return transform.transform(this, arg1, arg2);
+ }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
index d003ed2566..61eee256ab 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunction3.java
@@ -18,105 +18,99 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.atlas.lib.Lib ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import org.apache.jena.atlas.lib.Lib;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** A function of three arguments */
-
+
public abstract class ExprFunction3 extends ExprFunction
{
- protected final Expr expr1 ;
- protected final Expr expr2 ;
- protected final Expr expr3 ;
+ protected final Expr expr1;
+ protected final Expr expr2;
+ protected final Expr expr3;
+
+ protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName) { this(expr1, expr2, expr3, fName, null); }
- protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName) { this(expr1, expr2, expr3, fName, null) ; }
-
protected ExprFunction3(Expr expr1, Expr expr2, Expr expr3, String fName, String opSign)
{
- super(fName, opSign) ;
- this.expr1 = expr1 ;
- this.expr2 = expr2 ;
- this.expr3 = expr3 ;
+ super(fName, opSign);
+ this.expr1 = expr1;
+ this.expr2 = expr2;
+ this.expr3 = expr3;
}
-
- public Expr getArg1() { return expr1 ; }
- public Expr getArg2() { return expr2 ; }
- public Expr getArg3() { return expr3 ; }
-
+
+ public Expr getArg1() { return expr1; }
+ public Expr getArg2() { return expr2; }
+ public Expr getArg3() { return expr3; }
+
@Override
public Expr getArg(int i)
{
if ( i == 1 )
- return expr1 ;
+ return expr1;
if ( i == 2 )
- return expr2 ;
+ return expr2;
if ( i == 3 )
- return expr3 ;
- return null ;
+ return expr3;
+ return null;
}
-
+
@Override
- public int numArgs() { return 3 ; }
-
+ public int numArgs() { return 3; }
+
// ---- Evaluation
-
+
@Override
- public int hashCode()
- {
+ public int hashCode() {
return getFunctionSymbol().hashCode() ^
Lib.hashCodeObject(expr1) ^
Lib.hashCodeObject(expr2) ^
- Lib.hashCodeObject(expr3) ;
+ Lib.hashCodeObject(expr3);
}
@Override
- final public NodeValue eval(Binding binding, FunctionEnv env)
- {
- NodeValue s = evalSpecial(binding, env) ;
+ final public NodeValue eval(Binding binding, FunctionEnv env) {
+ NodeValue s = evalSpecial(binding, env);
if ( s != null )
- return s ;
-
- NodeValue x = eval(binding, env, expr1) ;
- NodeValue y = eval(binding, env, expr2) ;
- NodeValue z = eval(binding, env, expr3) ;
- return eval(x, y, z, env) ;
+ return s;
+
+ NodeValue x = eval(binding, env, expr1);
+ NodeValue y = eval(binding, env, expr2);
+ NodeValue z = eval(binding, env, expr3);
+ return eval(x, y, z, env);
}
-
+
/** Special form evaluation (example, don't eval the arguments first) */
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; }
-
- public NodeValue eval(NodeValue x, NodeValue y, NodeValue z, FunctionEnv env) { return eval(x,y, z) ; }
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null; }
- public abstract NodeValue eval(NodeValue x, NodeValue y, NodeValue z) ;
+ public NodeValue eval(NodeValue x, NodeValue y, NodeValue z, FunctionEnv env) { return eval(x,y, z); }
+
+ public abstract NodeValue eval(NodeValue x, NodeValue y, NodeValue z);
// ---- Duplication
-
+
@Override
- final public Expr copySubstitute(Binding binding)
- {
- Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding)) ;
- Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding)) ;
- Expr e3 = (expr3 == null ? null : expr3.copySubstitute(binding)) ;
- return copy(e1, e2, e3) ;
+ final public Expr copySubstitute(Binding binding) {
+ Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding));
+ Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding));
+ Expr e3 = (expr3 == null ? null : expr3.copySubstitute(binding));
+ return copy(e1, e2, e3);
}
-
@Override
- final public Expr applyNodeTransform(NodeTransform transform)
- {
- Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform)) ;
- Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform)) ;
- Expr e3 = (expr3 == null ? null : expr3.applyNodeTransform(transform)) ;
- return copy(e1, e2, e3) ;
+ final public Expr applyNodeTransform(NodeTransform transform) {
+ Expr e1 = (expr1 == null ? null : expr1.applyNodeTransform(transform));
+ Expr e2 = (expr2 == null ? null : expr2.applyNodeTransform(transform));
+ Expr e3 = (expr3 == null ? null : expr3.applyNodeTransform(transform));
+ return copy(e1, e2, e3);
}
- public abstract Expr copy(Expr arg1, Expr arg2, Expr arg3) ;
-
- @Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, Expr arg1, Expr arg2, Expr arg3) { return transform.transform(this, arg1, arg2, arg3) ; }
+ public abstract Expr copy(Expr arg1, Expr arg2, Expr arg3);
+ @Override
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, Expr arg1, Expr arg2, Expr arg3) { return transform.transform(this, arg1, arg2, arg3); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java
index e9916ee42c..d553f391f3 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionN.java
@@ -18,106 +18,97 @@
package org.apache.jena.sparql.expr;
-import java.util.ArrayList ;
-import java.util.List ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.function.FunctionEnv ;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.function.FunctionEnv;
import org.apache.jena.sparql.graph.NodeTransform;
/** A function which takes N arguments (N may be variable e.g. regex) */
-
+
public abstract class ExprFunctionN extends ExprFunction
{
- protected ExprList args = null ;
-
- protected ExprFunctionN(String fName, Expr... args)
- {
- this(fName, argList(args)) ;
+ protected ExprList args = null;
+
+ protected ExprFunctionN(String fName, Expr...args) {
+ this(fName, argList(args));
}
-
- protected ExprFunctionN(String fName, ExprList args)
- {
- super(fName) ;
- this.args = args ;
+
+ protected ExprFunctionN(String fName, ExprList args) {
+ super(fName);
+ this.args = args;
}
- private static ExprList argList(Expr[] args)
- {
- ExprList exprList = new ExprList() ;
+ private static ExprList argList(Expr[] args) {
+ ExprList exprList = new ExprList();
for ( Expr e : args )
if ( e != null )
- exprList.add(e) ;
- return exprList ;
+ exprList.add(e);
+ return exprList;
}
@Override
- public Expr getArg(int i)
- {
- i = i-1 ;
+ public Expr getArg(int i) {
+ i = i-1;
if ( i >= args.size() )
- return null ;
- return args.get(i) ;
+ return null;
+ return args.get(i);
}
@Override
- public int numArgs() { return args.size() ; }
-
+ public int numArgs() { return args.size(); }
+
@Override
- public List<Expr> getArgs() { return args.getList() ; }
+ public List<Expr> getArgs() { return args.getList(); }
@Override
- public Expr copySubstitute(Binding binding)
- {
- ExprList newArgs = new ExprList() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
+ public Expr copySubstitute(Binding binding) {
+ ExprList newArgs = new ExprList();
+ for ( int i = 1; i <= numArgs(); i++ )
{
- Expr e = getArg(i) ;
- e = e.copySubstitute(binding) ;
- newArgs.add(e) ;
+ Expr e = getArg(i);
+ e = e.copySubstitute(binding);
+ newArgs.add(e);
}
return copy(newArgs);
}
@Override
- public Expr applyNodeTransform(NodeTransform transform)
- {
- ExprList newArgs = new ExprList() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
- {
- Expr e = getArg(i) ;
- e = e.applyNodeTransform(transform) ;
- newArgs.add(e) ;
+ public Expr applyNodeTransform(NodeTransform transform) {
+ ExprList newArgs = new ExprList();
+ for ( int i = 1 ; i <= numArgs() ; i++ ) {
+ Expr e = getArg(i);
+ e = e.applyNodeTransform(transform);
+ newArgs.add(e);
}
- return copy(newArgs) ;
+ return copy(newArgs);
}
-
+
/** Special form evaluation (example, don't eval the arguments first) */
- protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null ; }
+ protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { return null; }
@Override
- final public NodeValue eval(Binding binding, FunctionEnv env)
- {
- NodeValue s = evalSpecial(binding, env) ;
+ final public NodeValue eval(Binding binding, FunctionEnv env) {
+ NodeValue s = evalSpecial(binding, env);
if ( s != null )
- return s ;
-
- List<NodeValue> argsEval = new ArrayList<>() ;
- for ( int i = 1 ; i <= numArgs() ; i++ )
- {
- NodeValue x = eval(binding, env, getArg(i)) ;
- argsEval.add(x) ;
+ return s;
+
+ List<NodeValue> argsEval = new ArrayList<>();
+ for ( int i = 1 ; i <= numArgs() ; i++ ) {
+ NodeValue x = eval(binding, env, getArg(i));
+ argsEval.add(x);
}
- return eval(argsEval, env) ;
+ return eval(argsEval, env);
}
-
- public NodeValue eval(List<NodeValue> args, FunctionEnv env) { return eval(args) ; }
- public abstract NodeValue eval(List<NodeValue> args) ;
+ public NodeValue eval(List<NodeValue> args, FunctionEnv env) { return eval(args); }
+
+ public abstract NodeValue eval(List<NodeValue> args);
+
+ public abstract Expr copy(ExprList newArgs);
- public abstract Expr copy(ExprList newArgs) ;
-
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, ExprList exprList) { return transform.transform(this, exprList) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, ExprList exprList) { return transform.transform(this, exprList); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java
index ad0239c459..896e2679a5 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprFunctionOp.java
@@ -18,82 +18,70 @@
package org.apache.jena.sparql.expr;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.engine.ExecutionContext ;
-import org.apache.jena.sparql.engine.QueryIterator ;
-import org.apache.jena.sparql.engine.binding.Binding ;
-import org.apache.jena.sparql.engine.iterator.QueryIterSingleton ;
-import org.apache.jena.sparql.engine.iterator.QueryIteratorCheck ;
-import org.apache.jena.sparql.engine.main.QC ;
-import org.apache.jena.sparql.function.FunctionEnv ;
-import org.apache.jena.sparql.syntax.Element ;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.engine.ExecutionContext;
+import org.apache.jena.sparql.engine.QueryIterator;
+import org.apache.jena.sparql.engine.binding.Binding;
+import org.apache.jena.sparql.engine.iterator.QueryIterSingleton;
+import org.apache.jena.sparql.engine.iterator.QueryIteratorCheck;
+import org.apache.jena.sparql.engine.main.QC;
+import org.apache.jena.sparql.function.FunctionEnv;
+import org.apache.jena.sparql.syntax.Element;
/** A "function" that executes over a pattern */
public abstract class ExprFunctionOp extends ExprFunction
{
- private final Op op ;
- private Op opRun = null ;
- private final Element element ;
+ private final Op op;
+ private Op opRun = null;
+ private final Element element;
- protected ExprFunctionOp(String fName, Element el, Op op)
- {
- super(fName) ;
- this.op = op ;
- this.element = el ;
+ protected ExprFunctionOp(String fName, Element el, Op op) {
+ super(fName);
+ this.op = op;
+ this.element = el;
}
@Override
- public Expr getArg(int i)
- {
- return null ;
+ public Expr getArg(int i) {
+ return null;
}
@Override
- public boolean isGraphPattern() { return true ; }
+ public boolean isGraphPattern() { return true; }
@Override
- public Op getGraphPattern() { return op ; }
+ public Op getGraphPattern() { return op; }
- public Element getElement() { return element ; }
+ public Element getElement() { return element; }
@Override
- public int numArgs() { return 0 ; }
+ public int numArgs() { return 0; }
// ---- Evaluation
@Override
- public final NodeValue eval(Binding binding, FunctionEnv env)
- {
- // Substitute?
- // Apply optimize transforms after substitution?
-// if ( opRun == null )
-// {
-// opRun = op ;
-// if ( env.getContext().isTrueOrUndef(ARQ.propertyFunctions) )
-// opRun = Optimize.apply("Property Functions", new TransformPropertyFunction(env.getContext()), opRun) ;
-// }
-
+ public final NodeValue eval(Binding binding, FunctionEnv env) {
ExecutionContext execCxt = new ExecutionContext(env.getContext(),
env.getActiveGraph(),
env.getDataset(),
QC.getFactory(env.getContext())
- ) ;
- QueryIterator qIter1 = QueryIterSingleton.create(binding, execCxt) ;
- QueryIterator qIter = QC.execute(op, qIter1, execCxt) ;
+ );
+ QueryIterator qIter1 = QueryIterSingleton.create(binding, execCxt);
+ QueryIterator qIter = QC.execute(op, qIter1, execCxt);
// Wrap with something to check for closed iterators.
- qIter = QueryIteratorCheck.check(qIter, execCxt) ;
+ qIter = QueryIteratorCheck.check(qIter, execCxt);
// Call the per-operation functionality.
try {
- return eval(binding, qIter, env) ;
- } finally { qIter.close() ; }
+ return eval(binding, qIter, env);
+ } finally { qIter.close(); }
}
protected abstract NodeValue eval(Binding binding, QueryIterator iter, FunctionEnv env);
- public abstract ExprFunctionOp copy(ExprList args, Op x) ;
- public abstract ExprFunctionOp copy(ExprList args, Element elPattern) ;
+ public abstract ExprFunctionOp copy(ExprList args, Op x);
+ public abstract ExprFunctionOp copy(ExprList args, Element elPattern);
@Override
- public void visit(ExprVisitor visitor) { visitor.visit(this) ; }
- public Expr apply(ExprTransform transform, ExprList args, Op x) { return transform.transform(this, args, x) ; }
+ public void visit(ExprVisitor visitor) { visitor.visit(this); }
+ public Expr apply(ExprTransform transform, ExprList args, Op x) { return transform.transform(this, args, x); }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
index 43a9300634..413229e682 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ApplyElementTransformVisitor.java
@@ -33,199 +33,199 @@ import org.apache.jena.sparql.expr.ExprTransformer;
import org.apache.jena.sparql.syntax.*;
class ApplyElementTransformVisitor implements ElementVisitor {
- protected final ElementTransform transform ;
- private final ExprTransform exprTransform ;
+ protected final ElementTransform transform;
+ private final ExprTransform exprTransform;
- private final Deque<Element> stack = new ArrayDeque<>() ;
+ private final Deque<Element> stack = new ArrayDeque<>();
protected final Element pop() {
- return stack.pop() ;
+ return stack.pop();
}
protected final void push(Element elt) {
- stack.push(elt) ;
+ stack.push(elt);
}
public ApplyElementTransformVisitor(ElementTransform transform, ExprTransform exprTransform) {
if ( transform == null )
- transform = ElementTransformIdentity.get() ;
- this.transform = transform ;
- this.exprTransform = exprTransform ;
+ transform = ElementTransformIdentity.get();
+ this.transform = transform;
+ this.exprTransform = exprTransform;
}
final Element result() {
if ( stack.size() != 1 )
- Log.warn(this, "Stack is not aligned") ;
- return pop() ;
+ Log.warn(this, "Stack is not aligned");
+ return pop();
}
@Override
public void visit(ElementTriplesBlock el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementPathBlock el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementFilter el) {
- Expr expr = el.getExpr() ;
- Expr expr2 = transformExpr(expr, exprTransform) ;
- Element el2 = transform.transform(el, expr2) ;
- push(el2) ;
+ Expr expr = el.getExpr();
+ Expr expr2 = transformExpr(expr, exprTransform);
+ Element el2 = transform.transform(el, expr2);
+ push(el2);
}
@Override
public void visit(ElementAssign el) {
- Var v = el.getVar() ;
- Var v1 = TransformElementLib.applyVar(v, exprTransform) ;
- Expr expr = el.getExpr() ;
- Expr expr1 = ExprTransformer.transform(exprTransform, expr) ;
- Element el2 = transform.transform(el, v1, expr1 ) ;
- push(el2) ;
+ Var v = el.getVar();
+ Var v1 = TransformElementLib.applyVar(v, exprTransform);
+ Expr expr = el.getExpr();
+ Expr expr1 = ExprTransformer.transform(exprTransform, expr);
+ Element el2 = transform.transform(el, v1, expr1 );
+ push(el2);
}
@Override
public void visit(ElementBind el) {
- Var v = el.getVar() ;
- Var v1 = TransformElementLib.applyVar(v, exprTransform) ;
- Expr expr = el.getExpr() ;
- Expr expr1 = ExprTransformer.transform(exprTransform, expr) ;
- Element el2 = transform.transform(el, v1, expr1) ;
- push(el2) ;
+ Var v = el.getVar();
+ Var v1 = TransformElementLib.applyVar(v, exprTransform);
+ Expr expr = el.getExpr();
+ Expr expr1 = ExprTransformer.transform(exprTransform, expr);
+ Element el2 = transform.transform(el, v1, expr1);
+ push(el2);
}
@Override
public void visit(ElementData el) {
- Element el2 = transform.transform(el) ;
- push(el2) ;
+ Element el2 = transform.transform(el);
+ push(el2);
}
@Override
public void visit(ElementOptional el) {
- Element elSub = pop() ;
- Element el2 = transform.transform(el, elSub) ;
- push(el2) ;
+ Element elSub = pop();
+ Element el2 = transform.transform(el, elSub);
+ push(el2);
}
@Override
public void visit(ElementLateral el) {
- Element elSub = pop() ;
- Element el2 = transform.transform(el, elSub) ;
- push(el2) ;
+ Element elSub = pop();
+ Element el2 = transform.transform(el, elSub);
+ push(el2);
}
@Override
public void visit(ElementGroup el) {
- ElementGroup newElt = new ElementGroup() ;
- transformFromTo(el.getElements(), newElt.getElements()) ;
- Element el2 = transform.transform(el, newElt.getElements()) ;
- push(el2) ;
+ ElementGroup newElt = new ElementGroup();
+ transformFromTo(el.getElements(), newElt.getElements());
+ Element el2 = transform.transform(el, newElt.getElements());
+ push(el2);
}
@Override
public void visit(ElementUnion el) {
- ElementUnion newElt = new ElementUnion() ;
- transformFromTo(el.getElements(), newElt.getElements()) ;
- Element el2 = transform.transform(el, newElt.getElements()) ;
- push(el2) ;
+ ElementUnion newElt = new ElementUnion();
+ transformFromTo(el.getElements(), newElt.getElements());
+ Element el2 = transform.transform(el, newElt.getElements());
+ push(el2);
}
private boolean transformFromTo(List<Element> elts, List<Element> elts2) {
- boolean changed = false ;
+ boolean changed = false;
for (Element elt : elts) {
- Element elt2 = pop() ;
- changed = (changed || (elt != elt2)) ;
+ Element elt2 = pop();
+ changed = (changed || (elt != elt2));
// Add reversed.
- elts2.add(0, elt2) ;
+ elts2.add(0, elt2);
}
- return changed ;
+ return changed;
}
@Override
public void visit(ElementDataset el) {
- Element sub = pop() ;
- Element el2 = transform.transform(el, sub) ;
- push(el2) ;
+ Element sub = pop();
+ Element el2 = transform.transform(el, sub);
+ push(el2);
}
@Override
public void visit(ElementNamedGraph el) {
- Node n = el.getGraphNameNode() ;
- Node n1 = transformNode(n) ;
- Element elt1 = pop() ;
- Element el2 = transform.transform(el, n1, elt1) ;
- push(el2) ;
+ Node n = el.getGraphNameNode();
+ Node n1 = transformNode(n);
+ Element elt1 = pop();
+ Element el2 = transform.transform(el, n1, elt1);
+ push(el2);
}
@Override
public void visit(ElementExists el) {
- Element elt = el.getElement() ;
- Element elt1 = subElement(elt) ;
- Element el2 = transform.transform(el, elt1) ;
- push(el2) ;
+ Element elt = el.getElement();
+ Element elt1 = subElement(elt);
+ Element el2 = transform.transform(el, elt1);
+ push(el2);
}
@Override
public void visit(ElementNotExists el) {
- Element elt = el.getElement() ;
- Element elt1 = subElement(elt) ;
- Element el2 = transform.transform(el, elt1) ;
- push(el2) ;
+ Element elt = el.getElement();
+ Element elt1 = subElement(elt);
+ Element el2 = transform.transform(el, elt1);
+ push(el2);
}
// When you need to force the walking of the tree ...
// EXISTS / NOT EXISTS
private Element subElement(Element elt) {
- ElementWalker.walk(elt, this) ;
- Element elt1 = pop() ;
- return elt1 ;
+ ElementWalker.walk(elt, this);
+ Element elt1 = pop();
+ return elt1;
}
@Override
public void visit(ElementMinus el) {
- Element elt = el.getMinusElement() ;
- Element elt1 = pop() ;
+ Element elt = el.getMinusElement();
+ Element elt1 = pop();
if ( elt == elt1 )
- push(el) ;
+ push(el);
else
- push(new ElementMinus(elt1)) ;
+ push(new ElementMinus(elt1));
}
@Override
public void visit(ElementService el) {
- Node n = el.getServiceNode() ;
- Node n1 = transformNode(n) ;
- Element elt1 = pop() ;
- Element el2 = transform.transform(el, n1, elt1) ;
- push(el2) ;
+ Node n = el.getServiceNode();
+ Node n1 = transformNode(n);
+ Element elt1 = pop();
+ Element el2 = transform.transform(el, n1, elt1);
+ push(el2);
}
@Override
public void visit(ElementSubQuery el) {
- Query newQuery = QueryTransformOps.transform(el.getQuery(), transform, exprTransform) ;
- push(new ElementSubQuery(newQuery)) ;
+ Query newQuery = QueryTransformOps.transform(el.getQuery(), transform, exprTransform);
+ push(new ElementSubQuery(newQuery));
}
private Node transformNode(Node n) {
if ( exprTransform == null )
- return n ;
- return TransformElementLib.apply(n, exprTransform) ;
+ return n;
+ return TransformElementLib.apply(n, exprTransform);
}
private ExprList transformExpr(ExprList exprList, ExprTransform exprTransform) {
if ( exprList == null || exprTransform == null )
- return exprList ;
- return ExprTransformer.transform(exprTransform, exprList) ;
+ return exprList;
+ return ExprTransformer.transform(exprTransform, exprList);
}
private Expr transformExpr(Expr expr, ExprTransform exprTransform) {
if ( expr == null || exprTransform == null )
- return expr ;
- return ExprTransformer.transform(exprTransform, expr) ;
+ return expr;
+ return ExprTransformer.transform(exprTransform, expr);
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
index d6818301c6..15b4475fb3 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCleanGroupsOfOne.java
@@ -18,9 +18,9 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.syntax.*;
/**
* Clean a SPARQL and ARQ syntax. This applies after using OpAsQuery.
@@ -40,8 +40,8 @@ public class ElementTransformCleanGroupsOfOne extends ElementTransformCopyBase {
@Override
public Element transform(ElementGroup eltGroup, List<Element> elts) {
if ( elts.size() != 1 )
- return super.transform(eltGroup, elts) ;
- Element elt = elts.get(0) ;
+ return super.transform(eltGroup, elts);
+ Element elt = elts.get(0);
if ( ( elt instanceof ElementTriplesBlock ) ||
( elt instanceof ElementPathBlock ) ||
( elt instanceof ElementFilter ) ||
@@ -50,8 +50,8 @@ public class ElementTransformCleanGroupsOfOne extends ElementTransformCopyBase {
( elt instanceof ElementMinus ) ||
( elt instanceof ElementOptional )
)
- return super.transform(eltGroup, elts) ; // No transformation.
- return elt ;
+ return super.transform(eltGroup, elts); // No transformation.
+ return elt;
}
// The ElementGroup transformation can be too strong.
@@ -60,17 +60,17 @@ public class ElementTransformCleanGroupsOfOne extends ElementTransformCopyBase {
// a different query syntax tree).
@Override
public Element transform(ElementUnion eltUnion, List<Element> elts) {
- ElementUnion el2 = new ElementUnion() ;
- for ( int i = 0 ; i < elts.size() ; i++ ) {
- Element el = elts.get(i) ;
+ ElementUnion el2 = new ElementUnion();
+ for ( int i = 0; i < elts.size(); i++ ) {
+ Element el = elts.get(i);
if ( ! ( el instanceof ElementGroup ) ) {
- ElementGroup elg = new ElementGroup() ;
+ ElementGroup elg = new ElementGroup();
elg.addElement(el);
- el = elg ;
+ el = elg;
}
el2.addElement(el);
}
- return el2 ;
+ return el2;
}
// Special case: If Optional, and the original had a {{}} protected filter, keep {{}}
@@ -80,55 +80,55 @@ public class ElementTransformCleanGroupsOfOne extends ElementTransformCopyBase {
// RHS of optional is always an ElementGroup in a normal syntax tree.
if ( ! ( transformedElt instanceof ElementGroup ) ) {
// DRY
- ElementGroup protectedElt = new ElementGroup() ;
+ ElementGroup protectedElt = new ElementGroup();
protectedElt.addElement(transformedElt);
- transformedElt = protectedElt ;
+ transformedElt = protectedElt;
}
// Step 1 : does the original eltOptional has a {{}} RHS?
- Element x = eltOptional.getOptionalElement() ;
+ Element x = eltOptional.getOptionalElement();
if ( ! ( x instanceof ElementGroup ) )
// No. But it is not possible in written query syntax to have a nongroup as the RHS.
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
// So far - {}-RHS.
- ElementGroup eGroup = (ElementGroup)x ;
+ ElementGroup eGroup = (ElementGroup)x;
// Is it {{}}?
- //ElementGroup inner = getGroupInGroup(x) ;
+ //ElementGroup inner = getGroupInGroup(x);
if ( eGroup.size() != 1 )
- return super.transform(eltOptional, transformedElt) ;
- Element inner = eGroup.get(0) ;
+ return super.transform(eltOptional, transformedElt);
+ Element inner = eGroup.get(0);
if ( ! ( inner instanceof ElementGroup ) )
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
// Yes - {{}}
- ElementGroup innerGroup = (ElementGroup)inner ;
+ ElementGroup innerGroup = (ElementGroup)inner;
// Unbundle multiple levels.
- innerGroup = unwrap(innerGroup) ;
- boolean mustProtect = containsFilter(innerGroup) ;
+ innerGroup = unwrap(innerGroup);
+ boolean mustProtect = containsFilter(innerGroup);
if ( mustProtect ) {
// No need to check for {{}} in elt1 as the transform(ElementGroup) will have processed it.
- ElementGroup protectedElt = new ElementGroup() ;
+ ElementGroup protectedElt = new ElementGroup();
protectedElt.addElement(transformedElt);
- return new ElementOptional(protectedElt) ;
+ return new ElementOptional(protectedElt);
}
// No need to protect - process as usual.
- return super.transform(eltOptional, transformedElt) ;
+ return super.transform(eltOptional, transformedElt);
}
private boolean containsFilter(ElementGroup eltGroup) {
- return eltGroup.getElements().stream().anyMatch(el2 ->( el2 instanceof ElementFilter ) ) ;
+ return eltGroup.getElements().stream().anyMatch(el2 ->( el2 instanceof ElementFilter ) );
}
// Removed layers of groups of one. Return inner most group.
private ElementGroup unwrap(ElementGroup eltGroup) {
if ( eltGroup.size() != 1 )
- return eltGroup ;
- Element el = eltGroup.get(0) ;
+ return eltGroup;
+ Element el = eltGroup.get(0);
if ( ! ( el instanceof ElementGroup ) )
- return eltGroup ;
- ElementGroup eltGroup2 = (ElementGroup)el ;
- return unwrap(eltGroup2) ;
+ return eltGroup;
+ ElementGroup eltGroup2 = (ElementGroup)el;
+ return unwrap(eltGroup2);
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
index 360011eed3..f3831b0d98 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformCopyBase.java
@@ -16,19 +16,19 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.graph.Node ;
+import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
-import org.apache.jena.query.Query ;
-import org.apache.jena.sparql.core.BasicPattern ;
-import org.apache.jena.sparql.core.PathBlock ;
+import org.apache.jena.query.Query;
+import org.apache.jena.sparql.core.BasicPattern;
+import org.apache.jena.sparql.core.PathBlock;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.syntax.*;
/** Create a copy if the Element(s) below has changed.
* This is a common base class for writing recursive {@link ElementTransform}
@@ -37,7 +37,7 @@ import org.apache.jena.sparql.syntax.* ;
public class ElementTransformCopyBase implements ElementTransform {
// Note the use of == as object pointer equality.
- protected boolean alwaysCopy = false ;
+ protected boolean alwaysCopy = false;
public ElementTransformCopyBase() {
this(false);
@@ -56,7 +56,7 @@ public class ElementTransformCopyBase implements ElementTransform {
before.getList().forEach(copy::add);
el = new ElementTriplesBlock(copy);
}
- return el ;
+ return el;
}
@Override
@@ -67,7 +67,7 @@ public class ElementTransformCopyBase implements ElementTransform {
before.getList().forEach(copy::add);
el = new ElementPathBlock(copy);
}
- return el ;
+ return el;
}
@Override
@@ -83,22 +83,22 @@ public class ElementTransformCopyBase implements ElementTransform {
@Override
public Element transform(ElementFilter el, Expr expr2) {
if ( !alwaysCopy && el.getExpr() == expr2 )
- return el ;
- return new ElementFilter(expr2) ;
+ return el;
+ return new ElementFilter(expr2);
}
@Override
public Element transform(ElementAssign el, Var v, Expr expr2) {
if ( !alwaysCopy && el.getVar() == v && el.getExpr() == expr2 )
- return el ;
- return new ElementAssign(v, expr2) ;
+ return el;
+ return new ElementAssign(v, expr2);
}
@Override
public Element transform(ElementBind el, Var v, Expr expr2) {
if ( !alwaysCopy && el.getVar() == v && el.getExpr() == expr2 )
- return el ;
- return new ElementBind(v, expr2) ;
+ return el;
+ return new ElementBind(v, expr2);
}
@Override
@@ -109,87 +109,87 @@ public class ElementTransformCopyBase implements ElementTransform {
el.getTable().rows().forEachRemaining(copy::add);
el = copy;
}
- return el ;
+ return el;
}
@Override
public Element transform(ElementUnion el, List<Element> elts) {
if ( !alwaysCopy && el.getElements() == elts )
- return el ;
- ElementUnion el2 = new ElementUnion() ;
- el2.getElements().addAll(elts) ;
- return el2 ;
+ return el;
+ ElementUnion el2 = new ElementUnion();
+ el2.getElements().addAll(elts);
+ return el2;
}
@Override
public Element transform(ElementOptional el, Element elt1) {
if ( !alwaysCopy && el.getOptionalElement() == elt1 )
- return el ;
- return new ElementOptional(elt1) ;
+ return el;
+ return new ElementOptional(elt1);
}
@Override
public Element transform(ElementLateral el, Element elt1) {
if ( !alwaysCopy && el.getLateralElement() == elt1 )
- return el ;
+ return el;
return new ElementLateral(elt1);
}
@Override
public Element transform(ElementGroup el, List<Element> elts) {
if ( !alwaysCopy && el.getElements() == elts )
- return el ;
- ElementGroup el2 = new ElementGroup() ;
- el2.getElements().addAll(elts) ;
- return el2 ;
+ return el;
+ ElementGroup el2 = new ElementGroup();
+ el2.getElements().addAll(elts);
+ return el2;
}
@Override
public Element transform(ElementDataset el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementDataset(el.getDataset(), elt1) ;
+ return el;
+ return new ElementDataset(el.getDataset(), elt1);
}
@Override
public Element transform(ElementNamedGraph el, Node gn, Element elt1) {
if ( !alwaysCopy && el.getGraphNameNode() == gn && el.getElement() == elt1 )
- return el ;
- return new ElementNamedGraph(gn, elt1) ;
+ return el;
+ return new ElementNamedGraph(gn, elt1);
}
@Override
public Element transform(ElementExists el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementExists(elt1) ;
+ return el;
+ return new ElementExists(elt1);
}
@Override
public Element transform(ElementNotExists el, Element elt1) {
if ( !alwaysCopy && el.getElement() == elt1 )
- return el ;
- return new ElementNotExists(elt1) ;
+ return el;
+ return new ElementNotExists(elt1);
}
@Override
public Element transform(ElementMinus el, Element elt1) {
if ( !alwaysCopy && el.getMinusElement() == elt1 )
- return el ;
- return new ElementMinus(elt1) ;
+ return el;
+ return new ElementMinus(elt1);
}
@Override
public Element transform(ElementService el, Node service, Element elt1) {
if ( !alwaysCopy && el.getServiceNode() == service && el.getElement() == elt1 )
- return el ;
- return new ElementService(service, elt1, el.getSilent()) ;
+ return el;
+ return new ElementService(service, elt1, el.getSilent());
}
@Override
public Element transform(ElementSubQuery el, Query query) {
if ( !alwaysCopy && el.getQuery() == query )
- return el ;
- return new ElementSubQuery(query) ;
+ return el;
+ return new ElementSubQuery(query);
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
index 7809f1bef5..0e63d1ca15 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformIdentity.java
@@ -18,15 +18,15 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.List ;
+import java.util.List;
-import org.apache.jena.graph.Node ;
+import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
-import org.apache.jena.query.Query ;
+import org.apache.jena.query.Query;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.syntax.*;
/** Transformation function on an Element that does nothing.
* Do not extend - it assumes that no change below happens.
@@ -37,46 +37,46 @@ import org.apache.jena.sparql.syntax.* ;
public final class ElementTransformIdentity implements ElementTransform
{
private ElementTransformIdentity() {}
- private static ElementTransformIdentity singleton = new ElementTransformIdentity() ;
- static ElementTransform get() { return singleton ; }
+ private static ElementTransformIdentity singleton = new ElementTransformIdentity();
+ static ElementTransform get() { return singleton; }
@Override
- public Element transform(ElementTriplesBlock el) { return el ; }
+ public Element transform(ElementTriplesBlock el) { return el; }
@Override
- public Element transform(ElementPathBlock el) { return el ; }
+ public Element transform(ElementPathBlock el) { return el; }
@Override
- public Element transform(ElementFilter el, Expr expr2) { return el ; }
+ public Element transform(ElementFilter el, Expr expr2) { return el; }
@Override
- public Element transform(ElementAssign el, Var v, Expr expr2) { return el ; }
+ public Element transform(ElementAssign el, Var v, Expr expr2) { return el; }
@Override
- public Element transform(ElementBind el, Var v, Expr expr2) { return el ; }
+ public Element transform(ElementBind el, Var v, Expr expr2) { return el; }
@Override
public Triple transform(Triple triple) { return triple; }
@Override
public Quad transform(Quad quad) { return quad; }
@Override
- public Element transform(ElementData el) { return el ; }
+ public Element transform(ElementData el) { return el; }
@Override
- public Element transform(ElementUnion el, List<Element> elements) { return el ; }
+ public Element transform(ElementUnion el, List<Element> elements) { return el; }
@Override
- public Element transform(ElementOptional el, Element subElt) { return el ; }
+ public Element transform(ElementOptional el, Element subElt) { return el; }
@Override
- public Element transform(ElementLateral el, Element subElt) { return el ; }
+ public Element transform(ElementLateral el, Element subElt) { return el; }
@Override
- public Element transform(ElementGroup el, List<Element> members) { return el ; }
+ public Element transform(ElementGroup el, List<Element> members) { return el; }
@Override
- public Element transform(ElementDataset el, Element subElt) { return el ; }
+ public Element transform(ElementDataset el, Element subElt) { return el; }
@Override
- public Element transform(ElementNamedGraph el, Node gn, Element subElt) { return el ; }
+ public Element transform(ElementNamedGraph el, Node gn, Element subElt) { return el; }
@Override
- public Element transform(ElementExists el, Element subElt) { return el ; }
+ public Element transform(ElementExists el, Element subElt) { return el; }
@Override
- public Element transform(ElementNotExists el, Element subElt) { return el ; }
+ public Element transform(ElementNotExists el, Element subElt) { return el; }
@Override
- public Element transform(ElementMinus el, Element eltRHS) { return el ; }
+ public Element transform(ElementMinus el, Element eltRHS) { return el; }
@Override
- public Element transform(ElementService el, Node service, Element subElt) { return el ; }
+ public Element transform(ElementService el, Node service, Element subElt) { return el; }
@Override
- public Element transform(ElementSubQuery el, Query query) { return el ; }
+ public Element transform(ElementSubQuery el, Query query) { return el; }
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
index 5391803db2..22d40bf58f 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformSubst.java
@@ -16,20 +16,20 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
+import java.util.Map;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.graph.Node_Variable ;
-import org.apache.jena.graph.Triple ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.graph.Node_Variable;
+import org.apache.jena.graph.Triple;
import org.apache.jena.sparql.core.Quad;
-import org.apache.jena.sparql.core.TriplePath ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.graph.NodeTransform ;
-import org.apache.jena.sparql.syntax.Element ;
-import org.apache.jena.sparql.syntax.ElementPathBlock ;
-import org.apache.jena.sparql.syntax.ElementTriplesBlock ;
+import org.apache.jena.sparql.core.TriplePath;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.graph.NodeTransform;
+import org.apache.jena.sparql.syntax.Element;
+import org.apache.jena.sparql.syntax.ElementPathBlock;
+import org.apache.jena.sparql.syntax.ElementTriplesBlock;
/** An {@link ElementTransform} which replaces occurrences of a variable with a Node value.
* Because a {@link Var} is a subclass of {@link Node_Variable} which is a {@link Node},
@@ -39,89 +39,89 @@ import org.apache.jena.sparql.syntax.ElementTriplesBlock ;
* inside sub-select's and not project (which means it is effectively a different variable).
*/
public class ElementTransformSubst extends ElementTransformCopyBase {
- private final NodeTransform nodeTransform ;
+ private final NodeTransform nodeTransform;
public ElementTransformSubst(Map<Var, ? extends Node> mapping) {
- this.nodeTransform = new NodeTransformSubst(mapping) ;
+ this.nodeTransform = new NodeTransformSubst(mapping);
}
@Override
public Element transform(ElementTriplesBlock el) {
- ElementTriplesBlock etb = new ElementTriplesBlock() ;
- boolean changed = false ;
+ ElementTriplesBlock etb = new ElementTriplesBlock();
+ boolean changed = false;
for (Triple t : el.getPattern()) {
- Triple t2 = transform(t) ;
- changed = changed || t != t2 ;
- etb.addTriple(t2) ;
+ Triple t2 = transform(t);
+ changed = changed || t != t2;
+ etb.addTriple(t2);
}
if ( changed )
- return etb ;
- return el ;
+ return etb;
+ return el;
}
@Override
public Element transform(ElementPathBlock el) {
- ElementPathBlock epb = new ElementPathBlock() ;
- boolean changed = false ;
+ ElementPathBlock epb = new ElementPathBlock();
+ boolean changed = false;
for (TriplePath p : el.getPattern()) {
- TriplePath p2 = transform(p) ;
- changed = changed || p != p2 ;
- epb.addTriplePath(p2) ;
+ TriplePath p2 = transform(p);
+ changed = changed || p != p2;
+ epb.addTriplePath(p2);
}
if ( changed )
- return epb ;
- return el ;
+ return epb;
+ return el;
}
private TriplePath transform(TriplePath path) {
- Node s = path.getSubject() ;
- Node s1 = transform(s) ;
- Node o = path.getObject() ;
- Node o1 = transform(o) ;
+ Node s = path.getSubject();
+ Node s1 = transform(s);
+ Node o = path.getObject();
+ Node o1 = transform(o);
if ( path.isTriple() ) {
- Node p = path.getPredicate() ;
- Node p1 = transform(p) ;
+ Node p = path.getPredicate();
+ Node p1 = transform(p);
if ( s == s1 && p == p1 && o == o1 )
- return path ;
- return new TriplePath(Triple.create(s1, p1, o1)) ;
+ return path;
+ return new TriplePath(Triple.create(s1, p1, o1));
}
if ( s == s1 && o == o1 )
- return path ;
- return new TriplePath(s1, path.getPath(), o1) ;
+ return path;
+ return new TriplePath(s1, path.getPath(), o1);
}
@Override
public Triple transform(Triple triple) {
- Node s = triple.getSubject() ;
- Node s1 = transform(s) ;
- Node p = triple.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = triple.getObject() ;
- Node o1 = transform(o) ;
+ Node s = triple.getSubject();
+ Node s1 = transform(s);
+ Node p = triple.getPredicate();
+ Node p1 = transform(p);
+ Node o = triple.getObject();
+ Node o1 = transform(o);
if ( s == s1 && p == p1 && o == o1 )
- return triple ;
- return Triple.create(s1, p1, o1) ;
+ return triple;
+ return Triple.create(s1, p1, o1);
}
@Override
public Quad transform(Quad quad) {
- Node g = quad.getGraph() ;
- Node g1 = transform(g) ;
- Node s = quad.getSubject() ;
- Node s1 = transform(s) ;
- Node p = quad.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = quad.getObject() ;
- Node o1 = transform(o) ;
+ Node g = quad.getGraph();
+ Node g1 = transform(g);
+ Node s = quad.getSubject();
+ Node s1 = transform(s);
+ Node p = quad.getPredicate();
+ Node p1 = transform(p);
+ Node o = quad.getObject();
+ Node o1 = transform(o);
if ( g == g1 && s == s1 && p == p1 && o == o1 )
- return quad ;
- return Quad.create(g1, s1, p1, o1) ;
+ return quad;
+ return Quad.create(g1, s1, p1, o1);
}
private Node transform(Node n) {
- return nodeTransform.apply(n) ;
+ return nodeTransform.apply(n);
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
index 7c1d8c7fe0..16864bbb19 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ElementTransformer.java
@@ -16,12 +16,12 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import org.apache.jena.atlas.logging.Log ;
-import org.apache.jena.query.Query ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.syntax.* ;
+import org.apache.jena.atlas.logging.Log;
+import org.apache.jena.query.Query;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.syntax.*;
/** A bottom-up application of a transformation of SPARQL syntax Elements.
* {@linkplain QueryTransformOps#transform} provides the mechanism
@@ -30,56 +30,56 @@ import org.apache.jena.sparql.syntax.* ;
* @see UpdateTransformOps#transform
*/
public class ElementTransformer {
- private static ElementTransformer singleton = new ElementTransformer() ;
+ private static ElementTransformer singleton = new ElementTransformer();
/** Get the current transformer */
public static ElementTransformer get() {
- return singleton ;
+ return singleton;
}
/** Set the current transformer - use with care */
public static void set(ElementTransformer value) {
- ElementTransformer.singleton = value ;
+ ElementTransformer.singleton = value;
}
/** Transform an algebra expression */
public static Element transform(Element element, ElementTransform transform) {
- return transform(element, transform, null, null, null) ;
+ return transform(element, transform, null, null, null);
}
/** Transformation with specific ElementTransform and ExprTransform */
public static Element transform(Element element, ElementTransform transform, ExprTransform exprTransform) {
- return get().transformation(element, transform, exprTransform, null, null) ;
+ return get().transformation(element, transform, exprTransform, null, null);
}
public static Element transform(Element element, ElementTransform transform, ExprTransform exprTransform,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
- return get().transformation(element, transform, exprTransform, beforeVisitor, afterVisitor) ;
+ return get().transformation(element, transform, exprTransform, beforeVisitor, afterVisitor);
}
// To allow subclassing this class, we use a singleton pattern
// and these protected methods.
protected Element transformation(Element element, ElementTransform transform, ExprTransform exprTransform,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
- ApplyElementTransformVisitor v = new ApplyElementTransformVisitor(transform, exprTransform) ;
- return transformation(v, element, beforeVisitor, afterVisitor) ;
+ ApplyElementTransformVisitor v = new ApplyElementTransformVisitor(transform, exprTransform);
+ return transformation(v, element, beforeVisitor, afterVisitor);
}
protected Element transformation(ApplyElementTransformVisitor transformApply, Element element,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
if ( element == null ) {
- Log.warn(this, "Attempt to transform a null element - ignored") ;
- return element ;
+ Log.warn(this, "Attempt to transform a null element - ignored");
+ return element;
}
- return applyTransformation(transformApply, element, beforeVisitor, afterVisitor) ;
+ return applyTransformation(transformApply, element, beforeVisitor, afterVisitor);
}
/** The primitive operation to apply a transformation to an Op */
protected Element applyTransformation(ApplyElementTransformVisitor transformApply, Element element,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
- ElementWalker.walk(element, transformApply, beforeVisitor, afterVisitor) ;
- Element r = transformApply.result() ;
- return r ;
+ ElementWalker.walk(element, transformApply, beforeVisitor, afterVisitor);
+ Element r = transformApply.result();
+ return r;
}
protected ElementTransformer() {}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
index 06f651da2c..9e4e3f5806 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformApplyElementTransform.java
@@ -18,10 +18,10 @@
package org.apache.jena.sparql.syntax.syntaxtransform;
-import org.apache.jena.sparql.ARQInternalErrorException ;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.expr.* ;
-import org.apache.jena.sparql.syntax.Element ;
+import org.apache.jena.sparql.ARQInternalErrorException;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.expr.*;
+import org.apache.jena.sparql.syntax.Element;
/**
* A copying transform that applies an ElementTransform syntax pattern of
@@ -29,7 +29,7 @@ import org.apache.jena.sparql.syntax.Element ;
* */
public class ExprTransformApplyElementTransform extends ExprTransformCopy
{
- private final ElementTransform transform ;
+ private final ElementTransform transform;
public ExprTransformApplyElementTransform(ElementTransform transform) {
this(transform, false);
@@ -37,21 +37,21 @@ public class ExprTransformApplyElementTransform extends ExprTransformCopy
public ExprTransformApplyElementTransform(ElementTransform transform, boolean alwaysDuplicate) {
super(alwaysDuplicate);
- this.transform = transform ;
+ this.transform = transform;
}
@Override
public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg)
{
- Element el2 = ElementTransformer.transform(funcOp.getElement(), transform) ;
+ Element el2 = ElementTransformer.transform(funcOp.getElement(), transform);
if ( el2 == funcOp.getElement() )
- return super.transform(funcOp, args, opArg) ;
+ return super.transform(funcOp, args, opArg);
if ( funcOp instanceof E_Exists )
- return new E_Exists(el2) ;
+ return new E_Exists(el2);
if ( funcOp instanceof E_NotExists )
- return new E_NotExists(el2) ;
- throw new ARQInternalErrorException("Unrecognized ExprFunctionOp: \n"+funcOp) ;
+ return new E_NotExists(el2);
+ throw new ARQInternalErrorException("Unrecognized ExprFunctionOp: \n"+funcOp);
}
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
index 2429bbe74e..7da7057fd0 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
@@ -40,8 +40,8 @@ public class ExprTransformNodeElement extends ExprTransformCopy {
public ExprTransformNodeElement(NodeTransform nodeTransform, ElementTransform eltrans) {
this(nodeTransform, eltrans, null, null) ;
}
-
- public ExprTransformNodeElement(NodeTransform nodeTransform, ElementTransform eltrans,
+
+ public ExprTransformNodeElement(NodeTransform nodeTransform, ElementTransform eltrans,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
this.nodeTransform = nodeTransform ;
this.elementTransform = eltrans ;
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
index 2aedae7783..1f7e221875 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/NodeTransformSubst.java
@@ -16,27 +16,27 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
+import java.util.Map;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.graph.NodeTransform ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.graph.NodeTransform;
/** A {@link NodeTransform} substituting variables for {@link Node}s. */
public class NodeTransformSubst implements NodeTransform {
- private final Map<Var, ? extends Node> map ;
+ private final Map<Var, ? extends Node> map;
public NodeTransformSubst(Map<Var, ? extends Node> map) {
- this.map = map ;
+ this.map = map;
}
@Override
public Node apply(Node node) {
- Node n = map.get(node) ;
+ Node n = map.get(node);
if ( n == null )
- return node ;
- return n ;
+ return node;
+ return n;
}
}
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 8d873f0714..b461a0a7e0 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
@@ -28,9 +28,9 @@ import org.apache.jena.graph.Triple;
import org.apache.jena.query.Query;
import org.apache.jena.query.QueryVisitor;
import org.apache.jena.query.SortCondition;
-import org.apache.jena.rdf.model.Literal ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.rdf.model.Resource ;
+import org.apache.jena.rdf.model.Literal;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.rdf.model.Resource;
import org.apache.jena.shared.JenaException;
import org.apache.jena.shared.PrefixMapping;
import org.apache.jena.shared.impl.PrefixMappingImpl;
@@ -274,7 +274,7 @@ public class QueryTransformOps {
if (e2 == null || e2 == ev )
return node;
if ( ! e2.isConstant() )
- return node ;
+ return node;
return e2.getConstant().getNode();
}
@@ -307,7 +307,7 @@ public class QueryTransformOps {
@Override
public void visitPrologue(Prologue prologue) {
- // newQuery.setBaseURI(prologue.getResolver()) ;
+ // newQuery.setBaseURI(prologue.getResolver());
PrefixMapping pmap = new PrefixMappingImpl().setNsPrefixes(prologue.getPrefixMapping());
newQuery.setPrefixMapping(pmap);
}
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
index ed2fb7ba38..d3b4d568be 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/TransformElementLib.java
@@ -16,50 +16,50 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import java.util.Map ;
-import java.util.stream.Collectors ;
+import java.util.Map;
+import java.util.stream.Collectors;
-import org.apache.jena.atlas.lib.InternalErrorException ;
+import org.apache.jena.atlas.lib.InternalErrorException;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.Expr ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.expr.ExprVar ;
-import org.apache.jena.sparql.expr.NodeValue ;
+import org.apache.jena.graph.Node;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.Expr;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.expr.ExprVar;
+import org.apache.jena.sparql.expr.NodeValue;
public class TransformElementLib {
public static Var applyVar(Var v, ExprTransform exprTransform) {
if ( exprTransform == null )
- return v ;
- ExprVar expr = new ExprVar(v) ;
- Expr e = exprTransform.transform(expr) ;
+ return v;
+ ExprVar expr = new ExprVar(v);
+ Expr e = exprTransform.transform(expr);
if ( e instanceof ExprVar )
- return ((ExprVar)e).asVar() ;
- throw new InternalErrorException("Managed to turn a variable " + v + " into " + e) ;
+ return ((ExprVar)e).asVar();
+ throw new InternalErrorException("Managed to turn a variable " + v + " into " + e);
}
public static Node apply(Node n, ExprTransform exprTransform) {
if ( exprTransform == null )
- return n ;
- Expr e = null ;
+ return n;
+ Expr e = null;
if ( Var.isVar(n) ) {
- Var v = Var.alloc(n) ;
- ExprVar expr = new ExprVar(v) ;
- e = exprTransform.transform(expr) ;
+ Var v = Var.alloc(n);
+ ExprVar expr = new ExprVar(v);
+ e = exprTransform.transform(expr);
} else {
- NodeValue nv = NodeValue.makeNode(n) ;
- e = exprTransform.transform(nv) ;
+ NodeValue nv = NodeValue.makeNode(n);
+ e = exprTransform.transform(nv);
}
if ( e instanceof ExprVar )
- return ((ExprVar)e).asVar() ;
+ return ((ExprVar)e).asVar();
if ( e instanceof NodeValue )
- return ((NodeValue)e).asNode() ;
- throw new InternalErrorException("Managed to turn a node " + n + " into " + e) ;
+ return ((NodeValue)e).asNode();
+ throw new InternalErrorException("Managed to turn a node " + n + " into " + e);
}
public static Map<Var, Node> convert(Map<String, ? extends RDFNode> substitutions) {
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
index b83b2609a5..5bf3932f0e 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/UpdateTransformOps.java
@@ -16,42 +16,42 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
-
-import java.util.ArrayList ;
-import java.util.List ;
-import java.util.Map ;
-
-import org.apache.jena.graph.Node ;
-import org.apache.jena.rdf.model.Literal ;
-import org.apache.jena.rdf.model.RDFNode ;
-import org.apache.jena.rdf.model.Resource ;
-import org.apache.jena.sparql.core.Quad ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.ExprTransform ;
-import org.apache.jena.sparql.graph.NodeTransform ;
-import org.apache.jena.sparql.modify.request.* ;
-import org.apache.jena.sparql.syntax.Element ;
-import org.apache.jena.update.Update ;
-import org.apache.jena.update.UpdateRequest ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.jena.graph.Node;
+import org.apache.jena.rdf.model.Literal;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.rdf.model.Resource;
+import org.apache.jena.sparql.core.Quad;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.ExprTransform;
+import org.apache.jena.sparql.graph.NodeTransform;
+import org.apache.jena.sparql.modify.request.*;
+import org.apache.jena.sparql.syntax.Element;
+import org.apache.jena.update.Update;
+import org.apache.jena.update.UpdateRequest;
/** Support for transformation of update abstract syntax. */
public class UpdateTransformOps {
/** Transform an {@link Update} based on a mapping from {@link Var} variable to replacement {@link Node}. */
public static Update transform(Update update, Map<Var, Node> substitutions) {
- ElementTransform eltrans = new ElementTransformSubst(substitutions) ;
- NodeTransform nodeTransform = new NodeTransformSubst(substitutions) ;
- ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform, eltrans) ;
- return transform(update, eltrans, exprTrans) ;
+ ElementTransform eltrans = new ElementTransformSubst(substitutions);
+ NodeTransform nodeTransform = new NodeTransformSubst(substitutions);
+ ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform, eltrans);
+ return transform(update, eltrans, exprTrans);
}
/** Transform an {@link UpdateRequest} based on a mapping from {@link Var} variable to replacement {@link Node}. */
public static UpdateRequest transform(UpdateRequest update, Map<Var, Node> substitutions) {
- ElementTransform eltrans = new ElementTransformSubst(substitutions) ;
- NodeTransform nodeTransform = new NodeTransformSubst(substitutions) ;
- ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform, eltrans) ;
- return transform(update, eltrans, exprTrans) ;
+ ElementTransform eltrans = new ElementTransformSubst(substitutions);
+ NodeTransform nodeTransform = new NodeTransformSubst(substitutions);
+ ExprTransform exprTrans = new ExprTransformNodeElement(nodeTransform, eltrans);
+ return transform(update, eltrans, exprTrans);
}
/**
@@ -73,147 +73,147 @@ public class UpdateTransformOps {
}
public static Update transform(Update update, ElementTransform transform, ExprTransform exprTransform) {
- UpdateTransform upParam = new UpdateTransform(transform, exprTransform) ;
- update.visit(upParam) ;
- Update update1 = upParam.result ;
- return update1 ;
+ UpdateTransform upParam = new UpdateTransform(transform, exprTransform);
+ update.visit(upParam);
+ Update update1 = upParam.result;
+ return update1;
}
public static UpdateRequest transform(UpdateRequest update, ElementTransform transform, ExprTransform exprTransform) {
- UpdateRequest req = new UpdateRequest() ;
- req.getPrefixMapping().setNsPrefixes(update.getPrefixMapping()) ;
+ UpdateRequest req = new UpdateRequest();
+ req.getPrefixMapping().setNsPrefixes(update.getPrefixMapping());
for (Update up : update.getOperations()) {
- up = transform(up, transform, exprTransform) ;
- req.add(up) ;
+ up = transform(up, transform, exprTransform);
+ req.add(up);
}
- return req ;
+ return req;
}
static class UpdateTransform implements UpdateVisitor {
- ElementTransform elTransform ;
- ExprTransform exprTransform ;
- Update result = null ;
+ ElementTransform elTransform;
+ ExprTransform exprTransform;
+ Update result = null;
public UpdateTransform(ElementTransform transform, ExprTransform exprTransform) {
- this.elTransform = transform ;
- this.exprTransform = exprTransform ;
+ this.elTransform = transform;
+ this.exprTransform = exprTransform;
}
@Override
public void visit(UpdateDrop update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateClear update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateCreate update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateLoad update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateAdd update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateCopy update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateMove update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDataInsert update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDataDelete update) {
- result = update ;
+ result = update;
}
@Override
public void visit(UpdateDeleteWhere update) {
- List<Quad> quads = update.getQuads() ;
- List<Quad> quads2 = transform(quads) ;
+ List<Quad> quads = update.getQuads();
+ List<Quad> quads2 = transform(quads);
if ( quads == quads2 )
- result = update ;
+ result = update;
else {
- QuadAcc acc = new QuadAcc() ;
- addAll(acc, quads2) ;
- result = new UpdateDeleteWhere(acc) ;
+ QuadAcc acc = new QuadAcc();
+ addAll(acc, quads2);
+ result = new UpdateDeleteWhere(acc);
}
}
@Override
public void visit(UpdateModify update) {
- Element el = update.getWherePattern() ;
- Element el2 = ElementTransformer.transform(el, elTransform, exprTransform) ;
+ Element el = update.getWherePattern();
+ Element el2 = ElementTransformer.transform(el, elTransform, exprTransform);
- List<Quad> del = update.getDeleteQuads() ;
- List<Quad> del1 = transform(del) ;
- List<Quad> ins = update.getInsertQuads() ;
- List<Quad> ins1 = transform(ins) ;
+ List<Quad> del = update.getDeleteQuads();
+ List<Quad> del1 = transform(del);
+ List<Quad> ins = update.getInsertQuads();
+ List<Quad> ins1 = transform(ins);
- UpdateModify mod = new UpdateModify() ;
+ UpdateModify mod = new UpdateModify();
- addAll(mod.getDeleteAcc(), del1) ;
- addAll(mod.getInsertAcc(), ins1) ;
+ addAll(mod.getDeleteAcc(), del1);
+ addAll(mod.getInsertAcc(), ins1);
mod.setElement(el2);
- result = mod ;
+ result = mod;
}
private void addAll(QuadAcc acc, List<Quad> quads) {
for (Quad q : quads)
- acc.addQuad(q) ;
+ acc.addQuad(q);
}
public List<Quad> transform(List<Quad> quads) {
- List<Quad> x = new ArrayList<>() ;
- boolean changed = false ;
+ List<Quad> x = new ArrayList<>();
+ boolean changed = false;
for (Quad q : quads) {
- Quad q1 = transform(q) ;
- changed = changed || q1 != q ;
- x.add(q1) ;
+ Quad q1 = transform(q);
+ changed = changed || q1 != q;
+ x.add(q1);
}
if ( changed )
- return x ;
- return quads ;
+ return x;
+ return quads;
}
private Quad transform(Quad q) {
- Node g = q.getGraph() ;
- Node g1 = transform(g) ;
- Node s = q.getSubject() ;
- Node s1 = transform(s) ;
- Node p = q.getPredicate() ;
- Node p1 = transform(p) ;
- Node o = q.getObject() ;
- Node o1 = transform(o) ;
+ Node g = q.getGraph();
+ Node g1 = transform(g);
+ Node s = q.getSubject();
+ Node s1 = transform(s);
+ Node p = q.getPredicate();
+ Node p1 = transform(p);
+ Node o = q.getObject();
+ Node o1 = transform(o);
if ( g == g1 && s == s1 && p == p1 && o == o1 )
- return q ;
- return Quad.create(g1, s1, p1, o1) ;
+ return q;
+ return Quad.create(g1, s1, p1, o1);
}
private Node transform(Node n) {
if ( Var.isVar(n) )
- return TransformElementLib.apply(Var.alloc(n), exprTransform) ;
+ return TransformElementLib.apply(Var.alloc(n), exprTransform);
else
- return TransformElementLib.apply(n, exprTransform) ;
+ return TransformElementLib.apply(n, exprTransform);
}
}
(jena) 02/02: GH-2650: Fix for substitution into aggregates
Posted by an...@apache.org.
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 f63360c4f052eb5e0529a1b256f7cbdcb82c0bce
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Tue Aug 20 22:19:43 2024 +0100
GH-2650: Fix for substitution into aggregates
---
.../syntaxtransform/ExprTransformNodeElement.java | 65 ++++++++++++----------
.../syntax/syntaxtransform/QueryTransformOps.java | 15 ++---
.../apache/jena/sparql/algebra/TestOpAsQuery.java | 42 +++++++-------
.../syntaxtransform/TestSyntaxTransform.java | 21 +++++++
4 files changed, 84 insertions(+), 59 deletions(-)
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
index 7da7057fd0..ea7eca93ad 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/syntax/syntaxtransform/ExprTransformNodeElement.java
@@ -16,72 +16,77 @@
* limitations under the License.
*/
-package org.apache.jena.sparql.syntax.syntaxtransform ;
+package org.apache.jena.sparql.syntax.syntaxtransform;
-import org.apache.jena.atlas.lib.InternalErrorException ;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.sparql.algebra.Op ;
-import org.apache.jena.sparql.core.Var ;
-import org.apache.jena.sparql.expr.* ;
-import org.apache.jena.sparql.graph.NodeTransform ;
-import org.apache.jena.sparql.syntax.Element ;
-import org.apache.jena.sparql.syntax.ElementVisitor ;
+import org.apache.jena.atlas.lib.InternalErrorException;
+import org.apache.jena.graph.Node;
+import org.apache.jena.sparql.algebra.Op;
+import org.apache.jena.sparql.core.Var;
+import org.apache.jena.sparql.expr.*;
+import org.apache.jena.sparql.graph.NodeTransform;
+import org.apache.jena.sparql.syntax.Element;
+import org.apache.jena.sparql.syntax.ElementVisitor;
/**
* Special version of ExprTransform for applying a node transform on syntax
* (Elements) only
*/
public class ExprTransformNodeElement extends ExprTransformCopy {
- private final NodeTransform nodeTransform ;
- private final ElementTransform elementTransform ;
+ private final NodeTransform nodeTransform;
+ private final ElementTransform elementTransform;
private final ElementVisitor beforeVisitor;
private final ElementVisitor afterVisitor;
public ExprTransformNodeElement(NodeTransform nodeTransform, ElementTransform eltrans) {
- this(nodeTransform, eltrans, null, null) ;
+ this(nodeTransform, eltrans, null, null);
}
public ExprTransformNodeElement(NodeTransform nodeTransform, ElementTransform eltrans,
ElementVisitor beforeVisitor, ElementVisitor afterVisitor) {
- this.nodeTransform = nodeTransform ;
- this.elementTransform = eltrans ;
- this.beforeVisitor = beforeVisitor ;
- this.afterVisitor = afterVisitor ;
+ this.nodeTransform = nodeTransform;
+ this.elementTransform = eltrans;
+ this.beforeVisitor = beforeVisitor;
+ this.afterVisitor = afterVisitor;
}
@Override
public Expr transform(ExprVar nv) {
- Node n = nodeTransform.apply(nv.getAsNode()) ;
+ Node n = nodeTransform.apply(nv.getAsNode());
if ( n == nv.getAsNode() )
- return nv ;
+ return nv;
if ( n instanceof Var ) {
- Var v = Var.alloc(n) ;
- return new ExprVar(v) ;
+ Var v = Var.alloc(n);
+ return new ExprVar(v);
}
- return NodeValue.makeNode(n) ;
+ return NodeValue.makeNode(n);
}
@Override
public Expr transform(NodeValue nv) {
- Node n = nodeTransform.apply(nv.asNode()) ;
+ Node n = nodeTransform.apply(nv.asNode());
if ( n == nv.asNode() )
- return nv ;
- return NodeValue.makeNode(n) ;
+ return nv;
+ return NodeValue.makeNode(n);
}
@Override
public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) {
// Syntax phased only - ignore args and opArg
- Element elt = funcOp.getElement() ;
- Element elt1 = ElementTransformer.transform(elt, elementTransform, this, beforeVisitor, afterVisitor) ;
+ Element elt = funcOp.getElement();
+ Element elt1 = ElementTransformer.transform(elt, elementTransform, this, beforeVisitor, afterVisitor);
if ( elt == elt1 )
- return funcOp ;
+ return funcOp;
else {
if ( funcOp instanceof E_Exists )
- return new E_Exists(elt1) ;
+ return new E_Exists(elt1);
if ( funcOp instanceof E_NotExists )
- return new E_NotExists(elt1) ;
- throw new InternalErrorException("Unknown ExprFunctionOp: " + funcOp.getFunctionSymbol()) ;
+ return new E_NotExists(elt1);
+ throw new InternalErrorException("Unknown ExprFunctionOp: " + funcOp.getFunctionSymbol());
}
}
+
+ @Override
+ public Expr transform(ExprAggregator eAgg) {
+ return eAgg.applyNodeTransform(nodeTransform);
+ }
}
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 b461a0a7e0..313f75245b 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
@@ -36,10 +36,7 @@ import org.apache.jena.shared.PrefixMapping;
import org.apache.jena.shared.impl.PrefixMappingImpl;
import org.apache.jena.sparql.ARQException;
import org.apache.jena.sparql.core.*;
-import org.apache.jena.sparql.expr.Expr;
-import org.apache.jena.sparql.expr.ExprTransform;
-import org.apache.jena.sparql.expr.ExprTransformer;
-import org.apache.jena.sparql.expr.ExprVar;
+import org.apache.jena.sparql.expr.*;
import org.apache.jena.sparql.graph.NodeTransform;
import org.apache.jena.sparql.modify.request.QuadAcc;
import org.apache.jena.sparql.syntax.*;
@@ -82,6 +79,7 @@ public class QueryTransformOps {
// Reset internal to only what now can be seen.
q2.resetResultVars();
}
+ setAggregators(q2, query, exprTransform);
return q2;
}
@@ -111,6 +109,12 @@ public class QueryTransformOps {
}
}
+ private static void setAggregators(Query newQuery, Query query, ExprTransform exprTransform) {
+ for (ExprAggregator aggregator : query.getAggregators()) {
+ newQuery.getAggregators().add((ExprAggregator) exprTransform.transform(aggregator));
+ }
+ }
+
// Do the result form part of the cloned query.
private static void mutateByQueryType(Query q2, ElementTransform transform, ExprTransform exprTransform) {
switch(q2.queryType()) {
@@ -300,9 +304,6 @@ public class QueryTransformOps {
for (String x : desc.getNamedGraphURIs())
newQuery.addNamedGraphURI(x);
}
-
- // Aggregators.
- newQuery.getAggregators().addAll(query.getAggregators());
}
@Override
diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/TestOpAsQuery.java b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/TestOpAsQuery.java
index 0004bcc172..3d91b293b9 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/TestOpAsQuery.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/TestOpAsQuery.java
@@ -344,28 +344,26 @@ public class TestOpAsQuery {
@Test
public void testAggregatesInSubQuery3() {
- //Actual test case from JENA-445 bug report
- String queryString =
- "PREFIX dcterms: <http://purl.org/dc/terms/> \n" +
- "PREFIX dbpedia: <http://dbpedia.org/resource/> \n" +
-
- "SELECT ?num_of_holidays ?celebrate_Chinese_New_Year WHERE { \n" +
- "{" +
- "SELECT ?country_cat (COUNT(?holiday) as ?num_of_holidays) \n" +
- "WHERE {" +
- "?country_cat <http://www.w3.org/2004/02/skos/core#broader> <http://dbpedia.org/resource/Category:Public_holidays_by_country>. \n" +
- "?holiday dcterms:subject ?country_cat \n" +
- "}GROUP by ?country_cat \n" +
- "} \n" +
- "{ \n" +
- "SELECT ?country_cat (COUNT(?holiday) as ?celebrate_Chinese_New_Year) \n" +
- "WHERE { \n" +
- "?country_cat <http://www.w3.org/2004/02/skos/core#broader> <http://dbpedia.org/resource/Category:Public_holidays_by_country>. \n" +
- "?holiday dcterms:subject ?country_cat \n" +
- "FILTER(?holiday=\"http://dbpedia.org/resource/Lunar_New_Year\'s_Day\") \n" +
- "}GROUP by ?country_cat \n" +
- "} \n" +
- "}\n";
+ String queryString = """
+ PREFIX dcterms: <http://purl.org/dc/terms/>
+ PREFIX dbpedia: <http://dbpedia.org/resource/>
+
+ SELECT ?num_of_holidays ?celebrate_Chinese_New_Year WHERE {
+ {
+ SELECT ?country_cat (COUNT(?holiday) as ?num_of_holidays) WHERE {
+ ?country_cat <http://www.w3.org/2004/02/skos/core#broader> <http://dbpedia.org/resource/Category:Public_holidays_by_country>.
+ ?holiday dcterms:subject ?country_cat
+ } GROUP by ?country_cat
+ }
+ {
+ SELECT ?country_cat (COUNT(?holiday) as ?celebrate_Chinese_New_Year) WHERE {
+ ?country_cat <http://www.w3.org/2004/02/skos/core#broader> <http://dbpedia.org/resource/Category:Public_holidays_by_country>.
+ ?holiday dcterms:subject ?country_cat
+ FILTER(?holiday="http://dbpedia.org/resource/Lunar_New_Year's_Day")
+ } GROUP by ?country_cat
+ }
+ }
+ """;
test_roundTripQuery(queryString);
}
diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestSyntaxTransform.java b/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestSyntaxTransform.java
index 1c93d54e9d..f05e19c005 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestSyntaxTransform.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/syntax/syntaxtransform/TestSyntaxTransform.java
@@ -96,6 +96,27 @@ public class TestSyntaxTransform
"s", "<urn:ex:z>");
}
+ // GH-2650
+ @Test public void subst_query_31() {
+ testQuery("PREFIX : <http://example/> SELECT (SUM(?a + ?b) AS ?c) WHERE { ?s :p ?a }",
+ "PREFIX : <http://example/> SELECT (SUM(123 + ?b) AS ?c) WHERE { ?s :p 123 }",
+ "a", "123");
+ }
+
+ // GH-2650
+ @Test public void subst_query_32() {
+ testQuery("PREFIX : <http://example/> SELECT (SUM(?a + ?b) AS ?c) WHERE { }",
+ "PREFIX : <http://example/> SELECT (SUM(123 + ?b) AS ?c) WHERE { }",
+ "a", "123");
+ }
+
+ // GH-2650
+ @Test public void subst_query_33() {
+ testQuery("SELECT * WHERE { ?s ?p ?o { SELECT (count(?a) as ?C) WHERE {} } }",
+ "SELECT * WHERE { ?s ?p ?o { SELECT (count(123) as ?C) WHERE {} } }",
+ "a", "123");
+ }
+
// Same except use the Model API.
@Test public void subst_query_model_2() {
testQueryModel("SELECT * { ?s ?p ?o } ORDER BY ?s",