@Override public void visit(OpOrder opOrder) { for ( Iterator<SortCondition> iter = opOrder.getConditions().iterator() ; iter.hasNext(); ) { SortCondition sc = iter.next(); Set<Var> x = sc.getExpression().getVarsMentioned() ; acc.addAll(x) ; } }
@Override public void visit(OpOrder opOrder) { for (Iterator<SortCondition> iter = opOrder.getConditions().iterator(); iter.hasNext();) { SortCondition sc = iter.next() ; Set<Var> x = sc.getExpression().getVarsMentioned() ; acc.addAll(x) ; } } }
/** For any expression now in scope, wrap the op with a filter */ private static Op insertAnyFilter(ExprList exprs, Set<Var> patternVarsScope, Op op) { for (Iterator<Expr> iter = exprs.iterator(); iter.hasNext();) { Expr expr = iter.next() ; // Cache Set<Var> exprVars = expr.getVarsMentioned() ; if ( patternVarsScope.containsAll(exprVars) ) { if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; iter.remove() ; // Record expr. } } return op ; }
private void processExpr(Expr e) { for(Var v : e.getVarsMentioned()) { add(processVar(v)); } }
/** * Creates a user defined function definition * @param uri Function URL * @param e Expression * @param argList Arguments */ public UserDefinedFunctionDefinition(String uri, Expr e, List<Var> argList) { this.uri = uri; this.expr = e; this.argList = new ArrayList<Var>(argList); //Verify that all mentioned variables are in the arguments list Set<Var> mentioned = this.expr.getVarsMentioned(); for (Var v : mentioned) { if (!argList.contains(v)) throw new ExprBuildException("Cannot use the variable " + v.toString() + " in the expression since it is not included in the argList argument. All variables must be arguments to the function"); } //If used variables is greater than argument variables this is an error if (mentioned.size() > this.argList.size()) throw new ExprBuildException("Mismatch between variables used in expression and number of variables in argument list, expected " + this.argList.size() + " but found " + mentioned.size()); //May have more arguments than used, however this only gives warning(s) if (mentioned.size() < this.argList.size()) { for (Var v : this.argList) { if (!mentioned.contains(v) && warnOnUnusedVariable) LOG.warn("Function <" + uri + "> has argument " + v + " which is never used in the expression"); } } }
/** For any expression now in scope, wrap the op with a filter */ private static Op insertAnyFilter(ExprList exprs, Set<Var> patternVarsScope, Op op) { for ( Iterator<Expr> iter = exprs.iterator() ; iter.hasNext() ; ) { Expr expr = iter.next() ; // Cache Set<Var> exprVars = expr.getVarsMentioned() ; if ( patternVarsScope.containsAll(exprVars) ) { if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; iter.remove() ; } } return op ; }
/** For any expression now in scope, wrap the op with a filter */ private static Op insertAnyFilter(ExprList exprs, Set<Var> patternVarsScope, Op op) { for ( Iterator<Expr> iter = exprs.iterator() ; iter.hasNext() ; ) { Expr expr = iter.next() ; // Cache Set<Var> exprVars = expr.getVarsMentioned() ; if ( patternVarsScope.containsAll(exprVars) ) { if ( op == null ) op = OpTable.unit() ; op = OpFilter.filter(expr, op) ; iter.remove() ; } } return op ; }
private static void checkAssignment(Collection<Var> scope, Expr expr, Var var) { // Project SELECT ?x if ( expr == null ) return ; // expr not null if ( scope.contains(var) ) throw new QueryParseException("Variable used when already in-scope: "+var+" in "+fmtAssignment(expr, var), -1 , -1) ; // test for impossible variables - bound() is a bit odd. if ( false ) { Set<Var> vars = expr.getVarsMentioned() ; for ( Var v : vars ) { if ( !scope.contains(v) ) throw new QueryParseException("Variable used in expression is not in-scope: "+v+" in "+expr, -1 , -1) ; } } }
private static void checkAssignment(Collection<Var> scope, Expr expr, Var var) { // Project SELECT ?x if ( expr == null ) return ; // expr not null if ( scope.contains(var) ) throw new QueryParseException("Variable used when already in-scope: "+var+" in "+fmtAssignment(expr, var), -1 , -1) ; // test for impossible variables - bound() is a bit odd. if ( false ) { Set<Var> vars = expr.getVarsMentioned() ; for ( Var v : vars ) { if ( !scope.contains(v) ) throw new QueryParseException("Variable used in expression is not in-scope: "+v+" in "+expr, -1 , -1) ; } } }
Set<Var> eVars = e.getVarsMentioned() ; for ( Var v2 : eVars )
/** * Determines whether a sort condition is valid in terms of this optimizer * * @param cond * Sort Condition * @param projectVars * Project Variables * @return True if valid, false otherwise */ private boolean isValidSortCondition(SortCondition cond, List<Var> projectVars) { if (cond.getExpression().isVariable()) { return projectVars.contains(cond.getExpression().asVar()); } else { for (Var v : cond.getExpression().getVarsMentioned()) { if (!projectVars.contains(v)) return false; } return true; } } }
Set<Var> eVars = e.getVarsMentioned() ; for ( Var v2 : eVars )
/** * Determines whether a sort condition is valid in terms of this optimizer * * @param cond * Sort Condition * @param projectVars * Project Variables * @return True if valid, false otherwise */ private boolean isValidSortCondition(SortCondition cond, Collection<Var> projectVars, Set<Var> seenVars) { if (cond.getExpression().isVariable()) { if (projectVars.contains(cond.getExpression().asVar())) { seenVars.add(cond.getExpression().asVar()); return true; } return false; } else { for (Var v : cond.getExpression().getVarsMentioned()) { if (!projectVars.contains(v)) return false; seenVars.add(v); } return true; } } }
@Override public void visit(OpGroup opGroup) { for(Entry<Var, Expr> e : opGroup.getGroupVars().getExprs().entrySet()) { add(processVar(e.getKey())); for(Var v : e.getValue().getVarsMentioned()) { add(processVar(v)); } } for(ExprAggregator e : opGroup.getAggregators()) { add(processVar(e.getAggVar().asVar())); if (e.getExpr() != null) { for(Var v : e.getExpr().getVarsMentioned()) { add(processVar(v)); } } if (e.getAggregator().getExpr() != null) { for(Var v : e.getAggregator().getExpr().getVarsMentioned()) { add(processVar(v)); } } } }
private Placement placeProject(ExprList exprs, OpProject input) { Collection<Var> varsProject = input.getVars() ; ExprList pushed = new ExprList() ; ExprList unpushed = new ExprList() ; for ( Expr expr : exprs ) { Set<Var> exprVars = expr.getVarsMentioned() ; if ( varsProject.containsAll(exprVars) ) pushed.add(expr); else unpushed.add(expr) ; } if ( pushed.isEmpty() ) return resultNoChange(input) ; // (filter (project ...)) ===> (project (filter ...)) Op opSub = input.getSubOp() ; Placement p = transform(pushed, opSub) ; if ( p == null ) { Op op1 = OpFilter.filter(pushed, opSub) ; Op op2 = input.copy(op1) ; return result(op2, unpushed) ; } Op op1 = OpFilter.filter(p.unplaced, p.op) ; Op op2 = input.copy(op1) ; return result(op2, unpushed) ; }
Set<Var> vars = expr.getVarsMentioned() ; boolean pushed = false ;
Set<Var> exprVars = expr.getVarsMentioned() ; if ( disjoint(vars1, exprVars) ) pushed.add(expr);