@Override final public Expr copySubstitute(Binding binding, boolean foldConstants) { Expr e1 = (expr1 == null ? null : expr1.copySubstitute(binding, foldConstants)) ; Expr e2 = (expr2 == null ? null : expr2.copySubstitute(binding, foldConstants)) ; Expr e3 = (expr3 == null ? null : expr3.copySubstitute(binding, foldConstants)) ; if ( foldConstants) { try { if ( e1 != null && e2 != null && e3 != null && e1.isConstant() && e2.isConstant() && e3.isConstant() ) return eval(e1.getConstant(), e2.getConstant(), e3.getConstant()) ; } catch (ExprEvalException ex) { /* Drop through */ } } return copy(e1, e2, e3) ; }
@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) ; } }
private static Pair<Var, NodeValue> preprocess(Expr e) { if (!(e instanceof E_NotEquals)) return null; ExprFunction2 eq = (ExprFunction2) e; Expr left = eq.getArg1(); Expr right = eq.getArg2(); Var var = null; NodeValue constant = null; if (left.isVariable() && right.isConstant()) { var = left.asVar(); constant = right.getConstant(); } else if (right.isVariable() && left.isConstant()) { var = right.asVar(); constant = left.getConstant(); } if (var == null || constant == null) return null; // Final check for "!=" where a FILTER != can do value matching when the // graph does not. // Value based? if (!ARQ.isStrictMode() && constant.isLiteral()) return null; return Pair.create(var, constant); }
/** Special form evaluation (example, don't eval the arguments first) */ @Override protected NodeValue evalSpecial(Binding binding, FunctionEnv env) { NodeValue nv = condition.eval(binding, env) ; if ( condition.isSatisfied(binding, env) ) return thenExpr.eval(binding, env) ; else return elseExpr.eval(binding, env) ; }
private void init(Expr pattern, Expr flags) { if ( pattern.isConstant() && pattern.getConstant().isString() && ( flags==null || flags.isConstant() ) ) regexEngine = makeRegexEngine(pattern.getConstant(), (flags==null)?null:flags.getConstant()) ; }
if (expr1.isVariable()) { variable = expr1; } else { if (func.getArg1().isConstant()) { constant = SemanticElement.removePrefix(NodeFactory.createURI(expr1.getConstant() .asString())); } else { constant = SemanticElement.removePrefix(NodeFactory.createURI(expr2.getConstant() .asString())); this.atomicQuery.getVarIndex(variable.getVarName()); .compareTo(constant); if (func.getArg1().isVariable()) { if (func.getOpName().equals(">") && compareToUpperBound > 0) { if (func.getArg1().getVarName().equals( func.getArg2().getVarName())) { return new E_Bool(true);
private static Pair<Var, Var> preprocess(Op opLeft, Op opRight, Expr e) { if (!(e instanceof E_Equals) && !(e instanceof E_SameTerm)) return null; ExprFunction2 eq = (ExprFunction2) e; // An equals or same term implicit join Expr left = eq.getArg1(); Expr right = eq.getArg2(); if (!left.isVariable() || !right.isVariable()) { return null; } if (left.equals(right)) { return null; } // If neither variable is visible in RHS optimization does not apply Collection<Var> rhsVars = OpVars.visibleVars(opRight); if (!rhsVars.contains(left.asVar()) && !rhsVars.contains(right.asVar())) return null; if (e instanceof E_Equals) { // Is a safe equals for this optimization? Tuple<Set<Var>> varsByPosition = OpVars.mentionedVarsByPosition(opLeft, opRight); if (!isSafeEquals(varsByPosition, left.asVar(), right.asVar())) return null; } return Pair.create(left.asVar(), right.asVar()); }
public void format(Expr expr) { expr.visit(visitor) ; }
/** * 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; } } }
public static Expr substitute(Expr expr, Binding binding) { if ( isNotNeeded(binding) ) return expr ; return expr.copySubstitute(binding) ; }
@Override public QueryIterator exec(Binding binding, Node name, ExprList args, ExecutionContext execCxt) { // Eval if possible. ExprList evalArgs = new ExprList() ; for (Expr e : args) { if ( e.isVariable() ) { Var v = e.getExprVar().asVar() ; // Special case - allow unevaluated variables. if ( binding.contains(v) ) evalArgs.add(e.eval(binding, execCxt)) ; else evalArgs.add(e) ; } else { NodeValue x = e.eval(binding, execCxt) ; evalArgs.add(x) ; } } return execEval(binding, evalArgs, execCxt) ; }
public void visit(ElementFilter el) { out.print("FILTER ") ; Expr expr = el.getExpr() ; FmtExpr v = new FmtExpr(out, context) ; // This assumes that complex expressions are bracketted // (parens) as necessary except for some cases: // Plain variable or constant boolean addParens = false ; if ( expr.isVariable() ) addParens = true ; if ( expr.isConstant() ) addParens = true ; if ( addParens ) out.print("( ") ; v.format(expr) ; if ( addParens ) out.print(" )") ; }
@Override public NodeValue evalSpecial(Binding binding, FunctionEnv env) { try { expr.eval(binding, env) ; return NodeValue.TRUE ; } catch (VariableNotBoundException ex) { return NodeValue.FALSE ; } }
SortCondition scBuilder(Item item) { int direction = Query.ORDER_DEFAULT ; if ( item.isTagged("asc") || item.isTagged("desc") ) { BuilderLib.checkList(item) ; BuilderLib.checkLength(2, item.getList(), "Direction corrupt") ; if ( item.isTagged("asc") ) direction = Query.ORDER_ASCENDING ; else direction = Query.ORDER_DESCENDING ; item = item.getList().get(1) ; } Expr expr = BuilderExpr.buildExpr(item) ; if ( expr.isVariable() ) return new SortCondition(expr.getExprVar().asVar(), direction) ; else return new SortCondition(expr, direction) ; }
public static Expr transform(NodeTransform nodeTransform, Expr expr) { return expr.applyNodeTransform(nodeTransform) ; }
changed = true ; Aggregator a2 = aggregator.copy(e2) ; aggs2.add(new ExprAggregator(eVar2.asVar(), a2)) ;
private static Pair<Var, Var> preprocess(Op subOp, Expr e) { // TODO Should also handle the case of && as TransformImplicitLeftJoin // is already capable of doing if (!(e instanceof E_Equals) && !(e instanceof E_SameTerm)) return null; ExprFunction2 eq = (ExprFunction2) e; Expr left = eq.getArg1(); Expr right = eq.getArg2(); if (!left.isVariable() || !right.isVariable()) { return null; } if (left.equals(right)) { return null; } if (e instanceof E_Equals) { // Is a safe equals for this optimization? Tuple<Set<Var>> varsByPosition = OpVars.mentionedVarsByPosition(subOp); if (!isSafeEquals(varsByPosition, left.asVar(), right.asVar())) return null; } return Pair.create(left.asVar(), right.asVar()); }
public void walk(Expr expr) { expr.visit(visitor) ; }
private void init(Expr pattern, Expr flags) { if ( pattern.isConstant() && pattern.getConstant().isString() && ( flags==null || flags.isConstant() ) ) regexEngine = makeRegexEngine(pattern.getConstant(), (flags==null)?null:flags.getConstant()) ; }
/** * 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; } } }