List of usage examples for org.apache.commons.lang3.mutable MutableObject MutableObject
public MutableObject(final T value)
From source file:edu.uci.ics.hyracks.algebricks.rewriter.rules.PushFunctionsBelowJoin.java
private boolean pushDownFunctions(AbstractBinaryJoinOperator joinOp, int inputIndex, List<Mutable<ILogicalExpression>> funcExprs, IOptimizationContext context) throws AlgebricksException { ILogicalOperator joinInputOp = joinOp.getInputs().get(inputIndex).getValue(); liveVars.clear();/*ww w . j a v a 2 s .com*/ VariableUtilities.getLiveVariables(joinInputOp, liveVars); Iterator<Mutable<ILogicalExpression>> funcIter = funcExprs.iterator(); List<LogicalVariable> assignVars = null; List<Mutable<ILogicalExpression>> assignExprs = null; while (funcIter.hasNext()) { Mutable<ILogicalExpression> funcExprRef = funcIter.next(); ILogicalExpression funcExpr = funcExprRef.getValue(); usedVars.clear(); funcExpr.getUsedVariables(usedVars); // Check if we can push the function down this branch. if (liveVars.containsAll(usedVars)) { if (assignVars == null) { assignVars = new ArrayList<LogicalVariable>(); assignExprs = new ArrayList<Mutable<ILogicalExpression>>(); } // Replace the original expression with a variable reference expression. LogicalVariable replacementVar = context.newVar(); assignVars.add(replacementVar); assignExprs.add(new MutableObject<ILogicalExpression>(funcExpr)); funcExprRef.setValue(new VariableReferenceExpression(replacementVar)); funcIter.remove(); } } // Create new assign operator below the join if any functions can be pushed. if (assignVars != null) { AssignOperator newAssign = new AssignOperator(assignVars, assignExprs); newAssign.getInputs().add(new MutableObject<ILogicalOperator>(joinInputOp)); newAssign.setExecutionMode(joinOp.getExecutionMode()); joinOp.getInputs().get(inputIndex).setValue(newAssign); context.computeAndSetTypeEnvironmentForOperator(newAssign); return true; } return false; }
From source file:com.romeikat.datamessie.core.base.dao.impl.DocumentDao.java
public Long count(final SharedSessionContract ssc, final DocumentsFilterSettings dfs) { final CountPublishedDateParallelLoadingStrategy loadingStrategy = new CountPublishedDateParallelLoadingStrategy( dfs, sessionFactory, sharedBeanProvider, parallelismFactor) { @Override/*from ww w . j a v a2 s .co m*/ protected MutableObject<Long> load(final SharedSessionContract ssc, final DocumentsFilterSettings dfsWithPublishedDate) { final Long count = countInternal(ssc, dfsWithPublishedDate); return new MutableObject<>(count); } }; return loadingStrategy.getResult().getValue(); }
From source file:edu.uci.ics.asterix.optimizer.rules.IntroduceAutogenerateIDRule.java
private AbstractFunctionCallExpression createRecordMergeFunction(ILogicalExpression rec0, ILogicalExpression rec1) {/*from w w w . jav a 2 s. c o m*/ List<Mutable<ILogicalExpression>> recordMergeFnArgs = new ArrayList<>(); recordMergeFnArgs.add(new MutableObject<>(rec0)); recordMergeFnArgs.add(new MutableObject<>(rec1)); AbstractFunctionCallExpression recordMergeFn = new ScalarFunctionCallExpression( FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.RECORD_MERGE), recordMergeFnArgs); return recordMergeFn; }
From source file:edu.uci.ics.asterix.optimizer.rules.InlineUnnestFunctionRule.java
private void removeUnecessaryAssign(AbstractLogicalOperator parentOp, AbstractLogicalOperator currentOp, AssignOperator assignOp, int index) { assignOp.getVariables().remove(index); assignOp.getExpressions().remove(index); if (assignOp.getVariables().size() == 0) { int opIndex = parentOp.getInputs().indexOf(new MutableObject<ILogicalOperator>(currentOp)); parentOp.getInputs().get(opIndex).setValue(assignOp.getInputs().get(0).getValue()); }/*from w w w . j a v a2s . c om*/ }
From source file:edu.uci.ics.asterix.optimizer.rules.am.IntroduceLSMComponentFilterRule.java
private void changePlan(List<IOptimizableFuncExpr> optFuncExprs, AbstractLogicalOperator op, Dataset dataset, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator descendantOp = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); while (descendantOp != null) { if (descendantOp.getOperatorTag() == LogicalOperatorTag.DATASOURCESCAN) { DataSourceScanOperator dataSourceScanOp = (DataSourceScanOperator) descendantOp; AqlDataSource ds = (AqlDataSource) dataSourceScanOp.getDataSource(); if (dataset.getDatasetName() .compareTo(((DatasetDataSource) ds).getDataset().getDatasetName()) == 0) { List<LogicalVariable> minFilterVars = new ArrayList<LogicalVariable>(); List<LogicalVariable> maxFilterVars = new ArrayList<LogicalVariable>(); AssignOperator assignOp = createAssignOperator(optFuncExprs, minFilterVars, maxFilterVars, context);/*from ww w . j a v a2 s .c om*/ dataSourceScanOp.setMinFilterVars(minFilterVars); dataSourceScanOp.setMaxFilterVars(maxFilterVars); List<Mutable<ILogicalExpression>> additionalFilteringExpressions = new ArrayList<Mutable<ILogicalExpression>>(); ; for (LogicalVariable var : assignOp.getVariables()) { additionalFilteringExpressions .add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(var))); } dataSourceScanOp.setAdditionalFilteringExpressions(additionalFilteringExpressions); assignOp.getInputs().add( new MutableObject<ILogicalOperator>(dataSourceScanOp.getInputs().get(0).getValue())); dataSourceScanOp.getInputs().get(0).setValue(assignOp); } } else if (descendantOp.getOperatorTag() == LogicalOperatorTag.UNNEST_MAP) { UnnestMapOperator unnestMapOp = (UnnestMapOperator) descendantOp; ILogicalExpression unnestExpr = unnestMapOp.getExpressionRef().getValue(); if (unnestExpr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) unnestExpr; FunctionIdentifier fid = f.getFunctionIdentifier(); if (!fid.equals(AsterixBuiltinFunctions.INDEX_SEARCH)) { throw new IllegalStateException(); } AccessMethodJobGenParams jobGenParams = new AccessMethodJobGenParams(); jobGenParams.readFromFuncArgs(f.getArguments()); if (dataset.getDatasetName().compareTo(jobGenParams.datasetName) == 0) { List<LogicalVariable> minFilterVars = new ArrayList<LogicalVariable>(); List<LogicalVariable> maxFilterVars = new ArrayList<LogicalVariable>(); AssignOperator assignOp = createAssignOperator(optFuncExprs, minFilterVars, maxFilterVars, context); unnestMapOp.setMinFilterVars(minFilterVars); unnestMapOp.setMaxFilterVars(maxFilterVars); List<Mutable<ILogicalExpression>> additionalFilteringExpressions = new ArrayList<Mutable<ILogicalExpression>>(); ; for (LogicalVariable var : assignOp.getVariables()) { additionalFilteringExpressions.add( new MutableObject<ILogicalExpression>(new VariableReferenceExpression(var))); } unnestMapOp.setAdditionalFilteringExpressions(additionalFilteringExpressions); assignOp.getInputs().add( new MutableObject<ILogicalOperator>(unnestMapOp.getInputs().get(0).getValue())); unnestMapOp.getInputs().get(0).setValue(assignOp); } } } if (descendantOp.getInputs().isEmpty()) { break; } descendantOp = (AbstractLogicalOperator) descendantOp.getInputs().get(0).getValue(); } }
From source file:edu.uci.ics.hyracks.algebricks.rewriter.rules.IntroduceGroupByForSubplanRule.java
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op0 = (AbstractLogicalOperator) opRef.getValue(); if (op0.getOperatorTag() != LogicalOperatorTag.SUBPLAN) { return false; }// w ww.ja va 2 s.c o m SubplanOperator subplan = (SubplanOperator) op0; Iterator<ILogicalPlan> plansIter = subplan.getNestedPlans().iterator(); ILogicalPlan p = null; while (plansIter.hasNext()) { p = plansIter.next(); } if (p == null) { return false; } if (p.getRoots().size() != 1) { return false; } Mutable<ILogicalOperator> subplanRoot = p.getRoots().get(0); AbstractLogicalOperator op1 = (AbstractLogicalOperator) subplanRoot.getValue(); Mutable<ILogicalOperator> botRef = subplanRoot; AbstractLogicalOperator op2; // Project is optional if (op1.getOperatorTag() != LogicalOperatorTag.PROJECT) { op2 = op1; } else { ProjectOperator project = (ProjectOperator) op1; botRef = project.getInputs().get(0); op2 = (AbstractLogicalOperator) botRef.getValue(); } if (op2.getOperatorTag() != LogicalOperatorTag.AGGREGATE) { return false; } AggregateOperator aggregate = (AggregateOperator) op2; Set<LogicalVariable> free = new HashSet<LogicalVariable>(); VariableUtilities.getUsedVariables(aggregate, free); Mutable<ILogicalOperator> op3Ref = aggregate.getInputs().get(0); AbstractLogicalOperator op3 = (AbstractLogicalOperator) op3Ref.getValue(); while (op3.getInputs().size() == 1) { Set<LogicalVariable> prod = new HashSet<LogicalVariable>(); VariableUtilities.getProducedVariables(op3, prod); free.removeAll(prod); VariableUtilities.getUsedVariables(op3, free); botRef = op3Ref; op3Ref = op3.getInputs().get(0); op3 = (AbstractLogicalOperator) op3Ref.getValue(); } if (op3.getOperatorTag() != LogicalOperatorTag.INNERJOIN && op3.getOperatorTag() != LogicalOperatorTag.LEFTOUTERJOIN) { return false; } AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) op3; if (join.getCondition().getValue() == ConstantExpression.TRUE) { return false; } VariableUtilities.getUsedVariables(join, free); AbstractLogicalOperator b0 = (AbstractLogicalOperator) join.getInputs().get(0).getValue(); // see if there's an NTS at the end of the pipeline NestedTupleSourceOperator outerNts = getNts(b0); if (outerNts == null) { AbstractLogicalOperator b1 = (AbstractLogicalOperator) join.getInputs().get(1).getValue(); outerNts = getNts(b1); if (outerNts == null) { return false; } } Set<LogicalVariable> pkVars = computeGbyVars(outerNts, free, context); if (pkVars == null || pkVars.size() < 1) { // there is no non-trivial primary key, group-by keys are all live variables ILogicalOperator subplanInput = subplan.getInputs().get(0).getValue(); pkVars = new HashSet<LogicalVariable>(); VariableUtilities.getLiveVariables(subplanInput, pkVars); } AlgebricksConfig.ALGEBRICKS_LOGGER.fine("Found FD for introducing group-by: " + pkVars); Mutable<ILogicalOperator> rightRef = join.getInputs().get(1); LogicalVariable testForNull = null; AbstractLogicalOperator right = (AbstractLogicalOperator) rightRef.getValue(); switch (right.getOperatorTag()) { case UNNEST: { UnnestOperator innerUnnest = (UnnestOperator) right; // Select [ $y != null ] testForNull = innerUnnest.getVariable(); break; } case RUNNINGAGGREGATE: { ILogicalOperator inputToRunningAggregate = right.getInputs().get(0).getValue(); Set<LogicalVariable> producedVars = new ListSet<LogicalVariable>(); VariableUtilities.getProducedVariables(inputToRunningAggregate, producedVars); if (!producedVars.isEmpty()) { // Select [ $y != null ] testForNull = producedVars.iterator().next(); } break; } case DATASOURCESCAN: { DataSourceScanOperator innerScan = (DataSourceScanOperator) right; // Select [ $y != null ] if (innerScan.getVariables().size() == 1) { testForNull = innerScan.getVariables().get(0); } break; } } if (testForNull == null) { testForNull = context.newVar(); AssignOperator tmpAsgn = new AssignOperator(testForNull, new MutableObject<ILogicalExpression>(ConstantExpression.TRUE)); tmpAsgn.getInputs().add(new MutableObject<ILogicalOperator>(rightRef.getValue())); rightRef.setValue(tmpAsgn); context.computeAndSetTypeEnvironmentForOperator(tmpAsgn); } IFunctionInfo finfoEq = context.getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.IS_NULL); ILogicalExpression isNullTest = new ScalarFunctionCallExpression(finfoEq, new MutableObject<ILogicalExpression>(new VariableReferenceExpression(testForNull))); IFunctionInfo finfoNot = context.getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.NOT); ScalarFunctionCallExpression nonNullTest = new ScalarFunctionCallExpression(finfoNot, new MutableObject<ILogicalExpression>(isNullTest)); SelectOperator selectNonNull = new SelectOperator(new MutableObject<ILogicalExpression>(nonNullTest), false, null); GroupByOperator g = new GroupByOperator(); Mutable<ILogicalOperator> newSubplanRef = new MutableObject<ILogicalOperator>(subplan); NestedTupleSourceOperator nts = new NestedTupleSourceOperator(new MutableObject<ILogicalOperator>(g)); opRef.setValue(g); selectNonNull.getInputs().add(new MutableObject<ILogicalOperator>(nts)); List<Mutable<ILogicalOperator>> prodInpList = botRef.getValue().getInputs(); prodInpList.clear(); prodInpList.add(new MutableObject<ILogicalOperator>(selectNonNull)); ILogicalPlan gPlan = new ALogicalPlanImpl(new MutableObject<ILogicalOperator>(subplanRoot.getValue())); g.getNestedPlans().add(gPlan); subplanRoot.setValue(op3Ref.getValue()); g.getInputs().add(newSubplanRef); HashSet<LogicalVariable> underVars = new HashSet<LogicalVariable>(); VariableUtilities.getLiveVariables(subplan.getInputs().get(0).getValue(), underVars); underVars.removeAll(pkVars); Map<LogicalVariable, LogicalVariable> mappedVars = buildVarExprList(pkVars, context, g, g.getGroupByList()); context.updatePrimaryKeys(mappedVars); for (LogicalVariable uv : underVars) { g.getDecorList().add(new Pair<LogicalVariable, Mutable<ILogicalExpression>>(null, new MutableObject<ILogicalExpression>(new VariableReferenceExpression(uv)))); } OperatorPropertiesUtil.typeOpRec(subplanRoot, context); OperatorPropertiesUtil.typeOpRec(gPlan.getRoots().get(0), context); context.computeAndSetTypeEnvironmentForOperator(g); return true; }
From source file:edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorManipulationUtil.java
public static ILogicalOperator bottomUpCopyOperators(ILogicalOperator op) throws AlgebricksException { ILogicalOperator newOp = deepCopy(op); newOp.getInputs().clear();/* w ww. j a va2 s.c o m*/ for (Mutable<ILogicalOperator> child : op.getInputs()) newOp.getInputs().add(new MutableObject<ILogicalOperator>(bottomUpCopyOperators(child.getValue()))); return newOp; }
From source file:edu.uci.ics.asterix.optimizer.rules.CancelUnnestWithNestedListifyRule.java
private boolean applies(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> varUsedAbove, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue(); if (op1.getOperatorTag() != LogicalOperatorTag.UNNEST) { return false; }//from ww w. j a va2 s.com UnnestOperator unnest1 = (UnnestOperator) op1; ILogicalExpression expr = unnest1.getExpressionRef().getValue(); LogicalVariable unnestedVar; switch (expr.getExpressionTag()) { case VARIABLE: unnestedVar = ((VariableReferenceExpression) expr).getVariableReference(); break; case FUNCTION_CALL: if (((AbstractFunctionCallExpression) expr) .getFunctionIdentifier() != AsterixBuiltinFunctions.SCAN_COLLECTION) { return false; } AbstractFunctionCallExpression functionCall = (AbstractFunctionCallExpression) expr; ILogicalExpression functionCallArgExpr = functionCall.getArguments().get(0).getValue(); if (functionCallArgExpr.getExpressionTag() != LogicalExpressionTag.VARIABLE) { return false; } unnestedVar = ((VariableReferenceExpression) functionCallArgExpr).getVariableReference(); break; default: return false; } if (varUsedAbove.contains(unnestedVar)) { return false; } Mutable<ILogicalOperator> opRef2 = op1.getInputs().get(0); AbstractLogicalOperator r = (AbstractLogicalOperator) opRef2.getValue(); if (r.getOperatorTag() != LogicalOperatorTag.GROUP) { return false; } // go inside of a group-by plan GroupByOperator gby = (GroupByOperator) r; if (gby.getNestedPlans().size() != 1) { return false; } if (gby.getNestedPlans().get(0).getRoots().size() != 1) { return false; } AbstractLogicalOperator nestedPlanRoot = (AbstractLogicalOperator) gby.getNestedPlans().get(0).getRoots() .get(0).getValue(); if (nestedPlanRoot.getOperatorTag() != LogicalOperatorTag.AGGREGATE) { return false; } AggregateOperator agg = (AggregateOperator) nestedPlanRoot; Mutable<ILogicalOperator> aggInputOpRef = agg.getInputs().get(0); if (agg.getVariables().size() > 1) { return false; } LogicalVariable aggVar = agg.getVariables().get(0); ILogicalExpression aggFun = agg.getExpressions().get(0).getValue(); if (!aggVar.equals(unnestedVar) || ((AbstractLogicalExpression) aggFun).getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return false; } AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) aggFun; if (!AsterixBuiltinFunctions.LISTIFY.equals(f.getFunctionIdentifier())) { return false; } if (f.getArguments().size() != 1) { return false; } ILogicalExpression arg0 = f.getArguments().get(0).getValue(); if (((AbstractLogicalExpression) arg0).getExpressionTag() != LogicalExpressionTag.VARIABLE) { return false; } LogicalVariable paramVar = ((VariableReferenceExpression) arg0).getVariableReference(); ArrayList<LogicalVariable> assgnVars = new ArrayList<LogicalVariable>(1); assgnVars.add(unnest1.getVariable()); ArrayList<Mutable<ILogicalExpression>> assgnExprs = new ArrayList<Mutable<ILogicalExpression>>(1); assgnExprs.add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(paramVar))); AssignOperator assign = new AssignOperator(assgnVars, assgnExprs); LogicalVariable posVar = unnest1.getPositionalVariable(); if (posVar == null) { // Creates assignment for group-by keys. ArrayList<LogicalVariable> gbyKeyAssgnVars = new ArrayList<LogicalVariable>(); ArrayList<Mutable<ILogicalExpression>> gbyKeyAssgnExprs = new ArrayList<Mutable<ILogicalExpression>>(); for (int i = 0; i < gby.getGroupByList().size(); i++) { if (gby.getGroupByList().get(i).first != null) { gbyKeyAssgnVars.add(gby.getGroupByList().get(i).first); gbyKeyAssgnExprs.add(gby.getGroupByList().get(i).second); } } // Moves the nested pipeline before aggregation out of the group-by op. Mutable<ILogicalOperator> bottomOpRef = aggInputOpRef; AbstractLogicalOperator bottomOp = (AbstractLogicalOperator) bottomOpRef.getValue(); while (bottomOp.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) { bottomOpRef = bottomOp.getInputs().get(0); bottomOp = (AbstractLogicalOperator) bottomOpRef.getValue(); } // Removes the group-by operator. opRef.setValue(assign); assign.getInputs().add(aggInputOpRef); AssignOperator gbyKeyAssign = new AssignOperator(gbyKeyAssgnVars, gbyKeyAssgnExprs); gbyKeyAssign.getInputs().add(gby.getInputs().get(0)); bottomOpRef.setValue(gbyKeyAssign); context.computeAndSetTypeEnvironmentForOperator(gbyKeyAssign); context.computeAndSetTypeEnvironmentForOperator(assign); } else { // if positional variable is used in unnest, the unnest will be pushed into the group-by as a running-aggregate // First create assign for the unnest variable List<LogicalVariable> nestedAssignVars = new ArrayList<LogicalVariable>(); List<Mutable<ILogicalExpression>> nestedAssignExprs = new ArrayList<Mutable<ILogicalExpression>>(); nestedAssignVars.add(unnest1.getVariable()); nestedAssignExprs.add(new MutableObject<ILogicalExpression>(arg0)); AssignOperator nestedAssign = new AssignOperator(nestedAssignVars, nestedAssignExprs); nestedAssign.getInputs().add(opRef2); // Then create running aggregation for the positional variable List<LogicalVariable> raggVars = new ArrayList<LogicalVariable>(); List<Mutable<ILogicalExpression>> raggExprs = new ArrayList<Mutable<ILogicalExpression>>(); raggVars.add(posVar); StatefulFunctionCallExpression fce = new StatefulFunctionCallExpression( FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.TID), UnpartitionedPropertyComputer.INSTANCE); raggExprs.add(new MutableObject<ILogicalExpression>(fce)); RunningAggregateOperator raggOp = new RunningAggregateOperator(raggVars, raggExprs); raggOp.setExecutionMode(unnest1.getExecutionMode()); RunningAggregatePOperator raggPOp = new RunningAggregatePOperator(); raggOp.setPhysicalOperator(raggPOp); raggOp.getInputs().add(nestedPlanRoot.getInputs().get(0)); gby.getNestedPlans().get(0).getRoots().set(0, new MutableObject<ILogicalOperator>(raggOp)); opRef.setValue(nestedAssign); context.computeAndSetTypeEnvironmentForOperator(nestedAssign); context.computeAndSetTypeEnvironmentForOperator(raggOp); context.computeAndSetTypeEnvironmentForOperator(gby); } return true; }
From source file:edu.uci.ics.hyracks.algebricks.rewriter.rules.PushSelectIntoJoinRule.java
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { Collection<LogicalVariable> joinLiveVarsLeft = new HashSet<LogicalVariable>(); Collection<LogicalVariable> joinLiveVarsRight = new HashSet<LogicalVariable>(); Collection<LogicalVariable> liveInOpsToPushLeft = new HashSet<LogicalVariable>(); Collection<LogicalVariable> liveInOpsToPushRight = new HashSet<LogicalVariable>(); List<ILogicalOperator> pushedOnLeft = new ArrayList<ILogicalOperator>(); List<ILogicalOperator> pushedOnRight = new ArrayList<ILogicalOperator>(); LinkedList<ILogicalOperator> notPushedStack = new LinkedList<ILogicalOperator>(); Collection<LogicalVariable> usedVars = new HashSet<LogicalVariable>(); Collection<LogicalVariable> producedVars = new HashSet<LogicalVariable>(); AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() != LogicalOperatorTag.SELECT) { return false; }//from w w w. ja va 2 s . c o m SelectOperator select = (SelectOperator) op; Mutable<ILogicalOperator> opRef2 = op.getInputs().get(0); AbstractLogicalOperator son = (AbstractLogicalOperator) opRef2.getValue(); AbstractLogicalOperator op2 = son; boolean needToPushOps = false; while (son.isMap()) { needToPushOps = true; Mutable<ILogicalOperator> opRefLink = son.getInputs().get(0); son = (AbstractLogicalOperator) opRefLink.getValue(); } if (son.getOperatorTag() != LogicalOperatorTag.INNERJOIN && son.getOperatorTag() != LogicalOperatorTag.LEFTOUTERJOIN) { return false; } boolean isLoj = son.getOperatorTag() == LogicalOperatorTag.LEFTOUTERJOIN; AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) son; Mutable<ILogicalOperator> joinBranchLeftRef = join.getInputs().get(0); Mutable<ILogicalOperator> joinBranchRightRef = join.getInputs().get(1); if (needToPushOps) { ILogicalOperator joinBranchLeft = joinBranchLeftRef.getValue(); ILogicalOperator joinBranchRight = joinBranchRightRef.getValue(); VariableUtilities.getLiveVariables(joinBranchLeft, joinLiveVarsLeft); VariableUtilities.getLiveVariables(joinBranchRight, joinLiveVarsRight); Mutable<ILogicalOperator> opIterRef = opRef2; ILogicalOperator opIter = op2; while (opIter != join) { LogicalOperatorTag tag = ((AbstractLogicalOperator) opIter).getOperatorTag(); if (tag == LogicalOperatorTag.PROJECT) { notPushedStack.addFirst(opIter); } else { VariableUtilities.getUsedVariables(opIter, usedVars); VariableUtilities.getProducedVariables(opIter, producedVars); if (joinLiveVarsLeft.containsAll(usedVars)) { pushedOnLeft.add(opIter); liveInOpsToPushLeft.addAll(producedVars); } else if (joinLiveVarsRight.containsAll(usedVars)) { pushedOnRight.add(opIter); liveInOpsToPushRight.addAll(producedVars); } else { return false; } } opIterRef = opIter.getInputs().get(0); opIter = opIterRef.getValue(); } if (isLoj && pushedOnLeft.isEmpty()) { return false; } } boolean intersectsAllBranches = true; boolean[] intersectsBranch = new boolean[join.getInputs().size()]; LinkedList<LogicalVariable> selectVars = new LinkedList<LogicalVariable>(); select.getCondition().getValue().getUsedVariables(selectVars); int i = 0; for (Mutable<ILogicalOperator> branch : join.getInputs()) { LinkedList<LogicalVariable> branchVars = new LinkedList<LogicalVariable>(); VariableUtilities.getLiveVariables(branch.getValue(), branchVars); if (i == 0) { branchVars.addAll(liveInOpsToPushLeft); } else { branchVars.addAll(liveInOpsToPushRight); } if (OperatorPropertiesUtil.disjoint(selectVars, branchVars)) { intersectsAllBranches = false; } else { intersectsBranch[i] = true; } i++; } if (!intersectsBranch[0] && !intersectsBranch[1]) { return false; } if (needToPushOps) { pushOps(pushedOnLeft, joinBranchLeftRef, context); pushOps(pushedOnRight, joinBranchRightRef, context); } if (intersectsAllBranches) { addCondToJoin(select, join, context); } else { // push down Iterator<Mutable<ILogicalOperator>> branchIter = join.getInputs().iterator(); ILogicalExpression selectCondition = select.getCondition().getValue(); boolean lojToInner = false; for (int j = 0; j < intersectsBranch.length; j++) { Mutable<ILogicalOperator> branch = branchIter.next(); boolean inter = intersectsBranch[j]; if (inter) { if (j > 0 && isLoj) { // if a left outer join, if the select condition is not-null filtering, // we rewrite left outer join // to inner join for this case. if (containsNotNullFiltering(selectCondition)) { lojToInner = true; } } if ((j > 0 && isLoj) && containsNullFiltering(selectCondition)) { // Select is-null($$var) cannot be pushed in the right branch of a LOJ; notPushedStack.addFirst(select); } else { // Conditions for the left branch can always be pushed. // Other conditions can be pushed to the right branch of a LOJ. copySelectToBranch(select, branch, context); } } } if (lojToInner) { // Rewrites left outer join to inner join. InnerJoinOperator innerJoin = new InnerJoinOperator(join.getCondition()); innerJoin.getInputs().addAll(join.getInputs()); join = innerJoin; context.computeAndSetTypeEnvironmentForOperator(join); } } ILogicalOperator top = join; for (ILogicalOperator npOp : notPushedStack) { List<Mutable<ILogicalOperator>> npInpList = npOp.getInputs(); npInpList.clear(); npInpList.add(new MutableObject<ILogicalOperator>(top)); context.computeAndSetTypeEnvironmentForOperator(npOp); top = npOp; } opRef.setValue(top); return true; }
From source file:edu.uci.ics.asterix.optimizer.rules.IntroduceDynamicTypeCastRule.java
/** * Inject a function to wrap a variable when necessary * * @param requiredRecordType// ww w. ja v a 2 s . c om * the required record type * @param recordVar * the record variable * @param parent * the current parent operator to be rewritten * @param context * the optimization context * @param fd * the function to be injected * @return true if cast is injected; false otherwise. * @throws AlgebricksException */ public static LogicalVariable addWrapperFunction(ARecordType requiredRecordType, LogicalVariable recordVar, ILogicalOperator parent, IOptimizationContext context, FunctionIdentifier fd) throws AlgebricksException { List<Mutable<ILogicalOperator>> opRefs = parent.getInputs(); for (int index = 0; index < opRefs.size(); index++) { Mutable<ILogicalOperator> opRef = opRefs.get(index); ILogicalOperator op = opRef.getValue(); /** get produced vars */ List<LogicalVariable> producedVars = new ArrayList<LogicalVariable>(); VariableUtilities.getProducedVariables(op, producedVars); IVariableTypeEnvironment env = op.computeOutputTypeEnvironment(context); for (int i = 0; i < producedVars.size(); i++) { LogicalVariable var = producedVars.get(i); if (var.equals(recordVar)) { /** insert an assign operator to call the function on-top-of the variable */ IAType actualType = (IAType) env.getVarType(var); AbstractFunctionCallExpression cast = new ScalarFunctionCallExpression( FunctionUtils.getFunctionInfo(fd)); cast.getArguments() .add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(var))); /** enforce the required record type */ TypeComputerUtilities.setRequiredAndInputTypes(cast, requiredRecordType, actualType); LogicalVariable newAssignVar = context.newVar(); AssignOperator newAssignOperator = new AssignOperator(newAssignVar, new MutableObject<ILogicalExpression>(cast)); newAssignOperator.getInputs().add(new MutableObject<ILogicalOperator>(op)); opRef.setValue(newAssignOperator); context.computeAndSetTypeEnvironmentForOperator(newAssignOperator); newAssignOperator.computeOutputTypeEnvironment(context); VariableUtilities.substituteVariables(parent, recordVar, newAssignVar, context); return newAssignVar; } } /** recursive descend to the operator who produced the recordVar */ LogicalVariable replacedVar = addWrapperFunction(requiredRecordType, recordVar, op, context, fd); if (replacedVar != null) { /** substitute the recordVar by the replacedVar for operators who uses recordVar */ VariableUtilities.substituteVariables(parent, recordVar, replacedVar, context); return replacedVar; } } return null; }