Introducción a SQL: SELECT, WHERE y ORDER BY

SQL (Structured Query Language) es el lenguaje para pedirle datos a una base de datos. En lugar de abrir un archivo y filtrar con el mouse, escribes una instrucción como «dame los pedidos de Lima por la web, del más caro al más barato» y la base de datos te devuelve el resultado, aunque la tabla tenga millones de filas. Casi todas las empresas guardan sus ventas, clientes e inventarios en bases de datos, por eso SQL aparece en la gran mayoría de ofertas de analista. La buena noticia: con media docena de palabras clave ya puedes hacer consultas útiles.

Qué es una base de datos relacional

Una base de datos relacional guarda la información en tablas (como hojas de Excel con reglas estrictas): cada columna tiene un tipo de dato fijo y cada fila es un registro. Las tablas se relacionan entre sí por columnas comunes; por ejemplo, la tabla ventas y la tabla regiones comparten la columna region. Los sistemas más conocidos son PostgreSQL, MySQL, SQL Server, Oracle, SQLite y, en la nube, BigQuery o Snowflake. Cada uno tiene pequeñas diferencias, pero lo que aprenderás aquí funciona en todos.

Prepara tu base de datos de práctica

La forma más sencilla y fiable de crearla es con Python, aunque todavía no sepas programar: copia este código en Google Colab (gratis, en el navegador) o en tu computadora, con los dos archivos del curso en la misma carpeta, y ejecútalo:

import sqlite3
import pandas as pd

archivo = "ventas-practica-analisis.xlsx"
con = sqlite3.connect("nexo.db")

ventas = pd.read_excel(archivo, sheet_name="Ventas_limpias")
ventas["fecha"] = ventas["fecha"].dt.strftime("%Y-%m-%d")
ventas.to_sql("ventas", con, index=False, if_exists="replace")

pd.read_excel(archivo, sheet_name="Regiones").to_sql(
    "regiones", con, index=False, if_exists="replace")
pd.read_csv("ventas-practica-analisis.csv").to_sql(
    "ventas_sin_limpiar", con, index=False, if_exists="replace")

print(pd.read_sql("SELECT COUNT(*) AS filas FROM ventas", con))   # 197
con.close()

Se crea el archivo nexo.db. Ábrelo con DB Browser for SQLite (programa gratuito), ve a la pestaña «Ejecutar SQL» y ya puedes escribir consultas. Las fechas se guardan como texto en formato AAAA-MM-DD, que se ordena y compara correctamente. Si quieres entender el código, el curso de Python lo explica en la lección de bases de datos con SQLite y SQL.

Anatomía de una consulta

Una consulta básica se escribe siempre en este orden. Solo SELECT y FROM son obligatorias:

1. SELECT: qué columnas
2. FROM: de qué tabla
3. WHERE: qué filas
4. ORDER BY: en qué orden
5. LIMIT: cuántas filas

SELECT y FROM: elige columnas

La consulta más simple muestra todas las columnas (*) de una tabla. Con LIMIT ves solo las primeras filas, ideal para conocer una tabla nueva sin cargarla entera:

SELECT *
FROM ventas
LIMIT 5;

Para ver valores sin repetir, usa DISTINCT. Esta consulta devuelve las 4 categorías, en orden alfabético: Accesorios, Audio, Cómputo y Oficina.

SELECT DISTINCT categoria
FROM ventas
ORDER BY categoria;

También puedes crear columnas calculadas y ponerles nombre con AS (alias). Esta consulta recalcula el importe de los pedidos con 8 unidades o más:

SELECT id_pedido, producto, unidades, precio_unitario,
       unidades * precio_unitario AS importe_calculado
FROM ventas
WHERE unidades >= 8
ORDER BY unidades DESC, id_pedido;

Curioso: todos los pedidos de 8 unidades o más son de mouse. Los compradores de volumen buscan productos baratos, una pista que retomarás al estudiar correlaciones.

WHERE: filtra las filas

WHERE deja pasar solo las filas que cumplen la condición. Estos son los operadores que más usarás:

Los textos y las fechas van entre comillas simples. Una consulta típica combina WHERE, ORDER BY y LIMIT para responder una pregunta tipo «top 5»: ¿cuáles fueron los cinco pedidos web más grandes de Lima?

SELECT id_pedido, fecha, producto, importe
FROM ventas
WHERE region = 'Lima' AND canal = 'Web'
ORDER BY importe DESC
LIMIT 5;

El resultado de la consulta como gráfico: cada barra, proporcional al pedido más grande (1.298 USD). Dos pedidos concentran la mayor parte del valor del top 5.

Dato curioso: P-0153 y P-0131 venían escritos como «lima» y «Lima » en la tabla sin limpiar. En ventas_sin_limpiar, esta misma consulta no los encontraría, porque en SQLite (y en PostgreSQL) el = distingue mayúsculas y espacios.

BETWEEN, IN y LIKE en acción

¿Qué laptops se vendieron en las regiones de Perú? Usamos LIKE para el producto e IN para la lista de regiones:

SELECT id_pedido, fecha, region, unidades, importe
FROM ventas
WHERE producto LIKE 'Laptop%'
  AND region IN ('Lima', 'Arequipa', 'La Libertad')
ORDER BY fecha;

Arequipa compró más laptops que Lima, y todas en el segundo semestre. Para fechas, BETWEEN incluye los dos extremos: WHERE fecha BETWEEN '2025-12-24' AND '2025-12-31' devuelve los 5 pedidos de la última semana del año (P-0193 a P-0197).

Buscar vacíos: IS NULL

En SQL, un valor vacío es NULL y no se compara con =. En la tabla sin limpiar:

SELECT id_pedido, region, producto, unidades, precio_unitario, importe
FROM ventas_sin_limpiar
WHERE importe IS NULL;

Son los 4 importes vacíos que corregiste en la lección 5. Si escribes WHERE importe = NULL, la consulta devuelve 0 filas sin dar error: NULL significa «desconocido», y nada es igual a algo desconocido.

La trampa de AND y OR

AND se evalúa antes que OR, igual que la multiplicación antes que la suma. Mira la diferencia entre estas dos consultas que parecen iguales:

-- Sin paréntesis: devuelve 101 filas
SELECT COUNT(*) FROM ventas
WHERE canal = 'Web' OR canal = 'Marketplace' AND importe > 500;

-- Con paréntesis: devuelve 14 filas
SELECT COUNT(*) FROM ventas
WHERE (canal = 'Web' OR canal = 'Marketplace') AND importe > 500;

La primera se lee como «todos los pedidos web (94), más los de Marketplace mayores a 500 (7)». La segunda es lo que probablemente querías: pedidos de cualquiera de los dos canales que superan 500. COUNT(*) cuenta filas; lo verás a fondo en la próxima lección. Regla práctica: siempre que mezcles AND y OR, usa paréntesis.

En qué orden «piensa» la base de datos

Escribes SELECT primero, pero la base de datos lo procesa en otro orden: FROM → WHERE → SELECT → ORDER BY → LIMIT. Primero toma la tabla, luego filtra filas, después elige y calcula columnas, ordena y, al final, corta. Por eso puedes ordenar por un alias creado en SELECT (ORDER BY importe_calculado), pero en muchos sistemas no puedes usar ese alias dentro de WHERE.

Errores comunes (y qué hacer en su lugar)

-- 1
SELECT id_pedido, fecha, producto, importe
FROM ventas
WHERE region = 'Bogotá' AND canal = 'Marketplace' AND importe > 100
ORDER BY importe DESC;

-- 2
SELECT id_pedido, fecha, region, canal, importe
FROM ventas
WHERE categoria = 'Oficina' AND importe >= 300
ORDER BY importe DESC;

Resumen

• SQL consulta bases de datos relacionales: tablas con tipos fijos que se relacionan por columnas comunes.
• SELECT elige columnas (con alias y cálculos), FROM la tabla y DISTINCT quita repetidos.
• WHERE filtra con comparaciones, BETWEEN, IN, LIKE e IS NULL; los textos van entre comillas simples.
• ORDER BY ordena y LIMIT corta: juntos responden preguntas de tipo «top N».
• Al mezclar AND y OR, usa paréntesis: 101 filas frente a 14 pueden ser la misma consulta mal escrita.

En la próxima lección: SQL intermedio: GROUP BY, HAVING y JOIN. Resumirás ventas por región y canal, filtrarás grupos y unirás la tabla de ventas con la de regiones para analizar por país.