private NestedTupleSourceOperator getNts(AbstractLogicalOperator op) { AbstractLogicalOperator alo = op; do { if (alo.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { return (NestedTupleSourceOperator) alo; } if (alo.getInputs().size() != 1) { return null; } alo = (AbstractLogicalOperator) alo.getInputs().get(0).getValue(); } while (true); }
private Mutable<ILogicalOperator> getNtsAtEndOfPipeline(Mutable<ILogicalOperator> opRef) { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { return opRef; } if (op.getInputs().size() != 1) { return null; } return getNtsAtEndOfPipeline(op.getInputs().get(0)); }
public static Mutable<ILogicalOperator> findLastSubplanOperator(Mutable<ILogicalOperator> opRef) { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef; AbstractLogicalOperator next; while (op.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) { opRef = op.getInputs().get(0); op = (AbstractLogicalOperator) opRef; next = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); if (next.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { break; } } return opRef; }
public final static ILogicalOperator firstChildOfType(AbstractLogicalOperator op, LogicalOperatorTag opType) { List<Mutable<ILogicalOperator>> ins = op.getInputs(); if (ins == null || ins.isEmpty()) { return null; } Mutable<ILogicalOperator> opRef2 = ins.get(0); AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue(); if (op2.getOperatorTag() == opType) { return op2; } else { return null; } }
public static AbstractLogicalOperator findLastSubplanOperator(AbstractLogicalOperator op) { AbstractLogicalOperator next; while (op.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) { op = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); next = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); if (next.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { break; } } return op; }
private AbstractLogicalOperator findLastSubplanOperator(AbstractLogicalOperator op) { AbstractLogicalOperator next; while (op.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) { op = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); next = (AbstractLogicalOperator) op.getInputs().get(0).getValue(); if (next.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { break; } } return op; }
private List<List<LogicalVariable>> getLiveVarsInInputs(AbstractLogicalOperator op) throws AlgebricksException { List<Mutable<ILogicalOperator>> copiedInputs = new ArrayList<>(); for (Mutable<ILogicalOperator> childRef : op.getInputs()) { copiedInputs.add(deepCopyOperatorReference(childRef, null)); } List<List<LogicalVariable>> liveVarsInInputs = new ArrayList<>(); for (Mutable<ILogicalOperator> inputOpRef : copiedInputs) { List<LogicalVariable> liveVars = new ArrayList<>(); VariableUtilities.getLiveVariables(inputOpRef.getValue(), liveVars); liveVarsInInputs.add(liveVars); } return liveVarsInInputs; }
/** * Checks whether the given operator is LEFTOUTERJOIN. * If so, also checks that GROUPBY is placed after LEFTOUTERJOIN. */ // Check whether (Groupby)? <-- Leftouterjoin private boolean isLeftOuterJoin(AbstractLogicalOperator op1) { if (op1.getInputs().size() != 1) { return false; } if (op1.getInputs().get(0).getValue().getOperatorTag() != LogicalOperatorTag.LEFTOUTERJOIN) { return false; } if (op1.getOperatorTag() == LogicalOperatorTag.GROUP) { return true; } hasGroupBy = false; return true; }
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()); } } }
private void removeTrivialShare() { for (List<Mutable<ILogicalOperator>> candidates : equivalenceClasses) { for (int i = candidates.size() - 1; i >= 0; i--) { Mutable<ILogicalOperator> opRef = candidates.get(i); AbstractLogicalOperator aop = (AbstractLogicalOperator) opRef.getValue(); if (aop.getOperatorTag() == LogicalOperatorTag.EXCHANGE) { aop = (AbstractLogicalOperator) aop.getInputs().get(0).getValue(); } if (aop.getOperatorTag() == LogicalOperatorTag.EMPTYTUPLESOURCE) { candidates.remove(i); } } } for (int i = equivalenceClasses.size() - 1; i >= 0; i--) { if (equivalenceClasses.get(i).size() < 2) { equivalenceClasses.remove(i); } } }
private void gatherProducingDataScans(Mutable<ILogicalOperator> opRef, List<LogicalVariable> joinUsedVars, List<DataSourceScanOperator> dataScans) { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() != LogicalOperatorTag.DATASOURCESCAN) { for (Mutable<ILogicalOperator> inputOp : op.getInputs()) { gatherProducingDataScans(inputOp, joinUsedVars, dataScans); } return; } DataSourceScanOperator dataScan = (DataSourceScanOperator) op; fillPKVars(dataScan, pkVars); // Check if join uses all PK vars. if (joinUsedVars.containsAll(pkVars)) { dataScans.add(dataScan); } }
private void disableJobGenRec(ILogicalOperator operator) { AbstractLogicalOperator op = (AbstractLogicalOperator) operator; op.disableJobGen(); for (Mutable<ILogicalOperator> i : op.getInputs()) { disableJobGenRec(i.getValue()); } }
private boolean inlineInputAssignIntoAgg(AggregateOperator aggOp) throws AlgebricksException { AbstractLogicalOperator op2 = (AbstractLogicalOperator) aggOp.getInputs().get(0).getValue(); if (op2.getOperatorTag() != LogicalOperatorTag.ASSIGN) { return false; } AssignOperator assignOp = (AssignOperator) op2; VarExprSubstitution ves = new VarExprSubstitution(assignOp.getVariables(), assignOp.getExpressions()); inlineVariables(aggOp, ves); List<Mutable<ILogicalOperator>> op1InpList = aggOp.getInputs(); op1InpList.clear(); op1InpList.add(op2.getInputs().get(0)); return true; }
private boolean isSelectionAboveDataScan(Mutable<ILogicalOperator> opRef) { boolean hasSelection = false; AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); LogicalOperatorTag tag = op.getOperatorTag(); switch (tag) { case DATASOURCESCAN: return false; case UNNEST_MAP: case LEFT_OUTER_UNNEST_MAP: case LIMIT: case SELECT: return true; default: for (Mutable<ILogicalOperator> inputOp : op.getInputs()) { hasSelection |= isSelectionAboveDataScan(inputOp); } } return hasSelection; }
private boolean changeRule(AbstractLogicalOperator op) { boolean planModified = false; for (int i = 0; i < op.getInputs().size(); ++i) { AbstractLogicalOperator descendantOp = (AbstractLogicalOperator) op.getInputs().get(i).getValue(); if (descendantOp.getOperatorTag() == LogicalOperatorTag.PROJECT) { ProjectOperator projectOp = (ProjectOperator) descendantOp; StreamProjectPOperator physicalOp = (StreamProjectPOperator) projectOp.getPhysicalOperator(); physicalOp.setRapidFrameFlush(true); planModified = true; } else if (descendantOp.getOperatorTag() == LogicalOperatorTag.ASSIGN) { AssignOperator assignOp = (AssignOperator) descendantOp; AssignPOperator physicalOp = (AssignPOperator) assignOp.getPhysicalOperator(); physicalOp.setRapidFrameFlush(true); planModified = true; } changeRule(descendantOp); } return planModified; }
private static void computeSchemaBottomUpForOp(AbstractLogicalOperator op) throws AlgebricksException { for (Mutable<ILogicalOperator> i : op.getInputs()) { computeSchemaBottomUpForOp((AbstractLogicalOperator) i.getValue()); } if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans a = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : a.getNestedPlans()) { computeSchemaBottomUpForPlan(p); } } op.recomputeSchema(); }
private void setNewOp(Mutable<ILogicalOperator> opRef, AbstractLogicalOperator newOp, IOptimizationContext context) throws AlgebricksException { ILogicalOperator oldOp = opRef.getValue(); opRef.setValue(newOp); newOp.getInputs().add(new MutableObject<>(oldOp)); newOp.recomputeSchema(); newOp.computeDeliveredPhysicalProperties(context); context.computeAndSetTypeEnvironmentForOperator(newOp); if (AlgebricksConfig.ALGEBRICKS_LOGGER.isTraceEnabled()) { AlgebricksConfig.ALGEBRICKS_LOGGER.trace(">>>> Structural properties for " + newOp.getPhysicalOperator() + ": " + newOp.getDeliveredPhysicalProperties() + "\n"); } PhysicalOptimizationsUtil.computeFDsAndEquivalenceClasses(newOp, context); }
private void typeOpRec(Mutable<ILogicalOperator> r, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op = (AbstractLogicalOperator) r.getValue(); for (Mutable<ILogicalOperator> i : op.getInputs()) { typeOpRec(i, context); } if (op.hasNestedPlans()) { for (ILogicalPlan p : ((AbstractOperatorWithNestedPlans) op).getNestedPlans()) { typePlan(p, context); } } context.computeAndSetTypeEnvironmentForOperator(op); context.addToDontApplySet(this, op); }
@Override public void printOperator(AbstractLogicalOperator op, int indent) throws AlgebricksException { final AlgebricksAppendable out = this.get(); op.accept(this, indent); IPhysicalOperator pOp = op.getPhysicalOperator(); if (pOp != null) { out.append("\n"); pad(out, indent); appendln(out, "-- " + pOp.toString() + " |" + op.getExecutionMode() + "|"); } else { appendln(out, " -- |" + op.getExecutionMode() + "|"); } for (Mutable<ILogicalOperator> i : op.getInputs()) { printOperator((AbstractLogicalOperator) i.getValue(), indent + 2); } }
public static void computeSchemaRecIfNull(AbstractLogicalOperator op) throws AlgebricksException { if (op.getSchema() == null) { for (Mutable<ILogicalOperator> i : op.getInputs()) { computeSchemaRecIfNull((AbstractLogicalOperator) i.getValue()); } if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans a = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : a.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { computeSchemaRecIfNull((AbstractLogicalOperator) r.getValue()); } } } op.recomputeSchema(); } }