Make Node and ExprTransform affect OpPropFunc arguments

Author: Aklakan

jena-arq/src/main/java/org/apache/jena/sparql/algebra/walker/ApplyTransformVisitor.java

@@ -22,6 +22,7 @@
 
 import org.apache.jena.atlas.lib.InternalErrorException ;
 import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.graph.Node ;
 import org.apache.jena.query.SortCondition ;
 import org.apache.jena.sparql.algebra.Op ;
 import org.apache.jena.sparql.algebra.OpVisitor ;
@@ -30,7 +31,9 @@
 import org.apache.jena.sparql.core.Var ;
 import org.apache.jena.sparql.core.VarExprList ;
 import org.apache.jena.sparql.expr.* ;
+import org.apache.jena.sparql.expr.NodeValue ;
 import org.apache.jena.sparql.expr.aggregate.Aggregator ;
+import org.apache.jena.sparql.pfunction.PropFuncArg ;
 
 /** Apply the {@link Transform}, {@link ExprTransform}
  *  Works in conjunction with {@link WalkerVisitor}.
@@ -335,6 +338,55 @@ public void visit(OpFilter opFilter) {
         push(opStack, f.apply(opTransform, subOp)) ;
     }
 
+    protected PropFuncArg visitPropFuncArg(PropFuncArg arg) {
+        ExprList in = arg.asExprList() ;
+        ExprList out = collect(in);
+
+        PropFuncArg result;
+        if (out.equals(in)) {
+            result = arg;
+        } else {
+            if (arg.isNode()) {
+                Node n = ExprLib.exprToNode(out.get(0));
+                result = new PropFuncArg(n);
+            } else {
+                List<Node> nodes = out.getList().stream().map(ExprLib::exprToNode).toList();
+                result = new PropFuncArg(nodes);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public void visit(OpPropFunc opPropFunc) {
+        Op outSubOp = null;
+        Op inSubOp = opPropFunc.getSubOp();
+        if (inSubOp != null) {
+            outSubOp = pop(opStack);
+        }
+
+        // This logic would also rename the function name
+        // (update OpVistorByTypeAndExpr to put the name onto the stack).
+        // List<Expr> opProperty = collect(1);
+        // Node inP = opPropFunc.getProperty();
+        // Node outP = ExprLib.exprToNode(opProperty.get(0));
+
+        Node outP = opPropFunc.getProperty();
+
+        PropFuncArg inS = opPropFunc.getSubjectArgs();
+        PropFuncArg outS = visitPropFuncArg(inS);
+
+        PropFuncArg inO = opPropFunc.getObjectArgs();
+        PropFuncArg outO = visitPropFuncArg(inO);
+
+        OpPropFunc f = opPropFunc;
+        if (inS != outS || inO != outO || inSubOp != outSubOp /* || inP != outP */) {
+            f = new OpPropFunc(outP, outS, outO, outSubOp);
+        }
+
+        push(opStack, f.apply(opTransform, outSubOp)) ;
+    }
+
     @Override
     public void visit(OpLeftJoin op) {
         Op left = null ;

jena-arq/src/main/java/org/apache/jena/sparql/algebra/walker/OpVisitorByTypeAndExpr.java

@@ -94,6 +94,9 @@ public default void visit(OpProcedure opProcedure) {
 
     @Override
     public default void visit(OpPropFunc opPropFunc) {
+        visitExpr(opPropFunc.getObjectArgs().asExprList());
+        visitExpr(opPropFunc.getSubjectArgs().asExprList());
+        // visitExpr(new ExprList(ExprLib.nodeToExpr(opPropFunc.getProperty())));
         visit1(opPropFunc);
     }
 

jena-arq/src/main/java/org/apache/jena/sparql/expr/ExprLib.java

@@ -224,6 +224,20 @@ public static Expr nodeToExpr(Node n) {
         return NodeValue.makeNode(n);
     }
 
+    /**
+     * Go from an expression to a node.
+     * If the argument cannot be converted to a node then an {@link IllegalArgumentException} is raised.
+     */
+    public static Node exprToNode(Expr e) {
+        if (e.isConstant()) {
+            return e.getConstant().asNode();
+        } else if (e.isVariable()) {
+            return e.getExprVar().asVar();
+        } else {
+            throw new IllegalArgumentException("Cannot convert Expression to Node: " + e);
+        }
+    }
+
     public static Expr rewriteTriple(Triple t) {
         Expr e1 = nodeToExpr(t.getSubject());
         Expr e2 = nodeToExpr(t.getPredicate());

jena-arq/src/test/java/org/apache/jena/sparql/algebra/TestNodeTransform.java

@@ -20,6 +20,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import org.apache.jena.graph.NodeFactory;
 import org.apache.jena.query.Query;
 import org.apache.jena.query.QueryFactory;
 import org.apache.jena.sparql.core.Var;
@@ -109,4 +110,28 @@ private static void testOp(Op opExpected, Op opInput, NodeTransform nt) {
                 ? Var.alloc(n.getName() + "ZZZ")
                 : n;
     };
+
+    @Test
+    public void transformPropFunc() {
+        Op inOp = SSE.parseOp("""
+            (propfunc <urn:p>
+              <urn:x> ("y" ?z)
+              (table unit))
+            """);
+
+        // Property function name is not affected by node transform.
+        Op expectedOp = SSE.parseOp("""
+            (propfunc <urn:p>
+              <URN:X> ("Y" ?Z)
+              (table unit))
+            """);
+
+        Op actualOp = NodeTransformLib.transform(x ->
+            x.isURI() ? NodeFactory.createURI(x.getURI().toUpperCase()) :
+            x.isVariable() ? Var.alloc(x.getName().toUpperCase()) :
+            x.isLiteral() ? NodeFactory.createLiteralString(x.getLiteralLexicalForm().toUpperCase()) :
+            x, inOp);
+
+        assertEquals(expectedOp, actualOp);
+    }
 }