Utiliser MySQL en langage Go pour implémenter le traitement de données non relationnelles

Avec le développement rapide d'Internet, les bases de données non relationnelles (NoSQL) sont de plus en plus utilisées, et dans le langage Go, il existe également des méthodes non relationnelles de traitement des données. Cependant, pour certaines bases de données relationnelles traditionnelles, comme MySQL, on peut également utiliser certaines techniques pour implémenter des fonctions de traitement de données non relationnelles.

Cet article présentera les méthodes et techniques d'utilisation de MySQL pour implémenter le traitement de données non relationnelles en langage Go, y compris comment créer et concevoir une table non relationnelle, et démontrera à travers des exemples comment lire, écrire et renouveler. Dans ce processus, nous utiliserons l'une de ces bibliothèques : github.com/go-sql-driver/mysql.

1. Créer des tables non relationnelles

Pour la base de données MySQL, nous la considérons généralement comme une base de données relationnelle, nous devons donc concevoir les tables et maintenir la relation entre les tables. Mais parfois, nous devons stocker des données dans une structure non relationnelle, telle que les données au format JSON.

Dans MySQL, nous pouvons utiliser des champs de type JSON pour implémenter un stockage non relationnel. Par exemple, nous créons une table pour stocker les informations de l'utilisateur, qui contient un champ de type JSON "info" pour stocker les informations personnelles de l'utilisateur :

CREATE TABLE users (
   id INT(11) NOT NULL AUTO_INCREMENT,
   name VARCHAR(50) NOT NULL,
   info JSON NOT NULL,
   PRIMARY KEY (id)
);

Dans le code ci-dessus, nous créons une table nommée "users", elle contient trois champs : identifiant, nom et informations. Le type du champ d'information est JSON, qui est utilisé pour stocker les informations personnelles de l'utilisateur. Dans des applications pratiques, nous pouvons également utiliser d'autres types non relationnels, tels que BLOB, TEXT, etc.

2. Utilisez le langage Go pour vous connecter à la base de données MySQL

La connexion à la base de données MySQL en langage Go nécessite l'utilisation d'une bibliothèque tierce, dont la plus couramment utilisée est github.com/go-sql-driver/mysql. Tout d'abord, vous devez installer cette bibliothèque, qui peut être installée via la commande suivante :

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

Cette bibliothèque fournit un type sql.DB qui peut être utilisé pour les connexions et les opérations de base de données. Avant de nous connecter à la base de données, nous devons fournir quelques informations de configuration, comme suit :

dsn := "root:password@(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
db, err := sql.Open("mysql", dsn)
if err != nil {
   panic(err)
}
defer db.Close()

dsn est un nom de source de données utilisé pour se connecter à la base de données. Cela inclut le nom d'utilisateur, le mot de passe, l'adresse de l'hôte, le numéro de port, le nom de la base de données, la méthode de codage et d'autres informations. Dans le code ci-dessus, nous utilisons l'adresse de l'hôte local et le numéro de port 3306 par défaut, et remplaçons le nom d'utilisateur et le mot de passe par les valeurs correspondantes. Si la connexion réussit, la variable db contiendra une référence à la base de données MySQL à laquelle vous vous êtes connecté.

3. Go langage pour lire et écrire des données non relationnelles

Après la connexion à la base de données MySQL, nous pouvons utiliser le type sql.DB pour exécuter des requêtes SQL et obtenir les données associées. Pour les données non relationnelles, nous pouvons utiliser la fonction JSON de MySQL pour lire et écrire des champs de type JSON.

1. Écrire des données non relationnelles

Le code suivant montre comment écrire de nouvelles informations utilisateur dans la table utilisateurs :

info := `{
   "age": 23,
   "gender": "male",
   "email": "john@example.com"
}`
result, err := db.Exec("INSERT INTO users(name, info) VALUES(?, ?)", "John", info)
if err != nil {
   panic(err)
}
fmt.Printf("New user id: %d
", result.LastInsertId())

Dans cet exemple, nous définissons d'abord un caractère JSON contenant une chaîne d'informations utilisateur. Nous utilisons ensuite la fonction Exec pour exécuter l'instruction insert et transmettre les informations utilisateur en tant que paramètres dans l'instruction SQL. Une fois l'insertion réussie, nous obtenons et affichons l'ID du nouvel utilisateur.

2. Lecture de données non relationnelles

Ensuite, nous montrerons comment lire des données JSON stockées dans des champs non relationnels. Vous pouvez simplement obtenir une paire clé-valeur en JSON à l'aide de la fonction JSON_EXTRACT de MySQL. Le code suivant montre comment lire toutes les informations utilisateur dans la table des utilisateurs :

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

for rows.Next() {
   var id int
   var name string
   var info []byte
   err := rows.Scan(&id, &name, &info)
   if err != nil {
      panic(err)
   }
   var user map[string]interface{}
   err = json.Unmarshal(info, &user)
   if err != nil {
      panic(err)
   }
   fmt.Printf("ID: %d, Name: %s, Age: %f, Gender: %s, Email: %s
", id, name, user["age"], user["gender"], user["email"])
}

Dans cet exemple, nous utilisons d'abord la fonction db.Query pour interroger toutes les données de la table des utilisateurs. Ensuite, nous utilisons la fonction rows.Scan pour lire les champs ID, nom et informations de chaque ligne de données. Ensuite, nous convertissons la valeur du champ d'information en une variable utilisateur de type map[string]interface{} et utilisons la fonction json.Unmarshal pour l'analyse. Enfin, nous affichons l'identifiant, le nom, l'âge, le sexe et l'e-mail de chaque utilisateur.

3. Mise à jour des données non relationnelles

Enfin, nous montrons comment mettre à jour les données stockées dans des champs non relationnels. La fonction JSON_SET de MySQL peut être utilisée pour mettre à jour dynamiquement une paire clé-valeur dans un champ JSON. Le code ci-dessous montre comment mettre à jour l'adresse e-mail de l'utilisateur avec une nouvelle valeur :

result, err := db.Exec("UPDATE users SET info=JSON_SET(info, '$.email', ?) WHERE name=?", "john_doe@example.com", "John")
if err != nil {
   panic(err)
}
rowsAffected, err := result.RowsAffected()
if err != nil {
   panic(err)
}
fmt.Printf("Rows affected: %d
", rowsAffected)

Dans cet exemple, nous utilisons la fonction Exec pour exécuter l'instruction de mise à jour et transmettons la nouvelle adresse e-mail en tant que paramètre à la fonction JSON_SET dans l'instruction SQL. . Nous utilisons la clause WHERE pour spécifier le nom de l'utilisateur à mettre à jour. Une fois la mise à jour réussie, nous vérifions et affichons le nombre de lignes affectées.

4. Résumé

En langage Go, nous pouvons utiliser la base de données MySQL pour stocker des données non relationnelles. En utilisant des champs de type JSON, nous pouvons facilement stocker et traiter des données au format JSON. Cet article présente des méthodes et des techniques pour créer des tables non relationnelles, se connecter à des bases de données MySQL, lire et écrire des données non relationnelles, ainsi que des exemples d'utilisation des fonctions JSON_EXTRACT et JSON_SET pour les opérations sur les données. Ils peuvent vous aider à mieux utiliser MySQL pour traiter des données non relationnelles dans des applications pratiques.

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!