Method initialize

bolt/exec/FilterProject.cpp:121–165

          "FilterProject"),
      hasFilter_(filter != nullptr),
      driverCtx_(driverCtx),
      project_(project),
      filter_(filter),
      acceptCompositeInput_(
          driverCtx->queryConfig().isHashAggregationCompositeOutputEnabled()),
      skipForCompositeInput_(type == ProjectType::kSkipCompositeRowVector) {
  if (filter_ != nullptr && project_ != nullptr) {
    folly::Synchronized<OperatorStats>& opStats = Operator::stats();
    opStats.withWLock([&](auto& stats) {
      stats.setStatSplitter(
          [filterId = filter_->id()](const auto& combinedStats) {
            return splitStats(combinedStats, filterId);
          });
    });
  }
}

void FilterProject::initialize() {
  Operator::initialize();
  std::vector<core::TypedExprPtr> allExprs;
  if (hasFilter_) {
    BOLT_CHECK_NOT_NULL(filter_);
    allExprs.push_back(filter_->filter());
  }
  if (project_) {
    const auto& inputType = project_->sources()[0]->outputType();
    for (column_index_t i = 0; i < project_->projections().size(); i++) {
      auto& projection = project_->projections()[i];
      bool identityProjection = checkAddIdentityProjection(
          projection, inputType, i, identityProjections_);
      if (!identityProjection) {
        allExprs.push_back(projection);
        resultProjections_.emplace_back(allExprs.size() - 1, i);
      }
    }
  } else {
    for (column_index_t i = 0; i < outputType_->size(); ++i) {
      identityProjections_.emplace_back(i, i);
    }
    isIdentityProjection_ = true;
  }
  {
    std::unordered_map<column_index_t, size_t> inputChannelCounts;
    for (const auto& projection : identityProjections_) {
      ++inputChannelCounts[projection.inputChannel];
    }
    for (const auto& [inputChannel, count] : inputChannelCounts) {
      if (count > 1) {