Pertenece a
Cree una relación uno a uno de un modelo a otro
Por ejemplo: una tarjeta bancaria solo se puede asignar a un usuario, crear una relación de clave externa Useren la estructura y luego anidar una estructura en la estructuraCreditCardIdUserCreditCard
// Belongs To
// 用户
type User struct {
gorm.Model
CreditCardId int64
CreditCard CreditCard
}
// 银行卡
type CreditCard struct {
gorm.Model
Number string
}
Cree la estructura de tabla correspondiente en función de la estructura.
db.AutoMigrate(&User{
})
tabla de usuarios:
tabla de credit_cards:
Insertar un dato
user := User{
CreditCardId: 100,
CreditCard: CreditCard{
Number: "123456",
},
}
db.Create(&user)
tabla de usuarios:
tabla de credit_cards:
Consultar un dato por id
Se requiere carga previa; de lo contrario, no se consultará el contenido de la estructura anidada
var user User
err = db.Preload("CreditCard").Where("id=?", 1).Find(&user).Error
if err != nil {
fmt.Printf("err: %v\n", err)
}
fmt.Printf("user: %v\n", user)
Nota: Al eliminar una tabla, la tabla principal (tabla de usuarios) debe eliminarse primero y luego la tabla secundaria (credit_cards) debe eliminarse
Tiene uno
De manera similar, Has Onese utiliza para establecer una relación uno a uno, lo que indica que cada instancia de un modelo contiene o posee una instancia de otro modelo. La diferencia Belongs Toes que la ubicación de la clave externa está dentro de la estructura anidada
// Has One
// 用户
type User struct {
gorm.Model
CreditCard CreditCard
}
//银行卡
type CreditCard struct {
gorm.Model
Number string
UserID int64
}
Cree una estructura de tabla correspondiente basada en la estructura
db.AutoMigrate(&User{
}, &CreditCard{
})
tabla de usuarios:
tabla credit_cards
Insertar un dato
En cuanto al contenido de la estructura, no es necesario asignar un valor cuando el atributo es el contenido de gorm.model, ya que CreditCardpertenece a una estructura anidada interna, UserIDno es necesario especificarlo, el valor es el valor ID de la estructura de Usuario.
user := User{
CreditCard: CreditCard{
Number: "100",
},
}
db.Create(&user)
tabla de usuarios tabla
de credit_cards
Los datos de consulta aún deben usar la carga ansiosa
var user User
err = db.Preload("CreditCard").Where("id=?", 1).Find(&user).Error
if err != nil {
fmt.Printf("err: %v\n", err)
}
fmt.Printf("user: %v\n", user)
Tiene muchas
Has ManyEstablezca una relación de uno a muchos entre un modelo y otro modelo. La estructura anidada es un tipo de segmento, y la estructura interna anidada utilizará una identificación para garantizar la relación con la estructura externa. El ejemplo de la tarjeta bancaria ilustra que todos
pueden tiene muchas tarjetas bancarias, pero cada tarjeta bancaria tiene su propio valor de identificación
// Has Many
type User struct {
gorm.Model
CreditCards []CreditCard
}
type CreditCard struct {
gorm.Model
Number string
UserID int64
}
Cree una estructura de tabla correspondiente basada en la estructura
Al crear una tabla, Has Onees lo mismo que la tabla clave.
db.AutoMigrate(&User{
}, &CreditCard{
})
Insertar un dato
user := User{
CreditCard: []CreditCard{
{
Number: "100"}, {
Number: "101"}, {
Number: "101"},
},
}
db.Create(&user)
En correspondencia con la tabla de usuarios, cree un usuario uno por uno y use la tabla credit_cards para crear tres datos de tarjetas bancarias
Consultar datos requiere precarga
var user User
err = db.Preload("CreditCards").Where("id=?", 1).Find(&user).Error
if err != nil {
fmt.Printf("err: %v\n", err)
}
fmt.Printf("user: %v\n", user)
Muchos a muchos
Many to ManySe añadirá una tabla de conexiones a los dos modelos.
Ejemplo: en una red del tamaño adecuado, una persona puede tener varios chats grupales, cada uno con varias personas diferentes.
type User struct {
gorm.Model
ChatGroups []ChatGroup `gorm:"many2many:user_chat_group;"`
}
type ChatGroup struct {
gorm.Model
Name string
Users []User `gorm:"many2many:user_chat_group;"`
}
Cree una estructura de tabla correspondiente basada en la estructura
db.AutoMigrate(&User{
})
El uso de la estructura de usuario creará tres userstablas tabla , chat_groupstabla, user_chat_grouptabla
Insertar un dato
var user = User{
ChatGroups: []ChatGroup{
{
Name: "幸福一家人"}, {
Name: "研究生小分队"}, {
Name: "钓鱼佬永不空军"},
},
}
db.Create(&user)
Para la primera inserción de datos, la identificación no especificada se asignará automáticamente, el valor predeterminado es ascendente, la segunda inserción de datos: cree una nueva identificación de usuario = 2, el chat grupal del usuario son dos chats grupales con identificación igual a 1 y 2
var user = User{
Model: gorm.Model{
ID: 2,
},
ChatGroups: []*ChatGroup{
{
Model: gorm.Model{
ID: 1,
},
},
{
Model: gorm.Model{
ID: 2,
},
},
},
}
db.Create(&user)
En este punto, se agrega un dato a la tabla de usuarios, no se insertan datos nuevos en la tabla chat_groups y se insertan dos datos en la tabla de relaciones correspondiente de user_chat_group
Consulta de datos
var user User
//查询指定用户，并且预加载用户的群聊信息
db.Preload("ChatGroups").Where("id=?", 1).Find(&user)
fmt.Printf("user: %v\n", user)
var chats []ChatGroup
//查询指定群聊，并且预加载群聊里面的人
db.Preload("Users").Where("id=?", 1).Find(&chats).Association("ChatGroup")
fmt.Printf("chats: %v\n", chats)
Con respecto a la precarga, es para completar un valor de atributo de estructura anidada en la estructura Preload. Tenga en cuenta que no es el nombre de la tabla precargada, ni el nombre de la estructura precargada, sino el nombre de la estructura anidada correspondiente
borrado de datos
Elimine la información del usuario de acuerdo con la identificación del usuario y elimine los datos correspondientes en la tabla de asociación de usuarios
Elimine usersla información del usuario en la tabla y también elimine user_chat_grouptoda la información del usuario en la tabla correspondiente del chat del grupo de usuarios
user := User{
Model: gorm.Model{
ID: 2,
},
ChatGroups: []ChatGroup{
{
Model: gorm.Model{
ID: 1,
},
},
{
Model: gorm.Model{
ID: 2,
},
},
},
}
db.Select("ChatGroups").Delete(&user)
cambiar los datos
Modifique la información del usuario de acuerdo con la identificación del usuario y modifique los datos correspondientes en la tabla de asociación de usuarios
Por ejemplo, el chat grupal de un usuario cambia del grupo original id=1, 2 a id=2, 3 grupo.
user := User{
Model: gorm.Model{
ID: 2,
},
}
chats := []ChatGroup{
{
Model: gorm.Model{
ID: 2,
},
},
}
db.Model(&user).Association("ChatGroups").Replace(&chats)