Function resolveAggregateType

bolt/exec/tests/utils/PlanBuilder.cpp:583–627

}

TypePtr resolveAggregateType(
    const std::string& aggregateName,
    core::AggregationNode::Step step,
    const std::vector<TypePtr>& rawInputTypes,
    bool nullOnFailure) {
  if (auto signatures = exec::getAggregateFunctionSignatures(aggregateName)) {
    for (const auto& signature : signatures.value()) {
      exec::SignatureBinder binder(*signature, rawInputTypes);
      if (binder.tryBind()) {
        return binder.tryResolveType(
            exec::isPartialOutput(step) ? signature->intermediateType()
                                        : signature->returnType());
      }
    }

    if (nullOnFailure) {
      return nullptr;
    }

    throwAggregateFunctionSignatureNotSupported(
        aggregateName, rawInputTypes, signatures.value());
  }

  // We may be parsing lambda expression used in a lambda aggregate function. In
  // this case, 'aggregateName' would refer to a scalar function.
  //
  // TODO Enhance the parser to allow for specifying separate resolver for
  // lambda expressions.
  if (auto type =
          exec::resolveTypeForSpecialForm(aggregateName, rawInputTypes)) {
    return type;
  }

  if (auto type = parse::resolveScalarFunctionType(
          aggregateName, rawInputTypes, true)) {
    return type;
  }

  if (nullOnFailure) {
    return nullptr;
  }

  throwAggregateFunctionDoesntExist(aggregateName);
  return nullptr;
}

class AggregateTypeResolver {
 public: