docs: @Override
      protected List<Driver> createDrivers(TaskContext taskContext)
      {
          ImmutableList.Builder<OperatorFactory> driversBuilder = ImmutableList.builder();
          driversBuilder.add(ordersTableScan);
          List<Type> sourceTypes = ordersTableTypes;
          OptionalInt hashChannel = OptionalInt.empty();
          if (hashEnabled) {
              driversBuilder.add(createHashProjectOperator(1, new PlanNodeId("test"), sourceTypes));
              sourceTypes = ImmutableList.<Type>builder()
                      .addAll(sourceTypes)
                      .add(BIGINT)
                      .build();
              hashChannel = OptionalInt.of(sourceTypes.size() - 1);
          }
  
          // hash build
          JoinBridgeManager<PartitionedLookupSourceFactory> lookupSourceFactoryManager = JoinBridgeManager.lookupAllAtOnce(new PartitionedLookupSourceFactory(
                  sourceTypes,
                  ImmutableList.of(0, 1).stream()
                          .map(sourceTypes::get)
                          .collect(toImmutableList()),
                  Ints.asList(0).stream()
                          .map(sourceTypes::get)
                          .collect(toImmutableList()),
                  1,
                  requireNonNull(ImmutableMap.of(), "layout is null"),
                  false));
          HashBuilderOperatorFactory hashBuilder = new HashBuilderOperatorFactory(
                  2,
                  new PlanNodeId("test"),
                  lookupSourceFactoryManager,
                  ImmutableList.of(0, 1),
                  Ints.asList(0),
                  hashChannel,
                  Optional.empty(),
                  Optional.empty(),
                  ImmutableList.of(),
                  1_500_000,
                  new PagesIndex.TestingFactory(false),
                  false,
                  SingleStreamSpillerFactory.unsupportedSingleStreamSpillerFactory());
          driversBuilder.add(hashBuilder);
          DriverFactory hashBuildDriverFactory = new DriverFactory(0, true, false, driversBuilder.build(), OptionalInt.empty(), UNGROUPED_EXECUTION);
  
          // join
          ImmutableList.Builder<OperatorFactory> joinDriversBuilder = ImmutableList.builder();
          joinDriversBuilder.add(lineItemTableScan);
          sourceTypes = lineItemTableTypes;
          hashChannel = OptionalInt.empty();
          if (hashEnabled) {
              joinDriversBuilder.add(createHashProjectOperator(1, new PlanNodeId("test"), sourceTypes));
              sourceTypes = ImmutableList.<Type>builder()
                      .addAll(sourceTypes)
                      .add(BIGINT)
                      .build();
              hashChannel = OptionalInt.of(sourceTypes.size() - 1);
          }
  
          OperatorFactory joinOperator = LOOKUP_JOIN_OPERATORS.innerJoin(
                  2,
                  new PlanNodeId("test"),
                  lookupSourceFactoryManager,
                  sourceTypes,
                  Ints.asList(0),
                  hashChannel,
                  Optional.empty(),
                  OptionalInt.empty(),
                  unsupportedPartitioningSpillerFactory());
          joinDriversBuilder.add(joinOperator);
          joinDriversBuilder.add(new NullOutputOperatorFactory(3, new PlanNodeId("test")));
          DriverFactory joinDriverFactory = new DriverFactory(1, true, true, joinDriversBuilder.build(), OptionalInt.empty(), UNGROUPED_EXECUTION);
  
          Driver hashBuildDriver = hashBuildDriverFactory.createDriver(taskContext.addPipelineContext(0, true, false, false).addDriverContext());
          hashBuildDriverFactory.noMoreDrivers();
          Driver joinDriver = joinDriverFactory.createDriver(taskContext.addPipelineContext(1, true, true, false).addDriverContext());
          joinDriverFactory.noMoreDrivers();
  
          return ImmutableList.of(hashBuildDriver, joinDriver);
      }