public ExprList copySubstitute(Binding binding, boolean foldConstants) { ExprList x = new ExprList() ; for ( Iterator<Expr> iter = expressions.iterator() ; iter.hasNext() ; ) { Expr expr = iter.next(); expr = expr.copySubstitute(binding, foldConstants) ; x.add(expr) ; } return x ; } public void addAll(ExprList exprs) { expressions.addAll(exprs.getList()) ; }
private static Pair<List<Pair<Var, NodeValue>>, ExprList> preprocessFilterEquality(ExprList exprs) { List<Pair<Var, NodeValue>> exprsFilterEquality = new ArrayList<Pair<Var, NodeValue>>(); ExprList exprsOther = new ExprList(); for (Expr e : exprs.getList()) { Pair<Var, NodeValue> p = preprocess(e); if (p != null) exprsFilterEquality.add(p); else exprsOther.add(e); } if (exprsFilterEquality.size() == 0) return null; return Pair.create(exprsFilterEquality, exprsOther); }
Collection<Var> leftVars = fixedVars(left) ; Collection<Var> rightVars = fixedVars(right) ; ExprList unpushed = new ExprList() ; ExprList pushLeft = new ExprList() ; ExprList pushRight = new ExprList() ; pushLeft.add(expr) ; pushed = true ; pushRight.add(expr) ; pushed = true ; unpushed.add(expr) ; if ( pushLeft.isEmpty() && pushRight.isEmpty() ) return null ; if ( !pushLeft.isEmpty() ) opLeftNew = transformOp(pushLeft, opLeftNew) ; if ( !pushRight.isEmpty() ) opRightNew = transformOp(pushRight, opRightNew) ;
@Override public Op transform(OpFilter opFilter, Op subOp) { if ( ! safeToTransform(subOp) ) return super.transform(opFilter, subOp) ; ExprList exprs = opFilter.getExprs() ; Op op = subOp ; // Variables set Set<Var> patternVars = OpVars.patternVars(op) ; // Any assignments must go inside filters so the filters see the assignments. // For each filter in the expr list ... ExprList exprs2 = new ExprList() ; // Unchanged filters. Put around the result. for ( Expr e : exprs.getList() ) { Op op2 = processFilterWorker(e, op, patternVars) ; if ( op2 == null ) exprs2.add(e) ; else op = op2 ; } // Place any filter expressions around the processed sub op. if ( exprs2.size() > 0 ) op = OpFilter.filter(exprs2, op) ; return op ; }
private Placement processExtendAssign(ExprList exprs, OpExtendAssign input) { ExprList pushed = new ExprList() ; ExprList unpushed = new ExprList() ; pushed.add(expr); else unpushed.add(expr) ; if ( pushed.isEmpty() ) return resultNoChange(input) ; if ( ! p.unplaced.isEmpty() ) unpushed.addAll(p.unplaced) ; Op op1 = input.copy(p.op) ;
private OpFilter(Op sub) { super(sub) ; expressions = new ExprList() ; }
private static void split(ExprList exprList, Expr expr) { // Explode &&-chain to exprlist. while ( expr instanceof E_LogicalAnd ) { E_LogicalAnd x = (E_LogicalAnd)expr ; Expr left = x.getArg1() ; Expr right = x.getArg2() ; split(exprList, left) ; expr = right ; } // Drop through and add remaining exprList.add(expr) ; } }
private static Op buildFilter(ExprList exprs, Op op) { if ( exprs == null || exprs.isEmpty() ) return op ; for (Iterator<Expr> iter = exprs.iterator(); iter.hasNext();) { Expr expr = iter.next() ; if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; iter.remove() ; } return op ; } }
@Override public List<Expr> getArgs() { return args.getList() ; }
public static Op filter(Expr expr, Op op) { OpFilter f = filter(op) ; f.getExprs().add(expr) ; return f ; }
@Override public QueryIterator matchRightLeft(Binding bindingLeft, boolean includeOnNoMatch, ExprList conditions, ExecutionContext execContext) { List<Binding> out = new ArrayList<Binding>() ; for (Iterator<Binding> iter = rows.iterator(); iter.hasNext();) { Binding bindingRight = iter.next() ; Binding r = Algebra.merge(bindingLeft, bindingRight) ; if ( r == null ) continue ; // This does the conditional part. Theta-join. if ( conditions == null || conditions.isSatisfied(r, execContext) ) out.add(r) ; } if ( out.size() == 0 && includeOnNoMatch ) out.add(bindingLeft) ; if ( out.size() == 0 ) return QueryIterNullIterator.create(execContext) ; return new QueryIterPlainWrapper(out.iterator(), execContext) ; }