PostgreSQL 复合类型与数组在 Go 中的正确映射教程-Golang-PHP中文网

PostgreSQL 复合类型与数组在 Go 中的正确映射教程

本文详解如何在 Go 应用中正确处理 PostgreSQL 的复合类型（Composite Type）和枚举数组（如 PhoneNumber[]），通过结构体定义、类型适配与查询优化，实现嵌套 JSON 的自然序列化。

本文详解如何在 go 应用中正确处理 postgresql 的复合类型（composite type）和枚举数组（如 `phonenumber[]`），通过结构体定义、类型适配与查询优化，实现嵌套 json 的自然序列化。

PostgreSQL 的复合类型（如 PhoneNumber）和数组（如 PhoneNumber[]）在 Go 中不会自动解包为结构体切片——默认情况下，gorp（及多数 PostgreSQL 驱动）会将复合数组字段作为 string（如 "{(123,MOBILE),(456,HOME)}"）或 []byte 返回，导致反序列化失败或字段丢失。要获得预期的嵌套 JSON（如 "PhoneNumber": [{"Number":"123","Type":"MOBILE"}]），需从数据建模和Go 类型设计两方面协同解决。

✅ 正确的 Go 结构体定义

首先修正 Go 端结构体，明确声明 PhoneNumber 字段为 []Phone 类型，并确保字段名与数据库列名匹配（注意：PostgreSQL 列名为 "Number"，但 Go 结构体应使用语义清晰的字段名 + JSON 标签）：

type PhoneType string

const (
    MOBILE PhoneType = "MOBILE"
    HOME   PhoneType = "HOME"
    WORK   PhoneType = "WORK"
)

type Phone struct {
    Number string  `json:"Number"`
    Type   PhoneType `json:"Type"`
}

type Person struct {
    Id          int     `db:"Id" json:"Id"`
    Name        string  `db:"Name" json:"Name"`
    Email       string  `db:"Email" json:"Email"`
    PhoneNumber []Phone `db:"Number" json:"PhoneNumber"` // ← 关键：db 标签映射到 PG 列 "Number"
}

⚠️ 注意：PhoneType 改为 string 枚举而非 iota int，因为 PostgreSQL 枚举在驱动中通常以字符串形式返回；若坚持用 int，需额外实现 sql.Scanner 和 driver.Valuer 接口。

✅ 查询时需手动解析复合数组（gorp 不原生支持）

gorp.Select 无法自动解析 PostgreSQL 复合数组。你必须：

将 Number 列作为 string 或 []byte 查询；
使用 pq.Array（配合 github.com/lib/pq）或手动解析其文本格式。

推荐方案：改用 database/sql + lib/pq，并自定义扫描逻辑（更可控、更主流）：

import (
    "database/sql"
    "github.com/lib/pq"
)

// 自定义 Scan 实现：将 PG 复合数组字符串解析为 []Phone
func (p *Person) ScanRow(rows *sql.Rows) error {
    var numberStr sql.NullString
    err := rows.Scan(&p.Id, &p.Name, &p.Email, &numberStr)
    if err != nil || !numberStr.Valid {
        return err
    }

    // 解析 composite array: "{(123,MOBILE),(456,HOME)}"
    p.PhoneNumber = make([]Phone, 0)
    var rawArray []interface{}
    if err := pq.Array(&rawArray).Scan([]byte(numberStr.String)); err != nil {
        return err
    }

    for _, item := range rawArray {
        if tuple, ok := item.(pq.Composite); ok {
            phone := Phone{}
            if len(tuple.Fields) >= 2 {
                if num, ok := tuple.Fields[0].(string); ok {
                    phone.Number = num
                }
                if typ, ok := tuple.Fields[1].(string); ok {
                    phone.Type = PhoneType(typ)
                }
            }
            p.PhoneNumber = append(p.PhoneNumber, phone)
        }
    }
    return nil
}

然后按行查询：

rows, err := db.Query("SELECT \"Id\", \"Name\", \"Email\", \"Number\" FROM Person")
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

var people []Person
for rows.Next() {
    p := Person{}
    if err := p.ScanRow(rows); err != nil {
        log.Printf("scan failed: %v", err)
        continue
    }
    people = append(people, p)
}

✅ 更优实践：避免复合类型，改用规范化表设计（推荐）

虽然技术上可行，但 PostgreSQL 复合类型+数组在 ORM/驱动兼容性、索引、查询灵活性（如按 Type = 'MOBILE' 过滤）等方面存在局限。生产环境强烈建议重构为一对多关系表：

-- 删除复合类型
DROP TABLE IF EXISTS Person;
DROP TYPE IF EXISTS PhoneNumber;
DROP TYPE IF EXISTS PhoneType;

-- 新建规范表
CREATE TABLE Person (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  email TEXT
);

CREATE TABLE Phone (
  id SERIAL PRIMARY KEY,
  person_id INTEGER NOT NULL REFERENCES Person(id) ON DELETE CASCADE,
  number TEXT NOT NULL,
  type TEXT CHECK (type IN ('MOBILE', 'HOME', 'WORK'))
);

对应 Go 结构体（配合 sqlc 或 squirrel 等工具轻松 JOIN 查询）：

type PersonWithPhones struct {
    Person
    Phones []Phone `json:"PhoneNumber"`
}

// 查询示例（使用 JOIN）
rows, _ := db.Query(`
  SELECT p.id, p.name, p.email, ph.number, ph.type
  FROM Person p
  LEFT JOIN Phone ph ON p.id = ph.person_id
  ORDER BY p.id, ph.id
`)

此设计天然支持 JSON 嵌套、高效查询、外键约束与事务一致性，是 Go + PostgreSQL 生产级应用的标准范式。

✅ 总结：