Gorm - interroger les enregistrements

Annuaire d'articles

(｡･∀･)ﾉﾞSalut
Définition de la structure utilisateur, conception de la table de base de données et initialisation de Gorm, veuillez vous référer à l'article https://mingvvv.blog.csdn.net/article/details/129026914

Initialisez d'abord le pool de connexion

db := cus_orm.MysqlConnection()

Interroger un seul enregistrement

Interroger la table correspondante via la structure

user := &model.User{
    
    }
db.Debug().Take(user)  //按照数据库表默认排序
db.Debug().First(user) //按照主键正序 如果没有设置主键 则按照第一个字段排序
db.Debug().Last(user)  //按照主键倒序  如果没有设置主键 则按照第一个字段排序
-----------------------------
SELECT * FROM `user` LIMIT 1
SELECT * FROM `user` WHERE `user`.`id` = 521 ORDER BY `user`.`id` LIMIT 1
SELECT * FROM `user` WHERE `user`.`id` = 521 ORDER BY `user`.`id` DESC LIMIT 1

Après l'interrogation, un résultat de type pointeur de base de données sera en fait renvoyé et le contenu de la structure de la base de données est le suivant :

type DB struct {
    
    
	*Config
	Error        error
	RowsAffected int64
	Statement    *Statement
	clone        int
}

En acceptant ce résultat, nous pouvons déterminer à l'avance si la requête est anormale et obtenir le nombre de lignes affectées :

result := db.First(&user)
//判断是不是没有找到任何一条行信息
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
    
    
	fmt.Println("记录不存在")
}else{
    
    
	fmt.Println(result.RowsAffected)
}

Spécifiez la table et placez le résultat de l'interrogation d'un enregistrement dans le dictionnaire

data2 := map[string]interface{
    
    }{
    
    }
result := db.Debug().Table("user").Take(&data2)
------------------------------------------
SELECT * FROM `user` LIMIT 1

De cette manière, nous pouvons interroger les données de la table à volonté, mais il convient de noter que les fonctions First() et Last() ne peuvent pas être utilisées pour spécifier le nom de la table,
car l'instruction SQL générée en utilisant ces deux méthodes ajoutera automatiquement la logique de tri selon la clé primaire du modèle, et comme le modèle n'est pas utilisé dans le code ci-dessus, le SQL final signalera une erreur comme suit
:

db.Debug().Table("user").First(&data2)
----------------------------
SELECT * FROM `user` ORDER BY id,`user`. LIMIT 1

Requête par clé primaire

db.Debug().First(user, 531)                                              //查询主键是 531 的记录
db.Debug().First(user, "id = ?", "1b74413f-f3b8-409f-ac47-e8c062e3472a") //主键是string时，需要用这种格式
---------------------------------------------------------
SELECT * FROM `user` WHERE `user`.`id` = 531 ORDER BY `user`.`id` LIMIT 1
SELECT * FROM `user` WHERE id = '1b74413f-f3b8-409f-ac47-e8c062e3472a' ORDER BY `user`.`id` LIMIT 1

Interroger plusieurs enregistrements

Requête par clé primaire

db.Debug().Find(user, []int{
    
    531, 532, 533})   
---------------------------------------------------------
SELECT * FROM `user` WHERE `user`.`id` IN (531,532,533)

requête utilisant la structure

var users []model.User
db.Debug().Find(&users)
------------------------------
SELECT * FROM `user`

Spécifiez la requête de nom de table et placez-la dans la liste du dictionnaire

var users []map[string]interface{
    
    }
db.Debug().Table("user").Find(&users)
//Scan一定要自己指定表名
db.Debug().Table("user").Scan(&users)
--------------------------------------------
SELECT * FROM `user`
SELECT * FROM `user`

spécifier les champs de requête

db.Debug().Select("concat(name,age)", "age").Find(&users)
---------------------------------------
SELECT concat(name,age),`age` FROM `user`

Conditions de requête

Où condition (=, comme, dans)

db.Debug().Where("age = ?", 18).Find(&users)
db.Debug().Where("age = ? and name like ?", 18, "%测试%").Find(&users)
db.Debug().Where("name in ?", []string{
    
    "测试goper333", "测试goper222"}).Find(&users)
--------------------------------------------
SELECT * FROM `user` WHERE age = 18
SELECT * FROM `user` WHERE age = 18 and name like '%测试%'
SELECT * FROM `user` WHERE name in ('测试goper333','测试goper222')

Gorm prend en charge l'ajout de conditions de requête intégrées dans les méthodes First, Last, Find

// Inline 查询条件
db.Debug().Find(&users, "age = ? and name in ?", 18, []string{
    
    "测试goper333", "测试goper222"})
---------------------------------------------
SELECT * FROM `user` WHERE age = 18 and name in ('测试goper333','测试goper222')

Définir les conditions de requête via la structure ou le dictionnaire

db.Debug().Where(&model.User{
    
    Name: "姓名"}).Find(&users)
db.Debug().Where(map[string]interface{
    
    }{
    
    "Name": "姓名"}).Find(&users)
db.Debug().Where([]int{
    
    521, 533}).Find(&users) //默认主键的 in 查询
------------------------------------------
SELECT * FROM `user` WHERE `user`.`name` = '姓名'
SELECT * FROM `user` WHERE `Name` = '姓名'
SELECT * FROM `user` WHERE `user`.`id` IN (521,533)

Lors de l'utilisation de la structure pour définir les conditions de requête, nous devons faire attention à un point :
les valeurs nulles (0, false, string "") ne participent pas à la formation SQL
, c'est-à-dire que si je définis Age = 0, la condition de ligne age = 0 n'apparaîtra pas dans le SQL généré final , comme suit :

userQ := &model.User{
    
    Name: "姓名", Age: 0}
db.Debug().Where(&userQ).Find(&users) 
-----------------------------------
SELECT * FROM `user` WHERE `user`.`name` = '姓名'

Si nous voulons que les valeurs nulles participent aux requêtes SQL, nous devons utiliser la forme du dictionnaire pour construire SQL, ou utiliser la méthode Raw pour écrire du SQL complet par nous-mêmes.

var users []model.User
db.Debug().Where(map[string]interface{
    
    }{
    
    "Name": "姓名", "Age": 0}).Find(&users)
db.Debug().Raw("select * from user where name = ? and age = ?", "姓名", 0).Find(&users)
------------------------------------
SELECT * FROM `user` WHERE `Age` = 0 AND `Name` = '姓名'
select * from user where name = '姓名' and age = 0

ou

db.Debug().Where("name = '测试'").Or(&model.User{
    
    Name: "goper222", Age: 18}).Or(map[string]interface{
    
    }{
    
    "id": "526"}).Find(&users)
------------------------------
SELECT * FROM `user` WHERE name = '测试' OR (`user`.`name` = 'goper222' AND `user`.`age` = 18) OR `id` = '526'

Non

db.Debug().Not("name = ?", "姓名").Find(&users) 
db.Debug().Not(model.User{
    
    Name: "姓名", Age: 18}).Find(&users) //使用结构体
db.Debug().Not(map[string]interface{
    
    }{
    
    "Name": "姓名", "Age": 0}).Find(&users) // 使用字典
db.Debug().Not([]int{
    
    521, 533}).Find(&users) //主键非 条件查询
--------------------------------------------
SELECT * FROM `user` WHERE NOT name = '姓名'
SELECT * FROM `user` WHERE (`user`.`name` <> '姓名' AND `user`.`age` <> 18)
SELECT * FROM `user` WHERE (`Age` <> 0 AND `Name` <> '姓名')
SELECT * FROM `user` WHERE `user`.`id` NOT IN (521,533)

Trier

db.Debug().Order("age desc,name").Find(&users)
db.Debug().Order("age desc").Order("name").Find(&users)
------------------------------------------------
SELECT * FROM `user` ORDER BY age desc,name

Limite et décalage

db.Debug().Limit(5).Find(&users)
db.Debug().Offset(10).Limit(5).Find(&users)
-------------------------------
SELECT * FROM `user` LIMIT 5
SELECT * FROM `user` LIMIT 5 OFFSET 10

filtre récapitulatif

db.Debug().Select("name").Group("name").Find(&users)
db.Debug().Select("name").Group("name,age").Having("age = 18").Find(&users)
------------------------------------------------
SELECT `name` FROM `user` GROUP BY `name`
SELECT `name` FROM `user` GROUP BY name,age HAVING age = 18

Déduplication

db.Debug().Distinct("name").Find(&users)
------------------------------------------------
SELECT DISTINCT `name` FROM `user`

requête conjointe

db.Debug().Select("a.*").Joins("a left join user_extend b on a.id = b.user_id").Find(&users)
------------------------------------------------
SELECT a.* FROM `user` a left join user_extend b on a.id = b.user_id