type Product struct {
  gorm.Model
  Code  string
  Price uint
}

func main() {
  // ...

  // Create
  db.Create(&Product{Code: "D42", Price: 100})

  // Read
  var product Product
  db.First(&product, "code = ?", "D42") // find product with code D42

  // Update - update product's price to 200
  db.Model(&product).Update("Price", 200)

  // Delete - delete product
  db.Delete(&product, 1)
}

// DB下的callbacks指针，实际为操作类型到callbacks的映射。
type callbacks struct {
	processors map[string]*processor
}

// 在请求执行过程中，会根据 crud 的类型，从 callbacks 中获取对应类型的 processor.
func initializeCallbacks(db *DB) *callbacks {
	return &callbacks{
		processors: map[string]*processor{
			"create": {db: db},
			"query":  {db: db},
			"update": {db: db},
			"delete": {db: db},
			"row":    {db: db},
			"raw":    {db: db},
		},
	}
}

type processor struct {
	db *DB

	// 拼接 sql 时的关键字顺序. 比如 query 类，固定为 SELECT,FROM,WHERE,GROUP BY, ORDER BY, LIMIT, FOR
	// 在RegisterDefaultCallbacks 中指定
	Clauses []string

	// 对应于 crud 类型的执行函数链
	fns []func(*DB)

	callbacks []*callback
}

// 设置写操作相关回调callbacks 以及 配置
createCallback := db.Callback().Create()
// 开启事务
createCallback.Match(enableTransaction).Register("gorm:begin_transaction", BeginTransaction)
// 业务回调： BeforeSave、BeforeCreate 
createCallback.Register("gorm:before_create", BeforeCreate)
// 处理插入前的关系：仅 BelongTo 关系
createCallback.Register("gorm:save_before_associations", SaveBeforeAssociations(true))
// 插入SQL构建及执行
createCallback.Register("gorm:create", Create(config))
// 查理插入后关系：包括 HasOne、HasMany、Many2Many 关系
createCallback.Register("gorm:save_after_associations", SaveAfterAssociations(true))
// 业务回调：AfterCreate、AfterSave
createCallback.Register("gorm:after_create", AfterCreate)
// 结束事务
createCallback.Match(enableTransaction).Register("gorm:commit_or_rollback_transaction", CommitOrRollbackTransaction)
// 设置dialector所需 Clause 名称
createCallback.Clauses = config.CreateClauses

// Find API 中会使用 query 对应的callback列表来执行Execute
func (db *DB) Find(dest interface{}, conds ...interface{}) (tx *DB) {
	tx = db.getInstance()
	if len(conds) > 0 {
		if exprs := tx.Statement.BuildCondition(conds[0], conds[1:]...); len(exprs) > 0 {
			tx.Statement.AddClause(clause.Where{Exprs: exprs})
		}
	}
	tx.Statement.Dest = dest
	return tx.callbacks.Query().Execute(tx)
}
// Create API 则会调用 create 对应的callback列表来执行Execute
func (db *DB) Create(value interface{}) (tx *DB) {
	if db.CreateBatchSize > 0 {
		return db.CreateInBatches(value, db.CreateBatchSize)
	}

	tx = db.getInstance()
	tx.Statement.Dest = value
	return tx.callbacks.Create().Execute(tx)
}

// 各API最终的执行逻辑都落到了这里
// Execute负责 callback 链条的调度
func (p *processor) Execute(db *DB) *DB {
	// ...

	// 遍历执行 fns 链
	// 其中最核心的 create/query/update/delete 操作都被包含在其中了. 还包括了一系列前、后处理函数
	for _, f := range p.fns {
		f(db)
	}

	// ...
}

// 新增
func (c *callback) Register(name string, fn func(*DB)) error {
	c.name = name
	c.handler = fn
	c.processor.callbacks = append(c.processor.callbacks, c)
	return c.processor.compile()
}

// 删除
func (c *callback) Remove(name string) error {
	c.processor.db.Logger.Warn(context.Background(), "removing callback `%s` from %s\n", name, utils.FileWithLineNum())
	c.name = name
	c.remove = true
	c.processor.callbacks = append(c.processor.callbacks, c)
	return c.processor.compile()
}

// 替换
func (c *callback) Replace(name string, fn func(*DB)) error {
	c.processor.db.Logger.Info(context.Background(), "replacing callback `%s` from %s\n", name, utils.FileWithLineNum())
	c.name = name
	c.handler = fn
	c.replace = true
	c.processor.callbacks = append(c.processor.callbacks, c)
	return c.processor.compile()
}

func (p *processor) compile() (err error) {
	var callbacks []*callback
	removedMap := map[string]bool{}
	for _, callback := range p.callbacks {
		// match通过才添加到callbacks，否则不添加。match为nil则添加到callbacks
		// 比如事务回调，需要判断配置 SkipDefaultTransaction 是否开启
		if callback.match == nil || callback.match(p.db) {
			callbacks = append(callbacks, callback)
		}
		// 需要删除的回到调函数，需要记录下来，后面删除
		if callback.remove {
			removedMap[callback.name] = true
		}
	}

	// 删除需要删除的回调函数，避免重复添加
	if len(removedMap) > 0 {
		callbacks = removeCallbacks(callbacks, removedMap)
	}
	p.callbacks = callbacks

	// 排序回调函数
	if p.fns, err = sortCallbacks(p.callbacks); err != nil {
		p.db.Logger.Error(context.Background(), "Got error when compile callbacks, got %v", err)
	}
	return
}

type User struct {  
    gorm.Model // 内嵌gorm.Model，以便使用其提供的字段和方法  
    Name       string  
    Age        sql.NullInt64  
    Birthday   *time.Time  
    Email      string `gorm:"type:varchar(100);uniqueIndex"`  
    Role       string `gorm:"size:255"`  
    // 其他字段定义...  
}

type Model struct {
	ID        uint `gorm:"primarykey"` // 默认主键
	CreatedAt time.Time // 创建时间
	UpdatedAt time.Time // 更新时间
	DeletedAt DeletedAt `gorm:"index"` // 删除时间。用于soft delete
}

var user User
var users []User

// works because destination struct is passed in
db.First(&user)
// SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 1

// works because model is specified using `db.Model()`
result := map[string]interface{}{}
db.Model(&User{}).First(&result)
// SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 1

// 任意对象为空时使用另一个对象替换
if stmt.Model == nil {
	stmt.Model = stmt.Dest
} else if stmt.Dest == nil {
	stmt.Dest = stmt.Model
}

// 解析 model，获取对应表的 schema 信息
if stmt.Model != nil {
	if err := stmt.Parse(stmt.Model); err != nil && (!errors.Is(err, schema.ErrUnsupportedDataType) || (stmt.Table == "" && stmt.TableExpr == nil && stmt.SQL.Len() == 0)) {
		if errors.Is(err, schema.ErrUnsupportedDataType) && stmt.Table == "" && stmt.TableExpr == nil {
			db.AddError(fmt.Errorf("%w: Table not set, please set it like: db.Model(&user) or db.Table(\"users\")", err))
		} else {
			db.AddError(err)
		}
	}
}

type Field struct {
	// 字段名称
	Name string
	// column 标签指定 db 列名。如果未指定，则使用字段名称转换（见：namer.ColumnName）
	DBName string
	// 字段的绑定名称，默认为结构体中的字段名称，当为嵌套字段时，也会追加嵌套字段的名称。比如 ["Model", "ID"]
	BindNames []string
	// 与bindNames相同，不包括Anonymous struct
	EmbeddedBindNames []string
	// 字段数据类型，共6种：bool、int、uint、float、string、time、bytes。还有自定义 https://gorm.io/docs/data_types.html#GormDataTypeInterface
	// 嵌套字段类型为空
	DataType      DataType
	GORMDataType  DataType
	PrimaryKey    bool  // 是否为pk
	AutoIncrement bool  // 是否自增
	AutoIncrementIncrement int64 // 自动步长，控制连续记录之间的间隔
	// 权限控制，用于控制字段的读写权限
	Creatable bool
	Updatable bool
	Readable  bool

	AutoCreateTime  TimeType // 参考 tag： autoCreateTime
	AutoUpdateTime  TimeType
	
	// 有默认值('Default')标识 或者 AUTOINCREMENT，则HasDefaultValue为true
	HasDefaultValue bool
	// 原始默认值 string
	DefaultValue string
	// defalut value值，使用interface{}类型，方便存储bool、int等类型
	// 可以指定 Default tag标签，但是不指定默认值。比如 `gorm:"default:(-)"`. see https://gorm.io/docs/create.html#Default-Values
	DefaultValueInterface interface{}

  // TAG 定义的标识，参考文档tag值定义
	NotNull         bool
	Unique          bool
	Comment         string
	Size            int
	Precision       int
	Scale           int
	IgnoreMigration bool

	// 反射类型
	FieldType reflect.Type
	// 反射类型。如果字段类型为指针，则返回指向的类型，否则等同于FieldType
	IndirectFieldType reflect.Type
	// 原始结构体字段
	StructField reflect.StructField
	// 原标签信息
	Tag         reflect.StructTag
	TagSettings map[string]string

	// 指向所属的Schema：当为嵌套字段时，指向其所属的根Schema
	Schema *Schema

	// 当前fields中嵌套字段的schema。注意嵌套schema下的fields也会被加入到schema.Fields 中
	EmbeddedSchema *Schema

	// 当前字段所属的Schema
	OwnerSchema *Schema

	// 用来获取struct中的字段值（reflect.Value），用于通过反射设置新值。
	// 类似于 reflect.Value.FieldByIndex，内部包含了指针的初始化
	ReflectValueOf func(context.Context, reflect.Value) reflect.Value
	// 与 ReflectValueOf 相同，但返回的是 interface{} 类型以及是否为零值（fieldValue.IsZero()）
	ValueOf        func(context.Context, reflect.Value) (value interface{}, zero bool)
	// 写字段值函数。在 scanIntoStruct 中调用到
	Set            func(context.Context, reflect.Value, interface{}) error
	// SerializerInterface：如果字段实现了Serializer，则指向序列化接口。见 https://gorm.io/docs/serializer.html
	Serializer     SerializerInterface
	// 为 IndirectFieldType 分配的缓存池，避免重复gc。在读取场景 scanToStruct 时，会使用 NewValuePool 分配临时值，避免gc
	NewValuePool   FieldNewValuePool

	// In some db (e.g. MySQL), Unique and UniqueIndex are indistinguishable.
	// When a column has a (not Mul) UniqueIndex, Migrator always reports its gorm.ColumnType is Unique.
	// It causes field unnecessarily migration.
	// Therefore, we need to record the UniqueIndex on this column (exclude Mul UniqueIndex) for MigrateColumnUnique.
	UniqueIndex string
}

const (
	Bool   DataType = "bool"
	Int    DataType = "int"
	Uint   DataType = "uint"
	Float  DataType = "float"
	String DataType = "string"
	Time   DataType = "time"
	Bytes  DataType = "bytes"
)

func (schema *Schema) ParseField(fieldStruct reflect.StructField) *Field {
  // ...
	// 递归解析 embedded 字段到当前结构的 EmbeddedSchema 中
	if field.EmbeddedSchema, err = getOrParse(fieldValue.Interface(), cacheStore, embeddedNamer{Table: schema.Table, Namer: schema.namer}); err != nil {
		schema.err = err
	}
  // ...
}

// 解析字段列表：将modelType中所有字段解析为Field，并加入到schema.Fields中。
for i := 0; i < modelType.NumField(); i++ {
	if fieldStruct := modelType.Field(i); ast.IsExported(fieldStruct.Name) {
		// 如果是嵌套字段，将其下所有递归解析出的字段加入到schema中。
		if field := schema.ParseField(fieldStruct); field.EmbeddedSchema != nil {
			schema.Fields = append(schema.Fields, field.EmbeddedSchema.Fields...)
		} else {
			// 否则将该字段加入到schema.Fields中
			schema.Fields = append(schema.Fields, field)
		}
	}
}

type user struct {
	firstName string
	lastName  string
}

type data struct {
	user
	firstName string
	lastName  string
}

u := data{
	user:      user{"Embedded John", "Embedded Doe"},
	firstName: "John",
	lastName:  "Doe",
}

s := reflect.ValueOf(u).FieldByIndex([]int{0, 1})
fmt.Println("embedded last name:", s)

// 设置嵌套字段的索引值。
// 因为嵌套字段会被添加到上层结构中，所以其原索引值需要追加其所属嵌套struct字段的索引值。
// index is negative means is pointer
if field.FieldType.Kind() == reflect.Struct {
	ef.StructField.Index = append([]int{fieldStruct.Index[0]}, ef.StructField.Index...)
} else {
  // 如果对象为指针，则用负数index表示
	ef.StructField.Index = append([]int{-fieldStruct.Index[0] - 1}, ef.StructField.Index...)
}

// struct 嵌套或者embedded字段的反射值获取
field.ReflectValueOf = func(ctx context.Context, v reflect.Value) reflect.Value {
	v = reflect.Indirect(v)
	// 自顶向下获取嵌套字段的反射值
	for idx, fieldIdx := range field.StructField.Index {
		if fieldIdx >= 0 {
			v = v.Field(fieldIdx)
		} else {
			// 指针类型
			v = v.Field(-fieldIdx - 1)

			if v.IsNil() {
			  // 初始化指针对象
				v.Set(reflect.New(v.Type().Elem()))
			}

			if idx < len(field.StructField.Index)-1 {
				v = v.Elem()
			}
		}
	}
	return v
}

switch field.FieldType.Kind() {
  // bool类型字段的赋值函数
	case reflect.Bool:
		field.Set = func(ctx context.Context, value reflect.Value, v interface{}) error {
			switch data := v.(type) {
			case **bool:
				if data != nil && *data != nil {
					field.ReflectValueOf(ctx, value).SetBool(**data)
				}
			case bool:
				field.ReflectValueOf(ctx, value).SetBool(data)
			case int64:
				field.ReflectValueOf(ctx, value).SetBool(data > 0)
			case string:
				b, _ := strconv.ParseBool(data)
				field.ReflectValueOf(ctx, value).SetBool(b)
			default:
				return fallbackSetter(ctx, value, v, field.Set)
			}
			return nil
		}
  //...
}

type Schema struct {
	// modelType.Name()
	Name string
	// 反射type
	ModelType reflect.Type
	// 表明
	Table                   string
	PrioritizedPrimaryField *Field
	// fields中的所有字段名称
	DBNames []string
	// 包含了primary key列表
	PrimaryFields       []*Field
	PrimaryFieldDBNames []string

	Fields []*Field // ParseField 解析出的struct字段

	// Field.Name -> Field 的映射
	FieldsByName map[string]*Field
	// Field.BindName -> Field 的映射. 嵌套字段的 BindName 格式为 'Embed.Field', like `Model.ID`
	FieldsByBindName map[string]*Field // embedded fields is 'Embed.Field'
	// Field.DBName -> Field 的映射
	FieldsByDBName map[string]*Field

	// 字段默认值依赖DB的默认值生成，tag中仅设置默认值表示，不提供默认值实现。
	FieldsWithDefaultDBValue []*Field // fields with default value assigned by database
	Relationships            Relationships

	// 各字段的默认clause，会被加入到所有会话中。比如 DeleteAt 字段的软删除条件
	CreateClauses             []clause.Interface
	QueryClauses              []clause.Interface
	UpdateClauses             []clause.Interface
	DeleteClauses             []clause.Interface

	BeforeCreate, AfterCreate bool
	BeforeUpdate, AfterUpdate bool
	BeforeDelete, AfterDelete bool
	BeforeSave, AfterSave     bool
	AfterFind                 bool
	err                       error
	// 初始化标识，避免多goroutine并行解析导致的冲突
	initialized               chan struct{}
	// DB.NamingStrategy
	namer                     Namer
	// 对应cacheStore
	cacheStore *sync.Map
}

BeforeCreate, AfterCreate bool
BeforeUpdate, AfterUpdate bool
BeforeDelete, AfterDelete bool
BeforeSave, AfterSave     bool
AfterFind                 bool

type Model struct {
	ID        uint `gorm:"primarykey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt DeletedAt `gorm:"index"`
}
// 软删除的queryCluase、DeleteCluase等
func (DeletedAt) QueryClauses(f *schema.Field) []clause.Interface {
	return []clause.Interface{SoftDeleteQueryClause{Field: f, ZeroValue: parseZeroValueTag(f)}}
}
func (DeletedAt) DeleteClauses(f *schema.Field) []clause.Interface {
	return []clause.Interface{SoftDeleteDeleteClause{Field: f, ZeroValue: parseZeroValueTag(f)}}
}
func (DeletedAt) UpdateClauses(f *schema.Field) []clause.Interface {
	return []clause.Interface{SoftDeleteUpdateClause{Field: f, ZeroValue: parseZeroValueTag(f)}}
}

type Relationships struct {
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship
	Relations map[string]*Relationship

	EmbeddedRelations map[string]*Relationships
}

func (db *DB) Create(value interface{}) (tx *DB) {
	if db.CreateBatchSize > 0 {
		return db.CreateInBatches(value, db.CreateBatchSize)
	}

	tx = db.getInstance()
	tx.Statement.Dest = value
	return tx.callbacks.Create().Execute(tx)
}

func (db *DB) Find(dest interface{}, conds ...interface{}) (tx *DB) {
	tx = db.getInstance()
	if len(conds) > 0 {
		if exprs := tx.Statement.BuildCondition(conds[0], conds[1:]...); len(exprs) > 0 {
			tx.Statement.AddClause(clause.Where{Exprs: exprs})
		}
	}
	tx.Statement.Dest = dest
	return tx.callbacks.Query().Execute(tx)
}

// doesn't work
result := map[string]interface{}{}
db.Table("users").First(&result)

// works with Take
result := map[string]interface{}{}
db.Table("users").Take(&result)