type Relationships struct {
  // 各种关系分类存储
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship
	
	// 所有关系。key为关系名（结构体名）
	Relations map[string]*Relationship

	EmbeddedRelations map[string]*Relationships
}

type Relationship struct {
	Name        string // 字段名. field.Name
	Type        RelationshipType
	Field       *Field // 指向所属的field
	Polymorphic *Polymorphic
	// 关联字段数组，每项记录了 primary 表的 PrimaryKey 字段 和 关联的 ForeignKey 字段
	References  []*Reference
	Schema      *Schema // 指向所属的schema
	FieldSchema *Schema // 嵌套关系field解析出的schema。即关系表的schema
	JoinTable   *Schema

	// Composite-Foreign-Keys时为数组
	foreignKeys []string // 关联的外键字段名. Override Foreign Key
	primaryKeys []string // 被引用的字段名（即对应parent表中的字段名）。 Override References。
}

type Reference struct {
	PrimaryKey    *Field  // primary Schema中的主键
	PrimaryValue  string
	ForeignKey    *Field   // foreign Schema中的外键
	OwnPrimaryKey bool
}

const (
	HasOne    RelationshipType = "has_one"      // HasOneRel has one relationship
	HasMany   RelationshipType = "has_many"     // HasManyRel has many relationship
	BelongsTo RelationshipType = "belongs_to"   // BelongsToRel belongs to relationship
	Many2Many RelationshipType = "many_to_many" // Many2ManyRel many to many relationship
	has       RelationshipType = "has"          // 占位符，表明还不确定关系类型
)

// embeddedCacheKey 表示 schema 对应的struct为 embeded、anonymous 结构体，此时不需要解析关系型字段
	if _, embedded := schema.cacheStore.Load(embeddedCacheKey); !embedded {
		for _, field := range schema.Fields {
			if field.DataType == "" && field.GORMDataType == "" && (field.Creatable || field.Updatable || field.Readable) {
				// 解析关系字段
				if schema.parseRelation(field); schema.err != nil {
					return schema, schema.err
				} else {
					// 关系类字段也需要加入 FieldsByName 和 FieldsByBindName 中,用于后续的 LookUpFieldByBindName 等查找
					schema.FieldsByName[field.Name] = field
					schema.FieldsByBindName[field.BindName()] = field
				}
			}
			//...
	}
}

func (schema *Schema) parseRelation(field *Field) *Relationship {
	var (
		err        error
		fieldValue = reflect.New(field.IndirectFieldType).Interface()
		relation   = &Relationship{
			Name:        field.Name,
			Field:       field,  // 指向所属的field
			Schema:      schema, // 指向所属的schema
			foreignKeys: toColumns(field.TagSettings["FOREIGNKEY"]),
			primaryKeys: toColumns(field.TagSettings["REFERENCES"]),
		}
	)

	cacheStore := schema.cacheStore

	// 解析关系struct对应的Schema定义
	if relation.FieldSchema, err = getOrParse(fieldValue, cacheStore, schema.namer); err != nil {
		schema.err = err
		return nil
	}

	// 多态关系
	if hasPolymorphicRelation(field.TagSettings) {
		schema.buildPolymorphicRelation(relation, field)
	} else if many2many := field.TagSettings["MANY2MANY"]; many2many != "" {
		// 明确指定为 M2M 关系
		schema.buildMany2ManyRelation(relation, field, many2many)
	} else if belongsTo := field.TagSettings["BELONGSTO"]; belongsTo != "" {
		// 明确指定为 BelongsTo 关系
		schema.guessRelation(relation, field, guessBelongs)
	} else {
		switch field.IndirectFieldType.Kind() {
		case reflect.Struct:
			// 结构体，不确定关系类型，猜测关系类型
			schema.guessRelation(relation, field, guessGuess)
		case reflect.Slice:
			// 切片，可能为 HasMany(O2M)、M2M 关系
			schema.guessRelation(relation, field, guessHas)
		default:
			schema.err = fmt.Errorf("unsupported data type %v for %v on field %s", relation.FieldSchema, schema,
				field.Name)
		}
	}

	// 如果关系类型为has（一个占位符），则根据字段类型（结构体为HasOne，切片为HasMany）更新关系类型。
	if relation.Type == has {
		// don't add relations to embedded schema, which might be shared
		// 如果关系不是嵌入的Schema（即不是同一个Schema），且没有多态性且字段的拥有者Schema为空，将该关系添加到目标Schema的关系中（使用特殊键名避免冲突）。???
		if relation.FieldSchema != relation.Schema && relation.Polymorphic == nil && field.OwnerSchema == nil {
			relation.FieldSchema.Relationships.Relations["_"+relation.Schema.Name+"_"+relation.Name] = relation
		}

		switch field.IndirectFieldType.Kind() {
		case reflect.Struct:
			// 如果是struct，则关系类型为HasOne
			relation.Type = HasOne
		case reflect.Slice:
			// 如果是切片，则关系类型为HasMany
			relation.Type = HasMany
		}
	}

	if schema.err == nil {
		// 设置关系并添加到Schema的关系列表中
		schema.setRelation(relation)

		switch relation.Type {
		case HasOne:
			schema.Relationships.HasOne = append(schema.Relationships.HasOne, relation)
		case HasMany:
			schema.Relationships.HasMany = append(schema.Relationships.HasMany, relation)
		case BelongsTo:
			schema.Relationships.BelongsTo = append(schema.Relationships.BelongsTo, relation)
		case Many2Many:
			schema.Relationships.Many2Many = append(schema.Relationships.Many2Many, relation)
		}
	}

	return relation
}

// foreign schema
type User struct {
	gorm.Model
	Name           string `gorm:"size:128;index:user_name"`
	Age            int
	CompanyID      uint // 默认情况下， CompanyID 被隐含地用来在 User 和 Company 之间创建一个外键关系， 因此必须包含在 User 结构体中才能填充 Company 内部结构体。
	Company        Company
}
// primary schema
type Company struct {
	ID   int
	Name string
}
c := Company{
	ID:   1,
	Name: "Taobao Inc",
}
user := User{
	Name:    "alex",
	Age:     age % 60,
	Company: c,
}
db.Create(&user)

// INSERT INTO `t_Company` (`Name`,`ID`) VALUES (?,?) ON DUPLICATE KEY UPDATE `ID`=`ID`
// INSERT INTO `t_User` (`CreatedAt`,`UpdatedAt`,`DeletedAt`,`Name`,`Age`,`CompanyID`) VALUES (?,?,?,?,?,?)

func HasOneCreate(db *gorm.DB) {
	age := rand.Int()
	c := CreditCard{
		Model: gorm.Model{
			ID: 1,
		},
		Number: "12345678",
	}
	user := User{
		Name:       "alex",
		Age:        age % 60,
		CreditCard: c,
	}
	db.Create(&user)

	// another user with the same one relation
	user = User{
		Name:       "bob",
		Age:        age % 60,
		CreditCard: c,
	}
	db.Create(&user)
}
// INSERT INTO `t_CreditCard` (`CreatedAt`,`UpdatedAt`,`DeletedAt`,`Number`,`UserID`,`ID`) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE `UserID`=VALUES(`UserID`)
// INSERT INTO `t_User` (`CreatedAt`,`UpdatedAt`,`DeletedAt`,`Name`,`Age`) VALUES (?,?,?,?,?)
// INSERT INTO `t_CreditCard` (`CreatedAt`,`UpdatedAt`,`DeletedAt`,`Number`,`UserID`,`ID`) VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE `UserID`=VALUES(`UserID`)
// INSERT INTO `t_User` (`CreatedAt`,`UpdatedAt`,`DeletedAt`,`Name`,`Age`) VALUES (?,?,?,?,?)

// Statement statement
type Statement struct {
	// Join 语句
	Joins    []join
	Preloads map[string][]interface{}
	// ...
}

// Preload preload associations with given conditions
//
//	// get all users, and preload all non-cancelled orders
//	db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
func (db *DB) Preload(query string, args ...interface{}) (tx *DB) {
	tx = db.getInstance()
	if tx.Statement.Preloads == nil {
		tx.Statement.Preloads = map[string][]interface{}{}
	}
	tx.Statement.Preloads[query] = args
	return
}

queryCallback := db.Callback().Query()
queryCallback.Register("gorm:query", Query)
queryCallback.Register("gorm:preload", Preload)
queryCallback.Register("gorm:after_query", AfterQuery)
queryCallback.Clauses = config.QueryClauses