Última actualización: 2026-11-11

Contenido de esta página

• ¿Qué es un JOIN en SQL?
• ¿Cuáles son los tipos de JOIN en SQL?
• ¿Qué es un FULL OUTER JOIN y cómo se reemplaza donde no existe?
• ¿Qué es un CROSS JOIN y cuándo tiene sentido?
• ¿Qué es un SELF JOIN?
• NATURAL JOIN y USING: dos atajos para escribir la condición
• ¿Cómo unir tres o más tablas en SQL?
• Ejemplos de JOIN en SQL: un taller de bicicletas en siete tablas
• ¿Para qué sirven los diagramas de Venn en los JOIN, y qué no muestran?
• ¿Qué JOIN usar? Cómo elegir según la pregunta
• ¿Por qué un JOIN multiplica filas?
• La pregunta antes de la consulta

Escena compuesta, con nombre ficticio. Hernán tiene un taller de bicicletas en un barrio de Bucaramanga. Lleva tres tablas en una base de datos pequeña: las órdenes de trabajo, los repuestos que gasta cada orden y los pagos que recibe. Un sábado le pide a su sobrino un reporte de lo cobrado en el mes.

El reporte sale con una cifra que lo pone contento hasta que la revisa. Un cambio de frenos que pagaron en dos cuotas, 30.000 y 20.000 pesos, aparece con 100.000 pesos cobrados. Nadie robó nada ni el computador falló.

La consulta unió las tres tablas en un solo paso. Esa orden gastó dos repuestos y tuvo dos pagos, así que cada pago salió una vez por cada repuesto. La suma contó cada cuota dos veces.

Lo que hizo el sobrino tiene nombre: un JOIN, la orden que junta filas de dos tablas cuando cumplen una condición. Es la herramienta de uso diario para cruzar datos y también una fuente frecuente de reportes inflados cuando se usa sin pensar en cuántas parejas tiene cada fila.

¿Qué es un JOIN en SQL?

Un JOIN combina las filas de dos tablas en una sola tabla de resultado. Para cada fila de la primera tabla, busca en la segunda las filas que cumplen una condición, casi siempre que un mismo número aparezca en las dos. Así se responde una pregunta que ninguna tabla resuelve sola: qué trabajos encargó cada cliente.

SQL (el lenguaje con que se consultan las bases de datos relacionales, las que guardan los datos en tablas) escribe esa condición después de la palabra ON (sobre). PostgreSQL, un gestor de bases de datos libre, define la tabla unida como una tabla derivada de otras dos «según las reglas del tipo de unión» [1]. Su manual distingue tres familias: uniones internas, externas y cruzadas [1].

La condición de ON acepta el mismo tipo de expresión que la cláusula WHERE (donde), la que filtra filas [1]. Dos filas forman pareja si esa expresión resulta verdadera [1]. Microsoft, que fabrica el gestor SQL Server, describe la condición típica como una columna que en una tabla apunta a la clave, el identificador único, de la otra [5]. Cómo se diseñan esas claves es tema de diseño de tablas, no de esta guía.

SQLite, una base de datos liviana que no necesita un servidor aparte y que Python trae en su módulo sqlite3 [8], lo explica desde el otro extremo. Para ese manual, toda unión parte del producto cartesiano de las dos tablas, es decir, de todas las combinaciones posibles de sus filas [2]. Después, la condición de ON deja pasar solo las combinaciones en las que resulta verdadera [2].

Detrás de todo esto hay una operación del álgebra relacional, la teoría matemática de las tablas. Esa formalización está en la guía del modelo relacional. Y si lo que necesita es el panorama del lenguaje, empiece por la guía de SQL.

¿Cuáles son los tipos de JOIN en SQL?

Son cinco: INNER (interno), LEFT (izquierdo), RIGHT (derecho), FULL (completo) y CROSS (cruzado). Microsoft los enumera así en su guía de uniones de SQL Server [5], y son los mismos que define PostgreSQL [1]. A ellos se suma el SELF JOIN (unión de una tabla consigo misma), que no es una palabra nueva del lenguaje sino una tabla unida consigo misma [6].

La diferencia entre ellos no está en cómo se forman las parejas. Está en qué hacen con las filas que se quedan sin pareja. Para describir ese hueco, SQL usa NULL, la marca de «aquí no hay valor».

Tipo	Qué filas devuelve	Qué pasa con las filas sin pareja	Cuándo se usa
INNER JOIN	Solo las parejas que cumplen la condición	Desaparecen de los dos lados	Cuando solo interesa lo que coincide
LEFT JOIN	Las parejas, más cada fila de la tabla izquierda que no tuvo pareja	Las de la izquierda se quedan, con NULL en las columnas de la derecha	Cuando la tabla izquierda manda: todos los clientes, tengan o no órdenes
RIGHT JOIN	Las parejas, más cada fila de la tabla derecha que no tuvo pareja	Las de la derecha se quedan, con NULL en las columnas de la izquierda	Lo mismo que LEFT con las tablas al revés
FULL JOIN	Las parejas, más las filas sin pareja de ambos lados	Se quedan todas, con NULL en el lado que falta	Para comparar dos listas y ver qué sobra en cada una
CROSS JOIN	Todas las combinaciones: N filas por M filas	No hay condición, así que no hay filas sin pareja	Para armar cuadrículas a propósito, como una lista de precios
SELF JOIN	Parejas entre filas de una misma tabla	Depende del tipo de unión que se use	Cuando una fila apunta a otra de su misma tabla

Las definiciones de la tabla siguen el manual de PostgreSQL [1] y el de SQLite [2]. La del SELF JOIN es de Oracle [6].

INNER y LEFT, en una línea cada uno

El INNER JOIN es el tipo por defecto: escribir solo JOIN equivale a pedir uno interno [1]. Para cada fila de la primera tabla, el resultado trae una fila por cada pareja que encuentra en la segunda [1].

El LEFT JOIN primero hace la unión interna y después agrega, con NULL, las filas de la izquierda que no encontraron pareja [1]. Por eso el resultado siempre tiene al menos una fila por cada fila de la izquierda [1]. Los dos tienen guía propia en preparación, con sus trampas y sus casos de uso.

¿Todos los gestores de bases de datos hacen los mismos JOIN?

Casi, pero no del todo. Los cinco tipos tienen el mismo nombre en los cinco gestores revisados, aunque no todos los gestores los aceptan todos ni los tratan igual. Estas son las diferencias que encontré en los manuales oficiales de cada uno, abiertos el 11 de noviembre de 2026.

Gestor (versión del manual)	RIGHT JOIN	FULL JOIN	Detalle propio
PostgreSQL 18	Sí	Sí	Define las tres uniones externas como una unión interna a la que luego se le agregan filas [1]
SQLite	Sí, desde la versión 3.39.0	Sí, desde la versión 3.39.0	La 3.39.0 salió el 25 de junio de 2022 y añadió los dos tipos [3]. En SQLite, CROSS JOIN impide que el optimizador (la parte del gestor que decide cómo ejecutar la consulta) cambie el orden de las tablas [2]
MySQL 8.4	Sí	No figura en su gramática del JOIN	JOIN, CROSS JOIN e INNER JOIN son equivalentes en MySQL; en la norma SQL no lo son [4]
SQL Server (Microsoft)	Sí	Sí	Recomienda escribir la condición en el FROM, la parte que nombra las tablas, y no en el WHERE [5]
Oracle (versión 26)	Sí	Sí	Conserva un operador propio, (+), para uniones externas, pero recomienda la sintaxis del FROM [6]

La gramática de MySQL 8.4 enumera INNER, CROSS, LEFT, RIGHT y NATURAL, pero no FULL (la unión completa) [4]. Más abajo verá cómo se obtiene el mismo resultado en ese caso.

¿Qué es un FULL OUTER JOIN y cómo se reemplaza donde no existe?

Un FULL OUTER JOIN (unión externa completa) devuelve las parejas y, además, las filas sin pareja de las dos tablas. Las columnas del lado que falta salen con NULL [1]. SQLite lo resume como la combinación de un LEFT JOIN y un RIGHT JOIN [2].

Sirve para conciliar. Un ejemplo es cruzar el inventario contra las compras y ver a la vez qué productos no tienen compras y qué compras no tienen producto. Las palabras OUTER (externo) e INNER son opcionales en todas las formas: FULL JOIN y FULL OUTER JOIN piden lo mismo [1].

En MySQL 8.4, donde FULL no aparece en la gramática [4], se arma en tres pasos:

1. Un LEFT JOIN que trae las parejas y las filas sin pareja de la izquierda.
2. Las filas de la derecha que no tienen pareja, buscadas con un LEFT JOIN al revés y la condición de que el cliente salga vacío (IS NULL).
3. Ambos resultados apilados uno debajo del otro con UNION ALL (unir todo), la orden que pega resultados en vertical y que tendrá su propia guía.

Lo comprobé en el ejemplo de esta página: las dos versiones devuelven las mismas cinco filas.

¿Qué es un CROSS JOIN y cuándo tiene sentido?

Un CROSS JOIN combina cada fila de una tabla con cada fila de la otra. Si las tablas tienen N y M filas, el resultado tiene N × M filas [1]. Ese conjunto de todas las combinaciones se llama producto cartesiano.

Tiene usos legítimos, como armar la cuadrícula de todos los servicios por todos los tipos de bicicleta para una lista de precios. El problema es cuando aparece sin querer. Oracle lo advierte en su manual: «A Cartesian product always generates many rows and is rarely useful» [6]. En español: un producto cartesiano siempre genera muchas filas y rara vez es útil. Su ejemplo son dos tablas de 100 filas que dan 10.000 [6].

En PostgreSQL, escribir FROM (desde, la parte de la consulta que nombra las tablas) T1 CROSS JOIN T2 equivale a escribir las dos tablas separadas por una coma [1]. Esa coma sin condición es una forma muy fácil de pedir un producto cartesiano por accidente.

¿Qué es un SELF JOIN?

Un SELF JOIN es la unión de una tabla consigo misma. La tabla aparece dos veces en el FROM, cada vez con un alias, un nombre corto que distingue una copia de la otra [6]. Con los alias, la condición puede decir qué columna de una copia se compara con qué columna de la otra.

El caso típico es una tabla de personas en la que cada fila guarda el número de su jefe, que también está en la misma tabla. Para poner al lado de cada mecánico el nombre de su jefe hay que leer la tabla dos veces: una como «mecánico» y otra como «jefe». No hace falta ninguna palabra especial: se usa un INNER JOIN o un LEFT JOIN corriente.

NATURAL JOIN y USING: dos atajos para escribir la condición

USING es un atajo para cuando la columna de unión se llama igual en las dos tablas. USING (num) equivale a escribir ON t1.num = t2.num, y la columna repetida sale una sola vez en el resultado [1].

NATURAL va más lejos: une por todas las columnas que tengan el mismo nombre en las dos tablas, sin nombrarlas [1]. El manual de PostgreSQL lo considera «considerablemente más riesgoso». La razón: si alguien agrega a una de las tablas una columna con un nombre que ya existe en la otra, la unión empieza a compararla también, sin aviso [1]. Y si no hay ninguna columna en común, NATURAL JOIN se comporta como un CROSS JOIN [1].

¿Cómo unir tres o más tablas en SQL?

Se encadenan los JOIN, uno tras otro. En SQLite, A JOIN B JOIN C se calcula como (A JOIN B) JOIN C: primero las dos primeras y luego el resultado con la tercera [2]. PostgreSQL añade que los paréntesis sirven para cambiar ese orden [1]. MySQL fija un tope de 61 tablas en una sola unión [4].

Cada eslabón necesita su propia condición. Si falta una, ese tramo se vuelve un producto cartesiano, y ahí empieza el problema de la sección siguiente.

Ejemplos de JOIN en SQL: un taller de bicicletas en siete tablas

Este esquema es mínimo y los datos son sintéticos: nombres y valores inventados para el ejemplo. Lo ejecuté con el módulo sqlite3 de Python, que trae SQLite 3.53.1. Esa versión es posterior a la 3.39.0, así que corre los cinco tipos.

-- Datos sintéticos: taller de bicicletas de barrio (nombres y cifras inventados).
CREATE TABLE cliente (
  id_cliente INTEGER PRIMARY KEY,
  nombre     TEXT NOT NULL
);
CREATE TABLE orden (               -- una orden = una bicicleta que entra al taller
  id_orden   INTEGER PRIMARY KEY,
  id_cliente INTEGER,              -- vacío (NULL) si fue una venta de mostrador
  trabajo    TEXT NOT NULL
);
CREATE TABLE repuesto_usado (      -- cada orden puede gastar varios repuestos
  id_orden INTEGER NOT NULL,
  repuesto TEXT NOT NULL
);
CREATE TABLE pago (                -- cada orden puede pagarse en varias cuotas
  id_orden INTEGER NOT NULL,
  valor    INTEGER NOT NULL        -- en pesos
);
CREATE TABLE mecanico (
  id_mecanico INTEGER PRIMARY KEY,
  nombre      TEXT NOT NULL,
  id_jefe     INTEGER              -- apunta a otro mecánico de la misma tabla
);
CREATE TABLE servicio  (nombre TEXT);
CREATE TABLE tipo_bici (nombre TEXT);

INSERT INTO cliente VALUES (1,'Ana'),(2,'Bruno'),(3,'Carla');
INSERT INTO orden VALUES (101,1,'Cambio de frenos'),(102,1,'Ajuste de cambios'),
                         (103,2,'Pinchazo'),(104,NULL,'Venta de mostrador');
INSERT INTO repuesto_usado VALUES (101,'Pastillas'),(101,'Cable');
INSERT INTO pago VALUES (101,30000),(101,20000),(103,8000);
INSERT INTO mecanico VALUES (1,'Rosa',NULL),(2,'Tomás',1),(3,'Lucía',1);
INSERT INTO servicio  VALUES ('Lavado'),('Frenos'),('Cambios');
INSERT INTO tipo_bici VALUES ('Ruta'),('Montaña');

Carla no tiene órdenes, y la orden 104 no tiene cliente. Esos dos huecos son los que separan un tipo de unión de otro.

INNER, LEFT, RIGHT y FULL sobre las mismas dos tablas

La consulta es la misma cuatro veces. Solo cambia la palabra que va antes de JOIN:

-- Cambie INNER por LEFT, RIGHT o FULL y compare los resultados.
SELECT c.nombre, o.trabajo
FROM cliente AS c                           -- tabla izquierda
INNER JOIN orden AS o                       -- tabla derecha
        ON o.id_cliente = c.id_cliente      -- condición: el mismo cliente
ORDER BY o.id_orden;

Tipo	Filas	Qué filas salen
INNER JOIN	3	Ana con Cambio de frenos, Ana con Ajuste de cambios, Bruno con Pinchazo
LEFT JOIN	4	Las tres anteriores, más Carla con el trabajo en NULL
RIGHT JOIN	4	Las tres anteriores, más la Venta de mostrador con el nombre en NULL
FULL JOIN	5	Las tres anteriores, más Carla y la Venta de mostrador

CROSS JOIN y SELF JOIN

-- CROSS JOIN: todas las combinaciones servicio × tipo de bicicleta.
SELECT s.nombre AS servicio, t.nombre AS tipo
FROM servicio AS s
CROSS JOIN tipo_bici AS t
ORDER BY s.nombre, t.nombre;               -- 3 × 2 = 6 filas

-- SELF JOIN: la tabla mecanico leída dos veces, con dos alias.
SELECT m.nombre AS mecanico, j.nombre AS jefe
FROM mecanico AS m                          -- copia 1: el mecánico
INNER JOIN mecanico AS j                    -- copia 2: su jefe
        ON m.id_jefe = j.id_mecanico;

El CROSS JOIN devuelve seis filas, de Cambios con Montaña a Lavado con Ruta. El SELF JOIN devuelve dos: Tomás con su jefa Rosa y Lucía con Rosa. Rosa no sale como mecánico porque no tiene jefe y la unión es interna. Con un LEFT JOIN aparecería con el jefe en NULL.

FULL JOIN armado a mano, para MySQL

-- Paso 1: parejas y clientes sin órdenes.
SELECT c.nombre, o.trabajo
FROM cliente AS c
LEFT JOIN orden AS o ON o.id_cliente = c.id_cliente
UNION ALL                                   -- pega el segundo resultado debajo
-- Paso 2: órdenes sin cliente.
SELECT c.nombre, o.trabajo
FROM orden AS o
LEFT JOIN cliente AS c ON o.id_cliente = c.id_cliente
WHERE c.id_cliente IS NULL;

Devuelve las mismas cinco filas que el FULL JOIN de SQLite.

¿Para qué sirven los diagramas de Venn en los JOIN, y qué no muestran?

Los círculos que se cruzan ayudan a recordar qué lado se conserva. El área común es el INNER JOIN, un círculo completo es el LEFT JOIN y los dos círculos son el FULL JOIN.

Pero un diagrama de Venn dibuja conjuntos de elementos distintos, y un JOIN no devuelve elementos: devuelve parejas. Ana aparece dos veces en el resultado porque tiene dos órdenes, y ningún círculo lo muestra. Tampoco caben ahí el CROSS JOIN, que no tiene zona común, ni la multiplicación de filas. Use los círculos para recordar qué lado se queda. Para saber cuántas filas saldrán, piense en cuántas parejas tiene cada fila.

¿Qué JOIN usar? Cómo elegir según la pregunta

El tipo de unión se elige antes de escribir la consulta, a partir de la pregunta. La pista está en las palabras «todos», «solo» y «aunque no».

Si la pregunta es…	Use	En el taller
«Quiero solo lo que coincide»	INNER JOIN	Los clientes que tienen al menos una orden
«Quiero todos los de esta lista, tengan o no pareja»	LEFT JOIN, con esa lista a la izquierda	Todos los clientes, con sus órdenes si las hay
«¿Cuáles no tienen pareja?»	LEFT JOIN y luego quedarse con las filas en NULL	Los clientes sin ninguna orden [4]
«Quiero ver lo que sobra en cada lista»	FULL JOIN	Clientes sin órdenes y órdenes sin cliente, en un solo resultado
«Quiero todas las combinaciones»	CROSS JOIN	Cada servicio con cada tipo de bicicleta
«Una fila apunta a otra de la misma tabla»	SELF JOIN	Cada mecánico con su jefe

¿Y el RIGHT JOIN? Cualquier RIGHT JOIN se puede escribir como LEFT JOIN cambiando el orden de las tablas [1]. MySQL lo recomienda así para que el código funcione en otros gestores: «it is recommended that you use LEFT JOIN instead of RIGHT JOIN» [4]. Es decir, recomienda usar LEFT JOIN en lugar de RIGHT JOIN.

¿Por qué un JOIN multiplica filas?

Porque una fila sale una vez por cada pareja que encuentra. Si una orden tiene dos pagos, la unión entre órdenes y pagos trae esa orden dos veces, y eso está bien. El problema aparece cuando se suma o se cuenta sin recordar esa repetición.

La cardinalidad, es decir, cuántas filas de una tabla se relacionan con cuántas de la otra, dice qué esperar:

Relación	Ejemplo en el taller	Qué pasa en la unión
Uno a uno (1:1)	Una orden y su factura única	Cada fila sale una vez
Uno a muchos (1:N)	Una orden y sus pagos	La orden se repite una vez por pago
Muchos a muchos (N:M)	Un repuesto se usa en muchas órdenes y una orden gasta muchos repuestos	Las filas pueden repetirse de los dos lados
Dos «uno a muchos» desde la misma tabla	Los repuestos y los pagos de una misma orden	Cada repuesto se combina con cada pago
Sin condición	Clientes y órdenes separados por una coma	Producto cartesiano: N × M filas

El reporte de Hernán, paso a paso

La orden 101 gastó dos repuestos y recibió dos pagos. Unir las tres tablas a la vez produce cuatro filas, y la suma de pagos se duplica:

-- Suma inflada: cada pago sale una vez por cada repuesto (2 × 2 = 4 filas).
SELECT SUM(p.valor) AS cobrado
FROM orden AS o
JOIN repuesto_usado AS r ON r.id_orden = o.id_orden
JOIN pago           AS p ON p.id_orden = o.id_orden
WHERE o.id_orden = 101;                     -- resultado: 100000

-- Suma correcta: para hablar de pagos, una solo los pagos.
SELECT SUM(p.valor) AS cobrado
FROM orden AS o
JOIN pago AS p ON p.id_orden = o.id_orden
WHERE o.id_orden = 101;                     -- resultado: 50000

La regla práctica es unir solo las tablas que la pregunta necesita. Si un mismo reporte pide repuestos y pagos, cada total se calcula por su lado y luego se juntan. Eso se hace con subconsultas o con funciones de agregación, temas que tendrán guía propia.

Cómo detectar la multiplicación antes de publicar un número

Revise estos tres puntos antes de entregar cualquier cifra que salga de una unión:

1. Cuente las filas antes y después. En el ejemplo hay 4 órdenes y 3 pagos. Si la unión de órdenes y pagos devuelve más de 3 filas, algo se está repitiendo.
2. Verifique que la columna del lado «uno» no tenga repetidos. Agrupe por esa columna y busque las que aparecen más de una vez: aquí, la orden 101 aparece dos veces en repuesto_usado.
3. Busque las condiciones que faltan. Clientes y órdenes separados por una coma, sin condición, dan 12 filas, que son 3 × 4 [1].

Las tres comprobaciones corren con la misma base de esta página. Son consultas cortas, y las puede correr quien encargó el reporte, no solo quien lo escribió.

La pregunta antes de la consulta

El sobrino de Hernán no se equivocó de tipo de JOIN. Usó el más común y la sintaxis estaba bien. Se equivocó antes, al no preguntarse cuántas parejas tenía cada orden.

A mi juicio, este error pesa más que cualquier fallo de sintaxis en los reportes de un negocio pequeño, y no se arregla con un curso de sintaxis. Se arregla con el hábito de contar filas antes y después de cada unión. Los manuales hablan de tipos y condiciones; el que paga la cuenta es quien toma decisiones con un total inflado. En un taller de barrio, una cifra doble puede llevar a contratar a un mecánico que no hacía falta.

Preguntas frecuentes

¿JOIN e INNER JOIN son lo mismo? Sí. La palabra INNER es opcional y una unión interna es la que se obtiene por defecto [1]. En MySQL, además, JOIN, INNER JOIN y CROSS JOIN son intercambiables. MySQL aclara que en la norma SQL no lo son: INNER JOIN va con ON y CROSS JOIN sin él [4].

¿Da igual poner la condición en ON o en WHERE? En una unión interna, el resultado es el mismo [2]. En una externa no. Las filas con NULL se agregan después de aplicar ON y antes de aplicar WHERE [2]. Por eso una condición en WHERE puede borrar justo las filas sin pareja que se quería conservar.

¿Una consulta puede tener varios tipos de JOIN a la vez? Sí. Los JOIN de todos los tipos se pueden encadenar o anidar, y los paréntesis controlan el orden [1]. Una misma consulta puede traer los clientes con LEFT JOIN y sus pagos con INNER JOIN. Lo que cambia según el orden es qué filas sin pareja sobreviven.

¿Qué pasa si las dos columnas de la condición tienen NULL? No forman pareja. En PostgreSQL, una comparación con el signo igual en la que uno de los lados es NULL no da verdadero ni falso: da NULL, que significa «desconocido» [7]. Como la condición no resulta verdadera, la pareja no se forma [1]. Por eso la venta de mostrador del ejemplo, sin cliente, no se une con nadie y solo aparece en el RIGHT JOIN y el FULL JOIN.

¿Unir tablas hace lenta una consulta? Puede, según el tamaño de las tablas, los índices disponibles y cómo se reparten los datos. Microsoft explica que SQL Server elige el algoritmo de unión según esos factores [5]. Cómo leer ese plan y acelerar una consulta es tema de la guía de optimización, en preparación.

Referencias

Las citas en otro idioma son traducción propia.

1. The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 7.2.1.1 «Joined Tables» — tabla unida derivada de otras dos según las reglas del tipo de unión; uniones internas, externas y cruzadas; CROSS JOIN con N × M filas y equivalente a la coma; INNER es el valor por defecto y las palabras INNER y OUTER son opcionales; definición de INNER, LEFT, RIGHT y FULL OUTER JOIN; la condición ON admite expresiones como las del WHERE; USING como atajo y NATURAL «considerably more risky»; NATURAL sin columnas comunes se comporta como CROSS JOIN; los JOIN se pueden encadenar o anidar, con paréntesis para fijar el orden. PostgreSQL: Documentation 18, Table Expressions — Consultada: 2026-11-11.
2. SQLite. SELECT, sección 2 «Determination of input data» (página actualizada el 9 de octubre de 2026) — todas las uniones parten del producto cartesiano de los dos conjuntos; ON deja pasar solo las filas en que la expresión es verdadera; un FULL JOIN es la combinación de un LEFT JOIN y un RIGHT JOIN; más de dos tablas se procesan de izquierda a derecha; el CROSS JOIN impide al optimizador reordenar las tablas y ese tratamiento es propio de SQLite; en uniones internas no hay diferencia entre poner la condición en ON o en WHERE, y en las externas las filas con NULL se agregan después de ON y antes de WHERE. SQLite: SELECT — Consultada: 2026-11-11.
3. SQLite. Release 3.39.0 On 2022-06-25 — añade el soporte de RIGHT y FULL OUTER JOIN. SQLite: Release 3.39.0 — Consultada: 2026-11-11.
4. Oracle Corporation. MySQL 8.4 Reference Manual, sección 15.2.13.2 «JOIN Clause» — gramática de joined_table con INNER, CROSS, STRAIGHT_JOIN, LEFT, RIGHT y NATURAL (sin FULL); JOIN, CROSS JOIN e INNER JOIN son equivalentes en MySQL y no en la norma; máximo de 61 tablas en una unión; LEFT JOIN con IS NULL para hallar filas sin contraparte; recomendación de usar LEFT JOIN en lugar de RIGHT JOIN por portabilidad. Leída en la copia de Internet Archive del 16 de octubre de 2026, porque el sitio de MySQL rechazó la descarga directa. MySQL 8.4 Reference Manual: JOIN Clause — Consultada: 2026-11-11.
5. Microsoft. Joins (SQL Server), Microsoft Learn — uniones lógicas internas, externas izquierda, derecha y completa, y cruzadas; la condición típica une una clave foránea con su clave asociada; la sintaxis simplificada del FROM según la norma ISO; escribir las condiciones en el FROM es el método recomendado; SQL Server elige el algoritmo físico de unión según el tamaño de las tablas, los índices y la distribución de los datos. Microsoft Learn: Joins (SQL Server) — Consultada: 2026-11-11.
6. Oracle Corporation. SQL Language Reference, sección «Joins» (Oracle AI Database, versión 26) — un SELF JOIN une una tabla consigo misma, que aparece dos veces en el FROM con alias; sin condición de unión se obtiene el producto cartesiano, «A Cartesian product always generates many rows and is rarely useful», con el ejemplo de dos tablas de 100 filas que dan 10.000; sintaxis LEFT, RIGHT y FULL OUTER JOIN y el operador propio (+); Oracle recomienda la sintaxis del FROM en lugar del operador (+). Oracle: SQL Language Reference, Joins — Consultada: 2026-11-11.
7. The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 9.2 «Comparison Functions and Operators» — los operadores de comparación ordinarios dan NULL («desconocido»), no verdadero ni falso, cuando una de las entradas es NULL; por ejemplo, 7 = NULL da NULL. PostgreSQL: Documentation 18, Comparison Functions and Operators — Consultada: 2026-11-11.
8. Python Software Foundation. sqlite3 — DB-API 2.0 interface for SQLite databases, documentación de Python 3.15 — SQLite es una biblioteca que ofrece una base de datos liviana en disco que no requiere un proceso de servidor aparte y usa una variante no estándar de SQL; el módulo sqlite3 da acceso a ella desde Python. Python: documentación del módulo sqlite3 — Consultada: 2026-11-11.

Cómo investigamos esta página

• Pregunta que responde: Qué hace un JOIN en SQL, qué filas devuelve cada tipo y por qué una unión mal hecha multiplica las filas.
• Fuentes: identificadas 12 → incluidas 8
• Criterios de inclusión: solo manuales oficiales de PostgreSQL, SQLite, MySQL, SQL Server, Oracle y Python, en su versión vigente; sin blogs, cursos ni enciclopedias.
• Fecha de corte de los datos: 2026-11-11