absl::StatusOr DDLColumnTypeToGoogleSqlType()

in backend/schema/updater/ddl_type_conversion.cc [38:148]
106 lines of code
23 McCabe index (conditional complexity)

absl::StatusOr<const zetasql::Type*> DDLColumnTypeToGoogleSqlType(
    const ddl::TypeDefinition& ddl_type_def,
    zetasql::TypeFactory* type_factory
    ,
    const ProtoBundle* proto_bundle
) {
  ZETASQL_RET_CHECK(ddl_type_def.has_type())
      << "No type field specification in "
      << "ddl::TypeDefinition input: " << ddl_type_def.ShortDebugString();

  switch (ddl_type_def.type()) {
    case ddl::TypeDefinition::FLOAT:
      return type_factory->get_float();
    case ddl::TypeDefinition::DOUBLE:
      return type_factory->get_double();
    case ddl::TypeDefinition::INT64:
      return type_factory->get_int64();
    case ddl::TypeDefinition::BOOL:
      return type_factory->get_bool();
    case ddl::TypeDefinition::STRING:
      return type_factory->get_string();
    case ddl::TypeDefinition::BYTES:
      return type_factory->get_bytes();
    case ddl::TypeDefinition::TIMESTAMP:
      return type_factory->get_timestamp();
    case ddl::TypeDefinition::DATE:
      return type_factory->get_date();
    case ddl::TypeDefinition::NUMERIC:
      return type_factory->get_numeric();
    case ddl::TypeDefinition::INTERVAL:
      return type_factory->get_interval();
    case ddl::TypeDefinition::PG_NUMERIC:
      return postgres_translator::spangres::types::PgNumericMapping()
          ->mapped_type();
    case ddl::TypeDefinition::JSON:
      return type_factory->get_json();
    case ddl::TypeDefinition::PG_JSONB:
      return postgres_translator::spangres::types::PgJsonbMapping()
          ->mapped_type();
    case ddl::TypeDefinition::ARRAY: {
      ZETASQL_RET_CHECK(ddl_type_def.has_array_subtype())
          << "Missing array_subtype field for ddl::TypeDefinition input: "
          << ddl_type_def.ShortDebugString();
      if (ddl_type_def.array_subtype().type() == ddl::TypeDefinition::ARRAY) {
        // TODO : Update when we have a proper way to
        // construct user-facing error messages in the error catalog.
        return absl::Status(
            absl::StatusCode::kInvalidArgument,
            "Array of arrays type is not supported by the schema.");
      }
      ZETASQL_ASSIGN_OR_RETURN(
          auto array_element_type,
          DDLColumnTypeToGoogleSqlType(ddl_type_def.array_subtype(),
                                       type_factory
                                       ,
                                       proto_bundle
                                       ));
      ZETASQL_RET_CHECK_NE(array_element_type, nullptr);
      const zetasql::Type* array_type;
      ZETASQL_RETURN_IF_ERROR(
          type_factory->MakeArrayType(array_element_type, &array_type));
      return array_type;
    }
    case ddl::TypeDefinition::STRUCT: {
      std::vector<zetasql::StructType::StructField> struct_fields;
      for (const ddl::TypeDefinition::StructDescriptor::Field& field :
           ddl_type_def.struct_descriptor().field()) {
        ZETASQL_ASSIGN_OR_RETURN(
            const zetasql::Type* type,
            DDLColumnTypeToGoogleSqlType(field.type(),
                                         type_factory
                                         ,
                                         proto_bundle
                                         ));
        struct_fields.push_back({field.name(), type});
      }
      const zetasql::Type* struct_type;
      ZETASQL_RETURN_IF_ERROR(
          type_factory->MakeStructType(struct_fields, &struct_type));
      return struct_type;
    }
    case ddl::TypeDefinition::TOKENLIST: {
      return type_factory->get_tokenlist();
    }
    default:
      if (ddl_type_def.type() == ddl::TypeDefinition::NONE &&
          ddl_type_def.has_proto_type_name()) {
        ZETASQL_RET_CHECK_NE(proto_bundle, nullptr);
        auto proto_descriptor =
            proto_bundle->GetTypeDescriptor(ddl_type_def.proto_type_name());
        if (proto_descriptor.ok()) {
          // PROTO
          const zetasql::Type* proto_type;
          ZETASQL_RETURN_IF_ERROR(type_factory->MakeProtoType(proto_descriptor.value(),
                                                      &proto_type));
          return proto_type;
        }
        auto enum_descriptor =
            proto_bundle->GetEnumTypeDescriptor(ddl_type_def.proto_type_name());
        if (enum_descriptor.ok()) {
          // ENUM
          const zetasql::Type* enum_type;
          ZETASQL_RETURN_IF_ERROR(
              type_factory->MakeEnumType(enum_descriptor.value(), &enum_type));
          return enum_type;
        }
      }
      ZETASQL_RET_CHECK_FAIL() << "Unrecognized ddl::TypeDefinition: "
                       << ddl_type_def.ShortDebugString();
  }
}