Gestion des données JSON dans MySQL

MySQLBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez à utiliser efficacement le type de données JSON dans MySQL. Vous effectuerez des opérations fondamentales telles que l'insertion de documents JSON, l'interrogation de champs spécifiques à l'aide de fonctions comme JSON_EXTRACT et de l'opérateur ->>, la modification de données dans une colonne JSON, et l'optimisation des requêtes en créant un index sur une propriété JSON.

Tout au long de ce laboratoire, vous vous connecterez à un serveur MySQL, créerez une base de données et une table dédiées, puis effectuerez une série de tâches pratiques pour développer vos compétences dans la gestion des données JSON dans un contexte de base de données relationnelle.

Se connecter à MySQL et créer la base de données

Dans cette première étape, vous allez vous connecter au serveur MySQL et configurer la base de données et la table nécessaires pour le laboratoire.

Tout d'abord, ouvrez le terminal depuis votre bureau.

Connectez-vous au serveur MySQL avec les privilèges de l'utilisateur root. Dans cet environnement de laboratoire, sudo vous permet de vous connecter sans mot de passe.

sudo mysql -u root

Une fois connecté, l'invite de commande changera en mysql>, indiquant que vous êtes dans le shell MySQL.

Ensuite, créez une nouvelle base de données nommée jsondb. La clause IF NOT EXISTS garantit que la commande s'exécute sans erreur si la base de données existe déjà.

CREATE DATABASE IF NOT EXISTS jsondb;

Maintenant, basculez vers votre base de données nouvellement créée pour en faire la base de données active pour les commandes suivantes.

USE jsondb;

Enfin, créez une table nommée products. Cette table comprendra une colonne avec le type de données JSON pour stocker des informations détaillées sur les produits.

CREATE TABLE IF NOT EXISTS products (
    id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(255),
    product_details JSON
);

Cette instruction définit une table avec trois colonnes :

  • id : un entier unique et auto-incrémenté pour chaque enregistrement.
  • product_name : une chaîne de caractères pour le nom du produit.
  • product_details : une colonne JSON pour contenir des données structurées.

Vous avez configuré avec succès la base de données et la table nécessaires. Laissez le shell MySQL ouvert pour la prochaine étape.

Insérer et interroger des données JSON

La table étant créée, vous allez maintenant insérer un enregistrement contenant un document JSON, puis effectuer une requête de base pour le récupérer.

Dans le même shell MySQL, exécutez l'instruction INSERT suivante pour ajouter un nouveau produit.

INSERT INTO products (product_name, product_details) VALUES (
    'Laptop',
    '{
        "brand": "Dell",
        "model": "XPS 13",
        "specs": {
            "processor": "Intel Core i7",
            "memory": "16GB",
            "storage": "512GB SSD"
        },
        "price": 1200
    }'
);

Cette commande insère un enregistrement de type 'Laptop'. La colonne product_details est remplie avec un objet JSON qui inclut des données imbriquées, telles que specs.

Pour confirmer que les données ont été insérées correctement, interrogez la table products pour afficher son contenu.

SELECT * FROM products;

La sortie devrait afficher la ligne que vous venez d'insérer. Notez comment les données JSON sont stockées dans la colonne product_details.

+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
| id | product_name | product_details                                                                                                                |
+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
|  1 | Laptop       | {"brand": "Dell", "model": "XPS 13", "price": 1200, "specs": {"memory": "16GB", "storage": "512GB SSD", "processor": "Intel Core i7"}} |
+----+--------------+--------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

Vous avez inséré avec succès un enregistrement contenant des données JSON. Dans la prochaine étape, vous apprendrez à extraire des informations spécifiques de cet objet JSON.

Extraire des données des champs JSON

Stocker des données au format JSON est utile, mais il faut aussi pouvoir interroger des champs individuels à l'intérieur. Dans cette étape, vous utiliserez la fonction JSON_EXTRACT et JSON_UNQUOTE pour extraire des valeurs spécifiques de la colonne product_details.

La fonction JSON_EXTRACT vous permet de sélectionner une valeur à partir d'un document JSON en utilisant une expression de chemin (path expression). Le chemin commence par $ pour représenter la racine du document.

Extraisons la brand (marque) de l'ordinateur portable.

SELECT JSON_EXTRACT(product_details, '$.brand') AS brand FROM products WHERE product_name = 'Laptop';

Cette requête renvoie la marque, mais remarquez que le résultat est une chaîne JSON, qui inclut des guillemets doubles.

+--------+
| brand  |
+--------+
| "Dell" |
+--------+
1 row in set (0.00 sec)

Pour un résultat plus propre, vous pouvez utiliser JSON_UNQUOTE combiné avec JSON_EXTRACT. Cette combinaison extrait la valeur et supprime les guillemets, renvoyant une chaîne standard.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.brand')) AS brand FROM products WHERE product_name = 'Laptop';

La sortie est maintenant le texte brut Dell.

+-------+
| brand |
+-------+
| Dell  |
+-------+
1 row in set (0.00 sec)

Vous pouvez également utiliser des expressions de chemin pour accéder aux valeurs dans des objets imbriqués. Pour obtenir le processor (processeur) de l'objet specs, utilisez le chemin $.specs.processor.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.specs.processor')) AS processor FROM products WHERE product_name = 'Laptop';

Ceci extraira correctement la valeur imbriquée.

+-----------------+
| processor       |
+-----------------+
| Intel Core i7   |
+-----------------+
1 row in set (0.00 sec)

Ces fonctions sont également utiles dans les clauses WHERE pour filtrer les lignes. Pour trouver tous les produits dont le prix est supérieur à 1000, vous devez CAST (convertir) la valeur JSON extraite en un type numérique pour la comparaison.

SELECT product_name, JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS price FROM products WHERE CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED) > 1000;

Cette requête démontre comment filtrer des enregistrements basés sur une valeur numérique à l'intérieur d'un champ JSON.

+--------------+-------+
| product_name | price |
+--------------+-------+
| Laptop       | 1200  |
+--------------+-------+
1 row in set (0.00 sec)

Vous savez maintenant comment extraire et filtrer des données basées sur des champs JSON.

Mettre à jour et ajouter des champs JSON

Les données changent avec le temps, et vous avez besoin d'un moyen de modifier les documents JSON stockés dans votre base de données. Dans cette étape, vous utiliserez la fonction JSON_SET pour mettre à jour des valeurs existantes et ajouter de nouvelles paires clé-valeur.

La fonction JSON_SET modifie un document JSON en prenant comme arguments la colonne cible, un chemin vers le champ, et la nouvelle valeur.

Tout d'abord, mettons à jour le price (prix) de l'ordinateur portable de 1200 à 1250.

UPDATE products
SET product_details = JSON_SET(product_details, '$.price', 1250)
WHERE product_name = 'Laptop';

Pour vérifier le changement, interrogez à nouveau le prix.

SELECT JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS price FROM products WHERE product_name = 'Laptop';

La sortie devrait maintenant afficher le nouveau prix.

+-------+
| price |
+-------+
| 1250  |
+-------+
1 row in set (0.00 sec)

Si le chemin spécifié n'existe pas, JSON_SET ajoutera la nouvelle clé et sa valeur. Ajoutons une propriété color (couleur) au produit.

UPDATE products
SET product_details = JSON_SET(product_details, '$.color', 'Silver')
WHERE product_name = 'Laptop';

Maintenant, interrogez l'objet JSON complet pour voir le champ nouvellement ajouté.

SELECT product_details FROM products WHERE product_name = 'Laptop';

La sortie affichera le document product_details, qui inclut maintenant la propriété color.

+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| product_details                                                                                                                                     |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| {"brand": "Dell", "color": "Silver", "model": "XPS 13", "price": 1250, "specs": {"memory": "16GB", "storage": "512GB SSD", "processor": "Intel Core i7"}} |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

Vous avez réussi à modifier et à étendre un document JSON au sein d'une table.

Créer un index sur une propriété JSON

Pour les grandes tables, l'interrogation des champs JSON peut être lente. Pour améliorer les performances, vous pouvez créer un index sur une valeur extraite d'une colonne JSON. Dans MariaDB, cela est réalisé en ajoutant d'abord une colonne virtuelle basée sur le champ JSON, puis en créant un index sur cette colonne virtuelle.

Dans cette étape, vous allez créer une colonne virtuelle pour la propriété price et l'indexer pour accélérer les requêtes basées sur le prix.

Tout d'abord, ajoutez une colonne virtuelle qui extrait le prix des données JSON :

ALTER TABLE products ADD COLUMN price_virtual INT AS (CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED)) STORED;

Cette commande ajoute une colonne virtuelle nommée price_virtual qui calcule et stocke automatiquement la valeur du prix à partir des données JSON.

Créez maintenant un index sur cette colonne virtuelle :

CREATE INDEX idx_product_price ON products (price_virtual);

Cette approche permet à MariaDB de rechercher efficacement des lignes basées sur le prix numérique en utilisant la colonne virtuelle indexée.

Pour confirmer que l'index a été créé, utilisez la commande SHOW INDEXES.

SHOW INDEXES FROM products;

La sortie listera tous les index de la table products, y compris votre nouvel index idx_product_price.

+----------+------------+-------------------+...
| Table    | Non_unique | Key_name          |...
+----------+------------+-------------------+...
| products |          0 | PRIMARY           |...
| products |          1 | idx_product_price |...
+----------+------------+-------------------+...

La partie la plus importante est de vérifier si l'optimiseur utilise l'index. Vous pouvez le faire avec la commande EXPLAIN.

EXPLAIN SELECT product_name FROM products WHERE price_virtual > 1200;

Dans la sortie de EXPLAIN, regardez les colonnes possible_keys et key. Vous devriez voir idx_product_price listé, confirmant que MariaDB utilise votre index pour exécuter la requête efficacement.

Vous pouvez également interroger en utilisant l'expression JSON d'origine, et l'optimiseur de MariaDB devrait toujours être capable d'utiliser l'index sur la colonne virtuelle :

EXPLAIN SELECT product_name FROM products WHERE CAST(JSON_UNQUOTE(JSON_EXTRACT(product_details, '$.price')) AS SIGNED) > 1200;

Vous avez réussi à créer une colonne virtuelle et à l'indexer pour optimiser les requêtes sur les propriétés JSON.

Vous pouvez maintenant quitter le shell MySQL.

exit

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique de la gestion des données JSON dans MariaDB. Vous avez appris le flux de travail complet, de la configuration de la structure de la base de données à l'exécution d'opérations avancées.

Vous avez réussi à insérer des données JSON structurées, à interroger des champs spécifiques à l'aide de JSON_EXTRACT et JSON_UNQUOTE, et à filtrer des enregistrements en fonction des valeurs contenues dans le document JSON. Vous vous êtes également exercé à modifier ces données avec JSON_SET pour mettre à jour et ajouter de nouvelles propriétés. Enfin, vous avez appris une technique d'optimisation clé en créant une colonne virtuelle pour une propriété JSON et en l'indexant pour améliorer les performances des requêtes.

Ces compétences sont précieuses pour concevoir des schémas de base de données flexibles et gérer efficacement les données semi-structurées dans MariaDB.