public Expr deepCopy(Expr proto) { Expr result; if(proto == null) { throw new NullPointerException(); } if(proto.isConstant()) { result = deepCopy(proto.getConstant()); } else if(proto.isFunction()) { result = deepCopy(proto.getFunction()); } else if(proto.isVariable()) { result = deepCopy(proto.getExprVar()); } else { throw new RuntimeException("Don't know how to copy " + proto + " of type " + proto.getClass()); } return result; //return deepCopy(proto, ExprArgs.getArgs(proto)); }
@Override public Expr apply(@Nullable Expr expr) { Expr result; if(expr.isFunction()) { ExprFunction fn = expr.getFunction(); boolean isConcat = SqlTranslationUtils.isConcatExpr(fn); List<Expr> args = fn.getArgs(); List<Expr> newArgs = new ArrayList<Expr>(args.size()); for(Expr arg : args) { Expr tmpArg = apply(arg); Expr newArg; // FIXME if(isConcat && tmpArg.isVariable()) { ExprVar ev = tmpArg.getExprVar(); newArg = new E_Str(ev); } else { newArg = tmpArg; } newArgs.add(newArg); } result = ExprCopy.getInstance().copy(expr, newArgs); } else { result = expr; } return result; }; };
public SqlExpr translate(Expr expr, Map<String, TypeToken> typeMap) { //assert expr != null : "Null pointer exception"; if(expr == null) { throw new NullPointerException(); } //System.out.println(expr); SqlExpr result = null; if(expr.isConstant()) { result = translate(expr.getConstant()); } else if(expr.isFunction()) { ExprFunction fn = expr.getFunction(); result = translate(fn, typeMap); } else if(expr.isVariable()) { result = translate(expr.getExprVar(), typeMap); } else { throw new RuntimeException("Unknown expression type encountered: " + expr); } return result; }
Var av = ae.getExprVar().asVar(); Var bv = be.getExprVar().asVar();
public ExprHolder rewrite(Expr expr, Map<String, TypeToken> typeMap, RewriteState state) { ExprHolder result; if(expr.isConstant()) { NodeValue nodeValue = expr.getConstant(); SqlExpr sqlExpr = translate(nodeValue); result = new ExprHolder(sqlExpr); } else if(expr.isVariable()) { ExprVar var = expr.getExprVar(); SqlExpr sqlExpr = translate(var, typeMap); result = new ExprHolder(sqlExpr); } else if(expr.isFunction()) { result = rewrite(expr.getFunction(), typeMap, state); } else { throw new RuntimeException("Should not happen: " + expr); } if(result.equals(TypeToken.TypeError)) { System.err.println("Got type error for " + expr); } return result; }
public Expr normalize(Expr expr, Map<String, TypeToken> typeMap) { Expr result; if(expr == null) { result = NodeValue.nvNothing; } else if(expr.isVariable()) { result = normalize(expr.getExprVar(), typeMap); } else if(expr.isConstant()) { result = normalize(expr.getConstant(), typeMap); } else if(expr.isFunction()) { result = normalize(expr.getFunction(), typeMap); } else { throw new RuntimeException("Unknown expression type: " + expr); } return result; //return MultiMethod.invokeStatic(ExprDatatypeNorm.class, "_nomalize", expr, columnToDatatype); }
/** * If a is a variable and b is a constant, then a mapping of the variable to the * constant is put into the map, and true is returned. * Otherwise, nothing is changed, and false is returned. * * A mapping of a variable is set to null, if it is mapped to multiple constants * * * @param a * @param b * @return */ public static Pair<Var, NodeValue> extractVarConstantDirected(Expr a, Expr b) { if(!(a.isVariable() && b.isConstant())) { return null; } Var var = a.getExprVar().asVar(); NodeValue nodeValue = b.getConstant(); return Pair.create(var, nodeValue); }
public SqlExpr translateX(Expr expr, Map<Var, Expr> binding, Map<String, TypeToken> typeMap) { //assert expr != null : "Null pointer exception"; if(expr == null) { throw new NullPointerException(); } //System.out.println(expr); SqlExpr result = null; if(expr.isConstant()) { result = translate(expr.getConstant()); } else if(expr.isFunction()) { ExprFunction fn = expr.getFunction(); result = translate(fn, binding, typeMap); } else if(expr.isVariable()) { result = translate(expr.getExprVar(), binding, typeMap); //result = expr; if(binding != null) { Expr boundExpr = binding.get(expr.asVar()); if(boundExpr != null) { result = translateX(boundExpr, null, typeMap); // Do not forward the binding } } } else { throw new RuntimeException("Unknown expression type encountered: " + expr); } return result; }
@Override public SDBConstraint recognize(Expr expr) { MapResult rMap = null ; if ( ( rMap = equalsString1.match(expr) ) != null ) { Var var = rMap.get("a1").getExprVar().asVar() ; String str = rMap.get("a2").getConstant().getString() ; return new StringEqualsSqlGen(expr, equalsString1, true) ; } return null ; } }
@Override public SDBConstraint recognize(Expr expr) { MapResult rMap = null ; if ( ( rMap = regex1.match(expr) ) != null ) { Var var = rMap.get("a1").getExprVar().asVar() ; String pattern = rMap.get("a2").getConstant().getString() ; return new RegexSqlGen(expr, regex1, pattern, null, true) ; } if ( ( rMap = regex1_i.match(expr) ) != null ) { Var var = rMap.get(Var.alloc("a1")).getExprVar().asVar() ; String pattern = rMap.get(Var.alloc("a2")).getConstant().getString() ; return new RegexSqlGen(expr, regex1_i, pattern, "i", true) ; } return null ; } }
@Override public SqlExpr compile(Scope scope) { MapResult rMap = exprPattern.match(getExpr()) ; if ( rMap == null ) throw new SDBException("Couldn't compile after all: "+getExpr()) ; //log.info("equalsString - Matched: ?a1 = "+rMap.get("a1")+" : ?a2 = "+rMap.get("a2")) ; Var var = rMap.get("a1").getExprVar().asVar() ; String str = rMap.get("a2").getConstant().getString() ; if ( ! scope.hasColumnForVar(var) ) { LoggerFactory.getLogger(this.getClass()).error("Variable '"+var+"' not in scope") ; return null ; } SqlColumn vCol = scope.findScopeForVar(var).getColumn() ; SqlColumn lexCol = new SqlColumn(vCol.getTable(), "lex") ; SqlColumn vTypeCol = new SqlColumn(vCol.getTable(), "type") ; // "is a string" SqlExpr isStr = new S_Equal(vTypeCol, new SqlConstant(ValueType.STRING.getTypeId())) ; isStr.addNote("is a string" ) ; // Equality SqlExpr strEquals = new S_Equal(lexCol, new SqlConstant(str)) ; isStr.addNote(getExpr().toString()) ; return new S_And(isStr, strEquals) ; }
@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) ; }
throw new SDBException("Couldn't compile after all: "+getExpr()) ; Var var = rMap.get(Var.alloc("a1")).getExprVar().asVar() ; String pattern = rMap.get(Var.alloc("a2")).getConstant().getString() ;
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) ; }