@Override public RestrictionImpl getRestriction(Expr expr) { if(expr.isVariable()) { return restrictions.get(expr.asVar()); } else { return exprToRestriction.get(expr); } }
public static String toString(Entry<Var, Expr> e) { Var v = e.getKey(); Expr x = e.getValue(); String result = x.isVariable() && x.asVar().equals(v) ? "" + v : "(" + x + " AS " + v + ")"; return result; }
public static String toString(Entry<Var, Expr> e) { Var v = e.getKey(); Expr x = e.getValue(); String result = x.isVariable() && x.asVar().equals(v) ? "" + v : "(" + x + " AS " + v + ")"; return result; }
public static String toString(Entry<Var, Expr> e) { Var v = e.getKey(); Expr x = e.getValue(); String result = x.isVariable() && x.asVar().equals(v) ? "" + v : "(" + x + " AS " + v + ")"; return result; }
public static String toString(Entry<Var, Expr> e) { Var v = e.getKey(); Expr x = e.getValue(); String result = x.isVariable() && x.asVar().equals(v) ? "" + v : "(" + x + " AS " + v + ")"; return result; }
public static String getColumnName(Expr expr) { String result; if(expr.isVariable()) { result = expr.asVar().getName(); } else { throw new RuntimeException("plainLiteral: first argument must be a column reference"); } return result; }
public static String getColumnName(Expr expr) { String result; if(expr.isVariable()) { result = expr.asVar().getName(); } else { throw new RuntimeException("plainLiteral: first argument must be a column reference"); } return result; }
public static Entry<Var, Node> tryGetVarConst(Expr a, Expr b) { Var v = a.isVariable() ? a.asVar() // Hack to unwrap variables from NodeValue : Optional.of(a).filter(Expr::isConstant) .map(Expr::getConstant).map(NodeValue::asNode).filter(Node::isVariable).map(n -> (Var)n) .orElse(null) ; Entry<Var, Node> result = v != null && b.isConstant() ? Maps.immutableEntry(v, b.getConstant().asNode()) : null ; return result; }
private static Pair<Var, Var> preprocess(Op subOp, Expr e) { 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 static boolean isGroupedOnlyByVar(Query query, Var groupVar) { boolean result = false; boolean hasOneGroup = query.getGroupBy().size() == 1; if(hasOneGroup) { Expr expr = query.getGroupBy().getExprs().values().iterator().next(); if(expr instanceof ExprVar) { Var v = expr.asVar(); result = v.equals(groupVar); } } return result; }
public static VarExprList createFromMap(Map<Var, Expr> map) { VarExprList result = new VarExprList(); for(Entry<Var, Expr> e : map.entrySet()) { Var v = e.getKey(); Expr w = e.getValue(); if(w.isVariable() && v.equals(w.asVar())) { result.add(v); } else { result.add(v, w); } } return result; } public static VarExprList createFromVarMap(Map<Var, Var> varMap) {
public RestrictionSetImpl getRestriction(Expr expr) { if(expr.isVariable()) { return restrictions.get(expr.asVar()); } else { return new RestrictionSetImpl(); //return null; //return exprToRestriction.get(expr); } }
public static Entry<Var, Node> extractEquality(Collection<? extends Expr> clause) { Entry<Var, Node> result = null; if(clause.size() == 1) { Expr expr = clause.iterator().next(); if(expr instanceof E_Equals) { E_Equals eq = (E_Equals)expr; eq = normalize(eq); Expr a = eq.getArg1(); Expr b = eq.getArg2(); if(a.isVariable() && b.isConstant()) { Var v = a.asVar(); Node c = b.getConstant().getNode(); result = new SimpleEntry<>(v, c); } } } return result; }
/** * 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; } } }
@Override public void startElement(ElementBind el) { if(preBoundVars.contains(el.getVar().getVarName())) { if(SH.valueVar.getVarName().equals(el.getVar().getVarName()) && el.getExpr().isVariable() && el.getExpr().asVar().equals(SH.thisVar)) { // Ignore clauses injected by engine } else { results.add("Query must not reassign the pre-bound variable " + el.getVar() + " in a BIND clause"); } } }
@Override public void startElement(ElementBind el) { if(preBoundVars.contains(el.getVar().getVarName())) { if(SH.valueVar.getVarName().equals(el.getVar().getVarName()) && el.getExpr().isVariable() && el.getExpr().asVar().equals(SH.thisVar)) { // Ignore clauses injected by engine } else { results.add("Query must not reassign the pre-bound variable " + el.getVar() + " in a BIND clause"); } } }
public void addGroupBy(Var v, Expr expr) { if ( v == null ) v = allocInternVar() ; if ( expr.isVariable() && v.isAllocVar() ) { // It was (?x) with no AS - keep the name by adding by variable. addGroupBy(expr.asVar()) ; return ; } groupVars.add(v, expr) ; }
private boolean deriveRestrictionEquals(Expr a, Expr b) { if(a.isVariable() && b.isConstant()) { RestrictionImpl r = getOrCreateRestriction(a.asVar()); r.stateNode(b.getConstant().asNode()); return true; } return false; }
public Expr _transform(ExprAggregator eAgg) { ExprList newAggExpr = this.transformMM(eAgg.getAggregator().getExprList()); Aggregator newAgg = eAgg.getAggregator().copy(newAggExpr); Expr newAggVar = this.transformMM(eAgg.getAggVar()); //ExprCopy.getInstance().copy(expr, eAgg.get) Expr result = new ExprAggregator(newAggVar.asVar(), newAgg); return result; //System.out.println("Aggregate"); //eAgg.getAggregator(). //AggCount //eAgg.get //throw new NotImplementedException(); } }