Method Make

cpp/src/arrow/acero/groupby_aggregate_node.cc:180–202

}

Result<ExecNode*> GroupByNode::Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                    const ExecNodeOptions& options) {
  RETURN_NOT_OK(ValidateExecNodeInputs(plan, inputs, 1, "GroupByNode"));

  auto input = inputs[0];
  const auto& aggregate_options = checked_cast<const AggregateNodeOptions&>(options);
  const auto& keys = aggregate_options.keys;
  const auto& segment_keys = aggregate_options.segment_keys;
  auto aggs = aggregate_options.aggregates;
  bool is_cpu_parallel = plan->query_context()->executor()->GetCapacity() > 1;

  const auto& input_schema = input->output_schema();
  auto exec_ctx = plan->query_context()->exec_context();
  ARROW_ASSIGN_OR_RAISE(
      auto args, MakeAggregateNodeArgs(input_schema, keys, segment_keys, aggs, exec_ctx,
                                       is_cpu_parallel));

  return input->plan()->EmplaceNode<GroupByNode>(
      input, std::move(args.output_schema), std::move(args.grouping_key_field_ids),
      std::move(args.segment_key_field_ids), std::move(args.segmenter),
      std::move(args.kernel_intypes), std::move(args.target_fieldsets),
      std::move(args.aggregates), std::move(args.kernels));
}

Status GroupByNode::ResetKernelStates() {
  auto ctx = plan()->query_context()->exec_context();