Módulo 4: Consultas, funciones y análisis de información

Una base de datos adquiere valor cuando permite responder preguntas.

Una tienda no necesita saber únicamente que existen 48 operaciones. Necesita descubrir cuánto vendió, qué productos tuvieron mayor movimiento, qué categorías generaron más ingresos, qué operaciones siguen pendientes y en qué meses cambió el comportamiento de sus clientes.

En este módulo convertirás preguntas escritas en lenguaje cotidiano en consultas SQL. Aprenderás a seleccionar, filtrar, ordenar, transformar, agrupar y resumir información sin modificar los datos originales.

El objetivo no consiste en memorizar instrucciones aisladas. La habilidad profesional consiste en comprender una necesidad, identificar los datos que intervienen, construir una consulta correcta y explicar qué significa su resultado.

Pregunta del negocio
        ↓
Datos necesarios
        ↓
Consulta SQL
        ↓
Resultado comprobado
        ↓
Conclusión útil

Principio del módulo: una consulta correcta no es la que “se ejecuta sin errores”, sino la que responde exactamente la pregunta planteada.

Antes de comenzar debes haber aprobado los módulos 1, 2 y 3. Necesitarás poder:

• Abrir y ejecutar scripts en DB Browser for SQLite.
• Reconocer tablas, columnas, filas y tipos de datos.
• Crear tablas con restricciones básicas.
• Interpretar claves primarias y foráneas.
• Insertar datos y utilizar NULL correctamente.
• Aplicar un WHERE sencillo para identificar registros.
• Guardar una base de datos y preparar evidencias.

En este módulo no utilizarás JOIN, subconsultas ni vistas. Esos recursos se estudiarán después. Todas las consultas trabajarán con una sola tabla cada vez para dominar primero el razonamiento esencial de SELECT.

Al completar el módulo serás capaz de:

• Traducir preguntas reales a consultas SQL.
• Elegir únicamente las columnas necesarias.
• Asignar alias claros a columnas y resultados calculados.
• Eliminar duplicados con DISTINCT cuando la pregunta lo requiera.
• Filtrar filas mediante comparaciones y operadores lógicos.
• Utilizar IN, BETWEEN, LIKE e IS NULL correctamente.
• Controlar condiciones complejas con paréntesis.
• Ordenar resultados por una o varias columnas.
• Limitar resultados y construir una paginación básica.
• Crear columnas calculadas sin modificar la tabla.
• Clasificar resultados mediante CASE.
• Limpiar y presentar datos con funciones de texto.
• Aplicar funciones numéricas y de fecha útiles.
• Resumir información con COUNT, SUM, AVG, MIN y MAX.
• Formar grupos con GROUP BY.
• Filtrar grupos con HAVING.
• Diferenciar con seguridad WHERE de HAVING.
• Explicar el orden lógico de una consulta.
• Detectar consultas sintácticamente válidas que responden mal una pregunta.
• Escribir SQL claro, comprobable y razonablemente portable.

Analizarás un conjunto de 48 operaciones de una tienda. El proyecto incluirá:

• Consultas de exploración.
• Filtros comerciales.
• Rankings y resultados limitados.
• Importes calculados.
• Clasificaciones con CASE.
• Limpieza de valores para presentación.
• Indicadores generales.
• Resúmenes por categoría, producto, ciudad y forma de pago.
• Filtros aplicados a grupos.
• Una explicación escrita de los resultados principales.

El archivo de datos contiene una sola tabla preparada para análisis:

operaciones_tienda
├── identificación y fecha
├── producto y categoría
├── cantidad y precio
├── descuento
├── ubicación
├── método de pago
├── estado
└── canal

Esta tabla es una fotografía de reporte. En un sistema operativo real, productos, categorías y ventas normalmente estarían separados en tablas relacionadas. Más adelante aprenderás a reunir esas tablas mediante JOIN.

Los tiempos son orientativos. Si una consulta produce un resultado inesperado, detente, formula la pregunta nuevamente y comprueba cada condición por separado.

De una pregunta a una consulta

Observa estas dos peticiones:

Muéstrame las ventas.

Muéstrame el código, el producto y el importe de las operaciones
confirmadas durante marzo de 2026, ordenadas del mayor importe al menor.

La segunda petición define:

• Qué columnas necesita.
• Qué filas deben participar.
• Qué cálculo debe realizarse.
• Qué orden debe tener el resultado.

Antes de escribir SQL, completa este análisis:

Una consulta puede contener estas cláusulas:

SELECT columnas_o_expresiones
FROM tabla
WHERE condicion_de_filas
GROUP BY columnas_de_agrupacion
HAVING condicion_de_grupos
ORDER BY criterio
LIMIT cantidad OFFSET desplazamiento;

No todas las cláusulas son obligatorias. La consulta más pequeña puede ser:

SELECT nombre
FROM productos;

SQL se escribe comenzando con SELECT, pero conceptualmente procesa la información en otro orden simplificado:

1. FROM       → localiza la fuente
2. WHERE      → descarta filas
3. GROUP BY   → forma grupos
4. HAVING     → descarta grupos
5. SELECT     → construye las columnas del resultado
6. DISTINCT   → elimina resultados repetidos
7. ORDER BY   → ordena
8. LIMIT      → conserva una parte

Este orden explica muchos errores. Por ejemplo, WHERE no puede filtrar el resultado de una función de agregación porque se aplica antes de crear los grupos. Para eso existe HAVING.

El modelo es deliberadamente simplificado y suficiente para resolver las consultas del módulo.

SELECT lee información. No cambia las filas almacenadas.

SELECT codigo, nombre, precio
FROM productos;

Puedes ejecutar una consulta varias veces y obtener el mismo resultado mientras los datos no cambien. Esta característica permite explorar y comprobar información con menos riesgo que una operación UPDATE o DELETE.

Selección de columnas, alias y valores distintos

SELECT * devuelve todas las columnas:

SELECT *
FROM productos;

Es útil para una exploración rápida durante el aprendizaje. Sin embargo, una consulta final debe indicar qué necesita:

SELECT codigo, nombre, precio
FROM productos;

Ventajas de las columnas explícitas:

• El propósito de la consulta queda claro.
• El resultado contiene menos información innecesaria.
• El orden de las columnas es controlado.
• Un cambio futuro en la tabla afecta menos la salida.
• Se evita exponer datos que no forman parte de la pregunta.

Un alias cambia el encabezado dentro del resultado; no renombra la columna almacenada.

SELECT
    codigo AS codigo_producto,
    nombre AS producto,
    precio AS precio_unitario
FROM productos;

Los alias son especialmente útiles para cálculos:

SELECT
    nombre,
    precio,
    stock,
    precio * stock AS valor_inventario
FROM productos;

Si un alias contiene espacios, SQLite permite comillas dobles:

SELECT precio * stock AS "Valor del inventario"
FROM productos;

Para scripts profesionales y reutilizables, suele ser más práctico utilizar alias sin espacios, escritos en snake_case.

Imagina una tabla con cientos de operaciones, pero solamente cuatro categorías. Esta consulta repite la categoría de cada fila:

SELECT categoria
FROM operaciones_tienda;

Para conocer qué categorías diferentes existen:

SELECT DISTINCT categoria
FROM operaciones_tienda;

DISTINCT se aplica a la combinación completa de columnas seleccionadas:

SELECT DISTINCT metodo_pago, canal
FROM operaciones_tienda;

El resultado contiene cada combinación distinta de método y canal. No significa que cada columna se haga independiente de la otra.

Pregunta de control

Si se seleccionan categoria y producto con DISTINCT, ¿se obtiene una fila por categoría?

No necesariamente. Se obtiene una fila por cada combinación diferente de categoría y producto.

Filtrado con WHERE

WHERE conserva únicamente las filas cuya condición resulta verdadera.

Ejemplo:

SELECT producto, cantidad, estado
FROM operaciones_tienda
WHERE estado = 'Confirmada';

Los textos se escriben entre comillas simples. Los números no:

SELECT producto, precio_unitario
FROM operaciones_tienda
WHERE precio_unitario >= 20;

AND: todas las condiciones deben cumplirse

SELECT producto, ciudad, estado
FROM operaciones_tienda
WHERE estado = 'Confirmada'
  AND ciudad = 'San Jose';

OR: al menos una condición debe cumplirse

SELECT producto, categoria
FROM operaciones_tienda
WHERE categoria = 'Tecnologia'
   OR categoria = 'Accesorios';

NOT: niega una condición

SELECT producto, estado
FROM operaciones_tienda
WHERE NOT estado = 'Cancelada';

También puede escribirse de forma más directa:

WHERE estado <> 'Cancelada'

AND se evalúa antes que OR. Observa:

WHERE categoria = 'Tecnologia'
   OR categoria = 'Accesorios'
  AND estado = 'Confirmada'

SQLite interpreta:

Tecnología
O
(Accesorios Y Confirmada)

Si la intención es obtener operaciones confirmadas de cualquiera de las dos categorías, escribe:

WHERE (categoria = 'Tecnologia' OR categoria = 'Accesorios')
  AND estado = 'Confirmada';

Cuando una condición combina AND y OR, utiliza paréntesis aunque conozcas la precedencia. El objetivo no es demostrar memoria, sino comunicar la regla sin ambigüedad.

En lugar de repetir muchos OR:

WHERE categoria = 'Tecnologia'
   OR categoria = 'Accesorios'
   OR categoria = 'Hogar'

puedes escribir:

WHERE categoria IN ('Tecnologia', 'Accesorios', 'Hogar')

Para excluirlos:

WHERE categoria NOT IN ('Tecnologia', 'Accesorios', 'Hogar')

SELECT fecha, producto, cantidad
FROM operaciones_tienda
WHERE fecha BETWEEN '2026-03-01' AND '2026-03-31';

BETWEEN incluye ambos extremos. Equivale a:

WHERE fecha >= '2026-03-01'
  AND fecha <= '2026-03-31'

En este curso las fechas se almacenan como texto ISO AAAA-MM-DD. Ese formato permite ordenarlas y compararlas cronológicamente cuando todas son fechas válidas y mantienen exactamente la misma estructura.

LIKE utiliza comodines:

Ejemplos:

-- Empieza con "M"
WHERE producto LIKE 'M%'

-- Contiene "escritorio"
WHERE producto LIKE '%escritorio%'

-- Tiene cualquier carácter antes de "able"
WHERE producto LIKE '_able%'

La sensibilidad a mayúsculas y minúsculas de LIKE puede variar según el motor, la configuración y los caracteres utilizados. No bases una regla crítica en ese comportamiento sin comprobar el motor de destino.

NULL representa ausencia de un valor conocido. No se compara con =:

-- Incorrecto
WHERE ciudad = NULL

-- Correcto
WHERE ciudad IS NULL

Para conservar valores conocidos:

WHERE ciudad IS NOT NULL

La expresión ciudad = NULL no resulta verdadera, aunque la celda esté vacía. En SQL, una comparación con información desconocida produce un resultado desconocido.

Orden y cantidad de resultados

Sin ORDER BY, SQL no garantiza el orden de las filas. El hecho de que hoy aparezcan por id no convierte ese orden en una promesa.

Orden ascendente:

SELECT producto, precio_unitario
FROM operaciones_tienda
ORDER BY precio_unitario ASC;

ASC es el valor predeterminado, pero escribirlo puede mejorar la claridad.

Orden descendente:

SELECT producto, precio_unitario
FROM operaciones_tienda
ORDER BY precio_unitario DESC;

SELECT categoria, producto, precio_unitario
FROM operaciones_tienda
ORDER BY categoria ASC, precio_unitario DESC, producto ASC;

El orden se interpreta de izquierda a derecha:

1. Agrupa visualmente por categoría en orden alfabético.
2. Dentro de cada categoría, coloca primero el precio mayor.
3. Si dos precios son iguales, ordena el producto alfabéticamente.

Añadir un criterio estable, como id, evita que dos filas empatadas cambien de posición entre ejecuciones:

ORDER BY fecha DESC, id DESC

Los cinco precios unitarios más altos:

SELECT DISTINCT producto, precio_unitario
FROM operaciones_tienda
ORDER BY precio_unitario DESC
LIMIT 5;

Saltar cinco resultados y mostrar los cinco siguientes:

SELECT id, fecha, producto
FROM operaciones_tienda
ORDER BY fecha DESC, id DESC
LIMIT 5 OFFSET 5;

La paginación puede imaginarse así:

Página 1: LIMIT 5 OFFSET 0
Página 2: LIMIT 5 OFFSET 5
Página 3: LIMIT 5 OFFSET 10

No utilices LIMIT para elegir “los mejores” sin definir primero ORDER BY. Sin orden, solo obtendrías una cantidad arbitraria de filas.

LIMIT es común en SQLite, MySQL y PostgreSQL. Otros motores ofrecen variantes como TOP u OFFSET ... FETCH. El propósito es el mismo, pero la sintaxis puede cambiar.

Expresiones y columnas calculadas

Una expresión produce un valor para cada fila del resultado:

SELECT
    producto,
    cantidad,
    precio_unitario,
    cantidad * precio_unitario AS subtotal
FROM operaciones_tienda;

La columna subtotal no se guarda. Se calcula cada vez que se ejecuta la consulta.

Para aplicar un descuento porcentual:

SELECT
    producto,
    cantidad * precio_unitario AS subtotal,
    descuento_porcentaje,
    cantidad * precio_unitario * descuento_porcentaje / 100.0
        AS monto_descuento,
    cantidad * precio_unitario
        * (1 - descuento_porcentaje / 100.0) AS total_neto
FROM operaciones_tienda;

El valor 100.0 comunica que la operación utiliza una proporción decimal.

SELECT
    producto,
    ROUND(
        cantidad * precio_unitario
        * (1 - descuento_porcentaje / 100.0),
        2
    ) AS total_neto
FROM operaciones_tienda;

ROUND(..., 2) mejora la presentación a dos decimales. No convierte un tipo REAL en un sistema contable exacto. Las aplicaciones financieras reales necesitan decisiones explícitas sobre moneda, precisión y redondeo.

CASE permite crear una categoría derivada:

SELECT
    producto,
    cantidad,
    CASE
        WHEN cantidad >= 8 THEN 'Volumen alto'
        WHEN cantidad >= 4 THEN 'Volumen medio'
        ELSE 'Volumen bajo'
    END AS nivel_volumen
FROM operaciones_tienda;

Las condiciones se revisan de arriba hacia abajo. La primera verdadera determina el resultado.

cantidad = 10
    ↓
¿cantidad >= 8? Sí
    ↓
'Volumen alto'

Por eso el orden importa. Si se colocara primero cantidad >= 4, una cantidad de 10 sería clasificada como volumen medio y nunca alcanzaría la condición siguiente.

CASE también puede combinar condiciones:

CASE
    WHEN estado = 'Confirmada' AND descuento_porcentaje >= 15
        THEN 'Confirmada con descuento alto'
    WHEN estado = 'Confirmada'
        THEN 'Confirmada'
    ELSE 'No concretada'
END AS clasificacion

Funciones útiles para presentar y transformar datos

Ejemplo completo:

SELECT
    UPPER(categoria) AS categoria_mayuscula,
    codigo_producto || ' - ' || producto AS producto_identificado,
    LENGTH(producto) AS caracteres_nombre
FROM operaciones_tienda;

La concatenación varía entre motores. SQLite y PostgreSQL utilizan ||; MySQL suele utilizar CONCAT(); SQL Server suele admitir +. Comprueba siempre la documentación del motor.

COALESCE devuelve el primer argumento que no sea NULL:

SELECT
    producto,
    COALESCE(ciudad, 'Ciudad no registrada') AS ciudad_presentada
FROM operaciones_tienda;

Esto no cambia el dato almacenado. Solo crea una presentación más comprensible.

COALESCE(ciudad, 'Ciudad no registrada')
       │
       ├── ciudad tiene valor → devuelve ciudad
       └── ciudad es NULL     → devuelve el texto alternativo

No confundas “mostrar un reemplazo” con “corregir la base”. Si una ciudad debe conocerse obligatoriamente, el problema debe resolverse en el diseño o en la captura del dato.

SELECT
    precio_unitario,
    ROUND(precio_unitario, 1) AS precio_redondeado,
    ABS(-precio_unitario) AS valor_absoluto
FROM operaciones_tienda;

Funciones frecuentes en SQLite:

• ROUND(numero, decimales) redondea.
• ABS(numero) obtiene el valor absoluto.
• MAX(a, b, ...) y MIN(a, b, ...) pueden comparar varios argumentos como funciones escalares en SQLite. No deben confundirse con sus usos agregados sobre muchas filas.

SQLite no posee un tipo de fecha dedicado. Puede almacenar fechas como texto ISO, números julianos o marcas de tiempo. En este curso se utiliza texto AAAA-MM-DD.

Extraer año y mes:

SELECT
    fecha,
    strftime('%Y', fecha) AS anio,
    strftime('%m', fecha) AS mes
FROM operaciones_tienda;

Presentar el primer día del mes:

SELECT
    fecha,
    date(fecha, 'start of month') AS inicio_mes
FROM operaciones_tienda;

Calcular días transcurridos entre la operación y una fecha de referencia:

SELECT
    fecha,
    CAST(julianday('2026-05-01') - julianday(fecha) AS INTEGER)
        AS dias_transcurridos
FROM operaciones_tienda;

Las funciones de fecha son una de las áreas con más diferencias entre motores. strftime() y los modificadores de date() pertenecen a SQLite. MySQL, PostgreSQL y SQL Server ofrecen herramientas equivalentes con otra sintaxis.

Guarda las fechas en un formato consistente. Una cadena como 03/04/26 es ambigua y no se ordena de forma segura como una fecha ISO.

Funciones de agregación

Una función de agregación recibe varias filas y produce un valor resumido.

Ejemplo:

SELECT
    COUNT(*) AS total_operaciones,
    SUM(cantidad) AS unidades_registradas,
    AVG(precio_unitario) AS precio_promedio,
    MIN(precio_unitario) AS precio_minimo,
    MAX(precio_unitario) AS precio_maximo
FROM operaciones_tienda;

SELECT
    COUNT(*) AS filas,
    COUNT(ciudad) AS ciudades_registradas
FROM operaciones_tienda;

COUNT(*) cuenta las 48 filas. COUNT(ciudad) ignora las filas donde ciudad es NULL.

Esta diferencia puede medir calidad de datos:

SELECT
    COUNT(*) - COUNT(ciudad) AS operaciones_sin_ciudad
FROM operaciones_tienda;

Para calcular ingresos confirmados no basta sumar precios unitarios. Cada fila posee cantidad y descuento:

SELECT
    ROUND(
        SUM(
            cantidad * precio_unitario
            * (1 - descuento_porcentaje / 100.0)
        ),
        2
    ) AS ingreso_confirmado
FROM operaciones_tienda
WHERE estado = 'Confirmada';

El orden conceptual es:

WHERE conserva operaciones confirmadas
        ↓
la expresión calcula el total de cada fila
        ↓
SUM reúne esos totales
        ↓
ROUND presenta el resultado

En general, SUM, AVG, MIN y MAX ignoran valores NULL. Esto puede ser correcto o puede ocultar un problema, según la pregunta.

Si una calificación desconocida aparece como NULL, el promedio de las conocidas no es igual a tratar la desconocida como cero. Antes de utilizar COALESCE dentro de una agregación, decide qué significa realmente la ausencia.

Agrupación con GROUP BY

Sin agrupación, la agregación resume toda la tabla. Con GROUP BY, se obtiene un resumen independiente por cada valor:

SELECT
    categoria,
    COUNT(*) AS operaciones,
    SUM(cantidad) AS unidades
FROM operaciones_tienda
GROUP BY categoria
ORDER BY unidades DESC;

Puedes imaginar que SQL separa temporalmente las filas:

Papelería  ──────┐
Tecnología ──────┼── cada grupo recibe COUNT y SUM
Accesorios ──────┤
Hogar ───────────┘

SELECT
    categoria,
    estado,
    COUNT(*) AS operaciones
FROM operaciones_tienda
GROUP BY categoria, estado
ORDER BY categoria, estado;

Cada grupo representa una combinación distinta de categoría y estado.

En una consulta agrupada, cada columna mostrada que no esté dentro de una función de agregación debe aparecer en GROUP BY.

Consulta clara y portable:

SELECT
    categoria,
    estado,
    COUNT(*) AS operaciones
FROM operaciones_tienda
GROUP BY categoria, estado;

Consulta problemática:

SELECT
    categoria,
    producto,
    COUNT(*) AS operaciones
FROM operaciones_tienda
GROUP BY categoria;

En el segundo caso hay varios productos dentro de cada categoría. ¿Cuál debería mostrarse? SQLite puede escoger el valor de una fila del grupo, pero otros motores rechazan la consulta y el resultado no responde una regla clara.

No aproveches las “columnas sueltas” permitidas por SQLite. Si una columna no está agregada, inclúyela en GROUP BY o retírala del resultado.

SELECT
    strftime('%Y-%m', fecha) AS periodo,
    COUNT(*) AS operaciones,
    SUM(cantidad) AS unidades
FROM operaciones_tienda
GROUP BY strftime('%Y-%m', fecha)
ORDER BY periodo;

Agrupar por una expresión permite transformar el dato y utilizar esa transformación como criterio del grupo.

Filtrado de grupos con HAVING

Pregunta:

¿Qué categorías tienen al menos ocho operaciones confirmadas?

Primero se eliminan las operaciones no confirmadas. Después se forman categorías. Finalmente se conservan los grupos cuyo conteo cumple la condición:

SELECT
    categoria,
    COUNT(*) AS operaciones_confirmadas
FROM operaciones_tienda
WHERE estado = 'Confirmada'
GROUP BY categoria
HAVING COUNT(*) >= 8
ORDER BY operaciones_confirmadas DESC;

Filas originales
    ↓ WHERE estado = 'Confirmada'
Filas confirmadas
    ↓ GROUP BY categoria
Grupos por categoría
    ↓ HAVING COUNT(*) >= 8
Categorías que cumplen

Regla práctica:

¿La condición se puede evaluar en una fila individual?
    ├── Sí → WHERE
    └── No, necesita COUNT/SUM/AVG o el grupo → HAVING

SELECT categoria, COUNT(*) AS total
FROM operaciones_tienda
WHERE COUNT(*) >= 8
GROUP BY categoria;

COUNT(*) todavía no existe cuando se aplica WHERE. La versión correcta usa HAVING:

SELECT categoria, COUNT(*) AS total
FROM operaciones_tienda
GROUP BY categoria
HAVING COUNT(*) >= 8;

Método profesional para construir una consulta

Utiliza este procedimiento:

1. Reescribe la pregunta. Elimina palabras ambiguas.
2. Identifica la granularidad. Decide si el resultado necesita filas individuales o un resumen por grupo.
3. Enumera las columnas. Incluye únicamente datos necesarios.
4. Separa filtros. Distingue condiciones de filas y condiciones de grupos.
5. Define cálculos y orden. Especifica fórmulas, alias y criterios de desempate.
6. Comprueba el resultado. Verifica casos límite y explica una fila.

Petición original:

Necesitamos saber las categorías más importantes.

La palabra “importantes” es ambigua. Debe convertirse en una regla medible:

Mostrar el ingreso neto de operaciones confirmadas por categoría. Conservar solamente categorías con ingresos de al menos 150 y ordenar de mayor a menor ingreso.

Diseño:

Consulta:

SELECT
    categoria,
    ROUND(
        SUM(
            cantidad * precio_unitario
            * (1 - descuento_porcentaje / 100.0)
        ),
        2
    ) AS ingreso_neto
FROM operaciones_tienda
WHERE estado = 'Confirmada'
GROUP BY categoria
HAVING SUM(
    cantidad * precio_unitario
    * (1 - descuento_porcentaje / 100.0)
) >= 150
ORDER BY ingreso_neto DESC;

• Ejecuta primero una versión sin agregación y observa las filas participantes.
• Comprueba los extremos del intervalo de fechas.
• Verifica si NULL debe incluirse o excluirse.
• Calcula manualmente una fila o un grupo pequeño.
• Confirma el número de resultados.
• Busca empates y añade un criterio de orden secundario.
• Lee la pregunta nuevamente y compara cada palabra con una cláusula.

Errores comunes y cómo corregirlos

WHERE ciudad = NULL

Corrección:

WHERE ciudad IS NULL

WHERE estado = Confirmada

Corrección:

WHERE estado = 'Confirmada'

WHERE categoria = 'Hogar'
   OR categoria = 'Papeleria'
  AND estado = 'Confirmada'

Corrección si ambas categorías deben estar confirmadas:

WHERE categoria IN ('Hogar', 'Papeleria')
  AND estado = 'Confirmada'

WHERE producto LIKE 'USB'

La consulta encuentra solamente el texto exacto USB. Para encontrar productos que lo contienen:

WHERE producto LIKE '%USB%'

SELECT id, fecha, producto
FROM operaciones_tienda
LIMIT 5;

Si se buscan las cinco más recientes:

SELECT id, fecha, producto
FROM operaciones_tienda
ORDER BY fecha DESC, id DESC
LIMIT 5;

SELECT SUM(precio_unitario)
FROM operaciones_tienda;

Esta suma ignora cantidades, descuentos y estados. La fórmula debe corresponder a la definición de ingreso.

WHERE SUM(cantidad) > 20

Si la condición depende del grupo:

HAVING SUM(cantidad) > 20

SELECT categoria, producto, SUM(cantidad)
FROM operaciones_tienda
GROUP BY categoria;

El producto no representa a todo el grupo. Retíralo o agrupa también por producto.

DISTINCT es correcto cuando la pregunta solicita valores o combinaciones únicas. No debe agregarse automáticamente para ocultar filas que no se comprenden.

ROUND controla el resultado presentado. No corrige decisiones de diseño sobre dinero ni elimina por sí solo las particularidades de los números decimales en coma flotante.

Buenas prácticas de consultas

1. Escribe una pregunta concreta antes de cada consulta.
2. Selecciona columnas explícitas en resultados finales.
3. Utiliza alias que describan el significado, no solamente la operación.
4. Divide cada cláusula en líneas para facilitar la lectura.
5. Sangra expresiones largas y condiciones relacionadas.
6. Utiliza paréntesis en reglas con AND y OR.
7. Añade ORDER BY cuando el orden tenga significado.
8. Define criterios de desempate para rankings y paginación.
9. Comprueba extremos de BETWEEN.
10. Trata NULL según su significado, no como una cadena vacía.
11. Filtra filas con WHERE antes de agrupar cuando sea posible.
12. Filtra resultados agregados con HAVING.
13. Incluye en GROUP BY toda columna seleccionada que no esté agregada.
14. Nombra fórmulas comerciales: subtotal, monto_descuento, ingreso_neto.
15. Verifica manualmente al menos un resultado calculado.
16. Documenta cualquier función dependiente de SQLite.
17. No interpretes correlación como una causa. SQL resume datos; no demuestra por qué ocurrió algo.
18. Conserva las consultas en un script reproducible.

Videos recomendados

Los videos se utilizan en momentos concretos. No es necesario verlos todos antes de practicar.

Tema exacto: construcción de condiciones y filtros frecuentes. Momento recomendado: después de la sección 3. Objetivo: comparar distintas formas de localizar filas. Nota de portabilidad: el video utiliza MySQL, pero los filtros estudiados se aplican de la misma forma en las consultas básicas de SQLite.

Tema exacto: resumen de conjuntos de filas con funciones agregadas. Momento recomendado: antes de la práctica guiada 4. Objetivo: reforzar qué pregunta responde cada función.

Tema exacto: formación de grupos y condiciones sobre resultados agregados. Momento recomendado: antes de la práctica guiada 5. Objetivo: diferenciar filtros de filas y filtros de grupos.

Al observar ejemplos con otro motor, identifica dos capas:

Concepto transferible: filtrar, agrupar, sumar, ordenar
Sintaxis del motor: funciones de fecha, concatenación, límites

No copies una función específica sin comprobar si existe en SQLite.

Documentación y recursos gratuitos

La documentación oficial de SQLite está en inglés. Puedes utilizar la traducción del navegador, pero conserva los nombres SQL originales para buscar términos con precisión.

• 📖`SELECT` — documentación oficial de SQLite

Revisa la estructura general, WHERE, GROUP BY, HAVING, DISTINCT, ORDER BY y LIMIT.

• 📖Expresiones SQL — documentación oficial de SQLite

Consulta operadores de comparación, operadores lógicos, BETWEEN, IN, LIKE, CASE e IS NULL.

• 📖Funciones integradas principales — documentación oficial de SQLite

Busca abs, coalesce, length, lower, replace, round, trim y upper.

• 📖Funciones de agregación — documentación oficial de SQLite

Compara avg, count, max, min y sum.

• 📖Funciones de fecha y hora — documentación oficial de SQLite

Concéntrate en date, strftime y julianday.

No intentes memorizarla completa. Utiliza este proceso:

1. Busca el nombre exacto de la cláusula o función.
2. Lee su propósito en una frase.
3. Identifica los argumentos.
4. Observa uno o dos ejemplos.
5. Prueba una variante pequeña en DB Browser.
6. Comprueba qué ocurre con NULL.
7. Anota si la sintaxis es propia de SQLite.

Material complementario

Este módulo requiere solamente un archivo descargable:

⬇️`Descargar datos_tienda_m04.sql`

El archivo evita dedicar tiempo a escribir 48 inserciones y permite que todas las consultas partan del mismo conjunto verificable.

No necesitas una plantilla adicional para el informe. Puedes utilizar cualquier procesador de texto y exportar un PDF sencillo. Las listas de comprobación, el diccionario de datos, las fórmulas y la rúbrica ya están incluidos en este módulo.

Glosario

Resumen final

En este módulo aprendiste a convertir preguntas en consultas SQL.

El recorrido principal fue:

Seleccionar columnas
        ↓
Filtrar filas
        ↓
Ordenar y limitar
        ↓
Calcular y presentar
        ↓
Resumir
        ↓
Agrupar
        ↓
Filtrar grupos
        ↓
Interpretar resultados

Ahora puedes:

• Elegir columnas explícitas y asignar alias.
• Obtener combinaciones únicas con DISTINCT.
• Construir filtros con comparaciones y lógica booleana.
• Utilizar IN, BETWEEN, LIKE e IS NULL.
• Ordenar con criterios de desempate.
• Limitar resultados con una intención definida.
• Crear subtotales, descuentos y totales netos.
• Clasificar filas con CASE.
• Presentar textos, valores ausentes y fechas.
• Calcular conteos, sumas, promedios, mínimos y máximos.
• Resumir por categorías, productos, meses y otros grupos.
• Aplicar WHERE antes de agrupar y HAVING después.
• Evitar columnas ambiguas en consultas agrupadas.
• Validar una consulta en lugar de confiar solamente en que se ejecutó.
• Escribir conclusiones limitadas por la evidencia disponible.

Al aprobar el módulo habrás demostrado que puedes:

• Traducir una necesidad comercial a una consulta verificable.
• Elegir entre filtros, expresiones, agregaciones y agrupaciones según la pregunta.
• Construir reportes ordenados y reproducibles sobre una tabla.
• Detectar resultados incorrectos aunque la consulta no muestre errores de sintaxis.
• Explicar cálculos y conclusiones a una persona que no escribió el SQL.
• Reconocer qué funciones pertenecen a SQLite y buscar equivalentes en otro motor.
• Preparar un script de análisis con calidad suficiente para revisión técnica.

SELECT no consiste en pedir datos al azar.

Consiste en definir con precisión:
qué observar,
qué excluir,
qué calcular,
cómo resumir
y cómo comprobar.

Debes poder responder sin consultar apuntes:

1. ¿Por qué no existe un orden garantizado sin ORDER BY?
2. ¿Cuál es la diferencia entre COUNT(*) y COUNT(columna)?
3. ¿Por qué BETWEEN requiere atención en los extremos?
4. ¿Cómo se busca un valor ausente?
5. ¿Qué diferencia existe entre WHERE y HAVING?
6. ¿Qué columnas deben aparecer en GROUP BY?
7. ¿Por qué una consulta que se ejecuta puede responder una pregunta equivocada?
8. ¿Qué parte de las funciones de fecha puede cambiar al utilizar otro motor?

Si todavía confundes filtros de filas con filtros de grupos, vuelve a la sección 9 y repite la práctica guiada 5. Esa distinción será indispensable cuando varias tablas participen en una misma consulta.

Completa el mini proyecto, aprueba la evaluación práctica y entrega el proyecto obligatorio. Continúa solamente cuando recibas la aprobación del módulo.