@Override public Query visit(Query q, Void arg) throws CompilationException { Query copy = new Query(q.isExplain(), q.isTopLevel(), (Expression) q.getBody().accept(this, arg), q.getVarCounter()); copy.setSourceLocation(q.getSourceLocation()); return copy; }
@Override public Pair<ILangExpression, VariableSubstitutionEnvironment> visit(Query q, VariableSubstitutionEnvironment env) throws CompilationException { Query newQ = new Query(q.isExplain()); Pair<ILangExpression, VariableSubstitutionEnvironment> p1 = q.getBody().accept(this, env); newQ.setBody((Expression) p1.first); newQ.setSourceLocation(q.getSourceLocation()); return new Pair<>(newQ, p1.second); }
/** * Substitutes expression with replacement expressions according to the exprMap. * * @param expression * , * an input expression. * @param exprMap * a map that maps expressions to their corresponding replacement expressions. * @return an expression, where sub-expressions of the input expression (including the input expression itself) * are replaced with deep copies with their mapped replacements in the exprMap if there exists such a * replacement expression. * @throws CompilationException */ public static Expression substituteExpression(Expression expression, Map<Expression, Expression> exprMap, LangRewritingContext context) throws CompilationException { if (exprMap.isEmpty()) { return expression; } // Creates a wrapper query for the expression so that if the expression itself // is the key, it can also be replaced. Query wrapper = new Query(false); wrapper.setSourceLocation(expression.getSourceLocation()); wrapper.setBody(expression); // Creates a substitution visitor. SqlppSubstituteExpressionVisitor visitor = new SqlppSubstituteExpressionVisitor(context, exprMap); wrapper.accept(visitor, wrapper); return wrapper.getBody(); } }
@Override public Void visit(Query q, Integer step) throws CompilationException { if (q.getBody() != null) { q.getBody().accept(this, step); } if (q.isTopLevel()) { out.println(SEMICOLON); } return null; }
private Expression rewriteFunctionBody(FunctionDecl fnDecl) throws CompilationException { SourceLocation sourceLoc = fnDecl.getSourceLocation(); Query wrappedQuery = new Query(false); wrappedQuery.setSourceLocation(sourceLoc); wrappedQuery.setBody(fnDecl.getFuncBody()); wrappedQuery.setTopLevel(false); String fnNamespace = fnDecl.getSignature().getNamespace(); Dataverse defaultDataverse = metadataProvider.getDefaultDataverse(); Dataverse fnDataverse; if (fnNamespace == null || fnNamespace.equals(defaultDataverse.getDataverseName())) { fnDataverse = defaultDataverse; } else { try { fnDataverse = metadataProvider.findDataverse(fnNamespace); } catch (AlgebricksException e) { throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, e, sourceLoc, fnNamespace); } } metadataProvider.setDefaultDataverse(fnDataverse); try { IQueryRewriter queryRewriter = rewriterFactory.createQueryRewriter(); queryRewriter.rewrite(declaredFunctions, wrappedQuery, metadataProvider, context, true, fnDecl.getParamList()); return wrappedQuery.getBody(); } finally { metadataProvider.setDefaultDataverse(defaultDataverse); } }
final public Query Query() throws ParseException, ParseException { Query query = new Query(false); Expression expr; expr = Expression(); query.setBody(expr); query.setVarCounter(getVarCounter()); {if (true) return query;} throw new Error("Missing return statement in function"); }
final public Query Query(boolean explain) throws ParseException, ParseException { Query query = new Query(explain); Expression expr; switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { throw new ParseException(); query.setBody(expr); query.setSourceLocation(expr.getSourceLocation()); {if (true) return query;} throw new Error("Missing return statement in function");
@Override public Expression visit(Query q, ILangExpression arg) throws CompilationException { q.setBody(visit(q.getBody(), q)); q.setVarCounter(scopeChecker.getVarCounter()); return null; }
@Override public Expression getBody() { return query.getBody(); }
var = ExpressionToVariableUtil.getGeneratedVariable(query.getBody(), true); query.setTopLevel(true); UpsertStatement stmt = new UpsertStatement(nameComponents.first, nameComponents.second, query, getVarCounter(), var, returnExpression);
@Override public Void visit(DeleteStatement deleteStmt, Void visitArg) { List<Expression> arguments = new ArrayList<>(); Identifier dataverseName = deleteStmt.getDataverseName(); Identifier datasetName = deleteStmt.getDatasetName(); String arg = dataverseName == null ? datasetName.getValue() : dataverseName.getValue() + "." + datasetName.getValue(); LiteralExpr argumentLiteral = new LiteralExpr(new StringLiteral(arg)); arguments.add(argumentLiteral); CallExpr callExpression = new CallExpr(new FunctionSignature(BuiltinFunctions.DATASET), arguments); List<Clause> clauseList = new ArrayList<>(); VariableExpr var = deleteStmt.getVariableExpr(); Clause forClause = new ForClause(var, callExpression); clauseList.add(forClause); Clause whereClause = null; Expression condition = deleteStmt.getCondition(); if (condition != null) { whereClause = new WhereClause(condition); clauseList.add(whereClause); } VariableExpr returnExpr = new VariableExpr(var.getVar()); returnExpr.setIsNewVar(false); FLWOGRExpression flowgr = new FLWOGRExpression(clauseList, returnExpr); Query query = new Query(false); query.setBody(flowgr); deleteStmt.setQuery(query); return null; }
whereClause = new WhereClause(whereClauseQuery.getBody()); SelectSetOperation selectSetOperation = new SelectSetOperation(new SetOperationInput(selectBlock, null), null); SelectExpression body = new SelectExpression(null, selectSetOperation, null, null, true); Query query = new Query(false, true, body, 0); return query;
query.setTopLevel(true); {if (true) return new InsertStatement(nameComponents.first, nameComponents.second, query, getVarCounter(), var, returnExpression);}
@Override public Void visit(InsertStatement insert, Integer step) throws CompilationException { out.print(skip(step) + "insert into " + datasetSymbol + generateFullName(insert.getDataverseName(), insert.getDatasetName())); out.print("("); insert.getQuery().accept(this, step + 2); out.print(")"); out.println(SEMICOLON); return null; }
base = new MutableObject<>(baseOp); SourceLocation sourceLoc = expr.getSourceLocation(); Pair<ILogicalOperator, LogicalVariable> p = expr.accept(this, base); ArrayList<Mutable<ILogicalOperator>> globalPlanRoots = new ArrayList<>(); ILogicalOperator topOp = p.first;
@Override public void setBody(Expression body) { query.setBody(body); }
final boolean isLoad = statement != null && statement.getKind() == Statement.Kind.LOAD; final SourceLocation sourceLoc = query != null ? query.getSourceLocation() : statement != null ? statement.getSourceLocation() : null; final boolean isExplainOnly = isQuery && query.isExplain();
MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); bActiveTxn = false; return query.isExplain() || !sessionConfig.isExecuteQuery() ? null : jobSpec; } catch (Exception e) { LOGGER.log(Level.INFO, e.getMessage(), e);
Query wrappedQuery = new Query(false); wrappedQuery.setSourceLocation(sourceLoc); wrappedQuery.setBody(cfs.getFunctionBodyExpression()); wrappedQuery.setTopLevel(false); List<VarIdentifier> paramVars = new ArrayList<>(); for (String v : cfs.getParamList()) {