SQL para el Análisis de Datos: Descubre las Consultas Analíticas Esenciales 📊

Introducción al Análisis de Datos con SQL 📈

En el mundo actual, los datos son el nuevo oro, y SQL (Structured Query Language) es la herramienta por excelencia para extraer su valor. No es solo un lenguaje para almacenar y recuperar información; es una potente suite para el análisis, capaz de transformar grandes volúmenes de datos en insights accionables. Este tutorial está diseñado para equiparte con las habilidades SQL necesarias para desempeñarte eficazmente en roles de analista de datos, científico de datos o cualquier profesional que necesite tomar decisiones informadas basadas en datos.

Aquí aprenderás a formular consultas que no solo traigan datos, sino que los sumaricen, agreguen, filtren y relacionen de maneras que revelen patrones, tendencias y anomalías. Veremos cómo ir más allá del SELECT * para construir consultas complejas que respondan a preguntas de negocio cruciales.

Preparando el Terreno: Nuestro Conjunto de Datos de Ejemplo 🛠️

Para hacer este tutorial lo más práctico posible, utilizaremos un conjunto de datos hipotético sobre ventas. Imaginemos que tenemos dos tablas principales: productos y ventas.

Tabla productos

Almacena información sobre los productos que vendemos.

Tabla ventas

Contiene los registros de cada venta realizada.

Vamos a crear estas tablas e insertar algunos datos de ejemplo. Puedes ejecutar estos comandos en tu base de datos preferida (PostgreSQL, MySQL, SQL Server, SQLite, etc.).

-- Crear tabla productos
CREATE TABLE productos (
    producto_id INT PRIMARY KEY,
    nombre VARCHAR(255) NOT NULL,
    categoria VARCHAR(100),
    precio DECIMAL(10,2) NOT NULL
);

-- Insertar datos en productos
INSERT INTO productos (producto_id, nombre, categoria, precio) VALUES
(1, 'Laptop Gaming X', 'Electrónica', 1200.00),
(2, 'Teclado Mecánico RGB', 'Accesorios', 80.00),
(3, 'Mouse Ergonómico', 'Accesorios', 35.00),
(4, 'Monitor UltraWide', 'Electrónica', 450.00),
(5, 'Silla Gamer Pro', 'Mobiliario', 300.00),
(6, 'Auriculares Inalámbricos', 'Accesorios', 120.00),
(7, 'Smartphone Z Flip', 'Electrónica', 900.00),
(8, 'Tablet Pro A', 'Electrónica', 550.00),
(9, 'Mesa de Escritorio Ajustable', 'Mobiliario', 250.00),
(10, 'Impresora Multifunción', 'Electrónica', 200.00);

-- Crear tabla ventas
CREATE TABLE ventas (
    venta_id INT PRIMARY KEY,
    producto_id INT NOT NULL,
    fecha_venta DATE NOT NULL,
    cantidad INT NOT NULL,
    region VARCHAR(50) NOT NULL,
    empleado_id INT NOT NULL,
    FOREIGN KEY (producto_id) REFERENCES productos(producto_id)
);

-- Insertar datos en ventas
INSERT INTO ventas (venta_id, producto_id, fecha_venta, cantidad, region, empleado_id) VALUES
(101, 1, '2023-01-10', 1, 'Norte', 10),
(102, 2, '2023-01-10', 2, 'Norte', 10),
(103, 3, '2023-01-11', 1, 'Sur', 11),
(104, 1, '2023-01-12', 1, 'Centro', 12),
(105, 4, '2023-01-12', 1, 'Norte', 10),
(106, 5, '2023-01-13', 1, 'Este', 13),
(107, 2, '2023-01-13', 3, 'Sur', 11),
(108, 6, '2023-01-14', 1, 'Norte', 10),
(109, 7, '2023-01-14', 1, 'Oeste', 14),
(110, 1, '2023-01-15', 2, 'Centro', 12),
(111, 8, '2023-01-15', 1, 'Norte', 10),
(112, 9, '2023-01-16', 1, 'Este', 13),
(113, 10, '2023-01-16', 1, 'Sur', 11),
(114, 1, '2023-02-01', 1, 'Norte', 10),
(115, 2, '2023-02-02', 2, 'Sur', 11),
(116, 3, '2023-02-03', 1, 'Centro', 12),
(117, 4, '2023-02-04', 1, 'Norte', 10),
(118, 5, '2023-02-05', 1, 'Este', 13),
(119, 6, '2023-02-06', 1, 'Oeste', 14),
(120, 7, '2023-02-07', 1, 'Norte', 10),
(121, 8, '2023-02-08', 1, 'Sur', 11),
(122, 9, '2023-02-09', 1, 'Centro', 12),
(123, 10, '2023-02-10', 1, 'Este', 13),
(124, 1, '2023-03-01', 1, 'Norte', 10),
(125, 2, '2023-03-02', 2, 'Sur', 11),
(126, 3, '2023-03-03', 1, 'Centro', 12);

Agregaciones Esenciales para el Análisis 🔢

Las funciones de agregación son la piedra angular del análisis de datos en SQL. Nos permiten realizar cálculos sobre conjuntos de filas, como sumar, contar, promediar, encontrar el mínimo o el máximo. Combinadas con la cláusula GROUP BY, se vuelven increíblemente poderosas.

COUNT(): Contando Registros

Para saber cuántas ventas se han realizado en total:

SELECT COUNT(*) AS total_ventas
FROM ventas;

Para contar ventas por región:

SELECT region, COUNT(*) AS numero_ventas
FROM ventas
GROUP BY region;

SUM(): Totalizando Valores

Calcula la suma de una columna numérica. Si queremos saber el total de productos vendidos:

SELECT SUM(cantidad) AS total_productos_vendidos
FROM ventas;

Para calcular el ingreso total generado por cada venta, necesitamos unir ventas con productos para obtener el precio, y luego multiplicar por la cantidad. Después, sumar todos esos ingresos.

SELECT SUM(v.cantidad * p.precio) AS ingreso_total_global
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id;

AVG(): Calculando Promedios

Para obtener el promedio de la cantidad de productos por venta:

SELECT AVG(cantidad) AS promedio_cantidad_por_venta
FROM ventas;

¿Cuál es el precio promedio de los productos por categoría?

SELECT categoria, AVG(precio) AS precio_promedio
FROM productos
GROUP BY categoria;

MIN() y MAX(): Encontrando Extremos

Para saber el precio mínimo y máximo de un producto:

SELECT MIN(precio) AS precio_minimo, MAX(precio) AS precio_maximo
FROM productos;

Para encontrar la fecha de la primera y última venta:

SELECT MIN(fecha_venta) AS primera_venta, MAX(fecha_venta) AS ultima_venta
FROM ventas;

Agregaciones Avanzadas con GROUP BY y HAVING ✨

GROUP BY es la clave para segmentar tus datos y realizar análisis por categorías. HAVING es como WHERE, pero para filtrar los resultados de agregaciones.

Ventas por Región y Categoría

Queremos saber cuánto se ha vendido (en unidades) por cada región y por cada categoría de producto.

SELECT
    v.region,
    p.categoria,
    SUM(v.cantidad) AS total_unidades_vendidas
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id
GROUP BY v.region, p.categoria
ORDER BY v.region, p.categoria;

Filtrando Grupos con HAVING

Supongamos que solo nos interesan las regiones que han vendido más de 5 unidades en total.

SELECT
    region,
    SUM(cantidad) AS total_unidades_vendidas
FROM ventas
GROUP BY region
HAVING SUM(cantidad) > 5
ORDER BY total_unidades_vendidas DESC;

Podemos combinar WHERE y HAVING. Por ejemplo, queremos ver las categorías de productos que han generado más de 1000€ en ventas, pero solo para ventas realizadas en enero de 2023.

SELECT
    p.categoria,
    SUM(v.cantidad * p.precio) AS ingresos_categoria
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id
WHERE v.fecha_venta BETWEEN '2023-01-01' AND '2023-01-31'
GROUP BY p.categoria
HAVING SUM(v.cantidad * p.precio) > 1000
ORDER BY ingresos_categoria DESC;

Subconsultas y Common Table Expressions (CTEs) 🚀

Para análisis más complejos, a menudo necesitamos romper una consulta grande en partes más manejables. Las subconsultas y las Common Table Expressions (CTEs) son herramientas perfectas para esto.

Subconsultas: Consultas dentro de Consultas

Una subconsulta es una consulta SELECT anidada dentro de otra consulta. Pueden usarse en las cláusulas FROM, WHERE, SELECT o HAVING.

Ejemplo: Encontrar los productos cuyo precio es superior al precio promedio de todos los productos.

SELECT
    nombre,
    precio
FROM productos
WHERE precio > (SELECT AVG(precio) FROM productos);

Ejemplo más complejo: Obtener las ventas (fecha, cantidad, producto) de los 3 productos más caros.

SELECT
    v.fecha_venta,
    v.cantidad,
    p.nombre AS nombre_producto,
    p.precio
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id
WHERE p.producto_id IN (
    SELECT producto_id
    FROM productos
    ORDER BY precio DESC
    LIMIT 3
);

Common Table Expressions (CTEs) con WITH 📝

Las CTEs, definidas con la cláusula WITH, mejoran la legibilidad y la modularidad de las consultas complejas. Son como tablas temporales que solo existen durante la ejecución de la consulta.

Reescribiendo el ejemplo de los 3 productos más caros con CTEs:

WITH TopProductos AS (
    SELECT
        producto_id,
        nombre,
        precio
    FROM productos
    ORDER BY precio DESC
    LIMIT 3
)
SELECT
    v.fecha_venta,
    v.cantidad,
    tp.nombre AS nombre_producto,
    tp.precio
FROM ventas v
JOIN TopProductos tp ON v.producto_id = tp.producto_id;

Ejemplo: Calcular el ingreso total por región y luego mostrar solo las regiones con ingresos por encima del promedio global.

Aquí utilizaremos dos CTEs.

WITH IngresosPorRegion AS (
    SELECT
        v.region,
        SUM(v.cantidad * p.precio) AS ingreso_total_region
    FROM ventas v
    JOIN productos p ON v.producto_id = p.producto_id
    GROUP BY v.region
),
PromedioGlobal AS (
    SELECT AVG(ingreso_total_region) AS avg_ingreso_global
    FROM IngresosPorRegion
)
SELECT
    irr.region,
    irr.ingreso_total_region
FROM IngresosPorRegion irr
JOIN PromedioGlobal pg ON irr.ingreso_total_region > pg.avg_ingreso_global
ORDER BY irr.ingreso_total_region DESC;

Uniones (JOINs) Avanzadas para Conectar Datos 🔗

Los JOINs son fundamentales para combinar datos de múltiples tablas. Más allá de los INNER JOIN básicos, existen otros tipos que son cruciales para el análisis.

LEFT JOIN (o LEFT OUTER JOIN)

Retorna todas las filas de la tabla izquierda y las filas coincidentes de la tabla derecha. Si no hay coincidencia, las columnas de la tabla derecha contendrán NULL.

Ejemplo: Listar todos los productos y, si han sido vendidos, mostrar el total de unidades vendidas. Si un producto no ha sido vendido, queremos que aparezca con NULL o 0 en la cantidad vendida.

SELECT
    p.nombre AS nombre_producto,
    p.categoria,
    COALESCE(SUM(v.cantidad), 0) AS total_unidades_vendidas
FROM productos p
LEFT JOIN ventas v ON p.producto_id = v.producto_id
GROUP BY p.nombre, p.categoria
ORDER BY total_unidades_vendidas DESC;

RIGHT JOIN (o RIGHT OUTER JOIN)

Similar a LEFT JOIN, pero retorna todas las filas de la tabla derecha y las coincidentes de la izquierda. Menos común, ya que la mayoría de los RIGHT JOIN pueden reescribirse como LEFT JOIN intercambiando las tablas.

FULL JOIN (o FULL OUTER JOIN)

Retorna todas las filas cuando hay una coincidencia en una de las tablas. Es decir, combina los resultados de un LEFT JOIN y un RIGHT JOIN. Las filas sin coincidencia en cualquiera de las tablas tendrán NULL en las columnas de la tabla sin coincidencia.

Este tipo de JOIN es muy útil cuando quieres ver todas las entradas de ambas tablas, incluso si no tienen una correspondencia. Por ejemplo, si tuviéramos una tabla de clientes y una de pedidos, un FULL JOIN nos mostraría clientes sin pedidos y pedidos sin un cliente asociado (posibles errores de datos).

Ejemplo (conceptual, ya que no tenemos una tercera tabla que no tenga relación completa con ventas o productos en ambos sentidos): Imagina que tienes una tabla empleados y quieres ver todos los empleados y todas las regiones, incluso si un empleado no ha vendido en una región o una región no tiene ventas de ningún empleado.

CROSS JOIN (Producto Cartesiano)

Combina cada fila de la primera tabla con cada fila de la segunda tabla. Esto produce un resultado que es el producto cartesiano de ambas tablas (Número de Filas Tabla 1 * Número de Filas Tabla 2).

Advertencia: Usa CROSS JOIN con extrema precaución, ya que puede generar conjuntos de resultados enormes y costosos computacionalmente si las tablas son grandes.

Uso analítico: Se usa raramente, pero puede ser útil para generar combinaciones posibles. Por ejemplo, para crear un calendario completo de días y productos para asegurar que todos los días y productos estén representados en un informe, incluso si no hubo ventas.

-- Ejemplo conceptual: Todas las combinaciones de producto y región
SELECT
    p.nombre AS nombre_producto,
    v.region
FROM productos p
CROSS JOIN (SELECT DISTINCT region FROM ventas) AS regiones_unicas;

Análisis de Tendencias y Series Temporales ⏰

Analizar datos a lo largo del tiempo es fundamental para identificar tendencias, estacionalidad y el rendimiento a lo largo del tiempo. SQL ofrece herramientas robustas para esto.

Agregaciones por Período de Tiempo

Podemos agrupar ventas por año, mes o día.

Ventas totales por mes (cantidad de unidades):

SELECT
    STRFTIME('%Y-%m', fecha_venta) AS ano_mes, -- Para SQLite
    -- DATE_FORMAT(fecha_venta, '%Y-%m') AS ano_mes, -- Para MySQL
    -- TO_CHAR(fecha_venta, 'YYYY-MM') AS ano_mes,   -- Para PostgreSQL/Oracle
    -- FORMAT(fecha_venta, 'yyyy-MM') AS ano_mes,   -- Para SQL Server
    SUM(cantidad) AS total_unidades_vendidas
FROM ventas
GROUP BY ano_mes
ORDER BY ano_mes;

Ingresos mensuales:

SELECT
    STRFTIME('%Y-%m', v.fecha_venta) AS ano_mes,
    SUM(v.cantidad * p.precio) AS ingresos_mensuales
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id
GROUP BY ano_mes
ORDER BY ano_mes;

Cálculos de Crecimiento MoM (Mes a Mes) o YoY (Año a Año)

Calcular el crecimiento requiere comparar un período con el anterior. Esto se puede lograr con subconsultas o CTEs, o de forma más eficiente con funciones de ventana.

Cálculo de ingresos mensuales y crecimiento MoM (usando CTEs):

WITH IngresosMensuales AS (
    SELECT
        STRFTIME('%Y-%m', v.fecha_venta) AS ano_mes,
        SUM(v.cantidad * p.precio) AS ingresos
    FROM ventas v
    JOIN productos p ON v.producto_id = p.producto_id
    GROUP BY ano_mes
    ORDER BY ano_mes
)
SELECT
    im.ano_mes,
    im.ingresos,
    LAG(im.ingresos, 1, 0) OVER (ORDER BY im.ano_mes) AS ingresos_mes_anterior,
    -- Cálculo del crecimiento MoM. Usamos NULLIF para evitar división por cero si el mes anterior tuvo 0 ingresos
    CASE
        WHEN LAG(im.ingresos, 1, 0) OVER (ORDER BY im.ano_mes) = 0 THEN NULL
        ELSE (im.ingresos - LAG(im.ingresos, 1, 0) OVER (ORDER BY im.ano_mes)) * 100.0 / LAG(im.ingresos, 1, 0) OVER (ORDER BY im.ano_mes)
    END AS crecimiento_mom_porcentaje
FROM IngresosMensuales im;

Funciones de Ventana para Análisis Avanzado de Datos 🧪

Las funciones de ventana (Window Functions) son herramientas extremadamente potentes para realizar cálculos sobre un conjunto de filas relacionadas con la fila actual, sin colapsar las filas como GROUP BY. Son ideales para rankings, totales acumulados y promedios móviles.

ROW_NUMBER(), RANK(), DENSE_RANK(): Rankings 🏆

Permiten asignar un rango a cada fila dentro de una partición de datos.

• ROW_NUMBER(): Asigna un número secuencial único a cada fila dentro de su partición.
• RANK(): Asigna el mismo rango a las filas con valores idénticos y luego salta el siguiente rango. (ej. 1, 2, 2, 4)
• DENSE_RANK(): Asigna el mismo rango a las filas con valores idénticos y no salta el siguiente rango. (ej. 1, 2, 2, 3)

Ejemplo: Clasificar los productos por ingresos generados en cada región.

WITH IngresosProductoRegion AS (
    SELECT
        v.region,
        p.nombre AS nombre_producto,
        SUM(v.cantidad * p.precio) AS ingresos_producto
    FROM ventas v
    JOIN productos p ON v.producto_id = p.producto_id
    GROUP BY v.region, p.nombre
)
SELECT
    region,
    nombre_producto,
    ingresos_producto,
    ROW_NUMBER() OVER (PARTITION BY region ORDER BY ingresos_producto DESC) AS row_num_region,
    RANK() OVER (PARTITION BY region ORDER BY ingresos_producto DESC) AS rank_region,
    DENSE_RANK() OVER (PARTITION BY region ORDER BY ingresos_producto DESC) AS dense_rank_region
FROM IngresosProductoRegion
ORDER BY region, ingresos_producto DESC;

SUM() OVER (), AVG() OVER (): Agregaciones con Ventanas 📈

Estas funciones de agregación se pueden usar como funciones de ventana para calcular valores acumulados o promedios móviles.

Ejemplo: Total acumulado de ventas por región a lo largo del tiempo.

SELECT
    fecha_venta,
    region,
    SUM(cantidad) AS ventas_diarias_region,
    SUM(SUM(cantidad)) OVER (PARTITION BY region ORDER BY fecha_venta) AS ventas_acumuladas_region
FROM ventas
GROUP BY fecha_venta, region
ORDER BY region, fecha_venta;

Ejemplo: Promedio móvil de ingresos para los últimos 3 meses.

Necesitaríamos datos más granularmente distribuidos a lo largo de muchos meses para un buen ejemplo. Sin embargo, conceptualmente se vería así:

-- Este ejemplo es conceptual y requiere más datos distribuidos en el tiempo
WITH IngresosMensuales AS (
    SELECT
        STRFTIME('%Y-%m-01', v.fecha_venta) AS mes_inicio,
        SUM(v.cantidad * p.precio) AS ingresos_totales
    FROM ventas v
    JOIN productos p ON v.producto_id = p.producto_id
    GROUP BY mes_inicio
    ORDER BY mes_inicio
)
SELECT
    mes_inicio,
    ingresos_totales,
    AVG(ingresos_totales) OVER (
        ORDER BY mes_inicio
        ROWS BETWEEN 2 PRECEDING AND CURRENT ROW -- Promedio de la fila actual y las 2 anteriores
    ) AS promedio_movil_3_meses
FROM IngresosMensuales;

LAG() y LEAD(): Comparando Filas ↔️

Estas funciones te permiten acceder a los datos de una fila anterior (LAG) o posterior (LEAD) dentro del mismo conjunto de resultados, muy útil para cálculos de diferencias o crecimientos.

Ya vimos un ejemplo con LAG() al calcular el crecimiento MoM. Aquí otro:

Ejemplo: Diferencia de ventas entre el producto actual y el anterior por precio (dentro de cada categoría).

WITH ProductosConPrecioOrdenado AS (
    SELECT
        categoria,
        nombre,
        precio,
        ROW_NUMBER() OVER (PARTITION BY categoria ORDER BY precio DESC) AS rn
    FROM productos
)
SELECT
    categoria,
    nombre,
    precio,
    LAG(precio, 1) OVER (PARTITION BY categoria ORDER BY precio DESC) AS precio_anterior,
    precio - LAG(precio, 1) OVER (PARTITION BY categoria ORDER BY precio DESC) AS diferencia_precio
FROM ProductosConPrecioOrdenado
ORDER BY categoria, precio DESC;

Casos de Uso Comunes para Analistas de Datos con SQL 🎯

Aquí tienes algunos escenarios típicos que puedes resolver con las técnicas aprendidas.

1. Identificar el Producto Más Vendido por Región y Mes

WITH VentasPorProductoMesRegion AS (
    SELECT
        STRFTIME('%Y-%m', v.fecha_venta) AS ano_mes,
        v.region,
        p.nombre AS nombre_producto,
        SUM(v.cantidad) AS total_unidades_vendidas
    FROM ventas v
    JOIN productos p ON v.producto_id = p.producto_id
    GROUP BY 1, 2, 3
),
RankedVentas AS (
    SELECT
        ano_mes,
        region,
        nombre_producto,
        total_unidades_vendidas,
        ROW_NUMBER() OVER (PARTITION BY ano_mes, region ORDER BY total_unidades_vendidas DESC) AS rn
    FROM VentasPorProductoMesRegion
)
SELECT
    ano_mes,
    region,
    nombre_producto,
    total_unidades_vendidas
FROM RankedVentas
WHERE rn = 1
ORDER BY ano_mes, region;

2. Clientes Top por Ingresos Generados (Concepto - si tuviéramos tabla de clientes)

Imaginando una tabla clientes y una relación con ventas por cliente_id.

-- Este es un ejemplo conceptual. Asume la existencia de una tabla 'clientes'
-- WITH IngresosPorCliente AS (
--     SELECT
--         c.cliente_id,
--         c.nombre_cliente,
--         SUM(v.cantidad * p.precio) AS ingreso_total
--     FROM clientes c
--     JOIN ventas v ON c.cliente_id = v.cliente_id
--     JOIN productos p ON v.producto_id = p.producto_id
--     GROUP BY c.cliente_id, c.nombre_cliente
-- )
-- SELECT
--     nombre_cliente,
--     ingreso_total
-- FROM IngresosPorCliente
-- ORDER BY ingreso_total DESC
-- LIMIT 10; -- Los 10 clientes top

3. Calcular la Tasa de Retención (Concepto - requiere más tablas)

Este tipo de análisis es muy común en e-commerce o SaaS y requiere un modelo de datos más complejo (ej. clientes, primeras_compras, compras_repetidas).

Optimizando tus Consultas Analíticas ⚙️

Escribir consultas SQL que funcionen es una cosa, pero escribir consultas que sean eficientes es otra. La optimización es crucial cuando se trabaja con grandes volúmenes de datos.

1. Índices (Repaso rápido)

Los índices son estructuras de datos especiales que mejoran la velocidad de las operaciones de recuperación de datos. Asegúrate de tener índices en las columnas utilizadas en las cláusulas WHERE, JOIN y ORDER BY.

-- Ejemplo de creación de índice
CREATE INDEX idx_ventas_fecha_region ON ventas (fecha_venta, region);
CREATE INDEX idx_ventas_producto_id ON ventas (producto_id);
CREATE INDEX idx_productos_categoria_precio ON productos (categoria, precio);

2. Evita SELECT * en Producción

Seleccionar solo las columnas que necesitas reduce la cantidad de datos que la base de datos tiene que leer y enviar, mejorando el rendimiento.

3. Usa EXPLAIN o EXPLAIN ANALYZE

Estas herramientas te muestran el plan de ejecución de tu consulta, lo que te permite identificar cuellos de botella y dónde el optimizador de la base de datos podría estar luchando.

EXPLAIN SELECT
    p.categoria,
    SUM(v.cantidad * p.precio) AS ingresos_categoria
FROM ventas v
JOIN productos p ON v.producto_id = p.producto_id
WHERE v.fecha_venta BETWEEN '2023-01-01' AND '2023-01-31'
GROUP BY p.categoria
HAVING SUM(v.cantidad * p.precio) > 1000;

4. Preferencia por CTEs sobre Subconsultas Anidadas (en la cláusula FROM)

Aunque los optimizadores modernos son muy buenos, las CTEs a menudo son más fáciles de leer y mantener, y en algunos casos, pueden ayudar al optimizador a generar un plan de ejecución más eficiente al dar más pistas sobre la intención de la consulta.

5. Filtrar lo antes posible

Aplica filtros (WHERE) lo más temprano posible en tu consulta para reducir el conjunto de datos sobre el que se realizan las operaciones más costosas como JOINs y agregaciones.

Conclusión: SQL como tu Aliado Analítico 💪

Has recorrido un camino significativo en este tutorial, explorando las capacidades analíticas de SQL. Desde las agregaciones básicas hasta el poder de las funciones de ventana y las CTEs, ahora tienes un arsenal de herramientas para transformar datos brutos en información valiosa.

El análisis de datos con SQL es una habilidad muy demandada y en constante evolución. La práctica constante, la experimentación con diferentes enfoques y la comprensión de cómo funciona tu base de datos son clave para convertirte en un experto. Sigue explorando, haciendo preguntas a tus datos y descubriendo las historias que tienen que contar.