@Override public PlanNode visitAssignUniqueId(AssignUniqueId node, RewriteContext<Void> context) { PlanNode source = context.rewrite(node.getSource()); return new AssignUniqueId(node.getId(), source, node.getIdColumn()); }
@Override public Void visitAssignUniqueId(AssignUniqueId node, Integer indent) { print(indent, "- AssignUniqueId => [%s]", formatOutputs(node.getOutputSymbols())); printPlanNodesStatsAndCost(indent + 2, node); printStats(indent + 2, node.getId()); return processChildren(node, indent + 1); }
@Override public PlanNode replaceChildren(List<PlanNode> newChildren) { checkArgument(newChildren.size() == 1, "expected newChildren to contain 1 node"); return new AssignUniqueId(getId(), Iterables.getOnlyElement(newChildren), idColumn); } }
@Override public PlanNode visitAssignUniqueId(AssignUniqueId node, RewriteContext<Set<Symbol>> context) { if (!context.get().contains(node.getIdColumn())) { return context.rewrite(node.getSource(), context.get()); } return context.defaultRewrite(node, context.get()); }
Symbol nonNull) AssignUniqueId inputWithUniqueColumns = new AssignUniqueId( idAllocator.getNextId(), lateralJoinNode.getInput(), ImmutableList.of(), ImmutableList.<Symbol>builder() .addAll(inputWithUniqueColumns.getOutputSymbols()) .addAll(scalarAggregationSource.getOutputSymbols()) .build(),
@Override public Optional<Symbol> getAssignedSymbol(PlanNode node, Session session, Metadata metadata, SymbolAliases symbolAliases) { if (!(node instanceof AssignUniqueId)) { return Optional.empty(); } AssignUniqueId assignUniqueIdNode = (AssignUniqueId) node; return Optional.of(assignUniqueIdNode.getIdColumn()); }
public AssignUniqueId assignUniqueId(Symbol unique, PlanNode source) { return new AssignUniqueId(idAllocator.getNextId(), source, unique); }
@Override public PhysicalOperation visitAssignUniqueId(AssignUniqueId node, LocalExecutionPlanContext context) { PhysicalOperation source = node.getSource().accept(this, context); OperatorFactory operatorFactory = new AssignUniqueIdOperator.AssignUniqueIdOperatorFactory( context.getNextOperatorId(), node.getId()); return new PhysicalOperation(operatorFactory, makeLayout(node), context, source); }
@Override public Void visitAssignUniqueId(AssignUniqueId node, Set<Symbol> boundSymbols) { node.getSource().accept(this, boundSymbols); // visit child return null; }
private static JoinNode leftOuterJoin(PlanNodeIdAllocator idAllocator, AssignUniqueId probeSide, ProjectNode buildSide, Expression joinExpression) { return new JoinNode( idAllocator.getNextId(), JoinNode.Type.LEFT, probeSide, buildSide, ImmutableList.of(), ImmutableList.<Symbol>builder() .addAll(probeSide.getOutputSymbols()) .addAll(buildSide.getOutputSymbols()) .build(), Optional.of(joinExpression), Optional.empty(), Optional.empty(), Optional.empty()); }
@Override public ActualProperties visitAssignUniqueId(AssignUniqueId node, List<ActualProperties> inputProperties) { ActualProperties properties = Iterables.getOnlyElement(inputProperties); ImmutableList.Builder<LocalProperty<Symbol>> newLocalProperties = ImmutableList.builder(); newLocalProperties.addAll(properties.getLocalProperties()); newLocalProperties.add(new GroupingProperty<>(ImmutableList.of(node.getIdColumn()))); node.getSource().getOutputSymbols().stream() .forEach(column -> newLocalProperties.add(new ConstantProperty<>(column))); if (properties.getNodePartitioning().isPresent()) { // preserve input (possibly preferred) partitioning return ActualProperties.builderFrom(properties) .local(newLocalProperties.build()) .build(); } return ActualProperties.builderFrom(properties) .global(partitionedOn(ARBITRARY_DISTRIBUTION, ImmutableList.of(node.getIdColumn()), Optional.empty())) .local(newLocalProperties.build()) .build(); }
PlanNode decorrelatedBuildSource = decorrelated.getDecorrelatedNode(); AssignUniqueId probeSide = new AssignUniqueId( idAllocator.getNextId(), apply.getInput(), .put(countNullMatchesSymbol, countWithFilter(nullMatchCondition)) .build(), singleGroupingSet(probeSide.getOutputSymbols()), ImmutableList.of(), AggregationNode.Step.SINGLE,
@Override public StreamProperties visitAssignUniqueId(AssignUniqueId node, List<StreamProperties> inputProperties) { StreamProperties properties = Iterables.getOnlyElement(inputProperties); if (properties.getPartitioningColumns().isPresent()) { // preserve input (possibly preferred) partitioning return properties; } return new StreamProperties(properties.getDistribution(), Optional.of(ImmutableList.of(node.getIdColumn())), properties.isOrdered()); }
new AssignUniqueId( context.getIdAllocator().getNextId(), lateralJoinNode.getInput(),
@Override public Map<PlanNodeId, SplitSource> visitAssignUniqueId(AssignUniqueId node, Void context) { return node.getSource().accept(this, context); }
@Override public Result apply(ExchangeNode node, Captures captures, Context context) { checkArgument(!node.getOrderingScheme().isPresent(), "Merge exchange over AssignUniqueId not supported"); AssignUniqueId assignUniqueId = captures.get(ASSIGN_UNIQUE_ID); PartitioningScheme partitioningScheme = node.getPartitioningScheme(); if (partitioningScheme.getPartitioning().getColumns().contains(assignUniqueId.getIdColumn())) { // The column produced by the AssignUniqueId is used in the partitioning scheme of the exchange. // Hence, AssignUniqueId node has to stay below the exchange node. return Result.empty(); } return Result.ofPlanNode(new AssignUniqueId( assignUniqueId.getId(), new ExchangeNode( node.getId(), node.getType(), node.getScope(), new PartitioningScheme( partitioningScheme.getPartitioning(), removeSymbol(partitioningScheme.getOutputLayout(), assignUniqueId.getIdColumn()), partitioningScheme.getHashColumn(), partitioningScheme.isReplicateNullsAndAny(), partitioningScheme.getBucketToPartition()), ImmutableList.of(assignUniqueId.getSource()), ImmutableList.of(removeSymbol(getOnlyElement(node.getInputs()), assignUniqueId.getIdColumn())), Optional.empty()), assignUniqueId.getIdColumn())); }
@Override public Optional<PlanNodeStatsEstimate> calculate(AssignUniqueId assignUniqueId, StatsProvider statsProvider, Lookup lookup, Session session, TypeProvider types) { PlanNodeStatsEstimate sourceStats = statsProvider.getStats(assignUniqueId.getSource()); return Optional.of(PlanNodeStatsEstimate.buildFrom(sourceStats) .addSymbolStatistics(assignUniqueId.getIdColumn(), SymbolStatsEstimate.builder() .setDistinctValuesCount(sourceStats.getOutputRowCount()) .setNullsFraction(0.0) .setAverageRowSize(BIGINT.getFixedSize()) .build()) .build()); } }
@Override public PlanNodeCostEstimate visitAssignUniqueId(AssignUniqueId node, Void context) { return cpuCost(getStats(node).getOutputSizeInBytes(ImmutableList.of(node.getIdColumn()), types)); }
@Override public Expression visitAssignUniqueId(AssignUniqueId node, Void context) { return node.getSource().accept(this, context); }
@Override public PlanNode visitAssignUniqueId(AssignUniqueId node, RewriteContext<Expression> context) { Set<Symbol> predicateSymbols = SymbolsExtractor.extractUnique(context.get()); checkState(!predicateSymbols.contains(node.getIdColumn()), "UniqueId in predicate is not yet supported"); return context.defaultRewrite(node, context.get()); } }