public static boolean isOperatorIsomorphicPlanSegment(ILogicalOperator op, ILogicalOperator arg) throws AlgebricksException { List<Mutable<ILogicalOperator>> inputs1 = op.getInputs(); List<Mutable<ILogicalOperator>> inputs2 = arg.getInputs(); if (inputs1.size() != inputs2.size()) { return false; } for (int i = 0; i < inputs1.size(); i++) { ILogicalOperator input1 = inputs1.get(i).getValue(); ILogicalOperator input2 = inputs2.get(i).getValue(); boolean isomorphic = isOperatorIsomorphicPlanSegment(input1, input2); if (!isomorphic) { return false; } } return IsomorphismUtilities.isOperatorIsomorphic(op, arg); }
private boolean compareSubplans(List<ILogicalPlan> plans, List<ILogicalPlan> plansArg) throws AlgebricksException { int plansSize = plans.size(); if (plansSize != plansArg.size()) { return false; } for (int i = 0; i < plansSize; i++) { if (!IsomorphismUtilities.isOperatorIsomorphicPlan(plans.get(i), plansArg.get(i))) { return false; } } return true; }
Map<LogicalVariable, ILogicalOperator> varOpMap = new HashMap<>(); for (LogicalVariable pk : pkVars) { ILogicalOperator mOp = getOpThatProducesPK(op, pk); if (mOp == null || !mOp.getOperatorTag().equals(LogicalOperatorTag.DATASOURCESCAN)) { throw new AlgebricksException("Illegal variable production."); IDataSource<?> rightSource = ((DataSourceScanOperator) (varOpMap.get(pkVars.get(j)))).getDataSource(); if (leftSource.getId().toString().equals(rightSource.getId().toString())) { mapVariablesTopDown(varOpMap.get(pkVars.get(i)), varOpMap.get(pkVars.get(j)), variableMapping);
for (int i = members.size() - 1; i >= 0; i--) { Mutable<ILogicalOperator> peer = members.get(i); if (IsomorphismUtilities.isOperatorIsomorphic(candidate.getValue(), peer.getValue())) { group.add(peer); members.remove(i); Map<LogicalVariable, LogicalVariable> variableMappingBack = new HashMap<LogicalVariable, LogicalVariable>(); IsomorphismUtilities.mapVariablesTopDown(ref.getValue(), candidate.getValue(), variableMappingBack); for (int i = 0; i < liveVarsNew.size(); i++) { liveVars.add(variableMappingBack.get(liveVarsNew.get(i)));
public static boolean isOperatorIsomorphicPlan(ILogicalPlan plan, ILogicalPlan arg) throws AlgebricksException { if (plan.getRoots().size() != arg.getRoots().size()) { return false; } for (int i = 0; i < plan.getRoots().size(); i++) { ILogicalOperator topOp1 = plan.getRoots().get(i).getValue(); ILogicalOperator topOp2 = arg.getRoots().get(i).getValue(); if (!IsomorphismUtilities.isOperatorIsomorphicPlanSegment(topOp1, topOp2)) { return false; } } return true; }
private ILogicalOperator copyAndSubstituteVar(ILogicalOperator op, ILogicalOperator argOp) throws AlgebricksException { ILogicalOperator newOp = OperatorManipulationUtil.deepCopy(argOp); variableMapping.clear(); IsomorphismUtilities.mapVariablesTopDown(op, argOp, variableMapping); List<LogicalVariable> liveVars = new ArrayList<>(); for (int i = 0; i < argOp.getInputs().size(); i++) { VariableUtilities.getLiveVariables(argOp.getInputs().get(i).getValue(), liveVars); } List<LogicalVariable> producedVars = new ArrayList<>(); VariableUtilities.getProducedVariables(argOp, producedVars); List<LogicalVariable> producedVarsNew = new ArrayList<>(); VariableUtilities.getProducedVariables(op, producedVarsNew); if (producedVars.size() != producedVarsNew.size()) { return newOp; } for (Entry<LogicalVariable, LogicalVariable> map : variableMapping.entrySet()) { if (liveVars.contains(map.getKey())) { VariableUtilities.substituteVariables(newOp, map.getKey(), map.getValue(), null); } } for (int i = 0; i < producedVars.size(); i++) { VariableUtilities.substituteVariables(newOp, producedVars.get(i), producedVarsNew.get(i), null); } return newOp; }
for (int j = i - 1; j >= 0; j--) { ILogicalOperator peer = candidates.get(j).getValue(); if (IsomorphismUtilities.isOperatorIsomorphic(candidate, peer)) { reserved[i] = true; reserved[j] = true;
IsomorphismUtilities.mergeHomogeneousPK(leftInputOp, leftInputPKs);
private static ILogicalOperator getOpThatProducesPK(ILogicalOperator rootOp, LogicalVariable pkVar) throws AlgebricksException { ILogicalOperator prodOp = null; boolean produced; for (Mutable<ILogicalOperator> opRef : rootOp.getInputs()) { produced = false; List<LogicalVariable> producedVars = new ArrayList<>(); VariableUtilities.getProducedVariables(opRef.getValue(), producedVars); if (producedVars.contains(pkVar)) { prodOp = opRef.getValue(); produced = true; } else if (opRef.getValue().hasInputs()) { prodOp = getOpThatProducesPK(opRef.getValue(), pkVar); if (prodOp != null) { produced = true; } } if (produced) { break; } } return prodOp; }
@Override public Boolean visitSubplanOperator(SubplanOperator op, ILogicalOperator arg) throws AlgebricksException { AbstractLogicalOperator aop = (AbstractLogicalOperator) arg; if (aop.getOperatorTag() != LogicalOperatorTag.SUBPLAN) { return Boolean.FALSE; } SubplanOperator subplanOpArg = (SubplanOperator) copyAndSubstituteVar(op, arg); List<ILogicalPlan> plans = op.getNestedPlans(); List<ILogicalPlan> plansArg = subplanOpArg.getNestedPlans(); for (int i = 0; i < plans.size(); i++) { List<Mutable<ILogicalOperator>> roots = plans.get(i).getRoots(); List<Mutable<ILogicalOperator>> rootsArg = plansArg.get(i).getRoots(); if (roots.size() == rootsArg.size()) { return Boolean.FALSE; } for (int j = 0; j < roots.size(); j++) { ILogicalOperator topOp1 = roots.get(j).getValue(); ILogicalOperator topOp2 = rootsArg.get(j).getValue(); boolean isomorphic = IsomorphismUtilities.isOperatorIsomorphicPlanSegment(topOp1, topOp2); if (!isomorphic) { return Boolean.FALSE; } } } return Boolean.TRUE; }
IsomorphismUtilities.mapVariablesTopDown(op, arg, variableMapping); IPhysicalPropertiesVector properties = op.getPhysicalOperator().getDeliveredProperties(); IPhysicalPropertiesVector propertiesArg = aop.getPhysicalOperator().getDeliveredProperties();
ILogicalOperator topOp1 = roots.get(j).getValue(); ILogicalOperator topOp2 = rootsArg.get(j).getValue(); isomorphic = IsomorphismUtilities.isOperatorIsomorphicPlanSegment(topOp1, topOp2); if (!isomorphic) { return Boolean.FALSE;
private ILogicalPlan fingIdenticalPlan(GroupByOperator newGbyOp, ILogicalPlan plan) throws AlgebricksException { for (ILogicalPlan nestedPlan : newGbyOp.getNestedPlans()) { if (IsomorphismUtilities.isOperatorIsomorphicPlan(plan, nestedPlan)) { return nestedPlan; } } return null; }
private boolean consolidateNestedPlans(WindowOperator winOpTo, WindowOperator winOpFrom, IOptimizationContext context) throws AlgebricksException { if (winOpTo.hasNestedPlans()) { AggregateOperator aggTo = getAggregateRoot(winOpTo.getNestedPlans()); if (aggTo == null) { return false; } AggregateOperator aggFrom = getAggregateRoot(winOpFrom.getNestedPlans()); if (aggFrom == null) { return false; } if (!IsomorphismUtilities.isOperatorIsomorphicPlanSegment(aggTo.getInputs().get(0).getValue(), aggFrom.getInputs().get(0).getValue())) { return false; } aggTo.getVariables().addAll(aggFrom.getVariables()); aggTo.getExpressions().addAll(aggFrom.getExpressions()); context.computeAndSetTypeEnvironmentForOperator(aggTo); } else { setAll(winOpTo.getNestedPlans(), winOpFrom.getNestedPlans()); setAll(winOpTo.getFrameValueExpressions(), winOpFrom.getFrameValueExpressions()); setAll(winOpTo.getFrameStartExpressions(), winOpFrom.getFrameStartExpressions()); setAll(winOpTo.getFrameEndExpressions(), winOpFrom.getFrameEndExpressions()); setAll(winOpTo.getFrameExcludeExpressions(), winOpFrom.getFrameExcludeExpressions()); winOpTo.setFrameExcludeNegationStartIdx(winOpFrom.getFrameExcludeNegationStartIdx()); winOpTo.getFrameOffset().setValue(winOpFrom.getFrameOffset().getValue()); winOpTo.setFrameMaxObjects(winOpFrom.getFrameMaxObjects()); } return true; }