@Override public Void visit(LetClause lc, Void arg) throws CompilationException { lc.getBindingExpr().accept(this, arg); return null; }
@Override public Void visit(LetClause lc, Void arg) throws CompilationException { lc.getBindingExpr().accept(this, arg); return null; }
@Override public Void visit(LetClause letClause, Collection<VariableExpr> freeVars) throws CompilationException { letClause.getBindingExpr().accept(this, freeVars); return null; }
@Override public Boolean visit(LetClause lc, ILangExpression arg) throws CompilationException { return visit(lc.getBindingExpr(), arg); }
private Map<Expression, Expression> extractLetBindingVariableExpressionMappings(List<LetClause> letClauses) throws CompilationException { Map<Expression, Expression> varExprMap = new HashMap<>(); for (LetClause lc : letClauses) { // inline let variables one by one iteratively. lc.setBindingExpr(SqlppRewriteUtil.substituteExpression(lc.getBindingExpr(), varExprMap, context)); varExprMap.put(lc.getVarExpr(), lc.getBindingExpr()); } return varExprMap; } }
@Override public boolean equals(Object object) { if (this == object) { return true; } if (!(object instanceof LetClause)) { return false; } LetClause target = (LetClause) object; return bindExpr.equals(target.getBindingExpr()) && varExpr.equals(target.getVarExpr()); }
private Map<VariableExpr, Expression> extractLetBindingVariables(List<Clause> clauses, GroupbyClause cuttingGbyClause) throws CompilationException { Map<VariableExpr, Expression> varExprMap = new HashMap<VariableExpr, Expression>(); int gbyIndex = clauses.indexOf(cuttingGbyClause); for (int i = gbyIndex + 1; i < clauses.size(); i++) { Clause cl = clauses.get(i); if (cl.getClauseType() == ClauseType.LET_CLAUSE) { LetClause letClause = (LetClause) cl; // inline let variables one by one iteratively. letClause.setBindingExpr((Expression) AQLVariableSubstitutionUtil .substituteVariable(letClause.getBindingExpr(), varExprMap)); varExprMap.put(letClause.getVarExpr(), letClause.getBindingExpr()); } } return varExprMap; }
@Override public Boolean visit(LetClause lc, List<FunctionDecl> arg) throws CompilationException { Pair<Boolean, Expression> p = inlineUdfsInExpr(lc.getBindingExpr(), arg); lc.setBindingExpr(p.second); return p.first; }
@Override public Expression visit(LetClause letClause, ILangExpression arg) throws CompilationException { letClause.setBindingExpr(visit(letClause.getBindingExpr(), letClause)); return null; }
@Override public Expression visit(LetClause letClause, ILangExpression arg) throws CompilationException { letClause.setBindingExpr(visit(letClause.getBindingExpr(), letClause)); return null; }
@Override public Void visit(LetClause lc, Integer step) throws CompilationException { out.print(skip(step) + "with "); Expression bindingExpr = lc.getBindingExpr(); bindingExpr.accept(this, step + 2); out.print(" as "); lc.getVarExpr().accept(this, step + 2); out.println(); return null; }
@Override public Void visit(LetClause lc, Integer step) throws CompilationException { out.print(skip(step) + "with "); lc.getVarExpr().accept(this, step + 2); out.print(" as "); Expression bindingExpr = lc.getBindingExpr(); bindingExpr.accept(this, step + 2); out.println(); return null; }
@Override public Void visit(LetClause lc, Integer step) throws CompilationException { out.print(skip(step) + "let "); lc.getVarExpr().accept(this, 0); out.print(assignSymbol); lc.getBindingExpr().accept(this, step + 1); out.println(); return null; }
private void visitLetClause(LetClause lc, Integer step, boolean startLet, boolean hasConsequentLet) throws CompilationException { if (startLet) { out.print(skip(step) + "with "); } else { out.print(skip(step + 3)); } lc.getVarExpr().accept(this, step + 3); out.print(" as "); lc.getBindingExpr().accept(this, step + 3); if (hasConsequentLet) { out.print(COMMA); } out.println(); }
@Override public Void visit(LetClause lc, Integer step) throws CompilationException { out.print(skip(step) + "Let "); lc.getVarExpr().accept(this, 0); out.println(skip(step + 1) + ":="); lc.getBindingExpr().accept(this, step + 1); return null; }
LetClause letClause = with.next(); Expression expr = letClause.getBindingExpr(); Expression newBindingExpr = SqlppRewriteUtil.substituteExpression(expr, varExprMap, context); letClause.setBindingExpr(newBindingExpr); Expression bindingExpr = letClause.getBindingExpr();
@Override public LetClause visit(LetClause letClause, Void arg) throws CompilationException { LetClause copy = new LetClause((VariableExpr) letClause.getVarExpr().accept(this, arg), (Expression) letClause.getBindingExpr().accept(this, arg)); copy.setSourceLocation(letClause.getSourceLocation()); return copy; }
@Override public Expression visit(LetClause letClause, ILangExpression arg) throws CompilationException { scopeChecker.extendCurrentScope(); letClause.setBindingExpr(visit(letClause.getBindingExpr(), letClause)); VariableExpr varExpr = letClause.getVarExpr(); addNewVarSymbolToScope(scopeChecker.getCurrentScope(), varExpr.getVar(), varExpr.getSourceLocation()); return null; }
@Override public Pair<ILangExpression, VariableSubstitutionEnvironment> visit(LetClause lc, VariableSubstitutionEnvironment env) throws CompilationException { Pair<ILangExpression, VariableSubstitutionEnvironment> p1 = lc.getBindingExpr().accept(this, env); VariableExpr varExpr = lc.getVarExpr(); VariableExpr newVe = generateNewVariable(context, varExpr); LetClause newLet = new LetClause(newVe, (Expression) p1.first); newLet.setSourceLocation(lc.getSourceLocation()); return new Pair<>(newLet, VariableCloneAndSubstitutionUtil.eliminateSubstFromList(lc.getVarExpr(), env)); }
@Override public Pair<ILogicalOperator, LogicalVariable> visit(LetClause lc, Mutable<ILogicalOperator> tupSource) throws CompilationException { LogicalVariable v; AssignOperator returnedOp; Expression bindingExpr = lc.getBindingExpr(); SourceLocation sourceLoc = bindingExpr.getSourceLocation(); if (bindingExpr.getKind() == Kind.VARIABLE_EXPRESSION) { VariableExpr bindingVarExpr = (VariableExpr) bindingExpr; ILogicalExpression prevVarRef = translateVariableRef(bindingVarExpr); v = context.newVarFromExpression(lc.getVarExpr()); returnedOp = new AssignOperator(v, new MutableObject<>(prevVarRef)); returnedOp.getInputs().add(tupSource); returnedOp.setSourceLocation(sourceLoc); } else { v = context.newVarFromExpression(lc.getVarExpr()); Pair<ILogicalExpression, Mutable<ILogicalOperator>> eo = langExprToAlgExpression(bindingExpr, tupSource); returnedOp = new AssignOperator(v, new MutableObject<>(eo.first)); returnedOp.getInputs().add(eo.second); returnedOp.setSourceLocation(sourceLoc); } return new Pair<>(returnedOp, v); }