SQL WHERE: filtra filas con AND, OR y NULL

La cláusula SQL WHERE es una cláusula SQL que filtra filas de una tabla según una condición. En una consulta SQL con cláusula WHERE, las filas coinciden solo cuando el predicado se evalúa como TRUE; tanto FALSE como NULL/UNKNOWN se excluyen. Esta lógica de tres valores es la fuente más común de comportamientos inesperados de WHERE alrededor de NULL.

Ejemplo de SQL WHERE para filtrar filas

Editor de SQL

CREATE TABLE productos (nombre TEXT, categoria TEXT, precio REAL);
INSERT INTO productos VALUES
  ('Teclado', 'Electrónica', 49.99),
  ('Ratón', 'Electrónica', 25.00),
  ('Cuaderno', 'Oficina', 4.50),
  ('Monitor', 'Electrónica', 299.00);
SELECT nombre, categoria, precio
FROM productos
WHERE categoria = 'Electrónica' AND precio < 100;

Salida:

La salida aparecerá aquí...

Salida:

+---------+-------------+--------+
| nombre  | categoria   | precio |
+---------+-------------+--------+
| Teclado | Electrónica | 49.99  |
| Ratón   | Electrónica | 25.0   |
+---------+-------------+--------+
2 row(s)

Cómo funciona este ejemplo

CREATE TABLE e INSERT crean una tabla productos con cuatro filas en dos categorías.
La cláusula SQL WHERE categoria = 'Electrónica' AND precio < 100 combina dos condiciones con AND; ambas deben ser TRUE para que aparezca una fila.
“Monitor” está en Electrónica pero cuesta 299.00, así que la condición de precio lo elimina. “Cuaderno” no cumple la comprobación de categoría. Solo “Teclado” y “Ratón” satisfacen ambos predicados.

¿Qué es una cláusula SQL WHERE?

Una cláusula SQL WHERE es un filtro booleano aplicado a cada fila de forma individual. La base de datos evalúa la expresión para cada fila candidata y conserva solo aquellas donde el resultado es TRUE. Cualquier expresión que devuelva FALSE o NULL se descarta. WHERE opera antes de GROUP BY y de las funciones de agregación, lo que la diferencia de HAVING.

Errores comunes en cláusulas SQL WHERE

Error: Comparar una columna con NULL usando =.

Incorrecto:

WHERE categoria = NULL

Correcto:

WHERE categoria IS NULL

Por qué: = NULL se evalúa como UNKNOWN, y WHERE filtra las filas UNKNOWN. Usa IS NULL o IS NOT NULL.

Error: Mezclar AND y OR sin paréntesis.

Incorrecto:

WHERE categoria = 'Oficina' OR categoria = 'Electronica' AND precio < 50

Correcto:

WHERE (categoria = 'Oficina' OR categoria = 'Electrónica') AND precio < 50

Por qué: AND tiene mayor precedencia que OR, así que los paréntesis son necesarios para reflejar tu intención.

WHERE vs HAVING

WHERE	HAVING
Filtra filas individuales antes de agrupar	Filtra grupos después de agregar
No puede referenciar funciones de agregación	Puede referenciar `COUNT`, `SUM`, etc.
Reduce las filas que entran a `GROUP BY`	Reduce grupos en el resultado final

Regla: usa WHERE para excluir filas antes de agregar, y HAVING para excluir grupos después. Filtrar pronto con WHERE reduce el trabajo de la etapa de agregación.

Consideraciones de rendimiento

Los predicados WHERE sobre columnas indexadas convierten escaneos completos de tabla en búsquedas por índice. Envolver la columna en una función (LOWER(nombre), DATE(created_at)) impide que el optimizador use el índice; transforma el valor de comparación en su lugar. Para condiciones conectadas con AND, un índice compuesto que siga el orden de las columnas del predicado ofrece el mejor rendimiento. Las condiciones con OR suelen producir escaneos de índice separados que luego se combinan, lo que es más lento que AND sobre el mismo índice.

Notas de seguridad

Construye condiciones WHERE con consultas parametrizadas, nunca concatenando la entrada del usuario en cadenas SQL. Para nombres de columna dinámicos, valida contra una lista de permitidos estricta. Para listas IN (...), genera placeholders y enlaza cada valor. Antes de ejecutar UPDATE y DELETE, previsualiza siempre con un SELECT usando la misma cláusula WHERE.

FAQ

¿Cuál es la diferencia entre WHERE y HAVING en SQL?

WHERE filtra filas antes de GROUP BY; HAVING filtra grupos agregados después. WHERE no puede referenciar funciones de agregación como COUNT() o SUM(). Una consulta puede usar ambas: WHERE reduce las filas de entrada y luego HAVING reduce la salida agrupada.

¿Por qué `= NULL` no funciona en una cláusula WHERE?

SQL usa lógica de tres valores: TRUE, FALSE y UNKNOWN. Cualquier comparación con NULL devuelve UNKNOWN, y WHERE descarta las filas UNKNOWN. Usa IS NULL para comprobar valores NULL. Algunas bases de datos también admiten IS NOT DISTINCT FROM para comparaciones de igualdad seguras con NULL.

¿El orden de la cláusula WHERE afecta al rendimiento?

El estándar SQL no garantiza el orden de evaluación, y la mayoría de optimizadores reordenan predicados internamente. Escribe las condiciones en el orden más legible. El rendimiento depende de qué columnas estén indexadas y de la selectividad de cada predicado, no del orden en que lo escribes.