Escribir una Subconsulta en una Cláusula WHERE
En este paso, aprenderás a usar una subconsulta dentro de la cláusula WHERE de una consulta SQL. Una subconsulta, también conocida como consulta interna o consulta anidada, es una consulta incrustada dentro de otra consulta. Las subconsultas se utilizan para devolver datos que se utilizarán en la consulta principal como una condición para restringir aún más los datos que se recuperarán.
Entendiendo las Subconsultas en la Cláusula WHERE
Una subconsulta en la cláusula WHERE se utiliza normalmente para comparar el valor de una columna con el resultado de la subconsulta. La subconsulta se ejecuta primero, y su resultado es entonces utilizado por la consulta externa.
Sintaxis Básica:
SELECT column1, column2
FROM table_name
WHERE column_name IN (SELECT column_name FROM another_table WHERE condition);
Aquí, la subconsulta (SELECT column_name FROM another_table WHERE condition) devuelve un conjunto de valores. La consulta externa entonces selecciona filas de table_name donde column_name está en ese conjunto.
Escenario:
Supongamos que tienes dos tablas: employees (empleados) y departments (departamentos). La tabla employees contiene información sobre los empleados, incluyendo su employee_id (id_empleado), employee_name (nombre_empleado) y department_id (id_departamento). La tabla departments contiene información sobre los departamentos, incluyendo su department_id (id_departamento) y department_name (nombre_departamento).
Queremos encontrar a todos los empleados que trabajan en el departamento de 'Sales' (Ventas).
Paso 1: Crear las Tablas e Insertar Datos
Primero, conéctate a la base de datos PostgreSQL usando el usuario postgres:
sudo -u postgres psql
A continuación, crea la tabla departments:
CREATE TABLE departments (
department_id SERIAL PRIMARY KEY,
department_name VARCHAR(50)
);
Inserta algunos datos de ejemplo en la tabla departments:
INSERT INTO departments (department_name) VALUES
('Sales'),
('Marketing'),
('Engineering');
Ahora, crea la tabla employees:
CREATE TABLE employees (
employee_id SERIAL PRIMARY KEY,
employee_name VARCHAR(50),
department_id INTEGER REFERENCES departments(department_id)
);
Inserta algunos datos de ejemplo en la tabla employees:
INSERT INTO employees (employee_name, department_id) VALUES
('Alice', 1),
('Bob', 2),
('Charlie', 1),
('David', 3),
('Eve', 2);
Paso 2: Escribir la Subconsulta
Ahora, escribamos la consulta para encontrar a todos los empleados que trabajan en el departamento de 'Sales' (Ventas) usando una subconsulta en la cláusula WHERE.
SELECT employee_name
FROM employees
WHERE department_id IN (SELECT department_id FROM departments WHERE department_name = 'Sales');
Explicación:
- La subconsulta
(SELECT department_id FROM departments WHERE department_name = 'Sales') selecciona el department_id (id_departamento) de la tabla departments donde el department_name (nombre_departamento) es 'Sales' (Ventas). En este caso, devolverá 1.
- La consulta externa entonces selecciona el
employee_name (nombre_empleado) de la tabla employees donde el department_id (id_departamento) está en el conjunto devuelto por la subconsulta (que es solo 1).
Paso 3: Ejecutar la Consulta y Ver los Resultados
Ejecuta la consulta en tu terminal psql. Deberías ver la siguiente salida:
employee_name
---------------
Alice
Charlie
(2 rows)
Esto muestra que Alice y Charlie son los empleados que trabajan en el departamento de 'Sales' (Ventas).
Paso 4: Usando EXISTS con Subconsultas
Otra forma de usar subconsultas en la cláusula WHERE es con el operador EXISTS. El operador EXISTS prueba la existencia de filas en una subconsulta. Devuelve verdadero si la subconsulta devuelve alguna fila, y falso en caso contrario.
Aquí tienes un ejemplo de cómo usar EXISTS para lograr el mismo resultado:
SELECT employee_name
FROM employees e
WHERE EXISTS (
SELECT 1
FROM departments d
WHERE d.department_id = e.department_id
AND d.department_name = 'Sales'
);
Esta consulta logra el mismo resultado que la anterior, pero utiliza el operador EXISTS en lugar de IN.
Explicación:
- La subconsulta
SELECT 1 FROM departments d WHERE d.department_id = e.department_id AND d.department_name = 'Sales' comprueba si hay un departamento con el nombre 'Sales' (Ventas) que tenga el mismo department_id (id_departamento) que el empleado actual.
- Si la subconsulta devuelve alguna fila (lo que significa que hay un departamento de 'Sales' (Ventas) con el mismo
department_id (id_departamento)), el operador EXISTS devuelve verdadero, y se selecciona el nombre del empleado.
Ejecuta la consulta en tu terminal psql. Deberías ver la misma salida que antes:
employee_name
---------------
Alice
Charlie
(2 rows)
Ahora has utilizado con éxito una subconsulta en la cláusula WHERE para filtrar datos basándote en una condición en otra tabla. También has aprendido a usar el operador EXISTS con una subconsulta.
