sql >> Base de Datos >  >> RDS >> Mysql

Cómo trabajar con subconsultas de MySQL

Una subconsulta es una consulta SQL (lenguaje de consulta estructurado) que está anidada dentro de otra consulta SQL. El comando en el que se anida la subconsulta se denomina consulta principal. Las subconsultas se utilizan para preprocesar los datos que se utilizan en la consulta principal. Las subconsultas se pueden aplicar en SELECT , INSERT , UPDATE y DELETE operaciones.

Cuando se ejecutan subconsultas, la subconsulta se procesa primero antes que la consulta principal. Al crear aplicaciones MySQL, el uso de subconsultas ofrece varias ventajas:

  • Dividen las declaraciones SQL en unidades lógicas simples, lo que puede hacerlas más fáciles de entender y mantener. En otras palabras, las subconsultas ayudan a aislar partes complejas de las consultas.
  • Eliminan la necesidad de usar complejos UNION declaraciones y JOIN declaraciones.
  • Se utilizan para hacer cumplir la integridad referencial en un escenario donde no se implementan claves foráneas.
  • Ayudan a los desarrolladores a codificar la lógica comercial en las consultas de MySQL.

En esta guía aprenderá:

  • Cómo usar una subconsulta correlacionada
  • Cómo usar una subconsulta correlacionada en un operador de comparación
  • Cómo usar una subconsulta como una tabla derivada

Antes de comenzar

Para seguir esta guía, asegúrese de tener lo siguiente:

  1. Si aún no lo ha hecho, cree una cuenta de Linode y una instancia de cómputo. Consulte nuestras guías Introducción a Linode y Creación de una instancia informática.

  2. Siga nuestra guía de configuración y protección de una instancia informática para actualizar su sistema. También puede establecer la zona horaria, configurar su nombre de host, crear una cuenta de usuario limitada y fortalecer el acceso SSH.

  3. El software del servidor MySQL (o MariaDB) instalado en su Linode. Consulte la sección MySQL, que contiene guías que describen cómo instalar MySQL en varias distribuciones de Linux.

Configurando la base de datos

Para comprender cómo funcionan las subconsultas, primero cree una base de datos de muestra. Esta base de datos de muestra se usa para ejecutar las diferentes consultas de ejemplo en esta guía:

  1. SSH a su servidor e inicie sesión en MySQL como root:

     mysql -u root -p

    Cuando se le solicite, ingrese la contraseña raíz de su servidor MySQL y presione Enter continuar. Tenga en cuenta que la contraseña raíz de su servidor MySQL no es la misma que la contraseña raíz de su Linode.

    Nota

    Si no se acepta su contraseña, es posible que deba ejecutar el comando anterior con sudo :

    sudo mysql -u root -p

  2. Si se acepta su contraseña, debería ver el aviso de MySQL:

    
mysql >
    Nota

    Si está utilizando MariaDB, es posible que vea un mensaje como el siguiente:

    
MariaDB [(none)]>

  3. Para crear una base de datos de muestra llamada test_db , ejecuta:

    CREATE DATABASE test_db;

    Debería ver este resultado, que confirma que la base de datos se creó correctamente:

    
Query OK, 1 row affected (0.01 sec)

  4. Cambiar a test_db base de datos:

    USE test_db;

    Deberías ver este resultado:

    
Database changed

  5. Ha creado el test_db y lo seleccionó. A continuación, cree una tabla llamada customers :

     CREATE TABLE customers
 (
 customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
 customer_name VARCHAR(50)
 ) ENGINE = InnoDB;

    Deberías ver este resultado:

    
Query OK, 0 rows affected (0.03 sec)

  6. Agregue algunos registros a los customers mesa. Ejecute el siguiente INSERT comandos uno por uno:

    INSERT INTO customers(customer_name) VALUES ('JOHN PAUL');
INSERT INTO customers(customer_name) VALUES ('PETER DOE');
INSERT INTO customers(customer_name) VALUES ('MARY DOE');
INSERT INTO customers(customer_name) VALUES ('CHRISTINE JAMES');
INSERT INTO customers(customer_name) VALUES ('MARK WELL');
INSERT INTO customers(customer_name) VALUES ('FRANK BRIAN');

    Esta salida se muestra después de insertar cada registro:

    
Query OK, 1 row affected (0.00 sec)
...

  7. Verifique que la información de los clientes se haya insertado en la base de datos. Ejecute este SELECT comando:

    SELECT * FROM customers;

    Debería ver esta lista de clientes:

    
+-------------+-----------------+
| customer_id | customer_name   |
+-------------+-----------------+
|           1 | JOHN PAUL       |
|           2 | PETER DOE       |
|           3 | MARY DOE        |
|           4 | CHRISTINE JAMES |
|           5 | MARK WELL       |
|           6 | FRANK BRIAN     |
+-------------+-----------------+
6 rows in set (0.00 sec)

  8. Crear una sales mesa. Esta tabla usa la columna customer_id para hacer referencia a los customers tabla:

    CREATE TABLE sales
(
order_id BIGINT PRIMARY KEY AUTO_INCREMENT,
customer_id BIGINT,
sales_amount DECIMAL(17,2)
) ENGINE = InnoDB;

    Aparece esta salida:

    
Query OK, 0 rows affected (0.03 sec)

  9. A continuación, complete las sales tabla con algunos registros. Ejecute el siguiente INSERT comandos uno por uno:

    INSERT INTO sales (customer_id, sales_amount) VALUES ('1','25.75');
INSERT INTO sales (customer_id, sales_amount) VALUES ('2','85.25');
INSERT INTO sales (customer_id, sales_amount) VALUES ('5','3.25');
INSERT INTO sales (customer_id, sales_amount) VALUES ('4','200.75');
INSERT INTO sales (customer_id, sales_amount) VALUES ('5','88.10');
INSERT INTO sales (customer_id, sales_amount) VALUES ('1','100.00');
INSERT INTO sales (customer_id, sales_amount) VALUES ('2','45.00');
INSERT INTO sales (customer_id, sales_amount) VALUES ('4','15.80');

    Esta salida se muestra después de insertar cada registro:

    
Query OK, 1 row affected (0.01 sec)
...

  10. Verifica los datos en las sales mesa. Ejecute este SELECT comando:

    SELECT * FROM sales;

    Ahora debería mostrarse esta lista de datos de ventas:

    
+----------+-------------+--------------+
| order_id | customer_id | sales_amount |
+----------+-------------+--------------+
|        1 |           1 |        25.75 |
|        2 |           2 |        85.25 |
|        3 |           5 |         3.25 |
|        4 |           4 |       200.75 |
|        5 |           5 |        88.10 |
|        6 |           1 |       100.00 |
|        7 |           2 |        45.00 |
|        8 |           4 |        15.80 |
+----------+-------------+--------------+
8 rows in set (0.00 sec)

Después de configurar la base de datos y las tablas relacionadas, ahora puede implementar las diferentes subconsultas en MySQL.

Cómo usar una subconsulta correlacionada

Una subconsulta correlacionada es un tipo de consulta anidada que utiliza los valores de una consulta principal. Este tipo de consultas hacen referencia a la consulta principal con una columna. La consulta anidada se ejecuta una vez por cada fila de la consulta principal.

El siguiente ejemplo presenta una consulta que selecciona a todos los clientes. Dentro de la consulta, hay una subconsulta correlacionada que obtiene el monto total de las ventas de cada cliente de las sales mesa.

  1. Ejecute la consulta de ejemplo:

    SELECT
customer_id,
customer_name,
(SELECT SUM(sales_amount)
FROM sales WHERE customer_id = customers.customer_id) as total_sales_amount
FROM
customers;

    En este ejemplo, la subconsulta es SELECT SUM(sales_amount) FROM sales WHERE customer_id = customers.customer_id , que aparece entre paréntesis.

    Aparece una lista de las ventas totales realizadas por los clientes:

    
+-------------+-----------------+--------------------+
| customer_id | customer_name   | total_sales_amount |
+-------------+-----------------+--------------------+
|           1 | JOHN PAUL       |             125.75 |
|           2 | PETER DOE       |             130.25 |
|           3 | MARY DOE        |               NULL |
|           4 | CHRISTINE JAMES |             216.55 |
|           5 | MARK WELL       |              91.35 |
|           6 | FRANK BRIAN     |               NULL |
+-------------+-----------------+--------------------+
6 rows in set (0.00 sec)

    El resultado anterior de la subconsulta correlacionada puede brindarle una lista resumida de los pedidos de los clientes. Tenga en cuenta que desde customer_id s 3 y 6 no tienen ningún registro asociado en la tabla de ventas, su total_sales_amount es NULL .

  2. Una forma más elegante de presentar esta lista es devolver 0 en lugar de NULL para los clientes con cero ventas. Para hacer esto, incluya la salida generada por la subconsulta con un IFNULL(expression, 0) declaración. Ejecute este comando actualizado:

     SELECT
 customer_id,
 customer_name,
 IFNULL((SELECT SUM(sales_amount)
 FROM sales WHERE customer_id = customers.customer_id), 0) as total_sales_amount
 FROM
 customers;

    Aparece el siguiente resultado. MySQL devuelve 0.00 para todas las filas que de otro modo habrían devuelto NULL valores.

    
+-------------+-----------------+--------------------+
| customer_id | customer_name   | total_sales_amount |
+-------------+-----------------+--------------------+
|           1 | JOHN PAUL       |             125.75 |
|           2 | PETER DOE       |             130.25 |
|           3 | MARY DOE        |               0.00 |
|           4 | CHRISTINE JAMES |             216.55 |
|           5 | MARK WELL       |              91.35 |
|           6 | FRANK BRIAN     |               0.00 |
+-------------+-----------------+--------------------+
6 rows in set (0.00 sec)

    Este enfoque ayuda a garantizar que la salida no dañe ningún otro cálculo en los registros.

Cómo usar una subconsulta correlacionada en un operador de comparación

Las subconsultas son útiles para mover la lógica empresarial al nivel de consulta de la base de datos. Los siguientes casos de uso comercial presentan subconsultas correlacionadas ubicadas dentro de la cláusula WHERE de una consulta principal:

  • Considere un escenario en el que le gustaría obtener una lista de todos los clientes registrados en la base de datos que no tienen ventas asociadas. Puede usar una subconsulta junto con el operador de comparación de MySQL NOT IN y recuperar estos clientes:

      SELECT
  customer_id,
  customer_name
  FROM
  customers
  WHERE customer_id NOT IN (SELECT customer_id FROM sales);

    En este ejemplo, la subconsulta es SELECT customer_id FROM sales , que aparece entre paréntesis. El comando SQL anterior genera una lista de dos clientes que no se encuentran en la tabla de ventas:

    
+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
|           3 | MARY DOE      |
|           6 | FRANK BRIAN   |
+-------------+---------------+
2 rows in set (0.00 sec)

    En un entorno de producción, puede usar este tipo de conjunto de registros para tomar mejores decisiones comerciales. Por ejemplo, puede crear una secuencia de comandos utilizando otro lenguaje como PHP o Python para enviar un correo electrónico a estos clientes y preguntarles si tienen algún problema al realizar un pedido.

  • Otro caso de uso es la limpieza de datos. Por ejemplo, puede utilizar una subconsulta para eliminar clientes que nunca han realizado un pedido:

      DELETE
  FROM
  customers
  WHERE customer_id NOT IN (SELECT customer_id FROM sales);

    El comando SQL anterior elimina los dos clientes y genera lo siguiente:

    
Query OK, 2 rows affected (0.01 sec)

    Si ejecuta un comando para enumerar todos los clientes nuevamente, estos clientes ya no deberían aparecer en la tabla:

      SELECT *
  FROM
  customers;

    El siguiente resultado confirma que se eliminaron los clientes sin pedidos asociados:

    
+-------------+-----------------+
| customer_id | customer_name   |
+-------------+-----------------+
|           1 | JOHN PAUL       |
|           2 | PETER DOE       |
|           4 | CHRISTINE JAMES |
|           5 | MARK WELL       |
+-------------+-----------------+
4 rows in set (0.00 sec)

Cómo usar una subconsulta como una tabla derivada

Cuando se utilizan subconsultas en FROM cláusula de una consulta principal, se denominan tablas derivadas . Son muy importantes cuando se implementan consultas complejas que de otro modo requerirían un MySQL VIEW , JOIN , o UNION cláusula. Existe una tabla derivada en la consulta que la creó y no se guarda de forma permanente en la base de datos.

Cuando las subconsultas se utilizan como tablas derivadas, aíslan las diferentes partes de la instrucción SQL. En otras palabras, la subconsulta proporciona una expresión simplificada de una tabla que se puede utilizar dentro del ámbito de la consulta principal.

Nota Recuerde, cada tabla derivada debe tener un alias.

Ejecute el siguiente comando para crear una subconsulta de tabla derivada que tenga el alias order_summary :

SELECT customer_id
FROM
    (
    SELECT
    customer_id,
    count(order_id) as total_orders
    FROM sales
    group by customer_id
    ) as order_summary
WHERE order_summary.total_orders > 1;
Nota

En este comando, la subconsulta aparece entre paréntesis como:

SELECT
customer_id,
count(order_id) as total_orders
FROM sales
group by customer_id

El comando anterior consulta la tabla de ventas para determinar los clientes con más de 1 pedido. Cuando ejecuta la consulta, aparece este resultado:


+-------------+
| customer_id |
+-------------+
|           1 |
|           2 |
|           5 |
|           4 |
+-------------+
4 rows in set (0.00 sec)

La lista anterior muestra cuatro customer_id s que tienen más de un pedido. Como ejemplo de caso de uso comercial, puede usar una consulta de este tipo en un script que recompensa a los clientes con una bonificación en su próxima compra.

Más información

Es posible que desee consultar los siguientes recursos para obtener información adicional sobre este tema. Si bien estos se proporcionan con la esperanza de que sean útiles, tenga en cuenta que no podemos garantizar la precisión o la puntualidad de los materiales alojados externamente.

  • Subconsultas MySQL