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

Example 1 with Clause

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

the class ClauseComparator method visit.

@Override
public Void visit(FLWOGRExpression flwor, Integer step) throws CompilationException {
    if (step != 0) {
        out.println("(");
    }
    List<Clause> clauseList = new ArrayList<Clause>();
    clauseList.addAll(flwor.getClauseList());
    // Processes data-independent let clauses.
    if (hasFor(clauseList)) {
        processLeadingLetClauses(step, clauseList);
    }
    // Distill unnecessary order-bys before a group-by.
    distillRedundantOrderby(clauseList);
    // Correlated "for" clauses after group-by.
    Pair<GroupbyClause, List<Clause>> extraction = extractUnnestAfterGroupby(clauseList);
    GroupbyClause cuttingGbyClause = extraction.first;
    List<Clause> unnestClauseList = extraction.second;
    Expression returnExpr = flwor.getReturnExpr();
    if (unnestClauseList.size() == 0) {
        if (hasFor(clauseList)) {
            out.print(skip(step) + "select element ");
            returnExpr.accept(this, step + 2);
            out.println();
        } else {
            // The FLOWGR only contains let-return, then inline let binding expressions into the return expression.
            Map<VariableExpr, Expression> varExprMap = extractLetBindingVariables(clauseList, cuttingGbyClause);
            returnExpr = (Expression) AQLVariableSubstitutionUtil.substituteVariable(returnExpr, varExprMap);
            returnExpr.accept(this, step);
            return null;
        }
    }
    String generated = generateVariableSymbol();
    if (unnestClauseList.size() > 0) {
        Map<VariableExpr, Expression> varExprMap = extractDefinedCollectionVariables(clauseList, cuttingGbyClause, generated);
        returnExpr = (Expression) AQLVariableSubstitutionUtil.substituteVariable(returnExpr, varExprMap);
        List<Clause> newUnnestClauses = new ArrayList<Clause>();
        for (Clause nestedCl : unnestClauseList) {
            newUnnestClauses.add((Clause) AQLVariableSubstitutionUtil.substituteVariable(nestedCl, varExprMap));
        }
        unnestClauseList = newUnnestClauses;
        out.print(skip(step) + "select element " + (hasDistinct(unnestClauseList) ? "distinct " : ""));
        returnExpr.accept(this, step + 2);
        out.println();
        out.println(skip(step) + "from");
        out.print(skip(step + 2) + "( select element " + (hasDistinct(clauseList) ? "distinct " : "") + "{");
        int index = 0;
        int size = varExprMap.size();
        for (VariableExpr var : varExprMap.keySet()) {
            out.print("\'" + var.getVar().getValue().substring(1) + "\':" + var.getVar().getValue().substring(1));
            if (++index < size) {
                out.print(COMMA);
            }
        }
        out.println("}");
    }
    reorder(clauseList);
    reorder(unnestClauseList);
    mergeConsecutiveWhereClauses(clauseList);
    mergeConsecutiveWhereClauses(unnestClauseList);
    boolean firstFor = true;
    boolean firstLet = true;
    int forStep = unnestClauseList.size() == 0 ? step : step + 3;
    int size = clauseList.size();
    // "for"s.
    for (int i = 0; i < size; ++i) {
        Clause cl = clauseList.get(i);
        if (cl.getClauseType() == ClauseType.FOR_CLAUSE) {
            boolean hasConsequentFor = false;
            if (i < size - 1) {
                Clause nextCl = clauseList.get(i + 1);
                hasConsequentFor = nextCl.getClauseType() == ClauseType.FOR_CLAUSE;
            }
            visitForClause((ForClause) cl, forStep, firstFor, hasConsequentFor);
            firstFor = false;
        } else if (cl.getClauseType() == ClauseType.LET_CLAUSE) {
            boolean hasConsequentLet = false;
            if (i < size - 1) {
                Clause nextCl = clauseList.get(i + 1);
                hasConsequentLet = nextCl.getClauseType() == ClauseType.LET_CLAUSE;
            }
            visitLetClause((LetClause) cl, forStep, firstLet, hasConsequentLet);
            firstLet = false;
        } else {
            cl.accept(this, forStep);
        }
        if (cl.getClauseType() == ClauseType.FROM_CLAUSE || cl.getClauseType() == ClauseType.GROUP_BY_CLAUSE) {
            firstLet = true;
        }
    }
    if (unnestClauseList.size() > 0) {
        out.println(skip(forStep - 1) + ") as " + generated.substring(1) + ",");
        for (Clause nestedCl : unnestClauseList) {
            if (nestedCl.getClauseType() == ClauseType.FOR_CLAUSE) {
                visitForClause((ForClause) nestedCl, step - 1, firstFor, false);
            } else {
                nestedCl.accept(this, step);
            }
        }
    }
    if (step > 0) {
        out.print(skip(step - 2) + ")");
    }
    return null;
}

Example 2 with Clause

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

the class ClauseComparator method reorder.

// Re-order clauses.
private List<Clause> reorder(List<Clause> clauses) {
    Comparator<Clause> comparator = new ClauseComparator();
    List<Clause> results = new ArrayList<Clause>();
    int size = clauses.size();
    int start = 0;
    for (int index = 0; index < size; ++index) {
        Clause clause = clauses.get(index);
        if (clause.getClauseType() == ClauseType.GROUP_BY_CLAUSE) {
            List<Clause> subList = clauses.subList(start, index);
            Collections.sort(subList, comparator);
            results.addAll(subList);
            results.add(clause);
            start = index + 1;
        }
    }
    if (start < clauses.size()) {
        List<Clause> subList = clauses.subList(start, size);
        Collections.sort(subList, comparator);
        results.addAll(subList);
    }
    return results;
}

Example 3 with Clause

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

the class AQLFormatPrintVisitor method visit.

@Override
public Void visit(FLWOGRExpression flwor, Integer step) throws CompilationException {
    for (Clause cl : flwor.getClauseList()) {
        cl.accept(this, step);
    }
    out.print(skip(step) + "return ");
    flwor.getReturnExpr().accept(this, step + 2);
    return null;
}

Example 4 with Clause

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

the class AQLInlineUdfsVisitor method visit.

@Override
public Boolean visit(FLWOGRExpression flwor, List<FunctionDecl> arg) throws CompilationException {
    boolean changed = false;
    for (Clause c : flwor.getClauseList()) {
        if (c.accept(this, arg)) {
            changed = true;
        }
    }
    Pair<Boolean, Expression> p = inlineUdfsInExpr(flwor.getReturnExpr(), arg);
    flwor.setReturnExpr(p.second);
    return changed || p.first;
}

Example 5 with Clause

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

the class AqlPlusExpressionToPlanTranslator method translate.

public ILogicalPlan translate(List<Clause> clauses) throws AlgebricksException, CompilationException {
    if (clauses == null) {
        return null;
    }
    Mutable<ILogicalOperator> opRef = new MutableObject<ILogicalOperator>(new EmptyTupleSourceOperator());
    Pair<ILogicalOperator, LogicalVariable> p = null;
    for (Clause c : clauses) {
        p = c.accept(this, opRef);
        opRef = new MutableObject<ILogicalOperator>(p.first);
    }
    ArrayList<Mutable<ILogicalOperator>> globalPlanRoots = new ArrayList<Mutable<ILogicalOperator>>();
    ILogicalOperator topOp = p.first;
    globalPlanRoots.add(new MutableObject<ILogicalOperator>(topOp));
    ILogicalPlan plan = new ALogicalPlanImpl(globalPlanRoots);
    return plan;
}