1
2
3
4
5
6
7
8
9
10
11
12

type User struct {
  gorm.Model
  Name         string
  Age          sql.NullInt64
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`
  Role         string  `gorm:"size:255"` // 设置字段大小为255
  MemberNumber *string `gorm:"unique;not null"` // 设置会员号（member number）唯一并且不为空
  Num          int     `gorm:"AUTO_INCREMENT"` // 设置 num 为自增类型
  Address      string  `gorm:"index:addr"` // 给address字段创建名为addr的索引
  IgnoreMe     int     `gorm:"-"` // 忽略本字段
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// sql.Scanner
type Scanner interface {
    // Scan assigns a value from a database driver.
    //
    // The src value will be of one of the following types:
    //
    //    int64
    //    float64
    //    bool
    //    []byte
    //    string
    //    time.Time
    //    nil - for NULL values
    //
    // An error should be returned if the value cannot be stored
    // without loss of information.
    //
    // Reference types such as []byte are only valid until the next call to Scan
    // and should not be retained. Their underlying memory is owned by the driver.
    // If retention is necessary, copy their values before the next call to Scan.
    Scan(src interface{}) error
}
// driver.Valuer
type Valuer interface {
    // Value returns a driver Value.
    // Value must not panic.
    Value() (Value, error)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Args 参数
type Args map[string]string
// Scan Scanner
func (args Args) Scan(value interface{}) error {
	if value == nil {
		return nil
	}
	b, ok := value.([]byte)
	if !ok {
		return fmt.Errorf("value is not []byte, value: %v", value)
	}
	return json.Unmarshal(b, &args)
}
// Value Valuer
func (args Args) Value() (driver.Value, error) {
	if args == nil {
		return nil, nil
	}
	return json.Marshal(args)
}

1
2
3

type Data struct {
  Args Args `json:"args" gorm:"type:text"`
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// scan for scanner helper
func scan(data interface{}, value interface{}) error {
	if value == nil {
		return nil
	}
	switch value.(type) {
	case []byte:
		return json.Unmarshal(value.([]byte), data)
	case string:
		return json.Unmarshal([]byte(value.(string)), data)
	default:
		return fmt.Errorf("val type is valid, is %+v", value)
	}
}
// for valuer helper
func value(data interface{}) (interface{}, error) {
	vi := reflect.ValueOf(data)
	// 判断是否为 0 值
	if vi.IsZero() {
		return nil, nil
	}
	return json.Marshal(data)
}

1
2
3
4
5
6
7
8
9
10
11
12

// Args 参数
type Args map[string]string
// Scan Scanner
func (args Args) Scan(value interface{}) error {
	return scan(&args, value)
}
// Value Valuer
func (args Args) Value() (driver.Value, error) {
	return value(args)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Data Data
type Data struct {
	Args    map[string]interface{} `json:"args" gorm:"-"`
	ArgsStr string                 `json:"-" gorm:"column:args"`
}
// BeforeSave 数据保存前
func (data *Data) BeforeSave() error {
	if data.Args == nil {
		return nil
	}
	b, err := json.Marshal(&data.Args)
	if err != nil {
		return err
	}
	data.ArgsStr = string(b)
	return nil
}
// AfterFind 查询之后
func (data *Data) AfterFind() error {
	if data.ArgsStr == "" {
		return nil
	}
	return json.Unmarshal([]byte(data.ArgsStr), &data.Args)
}