SQL · Lección 03 de 15

Operadores y filtros avanzados

CASE WHEN te permite crear columnas condicionales (como if/else de Python). COALESCE reemplaza NULLs. CAST convierte tipos. Estas herramientas transforman datos directamente en la consulta, sin necesidad de programar fuera de SQL.

80–100 min Prerrequisitos: SQL 02

Concepto teórico

CASE WHEN — el if/else de SQL

CASE WHEN evalúa condiciones y devuelve valores distintos según cuál se cumpla. Es la herramienta más poderosa para clasificar datos dentro de una consulta:

SELECT nombre,
       score,
       CASE
           WHEN score >= 800 THEN 'Excelente'
           WHEN score >= 700 THEN 'Bueno'
           WHEN score >= 600 THEN 'Regular'
           ELSE 'Bajo'
       END AS categoria
FROM clientes;

Equivalencia con Python: CASE WHEN es exactamente como los if/elif/else que escribiste en la lección 06 de Python. La diferencia es que acá lo hacés DENTRO del SELECT — no necesitás procesar los datos fuera de la base. Esto es más rápido y más eficiente que traer los datos crudos y clasificar en Python.

CASE WHEN se puede usar en:

SELECT: para crear columnas calculadas
WHERE: para filtros condicionales (menos común)
ORDER BY: para ordenar por lógica custom
Dentro de funciones de agregación: SUM(CASE WHEN ... THEN 1 ELSE 0 END) para contar condicionalmente

COALESCE — reemplazar NULLs

COALESCE(valor1, valor2, ...) devuelve el primer valor que NO sea NULL. Es la forma estándar de manejar datos faltantes:

-- Si email es NULL, mostrar 'sin email'
SELECT nombre, COALESCE(email, 'sin email') AS contacto
FROM clientes;

NULLIF — convertir valores a NULL

NULLIF(a, b) devuelve NULL si a = b, o devuelve a si son distintos. Útil para evitar divisiones por cero:

-- Evitar división por cero: si cantidad es 0, NULLIF la convierte a NULL
SELECT total / NULLIF(cantidad, 0) AS precio_unitario FROM ventas;

CAST — convertir tipos

CAST(valor AS tipo) convierte entre tipos. Útil cuando un campo numérico está guardado como texto:

SELECT CAST('42' AS INTEGER);     -- texto → entero
SELECT CAST(3.14 AS INTEGER);     -- decimal → entero (trunca)
SELECT CAST(42 AS TEXT);          -- entero → texto
SELECT ROUND(precio, 2);         -- redondear a 2 decimales

Columnas calculadas

Podés hacer cálculos directamente en el SELECT. El resultado aparece como una nueva columna:

SELECT nombre,
       saldo,
       saldo * 0.21 AS iva,
       saldo * 1.21 AS con_iva,
       ROUND(cuota * 100.0 / ingreso, 1) AS ratio_pct
FROM clientes;

División entera en SQLite: 5 / 2 da 2 (no 2.5) porque ambos son enteros. Para obtener decimal, multiplicá por 1.0: 5 * 1.0 / 2 da 2.5. O usá CAST(5 AS REAL) / 2.

En el trabajo: CASE WHEN es probablemente la herramienta SQL que más usás después de WHERE. "Clasificá los clientes por segmento", "marcá las transacciones sospechosas", "categorizá la mora por tramos" — todo es CASE WHEN. COALESCE es el segundo más usado: "si no tiene email, mostrar 'sin dato'".

Ejemplos explicados paso a paso

Ejemplo 1: CASE WHEN para clasificar

ejemplo_01_case.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García',720,150000),(2,'López',680,320000),
(3,'Martínez',590,45000),(4,'Pérez',810,890000),(5,'Fernández',645,72000);

SELECT nombre,
       score,
       CASE
           WHEN score >= 800 THEN 'Excelente'
           WHEN score >= 700 THEN 'Bueno'
           WHEN score >= 600 THEN 'Regular'
           ELSE 'Bajo'
       END AS categoria,
       CASE WHEN score >= 650 THEN 'Aprobado' ELSE 'Rechazado' END AS credito
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 2: COALESCE para reemplazar NULLs

ejemplo_02_coalesce.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, email TEXT, telefono TEXT);
INSERT INTO clientes VALUES (1,'García','garcia@mail.com','+5411234567');
INSERT INTO clientes VALUES (2,'López',NULL,'+5435123456');
INSERT INTO clientes VALUES (3,'Martínez','martinez@mail.com',NULL);
INSERT INTO clientes VALUES (4,'Pérez',NULL,NULL);

-- COALESCE: primer valor no-NULL
SELECT nombre,
       COALESCE(email, 'sin email') AS email,
       COALESCE(telefono, 'sin teléfono') AS telefono,
       COALESCE(email, telefono, 'sin contacto') AS contacto_principal
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 3: Columnas calculadas y ROUND

ejemplo_03_calculadas.sqlSQL

CREATE TABLE prestamos (id INTEGER, cliente TEXT, capital REAL, cuota REAL, ingreso REAL);
INSERT INTO prestamos VALUES (1,'García',500000,42000,350000);
INSERT INTO prestamos VALUES (2,'López',300000,28000,250000);
INSERT INTO prestamos VALUES (3,'Pérez',800000,65000,500000);

SELECT cliente,
       capital,
       cuota,
       ingreso,
       ROUND(cuota * 100.0 / ingreso, 1) AS ratio_pct,
       CASE
           WHEN cuota * 100.0 / ingreso > 30 THEN 'EXCEDE'
           ELSE 'OK'
       END AS estado_ratio
FROM prestamos;

Hacé clic en ▶ Ejecutar

Ejemplo 4: CASE WHEN dentro de agregación (contar condicionalmente)

ejemplo_04_count_case.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER, activo INTEGER);
INSERT INTO clientes VALUES (1,'García',720,1),(2,'López',680,1),
(3,'Martínez',590,0),(4,'Pérez',810,1),(5,'Fernández',645,1),(6,'Sosa',520,0);

-- Contar por categoría usando SUM + CASE
SELECT
    COUNT(*) AS total,
    SUM(CASE WHEN activo = 1 THEN 1 ELSE 0 END) AS activos,
    SUM(CASE WHEN activo = 0 THEN 1 ELSE 0 END) AS inactivos,
    SUM(CASE WHEN score >= 700 THEN 1 ELSE 0 END) AS premium,
    ROUND(SUM(CASE WHEN score >= 700 THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) AS pct_premium
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 5: NULLIF para evitar división por cero + CAST

ejemplo_05_nullif.sqlSQL

CREATE TABLE productos (id INTEGER, nombre TEXT, ventas INTEGER, stock INTEGER, precio_texto TEXT);
INSERT INTO productos VALUES (1,'Notebook',120,15,'920000');
INSERT INTO productos VALUES (2,'Mouse',0,150,'23000');
INSERT INTO productos VALUES (3,'Teclado',85,0,'46000');

-- NULLIF: evitar división por cero
SELECT nombre,
       ventas,
       stock,
       ROUND(ventas * 1.0 / NULLIF(stock, 0), 1) AS rotacion,
       CAST(precio_texto AS INTEGER) AS precio_num,
       CASE WHEN stock = 0 THEN 'SIN STOCK' ELSE 'OK' END AS estado
FROM productos;

Hacé clic en ▶ Ejecutar

Referencia rápida

Función	Sintaxis	Uso
CASE WHEN	`CASE WHEN cond THEN val ELSE val END`	Clasificar, condicional
COALESCE	`COALESCE(v1, v2, ...)`	Primer no-NULL
NULLIF	`NULLIF(a, b)`	NULL si a=b (evitar /0)
CAST	`CAST(val AS tipo)`	Convertir tipos
ROUND	`ROUND(val, decimales)`	Redondear
Cálculos	`col1 * col2 AS resultado`	Columnas derivadas

Ejercicios

Nivel 1 · Básico

Ejercicio 1: CASE WHEN simple

Clasificá cada cliente como 'Premium' (score>=700) o 'Estándar'. Debe incluir Premium.

ejercicio_01.sqlDebe incluir "Premium"

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García',720),(2,'López',680),(3,'Pérez',810);

-- CASE WHEN:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: COALESCE

Reemplazá NULLs de email por 'no registrado'. Debe incluir no registrado.

ejercicio_02.sqlDebe incluir "no registrado"

CREATE TABLE clientes (id INTEGER, nombre TEXT, email TEXT);
INSERT INTO clientes VALUES (1,'García','garcia@mail.com');
INSERT INTO clientes VALUES (2,'López',NULL);
INSERT INTO clientes VALUES (3,'Pérez','perez@mail.com');

-- COALESCE:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Columna calculada

Mostrá cada producto con su precio con IVA (precio * 1.21). Debe incluir 1113200.

ejercicio_03.sqlDebe incluir "1113200"

CREATE TABLE productos (id INTEGER, nombre TEXT, precio REAL);
INSERT INTO productos VALUES (1,'Notebook',920000),(2,'Mouse',23000),(3,'Teclado',46000);

-- Precio con IVA:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: CASE WHEN con múltiples niveles

Clasificá scores en 4 categorías: Excelente (>=800), Bueno (>=700), Regular (>=600), Bajo. Debe incluir Excelente.

ejercicio_04.sqlDebe incluir "Excelente"

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García',720),(2,'López',680),(3,'Martínez',590),(4,'Pérez',810),(5,'Fernández',645);

-- CASE WHEN con 4 niveles:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Ratio cuota/ingreso con ROUND

Calculá el ratio cuota/ingreso en porcentaje con 1 decimal. Debe incluir 12.0.

ejercicio_05.sqlDebe incluir "12.0"

CREATE TABLE prestamos (id INTEGER, cliente TEXT, cuota REAL, ingreso REAL);
INSERT INTO prestamos VALUES (1,'García',42000,350000);
INSERT INTO prestamos VALUES (2,'López',28000,250000);
INSERT INTO prestamos VALUES (3,'Pérez',65000,500000);

-- Ratio en porcentaje:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: NULLIF para evitar /0

Calculá rotación (ventas/stock) evitando división por cero con NULLIF. Debe incluir 8.0.

ejercicio_06.sqlDebe incluir "8.0"

CREATE TABLE productos (id INTEGER, nombre TEXT, ventas INTEGER, stock INTEGER);
INSERT INTO productos VALUES (1,'Notebook',120,15);
INSERT INTO productos VALUES (2,'Mouse',0,150);
INSERT INTO productos VALUES (3,'Teclado',80,0);

-- Rotación sin error de división:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: SUM + CASE para contar categorías

Contá cuántos clientes son Premium (score>=700) y cuántos no, en una sola fila. Debe incluir 3.

ejercicio_07.sqlDebe incluir "3"

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García',720),(2,'López',680),(3,'Martínez',590),(4,'Pérez',810),(5,'Sosa',750);

-- SUM + CASE para contar:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: CASE WHEN + COALESCE combinados

Creá columna "contacto" que use email si existe, teléfono si no, o "SIN CONTACTO" si ninguno. Clasificá clientes según si tienen contacto o no. Debe incluir SIN CONTACTO.

ejercicio_08.sqlDebe incluir "SIN CONTACTO"

CREATE TABLE clientes (id INTEGER, nombre TEXT, email TEXT, telefono TEXT);
INSERT INTO clientes VALUES (1,'García','garcia@mail.com',NULL);
INSERT INTO clientes VALUES (2,'López',NULL,'+5411234567');
INSERT INTO clientes VALUES (3,'Pérez',NULL,NULL);

-- COALESCE + CASE:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Ratio + CASE para decisión de crédito

Calculá ratio cuota/ingreso y clasificá en APROBADO (<=30%) o RECHAZADO (>30%). Debe incluir APROBADO.

ejercicio_09.sqlDebe incluir "APROBADO"

CREATE TABLE solicitudes (id INTEGER, cliente TEXT, cuota REAL, ingreso REAL, score INTEGER);
INSERT INTO solicitudes VALUES (1,'García',42000,350000,720);
INSERT INTO solicitudes VALUES (2,'López',95000,250000,680);
INSERT INTO solicitudes VALUES (3,'Pérez',65000,500000,810);

-- Ratio + decisión:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte completo con todas las herramientas

Generá un reporte que muestre: nombre, score, categoría (CASE WHEN 4 niveles), email limpio (COALESCE), saldo con IVA, y el % que cada saldo representa del total. Debe incluir Excelente.

ejercicio_10.sqlDebe incluir "Excelente"

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER, saldo REAL, email TEXT);
INSERT INTO clientes VALUES (1,'García',720,150000,'garcia@mail.com');
INSERT INTO clientes VALUES (2,'López',680,320000,NULL);
INSERT INTO clientes VALUES (3,'Pérez',810,890000,'perez@mail.com');
INSERT INTO clientes VALUES (4,'Sosa',590,45000,NULL);

-- Reporte completo:

Hacé clic en ▶ Ejecutar

Resumen y conexión

CASE WHEN ... THEN ... ELSE ... END es el if/else de SQL — clasificar datos en la consulta.
COALESCE(v1, v2) devuelve el primer valor no-NULL — reemplazar datos faltantes.
NULLIF(a, b) devuelve NULL si a=b — evitar divisiones por cero.
CAST(val AS tipo) convierte tipos. ROUND(val, n) redondea.
Columnas calculadas (col * 1.21 AS con_iva) crean datos derivados sin tocar la tabla original.
SUM(CASE WHEN ... THEN 1 ELSE 0 END) cuenta condicionalmente.

En la siguiente lección (04 · ORDER BY, LIMIT, DISTINCT) vas a aprender a ordenar, paginar y deduplicar resultados.

Hecho con ❤️ por Rodri Gonzalez