Method preload

bolt/exec/TableScan.cpp:440–483

}

void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
  // The AsyncSource returns a unique_ptr to the shared_ptr of the
  // DataSource. The callback may outlive the Task, hence it captures
  // a shared_ptr to it. This is required to keep memory pools live
  // for the duration. The callback checks for task cancellation to
  // avoid needless work.
  split->dataSource = std::make_unique<AsyncSource<connector::DataSource>>(
      [type = outputType_,
       table = tableHandle_,
       columns = columnHandles_,
       connector = connector_,
       ctx = operatorCtx_->createConnectorQueryCtx(
           split->connectorId,
           planNodeId(),
           connectorPool_,
           nullptr,
           asyncThreadCtx_),
       task = operatorCtx_->task(),
       pendingDynamicFilters = pendingDynamicFilters_,
       split]() -> std::unique_ptr<connector::DataSource> {
        if (task->isCancelled()) {
          return nullptr;
        }
        auto debugString =
            fmt::format("Split {} Task {}", split->toString(), task->taskId());
        ExceptionContextSetter exceptionContext(
            {[](BoltException::Type /*exceptionType*/, auto* debugString) {
               return *static_cast<std::string*>(debugString);
             },
             &debugString});

        auto ptr = connector->createDataSource(
            type, table, columns, ctx, task->queryCtx()->queryConfig());
        if (task->isCancelled()) {
          return nullptr;
        }
        for (const auto& entry : pendingDynamicFilters) {
          ptr->addDynamicFilter(entry.first, entry.second);
        }
        ptr->addSplit(split);
        return ptr;
      },
      true);
}

void TableScan::checkPreload() {
  auto executor = connector_->executor();