Comment implémenter les fonctions d'exploitation de base de données en langage Go

Comment implémenter les fonctions d'exploitation de base de données dans le langage Go

Le langage Go, en tant que langage de programmation efficace et concis, est très approprié pour développer des opérations de back-end de serveur et de base de données. Dans le développement d’applications réelles, le fonctionnement de la base de données constitue un maillon essentiel. Aujourd'hui, nous allons présenter comment implémenter les fonctions d'opération de base de données en langage Go, ainsi que quelques exemples d'opérations courantes.

1. Connexion à la base de données

En langage Go, nous pouvons utiliser des bibliothèques tierces pour nous connecter à différents types de bases de données. Parmi eux, les plus couramment utilisés sont le package "database/sql" de la bibliothèque standard et divers pilotes de base de données, tels que "go-sqlite3", "mysql" et "postgres".

Tout d'abord, nous devons importer les packages requis :

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql" // MySQL驱动
)

Ensuite, nous pouvons utiliser la fonction "sql.Open" pour nous connecter à la base de données :

db, err := sql.Open("mysql", "user:password@tcp(localhost:8889)/mydb")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

Dans le code ci-dessus, nous utilisons le pilote MySQL et spécifions la base de données adresse de connexion et informations d’identification. Si la connexion réussit, nous pouvons effectuer diverses opérations sur la base de données via l'objet "db".

2. Exécuter des instructions SQL

De manière générale, les opérations de base de données incluent principalement des fonctions telles que la requête, l'insertion, la mise à jour et la suppression. Vous trouverez ci-dessous quelques exemples d'opérations de base de données courantes.

1. Requête de données

rows, err := db.Query("SELECT * FROM users")
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

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

err = rows.Err()
if err != nil {
    log.Fatal(err)
}

Dans le code ci-dessus, nous exécutons une instruction SELECT via la fonction "db.Query" et obtenons les résultats de la requête via "rows.Next" et "rows.Scan". Il convient de noter que nous devons utiliser "defer rows.Close()" pour garantir que les ressources sont libérées après avoir utilisé les résultats de la requête.

2. Insérer des données

stmt, err := db.Prepare("INSERT INTO users(name) VALUES(?)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

res, err := stmt.Exec("John")
if err != nil {
    log.Fatal(err)
}

id, err := res.LastInsertId()
if err != nil {
    log.Fatal(err)
}

fmt.Println("Inserted record ID:", id)

Dans le code ci-dessus, nous utilisons la fonction "db.Prepare" pour préparer une instruction INSERT et "stmt.Exec" pour effectuer l'opération d'insertion. Ensuite, nous pouvons obtenir l'ID correspondant à l'enregistrement inséré via "res.LastInsertId".

3. Mettre à jour les données

stmt, err := db.Prepare("UPDATE users SET name=? WHERE id=?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

res, err := stmt.Exec("John Smith", 1)
if err != nil {
    log.Fatal(err)
}

rowsAffected, err := res.RowsAffected()
if err != nil {
    log.Fatal(err)
}

fmt.Println("Rows affected:", rowsAffected)

Dans le code ci-dessus, nous préparons une instruction UPDATE via la fonction "db.Prepare" et utilisons "stmt.Exec" pour effectuer l'opération de mise à jour. On peut alors obtenir le nombre de lignes concernées via "res.RowsAffected".

4. Supprimer les données

stmt, err := db.Prepare("DELETE FROM users WHERE id=?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

res, err := stmt.Exec(1)
if err != nil {
    log.Fatal(err)
}

rowsAffected, err := res.RowsAffected()
if err != nil {
    log.Fatal(err)
}

fmt.Println("Rows affected:", rowsAffected)

Dans le code ci-dessus, nous avons préparé une instruction DELETE via la fonction "db.Prepare" et utilisé "stmt.Exec" pour effectuer l'opération de suppression. De même, nous pouvons obtenir le nombre de lignes affectées via "res.RowsAffected".

3. Traitement des transactions

Dans le développement d'applications réelles, le traitement des transactions est une fonction très importante. En langage Go, on peut utiliser "db.Begin" pour démarrer une transaction et "tx.Commit" pour valider la transaction. Si une erreur se produit lors du traitement de la transaction, nous pouvons utiliser "tx.Rollback" pour annuler la transaction.

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

stmt, err := tx.Prepare("INSERT INTO users(name) VALUES(?)")
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}
defer stmt.Close()

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

err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

Dans le code ci-dessus, nous utilisons "db.Begin" pour démarrer une transaction et effectuer des opérations d'insertion dans la transaction. Si une erreur se produit, nous utilisons « tx.Rollback » pour annuler la transaction ; sinon, nous utilisons « tx.Commit » pour valider la transaction.

Résumé :

Grâce à l'introduction de cet article, nous avons appris comment implémenter les fonctions d'opération de base de données en langage Go et démontré quelques exemples courants d'opérations de base de données. Il convient de mentionner que différents types de bases de données peuvent être facilement connectés à l'aide du package "database/sql" et des pilotes de base de données appropriés. J'espère que cet article vous aidera à effectuer des opérations de base de données en langage Go !

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!