switch (topOp.getOperatorTag()) { case UNNEST_MAP: case LEFT_OUTER_UNNEST_MAP: return topOp; case UNIONALL: dataSourceOp = dataSourceOp.getInputs().get(0).getValue(); dataSourceOp = dataSourceOp.getInputs().get(0).getValue(); } while (dataSourceOp.getOperatorTag() != LogicalOperatorTag.SPLIT && dataSourceOp.hasInputs()); if (dataSourceOp.getOperatorTag() != LogicalOperatorTag.SPLIT) { dataSourceOp = dataSourceOp.getInputs().get(0).getValue(); } while (dataSourceOp.getOperatorTag() != LogicalOperatorTag.UNNEST_MAP && dataSourceOp.getOperatorTag() != LogicalOperatorTag.LEFT_OUTER_UNNEST_MAP && dataSourceOp.hasInputs()); if (dataSourceOp.getOperatorTag() == LogicalOperatorTag.UNNEST_MAP || dataSourceOp.getOperatorTag() == LogicalOperatorTag.LEFT_OUTER_UNNEST_MAP) { return dataSourceOp; } else {
private ILogicalOperator visitSingleInputOperator(ILogicalOperator op) throws AlgebricksException { if (op.getInputs().size() == 1) { // Deals with single input operators. Mutable<ILogicalOperator> childRef = op.getInputs().get(0); ILogicalOperator newChild = childRef.getValue().accept(this, null); LogicalOperatorTag childOpTag = newChild.getOperatorTag(); if (childOpTag == LogicalOperatorTag.INNERJOIN || childOpTag == LogicalOperatorTag.LEFTOUTERJOIN) { topJoinRef = childRef; } op.getInputs().get(0).setValue(newChild); } return op; }
public static ILogicalOperator deepCopy(ILogicalOperator op) throws AlgebricksException { OperatorDeepCopyVisitor visitor = new OperatorDeepCopyVisitor(); AbstractLogicalOperator copiedOperator = (AbstractLogicalOperator) op.accept(visitor, null); copiedOperator.setSourceLocation(op.getSourceLocation()); copiedOperator.setExecutionMode(op.getExecutionMode()); copiedOperator.getAnnotations().putAll(op.getAnnotations()); copiedOperator.setSchema(op.getSchema()); AbstractLogicalOperator sourceOp = (AbstractLogicalOperator) op; copiedOperator.setPhysicalOperator(sourceOp.getPhysicalOperator()); return copiedOperator; }
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { ILogicalOperator op = opRef.getValue(); if (op.getOperatorTag() == LogicalOperatorTag.UNNEST || op.getOperatorTag() == LogicalOperatorTag.LEFT_OUTER_UNNEST || op.getInputs().size() > 1) { return false; } return op.acceptExpressionTransform(exprRef -> rewriteExpressionReference(op, exprRef, context)); }
private boolean checkOperatorPattern(ILogicalOperator op1) { if (op1.getOperatorTag() != LogicalOperatorTag.LEFT_OUTER_UNNEST) { return false; } ILogicalOperator op2 = op1.getInputs().get(0).getValue(); if (op2.getOperatorTag() != LogicalOperatorTag.GROUP) { return false; } ILogicalOperator op3 = op2.getInputs().get(0).getValue(); if (op3.getOperatorTag() != LogicalOperatorTag.LEFTOUTERJOIN) { return false; } return true; }
private boolean isScanOrUnnest(ILogicalOperator op) { LogicalOperatorTag opTag = op.getOperatorTag(); return opTag == LogicalOperatorTag.DATASOURCESCAN || opTag == LogicalOperatorTag.UNNEST; }
@Override public void contributeRuntimeOperator(IHyracksJobBuilder builder, JobGenContext context, ILogicalOperator op, IOperatorSchema propagatedSchema, IOperatorSchema[] inputSchemas, IOperatorSchema outerPlanSchema) throws AlgebricksException { IOperatorDescriptorRegistry spec = builder.getJobSpec(); SinkOperatorDescriptor opDesc = new SinkOperatorDescriptor(spec, op.getInputs().size()); opDesc.setSourceLocation(op.getSourceLocation()); contributeOpDesc(builder, (AbstractLogicalOperator) op, opDesc); for (int i = 0; i < op.getInputs().size(); i++) { builder.contributeGraphEdge(op.getInputs().get(i).getValue(), 0, op, i); } }
/** * @return labels (0 or 1) for each input and output indicating the dependency between them. * The edges labeled as 1 must wait for the edges with label 0. */ @Override public Pair<int[], int[]> getInputOutputDependencyLabels(ILogicalOperator op) { int[] inputDependencyLabels = new int[op.getInputs().size()]; // filled with 0's int[] outputDependencyLabels = new int[] { 0 }; return new Pair<int[], int[]>(inputDependencyLabels, outputDependencyLabels); }
while (true) { ILogicalOperator candidateOp = candidateOpRef.getValue(); LogicalOperatorTag candidateOpTag = candidateOp.getOperatorTag(); if (candidateOp.getInputs().size() > 1 || !candidateOp.isMap() || candidateOpTag == LogicalOperatorTag.SELECT || candidateOpTag == LogicalOperatorTag.LIMIT || candidateOpTag == LogicalOperatorTag.UNNEST_MAP) { candidateOpRef = safeOpRef.getValue().getInputs().get(0); Mutable<ILogicalOperator> unsafeOpRef = safeOp.getInputs().get(0); ILogicalOperator unsafeOp = unsafeOpRef.getValue(); SourceLocation sourceLoc = limitOp.getSourceLocation(); limitCloneOp.setExecutionMode(unsafeOp.getExecutionMode()); OperatorPropertiesUtil.computeSchemaRecIfNull((AbstractLogicalOperator) unsafeOp); limitCloneOp.recomputeSchema();
/** * Checks whether a binary input operator in consideration needs to * run in a single partition mode. If it does, returns an empty properties vector. * Otherwise, returns the proposed partitioned properties vector. * * @param op, the binary input operator in consideration. * @param partitionedPropertiesVector, the proposed partitioned properties vector. * @return either an empty properties vector or the proposed partitioned properties vector. */ public static StructuralPropertiesVector checkUnpartitionedAndGetPropertiesVector(ILogicalOperator op, StructuralPropertiesVector partitionedPropertiesVector) { ILogicalOperator leftChild = op.getInputs().get(0).getValue(); ILogicalOperator rightChild = op.getInputs().get(1).getValue(); boolean unPartitioned = leftChild.getExecutionMode().equals(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED) && rightChild.getExecutionMode().equals(AbstractLogicalOperator.ExecutionMode.UNPARTITIONED); return unPartitioned ? StructuralPropertiesVector.EMPTY_PROPERTIES_VECTOR : partitionedPropertiesVector; } }
List<Mutable<ILogicalOperator>> opRefs = parent.getInputs(); for (int index = 0; index < opRefs.size(); index++) { Mutable<ILogicalOperator> opRef = opRefs.get(index); ILogicalOperator op = opRef.getValue(); SourceLocation sourceLoc = op.getSourceLocation(); IVariableTypeEnvironment env = op.computeOutputTypeEnvironment(context); for (int i = 0; i < producedVars.size(); i++) { LogicalVariable var = producedVars.get(i); new AssignOperator(newAssignVar, new MutableObject<ILogicalExpression>(cast)); newAssignOperator.setSourceLocation(sourceLoc); newAssignOperator.setExecutionMode(op.getExecutionMode()); newAssignOperator.getInputs().add(new MutableObject<ILogicalOperator>(op)); opRef.setValue(newAssignOperator);
private DotFormatBuilder.StringValue formatStringOf(ILogicalOperator operator, boolean showDetails) throws AlgebricksException { String formattedString = operator.accept(dotVisitor, showDetails).trim(); return DotFormatBuilder.StringValue.of(formattedString); }
private IOperatorDescriptor findOpDescForAlgebraicOp(ILogicalOperator op) throws AlgebricksException { IOperatorDescriptor hOpDesc = hyracksOps.get(op); if (hOpDesc != null) { return hOpDesc; } Integer metaOpKey = algebraicOpBelongingToMetaAsterixOp.get(op); if (metaOpKey == null) { throw AlgebricksException.create(DESCRIPTOR_GENERATION_ERROR, op.getSourceLocation(), op.getOperatorTag()); } return metaAsterixOps.get(metaOpKey); }
/** * Whether an operator can be moved around in the query plan. * * @param op * the operator to consider. * @return true if the operator can be moved, false if the operator cannot be moved. */ public static boolean isMovable(ILogicalOperator op) { Object annotation = op.getAnnotations().get(MOVABLE); if (annotation != null) { return (Boolean) annotation; } switch (op.getOperatorTag()) { case ASSIGN: // Can't move nonPures! AssignOperator assign = (AssignOperator) op; for (Mutable<ILogicalExpression> expr : assign.getExpressions()) { if (containsNonpureCall(expr.getValue())) { return false; } } break; case WINDOW: return false; } return true; }
private long getOperatorRequiredMemory(ILogicalOperator op, long memorySize) { if (op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.PARTITIONED || op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.LOCAL) { return memorySize * numComputationPartitions; } return memorySize; }
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; }
IPhysicalPropertiesVector reqdByParent, IOptimizationContext context) throws AlgebricksException { IPartitioningProperty pp; switch (op.getExecutionMode()) { case PARTITIONED: pp = new UnorderedPartitionedProperty(new ListSet<>(partitionColumns), break; default: throw new IllegalStateException(op.getExecutionMode().name()); if (!pcVars.remove(ocVar) && containsAny(orderColumns, oIdx + 1, pcVars)) { throw new AlgebricksException(ErrorCode.HYRACKS, ErrorCode.UNSUPPORTED_WINDOW_SPEC, op.getSourceLocation(), String.valueOf(partitionColumns), String.valueOf(orderColumns));
@Override public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException { ILogicalOperator op = opRef.getValue(); if (op.getInputs().isEmpty()) { return false; } // Populates the latest type information. context.computeAndSetTypeEnvironmentForOperator(op); if (op.acceptExpressionTransform(exprRef -> injectTypeCast(op, exprRef, context))) { // Generates the up-to-date type information. context.computeAndSetTypeEnvironmentForOperator(op); return true; } return false; }
private void copySourceLocation(ILogicalOperator src, AbstractLogicalOperator dest) { dest.setSourceLocation(src.getSourceLocation()); }