public synchronized Driver createDriver(DriverContext driverContext) { checkState(!closed, "DriverFactory is already closed"); requireNonNull(driverContext, "driverContext is null"); checkState(!closedLifespans.contains(driverContext.getLifespan()), "DriverFatory is already closed for driver group %s", driverContext.getLifespan()); encounteredLifespans.add(driverContext.getLifespan()); ImmutableList.Builder<Operator> operators = ImmutableList.builder(); for (OperatorFactory operatorFactory : operatorFactories) { Operator operator = operatorFactory.createOperator(driverContext); operators.add(operator); } return Driver.createDriver(driverContext, operators.build()); }
public synchronized void noMoreDrivers(Lifespan lifespan) { if (closedLifespans.contains(lifespan)) { return; } encounteredLifespans.add(lifespan); closedLifespans.add(lifespan); for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.noMoreOperators(lifespan); } }
public PhysicalOperation(OperatorFactory operatorFactory, Map<Symbol, Integer> layout) { requireNonNull(operatorFactory, "operatorFactory is null"); requireNonNull(layout, "layout is null"); this.operatorFactories = ImmutableList.of(operatorFactory); this.layout = ImmutableMap.copyOf(layout); this.types = operatorFactory.getTypes(); }
@Override public synchronized void close() { if (!closed) { closed = true; for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.close(); } } }
public IndexBuildDriverFactoryProvider(int outputOperatorId, PlanNodeId planNodeId, boolean inputDriver, List<OperatorFactory> coreOperatorFactories, Optional<DynamicTupleFilterFactory> dynamicTupleFilterFactory) { requireNonNull(planNodeId, "planNodeId is null"); requireNonNull(coreOperatorFactories, "coreOperatorFactories is null"); checkArgument(!coreOperatorFactories.isEmpty(), "coreOperatorFactories is empty"); requireNonNull(dynamicTupleFilterFactory, "dynamicTupleFilterFactory is null"); this.outputOperatorId = outputOperatorId; this.planNodeId = planNodeId; this.inputDriver = inputDriver; this.coreOperatorFactories = ImmutableList.copyOf(coreOperatorFactories); this.outputTypes = ImmutableList.copyOf(this.coreOperatorFactories.get(this.coreOperatorFactories.size() - 1).getTypes()); this.dynamicTupleFilterFactory = dynamicTupleFilterFactory; }
@Override public Operator createOperator(DriverContext driverContext) { checkState(!closed, "Factory is already closed"); OperatorContext context = driverContext.addOperatorContext(operatorId, planNodeId, TableFinishOperator.class.getSimpleName()); Operator statisticsAggregationOperator = statisticsAggregationOperatorFactory.createOperator(driverContext); boolean statisticsCpuTimerEnabled = !(statisticsAggregationOperator instanceof DevNullOperator) && isStatisticsCpuTimerEnabled(session); return new TableFinishOperator(context, tableFinisher, statisticsAggregationOperator, descriptor, statisticsCpuTimerEnabled); }
public PhysicalOperation(OperatorFactory operatorFactory, Map<Symbol, Integer> layout, PhysicalOperation source) { requireNonNull(operatorFactory, "operatorFactory is null"); requireNonNull(layout, "layout is null"); requireNonNull(source, "source is null"); this.operatorFactories = ImmutableList.<OperatorFactory>builder().addAll(source.getOperatorFactories()).add(operatorFactory).build(); this.layout = ImmutableMap.copyOf(layout); this.types = operatorFactory.getTypes(); }
public synchronized void noMoreDrivers() { if (closed) { return; } if (encounteredLifespans.size() != closedLifespans.size()) { Sets.difference(encounteredLifespans, closedLifespans).forEach(this::noMoreDrivers); verify(encounteredLifespans.size() == closedLifespans.size()); } closed = true; for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.noMoreOperators(); } } }
@Override public Operator createOperator(DriverContext driverContext) { checkState(!closed, "Factory is already closed"); OperatorContext context = driverContext.addOperatorContext(operatorId, planNodeId, TableWriterOperator.class.getSimpleName()); Operator statisticsAggregationOperator = statisticsAggregationOperatorFactory.createOperator(driverContext); boolean statisticsCpuTimerEnabled = !(statisticsAggregationOperator instanceof DevNullOperator) && isStatisticsCpuTimerEnabled(session); return new TableWriterOperator(context, createPageSink(), columnChannels, statisticsAggregationOperator, types, statisticsCpuTimerEnabled); }
protected DriverFactory createDriverFactory() { List<OperatorFactory> operatorFactories = new ArrayList<>(createOperatorFactories()); operatorFactories.add(new NullOutputOperatorFactory(999, new PlanNodeId("test"), Iterables.getLast(operatorFactories).getTypes())); return new DriverFactory(true, true, operatorFactories); }
public static List<Page> toPages(OperatorFactory operatorFactory, DriverContext driverContext, List<Page> input) { try (Operator operator = operatorFactory.createOperator(driverContext)) { return toPages(operator, input.iterator()); } catch (Exception e) { throwIfUnchecked(e); throw new RuntimeException(e); } }
@Override protected List<? extends OperatorFactory> createOperatorFactories() { OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "totalprice"); TopNOperatorFactory topNOperator = new TopNOperatorFactory( 1, new PlanNodeId("test"), tableScanOperator.getTypes(), 100, ImmutableList.of(0), ImmutableList.of(ASC_NULLS_LAST), false); return ImmutableList.of(tableScanOperator, topNOperator); }
private Object selectSingleValue(OperatorFactory operatorFactory, Type type, Session session) { Operator operator = operatorFactory.createOperator(createDriverContext(session)); return selectSingleValue(operator, type); }
@Override protected List<? extends OperatorFactory> createOperatorFactories() { OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "totalprice", "clerk"); LimitOperatorFactory limitOperator = new LimitOperatorFactory(1, new PlanNodeId("test"), tableScanOperator.getTypes(), ROWS); OrderByOperatorFactory orderByOperator = new OrderByOperatorFactory( 2, new PlanNodeId("test"), limitOperator.getTypes(), ImmutableList.of(1), ROWS, ImmutableList.of(0), ImmutableList.of(ASC_NULLS_LAST)); return ImmutableList.of(tableScanOperator, limitOperator, orderByOperator); }
private static boolean executeFilter(OperatorFactory operatorFactory, Session session) { return executeFilter(operatorFactory.createOperator(createDriverContext(session))); }
node.getId(), aggregationConcurrency, exchangeSource.getTypes(), getChannelsForSymbols(ImmutableList.copyOf(node.getMasks().values()), source.getLayout()), getChannelsForSymbols(ImmutableList.copyOf(node.getGroupBy()), source.getLayout()),
private static boolean executeFilterWithNoInputColumns(OperatorFactory operatorFactory, Session session) { return executeFilterWithNoInputColumns(operatorFactory.createOperator(createDriverContext(session))); }
assertType(operatorFactory.getTypes(), expectedType); Object directOperatorValue = selectSingleValue(operatorFactory, session); results.add(directOperatorValue);
private RevocableMemoryOperator setupConsumeRevocableMemory(DataSize reservedPerPage, long numberOfPages) { AtomicReference<RevocableMemoryOperator> createOperator = new AtomicReference<>(); setUp(() -> { DriverContext driverContext = taskContext.addPipelineContext(0, false, false, false).addDriverContext(); OperatorContext revokableOperatorContext = driverContext.addOperatorContext( Integer.MAX_VALUE, new PlanNodeId("revokable_operator"), TableScanOperator.class.getSimpleName()); OutputFactory outputFactory = new PageConsumerOutputFactory(types -> (page -> {})); Operator outputOperator = outputFactory.createOutputOperator(2, new PlanNodeId("output"), ImmutableList.of(), Function.identity(), new TestingPagesSerdeFactory()).createOperator(driverContext); RevocableMemoryOperator revocableMemoryOperator = new RevocableMemoryOperator(revokableOperatorContext, reservedPerPage, numberOfPages); createOperator.set(revocableMemoryOperator); Driver driver = Driver.createDriver(driverContext, revocableMemoryOperator, outputOperator); return ImmutableList.of(driver); }); return createOperator.get(); }
.addDriverContext(); try (Operator operator = operatorFactory.createOperator(driverContext)) { assertTrue(operator.needsInput()); operator.addInput(input);