Comment extraire des données de la base de données MySQL en utilisant le langage Go

MySQL est une base de données relationnelle très populaire et le langage Go est un langage de programmation en développement rapide Si vous combinez les deux, vous pouvez obtenir une extraction de données pratique et efficace. Cet article présentera la méthode d'utilisation du langage Go pour extraire des données MySQL. J'espère qu'il pourra inspirer et aider tout le monde.

1. Installez et configurez le pilote MySQL

Avant d'utiliser le langage Go pour extraire les données MySQL, nous devons d'abord installer le pilote MySQL. Il existe de nombreux choix de pilotes MySQL. Nous présentons ici les deux plus couramment utilisés : go-sql-driver et mysql driver.

Pour installer à l'aide de go-sql-driver, vous pouvez utiliser la commande suivante :

go get -u github.com/go-sql-driver/mysql

Pour installer à l'aide du pilote mysql, vous pouvez utiliser la commande suivante :

go get -u github.com/mysql/mysql-go

#🎜 🎜#Une fois l'installation terminée, importez simplement le package de pilotes correspondant dans le code, par exemple :

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

Mais il convient de noter que lors de l'utilisation du pilote MySQL, vous devez également configurer Concernant MySQL, en particulier, la méthode est la suivante :

Définissez le jeu de caractères de MySQL sur utf8mb4

Dans les versions antérieures à MySQL 5.7.7. , le jeu de caractères par défaut est utf8. Seuls les caractères Unicode de 3 octets sont pris en charge Dans la version 5.7.7 et les versions ultérieures, le jeu de caractères utf8mb4 est utilisé par défaut et les caractères Unicode de 4 octets sont pris en charge. fichier my.cnf ou my.ini. Le serveur de jeux de caractères est défini sur utf8mb4 pour obtenir l'effet de prendre en charge les caractères spéciaux tels que le chinois.

Ouvrir le journal binlog

Dans MySQL, le journal binlog enregistre toutes les instructions SQL qui fonctionnent sur MySQL, donc lors de l'extraction de données, vous avez besoin pour activer binlog pour la synchronisation des données en temps réel. Il peut être configuré et activé dans my.cnf ou my.ini.

2. Connectez-vous à la base de données MySQL

Après avoir installé le pilote MySQL et l'avoir configuré en conséquence, nous devons ensuite nous connecter à la base de données MySQL. La méthode pour se connecter à la base de données MySQL est la suivante :

db, err := sql.Open("mysql", "user:password@tcp(ip:port)/database")

Parmi eux, l'utilisateur et le mot de passe sont le nom d'utilisateur et le mot de passe de MySQL, l'ip et le port sont l'adresse de connexion et le numéro de port de MySQL, et base de données est la base de données à laquelle accéder.

Après une connexion réussie à la base de données MySQL, nous pouvons effectuer les opérations de données correspondantes, telles que la lecture de données dans MySQL dans le langage Go ou le stockage de données dans le langage Go dans MySQL.

3. Requête d'instruction SQL

Il est très simple d'utiliser des instructions SQL pour interroger des données dans MySQL en langage Go. Nous pouvons utiliser la fonction sql.Query pour exécuter l'instruction de requête et enregistrer les résultats dans l'objet rows, tel que :

rows, err := db.Query("SELECT * FROM table1")

Après une exécution réussie, vous pouvez utiliser la fonction Next de l'objet rows pour parcourir les résultats et supprimez un enregistrement d'élément à la fois, et encapsulez-le dans l'objet struct correspondant :

type Product struct {
    ID         int64  `db:"id"`
    Name       string `db:"name"`
    Price      int64  `db:"price"`
    CreateTime int64  `db:"create_time"`
}

func main() {
    rows, err := db.Query("SELECT * FROM product")  // 查询product表
    if err != nil {
        panic(err)
    }

    defer rows.Close()

    products := make([]Product, 0)

    for rows.Next() {  // 遍历结果集
        var p Product
        err = rows.Scan(&p.ID, &p.Name, &p.Price, &p.CreateTime)  // 将一条记录封装到Product对象中
        if err != nil {
            panic(err)
        }
        products = append(products, p)
    }
}

La méthode d'utilisation de la fonction sql.QueryRow pour interroger un seul enregistrement est également très simple : # 🎜🎜#

var p Product
err := db.QueryRow("SELECT * FROM product WHERE id=?", 1).Scan(&p.ID, &p.Name, &p.Price, &p.CreateTime)
if err != nil {
    panic(err)
}

4. Insérer des données# 🎜🎜#

Il est également très simple d'utiliser le langage Go pour insérer des données dans MySQL. Nous pouvons utiliser la fonction sql.Exec pour exécuter l'instruction SQL pour y parvenir :

stmt, err := db.Prepare("INSERT INTO product(name, price) VALUES(?,?)")
if err != nil {
    panic(err)
}

res, err := stmt.Exec("Product1", 100)
if err != nil {
    panic(err)
}

La fonction Prepare dans le code ci-dessus est utilisée pour préparer l'instruction SQL, puis utiliser la fonction Exec pour exécuter l'instruction SQL. Instruction SQL et renvoie le résultat. Si l'exécution réussit, le résultat renvoyé contient l'ID des données insérées (le cas échéant), qui peut être obtenu à l'aide de la fonction LastInsertId. Si vous avez besoin d'obtenir le nombre de lignes concernées, vous pouvez utiliser la fonction RowsAffected.

5. Mettre à jour et supprimer des données

Semblable à l'insertion de données, le langage Go peut également utiliser la fonction sql.Exec pour exécuter des instructions de mise à jour SQL et des instructions de suppression, comme suit : # 🎜🎜 #

// 执行更新操作
stmt, err := db.Prepare("UPDATE product SET price=? WHERE id=?")
if err != nil {
    panic(err)
}

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

// 执行删除操作
stmt, err = db.Prepare("DELETE FROM product WHERE id=?")
if err != nil {
    panic(err)
}

res, err = stmt.Exec(1)
if err != nil {
    panic(err)
}

6. Gestion des transactions

Lors de l'exécution d'opérations sur les données, il est parfois nécessaire de garantir l'atomicité des données, c'est-à-dire que toutes les opérations de base de données réussissent ou échouent. À ce stade, nous pouvons utiliser le mécanisme de gestion des transactions pour y parvenir.

En langage Go, vous pouvez utiliser db.Begin et tx.Commit pour ouvrir et soumettre des transactions, telles que :

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

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

res, err := stmt.Exec("Product1", 100)
if err != nil {
    tx.Rollback()
    panic(err)
}

stmt, err = tx.Prepare("INSERT INTO product(name, price) VALUES(?,?)")
if err != nil {
    panic(err)
}

res, err = stmt.Exec("Product2", 200)
if err != nil {
    tx.Rollback()
    panic(err)
}

// 提交事务
err = tx.Commit()
if err != nil {
    tx.Rollback()
    panic(err)
}

Dans le code ci-dessus, après avoir ouvert la transaction, nous pouvons Plusieurs opérations SQL sont effectuées dans une transaction. Après avoir exécuté toutes les opérations SQL et assuré l'atomicité de toutes les opérations SQL, vous devez utiliser la fonction Commit() pour valider la transaction. Si une erreur se produit dans une opération SQL, vous pouvez utiliser la fonction Rollback() pour annuler la transaction.

7. Conclusion

Cet article présente la méthode d'utilisation du langage Go pour extraire des données de la base de données MySQL. Grâce à l'introduction ci-dessus, nous pouvons constater que l'utilisation du langage Go pour effectuer des opérations de données sur la base de données MySQL est très pratique et efficace. Si vous n'avez pas essayé d'utiliser le langage Go pour les opérations de base de données, autant l'essayer, je pense que vous en tomberez amoureux.

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!