requête de table commune Golang

Dans le développement de Golang, nous devons souvent utiliser des bases de données pour les opérations de données, et dans les affaires réelles, nous devons souvent effectuer des requêtes de table conjointes sur plusieurs tables. Cet article explique comment utiliser Golang pour effectuer des requêtes conjointes multi-tables.

1. Installez l'outil ORM de Golang

Dans Golang, nous utilisons souvent les outils ORM pour effectuer des opérations de base de données. ORM (Object Relational Mapping), qui est Object Relational Mapping, convertit les tables des bases de données relationnelles en formulaires orientés objet, rendant les opérations de base de données plus flexibles et plus pratiques. Les outils Golang ORM couramment utilisés incluent GORM, XORM, Beego ORM, etc. Ici, nous prenons GORM comme exemple.

Vous pouvez installer GORM via la commande suivante :

go get -u github.com/jinzhu/gorm

2. Définir le modèle de données

Avant d'effectuer une requête de table commune, vous devez définir le modèle de données. Le modèle de données convertit les tables de base de données relationnelles en structures en Golang pour faciliter nos opérations de données. Par exemple, nous devons effectuer une requête de table conjointe de deux tables, l'une est la table user user et l'autre est la table order user et order peuvent être définies respectivement comme les structures suivantes :

type User struct {
    Id   int
    Name string
}

type Order struct {
    Id         int
    UserId     int
    OrderName  string
    CreateTime time.Time
}

Parmi elles, la. La structure User comprend deux champs, respectivement Id et Name, correspondant aux champs id et name de la table user ; la structure Order comprend quatre champs, à savoir Id, UserId, OrderName et CreateTime, correspondant aux champs id, user_id, order_name et create_time. dans le tableau des commandes.

3. Définir la relation

Lors de l'exécution d'une requête de table commune, vous devez définir la relation entre les deux tables. GORM propose quatre types de relations : un-à-un, un-à-plusieurs, plusieurs-à-un, plusieurs-à-plusieurs).

Par exemple, nous devons faire une association plusieurs-à-un entre l'utilisateur et la commande, c'est-à-dire qu'un utilisateur peut correspondre à plusieurs commandes et qu'une commande ne peut correspondre qu'à un seul utilisateur. Vous pouvez ajouter un champ Commandes à la structure Utilisateur pour représenter toutes les commandes correspondant à un utilisateur, comme suit :

type User struct {
    Id     int
    Name   string
    Orders []Order `gorm:"ForeignKey:UserId"`
}

Dans la structure Commandes, vous devez ajouter un champ Utilisateur pour représenter les utilisateurs correspondant à une commande, comme suit :

type Order struct {
    Id         int
    UserId     int
    User       User
    OrderName  string
    CreateTime time.Time
}

Parmi eux, "ForeignKey:UserId" dans le champ Orders indique que le champ user_id de la table des commandes est associé au champ id de la table des utilisateurs et est utilisé comme clé étrangère dans la table des utilisateurs ; indique que le champ est le champ Association des Commandes dans la structure Utilisateur.

4. Effectuer des requêtes conjointes

Lorsque vous effectuez des requêtes conjointes sur plusieurs tables via Golang, vous pouvez utiliser la méthode Preload de GORM. La méthode Preload peut interroger toutes les données pertinentes en fonction de la relation d'association. Par exemple, si nous devons interroger toutes les commandes et inclure leurs informations utilisateur correspondantes, nous pouvons utiliser le code suivant :

var orders []Order 

db.Preload("User").Find(&orders)

fmt.Println(orders[0].User.Name)  // 输出第一条数据的用户名

Parmi eux, Preload("User") signifie utiliser le champ User pour l'association lors de l'interrogation, et Find( &orders) signifie interroger toutes les commandes et stockées dans la variable commandes. commandes[0].User.Name représente le nom d'utilisateur de l'utilisateur correspondant à la première donnée de sortie.

Si nous devons interroger tous les utilisateurs et leurs commandes correspondantes, nous pouvons utiliser le code suivant :

var users []User

db.Preload("Orders").Find(&users)

fmt.Println(users[0].Orders[0].OrderName)  // 输出第一个用户的第一个订单名

Parmi eux, Preload("Commandes") signifie utiliser le champ Commandes pour l'association lors de l'interrogation, et Find(&users) signifie pour interroger tous les utilisateurs et stocké dans la variable utilisateurs. users[0].Orders[0].OrderName signifie afficher le premier nom de commande du premier utilisateur.

Résumé

En utilisant Golang pour effectuer une requête conjointe multi-tables, nous pouvons l'implémenter en définissant le modèle de données, en définissant la relation et en utilisant la méthode Preload de GORM. De bons modèles de données et de bonnes relations peuvent faciliter nos opérations et requêtes de données. La méthode Preload de GORM nous permet d'effectuer facilement des requêtes conjointes multi-tables, réduisant ainsi la quantité de code et améliorant l'efficacité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!