Fundamentos de SQL

Hasta ahora leías la tabla entera. Aquí empiezas a hacer preguntas

En el módulo anterior aprendiste a elegir columnas con SELECT. Pero una consulta como SELECT * FROM productos te devuelve todas las filas, y casi nunca quieres todas. En el trabajo real las preguntas suenan así:

• «¿Qué productos cuestan más de 500.000?»
• «¿Qué ventas se hicieron en Bogotá?»
• «¿Qué productos están agotados (stock igual a 0)?»

Todas esas preguntas filtran filas según una condición. Esa es exactamente la tarea de la cláusula WHERE. Al terminar esta lección podrás escribir condiciones con los seis operadores de comparación (=, <>, <, >, <=, >=) para quedarte solo con las filas que te interesan.

Trabajamos sobre tienda_tech, la base de datos de una tienda de tecnología con dos tablas: productos (el catálogo) y ventas (cada transacción). Es el mismo dataset de todo el curso, así que las consultas que escribas aquí te servirán tal cual en las siguientes lecciones.

La forma de una consulta con WHERE

WHERE se escribe después de FROM y recibe una condición. La base de datos evalúa esa condición fila por fila: si para una fila la condición es verdadera, la fila entra en el resultado; si es falsa, se descarta.

SELECT columnas
FROM tabla
WHERE condición;

Piénsalo como un portero en la puerta: revisa cada fila de una en una y solo deja pasar las que cumplen la regla. Ejecuta este primer ejemplo, que se queda solo con los productos de la categoría Monitores:

De las 12 filas del catálogo, solo salieron 2: las dos que cumplen categoria = 'Monitores'. El operador = compara por igualdad exacta.

Dos detalles clave que ya viste en acción:

• El texto va entre comillas simples: 'Monitores', no "Monitores". En PostgreSQL las comillas dobles son para nombres de columnas o tablas, no para valores de texto.
• La comparación de texto distingue mayúsculas y minúsculas. 'monitores' (en minúscula) no encontraría nada, porque en la tabla está guardado como 'Monitores'.

Los seis operadores de comparación

Una condición compara un valor de la fila (normalmente una columna) con otro valor usando uno de estos operadores:

El operador «distinto de» estándar es <>. PostgreSQL también acepta != como sinónimo, pero <> es el que funciona en todas las bases de datos; acostúmbrate a ese.

Comparaciones numéricas: mayor que, menor que

Los operadores <, >, <= y >= funcionan igual de bien con números. Esta consulta responde «¿qué productos cuestan más de 500.000?»:

Fíjate en la diferencia entre > y >=. Un producto que costara exactamente 500000 no aparecería con precio > 500000, pero sí con precio >= 500000. Cuando el límite importa (por ejemplo «al menos 500.000»), elige el operador con el = incluido.

Ahora cambiemos de tabla. Esta consulta filtra la tabla ventas para responder «¿qué ventas ocurrieron en Bogotá?»:

«Distinto de» con <>

A veces quieres justo lo contrario: todas las filas excepto las que cumplen algo. Para eso está <>. Esta consulta lista todas las ventas que no fueron en Bogotá:

Tu turno: predice antes de ejecutar

La tabla productos tiene 12 filas. La siguiente consulta busca los productos agotados, es decir, con stock igual a 0. Antes de darle a ejecutar, mira el catálogo mentalmente: ¿cuántas filas crees que saldrán? Luego ejecútala y comprueba tu predicción.

Salen exactamente 2 filas (Monitor 24" Full HD y Webcam 1080p), las únicas con stock = 0. Si predijiste ese número, ya estás pensando como piensa la base de datos: recorriendo fila por fila y quedándote solo con las que cumplen la condición.

Cómo se evalúa la condición, fila por fila

Merece la pena ver el mecanismo con calma, porque entenderlo evita casi todos los errores de principiante. Para WHERE stock = 0, la base de datos hace, literalmente, esto con cada fila del catálogo:

La condición nunca mira «la tabla entera» de golpe: solo sabe responder verdadero/falso para una fila a la vez. Por eso una condición siempre se escribe en términos de una sola fila (stock = 0, ciudad = 'Bogotá'), nunca sobre el conjunto completo.

Dos errores clásicos (y cómo evitarlos)

1. Usar = cuando querías <>. Son opuestos y es facilísimo confundirlos al leer una pregunta de negocio. «Productos que no sean accesorios» es categoria <> 'Accesorios', no =. Lee la condición en voz alta: si dice «no es / distinto de / excepto», necesitas <>.

2. Olvidar las comillas simples en el texto (o usar comillas dobles). El texto siempre va entre comillas simples. Compara estas dos consultas: la primera es correcta; la segunda falla porque PostgreSQL interpreta "Bogotá" como el nombre de una columna llamada Bogotá, que no existe.

Ese mensaje de error (column "Bogotá" does not exist) es uno de los más comunes al empezar. Cuando lo veas, revisa que tus valores de texto lleven comillas simples. Los números, en cambio, van sin comillas: precio > 500000, nunca precio > '500000'.

Practica: filtra tú mismo

Toca ponerlo en práctica y recibir corrección automática. Lee el enunciado, completa la consulta y pulsa Comprobar. El resultado sale en el orden natural en que están las filas en la tabla (por eso las filas de enero aparecen antes que las de febrero); todavía no usamos ORDER BY —lo verás en el módulo siguiente—, así que respeta ese orden.

Recapitulación

• WHERE filtra filas según una condición que se evalúa fila por fila.
• Los seis operadores de comparación son =, <>, <, >, <=, >=. <> significa «distinto de».
• Elige >= / <= (con el =) cuando el valor límite debe entrar; usa > / < cuando debe quedar fuera.
• El texto va entre comillas simples y distingue mayúsculas; los números van sin comillas.

En la próxima lección combinarás varias condiciones a la vez con AND, OR y NOT para preguntas más ricas, como «monitores que cuesten más de 500.000 y estén en stock».

Comprueba lo aprendido

Responde antes de continuar: fijar el concepto ahora es lo que hace que se te quede.

Y una última pregunta de retención, con corrección automática. Escribe la consulta que responde «¿qué productos NO son de la categoría Accesorios?» mostrando su nombre y categoría: