gorm/schema/relationship.go

295 lines
9.1 KiB
Go
Raw Normal View History

2020-01-31 07:22:37 +03:00
package schema
2020-01-29 14:22:44 +03:00
import (
"fmt"
"reflect"
"strings"
"github.com/jinzhu/inflection"
)
2020-01-29 14:22:44 +03:00
// RelationshipType relationship type
type RelationshipType string
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
2020-01-29 14:22:44 +03:00
)
type Relationships struct {
HasOne []*Relationship
BelongsTo []*Relationship
HasMany []*Relationship
Many2Many []*Relationship
Relations map[string]*Relationship
2020-01-29 14:22:44 +03:00
}
type Relationship struct {
2020-02-01 10:23:45 +03:00
Name string
Type RelationshipType
Field *Field
Polymorphic *Polymorphic
References []Reference
Schema *Schema
FieldSchema *Schema
JoinTable *Schema
2020-02-01 16:48:06 +03:00
foreignKeys, primaryKeys []string
}
type Polymorphic struct {
PolymorphicID *Field
PolymorphicType *Field
Value string
2020-01-29 14:22:44 +03:00
}
type Reference struct {
PrimaryKey *Field
PrimaryValue string
ForeignKey *Field
OwnPrimaryKey bool
2020-01-29 14:22:44 +03:00
}
func (schema *Schema) parseRelation(field *Field) {
var (
2020-02-01 16:48:06 +03:00
err error
fieldValue = reflect.New(field.FieldType).Interface()
relation = &Relationship{
2020-02-01 10:23:45 +03:00
Name: field.Name,
Field: field,
Schema: schema,
2020-02-01 16:48:06 +03:00
foreignKeys: toColumns(field.TagSettings["FOREIGNKEY"]),
primaryKeys: toColumns(field.TagSettings["REFERENCES"]),
}
)
2020-02-01 16:48:06 +03:00
if relation.FieldSchema, err = Parse(fieldValue, schema.cacheStore, schema.namer); err != nil {
schema.err = err
return
}
if polymorphic, _ := field.TagSettings["POLYMORPHIC"]; polymorphic != "" {
2020-02-01 13:02:19 +03:00
schema.buildPolymorphicRelation(relation, field, polymorphic)
} else if many2many, _ := field.TagSettings["MANY2MANY"]; many2many != "" {
schema.buildMany2ManyRelation(relation, field, many2many)
2020-02-01 10:23:45 +03:00
} else {
switch field.FieldType.Kind() {
2020-02-01 13:02:19 +03:00
case reflect.Struct, reflect.Slice:
2020-02-01 10:23:45 +03:00
schema.guessRelation(relation, field, true)
default:
schema.err = fmt.Errorf("unsupported data type %v for %v on field %v", relation.FieldSchema, schema, field.Name)
}
}
if relation.Type == "has" {
switch field.FieldType.Kind() {
case reflect.Struct:
relation.Type = HasOne
case reflect.Slice:
relation.Type = HasMany
}
2020-02-01 10:23:45 +03:00
}
2020-02-01 16:48:06 +03:00
if schema.err == nil {
schema.Relationships.Relations[relation.Name] = 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)
}
}
2020-02-01 10:23:45 +03:00
}
2020-02-01 13:02:19 +03:00
// User has many Toys, its `Polymorphic` is `Owner`, Pet has one Toy, its `Polymorphic` is `Owner`
// type User struct {
// Toys []Toy `gorm:"polymorphic:Owner;"`
// }
// type Pet struct {
// Toy Toy `gorm:"polymorphic:Owner;"`
// }
// type Toy struct {
// OwnerID int
// OwnerType string
// }
func (schema *Schema) buildPolymorphicRelation(relation *Relationship, field *Field, polymorphic string) {
relation.Polymorphic = &Polymorphic{
Value: schema.Table,
PolymorphicType: relation.FieldSchema.FieldsByName[polymorphic+"Type"],
PolymorphicID: relation.FieldSchema.FieldsByName[polymorphic+"ID"],
}
if value, ok := field.TagSettings["POLYMORPHIC_VALUE"]; ok {
relation.Polymorphic.Value = strings.TrimSpace(value)
}
if relation.Polymorphic.PolymorphicType == nil {
schema.err = fmt.Errorf("invalid polymorphic type %v for %v on field %v, missing field %v", relation.FieldSchema, schema, field.Name, polymorphic+"Type")
}
if relation.Polymorphic.PolymorphicID == nil {
schema.err = fmt.Errorf("invalid polymorphic type %v for %v on field %v, missing field %v", relation.FieldSchema, schema, field.Name, polymorphic+"ID")
}
if schema.err == nil {
relation.References = append(relation.References, Reference{
PrimaryValue: relation.Polymorphic.Value,
2020-02-01 13:02:19 +03:00
ForeignKey: relation.Polymorphic.PolymorphicType,
})
primaryKeyField := schema.PrioritizedPrimaryField
2020-02-01 16:48:06 +03:00
if len(relation.foreignKeys) > 0 {
if primaryKeyField = schema.LookUpField(relation.foreignKeys[0]); primaryKeyField == nil || len(relation.foreignKeys) > 1 {
schema.err = fmt.Errorf("invalid polymorphic foreign keys %+v for %v on field %v", relation.foreignKeys, schema, field.Name)
2020-02-01 13:02:19 +03:00
}
}
relation.References = append(relation.References, Reference{
PrimaryKey: primaryKeyField,
ForeignKey: relation.Polymorphic.PolymorphicID,
OwnPrimaryKey: true,
2020-02-01 13:02:19 +03:00
})
}
relation.Type = "has"
}
func (schema *Schema) buildMany2ManyRelation(relation *Relationship, field *Field, many2many string) {
relation.Type = Many2Many
var (
2020-02-01 16:48:06 +03:00
err error
2020-02-01 13:02:19 +03:00
joinTableFields []reflect.StructField
fieldsMap = map[string]*Field{}
ownFieldsMap = map[string]bool{} // fix self join many2many
2020-02-01 13:02:19 +03:00
)
for _, s := range []*Schema{schema, relation.FieldSchema} {
2020-02-01 13:02:19 +03:00
for _, primaryField := range s.PrimaryFields {
fieldName := s.Name + primaryField.Name
if _, ok := fieldsMap[fieldName]; ok {
if field.Name != s.Name {
fieldName = inflection.Singular(field.Name) + primaryField.Name
2020-02-01 13:02:19 +03:00
} else {
fieldName = s.Name + primaryField.Name + "Reference"
}
} else {
ownFieldsMap[fieldName] = true
2020-02-01 13:02:19 +03:00
}
fieldsMap[fieldName] = primaryField
joinTableFields = append(joinTableFields, reflect.StructField{
Name: fieldName,
PkgPath: primaryField.StructField.PkgPath,
Type: primaryField.StructField.Type,
Tag: removeSettingFromTag(primaryField.StructField.Tag, "column"),
})
}
}
2020-02-01 16:48:06 +03:00
if relation.JoinTable, err = Parse(reflect.New(reflect.StructOf(joinTableFields)).Interface(), schema.cacheStore, schema.namer); err != nil {
schema.err = err
}
2020-02-01 13:02:19 +03:00
relation.JoinTable.Name = many2many
relation.JoinTable.Table = schema.namer.JoinTableName(many2many)
// build references
for _, f := range relation.JoinTable.Fields {
relation.References = append(relation.References, Reference{
PrimaryKey: fieldsMap[f.Name],
2020-02-01 13:02:19 +03:00
ForeignKey: f,
OwnPrimaryKey: schema == fieldsMap[f.Name].Schema && ownFieldsMap[f.Name],
2020-02-01 13:02:19 +03:00
})
}
return
}
2020-02-01 10:23:45 +03:00
func (schema *Schema) guessRelation(relation *Relationship, field *Field, guessHas bool) {
var (
primaryFields, foreignFields []*Field
primarySchema, foreignSchema = schema, relation.FieldSchema
)
if !guessHas {
primarySchema, foreignSchema = relation.FieldSchema, schema
}
reguessOrErr := func(err string, args ...interface{}) {
if guessHas {
schema.guessRelation(relation, field, false)
} else {
schema.err = fmt.Errorf(err, args...)
}
}
2020-02-01 16:48:06 +03:00
if len(relation.foreignKeys) > 0 {
for _, foreignKey := range relation.foreignKeys {
2020-02-01 10:23:45 +03:00
if f := foreignSchema.LookUpField(foreignKey); f != nil {
foreignFields = append(foreignFields, f)
} else {
2020-02-01 16:48:06 +03:00
reguessOrErr("unsupported relations %v for %v on field %v with foreign keys %v", relation.FieldSchema, schema, field.Name, relation.foreignKeys)
2020-02-01 10:23:45 +03:00
return
}
}
} else {
for _, primaryField := range primarySchema.PrimaryFields {
2020-02-01 16:48:06 +03:00
lookUpName := schema.Name + primaryField.Name
if !guessHas {
lookUpName = field.Name + primaryField.Name
}
if f := foreignSchema.LookUpField(lookUpName); f != nil {
2020-02-01 10:23:45 +03:00
foreignFields = append(foreignFields, f)
primaryFields = append(primaryFields, primaryField)
}
}
}
if len(foreignFields) == 0 {
2020-02-01 16:48:06 +03:00
reguessOrErr("failed to guess %v's relations with %v's field %v 1 g %v", relation.FieldSchema, schema, field.Name, guessHas)
return
2020-02-01 16:48:06 +03:00
} else if len(relation.primaryKeys) > 0 {
for idx, primaryKey := range relation.primaryKeys {
2020-02-01 10:23:45 +03:00
if f := primarySchema.LookUpField(primaryKey); f != nil {
if len(primaryFields) < idx+1 {
primaryFields = append(primaryFields, f)
} else if f != primaryFields[idx] {
2020-02-01 16:48:06 +03:00
reguessOrErr("unsupported relations %v for %v on field %v with primary keys %v", relation.FieldSchema, schema, field.Name, relation.primaryKeys)
2020-02-01 10:23:45 +03:00
return
}
} else {
2020-02-01 16:48:06 +03:00
reguessOrErr("unsupported relations %v for %v on field %v with primary keys %v", relation.FieldSchema, schema, field.Name, relation.primaryKeys)
2020-02-01 10:23:45 +03:00
return
}
}
} else if len(primaryFields) == 0 {
if len(foreignFields) == 1 {
primaryFields = append(primaryFields, primarySchema.PrioritizedPrimaryField)
} else if len(primarySchema.PrimaryFields) == len(foreignFields) {
primaryFields = append(primaryFields, primarySchema.PrimaryFields...)
} else {
reguessOrErr("unsupported relations %v for %v on field %v", relation.FieldSchema, schema, field.Name)
return
}
}
2020-02-01 10:23:45 +03:00
// build references
for idx, foreignField := range foreignFields {
relation.References = append(relation.References, Reference{
PrimaryKey: primaryFields[idx],
2020-02-01 10:23:45 +03:00
ForeignKey: foreignField,
OwnPrimaryKey: schema == primarySchema && guessHas,
2020-02-01 10:23:45 +03:00
})
}
2020-01-31 07:22:37 +03:00
2020-02-01 10:23:45 +03:00
if guessHas {
relation.Type = "has"
} else {
2020-02-01 13:02:19 +03:00
relation.Type = BelongsTo
2020-02-01 10:23:45 +03:00
}
2020-01-31 07:22:37 +03:00
}