protected static Op rewriteDistinct(Op op, SDBRequest request) { Transform t = new DistinctOptimizer(request) ; return Transformer.transform(t, op) ; }
protected static Op rewriteFilters(Op op, SDBRequest request) { Transform t = new FilterOptimizer(request) ; return Transformer.transform(t, op) ; }
/** Convert a pattern, assumed to be quad form, * so that the default graph is the union of named graphs. */ public static Op unionDefaultGraphQuads(Op op) { // Rewrite so that any explicitly named "default graph" is union graph. Transform t = new TransformGraphRename(Quad.defaultGraphNodeGenerated, Quad.unionGraph) ; op = Transformer.transform(t, op) ; return op ; } }
protected static Op rewriteLimitOffset(Op op, SDBRequest request) { Transform t = new LimitOffsetOptimizer(request) ; return Transformer.transform(t, op) ; }
@Override protected Op modifyOp(Op op) { // Just property functions Transform t = new TransformPropertyFunction(context) ; op = Transformer.transform(t, op) ; return op ; }
/** Convert a pattern, assumed to be quad form, * so that the default graph is the union of named graphs. */ public static Op unionDefaultGraphQuads(Op op) { // Rewrite so that any explicitly named "default graph" is union graph. Transform t = new TransformGraphRename(Quad.defaultGraphNodeGenerated, Quad.unionGraph) ; op = Transformer.transform(t, op) ; return 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); }
/** Do a node{@literal ->}node conversion of an Op - return original BGP for "no change" */ public static Op transform(NodeTransform nodeTransform, Op op) { Transform opTransform = new NodeTransformOp(nodeTransform) ; ExprTransform exprTransform = new NodeTransformExpr(nodeTransform) ; return Transformer.transform(opTransform, exprTransform, op); }
public static Op transform(Op op) { Transform transform = new TransformDistributeJoinOverUnion(); Op result = FixpointIteration.apply(op, o -> Transformer.transform(transform, o)); //Op result = Transformer.transform(transform, op); return result; }
public static Op transform(Op op) { Transform transform = new TransformDistributeJoinOverUnion(); Op result = FixpointIteration.apply(op, o -> Transformer.transform(transform, o)); //Op result = Transformer.transform(transform, op); return result; }
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 void check(Op opToOptimize, Transform additionalOptimizer, String opExpectedString) { Op opOptimize = Algebra.optimize(opToOptimize) ; opOptimize = Transformer.transform(additionalOptimizer, opOptimize) ; Op opExpected = SSE.parseOp(opExpectedString) ; assertEquals(opExpected, opOptimize) ; }
@Override public Expr transform(ExprFunctionOp funcOp, ExprList args, Op opArg) { // Manually transform each argument Op op = Transformer.transform(new TransformCopy(), this, funcOp.getGraphPattern()); ExprList newArgs = new ExprList(); for (int i = 0; i < args.size(); i++) { Expr curr = args.get(i); Expr newArg = ExprTransformer.transform(this, curr) ; newArgs.add(newArg); } return funcOp.copy(newArgs, op); }
public static void test(Op input, Transform transform, String... output) { Op opOptimized = Transformer.transform(transform, input); if (output == null) { // No transformation. Assert.assertEquals(input, opOptimized); return; } Op op3 = SSE.parseOp(StrUtils.strjoinNL(output)); Assert.assertEquals(op3, opOptimized); } }
private void test(String input, String output) { input = pre+input+post ; output = pre+output+post ; Op op1 = SSE.parseOp(input) ; //op1 = Transformer.transform(new TransformPathFlattern(), op1) ; Op op3 = Transformer.transform(new TransformMergeBGPs(), op1) ; Op expected = SSE.parseOp(output) ; assertEquals(expected, op3) ; } }
public void test(Op op1, Transform transform, String... output) { Op op2 = Transformer.transform(transform, op1) ; if ( output == null ) { // No transformation. Assert.assertEquals(op1, op2) ; return ; } Op op3 = SSE.parseOp(StrUtils.strjoinNL(output)) ; Assert.assertEquals(op3, op2) ; }
private static void test(Op input, String... joinForm) { Op op2 = Transformer.transform(new TransformPattern2Join() , input) ; String x = StrUtils.strjoinNL(joinForm) ; Op opExpected = SSE.parseOp("(prefix ((: <http://example/>)) "+x+")") ; assertEquals(opExpected, op2) ; } }
private void test(String input, String expected, ExprTransform transform) { Op opOrig = SSE.parseOp(input); Op opExpected = SSE.parseOp(expected != null ? expected : input); Op opOptimized = Transformer.transform(new TransformCopy(), transform, opOrig); Assert.assertEquals(opExpected, opOptimized); }
@Test public void equality_expression_1() { // Need to fold to a string or URI to trigger equality. Op op = SSE.parseOp("(filter (= ?o (+ 'a' 'b')) (bgp (?x <http://p2> ?o)))") ; // Fold constants. Op op1 = Transformer.transform(new TransformCopy(), new ExprTransformConstantFold(), op); // Then apply filter-equality. check(op1, t_equality, "(assign ((?o 'ab')) (bgp (?x <http://p2> 'ab')) )") ; }
public static void checkAlgebra(String algString, Transform additionalOptimizer, String opExpectedString) { Op algebra = SSE.parseOp(algString) ; Op algebra1 = SSE.parseOp(algString) ; // Safe copy Op optimized = Algebra.optimize(algebra) ; if ( additionalOptimizer != null ) optimized = Transformer.transform(additionalOptimizer, optimized); Op opExpected = SSE.parseOp(opExpectedString != null ? opExpectedString : algString); assertEquals(opExpected, optimized) ; assertEquals("Modification of input during optimization", algebra1, algebra) ; }