La mayoría de los informes necesitan algo de lógica: etiquetar los pedidos como grandes o pequeños, contar los pedidos pagados y pendientes uno al lado del otro o mostrar primero los artículos urgentes. SQL CASE WHEN maneja todo esto directamente dentro de una consulta y funciona en todas las bases de datos principales.

Ejecutamos todas las consultas aquí en SQLite 3.50 y los resultados mostrados provienen de esa ejecución. CASE es parte del SQL estándar, por lo que se comporta de la misma manera en PostgreSQL, MySQL, SQL Server y Oracle para estos ejemplos.

¿Qué es CASO CUANDO?

CASE es una expresión, no un comando separado. Evalúa las condiciones en orden y devuelve un valor, por lo que puede ir a cualquier lugar donde se permita un valor: en SELECT, WHERE, GROUP BY, ORDER BY o dentro de funciones. Siempre termina en END.

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  ELSE fallback
END

La tabla de muestra

CREATE TABLE orders (id INT, customer TEXT, total INT, status TEXT);

INSERT INTO orders VALUES
 (1,'Asha',1200,'paid'), (2,'Ben',300,'pending'),
 (3,'Asha',800,'paid'), (4,'Chitra',2500,'shipped'),
 (5,'Dev',150,'cancelled'), (6,'Ben',NULL,'pending');

Observe que el pedido 6 no tiene total. Esa disputa importa más adelante.

CASO buscado

Esta es la forma más flexible, ya que cada WHEN tiene una condición propia y completa:

SELECT id, total,
       CASE
         WHEN total >= 1000 THEN 'large'
         WHEN total >= 500 THEN 'medium'
         ELSE 'small'
       END AS size
FROM orders;

-- 1 | 1200 | large
-- 2 |  300 | small
-- 3 |  800 | medium
-- 4 | 2500 | large
-- 5 |  150 | small
-- 6 | NULL | small

Mira la última fila. El pedido 6 no tiene total, pero está etiquetado como “pequeño”. Ambas comparaciones con NULL no eran ciertas, por lo que se optó por ELSE. Mostramos cómo solucionar este problema en la sección NULL. Asigne siempre un nombre al resultado usando AS, o puede obtener un nombre de columna extraño.

CASO sencillo

Cuando compara una columna con valores fijos, la forma más corta se lee mejor:

SELECT id,
       CASE status
         WHEN 'paid' THEN 'Complete'
         WHEN 'shipped' THEN 'Complete'
         WHEN 'pending' THEN 'Waiting'
       END AS label
FROM orders;

-- 1 | Complete
-- 2 | Waiting
-- 3 | Complete
-- 4 | Complete
-- 5 | NULL
-- 6 | Waiting

El orden importa

CASE se detiene en la primera condición verdadera y este es el error lógico más común. Cambie las dos condiciones de nuestra consulta anterior:

SELECT id, total,
       CASE
         WHEN total >= 500 THEN 'medium'
         WHEN total >= 1000 THEN 'large'
         ELSE 'small'
       END AS size
FROM orders WHERE id IN (1, 4);

-- 1 | 1200 | medium
-- 4 | 2500 | medium

Ahora nada puede ser “grande”. Un total de 2500 es también al menos 500, por lo que la primera rama gana y la segunda nunca se alcanza. No aparece ningún error, sólo etiquetas incorrectas. Para rangos, coloque primero la condición más restrictiva o escriba rangos completos, como total >= 500 AND total < 1000.

¿Qué pasa sin MÁS?

En nuestro ejemplo de CASO simple anterior, el pedido 5 se canceló y ninguna sucursal lo manejó, por lo que el resultado fue NULL. A veces eso es exactamente lo que quieres, como se muestra en la siguiente sección. Pero al crear etiquetas, un ELSE 'other' claro suele ser mejor, ya que hace visibles los valores inesperados en lugar de dejar espacios en blanco en un informe.

Informes estilo pivote con SUM

Este es uno de los patrones más útiles en SQL cotidiano. Al agrupar CASE en un agregado, las filas se convierten en columnas, con una fila por cliente:

SELECT customer,
       SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid,
       SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_orders
FROM orders
GROUP BY customer
ORDER BY customer;

-- Asha   | 2000 | 0
-- Ben    |    0 | 2
-- Chitra |    0 | 0
-- Dev    |    0 | 0

Una consulta ahora proporciona tanto los ingresos pagados como el número de pedidos pendientes, sin necesidad de consultas ni uniones por separado. El patrón funciona en casi todas las bases de datos, a diferencia de la sintaxis dedicada PIVOT que sólo algunas ofrecen. Si GROUP BY es nuevo para usted, lea SQL GROUP BY y HAVING.

Conteos condicionales

COUNT omite NULL, por lo que un CASE sin ELSE cuenta solo las filas que coinciden:

SELECT COUNT(*) AS all_orders,
       COUNT(CASE WHEN status = 'paid' THEN 1 END) AS paid_orders,
       COUNT(CASE WHEN total >= 1000 THEN 1 END) AS large_orders
FROM orders;

-- 6 | 2 | 2

Tenga cuidado: si agrega ELSE 0 dentro de COUNT, cada fila se cuenta, porque 0 no es NULL. Utilice ELSE 0 con SUM y omítalo con COUNT. PostgreSQL y SQLite también admiten COUNT(*) FILTER (WHERE ...), que se lee muy bien, pero no está disponible en todas partes.

Agrupar por un CASO

Puede crear sus propios depósitos y luego resumirlos:

SELECT CASE WHEN total >= 1000 THEN 'large' ELSE 'other' END AS bucket,
       COUNT(*)
FROM orders
GROUP BY bucket
ORDER BY bucket;

-- large | 2
-- other | 4

La agrupación por alias funciona en SQLite, PostgreSQL y MySQL. SQL Server no lo permite, por lo que tendría que repetir la expresión completa o colocar la consulta en un CTE o subconsulta primero.

Clasificación personalizada con ORDER BY

El orden alfabético rara vez es lo que quiere una empresa. CASE le permite definir su propio orden:

SELECT id, status FROM orders
ORDER BY CASE status
           WHEN 'pending' THEN 1
           WHEN 'paid' THEN 2
           ELSE 3
         END, id;

-- 2 | pending
-- 6 | pending
-- 1 | paid
-- 3 | paid
-- 4 | shipped
-- 5 | cancelled

Los pedidos pendientes van primero, lo cual resulta útil para una cola de trabajo. La segunda columna de clasificación, id, mantiene las filas en un orden predecible dentro de cada grupo.

CASO en ACTUALIZACIÓN

CASE permite que una declaración aplique diferentes cambios a diferentes filas. Aquí, las pequeñas órdenes pendientes se marcan para su revisión:

UPDATE orders
SET status = CASE
               WHEN status = 'pending' AND total < 500 THEN 'review'
               ELSE status
             END;

SELECT id, status FROM orders WHERE customer = 'Ben';

-- 2 | review
-- 6 | pending

El ELSE status mantiene las demás filas sin cambios. Dejarlo fuera es peligroso, porque las filas no coincidentes se establecerían en NULL. Sin una cláusula WHERE, esta declaración también afecta a cada fila, por lo que en tablas grandes agregue un filtro y considere incluir el cambio en una transacción para que pueda verificar el resultado antes de confirmar. Observe también que el orden 6 no cambió, porque su total NULL no satisfizo total < 500.

trampas NULL

NULL causa dos problemas distintos con CASE. Primero, la forma simple compara usando igualdad, y nada es igual a NULL, ni siquiera NULL en sí:

SELECT CASE NULL WHEN NULL THEN 'matched' ELSE 'not matched' END;

-- not matched

Entonces CASE col WHEN NULL nunca coincide. Utilice el formulario buscado con IS NULL en su lugar. En segundo lugar, como vimos con el orden 6, un valor NULL pasa por alto las comparaciones y aterriza en ELSE. La solución es comprobarlo primero:

SELECT id,
       CASE
         WHEN total IS NULL THEN 'unknown'
         WHEN total >= 1000 THEN 'large'
         ELSE 'other'
       END AS size
FROM orders WHERE id IN (1, 2, 6);

-- 1 | large
-- 2 | other
-- 6 | unknown

El pedido 6 ahora recibe una etiqueta honesta. Nuestra guía sobre valores NULL de SQL cubre este comportamiento en su totalidad.

CASE frente a otras opciones

Esa última opción merece una reflexión. Si un CASE crece hasta treinta ramas y aparece en cinco consultas, mueva la asignación a una tabla y únase a ella. Entonces un cambio es una actualización de una sola fila, en lugar de un cambio de código en cinco lugares.

Errores comunes

• Orden de condiciones incorrecto. Una condición amplia primero oculta las más estrechas.
• Olvidar END. Este es el error de sintaxis más frecuente.
• Usando WHEN NULL. Nunca coincide, así que usa WHEN col IS NULL.
• Agregando ELSE 0 dentro de COUNT. Cuenta todas las filas.
• Omitir ELSE en una ACTUALIZACIÓN. Puede borrar valores con NULL.
• Filtrar por CASO en WHERE. Puede detener el uso de un índice. Consulte nuestra guía para optimización de consultas SQL.

Conclusión

CASE CUANDO es una pequeña característica que hace mucho trabajo. Recuerde tres reglas: la primera rama verdadera gana, las filas no coincidentes se vuelven NULL sin un ELSE y NULL necesita su propia verificación. Para practicar, tome un informe que esté creando actualmente con varias consultas e intente generarlo como una sola consulta usando SUM(CASE ...).

Preguntas frecuentes

sigue aprendiendo