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.
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.
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
);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.
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;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.
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';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:
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;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.
SELECT
c.CustomerId,
c.CustomerName,
o.OrderId
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
ON o.CustomerId = c.CustomerId;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:
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';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:
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';Usar EXISTS cuando solo necesitas saber si hay coincidencia
Supongamos que solo necesitas los clientes que tienen al menos un pedido.
Esto funciona:
SELECT DISTINCT
c.CustomerId,
c.CustomerName
FROM dbo.Customers AS c
INNER JOIN dbo.Orders AS o
ON o.CustomerId = c.CustomerId;Pero EXISTS expresa el requisito de forma más directa:
SELECT
c.CustomerId,
c.CustomerName
FROM dbo.Customers AS c
WHERE EXISTS
(
SELECT 1
FROM dbo.Orders AS o
WHERE o.CustomerId = c.CustomerId
);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:
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;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.
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';El destino es:
UPDATE pLa tabla unida se usa para calificar las filas.
UPDATE con valores de otra tabla
Supongamos que tienes una tabla de staging:
CREATE TABLE dbo.ProductPriceStage
(
ProductId int NOT NULL,
NewPrice decimal(18,2) NOT NULL
);Puedes actualizar el destino con los valores del staging:
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
ON s.ProductId = p.ProductId;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:
UPDATE p
SET p.CurrentPrice = s.NewPrice
FROM dbo.Products AS p
INNER JOIN dbo.ProductPriceStage AS s
ON s.ProductId = p.ProductId;es ambiguo desde el punto de vista del negocio.
Primero debes garantizar la unicidad:
SELECT
ProductId,
COUNT(*) AS RowCount
FROM dbo.ProductPriceStage
GROUP BY ProductId
HAVING COUNT(*) > 1;Una restricción de unicidad o un índice único es todavía mejor cuando el modelo exige una fila por producto.
CREATE UNIQUE INDEX UX_ProductPriceStage_ProductId
ON dbo.ProductPriceStage(ProductId);¿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.
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';La tabla de destino es:
DELETE oiEs 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.
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';Después valida el número de filas.
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';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:
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;El tamaño de lote adecuado depende de la carga.
DELETE con EXISTS
A veces EXISTS es más sencillo:
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'
);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:
CREATE INDEX IX_Orders_CustomerId
ON dbo.Orders(CustomerId);y:
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId);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:
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;Un índice útil podría ser:
CREATE INDEX IX_Orders_CustomerId_OrderDate
ON dbo.Orders(CustomerId, OrderDate)
INCLUDE (OrderId, TotalAmount);¿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:
CREATE INDEX IX_OrderItems_OrderId
ON dbo.OrderItems(OrderId)
INCLUDE (ProductId, Quantity, UnitPrice);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:
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;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:
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);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:
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';sigue obligando a SQL Server a:
- encontrar los clientes que cumplen la condición;
- encontrar los pedidos correspondientes;
- actualizar las filas;
- mantener los índices;
- registrar los cambios en el log;
- 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.
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;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:
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';Posibles índices de apoyo:
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);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
DISTINCTpara ocultar una lógica de duplicados; - usa
EXISTScuando 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.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaEncontrar consultas con alto consumo de CPUIdentifica las consultas de SQL Server que más CPU consumen ahora y en el historial, distingue el CPU total del CPU por ejecución y elige el siguiente paso de optimización adecuado.Abrir guía rápida
- RecursoContenido en inglésSQL Server Performance Tuning ChecklistA one-page troubleshooting reference for slow SQL Server workloads: ten steps from incident scope to measured change, with three diagnostic queries.Ver recurso
¿Qué debería crear después?
Estoy construyendo Javi Builds alrededor de problemas reales que enfrentan los ingenieros de datos. Dime qué tema te gustaría ver después.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.