@Override public PlanNode visitTableFinish(TableFinishNode node, RewriteContext<Set<Symbol>> context) { PlanNode source = context.rewrite(node.getSource(), ImmutableSet.copyOf(node.getSource().getOutputSymbols())); return new TableFinishNode( node.getId(), source, node.getTarget(), node.getRowCountSymbol(), node.getStatisticsAggregation(), node.getStatisticsAggregationDescriptor()); }
@Override public Void visitTableFinish(TableFinishNode node, Integer indent) { print(indent, "- TableCommit[%s] => [%s]", node.getTarget(), formatOutputs(node.getOutputSymbols())); printPlanNodesStatsAndCost(indent + 2, node); printStats(indent + 2, node.getId()); if (node.getStatisticsAggregation().isPresent()) { verify(node.getStatisticsAggregationDescriptor().isPresent(), "statisticsAggregationDescriptor is not present"); printStatisticAggregations(node.getStatisticsAggregation().get(), node.getStatisticsAggregationDescriptor().get(), indent + 2); } return processChildren(node, indent + 1); }
@Override public PlanNode replaceChildren(List<PlanNode> newChildren) { return new TableFinishNode( getId(), Iterables.getOnlyElement(newChildren), target, rowCountSymbol, statisticsAggregation, statisticsAggregationDescriptor); } }
@Override public PlanNode visitTableFinish(TableFinishNode node, List<PlanNode> newChildren) { return new TableFinishNode(node.getId(), Iterables.getOnlyElement(newChildren), node.getTarget(), node.getOutputSymbols()); }
@Override public PhysicalOperation visitTableFinish(TableFinishNode node, LocalExecutionPlanContext context) PhysicalOperation source = node.getSource().accept(this, context); OperatorFactory statisticsAggregation = node.getStatisticsAggregation().map(aggregation -> { List<Symbol> groupingSymbols = aggregation.getGroupingSymbols(); if (groupingSymbols.isEmpty()) { return createAggregationOperatorFactory( node.getId(), aggregation.getAggregations(), FINAL, node.getId(), aggregation.getAggregations(), ImmutableSet.of(), }).orElse(new DevNullOperatorFactory(context.getNextOperatorId(), node.getId())); StatisticAggregationsDescriptor<Integer> descriptor = node.getStatisticsAggregationDescriptor() .map(desc -> desc.map(aggregationOutput::get)) .orElse(StatisticAggregationsDescriptor.empty()); node.getId(), createTableFinisher(session, node, metadata), statisticsAggregation, descriptor, session); Map<Symbol, Integer> layout = ImmutableMap.of(node.getOutputSymbols().get(0), 0);
@Override public Void visitTableFinish(TableFinishNode node, Void context) { printNode(node, format("TableFinish[%s]", Joiner.on(", ").join(node.getOutputSymbols())), NODE_COLORS.get(NodeType.TABLE_FINISH)); return node.getSource().accept(this, context); }
private RelationPlan createDeletePlan(Analysis analysis, Delete node) { DeleteNode deleteNode = new QueryPlanner(analysis, symbolAllocator, idAllocator, buildLambdaDeclarationToSymbolMap(analysis, symbolAllocator), metadata, session) .plan(node); TableFinishNode commitNode = new TableFinishNode( idAllocator.getNextId(), deleteNode, deleteNode.getTarget(), symbolAllocator.newSymbol("rows", BIGINT), Optional.empty(), Optional.empty()); return new RelationPlan(commitNode, analysis.getScope(node), commitNode.getOutputSymbols()); }
@Override public PhysicalOperation visitTableFinish(TableFinishNode node, LocalExecutionPlanContext context) { PhysicalOperation source = node.getSource().accept(this, context); OperatorFactory operatorFactory = new TableFinishOperatorFactory(context.getNextOperatorId(), node.getId(), createTableFinisher(session, node, metadata)); Map<Symbol, Integer> layout = ImmutableMap.of(node.getOutputSymbols().get(0), 0); return new PhysicalOperation(operatorFactory, layout, source); }
@Override public Result apply(TableFinishNode node, Captures captures, Context context) { return Result.ofPlanNode( new ValuesNode( node.getId(), node.getOutputSymbols(), ImmutableList.of(ImmutableList.of(new LongLiteral("0"))))); } }
@Override public Void visitTableFinish(TableFinishNode node, Set<Symbol> boundSymbols) { node.getSource().accept(this, boundSymbols); // visit child return null; }
public TableFinishNode tableDelete(SchemaTableName schemaTableName, PlanNode deleteSource, Symbol deleteRowId) { TableWriterNode.DeleteHandle deleteHandle = new TableWriterNode.DeleteHandle( new TableHandle( new ConnectorId("testConnector"), new TestingTableHandle()), schemaTableName); return new TableFinishNode( idAllocator.getNextId(), exchange(e -> e .addSource(new DeleteNode( idAllocator.getNextId(), deleteSource, deleteHandle, deleteRowId, ImmutableList.of(deleteRowId))) .addInputsSet(deleteRowId) .singleDistributionPartitioningScheme(deleteRowId)), deleteHandle, deleteRowId, Optional.empty(), Optional.empty()); }
@Override public Void visitTableFinish(TableFinishNode node, Integer indent) { print(indent, "- TableCommit[%s] => [%s]", node.getTarget(), formatOutputs(node.getOutputSymbols())); return processChildren(node, indent + 1); }
private static TableFinisher createTableFinisher(Session session, TableFinishNode node, Metadata metadata) { WriterTarget target = node.getTarget(); return (fragments, statistics) -> { if (target instanceof CreateHandle) { return metadata.finishCreateTable(session, ((CreateHandle) target).getHandle(), fragments, statistics); } else if (target instanceof InsertHandle) { return metadata.finishInsert(session, ((InsertHandle) target).getHandle(), fragments, statistics); } else if (target instanceof DeleteHandle) { metadata.finishDelete(session, ((DeleteHandle) target).getHandle(), fragments); return Optional.empty(); } else { throw new AssertionError("Unhandled target type: " + target.getClass().getName()); } }; }
@Override public PlanNode visitTableFinish(TableFinishNode node, RewriteContext<Set<Symbol>> context) { // Maintain the existing inputs needed for TableCommitNode PlanNode source = context.rewrite(node.getSource(), ImmutableSet.copyOf(node.getSource().getOutputSymbols())); return new TableFinishNode(node.getId(), source, node.getTarget(), node.getOutputSymbols()); }
@Override public PlanNode visitTableFinish(TableFinishNode node, RewriteContext<Void> context) { Optional<DeleteNode> delete = findNode(node.getSource(), DeleteNode.class); if (!delete.isPresent()) { return context.defaultRewrite(node); } Optional<TableScanNode> tableScan = findNode(delete.get().getSource(), TableScanNode.class); if (!tableScan.isPresent()) { return context.defaultRewrite(node); } TableScanNode tableScanNode = tableScan.get(); if (!metadata.supportsMetadataDelete(session, tableScanNode.getTable(), tableScanNode.getLayout().get())) { return context.defaultRewrite(node); } return new MetadataDeleteNode(idAllocator.getNextId(), delete.get().getTarget(), Iterables.getOnlyElement(node.getOutputSymbols()), tableScanNode.getLayout().get()); }
Optional.of(result.getDescriptor().map(aggregations.getMappings()::get))); TableFinishNode commitNode = new TableFinishNode( idAllocator.getNextId(), writerNode, Optional.of(result.getDescriptor())); return new RelationPlan(commitNode, analysis.getRootScope(), commitNode.getOutputSymbols()); TableFinishNode commitNode = new TableFinishNode( idAllocator.getNextId(), new TableWriterNode( Optional.empty(), Optional.empty()); return new RelationPlan(commitNode, analysis.getRootScope(), commitNode.getOutputSymbols());
@Override public Map<PlanNodeId, SplitSource> visitTableFinish(TableFinishNode node, Void context) { return node.getSource().accept(this, context); }
TableFinishNode commitNode = new TableFinishNode( idAllocator.getNextId(), writerNode,
@Override public Void visitTableFinish(TableFinishNode node, IOPlanBuilder context) WriterTarget writerTarget = node.getTarget(); if (writerTarget instanceof CreateHandle) { CreateHandle createHandle = (CreateHandle) writerTarget;
public TableFinishNode map(TableFinishNode node, PlanNode source) { return new TableFinishNode( node.getId(), source, node.getTarget(), map(node.getRowCountSymbol()), node.getStatisticsAggregation().map(this::map), node.getStatisticsAggregationDescriptor().map(descriptor -> descriptor.map(this::map))); }