0Pricing
SQL Academy · Lección

Comparación de filas de la misma tabla

Encuentre pares y relaciones

Comparación de filas de la misma tabla es una lección gratuita de SQL Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de SQL Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué es una autounión?

Una autounión consiste en unir una tabla consigo misma. Al principio puede parecer extraño, pero es una técnica muy eficaz para comparar filas de una misma tabla.

Imagine una tabla employees en la que cada empleado tiene un manager_id que apunta a otra fila de la misma tabla. Una autounión permite asociar cada empleado con su gerente en una sola consulta.

Configurar la tabla de ejemplo

Vamos a crear una tabla sencilla de employees para usarla durante toda esta lección. Cada fila tiene un id, un name, un salary y un manager_id que hace referencia a otro empleado de la misma tabla.

CREATE TABLE employees (
  id         INT PRIMARY KEY,
  name       VARCHAR(50),
  salary     INT,
  manager_id INT
);

INSERT INTO employees VALUES
  (1, 'Alice',   90000, NULL),
  (2, 'Bob',     70000, 1),
  (3, 'Carol',   65000, 1),
  (4, 'Dave',    55000, 2),
  (5, 'Eve',     60000, 2),
  (6, 'Frank',   48000, 3);

Sintaxis básica de una autounión

Para realizar una autounión, haga referencia a la misma tabla dos veces mediante dos alias diferentes. Los alias actúan como si tuviera dos copias independientes de la tabla. A continuación, especifique la condición de unión que vincula ambas copias.

Aquí asignamos a employees el alias e (el empleado) y m (el gerente), y después hacemos coincidir e.manager_id = m.id.

SELECT
  e.name   AS employee,
  m.name   AS manager
FROM employees e
JOIN employees m ON e.manager_id = m.id;

Incluir filas de nivel superior con LEFT JOIN

Un INNER JOIN normal descarta las filas en las que manager_id es NULL, lo que significa que el empleado de nivel superior (Alice, la CEO) quedaría excluido de los resultados.

Use un LEFT JOIN para que aparezcan todos los empleados, incluso quienes no tienen gerente. En esos casos, la columna del gerente simplemente será NULL.

SELECT
  e.name          AS employee,
  m.name          AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id
ORDER BY m.name NULLS LAST, e.name;

Buscar pares que compartan una propiedad

Las autouniones también resultan útiles para buscar pares de filas que compartan un valor. Por ejemplo, puede encontrar todos los pares de empleados que reportan al mismo gerente.

La condición a.id < b.id evita que aparezcan en los resultados pares duplicados como (Bob, Carol) y (Carol, Bob).

SELECT
  a.name       AS employee_1,
  b.name       AS employee_2,
  a.manager_id AS shared_manager
FROM employees a
JOIN employees b
  ON a.manager_id = b.manager_id
 AND a.id < b.id;

Comparar salarios entre filas

Puede usar una autounión para comparar valores numéricos entre filas. La consulta siguiente encuentra a todos los empleados cuyo salario es mayor que el salario de su propio gerente, una comprobación analítica clásica.

SELECT
  e.name       AS employee,
  e.salary     AS emp_salary,
  m.name       AS manager,
  m.salary     AS mgr_salary
FROM employees e
JOIN employees m ON e.manager_id = m.id
WHERE e.salary > m.salary;

Buscar filas sin coincidencias

Una autounión con un LEFT JOIN y una comprobación WHERE ... IS NULL permite encontrar filas que no tienen ninguna contraparte coincidente. Aquí buscamos empleados que no tienen subordinados, es decir, nodos hoja de la jerarquía.

SELECT e.name AS employee
FROM employees e
LEFT JOIN employees sub ON sub.manager_id = e.id
WHERE sub.id IS NULL
ORDER BY e.name;

Contar los subordinados directos

Al unir la tabla consigo misma y agrupar por el lado del gerente, puede contar cuántos subordinados directos tiene cada gerente. Los empleados sin subordinados se incluyen mediante LEFT JOIN.

SELECT
  m.name           AS manager,
  COUNT(e.id)      AS direct_reports
FROM employees m
LEFT JOIN employees e ON e.manager_id = m.id
GROUP BY m.id, m.name
ORDER BY direct_reports DESC;

Usar CTE para aclarar las autouniones

Cuando una consulta con autouniones se vuelve compleja, envolverla en una expresión de tabla común (CTE) facilita la lectura de la lógica. Defina una CTE para la jerarquía y, a continuación, consúltela con claridad.

WITH hierarchy AS (
  SELECT
    e.id         AS emp_id,
    e.name       AS employee,
    e.salary     AS emp_salary,
    m.name       AS manager,
    m.salary     AS mgr_salary
  FROM employees e
  LEFT JOIN employees m ON e.manager_id = m.id
)
SELECT *
FROM hierarchy
WHERE mgr_salary IS NOT NULL
  AND emp_salary > mgr_salary;

Autounión sobre una tabla no jerárquica

Las autouniones no se limitan a las jerarquías de gerentes y empleados. El ejemplo siguiente usa una tabla products para encontrar todos los pares de productos que pertenecen a la misma categoría, algo útil para motores de recomendación o comprobaciones de similitud.

CREATE TABLE products (
  id       INT PRIMARY KEY,
  name     VARCHAR(50),
  category VARCHAR(30)
);

INSERT INTO products VALUES
  (1, 'Laptop',  'Electronics'),
  (2, 'Phone',   'Electronics'),
  (3, 'Tablet',  'Electronics'),
  (4, 'Shirt',   'Clothing'),
  (5, 'Jeans',   'Clothing');

SELECT
  a.name AS product_1,
  b.name AS product_2,
  a.category
FROM products a
JOIN products b
  ON a.category = b.category
 AND a.id < b.id;

Errores frecuentes: productos cartesianos y duplicados

Dos errores habituales en las autouniones son los productos cartesianos (olvidar por completo la condición de unión) y los pares duplicados (usar a.id <> b.id en lugar de a.id < b.id).

Compruebe siempre que la condición de unión sea correcta y use < en lugar de <> cuando solo necesite pares sin orden, no pares ordenados.

-- Wrong: returns every ordered pair (A,B) AND (B,A)
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id <> b.id;

-- Correct: returns each unordered pair once
SELECT a.name, b.name
FROM employees a
JOIN employees b ON a.manager_id = b.manager_id
                AND a.id < b.id;

Comprobación rápida

Compruebe su comprensión de las autouniones y de la comparación de filas dentro de la misma tabla.

Resumen de la lección

En esta lección ha aprendido a usar autouniones para comparar filas dentro de la misma tabla.

Ideas clave:

  • Asigne un alias a la tabla dos veces (por ejemplo, e y m) para que la base de datos las trate como fuentes independientes.
  • Use INNER JOIN cuando solo necesite filas que tengan una coincidencia, y LEFT JOIN cuando también quiera incluir las filas sin coincidencia.
  • Use a.id < b.id para evitar pares no ordenados duplicados.
  • Las autouniones funcionan con jerarquías (gerente/empleado), búsquedas por similitud (misma categoría) y cualquier comparación en la que deban relacionarse dos filas de la misma tabla.
  • Las CTE pueden hacer que las consultas complejas con autouniones sean mucho más fáciles de leer y mantener.

Preguntas frecuentes

¿La lección «Comparación de filas de la misma tabla» es gratis?

Sí — el texto completo de «Comparación de filas de la misma tabla» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de SQL Academy, actualiza a CoddyKit PRO. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Comparación de filas de la misma tabla»?

Encuentre pares y relaciones Practicas SQL Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar SQL Academy?

No se requiere experiencia previa. SQL Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Comparación de filas de la misma tabla»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de SQL Academy?

Sí. Cada lección de SQL Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Qué es un self join
  2. Empleados y responsables
  3. Comparación de filas de la misma tabla
  4. Limitaciones de los self joins
← Volver a SQL Academy