Example usage for org.apache.commons.lang3.mutable Mutable getValue

Introduction

In this page you can find the example usage for org.apache.commons.lang3.mutable Mutable getValue.

Prototype

T getValue();

Source Link

Document

Gets the value of this mutable.

Usage

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitDistinctOperator(DistinctOperator op, Void arg) {
    for (Mutable<ILogicalExpression> eRef : op.getExpressions()) {
        eRef.getValue().getUsedVariables(usedVariables);
    }/*from w w w  .j a va2 s  .  c o m*/
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitWriteOperator(WriteOperator op, Void arg) {
    for (Mutable<ILogicalExpression> expr : op.getExpressions()) {
        expr.getValue().getUsedVariables(usedVariables);
    }// www . java  2  s.  c  o  m
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitDistributeResultOperator(DistributeResultOperator op, Void arg) {
    for (Mutable<ILogicalExpression> expr : op.getExpressions()) {
        expr.getValue().getUsedVariables(usedVariables);
    }/*from   w  w  w  .  j  a  va 2s. co m*/
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.core.rewriter.base.AbstractRuleController.java

private String getPlanString(Mutable<ILogicalOperator> opRef) throws AlgebricksException {
    if (AlgebricksConfig.ALGEBRICKS_LOGGER.isLoggable(Level.FINE)) {
        StringBuilder sb = new StringBuilder();
        LogicalOperatorPrettyPrintVisitor pvisitor = context.getPrettyPrintVisitor();
        PlanPrettyPrinter.printOperator((AbstractLogicalOperator) opRef.getValue(), sb, pvisitor, 0);
        return sb.toString();
    }/*from ww  w.j av a  2 s  .  c  o  m*/
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.rewriter.rules.RemoveUnusedAssignAndAggregateRule.java

private void removeUnusedAssigns(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> toRemove,
        IOptimizationContext context) throws AlgebricksException {
    AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
    while (removeFromAssigns(op, toRemove, context) == 0) {
        if (op.getOperatorTag() == LogicalOperatorTag.AGGREGATE) {
            break;
        }/* www  .  java 2  s  .co m*/
        op = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
        opRef.setValue(op);
    }
    Iterator<Mutable<ILogicalOperator>> childIter = op.getInputs().iterator();
    while (childIter.hasNext()) {
        Mutable<ILogicalOperator> cRef = childIter.next();
        removeUnusedAssigns(cRef, toRemove, context);
    }
    if (op.hasNestedPlans()) {
        AbstractOperatorWithNestedPlans opWithNest = (AbstractOperatorWithNestedPlans) op;
        Iterator<ILogicalPlan> planIter = opWithNest.getNestedPlans().iterator();
        while (planIter.hasNext()) {
            ILogicalPlan p = planIter.next();
            for (Mutable<ILogicalOperator> r : p.getRoots()) {
                removeUnusedAssigns(r, toRemove, context);
            }
        }

        // Removes redundant nested plans that produces nothing
        for (int i = opWithNest.getNestedPlans().size() - 1; i >= 0; i--) {
            ILogicalPlan nestedPlan = opWithNest.getNestedPlans().get(i);
            List<Mutable<ILogicalOperator>> rootsToBeRemoved = new ArrayList<Mutable<ILogicalOperator>>();
            for (Mutable<ILogicalOperator> r : nestedPlan.getRoots()) {
                ILogicalOperator topOp = r.getValue();
                Set<LogicalVariable> producedVars = new ListSet<LogicalVariable>();
                VariableUtilities.getProducedVariablesInDescendantsAndSelf(topOp, producedVars);
                if (producedVars.size() == 0) {
                    rootsToBeRemoved.add(r);
                }
            }
            // Makes sure the operator should have at least ONE nested plan even it is empty 
            // (because a lot of places uses this assumption,  TODO(yingyib): clean them up).
            if (nestedPlan.getRoots().size() == rootsToBeRemoved.size()
                    && opWithNest.getNestedPlans().size() > 1) {
                nestedPlan.getRoots().removeAll(rootsToBeRemoved);
                opWithNest.getNestedPlans().remove(nestedPlan);
            }
        }
    }
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitAggregateOperator(AggregateOperator op, Void arg) {
    for (Mutable<ILogicalExpression> exprRef : op.getExpressions()) {
        exprRef.getValue().getUsedVariables(usedVariables);
    }//from  ww w. ja va2  s.  c o m
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitAssignOperator(AssignOperator op, Void arg) {
    for (Mutable<ILogicalExpression> exprRef : op.getExpressions()) {
        exprRef.getValue().getUsedVariables(usedVariables);
    }/*ww  w  .  j  ava 2s .  c  o  m*/
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitRunningAggregateOperator(RunningAggregateOperator op, Void arg) {
    for (Mutable<ILogicalExpression> exprRef : op.getExpressions()) {
        exprRef.getValue().getUsedVariables(usedVariables);
    }//from w  w w. j av  a 2 s. c o  m
    return null;
}

From source file:edu.uci.ics.hyracks.algebricks.rewriter.rules.PushSubplanIntoGroupByRule.java

@Override
public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
        throws AlgebricksException {
    ILogicalOperator parentOperator = opRef.getValue();
    if (context.checkIfInDontApplySet(this, parentOperator)) {
        return false;
    }//from  w  w w . ja v  a  2 s. co  m
    context.addToDontApplySet(this, parentOperator);
    VariableUtilities.getUsedVariables(parentOperator, usedVarsSoFar);
    if (parentOperator.getInputs().size() <= 0) {
        return false;
    }
    boolean changed = false;
    GroupByOperator gby = null;
    for (Mutable<ILogicalOperator> ref : parentOperator.getInputs()) {
        AbstractLogicalOperator op = (AbstractLogicalOperator) ref.getValue();
        /** Only processes subplan operator. */
        List<SubplanOperator> subplans = new ArrayList<SubplanOperator>();
        if (op.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
            while (op.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
                SubplanOperator currentSubplan = (SubplanOperator) op;
                subplans.add(currentSubplan);
                op = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
            }
            /** Only processes the case a group-by operator is the input of the subplan operators. */
            if (op.getOperatorTag() == LogicalOperatorTag.GROUP) {
                gby = (GroupByOperator) op;
                List<ILogicalPlan> newGbyNestedPlans = new ArrayList<ILogicalPlan>();
                for (SubplanOperator subplan : subplans) {
                    List<ILogicalPlan> subplanNestedPlans = subplan.getNestedPlans();
                    List<ILogicalPlan> gbyNestedPlans = gby.getNestedPlans();
                    List<ILogicalPlan> subplanNestedPlansToRemove = new ArrayList<ILogicalPlan>();
                    for (ILogicalPlan subplanNestedPlan : subplanNestedPlans) {
                        List<Mutable<ILogicalOperator>> rootOpRefs = subplanNestedPlan.getRoots();
                        List<Mutable<ILogicalOperator>> rootOpRefsToRemove = new ArrayList<Mutable<ILogicalOperator>>();
                        for (Mutable<ILogicalOperator> rootOpRef : rootOpRefs) {
                            /** Gets free variables in the root operator of a nested plan and its descent. */
                            Set<LogicalVariable> freeVars = new ListSet<LogicalVariable>();
                            VariableUtilities.getUsedVariablesInDescendantsAndSelf(rootOpRef.getValue(),
                                    freeVars);
                            Set<LogicalVariable> producedVars = new ListSet<LogicalVariable>();
                            VariableUtilities.getProducedVariablesInDescendantsAndSelf(rootOpRef.getValue(),
                                    producedVars);
                            freeVars.removeAll(producedVars);
                            /** * Checks whether the above freeVars are all contained in live variables * of one nested plan inside the group-by operator. * If yes, then the subplan can be pushed into the nested plan of the group-by. */
                            for (ILogicalPlan gbyNestedPlanOriginal : gbyNestedPlans) {
                                // add a subplan in the original gby
                                if (!newGbyNestedPlans.contains(gbyNestedPlanOriginal)) {
                                    newGbyNestedPlans.add(gbyNestedPlanOriginal);
                                }

                                // add a pushed subplan
                                ILogicalPlan gbyNestedPlan = OperatorManipulationUtil
                                        .deepCopy(gbyNestedPlanOriginal, context);
                                List<Mutable<ILogicalOperator>> gbyRootOpRefs = gbyNestedPlan.getRoots();
                                for (int rootIndex = 0; rootIndex < gbyRootOpRefs.size(); rootIndex++) {
                                    //set the nts for a original subplan
                                    Mutable<ILogicalOperator> originalGbyRootOpRef = gbyNestedPlanOriginal
                                            .getRoots().get(rootIndex);
                                    Mutable<ILogicalOperator> originalGbyNtsRef = downToNts(
                                            originalGbyRootOpRef);
                                    NestedTupleSourceOperator originalNts = (NestedTupleSourceOperator) originalGbyNtsRef
                                            .getValue();
                                    originalNts
                                            .setDataSourceReference(new MutableObject<ILogicalOperator>(gby));

                                    //push a new subplan if possible
                                    Mutable<ILogicalOperator> gbyRootOpRef = gbyRootOpRefs.get(rootIndex);
                                    Set<LogicalVariable> liveVars = new ListSet<LogicalVariable>();
                                    VariableUtilities.getLiveVariables(gbyRootOpRef.getValue(), liveVars);
                                    if (liveVars.containsAll(freeVars)) {
                                        /** Does the actual push. */
                                        Mutable<ILogicalOperator> ntsRef = downToNts(rootOpRef);
                                        ntsRef.setValue(gbyRootOpRef.getValue());
                                        // Removes unused vars.
                                        AggregateOperator aggOp = (AggregateOperator) gbyRootOpRef.getValue();
                                        for (int varIndex = aggOp.getVariables().size()
                                                - 1; varIndex >= 0; varIndex--) {
                                            if (!freeVars.contains(aggOp.getVariables().get(varIndex))) {
                                                aggOp.getVariables().remove(varIndex);
                                                aggOp.getExpressions().remove(varIndex);
                                            }
                                        }

                                        gbyRootOpRef.setValue(rootOpRef.getValue());
                                        rootOpRefsToRemove.add(rootOpRef);

                                        // Sets the nts for a new pushed plan.
                                        Mutable<ILogicalOperator> oldGbyNtsRef = downToNts(gbyRootOpRef);
                                        NestedTupleSourceOperator nts = (NestedTupleSourceOperator) oldGbyNtsRef
                                                .getValue();
                                        nts.setDataSourceReference(new MutableObject<ILogicalOperator>(gby));

                                        newGbyNestedPlans.add(gbyNestedPlan);
                                        changed = true;
                                        continue;
                                    }
                                }
                            }
                        }
                        rootOpRefs.removeAll(rootOpRefsToRemove);
                        if (rootOpRefs.size() == 0) {
                            subplanNestedPlansToRemove.add(subplanNestedPlan);
                        }
                    }
                    subplanNestedPlans.removeAll(subplanNestedPlansToRemove);
                }
                if (changed) {
                    ref.setValue(gby);
                    gby.getNestedPlans().clear();
                    gby.getNestedPlans().addAll(newGbyNestedPlans);
                }
            }
        }
    }
    if (changed) {
        cleanup(gby);
    }
    return changed;
}

From source file:edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.UsedVariableVisitor.java

@Override
public Void visitWriteResultOperator(WriteResultOperator op, Void arg) {
    op.getPayloadExpression().getValue().getUsedVariables(usedVariables);
    for (Mutable<ILogicalExpression> e : op.getKeyExpressions()) {
        e.getValue().getUsedVariables(usedVariables);
    }//w  w w.j  ava 2s. c  o  m
    if (op.getAdditionalFilteringExpressions() != null) {
        for (Mutable<ILogicalExpression> e : op.getAdditionalFilteringExpressions()) {
            e.getValue().getUsedVariables(usedVariables);
        }
    }
    return null;
}