Examples with Expression org.apache.asterix.lang.common.base.Expression used on opensource projects

Example 11 with Expression

use of org.apache.asterix.lang.common.base.Expression in project asterixdb by apache.

the class SqlppGroupByVisitor method visit.

@Override
public Expression visit(SelectBlock selectBlock, ILangExpression arg) throws CompilationException {
    // Traverses the select block in the order of "from", "let"s, "where",
    // "group by", "let"s, "having" and "select".
    FromClause fromClause = selectBlock.getFromClause();
    if (selectBlock.hasFromClause()) {
        fromClause.accept(this, arg);
    }
    if (selectBlock.hasLetClauses()) {
        List<LetClause> letList = selectBlock.getLetList();
        for (LetClause letClause : letList) {
            letClause.accept(this, arg);
        }
    }
    if (selectBlock.hasWhereClause()) {
        selectBlock.getWhereClause().accept(this, arg);
    }
    if (selectBlock.hasGroupbyClause()) {
        GroupbyClause groupbyClause = selectBlock.getGroupbyClause();
        groupbyClause.accept(this, fromClause);
        Collection<VariableExpr> visibleVarsInCurrentScope = SqlppVariableUtil.getBindingVariables(groupbyClause);
        VariableExpr groupVar = groupbyClause.getGroupVar();
        Set<VariableExpr> groupFieldVars = getGroupFieldVariables(groupbyClause);
        Collection<VariableExpr> freeVariablesInGbyLets = new HashSet<>();
        if (selectBlock.hasLetClausesAfterGroupby()) {
            List<LetClause> letListAfterGby = selectBlock.getLetListAfterGroupby();
            for (LetClause letClauseAfterGby : letListAfterGby) {
                letClauseAfterGby.accept(this, arg);
                // Rewrites each let clause after the group-by.
                SqlppRewriteUtil.rewriteExpressionUsingGroupVariable(groupVar, groupFieldVars, letClauseAfterGby, context);
                Collection<VariableExpr> freeVariablesInLet = SqlppVariableUtil.getFreeVariables(letClauseAfterGby.getBindingExpr());
                freeVariablesInLet.removeAll(visibleVarsInCurrentScope);
                freeVariablesInGbyLets.addAll(freeVariablesInLet);
                visibleVarsInCurrentScope.add(letClauseAfterGby.getVarExpr());
            }
        }
        Collection<VariableExpr> freeVariables = new HashSet<>();
        if (selectBlock.hasHavingClause()) {
            // Rewrites the having clause.
            HavingClause havingClause = selectBlock.getHavingClause();
            havingClause.accept(this, arg);
            SqlppRewriteUtil.rewriteExpressionUsingGroupVariable(groupVar, groupFieldVars, havingClause, context);
            freeVariables.addAll(SqlppVariableUtil.getFreeVariables(havingClause));
        }
        SelectExpression parentSelectExpression = (SelectExpression) arg;
        // We cannot rewrite ORDER BY and LIMIT if it's a SET operation query.
        if (!parentSelectExpression.getSelectSetOperation().hasRightInputs()) {
            if (parentSelectExpression.hasOrderby()) {
                // Rewrites the ORDER BY clause.
                OrderbyClause orderbyClause = parentSelectExpression.getOrderbyClause();
                orderbyClause.accept(this, arg);
                SqlppRewriteUtil.rewriteExpressionUsingGroupVariable(groupVar, groupFieldVars, orderbyClause, context);
                freeVariables.addAll(SqlppVariableUtil.getFreeVariables(orderbyClause));
            }
            if (parentSelectExpression.hasLimit()) {
                // Rewrites the LIMIT clause.
                LimitClause limitClause = parentSelectExpression.getLimitClause();
                limitClause.accept(this, arg);
                SqlppRewriteUtil.rewriteExpressionUsingGroupVariable(groupVar, groupFieldVars, limitClause, context);
                freeVariables.addAll(SqlppVariableUtil.getFreeVariables(limitClause));
            }
        }
        // Visits the select clause.
        SelectClause selectClause = selectBlock.getSelectClause();
        selectClause.accept(this, arg);
        // Rewrites the select clause.
        SqlppRewriteUtil.rewriteExpressionUsingGroupVariable(groupVar, groupFieldVars, selectClause, context);
        freeVariables.addAll(SqlppVariableUtil.getFreeVariables(selectClause));
        freeVariables.removeAll(visibleVarsInCurrentScope);
        // Gets the final free variables.
        freeVariables.addAll(freeVariablesInGbyLets);
        // Gets outer scope variables.
        Collection<VariableExpr> decorVars = SqlppVariableUtil.getLiveVariables(scopeChecker.getCurrentScope(), true);
        decorVars.removeAll(visibleVarsInCurrentScope);
        // Need path resolution or not?
        boolean needResolution = !decorVars.containsAll(freeVariables);
        // Otherwise, we only need to retain used free variables.
        if (needResolution) {
            // Tracks used variables, including WITH variables.
            decorVars.retainAll(freeVariables);
            // Adds all non-WITH outer scope variables, for path resolution.
            Collection<VariableExpr> visibleOuterScopeNonWithVars = SqlppVariableUtil.getLiveVariables(scopeChecker.getCurrentScope(), false);
            visibleOuterScopeNonWithVars.removeAll(visibleVarsInCurrentScope);
            decorVars.addAll(visibleOuterScopeNonWithVars);
        } else {
            // Only retains used free variables.
            decorVars.retainAll(freeVariables);
        }
        if (!decorVars.isEmpty()) {
            // Adds used WITH variables.
            Collection<VariableExpr> visibleOuterScopeNonWithVars = SqlppVariableUtil.getLiveVariables(scopeChecker.getCurrentScope(), false);
            visibleOuterScopeNonWithVars.retainAll(freeVariables);
            decorVars.addAll(visibleOuterScopeNonWithVars);
            // Adds necessary decoration variables for the GROUP BY.
            // NOTE: we need to include WITH binding variables so as they can be evaluated before
            // the GROUP BY instead of being inlined as part of nested pipepline. The current optimzier
            // is not able to optimize the latter case. The following query is such an example:
            // asterixdb/asterix-app/src/test/resources/runtimets/queries_sqlpp/dapd/q2-11
            List<GbyVariableExpressionPair> decorList = new ArrayList<>();
            for (VariableExpr var : decorVars) {
                decorList.add(new GbyVariableExpressionPair((VariableExpr) SqlppRewriteUtil.deepCopy(var), (Expression) SqlppRewriteUtil.deepCopy(var)));
            }
            groupbyClause.getDecorPairList().addAll(decorList);
        }
    } else {
        selectBlock.getSelectClause().accept(this, arg);
    }
    return null;
}

Example 12 with Expression

use of org.apache.asterix.lang.common.base.Expression in project asterixdb by apache.

the class InlineColumnAliasVisitor method mapRecordConstructor.

private Map<Expression, Expression> mapRecordConstructor(RecordConstructor rc) {
    Map<Expression, Expression> exprMap = new HashMap<>();
    for (FieldBinding binding : rc.getFbList()) {
        Expression leftExpr = binding.getLeftExpr();
        // (e.g., foo.name AS name) in regular SQL SELECT.
        if (leftExpr.getKind() != Kind.LITERAL_EXPRESSION) {
            continue;
        }
        LiteralExpr literalExpr = (LiteralExpr) leftExpr;
        if (literalExpr.getValue().getLiteralType() == Literal.Type.STRING) {
            String fieldName = SqlppVariableUtil.toInternalVariableName(literalExpr.getValue().getStringValue());
            exprMap.put(new VariableExpr(new VarIdentifier(fieldName)), binding.getRightExpr());
        }
    }
    return exprMap;
}

Example 13 with Expression

use of org.apache.asterix.lang.common.base.Expression in project asterixdb by apache.

the class OperatorExpressionVisitor method visit.

@Override
public Expression visit(OperatorExpr operatorExpr, ILangExpression arg) throws CompilationException {
    List<Expression> newExprList = new ArrayList<>();
    for (Expression expr : operatorExpr.getExprList()) {
        newExprList.add(expr.accept(this, operatorExpr));
    }
    operatorExpr.setExprList(newExprList);
    OperatorType opType = operatorExpr.getOpList().get(0);
    switch(opType) {
        // There can only be one LIKE/NOT_LIKE/IN/NOT_IN in an operator expression (according to the grammar).
        case LIKE:
        case NOT_LIKE:
            return processLikeOperator(operatorExpr, opType);
        case IN:
        case NOT_IN:
            return processInOperator(operatorExpr, opType);
        case CONCAT:
            // There can be multiple "||"s in one operator expression (according to the grammar).
            return processConcatOperator(operatorExpr);
        case BETWEEN:
        case NOT_BETWEEN:
            return processBetweenOperator(operatorExpr, opType);
        default:
            break;
    }
    return operatorExpr;
}

Example 14 with Expression

use of org.apache.asterix.lang.common.base.Expression in project asterixdb by apache.

the class SqlppQueryRewriter method inlineDeclaredUdfs.

protected void inlineDeclaredUdfs() throws CompilationException {
    List<FunctionSignature> funIds = new ArrayList<FunctionSignature>();
    for (FunctionDecl fdecl : declaredFunctions) {
        funIds.add(fdecl.getSignature());
    }
    List<FunctionDecl> usedStoredFunctionDecls = new ArrayList<>();
    for (Expression topLevelExpr : topExpr.getDirectlyEnclosedExpressions()) {
        usedStoredFunctionDecls.addAll(FunctionUtil.retrieveUsedStoredFunctions(metadataProvider, topLevelExpr, funIds, null, expr -> getFunctionCalls(expr), func -> functionRepository.getFunctionDecl(func), signature -> FunctionMapUtil.normalizeBuiltinFunctionSignature(signature, false)));
    }
    declaredFunctions.addAll(usedStoredFunctionDecls);
    if (!declaredFunctions.isEmpty()) {
        SqlppInlineUdfsVisitor visitor = new SqlppInlineUdfsVisitor(context, new SqlppFunctionBodyRewriterFactory(), /* the rewriter for function bodies expressions*/
        declaredFunctions, metadataProvider);
        while (topExpr.accept(visitor, declaredFunctions)) {
        // loop until no more changes
        }
    }
    declaredFunctions.removeAll(usedStoredFunctionDecls);
}

Example 15 with Expression

use of org.apache.asterix.lang.common.base.Expression in project asterixdb by apache.

the class SqlppInlineUdfsVisitor method extractLetBindingVariableExpressionMappings.

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;
}