| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jena.sparql.core; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.apache.jena.graph.Node; |
| import org.apache.jena.graph.Triple; |
| import org.apache.jena.sparql.algebra.Op; |
| import org.apache.jena.sparql.algebra.TransformCopy; |
| import org.apache.jena.sparql.algebra.Transformer; |
| import org.apache.jena.sparql.algebra.op.*; |
| import org.apache.jena.sparql.engine.binding.Binding; |
| import org.apache.jena.sparql.engine.binding.BindingFactory; |
| import org.apache.jena.sparql.expr.Expr; |
| import org.apache.jena.sparql.expr.ExprList; |
| import org.apache.jena.sparql.pfunction.PropFuncArg; |
| |
| public class Substitute { |
| public static Op substitute(Op op, Binding binding) { |
| // Want to avoid cost if the binding is empty |
| // but the empty test is not zero-cost on non-empty things. |
| |
| if ( isNotNeeded(binding) ) |
| return op; |
| return Transformer.transform(new OpSubstituteWorker(binding), op); |
| } |
| |
| public static Op substitute(Op op, Var var, Node node) { |
| Binding b = BindingFactory.binding(var, node); |
| return substitute(op, b); |
| } |
| |
| public static BasicPattern substitute(BasicPattern bgp, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return bgp; |
| |
| BasicPattern bgp2 = new BasicPattern(); |
| for ( Triple triple : bgp ) { |
| Triple t = substitute(triple, binding); |
| bgp2.add(t); |
| } |
| return bgp2; |
| } |
| |
| public static Triple substitute(Triple triple, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return triple; |
| |
| Node s = triple.getSubject(); |
| Node p = triple.getPredicate(); |
| Node o = triple.getObject(); |
| |
| Node s1 = substitute(s, binding); |
| Node p1 = substitute(p, binding); |
| Node o1 = substitute(o, binding); |
| |
| Triple t = triple; |
| if ( s1 != s || p1 != p || o1 != o ) |
| t = new Triple(s1, p1, o1); |
| return t; |
| } |
| |
| public static TriplePath substitute(TriplePath triplePath, Binding binding) { |
| if ( triplePath.isTriple() ) |
| return new TriplePath(Substitute.substitute(triplePath.asTriple(), binding)); |
| |
| Node s = triplePath.getSubject(); |
| Node o = triplePath.getObject(); |
| Node s1 = substitute(s, binding); |
| Node o1 = substitute(o, binding); |
| |
| TriplePath tp = triplePath; |
| if ( s1 != s || o1 != o ) |
| tp = new TriplePath(s1, triplePath.getPath(), o1); |
| return tp; |
| } |
| |
| public static Quad substitute(Quad quad, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return quad; |
| |
| Node g = quad.getGraph(); |
| Node s = quad.getSubject(); |
| Node p = quad.getPredicate(); |
| Node o = quad.getObject(); |
| |
| Node g1 = substitute(g, binding); |
| Node s1 = substitute(s, binding); |
| Node p1 = substitute(p, binding); |
| Node o1 = substitute(o, binding); |
| |
| Quad q = quad; |
| if ( s1 != s || p1 != p || o1 != o || g1 != g ) |
| q = new Quad(g1, s1, p1, o1); |
| return q; |
| } |
| |
| public static Node substitute(Node n, Binding b) { |
| return Var.lookup(b, n); |
| } |
| |
| public static PropFuncArg substitute(PropFuncArg propFuncArg, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return propFuncArg; |
| |
| if ( propFuncArg.isNode() ) { |
| Node n = propFuncArg.getArg(); |
| if ( !Var.isVar(n) ) |
| // Not a Var, no substitute needed. |
| return propFuncArg; |
| return new PropFuncArg(substitute(propFuncArg.getArg(), binding)); |
| } |
| |
| List<Node> newArgList = new ArrayList<>(); |
| for ( Node n : propFuncArg.getArgList() ) |
| newArgList.add(substitute(n, binding)); |
| return new PropFuncArg(newArgList); |
| } |
| |
| public static Expr substitute(Expr expr, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return expr; |
| return expr.copySubstitute(binding); |
| } |
| |
| public static ExprList substitute(ExprList exprList, Binding binding) { |
| if ( isNotNeeded(binding) ) |
| return exprList; |
| return exprList.copySubstitute(binding); |
| } |
| |
| private static boolean isNotNeeded(Binding b) { |
| return b == null || b.isEmpty(); |
| } |
| |
| // ---- |
| private static class OpSubstituteWorker extends TransformCopy { |
| private Binding binding; |
| |
| public OpSubstituteWorker(Binding binding) { |
| super(TransformCopy.COPY_ALWAYS); |
| this.binding = binding; |
| } |
| |
| @Override |
| public Op transform(OpBGP opBGP) { |
| BasicPattern bgp = opBGP.getPattern(); |
| bgp = substitute(bgp, binding); |
| return new OpBGP(bgp); |
| } |
| |
| @Override |
| public Op transform(OpQuadPattern quadPattern) { |
| Node gNode = quadPattern.getGraphNode(); |
| Node g = substitute(gNode, binding); |
| |
| BasicPattern triples = new BasicPattern(); |
| for ( Triple triple : quadPattern.getBasicPattern() ) { |
| Node s = substitute(triple.getSubject(), binding); |
| Node p = substitute(triple.getPredicate(), binding); |
| Node o = substitute(triple.getObject(), binding); |
| Triple t = new Triple(s, p, o); |
| triples.add(t); |
| } |
| |
| // Pure quading. |
| // for ( Iterator iter = quadPattern.getQuads().iterator() ; |
| // iter.hasNext() ; ) |
| // { |
| // Quad quad = (Quad)iter.next() ; |
| // if ( ! quad.getGraph().equals(gNode) ) |
| // throw new ARQInternalErrorException("Internal error: quads block |
| // is not uniform over the graph node") ; |
| // Node s = substitute(quad.getSubject(), binding) ; |
| // Node p = substitute(quad.getPredicate(), binding) ; |
| // Node o = substitute(quad.getObject(), binding) ; |
| // Triple t = new Triple(s, p, o) ; |
| // triples.add(t) ; |
| // } |
| |
| return new OpQuadPattern(g, triples); |
| } |
| |
| @Override |
| public Op transform(OpPath opPath) { |
| return new OpPath(substitute(opPath.getTriplePath(), binding)); |
| } |
| |
| @Override |
| public Op transform(OpPropFunc opPropFunc, Op subOp) { |
| PropFuncArg sArgs = opPropFunc.getSubjectArgs(); |
| PropFuncArg oArgs = opPropFunc.getObjectArgs(); |
| |
| PropFuncArg sArgs2 = substitute(sArgs, binding); |
| PropFuncArg oArgs2 = substitute(oArgs, binding); |
| |
| if ( sArgs2 == sArgs && oArgs2 == oArgs && opPropFunc.getSubOp() == subOp ) |
| return super.transform(opPropFunc, subOp); |
| return new OpPropFunc(opPropFunc.getProperty(), sArgs2, oArgs2, subOp); |
| } |
| |
| @Override |
| public Op transform(OpFilter filter, Op op) { |
| ExprList exprs = filter.getExprs().copySubstitute(binding); |
| if ( exprs == filter.getExprs() ) |
| return filter; |
| return OpFilter.filterBy(exprs, op); |
| } |
| |
| @Override |
| public Op transform(OpAssign opAssign, Op subOp) { |
| VarExprList varExprList2 = transformVarExprList(opAssign.getVarExprList()); |
| if ( varExprList2.isEmpty() ) |
| return subOp; |
| return OpAssign.assign(subOp, varExprList2); |
| } |
| |
| @Override |
| public Op transform(OpExtend opExtend, Op subOp) { |
| VarExprList varExprList2 = transformVarExprList(opExtend.getVarExprList()); |
| if ( varExprList2.isEmpty() ) |
| return subOp; |
| |
| return OpExtend.create(subOp, varExprList2); |
| } |
| |
| private VarExprList transformVarExprList(VarExprList varExprList) { |
| VarExprList varExprList2 = new VarExprList(); |
| for ( Var v : varExprList.getVars() ) { |
| // if ( binding.contains(v)) |
| // // Already bound. No need to do anything because the |
| // // logical assignment will test value. |
| // continue ; |
| Expr expr = varExprList.getExpr(v); |
| expr = expr.copySubstitute(binding); |
| varExprList2.add(v, expr); |
| } |
| return varExprList2; |
| } |
| |
| // The expression? |
| // public Op transform(OpLeftJoin opLeftJoin, Op left, Op right) { |
| // return xform(opLeftJoin, left, right) ; } |
| |
| @Override |
| public Op transform(OpGraph op, Op sub) { |
| Node n = substitute(op.getNode(), binding); |
| return new OpGraph(n, sub); |
| } |
| |
| @Override |
| public Op transform(OpService op, Op sub) { |
| Node n = substitute(op.getService(), binding); |
| return new OpService(n, sub, op.getSilent()); |
| } |
| } |
| } |
