Apprenez le langage Go pour faire fonctionner le prétraitement MySQL

Rappel amical : Cet article prend environ 6 minutes et 41 secondes à lire. Veuillez me donner quelques conseils en cas de lacunes. Merci d'avoir lu. Abonnez-vous à ce site

Prétraitement

Le prétraitement est une technologie utilisée par MySQL pour éviter les requêtes fréquentes des clients. Il effectue la même instruction de traitement sur Pre. -chargées dans MySQL, les données des variables d'exploitation sont remplacées par des espaces réservés, réduisant ainsi les requêtes fréquentes vers MySQL et permettant au serveur de fonctionner efficacement.

Ici, le client n'est pas l'architecture C/S entre le front et le backend, mais l'architecture C/S dans laquelle le programme d'arrière-plan exploite le serveur de base de données. De cette façon, vous pouvez brièvement comprendre le programme d'arrière-plan comme. le client vers le serveur MySQL demande et traite les résultats.

Recommandations d'apprentissage associées : Tutoriel du langage GO

Processus de traitement d'exécution SQL ordinaire :

1. Préparer l'instruction SQL sur le client ;
2. Envoyer l'instruction SQL au serveur MySQL
3. Exécuter l'instruction SQL sur le serveur MySQL
4. Le serveur renvoie le résultat de l'exécution au client.

Processus d'exécution du prétraitement :

1. Diviser SQL en partie structure et partie données
2. Quand lors de l'exécution d'une instruction SQL, envoyez d'abord la même partie de commande et de structure au serveur MySQL, permettant au serveur MySQL d'effectuer un prétraitement à l'avance (l'instruction SQL n'est pas réellement exécutée à ce moment
3. Afin de garantir) ; l'intégrité structurelle de l'instruction SQL, lorsque l'instruction SQL est envoyée pour la première fois, les parties de données variables sont représentées par un espace réservé aux données
4. puis la partie de données est envoyée au serveur MySQL ; Le serveur MySQL remplace les espaces réservés de l'instruction SQL ;
5. Le serveur MySQL exécute l'instruction SQL complète et renvoie le résultat au client.

Avantages du prétraitement

• Les instructions de prétraitement réduisent considérablement le temps d'analyse, une seule requête est effectuée (bien que l'instruction Multiple exécutions);
• Paramètres de liaison Réduit la bande passante du serveur en envoyant uniquement les paramètres de la requête au lieu de l'instruction entière
• La cible des instructions préparées ** L'injection SQL** est ; très utile car différents protocoles sont utilisés après l'envoi de la valeur du paramètre, garantissant la légalité des données.

Implémentation du langage Go

Dans le langage Go, utilisez la méthode db.Prepare() pour implémenter le prétraitement :

func (db *DB) Prepare(query string) (*Stmt, error)

Prepare exécute l'instruction SQL de prétraitement et renvoie le pointeur de structure Stmt pour les opérations de liaison de données.

Les opérations de requête utilisent la méthode db.Prepare() pour déclarer le prétraitement SQL, utilisez stmt.Query() pour remplacer les espaces réservés par des données pour la requête et les opérations de mise à jour, d'insertion et de suppression à l'aide de stmt.Exec().

Exemple de requête de prétraitement

// 预处理查询数据func prepareQuery() {
    sqlStr := "SELECT id,name,age FROM user WHERE id > ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    rows, err := stmt.Query(1)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var u user
        err := rows.Scan(&u.id, &u.name, &u.age)
        if err != nil {
            fmt.Printf("scan data failed, err:%v\n", err)
            return
        }
        fmt.Printf("id:%d, name:%s, age:%d\n", u.id, u.name, u.age)
    }}

Exemple de mise à jour de prétraitement

// 预处理更新数据func prepareUpdate() {
    sqlStr := "UPDATE user SET age = ? WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    _, err = stmt.Exec(18, 2)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    fmt.Printf("prepare update data success")}

Exemple d'insertion de prétraitement

// 预处理更新数据func prepareUpdate() {
    sqlStr := "UPDATE user SET age = ? WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    _, err = stmt.Exec(18, 2)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    fmt.Printf("prepare update data success")}

Exemple de suppression de prétraitement

// 预处理删除数据func prepareDelete() {
    sqlStr := "DELETE FROM user WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    result, err := stmt.Exec(3)
    n, err := result.RowsAffected()
    if err != nil {
        fmt.Printf("delete rows failed, err:%v\n", err)
        return
    }
    if n > 0 {
        fmt.Printf("delete data success")
    } else {
        fmt.Printf("delete data error")
    }

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!