SQL Server

JOINs en SQL Server: SELECT con varias tablas, UPDATE, DELETE, índices y rendimiento

Guía práctica de SQL Server sobre JOINs entre múltiples tablas, UPDATE y DELETE usando JOIN, errores por duplicados, índices y consideraciones de rendimiento.

Por JaviPublicado 21 min de lecturaIntermedio

En este artículo

Los JOINs son una de las partes más importantes de SQL Server.

También son uno de los lugares donde es más fácil crear problemas de rendimiento.

Un JOIN puede ser lógicamente correcto y aun así costoso por culpa de:

  • índices que faltan;
  • malas estimaciones de cardinalidad;
  • coincidencias duplicadas;
  • relaciones de muchos a muchos;
  • conversiones implícitas;
  • predicados no SARGables;
  • estadísticas desactualizadas;
  • unir muchas más filas de las necesarias;
  • listas SELECT demasiado anchas;
  • un mal orden de filtrado.

Esta guía se centra en patrones de JOIN prácticos que puedes usar en cargas reales de SQL Server.

Cubre:

  • unir varias tablas;
  • los patrones INNER, LEFT y EXISTS;
  • UPDATE con JOIN;
  • DELETE con JOIN;
  • cómo evitar errores de filas duplicadas;
  • la indexación de columnas de join;
  • el diseño de índices compuestos;
  • las columnas incluidas;
  • las consideraciones del plan de ejecución;
  • los algoritmos de join;
  • la cardinalidad y las estadísticas;
  • la resolución de problemas de rendimiento.

Modelo de ejemplo

Usaremos un pequeño modelo de tipo comercio.

Consulta SQL: Modelo de ejemploT-SQL
CREATE TABLE dbo.Customers
(
    CustomerId       int           NOT NULL PRIMARY KEY,
    CustomerName     varchar(100)  NOT NULL,
    Status           varchar(20)   NOT NULL
);

CREATE TABLE dbo.Orders
(
    OrderId          bigint        NOT NULL PRIMARY KEY,
    CustomerId       int           NOT NULL,
    OrderDate        datetime2     NOT NULL,
    OrderStatus      varchar(20)   NOT NULL,
    TotalAmount      decimal(18,2) NOT NULL
);

CREATE TABLE dbo.OrderItems
(
    OrderItemId      bigint        NOT NULL PRIMARY KEY,
    OrderId          bigint        NOT NULL,
    ProductId        int           NOT NULL,
    Quantity         int           NOT NULL,
    UnitPrice        decimal(18,2) NOT NULL
);

CREATE TABLE dbo.Products
(
    ProductId        int           NOT NULL PRIMARY KEY,
    ProductName      varchar(150)  NOT NULL,
    CategoryId       int           NOT NULL,
    IsActive         bit           NOT NULL
);

CREATE TABLE dbo.Categories
(
    CategoryId       int           NOT NULL PRIMARY KEY,
    CategoryName     varchar(100)  NOT NULL
);
T-SQL38 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Las relaciones son:

Customers
   1
   │
   └──< Orders
          1
          │
          └──< OrderItems >── 1 Products >── 1 Categories

INNER JOIN básico

Un INNER JOIN devuelve las filas en las que ambos lados coinciden.

Consulta SQL: INNER JOIN básicoT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    c.CustomerName,
    o.TotalAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId;
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

El predicado del join es:

c.CustomerId = o.CustomerId

Ese predicado normalmente debe comparar columnas con tipos de datos compatibles.

Unir muchas tablas

Un JOIN entre varias tablas es simplemente una cadena de relaciones.

Consulta SQL: Unir muchas tablasT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    c.CustomerName,
    p.ProductName,
    cat.CategoryName,
    oi.Quantity,
    oi.UnitPrice,
    oi.Quantity * oi.UnitPrice AS LineAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId
INNER JOIN dbo.Categories AS cat
    ON cat.CategoryId = p.CategoryId
WHERE o.OrderDate >= '2026-10-01'
  AND o.OrderDate <  '2026-11-01';
T-SQL20 líneasVista de solo lectura. No está conectada a ninguna base de datos.

La pregunta importante no es:

¿Cuántas tablas puede unir SQL Server?

SQL Server puede unir muchas tablas.

La mejor pregunta es:

¿Cuántas filas fluyen por cada paso del plan?

Cinco tablas bien indexadas pueden ser rápidas.

Tres tablas mal unidas pueden ser muy lentas.

Entender la multiplicación de filas

Supongamos que un pedido tiene cinco líneas de pedido.

Esta consulta:

Consulta SQL: Entender la multiplicación de filasT-SQL
SELECT
    o.OrderId,
    c.CustomerName
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId;
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

devuelve una fila por línea de pedido, no una fila por pedido.

Si un pedido tiene cinco artículos, el pedido aparece cinco veces.

No es un error de SQL Server.

Es el resultado correcto para esa forma de join.

Antes de usar DISTINCT, pregúntate por qué existen los duplicados.

DISTINCT puede ocultar un problema de modelado o de join a la vez que añade una operación de ordenación o de hash.

LEFT JOIN

Usa LEFT JOIN cuando necesites todas las filas del lado izquierdo aunque no haya coincidencia.

Consulta SQL: LEFT JOINT-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId;
T-SQL7 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Los clientes sin pedidos siguen apareciendo, con NULL en las columnas del pedido.

Un error común con LEFT JOIN

Esto parece un LEFT JOIN:

Consulta SQL: Un error común con LEFT JOINT-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
WHERE o.OrderStatus = 'Open';
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Pero el predicado WHERE elimina las filas en las que o.OrderStatus es NULL.

En la práctica, eso convierte la consulta en un INNER JOIN.

Si quieres los clientes aunque no tengan pedidos abiertos, mueve el filtro al join:

Consulta SQL: Un error común con LEFT JOIN (2)T-SQL
SELECT
    c.CustomerId,
    c.CustomerName,
    o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
   AND o.OrderStatus = 'Open';
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Usar EXISTS cuando solo necesitas saber si hay coincidencia

Supongamos que solo necesitas los clientes que tienen al menos un pedido.

Esto funciona:

Consulta SQL: Usar EXISTS cuando solo necesitas saber si hay coincidenciaT-SQL
SELECT DISTINCT
    c.CustomerId,
    c.CustomerName
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Pero EXISTS expresa el requisito de forma más directa:

Consulta SQL: Usar EXISTS cuando solo necesitas saber si hay coincidencia (2)T-SQL
SELECT
    c.CustomerId,
    c.CustomerName
FROM dbo.Customers AS c
WHERE EXISTS
(
    SELECT 1
    FROM dbo.Orders AS o
    WHERE o.CustomerId = c.CustomerId
);
T-SQL10 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Cuando no necesitas columnas de la segunda tabla, EXISTS suele ser un diseño más limpio.

Unir datos agregados

Ten cuidado al unir después de agregar.

Ejemplo:

Consulta SQL: Unir datos agregadosT-SQL
WITH OrderTotals AS
(
    SELECT
        oi.OrderId,
        SUM(oi.Quantity * oi.UnitPrice) AS CalculatedTotal
    FROM dbo.OrderItems AS oi
    GROUP BY oi.OrderId
)
SELECT
    o.OrderId,
    o.TotalAmount,
    ot.CalculatedTotal
FROM dbo.Orders AS o
INNER JOIN OrderTotals AS ot
    ON ot.OrderId = o.OrderId;
T-SQL15 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Agregar primero puede reducir drásticamente el número de filas que participan en los joins posteriores.

Eso puede mejorar tanto la exactitud como el rendimiento.

UPDATE con JOIN

SQL Server permite que un UPDATE tenga como destino una tabla mientras usa tablas unidas para identificar filas o calcular valores.

Ejemplo: desactivar los productos de una categoría descatalogada.

Consulta SQL: UPDATE con JOINT-SQL
UPDATE p
SET p.IsActive = 0
FROM dbo.Products AS p
INNER JOIN dbo.Categories AS c
    ON c.CategoryId = p.CategoryId
WHERE c.CategoryName = 'Discontinued';
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

El destino es:

Consulta SQL: UPDATE con JOIN (2)T-SQL
UPDATE p
T-SQL1 líneaVista de solo lectura. No está conectada a ninguna base de datos.

La tabla unida se usa para calificar las filas.

UPDATE con valores de otra tabla

Supongamos que tienes una tabla de staging:

Consulta SQL: UPDATE con valores de otra tablaT-SQL
CREATE TABLE dbo.ProductPriceStage
(
    ProductId int NOT NULL,
    NewPrice  decimal(18,2) NOT NULL
);
T-SQL5 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Puedes actualizar el destino con los valores del staging:

Consulta SQL: UPDATE con valores de otra tabla (2)T-SQL
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
    ON s.ProductId = p.ProductId;
T-SQL5 líneasVista de solo lectura. No está conectada a ninguna base de datos.

El requisito importante es que el join identifique cada fila de destino de forma determinista.

UPDATE peligroso: varias filas de origen para un mismo destino

Supongamos que la tabla de staging contiene varias filas para un mismo ProductId.

Entonces:

Consulta SQL: UPDATE peligroso: varias filas de origen para un mismo destinoT-SQL
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
    ON s.ProductId = p.ProductId;
T-SQL5 líneasVista de solo lectura. No está conectada a ninguna base de datos.

es ambiguo desde el punto de vista del negocio.

Primero debes garantizar la unicidad:

Consulta SQL: UPDATE peligroso: varias filas de origen para un mismo destino (2)T-SQL
SELECT
    ProductId,
    COUNT(*) AS RowCount
FROM dbo.ProductPriceStage
GROUP BY ProductId
HAVING COUNT(*) > 1;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Una restricción de unicidad o un índice único es todavía mejor cuando el modelo exige una fila por producto.

Consulta SQL: UPDATE peligroso: varias filas de origen para un mismo destino (3)T-SQL
CREATE UNIQUE INDEX UX_ProductPriceStage_ProductId
ON dbo.ProductPriceStage(ProductId);
T-SQL2 líneasVista de solo lectura. No está conectada a ninguna base de datos.

¿Actualizar varias tablas?

Una sola instrucción UPDATE de SQL Server actualiza una única tabla de destino.

Puedes unir muchas tablas para decidir qué filas y qué valores actualizar, pero solo una tabla es el destino.

Si varias tablas necesitan cambios, usa instrucciones separadas dentro de una transacción cuando se requiera atomicidad.

BEGIN TRANSACTION;

UPDATE ...;

UPDATE ...;

COMMIT TRANSACTION;

DELETE con JOIN

SQL Server permite eliminar filas de una tabla usando tablas unidas para identificarlas.

Ejemplo: eliminar las líneas de los pedidos cancelados anteriores a una fecha límite.

Consulta SQL: DELETE con JOINT-SQL
DELETE oi
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

La tabla de destino es:

Consulta SQL: DELETE con JOIN (2)T-SQL
DELETE oi
T-SQL1 líneaVista de solo lectura. No está conectada a ninguna base de datos.

Es un detalle de sintaxis de SQL Server importante.

Un flujo de DELETE más seguro

Antes de ejecutar el DELETE, ejecuta la misma lógica como un SELECT.

Consulta SQL: Un flujo de DELETE más seguroT-SQL
SELECT
    oi.*
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL7 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Después valida el número de filas.

Consulta SQL: Un flujo de DELETE más seguro (2)T-SQL
SELECT
    COUNT_BIG(*) AS RowsToDelete
FROM dbo.OrderItems AS oi
INNER JOIN dbo.Orders AS o
    ON o.OrderId = oi.OrderId
WHERE o.OrderStatus = 'Cancelled'
  AND o.OrderDate < '2025-01-01';
T-SQL7 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Solo entonces conviértelo en el DELETE.

En borrados grandes, trabajar por lotes puede ser más seguro.

DELETE por lotes

Borrar millones de filas en una sola transacción puede provocar:

  • crecimiento del log de transacciones;
  • bloqueos;
  • escalado de bloqueos;
  • rollbacks largos;
  • presión sobre la replicación o los grupos de disponibilidad (AG).

Un patrón por lotes puede ayudar:

Consulta SQL: DELETE por lotesT-SQL
WHILE 1 = 1
BEGIN
    DELETE TOP (10000) oi
    FROM dbo.OrderItems AS oi
    INNER JOIN dbo.Orders AS o
        ON o.OrderId = oi.OrderId
    WHERE o.OrderStatus = 'Cancelled'
      AND o.OrderDate < '2025-01-01';

    IF @@ROWCOUNT = 0
        BREAK;
END;
T-SQL12 líneasVista de solo lectura. No está conectada a ninguna base de datos.

El tamaño de lote adecuado depende de la carga.

DELETE con EXISTS

A veces EXISTS es más sencillo:

Consulta SQL: DELETE con EXISTST-SQL
DELETE oi
FROM dbo.OrderItems AS oi
WHERE EXISTS
(
    SELECT 1
    FROM dbo.Orders AS o
    WHERE o.OrderId = oi.OrderId
      AND o.OrderStatus = 'Cancelled'
      AND o.OrderDate < '2025-01-01'
);
T-SQL10 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Ambos enfoques pueden producir buenos planes.

Elige el que deje más clara la intención y valida el plan de ejecución.

Los índices son fundamentales para el rendimiento de los JOINs

Un JOIN suele beneficiarse de índices en:

  • claves primarias;
  • claves foráneas;
  • columnas de filtrado;
  • claves de negocio que se unen con frecuencia.

En nuestro ejemplo:

Customers.CustomerId
Orders.CustomerId
OrderItems.OrderId
OrderItems.ProductId
Products.ProductId
Products.CategoryId
Categories.CategoryId

Las claves primarias ya están indexadas.

Las claves foráneas no se indexan automáticamente en SQL Server.

Esto es importante.

Indexar las columnas de clave foránea cuando el patrón de acceso lo necesite

Por ejemplo:

Consulta SQL: Indexar las columnas de clave foránea cuando el patrón de acceso lo necesiteT-SQL
CREATE INDEX IX_Orders_CustomerId
ON dbo.Orders(CustomerId);
T-SQL2 líneasVista de solo lectura. No está conectada a ninguna base de datos.

y:

Consulta SQL: Indexar las columnas de clave foránea cuando el patrón de acceso lo necesite (2)T-SQL
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId);
T-SQL2 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Estos índices pueden ayudar a SQL Server a encontrar eficientemente las filas hijas durante los joins.

También pueden mejorar las actualizaciones o eliminaciones de filas padre cuando las comprobaciones referenciales necesitan inspeccionar las tablas hijas.

Pero no indexes a ciegas cada clave foránea.

Mide la carga.

Índices compuestos para JOIN + filtro

Supongamos que la consulta es:

Consulta SQL: Índices compuestos para JOIN + filtroT-SQL
SELECT
    o.OrderId,
    o.OrderDate,
    o.TotalAmount
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
WHERE o.CustomerId = @CustomerId
  AND o.OrderDate >= @StartDate
  AND o.OrderDate < @EndDate;
T-SQL10 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Un índice útil podría ser:

Consulta SQL: Índices compuestos para JOIN + filtro (2)T-SQL
CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId, TotalAmount);
T-SQL3 líneasVista de solo lectura. No está conectada a ninguna base de datos.

¿Por qué?

Las columnas clave dan soporte a:

igualdad en CustomerId
+
rango en OrderDate

Las columnas incluidas pueden cubrir la salida del SELECT.

El orden de las columnas importa

Estos índices no son equivalentes:

(CustomerId, OrderDate)

y:

(OrderDate, CustomerId)

Si el predicado habitual es:

CustomerId = constant
AND OrderDate BETWEEN ...

entonces (CustomerId, OrderDate) suele ofrecer un mejor patrón de acceso.

Pero el diseño de índices depende de la distribución real de la carga y de los patrones de consulta.

Índices de cobertura

Un índice de cobertura contiene suficientes columnas para satisfacer la consulta sin búsquedas adicionales.

Ejemplo:

Consulta SQL: Índices de coberturaT-SQL
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity, UnitPrice);
T-SQL3 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Así, una consulta que filtre o una por OrderId puede evitar key lookups repetidos.

La cobertura puede reducir las lecturas.

Pero cada columna incluida aumenta el tamaño del índice y el costo de escritura.

Demasiados índices pueden ralentizar las escrituras relacionadas con JOINs

Los índices aceleran las lecturas, pero deben mantenerse durante:

INSERT
UPDATE
DELETE

Si una tabla tiene 20 índices solapados, un UPDATE basado en un join puede pasar mucho tiempo manteniendo índices.

Optimizar el rendimiento es un equilibrio:

beneficio en lectura
vs
costo de escritura
vs
almacenamiento
vs
mantenimiento

Las conversiones implícitas pueden arruinar un buen JOIN

Supongamos:

TableA.CustomerId = int
TableB.CustomerId = varchar(20)

Entonces un join como:

ON a.CustomerId = b.CustomerId

requiere una conversión.

Eso puede:

  • impedir seeks eficientes;
  • aumentar el CPU;
  • distorsionar las estimaciones;
  • aumentar las lecturas.

Las columnas de join deben usar tipos de datos compatibles siempre que sea posible.

La mejor corrección suele estar en el modelo de datos, no en envolver ambas columnas en funciones.

Evitar funciones en las columnas de join

Esto suele dar problemas:

ON CAST(a.CustomerId AS varchar(20)) = b.CustomerId

o:

ON UPPER(a.Code) = UPPER(b.Code)

Estas expresiones pueden dificultar el acceso por índice.

Prefiere almacenar valores comparables en tipos comparables y con formatos normalizados.

Los joins de muchos a muchos pueden disparar el número de filas

Supongamos que ambos lados contienen claves duplicadas:

Tabla A:
Key = 10 aparece 100 veces

Tabla B:
Key = 10 aparece 200 veces

Unir por Key puede producir:

100 × 200 = 20.000 filas

solo para esa clave.

Es una de las razones por las que las consultas con joins pueden volverse enormes de forma inesperada.

Antes de unir, entiende la relación esperada:

uno a uno
uno a muchos
muchos a uno
muchos a muchos

Si esperas uno a uno, impónlo con una restricción de unicidad o un índice único cuando corresponda.

Las estadísticas influyen en las decisiones de JOIN

SQL Server elige los planes a partir del número estimado de filas.

Esas estimaciones influyen en si elige:

  • Nested Loops;
  • Hash Match;
  • Merge Join;
  • el orden de los joins;
  • la concesión de memoria;
  • el paralelismo.

Si las estadísticas no son precisas, la estrategia de join puede ser incorrecta.

Nested Loops

Nested Loops suele funcionar bien cuando:

  • la entrada externa es pequeña;
  • el lado interno tiene un índice eficiente;
  • se espera un número limitado de filas.

Conceptualmente:

Por cada fila externa
    buscar (seek) las filas internas que coinciden

Puede ser extremadamente rápido.

También puede ser desastroso si SQL Server espera 10 filas y en realidad procesa 10 millones.

Hash Match

Los hash joins son habituales con conjuntos más grandes.

Conceptualmente:

construir una tabla hash con una entrada
sondearla con la otra entrada

Pueden funcionar bien en joins grandes incluso sin un orden útil.

Pero pueden necesitar mucha memoria.

Las malas estimaciones pueden provocar derrames (spills) a tempdb.

Merge Join

Merge Join puede ser muy eficiente cuando ambas entradas ya están ordenadas por las claves del join.

Conceptualmente:

entrada A ordenada
+
entrada B ordenada
→ recorrer ambas en orden

Pero obtener el orden necesario puede ser costoso en sí mismo si SQL Server necesita ordenar.

No fuerces un tipo de join sin evidencia

SQL Server admite hints de join, pero deberían ser excepcionales.

Por ejemplo:

OPTION (HASH JOIN);

puede mejorar una prueba y empeorar otros valores de parámetros o futuras distribuciones de datos.

Prefiere corregir el problema de fondo:

  • el índice;
  • las estadísticas;
  • el tipo de datos;
  • la cardinalidad;
  • la forma de la consulta.

Filtra pronto, pero entiende la optimización de SQL Server

Esto no significa envolver manualmente cada tabla en una CTE solo para «filtrar primero».

El optimizador de SQL Server puede reordenar los joins y empujar los predicados.

Lo que importa es darle:

  • predicados SARGables;
  • índices útiles;
  • buenas estadísticas;
  • relaciones claras.

Un buen predicado:

o.OrderDate >= @StartDate
AND o.OrderDate < @EndDate

Un predicado menos útil:

YEAR(o.OrderDate) = 2026

La primera forma tiene más probabilidades de permitir un index seek sobre OrderDate.

Evita SELECT *

En joins grandes, SELECT * puede:

  • devolver datos innecesarios;
  • aumentar el tráfico de red;
  • aumentar los requisitos de memoria;
  • impedir índices de cobertura estrechos;
  • hacer frágil el código cuando cambian los esquemas.

Selecciona solo las columnas que necesitas.

Une solo lo que necesitas

Esta consulta:

Consulta SQL: Une solo lo que necesitasT-SQL
SELECT
    o.OrderId,
    c.CustomerName
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId;
T-SQL10 líneasVista de solo lectura. No está conectada a ninguna base de datos.

no debería unir OrderItems y Products si ningún filtro ni ninguna columna de salida los necesita.

Cada join innecesario aumenta la complejidad y puede aumentar el trabajo.

Las CTE no mejoran automáticamente el rendimiento

Una CTE puede mejorar la legibilidad:

WITH RecentOrders AS
(
    SELECT
        OrderId,
        CustomerId,
        OrderDate
    FROM dbo.Orders
    WHERE OrderDate >= @StartDate
)
SELECT ...

Pero una CTE normal no se materializa automáticamente.

SQL Server puede integrarla en línea dentro del plan general.

Usa las CTE por claridad, no como una barrera de optimización garantizada.

Las tablas temporales pueden ayudar en joins grandes de varias etapas

A veces dividir una consulta compleja en etapas mejora:

  • las estimaciones de cardinalidad;
  • las oportunidades de indexación;
  • la resolución de problemas;
  • la reutilización.

Ejemplo:

Consulta SQL: Las tablas temporales pueden ayudar en joins grandes de varias etapasT-SQL
SELECT
    o.OrderId,
    o.CustomerId
INTO #RecentOrders
FROM dbo.Orders AS o
WHERE o.OrderDate >= @StartDate
  AND o.OrderDate < @EndDate;

CREATE INDEX IX_RecentOrders_CustomerId
ON #RecentOrders(CustomerId);
T-SQL10 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Después une #RecentOrders con el resto del modelo.

Esto puede ser útil cuando un resultado intermedio es mucho más pequeño que los datos originales.

Pero las tablas temporales también añaden trabajo en tempdb.

Mide la contrapartida.

UPDATE y DELETE necesitan el mismo análisis de rendimiento que SELECT

Un error común es optimizar solo las consultas SELECT.

Este UPDATE:

Consulta SQL: UPDATE y DELETE necesitan el mismo análisis de rendimiento que SELECTT-SQL
UPDATE o
SET o.OrderStatus = 'Archived'
FROM dbo.Orders AS o
INNER JOIN dbo.Customers AS c
    ON c.CustomerId = o.CustomerId
WHERE c.Status = 'Inactive';
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

sigue obligando a SQL Server a:

  1. encontrar los clientes que cumplen la condición;
  2. encontrar los pedidos correspondientes;
  3. actualizar las filas;
  4. mantener los índices;
  5. registrar los cambios en el log;
  6. mantener bloqueos.

El diseño del join y de los índices importa igual.

Las actualizaciones grandes pueden provocar bloqueos

Un único UPDATE que afecta a millones de filas puede:

  • mantener bloqueos durante mucho tiempo;
  • escalar bloqueos;
  • hacer crecer el log de transacciones;
  • bloquear lectores y escritores;
  • provocar rollbacks largos.

Trabajar por lotes puede ayudar cuando las reglas de negocio lo permiten.

Consulta SQL: Las actualizaciones grandes pueden provocar bloqueosT-SQL
WHILE 1 = 1
BEGIN
    UPDATE TOP (5000) o
    SET o.OrderStatus = 'Archived'
    FROM dbo.Orders AS o
    INNER JOIN dbo.Customers AS c
        ON c.CustomerId = o.CustomerId
    WHERE c.Status = 'Inactive'
      AND o.OrderStatus <> 'Archived';

    IF @@ROWCOUNT = 0
        BREAK;
END;
T-SQL13 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Revisa el plan de ejecución

Para los joins importantes, inspecciona el plan de ejecución real.

Busca:

  • filas estimadas frente a reales;
  • scans sobre tablas grandes;
  • key lookups repetidos;
  • spills de hash;
  • spills de ordenación;
  • conversiones implícitas;
  • advertencias;
  • comportamiento costoso de muchos a muchos;
  • algoritmos de join inesperados.

No te fijes solo en el porcentaje de costo de los operadores.

Esos porcentajes son estimaciones del optimizador, no una medición directa del tiempo de ejecución.

Mide las lecturas lógicas

SET STATISTICS IO ON es extremadamente útil.

SET STATISTICS IO ON;
SET STATISTICS TIME ON;

SELECT ...

Compara el antes y el después.

Una consulta que mejora de:

8.000.000 lecturas lógicas

a:

80.000 lecturas lógicas

suele representar una reducción significativa del trabajo.

Ejemplo: JOIN de varias tablas mal indexado

Imagina esta consulta:

Consulta SQL: Ejemplo: JOIN de varias tablas mal indexadoT-SQL
SELECT
    c.CustomerName,
    o.OrderId,
    p.ProductName,
    oi.Quantity
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
    ON o.CustomerId = c.CustomerId
INNER JOIN dbo.OrderItems AS oi
    ON oi.OrderId = o.OrderId
INNER JOIN dbo.Products AS p
    ON p.ProductId = oi.ProductId
WHERE c.Status = 'Active'
  AND o.OrderDate >= '2026-10-01';
T-SQL14 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Posibles índices de apoyo:

Consulta SQL: Ejemplo: JOIN de varias tablas mal indexado (2)T-SQL
CREATE INDEX IX_Customers_Status
ON dbo.Customers(Status)
INCLUDE (CustomerId, CustomerName);

CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId);

CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity);
T-SQL11 líneasVista de solo lectura. No está conectada a ninguna base de datos.

La clave primaria de Products(ProductId) ya da soporte al último join.

Estos índices son ejemplos, no recetas universales.

Pruébalos con la carga real.

Un mejor índice puede depender del predicado más selectivo

Supongamos que casi todos los clientes están activos.

Entonces:

Customers(Status)

puede no ser lo bastante selectivo para ayudar.

Un índice que parece lógico sobre el papel puede no ser útil.

El diseño de índices debe tener en cuenta:

la selectividad
el número de filas
la frecuencia de las consultas
el volumen de escritura
los índices existentes
los planes de ejecución reales

Los índices de claves foráneas también pueden ayudar al rendimiento de DELETE

Supongamos que eliminas un cliente.

SQL Server puede tener que comprobar si existen filas hijas en Orders.

Si Orders.CustomerId no está indexada, las comprobaciones referenciales pueden requerir un scan.

Un índice sobre la clave foránea puede hacer esas comprobaciones mucho más baratas.

Esta es una de las razones por las que indexar las claves foráneas puede importar más allá del rendimiento de los SELECT.

Lista de comprobación para un buen diseño de JOIN

Antes de aprobar un join en producción, pregúntate:

Exactitud

  • ¿La relación esperada es uno a uno, uno a muchos o muchos a muchos?
  • ¿Pueden las coincidencias duplicadas multiplicar las filas?
  • ¿El LEFT JOIN sigue siendo un LEFT JOIN después de los predicados WHERE?
  • ¿Es determinista el destino del UPDATE/DELETE?

Tipos de datos

  • ¿Las columnas de join son del mismo tipo o de tipos compatibles?
  • ¿Hay conversiones implícitas?
  • ¿Se aplican funciones a las columnas de join?

Indexación

  • ¿Están indexadas las claves primarias?
  • ¿Necesitan índices las claves foráneas más usadas?
  • ¿Necesita la consulta un índice compuesto?
  • ¿Evitarían las columnas INCLUDE búsquedas costosas?
  • ¿Ya existen índices solapados?

Filtrado

  • ¿Son SARGables los predicados?
  • ¿Puede la consulta reducir filas de forma eficiente?
  • ¿Hay joins innecesarios?

Calidad del plan

  • ¿Filas estimadas frente a reales?
  • ¿Qué algoritmo de join?
  • ¿Algún scan sobre una tabla muy grande?
  • ¿Spills?
  • ¿Advertencias?
  • ¿Búsquedas repetidas?

Impacto en la escritura

Para UPDATE/DELETE:

  • ¿Cuántas filas?
  • ¿Cuánto registro en el log?
  • ¿Riesgo de bloqueos?
  • ¿Hace falta trabajar por lotes?
  • ¿Cuántos índices hay que mantener?

Reflexiones finales

El rendimiento de un JOIN no depende solo del número de tablas.

Depende de:

las relaciones
el número de filas
la cardinalidad
los índices
las estadísticas
los tipos de datos
los filtros
los predicados de join
las columnas seleccionadas
el volumen de escritura

Un join de cinco tablas bien diseñado puede terminar en milisegundos.

Un join de dos tablas mal diseñado puede recorrer cientos de millones de filas.

Las reglas prácticas son sencillas:

  • entiende la relación antes de escribir el JOIN;
  • no uses DISTINCT para ocultar una lógica de duplicados;
  • usa EXISTS cuando solo necesites saber si existe;
  • valida primero con un SELECT los joins de UPDATE y DELETE;
  • indexa las columnas de join cuando la carga se beneficie;
  • diseña los índices compuestos en torno a los predicados reales;
  • evita las conversiones implícitas;
  • inspecciona los planes reales;
  • compara las lecturas lógicas;
  • mide antes y después.

El objetivo no es solo que el SQL sea sintácticamente correcto.

El objetivo es que la relación sea clara, determinista y eficiente.

Etiquetas

  • SQL Server
  • Rendimiento
  • Indexación
  • Joins (JOIN)
  • Planes de ejecución