Method tryResolveType

bolt/expression/SignatureBinder.cpp:251–315

}

TypePtr SignatureBinder::tryResolveType(
    const exec::TypeSignature& typeSignature,
    const std::unordered_map<std::string, SignatureVariable>& variables,
    const std::unordered_map<std::string, TypePtr>& typeVariablesBindings,
    std::unordered_map<std::string, int>& integerVariablesBindings) {
  const auto baseName = typeSignature.baseName();

  if (variables.count(baseName)) {
    auto it = typeVariablesBindings.find(baseName);
    if (it == typeVariablesBindings.end()) {
      return nullptr;
    }
    return it->second;
  }

  // Type is not a variable.
  auto typeName = boost::algorithm::to_upper_copy(baseName);

  const auto& params = typeSignature.parameters();
  std::vector<std::string> params_name;

  std::vector<TypeParameter> typeParameters;
  for (auto& param : params) {
    if (param.rowFieldName().has_value()) {
      params_name.emplace_back(param.rowFieldName().value());
    } else {
      params_name.emplace_back("");
    }
    auto literal =
        tryResolveLongLiteral(param, variables, integerVariablesBindings);
    if (literal.has_value()) {
      typeParameters.push_back(TypeParameter(literal.value()));
      continue;
    }

    auto type = tryResolveType(
        param, variables, typeVariablesBindings, integerVariablesBindings);
    if (!type) {
      return nullptr;
    }
    typeParameters.push_back(TypeParameter(type));
  }

  try {
    if (auto type = getType(typeName, typeParameters, std::move(params_name))) {
      return type;
    }
  } catch (const std::exception&) {
    // TODO Perhaps, modify getType to add suppress-errors flag.
    return nullptr;
  }

  auto typeKind = tryMapNameToTypeKind(typeName);
  if (!typeKind.has_value()) {
    return nullptr;
  }

  // getType(parameters) function doesn't support OPAQUE type.