absl::Status TypeFromProto()

in frontend/converters/types.cc [50:179]

• 117 lines of code
• 21 McCabe index (conditional complexity)

absl::Status TypeFromProto(
    const google::spanner::v1::Type& type_pb, zetasql::TypeFactory* factory,
    const zetasql::Type** type
    ,
    std::shared_ptr<const backend::ProtoBundle> proto_bundle
) {
  switch (type_pb.code()) {
    case google::spanner::v1::TypeCode::BOOL: {
      *type = factory->get_bool();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::INT64: {
      if (type_pb.type_annotation() == v1::TypeAnnotationCode::PG_OID) {
        *type = GetPgOidType();
      } else {
        *type = factory->get_int64();
      }
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::TIMESTAMP: {
      *type = factory->get_timestamp();
      return absl::OkStatus();
    }
    case google::spanner::v1::TypeCode::FLOAT32: {
      *type = factory->get_float();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::FLOAT64: {
      *type = factory->get_double();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::DATE: {
      *type = factory->get_date();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::STRING: {
      *type = factory->get_string();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::BYTES: {
      *type = factory->get_bytes();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::NUMERIC: {
      if (type_pb.type_annotation() == v1::TypeAnnotationCode::PG_NUMERIC) {
        *type = GetPgNumericType();
      } else {
        *type = factory->get_numeric();
      }
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::JSON: {
      if (type_pb.type_annotation() == v1::TypeAnnotationCode::PG_JSONB) {
        *type = GetPgJsonbType();
      } else {
        *type = factory->get_json();
      }
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::INTERVAL: {
      *type = factory->get_interval();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::ARRAY: {
      const zetasql::Type* element_type;
      if (!type_pb.has_array_element_type()) {
        return error::ArrayTypeMustSpecifyElementType(type_pb.DebugString());
      }
      ZETASQL_RETURN_IF_ERROR(TypeFromProto(type_pb.array_element_type(), factory,
                                    &element_type
                                    ,
                                    proto_bundle
                                    ))
          << "\nWhen parsing array element type of " << type_pb.DebugString();
      ZETASQL_RETURN_IF_ERROR(factory->MakeArrayType(element_type, type))
          << "\nWhen parsing " << type_pb.DebugString();
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::STRUCT: {
      std::vector<zetasql::StructField> fields;
      for (int i = 0; i < type_pb.struct_type().fields_size(); ++i) {
        const zetasql::Type* type;
        ZETASQL_RETURN_IF_ERROR(TypeFromProto(type_pb.struct_type().fields(i).type(),
                                      factory,
                                      &type
                                      ,
                                      proto_bundle
                                      ))
            << "\nWhen parsing field #" << i << " of " << type_pb.DebugString();
        zetasql::StructField field(type_pb.struct_type().fields(i).name(),
                                     type);
        fields.push_back(field);
      }
      ZETASQL_RETURN_IF_ERROR(factory->MakeStructTypeFromVector(fields, type))
          << "\nWhen parsing " << type_pb.DebugString();
      return absl::OkStatus();
    }
    case google::spanner::v1::TypeCode::PROTO: {
      ZETASQL_RET_CHECK_NE(proto_bundle, nullptr);
      std::string proto_type_fqn = type_pb.proto_type_fqn();
      ZETASQL_ASSIGN_OR_RETURN(auto descriptor,
                       proto_bundle->GetTypeDescriptor(proto_type_fqn));
      ZETASQL_RETURN_IF_ERROR(factory->MakeProtoType(descriptor, type));
      return absl::OkStatus();
    }

    case google::spanner::v1::TypeCode::ENUM: {
      ZETASQL_RET_CHECK_NE(proto_bundle, nullptr);
      std::string proto_type_fqn = type_pb.proto_type_fqn();
      ZETASQL_ASSIGN_OR_RETURN(auto descriptor,
                       proto_bundle->GetEnumTypeDescriptor(proto_type_fqn));
      ZETASQL_RETURN_IF_ERROR(factory->MakeEnumType(descriptor, type));
      return absl::OkStatus();
    }

    default:
      return error::UnspecifiedType(type_pb.DebugString());
  }
}