Conversión de tipos: CAST, COALESCE y NULLIF — Aprende SQL

Aprende SQL · lección gratuita

Lección 12 · Conversión de tipos: CAST, COALESCE y NULLIF

Resumen

SQLite usa tipado dinámico: una columna puede contener valores de distinto tipo y el motor convierte implícitamente cuando mezclas tipos en una operación. Estas conversiones automáticas son cómodas pero peligrosas (la división entera, el texto comparado con números). CAST te da control explícito del tipo; COALESCE y NULLIF gestionan los NULL, que aparecen en cuanto haces un LEFT JOIN o agregas sobre conjunto vacío.

CAST(x AS tipo): convierte explícitamente. CAST('42' AS INTEGER), CAST(salario AS REAL), CAST(precio AS TEXT).
Conversión implícita: SQLite convierte solo cuando puede. '10' + 5 → 15 (texto numérico se convierte); 'abc' + 5 → 5 (texto no numérico se trata como 0).
COALESCE(a, b, c, ...): devuelve el primer argumento no NULL. Ideal para valores por defecto: COALESCE(SUM(x), 0).
NULLIF(a, b): devuelve NULL si a = b, si no devuelve a. Su uso estrella: evitar división por cero con x / NULLIF(divisor, 0).
NULL es contagioso: cualquier operación aritmética o concatenación con NULL da NULL; por eso se neutraliza con COALESCE.

Sintaxis / Conceptos

Conversiones implícitas: lo que SQLite hace por ti (y a veces en tu contra)

Cuando mezclas tipos, SQLite aplica reglas de afinidad. Al sumar un TEXT con un INTEGER, intenta leer el texto como número: '10' + 5 da 15, pero '10 cajas' + 5 da 15 también (lee el prefijo numérico) y 'cajas' + 5 da 5 (el texto no numérico vale 0). En comparaciones, '5' = 5 puede ser falso porque compara texto contra número según la afinidad de la columna. La lección: no confíes en la conversión implícita; cuando importa el tipo, usa CAST.

CAST y la división entera (repaso aplicado)

CAST es la herramienta para forzar el tipo de una operación. Para que total_pedidos / total_clientes no se trunque a entero, conviertes uno a real: CAST(total_pedidos AS REAL) / total_clientes. También se usa para ordenar correctamente texto numérico: ORDER BY CAST(codigo AS INTEGER).

COALESCE: rellenar NULL tras un LEFT JOIN

Cuando un LEFT JOIN no encuentra coincidencia, las columnas de la tabla derecha quedan en NULL. Si luego sumas o cuentas, esos NULL distorsionan el reporte. COALESCE(columna, valor_por_defecto) sustituye el NULL: típicamente COALESCE(SUM(revenue), 0) para mostrar 0 en lugar de vacío, o COALESCE(nombre_jefe, 'Sin jefe') para etiquetas. Acepta varios argumentos y devuelve el primero no nulo, encadenando preferencias.

NULLIF: el guardián de la división por cero

NULLIF(a, b) devuelve NULL si ambos son iguales. El patrón canónico es numerador / NULLIF(denominador, 0): si el denominador es 0, NULLIF lo convierte en NULL y la división da NULL (en lugar de error o infinito), que luego puedes envolver en COALESCE para mostrar 0. También sirve para tratar un valor centinela como ausente: NULLIF(descuento, 0).

SELECT nombre, salario, ROUND(CAST(salario AS REAL) / 12, 2) AS salario_mensual FROM empleados LIMIT 5

Ejemplos

-- Conversión implícita vs explícita: el clásico error de la división entera.
-- La primera columna trunca; la segunda usa CAST para obtener decimales.
SELECT
  (SELECT COUNT(*) FROM pedidos)  AS total_pedidos,
  (SELECT COUNT(*) FROM clientes) AS total_clientes,
  (SELECT COUNT(*) FROM pedidos) / (SELECT COUNT(*) FROM clientes)                       AS promedio_entero,
  ROUND(CAST((SELECT COUNT(*) FROM pedidos) AS REAL) / (SELECT COUNT(*) FROM clientes), 2) AS promedio_real;

-- COALESCE tras LEFT JOIN: revenue por empleado, mostrando 0 a quien no vendió.
-- Solo los empleados 9-12 tienen pedidos; el resto saldría NULL sin COALESCE.
SELECT
  e.nombre,
  COALESCE(SUM(d.cantidad * d.precio_unitario * (1 - d.descuento)), 0) AS revenue
FROM empleados e
LEFT JOIN pedidos p        ON p.empleado_id = e.id
LEFT JOIN detalle_pedidos d ON d.pedido_id = p.id
GROUP BY e.id, e.nombre
ORDER BY revenue DESC, e.id
LIMIT 10;

-- NULLIF para evitar división por cero al calcular ratio stock/ventas.
-- Productos 21-24 no tienen ventas; NULLIF evita el error y devuelve NULL.
SELECT
  p.nombre,
  p.stock,
  COALESCE(SUM(d.cantidad), 0) AS unidades_vendidas,
  ROUND(p.stock * 1.0 / NULLIF(SUM(d.cantidad), 0), 2) AS ratio_stock_ventas
FROM productos p
LEFT JOIN detalle_pedidos d ON d.producto_id = p.id
GROUP BY p.id, p.nombre, p.stock
ORDER BY p.id
LIMIT 8;

-- CAST de texto a número: strftime devuelve texto, lo convertimos para comparar.
SELECT
  id,
  fecha,
  CAST(strftime('%m', fecha) AS INTEGER) AS mes_numerico
FROM pedidos
WHERE CAST(strftime('%m', fecha) AS INTEGER) BETWEEN 1 AND 3
ORDER BY fecha
LIMIT 6;

💡 La regla de oro: NULL no es 0 ni cadena vacía; es "desconocido", y contagia toda operación. Usa COALESCE para darle un valor por defecto y NULLIF(x, 0) antes de dividir. Cuando un cálculo numérico te dé resultados raros, sospecha de una conversión implícita y haz el tipo explícito con CAST.

Cheatsheet

Función	Qué hace
`CAST(x AS INTEGER)`	Convierte/trunca a entero
`CAST(x AS REAL)`	Convierte a punto flotante (fuerza división decimal)
`CAST(x AS TEXT)`	Convierte a texto
`COALESCE(a, b, ...)`	Primer valor no NULL (valores por defecto)
`NULLIF(a, b)`	NULL si `a = b`; evita división por cero con `NULLIF(d, 0)`
`typeof(x)`	Devuelve el tipo dinámico del valor (`'integer'`, `'text'`, `'null'`...)

---

← Fechas y tiempo Funciones de agregación: COUNT, SUM, AVG, MIN, MAX →

Ver todas las lecciones de Aprende SQL →