自定义的数据类型必须实现 Scanner 和 接口，以便让 GORM 知道如何将该类型接收、保存到数据库

    例如:

    有许多第三方包实现了 /Valuer 接口，可与 GORM 一起使用，例如：

    1. import (
    2.   "github.com/google/uuid"
    3.   "github.com/lib/pq"
    4. )
    6. type Post struct {
    7.   ID     uuid.UUID `gorm:"type:uuid;default:uuid_generate_v4()"`
    8.   Title  string
    9.   Tags   pq.StringArray `gorm:"type:text[]"`
    10. }
    1. type GormDataTypeInterface interface {
    2.   GormDataType() string
    3. }
    5. type GormDBDataTypeInterface interface {
    6.   GormDBDataType(*gorm.DB, *schema.Field) string
    7. }

    GormDataType 的结果用于生成通用数据类型，也可以通过 schema.Field 的 DataType 字段得到。这在 编写插件 或者 时可能会有用，例如：

    在迁移时，GormDBDataType 通常会为当前驱动返回恰当的数据类型，例如：

    1. func (JSON) GormDBDataType(db *gorm.DB, field *schema.Field) string {
    2.   // 使用 field.Tag、field.TagSettings 获取字段的 tag
    3.   // 查看 https://github.com/go-gorm/gorm/blob/master/schema/field.go 获取全部的选项
    5.   // 根据不同的数据库驱动返回不同的数据类型
    6.   switch db.Dialector.Name() {
    7.   case "mysql", "sqlite":
    8.     return "JSON"
    9.   case "postgres":
    10.     return "JSONB"
    11.   }
    12.   return ""
    13. }

    如果 struct 没有实现 GormDBDataTypeInterface 或 接口，GORM 会根据 struct 第一个字段推测其数据类型，例如：会为 NullString 使用 string

    1.   String string // 使用第一个字段的数据类型
    2.   Valid  bool
    3. }
    5. type User struct {
    6.   Name NullString // 数据类型会是 string
    7. }

    使用 SQL 表达式进行 Create/Update

    1. type Location struct {
    2.     X, Y int
    3. }
    5. func (loc Location) GormDataType() string {
    6.   return "geometry"
    7. }
    9. func (loc Location) GormValue(ctx context.Context, db *gorm.DB) clause.Expr {
    10.   return clause.Expr{
    11.     SQL:  "ST_PointFromText(?)",
    12.     Vars: []interface{}{fmt.Sprintf("POINT(%d %d)", loc.X, loc.Y)},
    13.   }
    14. }
    16. // Scan 方法实现了 sql.Scanner 接口
    17. func (loc *Location) Scan(v interface{}) error {
    18.   // Scan a value into struct from database driver
    19. }
    21. type User struct {
    22.   ID       int
    23.   Name     string
    24.   Location Location
    25. }
    27. db.Create(&User{
    28.   Name:     "jinzhu",
    30. })
    32. db.Model(&User{ID: 1}).Updates(User{
    33.   Name:  "jinzhu",
    34.   Location: Location{X: 100, Y: 100},
    35. })
    36. // UPDATE `user_with_points` SET `name`="jinzhu",`location`=ST_PointFromText("POINT(100 100)") WHERE `id` = 1

    你也可以根据 SQL 表达式进行 create/update，查看 和 Update with SQL Expression 获取详情

    基于 Context 的值

    如果你想创建或更新一个依赖于当前 context 的值，你也可以实现 GormValuerInterface 接口，例如：

    1. type EncryptedString struct {
    2.   Value string
    3. }
    5. func (es EncryptedString) GormValue(ctx context.Context, db *gorm.DB) (expr clause.Expr) {
    6.   if encryptionKey, ok := ctx.Value("TenantEncryptionKey").(string); ok {
    7.     return clause.Expr{SQL: "?", Vars: []interface{}{Encrypt(es.Value, encryptionKey)}}
    8.   } else {
    9.     db.AddError(errors.New("invalid encryption key"))
    10.   }
    12.   return
    13. }

    如果你想构建一些查询 helper，你可以让 struct 实现 clause.Expression 接口：

    1. // 根据 Clause Expression 生成 SQL
    2. db.Find(&user, datatypes.JSONQuery("attributes").HasKey("role"))
    3. db.Find(&user, datatypes.JSONQuery("attributes").HasKey("orgs", "orga"))
    5. // MySQL
    6. // SELECT * FROM `users` WHERE JSON_EXTRACT(`attributes`, '$.role') IS NOT NULL
    7. // SELECT * FROM `users` WHERE JSON_EXTRACT(`attributes`, '$.orgs.orga') IS NOT NULL
    9. // PostgreSQL
    10. // SELECT * FROM "user" WHERE "attributes"::jsonb ? 'role'
    11. // SELECT * FROM "user" WHERE "attributes"::jsonb -> 'orgs' ? 'orga'
    13. db.Find(&user, datatypes.JSONQuery("attributes").Equals("jinzhu", "name"))
    14. // MySQL
    15. // SELECT * FROM `user` WHERE JSON_EXTRACT(`attributes`, '$.name') = "jinzhu"
    18. // SELECT * FROM "user" WHERE json_extract_path_text("attributes"::json,'name') = 'jinzhu'

    自定义数据类型集合

    我们创建了一个 Github 仓库，用于收集各种自定义数据类型，非常欢迎同学们的 pull request ;)