如何在GORM中模拟ConnectionInfo的联合类型？

问题背景 #

需要定义一个仅允许为PostgresConnectionInfo或MySQLConnectionInfo的ConnectionInfo类型，并将其嵌入DataSource结构体中，但直接使用接口作为GORM结构体字段会触发unsupported data type: /models.ConnectionInfo错误。

核心原因 #

GORM无法直接处理接口类型的字段：它无法推断接口对应的具体实例类型，也无法完成数据库列与接口类型的映射。必须使用具体的封装类型来实现序列化/反序列化，同时限制可传入的类型范围。

实现方案 #

1. 定义具体连接信息类型及约束 #

先实现两种具体的连接信息结构体，同时定义一个泛型约束用于编译时类型检查：

type DataSourceType string

const (
    Postgres DataSourceType = "POSTGRES"
    MySQL    DataSourceType = "MYSQL"
)

type PostgresConnectionInfo struct {
    Host     string
    Port     int
    Username string
    Password string
    DBName   string
}

type MySQLConnectionInfo struct {
    Host     string
    Port     int
    Username string
    Password string
    DBName   string
    Charset  string
}

// 泛型约束：仅允许两种连接信息类型
type connectionInfoConstraint interface {
    ~PostgresConnectionInfo | ~MySQLConnectionInfo
}

2. 实现封装类型ConnectionInfo #

创建一个具体的封装结构体，代替原接口，同时实现driver.Valuer和sql.Scanner接口，处理序列化/反序列化逻辑：

import (
    "database/sql/driver"
    "encoding/json"
    "fmt"
)

type ConnectionInfo struct {
    data interface{}
}

// 构造函数：仅允许传入符合约束的类型，编译时检查
func NewConnectionInfo[T connectionInfoConstraint](info T) ConnectionInfo {
    return ConnectionInfo{data: info}
}

// 获取实际连接信息实例
func (c ConnectionInfo) Get() interface{} {
    return c.data
}

// 实现Valuer接口：序列化时包含类型标记
func (c ConnectionInfo) Value() (driver.Value, error) {
    var serialized struct {
        Type DataSourceType `json:"type"`
        Data interface{}    `json:"data"`
    }

    switch v := c.data.(type) {
    case PostgresConnectionInfo:
        serialized.Type = Postgres
        serialized.Data = v
    case MySQLConnectionInfo:
        serialized.Type = MySQL
        serialized.Data = v
    default:
        return nil, fmt.Errorf("不支持的连接信息类型: %T", v)
    }

    return json.Marshal(serialized)
}

// 实现Scanner接口：反序列化时根据类型标记解析对应结构体
func (c *ConnectionInfo) Scan(value interface{}) error {
    bytes, ok := value.([]byte)
    if !ok {
        return fmt.Errorf("ConnectionInfo值类型无效: %T", value)
    }

    var raw struct {
        Type DataSourceType `json:"type"`
        Data json.RawMessage `json:"data"`
    }
    if err := json.Unmarshal(bytes, &raw); err != nil {
        return err
    }

    var data interface{}
    switch raw.Type {
    case Postgres:
        var pgInfo PostgresConnectionInfo
        if err := json.Unmarshal(raw.Data, &pgInfo); err != nil {
            return err
        }
        data = pgInfo
    case MySQL:
        var mysqlInfo MySQLConnectionInfo
        if err := json.Unmarshal(raw.Data, &mysqlInfo); err != nil {
            return err
        }
        data = mysqlInfo
    default:
        return fmt.Errorf("不支持的连接信息类型: %s", raw.Type)
    }

    *c = ConnectionInfo{data: data}
    return nil
}

3. 修改DataSource结构体 #

使用封装后的ConnectionInfo类型作为字段，并指定数据库列类型为JSON：

import "gorm.io/gorm"

type DataSource struct {
    gorm.Model

    Name           string             `gorm:"column:name"`
    Type           DataSourceType     `gorm:"column:data_source_type;type:ENUM('POSTGRES','MYSQL')"`
    ConnectionInfo ConnectionInfo     `gorm:"column:connection_info;type:JSON"`
}

4. 使用示例 #

// 创建Postgres数据源
pgInfo := PostgresConnectionInfo{
    Host:     "localhost",
    Port:     5432,
    Username: "postgres",
    Password: "123456",
    DBName:   "test_db",
}

ds := DataSource{
    Name:           "Postgres测试库",
    Type:           Postgres,
    ConnectionInfo: NewConnectionInfo(pgInfo),
}

// 保存到数据库
db.Create(&ds)

// 查询并处理连接信息
var result DataSource
db.First(&result, ds.ID)

switch info := result.ConnectionInfo.Get().(type) {
case PostgresConnectionInfo:
    fmt.Printf("Postgres主机: %s\n", info.Host)
case MySQLConnectionInfo:
    fmt.Printf("MySQL字符集: %s\n", info.Charset)
}

关键说明 #

• 泛型构造函数NewConnectionInfo确保只有指定的两种类型能被赋值到ConnectionInfo，编译时就会拦截非法类型。
• 序列化时将类型标记与数据一起存入JSON字段，反序列化时根据类型标记解析到对应结构体，保证数据正确性。
• 封装后的ConnectionInfo是具体类型，GORM可以正常识别并映射到数据库的JSON列。

内容的提问来源于stack exchange，提问作者Charlie Clarke