private static Op simplify(Op op) { return Transformer.transform(simplify, op) ; }
protected static Op simplify(Op op) { return Transformer.transform(simplify, op) ; }
@Override protected Op modifyOp(Op op) { // Just property functions Transform t = new TransformPropertyFunction(context) ; op = Transformer.transform(t, op) ; return op ; }
/** Do a node->node conversion of an Op - return original BGP for "no change" */ public static Op transform(NodeTransform nodeTransform, Op op) { Transform opTransform = new NodeTransformOp(nodeTransform) ; return Transformer.transform(opTransform, null, op) ; // No expr transform - we do it ourselves. }
@Override protected Op modifyOp(Op op) { // Just property functions Transform t = new TransformPropertyFunction(context) ; op = Transformer.transform(t, op) ; return op ; }
/** Do a node->node conversion of an Op - return original BGP for "no change" */ public static Op transform(NodeTransform nodeTransform, Op op) { Transform opTransform = new NodeTransformOp(nodeTransform) ; return Transformer.transform(opTransform, op) ; }
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, 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) ; }
@Override public Op transform(OpExtend opExtend, Op subOp) { if (subOp instanceof OpExtend) { return OpExtend.extend(Transformer.transform(this, subOp), opExtend.getVarExprList()); } return super.transform(opExtend, subOp); } }
@Override public Op transform(OpAssign opAssign, Op subOp) { if (subOp instanceof OpAssign) { return OpAssign.assign(Transformer.transform(this, subOp), opAssign.getVarExprList()); } return super.transform(opAssign, subOp); }
public static Op transform(Op op) { TransformUnionQuery t = new TransformUnionQuery() ; Op op2 = Transformer.transform(t, op, new Pusher(t.currentGraph), new Popper(t.currentGraph)) ; return op2 ; }
public static Op transform(Op op) { TransformUnionQuery t = new TransformUnionQuery() ; Op op2 = Transformer.transform(t, op, new Pusher(t.currentGraph), new Popper(t.currentGraph)) ; return op2 ; }
public Op work() { return Transformer.transform(new RenameByScope(), op, new BeforeWalk(), new AfterWalk()) ; }
public Op work() { return Transformer.transform(new RenameByScope(), op, new BeforeWalk(), new AfterWalk()) ; }
/** Transform an algebra expression except skip (leave alone) any OpService nodes */ public static Op transformSkipService(Transform transform, ExprTransform exprTransform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { // Skip SERVICE if ( true ) { // Simplest way but still walks the OpService subtree (and throws away the transformation). Transform walker = new TransformSkipService(transform) ; return Transformer.transform(walker, exprTransform, op, beforeVisitor, afterVisitor) ; } else { ApplyTransformVisitorServiceAsLeaf v = new ApplyTransformVisitorServiceAsLeaf(transform, exprTransform) ; WalkerVisitorSkipService walker = new WalkerVisitorSkipService(v, beforeVisitor, afterVisitor) ; OpWalker.walk(walker, op) ; return v.result() ; } }
@Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) { Op opArg2 = Transformer.transform(transform, opArg, beforeVisitor, afterVisitor) ; if ( opArg2 == opArg ) return super.transform(funcOp, args, opArg) ; if ( funcOp instanceof E_Exists ) return new E_Exists(opArg2) ; if ( funcOp instanceof E_NotExists ) return new E_NotExists(opArg2) ; throw new ARQInternalErrorException("Unrecognized ExprFunctionOp: \n"+funcOp) ; } }
@Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) { Op opArg2 = Transformer.transform(transform, opArg) ; if ( opArg2 == opArg ) return super.transform(funcOp, args, opArg) ; if ( funcOp instanceof E_Exists ) return new E_Exists(opArg2) ; if ( funcOp instanceof E_NotExists ) return new E_NotExists(opArg2) ; throw new ARQInternalErrorException("Unrecognized ExprFunctionOp: \n"+funcOp) ; } }
/** * Optimizes the join order of the query * * @param sparql The SPARQL query * * @return The optimized SPARQL query */ public String optimizeJoinOrder(String sparql) { Op op = Algebra.compile(QueryFactory.create(sparql)); Transform joinReorder = new TransformJoinStrategy(); op = Transformer.transform(joinReorder, op); return OpAsQuery.asQuery(op).serialize(); }
public void visit(ExprFunctionOp funcOp) { ExprList x = null ; if ( funcOp.getArgs() != null ) x = process(funcOp.getArgs()) ; Op op = funcOp.getGraphPattern() ; if ( transform instanceof ExprTransformOp ) { ExprTransformOp t = (ExprTransformOp)transform ; op = Transformer.transform(t.getTransform(), op) ; } Expr e = funcOp.apply(transform, x, op) ; push(stack, e) ; }
@Override public void visit(ExprFunctionOp funcOp) { ExprList x = null ; if ( funcOp.getArgs() != null ) x = process(funcOp.getArgs()) ; Op op = funcOp.getGraphPattern() ; // Caution: the expression can have a pattern inside it. // See also: ExprTransformApplyTransform which does much the same in a different way. if ( transform instanceof ExprTransformOp ) { ExprTransformOp t = (ExprTransformOp)transform ; op = Transformer.transform(t.getTransform(), op) ; } Expr e = funcOp.apply(transform, x, op) ; push(stack, e) ; }