protected List<List<AlgebricksPipeline>> compileSubplansImpl(IOperatorSchema outerPlanSchema, AbstractOperatorWithNestedPlans npOp, IOperatorSchema opSchema, JobGenContext context) throws AlgebricksException { List<List<AlgebricksPipeline>> subplans = new ArrayList<>(npOp.getNestedPlans().size()); PlanCompiler pc = new PlanCompiler(context); for (ILogicalPlan p : npOp.getNestedPlans()) { subplans.add(buildPipelineWithProjection(p, outerPlanSchema, npOp, opSchema, pc)); } return subplans; }
private void typeGby(AbstractOperatorWithNestedPlans op, IOptimizationContext context) throws AlgebricksException { for (ILogicalPlan p : op.getNestedPlans()) { OperatorPropertiesUtil.typePlan(p, context); } context.computeAndSetTypeEnvironmentForOperator(op); }
private void mapVariablesInNestedPlans(AbstractOperatorWithNestedPlans op, ILogicalOperator arg) throws AlgebricksException { if (op.getOperatorTag() != arg.getOperatorTag()) { return; } AbstractOperatorWithNestedPlans argOp = (AbstractOperatorWithNestedPlans) arg; List<ILogicalPlan> plans = op.getNestedPlans(); List<ILogicalPlan> plansArg = argOp.getNestedPlans(); if (plans.size() != plansArg.size()) { return; } 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; } for (int j = 0; j < roots.size(); j++) { ILogicalOperator topOp1 = roots.get(j).getValue(); ILogicalOperator topOp2 = rootsArg.get(j).getValue(); topOp1.accept(this, topOp2); } } }
private void visitNestedPlans(AbstractOperatorWithNestedPlans op) throws AlgebricksException { for (ILogicalPlan p : op.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { VariableUtilities.getUsedVariablesInDescendantsAndSelf(r.getValue(), usedVariables); } } } }
private void substInNestedPlans(LogicalVariable v1, LogicalVariable v2, AbstractOperatorWithNestedPlans op) throws AlgebricksException { for (ILogicalPlan p : op.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { VariableUtilities.substituteVariablesInDescendantsAndSelf(r.getValue(), v1, v2, ctx); } } }
public static void getFreeVariablesInSubplans(AbstractOperatorWithNestedPlans op, Set<LogicalVariable> freeVars) throws AlgebricksException { for (ILogicalPlan p : op.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { getFreeVariablesInSelfOrDesc((AbstractLogicalOperator) r.getValue(), freeVars); } } }
protected void printNestedPlans(AbstractOperatorWithNestedPlans op, Integer indent) throws AlgebricksException { boolean first = true; if (op.getNestedPlans().isEmpty()) { buffer.append("}"); } else { for (ILogicalPlan p : op.getNestedPlans()) { // PrettyPrintUtil.indent(buffer, level + 10).append("var " + // p.first + ":\n"); buffer.append("\n"); if (first) { first = false; } else { addIndent(indent).append(" {\n"); } printPlan(p, indent + 10); addIndent(indent).append(" }"); } } }
private void rewriteAggregateInNestedSubplan(LogicalVariable oldAggVar, AbstractOperatorWithNestedPlans nspOp, AggregateFunctionCallExpression aggFun, LogicalVariable newAggVar, IOptimizationContext context) throws AlgebricksException { for (int j = 0; j < nspOp.getNestedPlans().size(); j++) { AggregateOperator aggOp = (AggregateOperator) nspOp.getNestedPlans().get(j).getRoots().get(0).getValue(); int n = aggOp.getVariables().size(); for (int i = 0; i < n; i++) { LogicalVariable v = aggOp.getVariables().get(i); if (v.equals(oldAggVar)) { AbstractFunctionCallExpression oldAggExpr = (AbstractFunctionCallExpression) aggOp.getExpressions().get(i).getValue(); AggregateFunctionCallExpression newAggFun = BuiltinFunctions .makeAggregateFunctionExpression(aggFun.getFunctionIdentifier(), new ArrayList<>()); newAggFun.setSourceLocation(oldAggExpr.getSourceLocation()); for (Mutable<ILogicalExpression> arg : oldAggExpr.getArguments()) { ILogicalExpression cloned = arg.getValue().cloneExpression(); newAggFun.getArguments().add(new MutableObject<>(cloned)); } aggOp.getVariables().add(newAggVar); aggOp.getExpressions().add(new MutableObject<>(newAggFun)); context.computeAndSetTypeEnvironmentForOperator(aggOp); break; } } } }
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(); }
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); if (op.getOperatorTag() != LogicalOperatorTag.GROUP && op.getOperatorTag() != LogicalOperatorTag.WINDOW) { return false; } boolean changed = false; AbstractOperatorWithNestedPlans opWithNestedPlan = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : opWithNestedPlan.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { changed |= inlined(r.getValue(), opWithNestedPlan); } } return changed; }
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); }
protected void printNestedPlans(AbstractOperatorWithNestedPlans op, Integer indent) throws AlgebricksException { idCounter.nextPrefix(); buffer.append("[\n"); boolean first = true; for (ILogicalPlan p : op.getNestedPlans()) { if (!first) { buffer.append(","); } printPlan(p, indent + 4); first = false; } addIndent(indent).append("]"); idCounter.previousPrefix(); }
/** * Recursively visits all descendants of the given operator and * (re)computes and sets a type environment for each operator. * * @param r * a mutable logical operator * @param context * optimization context * @throws AlgebricksException */ public static 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); }
private static <R> void computeFDsAndEqClassesWithVisitorRec(ILogicalOperator op, IOptimizationContext ctx, ILogicalOperatorVisitor<R, IOptimizationContext> visitor, Set<ILogicalOperator> visitSet) throws AlgebricksException { visitSet.add(op); for (Mutable<ILogicalOperator> i : op.getInputs()) { computeFDsAndEqClassesWithVisitorRec((AbstractLogicalOperator) i.getValue(), ctx, visitor, visitSet); } AbstractLogicalOperator aop = (AbstractLogicalOperator) op; if (aop.hasNestedPlans()) { for (ILogicalPlan p : ((AbstractOperatorWithNestedPlans) op).getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { AbstractLogicalOperator rootOp = (AbstractLogicalOperator) r.getValue(); computeFDsAndEqClassesWithVisitorRec(rootOp, ctx, visitor, visitSet); } } } if (op.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) { NestedTupleSourceOperator nts = (NestedTupleSourceOperator) op; ILogicalOperator source = nts.getDataSourceReference().getValue().getInputs().get(0).getValue(); if (!visitSet.contains(source)) { computeFDsAndEqClassesWithVisitorRec((AbstractLogicalOperator) source, ctx, visitor, visitSet); } } op.accept(visitor, ctx); }
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(); } }
/** * Compute type environment of a newly generated operator {@code op} and its input. * * @param op, * the logical operator. * @param context,the * optimization context. * @throws AlgebricksException */ public static void computeTypeEnvironmentBottomUp(ILogicalOperator op, ITypingContext context) throws AlgebricksException { for (Mutable<ILogicalOperator> children : op.getInputs()) { computeTypeEnvironmentBottomUp(children.getValue(), context); } AbstractLogicalOperator abstractOp = (AbstractLogicalOperator) op; if (abstractOp.hasNestedPlans()) { for (ILogicalPlan p : ((AbstractOperatorWithNestedPlans) op).getNestedPlans()) { for (Mutable<ILogicalOperator> rootRef : p.getRoots()) { computeTypeEnvironmentBottomUp(rootRef.getValue(), context); } } } context.computeAndSetTypeEnvironmentForOperator(op); }
public static void printPhysicalOperator(AbstractLogicalOperator op, int indent, AlgebricksAppendable out) throws AlgebricksException { IPhysicalOperator pOp = op.getPhysicalOperator(); pad(out, indent); appendln(out, "-- " + pOp.toString() + " |" + op.getExecutionMode() + "|"); if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans opNest = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : opNest.getNestedPlans()) { pad(out, indent + 8); appendln(out, "{"); printPhysicalOps(p, out, indent + 10); pad(out, indent + 8); appendln(out, "}"); } } for (Mutable<ILogicalOperator> i : op.getInputs()) { printPhysicalOperator((AbstractLogicalOperator) i.getValue(), indent + 2, out); } }
public static void computeSchemaAndPropertiesRecIfNull(AbstractLogicalOperator op, IOptimizationContext context) throws AlgebricksException { if (op.getSchema() == null) { for (Mutable<ILogicalOperator> i : op.getInputs()) { computeSchemaAndPropertiesRecIfNull((AbstractLogicalOperator) i.getValue(), context); } if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans a = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : a.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { computeSchemaAndPropertiesRecIfNull((AbstractLogicalOperator) r.getValue(), context); } } } op.recomputeSchema(); op.computeDeliveredPhysicalProperties(context); } }
public static void substituteVarRec(AbstractLogicalOperator op, LogicalVariable v1, LogicalVariable v2, boolean goThroughNts, ITypingContext ctx) throws AlgebricksException { VariableUtilities.substituteVariables(op, v1, v2, goThroughNts, ctx); for (Mutable<ILogicalOperator> opRef2 : op.getInputs()) { substituteVarRec((AbstractLogicalOperator) opRef2.getValue(), v1, v2, goThroughNts, ctx); } if (op.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE && goThroughNts) { NestedTupleSourceOperator nts = (NestedTupleSourceOperator) op; if (nts.getDataSourceReference() != null) { AbstractLogicalOperator op2 = (AbstractLogicalOperator) nts.getDataSourceReference().getValue().getInputs().get(0).getValue(); substituteVarRec(op2, v1, v2, goThroughNts, ctx); } } if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans aonp = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : aonp.getNestedPlans()) { for (Mutable<ILogicalOperator> ref : p.getRoots()) { AbstractLogicalOperator aop = (AbstractLogicalOperator) ref.getValue(); substituteVarRec(aop, v1, v2, goThroughNts, ctx); } } } }
private boolean applyRuleDown(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> varSet, IOptimizationContext context) throws AlgebricksException { boolean changed = applies(opRef, varSet, context); AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue(); VariableUtilities.getUsedVariables(op, varSet); if (op.hasNestedPlans()) { AbstractOperatorWithNestedPlans aonp = (AbstractOperatorWithNestedPlans) op; for (ILogicalPlan p : aonp.getNestedPlans()) { for (Mutable<ILogicalOperator> r : p.getRoots()) { if (applyRuleDown(r, varSet, context)) { changed = true; } context.addToDontApplySet(this, r.getValue()); } } } for (Mutable<ILogicalOperator> i : op.getInputs()) { if (applyRuleDown(i, varSet, context)) { changed = true; } context.addToDontApplySet(this, i.getValue()); } return changed; }