Manejo de Datos JSON en MySQL

MySQLBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderá a utilizar eficazmente el tipo de dato JSON en MySQL. Realizará operaciones fundamentales como la inserción de documentos JSON, la consulta de campos específicos utilizando funciones como JSON_EXTRACT y el operador ->>, la modificación de datos dentro de una columna JSON, y la optimización de consultas mediante la creación de un índice sobre una propiedad JSON.

A lo largo de este laboratorio, se conectará a un servidor MySQL, creará una base de datos y una tabla dedicadas, y luego realizará una serie de tareas prácticas para desarrollar sus habilidades en la gestión de datos JSON dentro de un contexto de base de datos relacional.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 93%. Ha recibido una tasa de reseñas positivas del 77% por parte de los estudiantes.

Conectar a MySQL y Crear la Base de Datos

En este primer paso, se conectará al servidor MySQL y configurará la base de datos y la tabla necesarias para el laboratorio.

Primero, abra la terminal desde su escritorio.

Conéctese al servidor MySQL con privilegios de usuario root. En este entorno de laboratorio, sudo le permite conectarse sin contraseña.

sudo mysql -u root

Una vez conectado, el prompt del comando cambiará a mysql>, indicando que se encuentra en el shell de MySQL.

A continuación, cree una nueva base de datos llamada jsondb. La cláusula IF NOT EXISTS asegura que el comando se ejecute sin errores si la base de datos ya existe.

CREATE DATABASE IF NOT EXISTS jsondb;

Ahora, cambie a su base de datos recién creada para que sea la base de datos activa para los comandos subsiguientes.

USE jsondb;

Finalmente, cree una tabla llamada products. Esta tabla incluirá una columna con el tipo de dato JSON para almacenar información detallada de los productos.

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

Esta sentencia define una tabla con tres columnas:

  • id: Un entero único y autoincremental para cada registro.
  • product_name: Una cadena de texto para el nombre del producto.
  • product_details: Una columna JSON para almacenar datos estructurados.

Ha configurado con éxito la base de datos y la tabla necesarias. Mantenga abierto el shell de MySQL para el siguiente paso.

Insertar y Consultar Datos JSON

Con la tabla creada, ahora insertará un registro que contiene un documento JSON y luego realizará una consulta básica para recuperarlo.

En el mismo shell de MySQL, ejecute la siguiente sentencia INSERT para agregar un nuevo producto.

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
    }'
);

Este comando inserta un registro de 'Laptop'. La columna product_details se rellena con un objeto JSON que incluye datos anidados, como specs.

Para confirmar que los datos se insertaron correctamente, consulte la tabla products para ver su contenido.

SELECT * FROM products;

La salida debería mostrar la fila que acaba de insertar. Observe cómo se almacenan los datos JSON en la columna 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)

Ha insertado con éxito un registro con datos JSON. En el siguiente paso, aprenderá a extraer información específica de este objeto JSON.

Extraer Datos de Campos JSON

Almacenar datos en formato JSON es útil, pero también necesita poder consultar campos individuales dentro de él. En este paso, utilizará la función JSON_EXTRACT y JSON_UNQUOTE para extraer valores específicos de la columna product_details.

La función JSON_EXTRACT le permite seleccionar un valor de un documento JSON utilizando una expresión de ruta. La ruta comienza con $ para representar la raíz del documento.

Extraigamos la brand (marca) de la laptop.

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

Esta consulta devuelve la marca, pero observe que el resultado es una cadena JSON, que incluye comillas dobles.

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

Para obtener un resultado más limpio, puede usar JSON_UNQUOTE combinado con JSON_EXTRACT. Esta combinación extrae el valor y elimina las comillas, devolviendo una cadena estándar.

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

La salida ahora es el texto plano Dell.

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

También puede usar expresiones de ruta para acceder a valores en objetos anidados. Para obtener el processor (procesador) del objeto specs, use la ruta $.specs.processor.

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

Esto extraerá correctamente el valor anidado.

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

Estas funciones también son útiles en las cláusulas WHERE para filtrar filas. Para encontrar todos los productos con un precio superior a 1000, debe CAST (convertir) el valor JSON extraído a un tipo numérico para la comparación.

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;

Esta consulta demuestra cómo filtrar registros basándose en un valor numérico dentro de un campo JSON.

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

Ahora sabe cómo extraer y filtrar datos basándose en campos JSON.

Actualizar y Añadir Campos JSON

Los datos cambian con el tiempo y necesita una forma de modificar los documentos JSON almacenados en su base de datos. En este paso, utilizará la función JSON_SET para actualizar valores existentes y añadir nuevos pares clave-valor.

La función JSON_SET modifica un documento JSON tomando como argumentos la columna de destino, una ruta al campo y el nuevo valor.

Primero, actualicemos el price (precio) de la laptop de 1200 a 1250.

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

Para verificar el cambio, consulte el precio nuevamente.

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

La salida ahora debería mostrar el nuevo precio.

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

Si la ruta especificada no existe, JSON_SET añadirá la nueva clave y valor. Añadamos una propiedad color (color) al producto.

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

Ahora, consulte el objeto JSON completo para ver el campo recién añadido.

SELECT product_details FROM products WHERE product_name = 'Laptop';

La salida mostrará el documento product_details, que ahora incluye la propiedad 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)

Ha modificado y ampliado con éxito un documento JSON dentro de una tabla.

Crear un Índice en una Propiedad JSON

Para tablas grandes, consultar campos JSON puede ser lento. Para mejorar el rendimiento, puede crear un índice en un valor extraído de una columna JSON. En MariaDB, esto se logra primero añadiendo una columna virtual basada en el campo JSON, y luego creando un índice en esa columna virtual.

En este paso, creará una columna virtual para la propiedad price y luego la indexará para acelerar las consultas basadas en el precio.

Primero, añada una columna virtual que extraiga el precio de los datos JSON:

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

Este comando añade una columna virtual llamada price_virtual que calcula y almacena automáticamente el valor del precio de los datos JSON.

Ahora cree un índice en esta columna virtual:

CREATE INDEX idx_product_price ON products (price_virtual);

Este enfoque permite a MariaDB buscar eficientemente filas basándose en el precio numérico utilizando la columna virtual indexada.

Para confirmar que se creó el índice, utilice el comando SHOW INDEXES.

SHOW INDEXES FROM products;

La salida listará todos los índices en la tabla products, incluyendo su nuevo idx_product_price.

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

La parte más importante es ver si el optimizador utiliza el índice. Puede comprobarlo con el comando EXPLAIN.

EXPLAIN SELECT product_name FROM products WHERE price_virtual > 1200;

En la salida de EXPLAIN, observe las columnas possible_keys y key. Debería ver idx_product_price listado, confirmando que MariaDB está utilizando su índice para ejecutar la consulta de manera eficiente.

También puede consultar utilizando la expresión JSON original, y el optimizador de MariaDB aún debería poder utilizar el índice en la columna virtual:

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

Ha creado con éxito una columna virtual y la ha indexado para optimizar las consultas de propiedades JSON.

Ahora puede salir del shell de MySQL.

exit

Resumen

En este laboratorio, ha adquirido experiencia práctica en el manejo de datos JSON en MariaDB. Aprendió el flujo de trabajo completo, desde la configuración de la estructura de la base de datos hasta la realización de operaciones avanzadas.

Insertó con éxito datos JSON estructurados, consultó campos específicos utilizando JSON_EXTRACT y JSON_UNQUOTE, y filtró registros basándose en valores dentro del documento JSON. También practicó la modificación de estos datos con JSON_SET para actualizar y añadir nuevas propiedades. Finalmente, aprendió una técnica de optimización clave al crear una columna virtual para una propiedad JSON y indexarla para mejorar el rendimiento de las consultas.

Estas habilidades son valiosas para diseñar esquemas de bases de datos flexibles y gestionar eficientemente datos semiestructurados en MariaDB.