@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 Entry<Var, Var> tryGetVarVar(Expr a, Expr b) { Entry<Var, Var> result = a.isVariable() && b.isVariable() ? Maps.immutableEntry(a.asVar(), b.asVar()) : null; 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; }
@Override public boolean match(Var var, Expr expr, MapResult resultMap) { if ( ! expr.isVariable() ) throw new NoExprMatch("ActionMatchVar: Not a variable: "+expr) ; return super.match(var, expr, resultMap) ; } }
@Override public SqlExprType getType() { SqlExprType result; if(expr.isConstant()) { result = SqlExprType.Constant; } else if(expr.isVariable()) { result = SqlExprType.Variable; } else if(expr.isFunction()) { result = SqlExprType.Function; } else { throw new RuntimeException("Should not happen: could not determine expression type of " + expr); } return result; }
public static int classify(Expr e) { int result = e.isConstant() ? 0 : e.isVariable() ? 1 : e.isFunction() ? 2 : 3; 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; }
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); } }
@SuppressWarnings("unchecked") public static <T extends ExprFunction2> T normalize(T expr) { Expr a = expr.getArg1(); Expr b = expr.getArg2(); Expr result = a.isConstant() && b.isVariable() ? expr.copy(b, a) : expr ; return (T)result; }
@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; }
private static void testVar(String string, String rightVarName) { Expr expr = parse(string) ; assertTrue("Not a NodeVar: "+expr, expr.isVariable()) ; ExprVar v = (ExprVar)expr ; assertEquals("Different variable names", rightVarName, v.getVarName()) ; }