Pré-vérification des opérations de données dans la base de données MySQL à l'aide du langage Go

La pré-vérification est une étape très critique dans le développement de logiciels. Elle peut nous aider à réduire l'apparition d'erreurs lors de l'exécution du programme et à améliorer la stabilité et la sécurité du programme. Lors de l'exécution d'opérations de données sur la base de données MySQL, la pré-vérification est également très importante, car MySQL est une base de données relationnelle et toute opération déraisonnable peut entraîner une perte de données ou des résultats d'opération incorrects. Cet article explique comment utiliser le langage Go pour effectuer une pré-vérification des opérations de données dans la base de données MySQL.

Tout d'abord, nous devons nous connecter à la base de données MySQL en langage Go. En utilisant le langage Go pour faire fonctionner la base de données MySQL, nous pouvons utiliser le pilote mysql officiellement fourni. Le processus de fonctionnement spécifique est le suivant :

import (
    "database/sql"
    "fmt"

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

func main() {
    // Open up our database connection.
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
    if err != nil {
        log.Fatal(err)
    }

    // Verify the connection with the Ping() method.
    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }

    // Do something with the newly opened connection here.
    // ...
}

Dans le code ci-dessus, nous utilisons d'abord la fonction sql.Open() pour nous connecter à la base de données MySQL, qui comprend le nom d'utilisateur, le mot de passe et l'adresse IP. du serveur MySQL qui doit être connecté, le numéro de port et le nom de la base de données à laquelle se connecter. Ensuite, nous utilisons la méthode db.Ping() pour vérifier si la connexion réussit. Si la connexion échoue, un message d'erreur sera imprimé et le programme se terminera. sql.Open()函数连接MySQL数据库，其中包括需要连接的用户名、密码、MySQL服务器的IP地址和端口号，以及要连接的数据库名称。然后，我们使用db.Ping()方法验证连接是否成功，如果连接失败则会打印错误信息并且退出程序。

接下来，我们需要对前置验证进行分类。按照常见的操作类型，可以将前置验证分为以下几类：

1. 连接验证
2. 插入、修改、删除等操作的验证
3. 查询参数的验证

第一种前置验证比较简单，在上面的代码中我们已经对连接做了验证，如果连接成功则说明它通过验证。

第二种前置验证一般是在执行插入、修改、删除等操作之前进行，具体的验证方法根据实际需求而定。以下是一个简单的示例：

func insertData(db *sql.DB, username string, password string) error {
    // Ensure username and password are not empty.
    if len(username) == 0 || len(password) == 0 {
        return errors.New("username and password are required")
    }

    // In the real world, ensure the username doesn't exist before creating a new user.
    if userExists(db, username) {
        return errors.New("user already exists")
    }

    // Perform the insert operation.
    _, err := db.Exec("INSERT INTO users (username, password) VALUES (?, ?)", username, password)
    if err != nil {
        return err
    }

    return nil
}

func userExists(db *sql.DB, username string) bool {
    // Prepare the SQL statement.
    stmt, err := db.Prepare("SELECT count(*) FROM users WHERE username = ?")
    if err != nil {
        return false
    }
    defer stmt.Close()

    // Execute the SQL statement.
    var count int
    err = stmt.QueryRow(username).Scan(&count)
    if err != nil {
        return false
    }

    return count > 0
}

在上面的示例中，我们定义了一个名为insertData()的函数，该函数首先验证了输入的用户名和密码是否为空，再调用userExists()函数验证用户名是否已经存在。如果用户名已经存在，则该函数将返回错误信息。如果所有的验证都通过了，则该函数执行插入操作。userExists()函数验证给定的用户名是否已经存在于数据库中，如果存在则返回true，否则返回false。

第三种前置验证是验证查询时的参数，这种方法非常有用，因为它可以帮助我们防止SQL注入攻击。以下是一个示例：

func getUsers(db *sql.DB, username string) ([]User, error) {
    // Ensure the username parameter is not empty.
    if len(username) == 0 {
        return nil, errors.New("username is required")
    }

    // Prepare the SQL statement.
    stmt, err := db.Prepare("SELECT * FROM users WHERE username = ?")
    if err != nil {
        return nil, err
    }
    defer stmt.Close()

    // Execute the SQL statement with the given username parameter.
    rows, err := stmt.Query(username)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    // Collect the query results into a slice of User objects.
    var users []User
    for rows.Next() {
        var u User
        err := rows.Scan(&u.Username, &u.Password)
        if err != nil {
            return nil, err
        }
        users = append(users, u)
    }

    return users, nil
}

在上面的示例中，我们定义了一个名为getUsers()的函数，该函数首先验证了输入的用户名是否为空，然后执行预编译的SQL语句，该语句将查询名为users的表中所有用户名为给定参数的用户信息。注意，我们使用了stmt.Query()

Ensuite, nous devons classer la pré-validation. Selon les types d'opérations courants, la pré-vérification peut être divisée dans les catégories suivantes :

1. Vérification de connexion
2. Vérification de l'insertion, de la modification, de la suppression et d'autres opérations
3. Vérification des paramètres de requête

Le premier type de pré-vérification est relativement simple. Dans le code ci-dessus, nous avons déjà vérifié la connexion. Si la connexion réussit, cela signifie qu'elle a réussi la vérification.

Le deuxième type de pré-vérification est généralement effectué avant l'insertion, la modification, la suppression et d'autres opérations. La méthode de vérification spécifique est déterminée en fonction des besoins réels. Voici un exemple simple : 🎜rrreee🎜Dans l'exemple ci-dessus, nous définissons une fonction appelée insertData(), qui vérifie d'abord si le nom d'utilisateur et le mot de passe saisis sont vides, puis appelle le fonction userExists() pour vérifier si le nom d'utilisateur existe déjà. Si le nom d'utilisateur existe déjà, cette fonction renverra un message d'erreur. Si toutes les validations réussissent, cette fonction effectue l'opération d'insertion. La fonction userExists() vérifie si le nom d'utilisateur donné existe déjà dans la base de données et renvoie true s'il existe, sinon elle renvoie false. 🎜🎜Le troisième type de pré-validation consiste à vérifier les paramètres lors de l'interrogation. Cette méthode est très utile car elle peut nous aider à prévenir les attaques par injection SQL. Voici un exemple : 🎜rrreee🎜 Dans l'exemple ci-dessus, nous définissons une fonction appelée getUsers(), qui vérifie d'abord si le nom d'utilisateur saisi est vide, puis exécute une instruction SQL de précompilation, qui interrogera l'utilisateur. informations sur tous les noms d'utilisateurs dans la table nommée users. Notez que nous utilisons la fonction stmt.Query() pour transmettre les paramètres de requête via le passage de paramètres. Cela empêche les paramètres d'être directement fusionnés dans les instructions de requête SQL, empêchant ainsi les attaques par injection SQL. 🎜🎜Résumé🎜🎜Cet article présente la méthode d'utilisation du langage Go pour effectuer la pré-vérification des opérations de données dans la base de données MySQL. Lors de l'exécution d'opérations sur la base de données MySQL, la pré-vérification est très importante. Elle peut nous aider à réduire l'apparition d'erreurs lors de l'exécution du programme et à améliorer la stabilité et la sécurité du programme. Nous pouvons diviser la pré-vérification en trois catégories : la vérification de la connexion, la vérification de l'insertion, de la modification, de la suppression et d'autres opérations, et la vérification des paramètres de requête. Dans les applications pratiques, nous pouvons personnaliser notre propre processus de pré-vérification selon les besoins pour améliorer la robustesse et la sécurité du programme. 🎜

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!