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

Example 11 with Clause

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

the class ClauseComparator method mergeConsecutiveWhereClauses.

// Merge consecutive "where" clauses.
private void mergeConsecutiveWhereClauses(List<Clause> clauses) throws CompilationException {
    List<Clause> results = new ArrayList<Clause>();
    int size = clauses.size();
    for (int index = 0; index < size; ) {
        Clause clause = clauses.get(index);
        if (clause.getClauseType() != ClauseType.WHERE_CLAUSE) {
            results.add(clause);
            ++index;
        } else {
            List<Expression> expressions = new ArrayList<Expression>();
            Clause firstWhereClause = clause;
            do {
                WhereClause whereClause = (WhereClause) clause;
                expressions.add(whereClause.getWhereExpr());
                if (++index >= size) {
                    break;
                }
                clause = clauses.get(index);
            } while (clause.getClauseType() == ClauseType.WHERE_CLAUSE);
            if (expressions.size() > 1) {
                OperatorExpr newWhereExpr = new OperatorExpr();
                newWhereExpr.setExprList(expressions);
                newWhereExpr.setCurrentop(true);
                for (int operatorIndex = 0; operatorIndex < expressions.size(); ++operatorIndex) {
                    newWhereExpr.addOperator("and");
                }
                results.add(new WhereClause(newWhereExpr));
            } else {
                results.add(firstWhereClause);
            }
        }
    }
    clauses.clear();
    clauses.addAll(results);
}

Example 12 with Clause

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

the class ClauseComparator method extractUnnestAfterGroupby.

// Extracts all clauses that led by a "for" clause after the first group-by
// clause in the input clause list.
// Those extracted clauses will be removed from the input clause list.
/**
     * @param clauseList
     *            , a list of clauses
     * @return the cutting group-by clause and the list of extracted clauses.
     * @throws CompilationException
     */
private Pair<GroupbyClause, List<Clause>> extractUnnestAfterGroupby(List<Clause> clauseList) throws CompilationException {
    List<Clause> nestedClauses = new ArrayList<Clause>();
    GroupbyClause cuttingGbyClause = null;
    boolean meetGroupBy = false;
    boolean nestedClauseStarted = false;
    for (Clause cl : clauseList) {
        if (cl.getClauseType() == ClauseType.GROUP_BY_CLAUSE) {
            meetGroupBy = true;
            cuttingGbyClause = (GroupbyClause) cl;
            continue;
        }
        if (meetGroupBy && cl.getClauseType() == ClauseType.FOR_CLAUSE) {
            nestedClauseStarted = true;
        }
        if (nestedClauseStarted) {
            nestedClauses.add(cl);
        }
    }
    clauseList.removeAll(nestedClauses);
    return new Pair<GroupbyClause, List<Clause>>(cuttingGbyClause, nestedClauses);
}

Example 13 with Clause

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

the class ClauseComparator method extractDefinedCollectionVariables.

// Extracts the variables to be substituted with a path access.
private Map<VariableExpr, Expression> extractDefinedCollectionVariables(List<Clause> clauses, GroupbyClause cuttingGbyClause, String generatedAlias) {
    Map<VariableExpr, Expression> varExprMap = new HashMap<VariableExpr, Expression>();
    List<VariableExpr> varToSubstitute = collectProducedVariablesFromGroupby(cuttingGbyClause);
    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) {
            varToSubstitute.add(((LetClause) cl).getVarExpr());
        }
    }
    for (VariableExpr var : varToSubstitute) {
        varExprMap.put(var, new FieldAccessor(new VariableExpr(new VarIdentifier(generatedAlias)), new VarIdentifier(var.getVar().getValue().substring(1))));
    }
    return varExprMap;
}

Example 14 with Clause

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

the class ClauseComparator method distillRedundantOrderby.

// Removes all redundant order by clauses.
private void distillRedundantOrderby(List<Clause> clauseList) {
    List<Clause> redundantOrderbys = new ArrayList<Clause>();
    boolean gbyAfterOrderby = false;
    for (Clause cl : clauseList) {
        if (cl.getClauseType() == ClauseType.ORDER_BY_CLAUSE) {
            redundantOrderbys.add(cl);
        }
        if (cl.getClauseType() == ClauseType.GROUP_BY_CLAUSE) {
            gbyAfterOrderby = true;
            break;
        }
    }
    if (gbyAfterOrderby) {
        clauseList.removeAll(redundantOrderbys);
    }
    redundantOrderbys.clear();
    for (Clause cl : clauseList) {
        if (cl.getClauseType() == ClauseType.ORDER_BY_CLAUSE) {
            redundantOrderbys.add(cl);
        }
    }
    if (redundantOrderbys.size() > 0) {
        redundantOrderbys.remove(redundantOrderbys.size() - 1);
    }
    clauseList.removeAll(redundantOrderbys);
}

Example 15 with Clause

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

the class AqlDeleteRewriteVisitor method visit.

@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(FunctionConstants.ASTERIX_NS, "dataset", 1), 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;
}