SQLite y NULL: IS NULL, COALESCE e IFNULL

NULL significa "desconocido"

Cualquier otro valor en SQLite representa algo concreto: un número, una cadena, un blob. NULL es distinto. Es un marcador que indica un valor ausente o desconocido. Esa sola idea explica todas las rarezas que vas a ver al manejar valores NULL en SQLite.

Vamos a crear una tablita pequeña para hacer pruebas:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT * FROM users;

Dos columnas permiten valores nulos. Boris no tiene email. Cleo no tiene edad. Dan no tiene ninguno de los dos. El resto de la página trata sobre cómo consultar filas como estas sin caer en trampas.

= y <> no funcionan con NULL

Lo primero que se te ocurre es escribir WHERE email = NULL. Parece razonable. Y no devuelve nada:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email FROM users WHERE email = NULL;

Cero filas, aunque a simple vista Boris y Dan tienen el email en NULL. El motivo: al comparar cualquier cosa con NULL, el resultado es NULL, no verdadero ni falso. Y la cláusula WHERE de SQLite solo conserva las filas cuya condición sea verdadera; como NULL no lo es, la fila se descarta.

La misma trampa aparece con <>:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email FROM users WHERE email <> 'ada@example.com';

Esperarías que esto devolviera a todos menos a Ada. Pero solo devuelve a Cleo. Boris y Dan, cuyos correos son nulos, quedan fuera, porque NULL <> 'ada@example.com' también da NULL, no true.

Este es el típico tropiezo con SQL, el más común de todos. Cada vez que una consulta "pierde filas" sin que te lo esperes, sospecha de alguna columna con valores nulos.

Cómo usar IS NULL e IS NOT NULL en SQLite

La forma correcta de comprobar si un valor es nulo es con el operador IS. A diferencia de =, este sí entiende los nulos y siempre devuelve true o false, nunca NULL:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name FROM users WHERE email IS NULL;

SELECT name FROM users WHERE email IS NOT NULL;

La primera consulta devuelve a Boris y Dan. La segunda, a Ada y Cleo. IS NULL e IS NOT NULL son los dos operadores pensados precisamente para preguntar "¿falta este valor?". Úsalos siempre que te den ganas de escribir = NULL o <> NULL.

Si lo que buscas es "todos menos Ada, incluyendo los desconocidos", combina ambas comprobaciones de forma explícita:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, email
FROM users
WHERE email <> 'ada@example.com' OR email IS NULL;

Ahora aparecen Boris, Cleo y Dan.

NULL se propaga en operaciones aritméticas y concatenación

La regla de "valor desconocido" no se limita a las comparaciones. Cualquier operación que toque un NULL devuelve NULL:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    age,
    age + 1       AS next_year,
    age * 2       AS doubled,
    'Hola ' || name AS greeting,
    'Edad: ' || age AS labelled_age
FROM users;

next_year y doubled son NULL para Cleo y Dan. labelled_age también queda en NULL: al concatenar una cadena con NULL, el resultado es NULL, no 'Edad: '. Si una columna puede contener nulos y necesitas un valor utilizable al final, tendrás que manejarlo a mano. Para eso entran en juego las dos funciones que veremos a continuación.

IFNULL: valor por defecto con dos argumentos

IFNULL(a, b) devuelve a salvo que sea nulo; en ese caso devuelve b. Es la forma más sencilla de sustituir un NULL por un valor por defecto:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    IFNULL(email, '(sin correo)') AS email,
    IFNULL(age, 0)                AS age
FROM users;

Boris y Dan reciben (sin correo). Cleo y Dan reciben 0. Los datos originales no cambian: IFNULL solo reescribe la salida.

IFNULL siempre recibe exactamente dos argumentos. Si necesitas más alternativas, lo tuyo es COALESCE.

COALESCE: gana el primer valor no NULL

COALESCE(a, b, c, ...) recorre sus argumentos en orden y devuelve el primero que no sea NULL. Es la versión generalizada de IFNULL, pero admite tantas alternativas como quieras:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    name,
    COALESCE(email, name || '@desconocido.local', 'anónimo') AS contact
FROM users;

En el caso de Ada y Cleo se usa el email. Para Boris y Dan, el email es nulo, así que SQLite pasa al segundo argumento: una dirección generada a partir del nombre. Si ese también fuera nulo, caería al valor 'anónimo'.

COALESCE es la opción portable: todas las bases de datos SQL importantes la soportan de la misma forma. IFNULL, en cambio, es un atajo de SQLite y MySQL para cuando solo tienes dos argumentos. Tira de COALESCE por defecto y reserva IFNULL para los casos en los que realmente solo manejas dos argumentos y prefieras el nombre más corto.

NULL no es lo mismo que una cadena vacía

Una confusión muy habitual: tratar NULL y '' como si fueran intercambiables. No lo son.

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT
    '' IS NULL          AS empty_is_null,
    NULL IS NULL        AS null_is_null,
    length('')          AS empty_length,
    length(NULL)        AS null_length,
    '' = ''             AS empty_equals_empty,
    NULL = NULL         AS null_equals_null;

'' es una cadena real que casualmente tiene cero caracteres. NULL, en cambio, es la ausencia de valor. length('') da 0; length(NULL) da NULL. Y NULL = NULL no devuelve 1, sino NULL, y por eso mismo existe IS NULL.

Si una columna puede contener tanto '' como NULL, decide cuál de los dos representa "sin valor" y mantén ese criterio. Mezclarlos te obliga a contemplar dos casos en cada consulta y, tarde o temprano, se te va a escapar uno.

NULL con IN, NOT IN y DISTINCT

Hay un par de sitios más donde el null te tiende emboscadas.

Usar IN con una lista que contiene null puede dar resultados inesperados, sobre todo con NOT IN:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT name, age FROM users WHERE age NOT IN (25, NULL);

Uno esperaría obtener todas las personas cuya edad sea distinta de 25. Pues no devuelve nada. SQLite expande NOT IN (25, NULL) a algo parecido a age <> 25 AND age <> NULL, y age <> NULL siempre da NULL, así que la condición jamás se cumple. La solución pasa por descartar los nulos de la lista (o de la columna) antes de hacer la comparación.

DISTINCT, en cambio, sí considera iguales entre sí los valores NULL a la hora de eliminar duplicados:

CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    email  TEXT,
    age    INTEGER
);

INSERT INTO users (name, email, age) VALUES
    ('Ada',   'ada@example.com', 30),
    ('Boris', NULL,              25),
    ('Cleo',  'cleo@example.com', NULL),
    ('Dan',   NULL,              NULL);

SELECT DISTINCT email FROM users;

Obtienes tres filas: el email de Ada, el de Cleo y un único NULL (colapsado a partir de Boris y Dan). Lo mismo ocurre con GROUP BY y UNION: tratan los nulos como un solo grupo, justo lo contrario de lo que hace =. SQL no siempre es coherente en este punto, así que conviene tener claro de qué lado cae cada operador.

Checklist rápido para manejar valores NULL en SQLite

• Comprueba los valores ausentes con IS NULL / IS NOT NULL. Nunca con = NULL.
• Cualquier operación aritmética, concatenación o comparación que toque un NULL devuelve NULL.
• Usa COALESCE(a, b, c, ...) para sustituir nulos por un valor por defecto. IFNULL(a, b) es el atajo para dos argumentos.
• La cadena vacía '' no es lo mismo que NULL. Decide cuál representa "ausente" en cada columna y mantén el criterio.
• NOT IN (..., NULL) casi siempre es un bug. Filtra los nulos de la lista antes de usarla.

Lo siguiente: ordenar resultados

Una vez que sabes filtrar filas correctamente —incluidas las que tienen nulos—, el siguiente paso es ordenarlas de forma útil. ORDER BY es la siguiente página, y tiene sus propias reglas sobre dónde acaban los nulos dentro del resultado ordenado.