0Pricing
SQL Academy · Lección

Qué es un self join

Combine una tabla consigo misma mediante alias

Qué es un self join es una lección gratuita de SQL Academy en CoddyKit. Esta es la lección 1 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.

Unir una tabla consigo misma

Una autounión consiste en unir una tabla consigo misma. Al principio puede parecer extraño, pero es una técnica muy eficaz cuando las filas de una tabla están relacionadas con otras filas de esa misma tabla.

El ejemplo más habitual es una tabla de employees en la que cada fila de empleado también almacena el ID de su gerente, que también es un empleado de la misma tabla.

La tabla employees

Considere una tabla employees en la que cada fila tiene un id, un name y un manager_id que apunta a otra fila de la misma tabla.

Esta estructura se denomina relación autorreferenciada o recursiva. Ejecute la consulta siguiente para crear y rellenar la tabla.

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

INSERT INTO employees VALUES
  (1, 'Alice',   NULL),
  (2, 'Bob',     1),
  (3, 'Carol',   1),
  (4, 'Dave',    2),
  (5, 'Eve',     2),
  (6, 'Frank',   3);

Por qué las uniones normales no funcionan aquí

Si desea mostrar cada empleado junto al nombre de su gerente, ambas partes de la información se encuentran en la misma tabla. Un JOIN normal conecta dos tablas distintas (o, al menos, dos fuentes distintas).

Para leer dos veces de la misma tabla —una vez para el empleado y otra para el gerente— necesita una autounión combinada con alias de tabla.

Introducción a los alias

Para realizar una autounión, escriba el mismo nombre de tabla dos veces en la cláusula FROM / JOIN y asigne un alias diferente a cada aparición. Los alias permiten que SQL las trate como dos tablas lógicas independientes.

La convención consiste en usar alias cortos y descriptivos, como e para employee y m para manager.

-- Conceptual structure (not yet a full query)
-- FROM employees AS e
-- JOIN employees AS m ON e.manager_id = m.id

Su primera autounión

Aquí tiene una autounión completa que muestra cada empleado junto con el nombre de su gerente. La condición ON vincula el manager_id del empleado con el id del gerente.

Alice no tiene gerente, por lo que queda excluida por el INNER JOIN: no tiene ninguna fila coincidente en el lado del gerente.

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

Incluir filas sin gerente

Cuando usa INNER JOIN, se descartan las filas que no tienen coincidencias. Alice tiene manager_id = NULL, por lo que desaparece de los resultados.

Cambie a un LEFT JOIN para conservar a todos los empleados y mostrar simplemente NULL (o una etiqueta) cuando no haya gerente.

SELECT
  e.name             AS employee,
  COALESCE(m.name, 'No Manager') AS manager
FROM employees AS e
LEFT JOIN employees AS m
  ON e.manager_id = m.id;

Filtrar los resultados de la autounión

Puede añadir una cláusula WHERE a una autounión igual que a cualquier otra consulta. El ejemplo siguiente recupera únicamente los empleados cuyo gerente directo es Alice (id = 1).

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

Contar los subordinados directos

Las autouniones se combinan de forma natural con las funciones de agregación. La consulta siguiente cuenta cuántos subordinados directos tiene cada gerente agrupando por el alias del gerente.

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

Autouniones sobre datos no jerárquicos

Las autouniones no se limitan a las jerarquías. Siempre que las filas de una tabla estén relacionadas con otras filas de esa misma tabla, una autounión puede resultar útil.

Por ejemplo, puede buscar todos los pares de empleados que tienen el mismo gerente: para ello, una la tabla consigo misma mediante valores coincidentes de manager_id y asegúrese de no emparejar a un empleado consigo mismo.

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

El papel del alias

Los alias son obligatorios en una autounión: sin ellos, la base de datos no puede determinar a qué copia de la tabla se refiere cada columna y se producirá un error de ambigüedad.

Puede usar los nombres de alias que prefiera. La regla fundamental es anteponer el alias correcto a cada referencia de columna, para que SQL sepa qué instancia de la tabla debe consultar.

-- This will fail: column 'name' is ambiguous
-- SELECT name FROM employees JOIN employees ON manager_id = id;

-- This works: aliases remove the ambiguity
SELECT e.name, m.name
FROM employees AS e
JOIN employees AS m ON e.manager_id = m.id;

Casos de uso reales

Las autouniones aparecen con frecuencia en las bases de datos reales. Algunos casos de uso habituales son:

  • Organigramas: empleados y sus gerentes
  • Árboles de categorías: categorías principales y secundarias
  • Listas de materiales: componentes formados por otros componentes
  • Redes sociales: búsqueda de amigos de amigos en una única tabla de conexiones

Reconocer una clave foránea autorreferenciada en un esquema es el primer indicio de que puede ser necesaria una autounión.

Comprobación rápida

Compruebe que entiende las autouniones antes de continuar.

Resumen de la lección

En esta lección ha aprendido qué es una autounión y cuándo usarla:

  • Una autounión conecta una tabla consigo misma haciendo referencia a ella dos veces mediante alias diferentes
  • Use INNER JOIN para excluir las filas sin coincidencias (por ejemplo, los gerentes de nivel superior) o LEFT JOIN para conservarlas
  • Añada WHERE, GROUP BY y funciones de agregación exactamente como lo haría en cualquier otra unión
  • Use a.id < b.id en la cláusula ON para evitar pares duplicados al comparar filas de una misma tabla
  • Las autouniones son la herramienta habitual para trabajar con datos jerárquicos, árboles de categorías y cualquier relación autorreferenciada

A continuación: explorará jerarquías de varios niveles con CTE recursivas.

Preguntas frecuentes

¿La lección «Qué es un self join» es gratis?

Sí — el texto completo de «Qué es un self join» 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 «Qué es un self join»?

Combine una tabla consigo misma mediante alias 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 1 de 4.

¿Cuánto tiempo toma la lección «Qué es un self join»?

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