WHERE: separar las filas verdaderas de las falsas

En la lección anterior ya filtraste filas con WHERE. Ahora miramos bien qué puede decir una condición, porque en el filtrado nacen la mayoría de las respuestas equivocadas. La cafetería lleva una segunda tabla, orders, con una fila por pedido: qué se compró, por cuánto y si está pagado. Una fila tiene paid = NULL: la cafetería todavía no lo sabe.

orders
+----+--------+-------+----------+
| id | item   | price | paid     |
+----+--------+-------+----------+
| 1  | soup   | 2.50  | yes      |
| 2  | salad  | 2.80  | no       |
| 3  | juice  | 1.90  | yes      |
| 4  | juice  | 1.90  | NULL     |
| 5  | soup   | 2.50  | yes      |
+----+--------+-------+----------+La tabla orders: una fila por pedido, y un valor desconocido en paid.

Una comparación como price < 2.00 o paid = 'yes' no describe la tabla — es una pregunta que le haces a cada fila por separado. Cada fila responde sí, no o no puedo decirlo. WHERE conserva exactamente las filas que dicen sí. Por eso la misma consulta puede devolver mañana otra cantidad de filas: la pregunta es estable, los datos no.

Lee ambas consultas sobre la tabla orders y predice las filas antes de mirar la respuesta. AND estrecha: una condición va sobre el pago, la otra sobre el precio, y deben cumplirse las dos. OR ensancha: una fila sobrevive si al menos un lado es verdadero, así que el precio por sí solo salva a las filas baratas.

WHERE paid = 'yes' AND price < 2.00
rows kept: juice (1.90, yes)

WHERE paid = 'yes' OR price < 2.00
rows kept: soup, juice, juice, soupDos condiciones sobre la misma tabla: filas que deja AND y luego OR.

AND ata más fuerte que OR, exactamente como la multiplicación antes que la suma en aritmética. Si quieres decir otra cosa, pon paréntesis. WHERE a = 1 OR b = 2 AND c = 3 significa a = 1 OR (b = 2 AND c = 3), y la gente se equivoca en esto constantemente — los paréntesis no cuestan nada.

La igualdad exige que coincida el valor entero. LIKE compara en cambio con un patrón: % representa cualquier texto de cualquier longitud, incluido nada. Así, dish LIKE 'veggie%' atrapa todo lo que empieza por veggie, y '%soup%' todo lo que contiene soup en cualquier parte.

menu
+----+---------------+
| id | dish          |
+----+---------------+
| 1  | veggie soup   |
| 2  | chicken soup  |
| 3  | veggie salad  |
+----+---------------+

WHERE dish LIKE 'veggie%'    matches: veggie soup, veggie salad
WHERE dish LIKE '%soup%'     matches: veggie soup, chicken soupLa tabla menu y dos patrones LIKE sobre la columna dish.

Ahora la regla más extraña de SQL. La fila con paid = NULL desaparece de todas las consultas con comparaciones. No solo de paid = 'no' ni solo de paid = 'yes' — de las dos. Para entender por qué, mira qué es en realidad NULL.

WHERE paid = 'yes'
rows kept: soup (1), juice (3), soup (5)
row 4: paid is NULL, dropped

NULL = NULL  is  not true, it is unknownPor qué paid = 'yes' suelta la fila con NULL, y por qué NULL = NULL no es verdadero.

NULL no es un valor, es la ausencia de uno: la cafetería todavía no sabe si ese pedido se pagó. Preguntar si algo desconocido es igual a yes es como preguntar si mi dolor de cabeza de mañana es igual a yes: la respuesta honesta no es no, es desconocido. SQL llama a eso unknown, y WHERE solo conserva lo true, así que la fila se descarta.