Comment utiliser la base de données dans Go ?

Avec la popularité généralisée des applications Web et autres applications complexes sur Internet, les bases de données sont devenues un élément indispensable. Go est un langage de programmation populaire qui peut être utilisé pour le développement d'applications Web et d'autres systèmes. Dans cet article, nous explorerons comment utiliser les bases de données dans Go.

1. Choisissez une base de données

Avant de commencer à utiliser une base de données, vous devez d'abord choisir une base de données adaptée à votre application. Go prend en charge de nombreuses bases de données populaires telles que MySQL, PostgreSQL, MongoDB, etc. Vous pouvez également utiliser une bibliothèque ORM (Object Relational Mapper) ou une bibliothèque de générateur SQL pour simplifier l'interaction avec la base de données. Une bibliothèque ORM est une bibliothèque qui mappe des objets aux tables d'une base de données, tandis qu'une bibliothèque de générateur SQL est une bibliothèque permettant de créer et d'interroger des requêtes SQL. Le choix d'une base de données doit être basé sur les besoins de votre application et sur votre compréhension des avantages et des inconvénients des différentes bases de données.

2. Installer le pilote de base de données

Une fois que vous avez sélectionné votre base de données, l'étape suivante consiste à installer le pilote de base de données. Go dispose de pilotes pour diverses bases de données, vous pouvez utiliser des pilotes de la base de données/sql de la bibliothèque standard de Go ou des bibliothèques externes avec des fonctionnalités de niveau supérieur. Il est crucial d'obtenir les informations correctes sur le conducteur à partir de la documentation officielle de la base de données. En fonction de la base de données que vous choisissez, les exigences diffèrent, veuillez donc être conscient de certains détails auxquels vous devez prêter attention lors du processus d'installation.

3. Établir une connexion

Avant d'utiliser la base de données, vous devez établir une connexion à la base de données. Dans Go, vous pouvez utiliser le code suivant pour créer une connexion à une base de données MySQL :

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/mydb")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    err = db.Ping()
    if err != nil {
        panic(err.Error())
    }

    fmt.Println("Connection established")
}

Dans cet exemple, nous utilisons la fonction sql.Open() pour ouvrir une connexion à une base de données MySQL. Dans la fonction Open(), nous utilisons le pilote MySQL (dans ce cas github.com/go-sql-driver/mysql), indiquant à Go que nous nommons la base de données, nom d'utilisateur, mot de passe et adresse pour se connecter. Ensuite, nous utilisons la commande db.Ping() pour tester si la connexion à la base de données réussit afin de garantir que la connexion est réussie. Enfin, utilisez defer db.Close() pour vous assurer que la connexion à la base de données est fermée avant la fermeture du programme. sql.Open()函数打开一个MySQL数据库连接。在Open()函数中，我们使用MySQL的驱动程序（在这种情况下是github.com/go-sql-driver/mysql），告诉Go我们要连接的数据库名称，用户名，密码和地址。然后，我们使用db.Ping()命令来测试是否成功连接到数据库，以确保连接成功。最后，使用defer db.Close()，以确保在程序退出之前关闭数据库连接。

4. 执行查询

一旦与数据库建立了连接，您就可以开始使用它。要执行查询语句，您可以使用db.Query()或db.QueryRow()函数。 db.Query()函数用于执行返回多行的查询，而db.QueryRow()函数用于执行返回单行结果的查询。

下面是一个用于执行查询的示例：

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/mydb")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    rows, err := db.Query("SELECT * FROM mytable")
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        err = rows.Scan(&id, &name)
        if err != nil {
            panic(err.Error())
        }
        fmt.Println("id:", id, "name:", name)
    }

    err = rows.Err()
    if err != nil {
        panic(err.Error())
    }
}

在上述示例代码中，我们首先使用db.Query()执行SELECT语句，将结果存储在rows变量中。然后，我们使用rows.Close()函数关闭结果集。接下来，我们使用rows.Next()循环遍历结果集中的每一行，并使用rows.Scan()函数将结果和变量匹配。最后，我们使用rows.Err()函数处理任何潜在的错误。

5. 执行插入，更新和删除操作

除了查询操作，数据库还支持插入，更新和删除操作。在Go中执行这些操作与查询操作类似，您需要使用不同的函数。

要执行插入操作，您可以使用以下代码：

res, err := db.Exec("INSERT INTO mytable (name) VALUES (?)", "John")
if err != nil {
    panic(err.Error())
}
lastInsertID, err := res.LastInsertId()
if err != nil {
    panic(err.Error())
}
fmt.Println("Last inserted ID:", lastInsertID)

要执行更新操作，您可以使用以下代码：

res, err = db.Exec("UPDATE mytable SET name = ? WHERE id = ?", "John Doe", 1)
if err != nil {
    panic(err.Error())
}
rowsAffected, err := res.RowsAffected()
if err != nil {
    panic(err.Error())
}
fmt.Println("Rows affected:", rowsAffected)

要执行删除操作，您可以使用以下代码：

res, err = db.Exec("DELETE FROM mytable WHERE id = ?", 1)
if err != nil {
    panic(err.Error())
}
rowsAffected, err = res.RowsAffected()
if err != nil {
    panic(err.Error())
}
fmt.Println("Rows affected:", rowsAffected)

6. 使用事务

在进行任何更改时，使用数据库事务对于确保数据库的完整性非常重要。在Go中，您可以使用以下代码使用事务：

tx, err := db.Begin()

stmt, err := tx.Prepare("INSERT INTO mytable (name) VALUES (?)")
if err != nil {
    tx.Rollback()
    panic(err.Error())
}

_, err = stmt.Exec("John")
if err != nil {
    tx.Rollback()
    panic(err.Error())
}

stmt, err = tx.Prepare("UPDATE mytable SET name = ? WHERE id = ?")
if err != nil {
    tx.Rollback()
    panic(err.Error())
}

_, err = stmt.Exec("John Doe", 1)
if err != nil {
    tx.Rollback()
    panic(err.Error())
}

err = tx.Commit()
if err != nil {
    panic(err.Error())
}

在上述代码中，我们首先使用db.Begin()函数启动一个事务。然后，我们使用tx.Prepare()函数准备要执行的SQL语句。接下来，我们使用stmt.Exec()函数执行SQL语句。在执行所有操作之后，我们使用tx.Commit()函数提交事务。如果任何操作失败，我们使用tx.Rollback()

Exécutez la requête
7. Une fois la connexion à la base de données établie, vous pouvez commencer à l'utiliser. Pour exécuter une instruction de requête, vous pouvez utiliser la fonction db.Query() ou db.QueryRow(). La fonction db.Query() est utilisée pour exécuter des requêtes qui renvoient plusieurs lignes, tandis que la fonction db.QueryRow() est utilisée pour exécuter des requêtes qui renvoient une seule ligne de résultats.

Voici un exemple d'exécution d'une requête :

rrreee

Dans l'exemple de code ci-dessus, nous exécutons d'abord l'instruction SELECT en utilisant db.Query() et stockons les résultats dans la variable rows. Ensuite, nous fermons le jeu de résultats en utilisant la fonction rows.Close(). Ensuite, nous utilisons rows.Next() pour parcourir chaque ligne du jeu de résultats et utilisons la fonction rows.Scan() pour faire correspondre les résultats avec les variables. Enfin, nous utilisons la fonction rows.Err() pour gérer les erreurs potentielles.
Effectuer des opérations d'insertion, de mise à jour et de suppression
• En plus des opérations de requête, la base de données prend également en charge les opérations d'insertion, de mise à jour et de suppression. Effectuer ces opérations dans Go est similaire aux opérations de requête, vous devez utiliser différentes fonctions.
• Pour effectuer une opération d'insertion, vous pouvez utiliser le code suivant :
rrreee

Pour effectuer une opération de mise à jour, vous pouvez utiliser le code suivant : 🎜rrreee 🎜 Pour effectuer une opération de suppression, vous pouvez utiliser le code suivant : 🎜rrreee🎜Utiliser les transactions🎜🎜🎜L'utilisation des transactions de base de données est très importante pour garantir l'intégrité de la base de données lors de toute modification. Dans Go, vous pouvez utiliser des transactions en utilisant le code suivant : 🎜rrreee🎜 Dans le code ci-dessus, on démarre d'abord une transaction en utilisant la fonction db.Begin(). Ensuite, nous utilisons la fonction tx.Prepare() pour préparer l'instruction SQL à exécuter. Ensuite, nous utilisons la fonction stmt.Exec() pour exécuter l'instruction SQL. Une fois toutes les opérations effectuées, nous validons la transaction à l'aide de la fonction tx.Commit(). Si une opération échoue, nous utilisons la fonction tx.Rollback() pour annuler toutes les modifications. 🎜🎜🎜Références🎜🎜🎜Dans cet article, nous avons expliqué comment utiliser les bases de données dans Go. Pour des opérations de base de données plus avancées, vous pouvez utiliser une bibliothèque de générateur ORM ou SQL pour une interaction plus facile. Pour en savoir plus sur l'utilisation d'une base de données spécifique, veuillez consulter la documentation officielle concernée et la documentation de la bibliothèque Go. Voici quelques références : 🎜🎜🎜Database/SQL pour Golang : https://golang.org/pkg/database/sql/ 🎜🎜Go MySQL Driver : https://github.com/go-sql-driver/ mysql🎜 🎜Pilote Go PostgreSQL : https://github.com/lib/pq🎜🎜Pilote MongoDB Go : https://github.com/mongodb/mongo-go-driver🎜🎜

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!