🎯 Cheat Sheet de SQL: 100 Consultas Esenciales para Análisis de Datos

Hemos recopilado una hoja de referencia rápida (cheat sheet) con consultas y conceptos fundamentales de SQL utilizados en el análisis de datos, abarcando desde comandos básicos hasta técnicas avanzadas. Estos consejos cubren un amplio rango de temas, incluyendo uniones (joins), manejo de duplicados, limpieza de datos, y más.

La Gran Idea: SQL como un Mapa Mental (Mind Map)

Para memorizar y visualizar mejor estos conceptos, sugiero organizar los consejos de SQL usando la estructura de un Mapa Mental. El nodo central sería "SQL para Análisis de Datos", y los cinco grandes temas de abajo actuarían como las ramas principales, facilitando la comprensión de cómo se conectan las técnicas:

Ramas Principales: Consultas Básicas, Filtrado, Ordenamiento/Limitación, Agregación/Agrupación, y Joins.
Sub-ramas: Cada consulta específica de esta lista (e.g., COUNT(*), INNER JOIN) sería una sub-rama de la categoría principal.

Visualización del Flujo Lógico de Consultas

Un analista de datos a menudo sigue un Orden Lógico de Procesamiento de Consultas (aunque no siempre sea el orden en que se escriben). Entender este flujo es clave para escribir queries más precisas y eficientes.

                graph TD
                    A[FROM: Origen de Datos Tablas] --> B{JOIN: Unir Datos}
                    B --> C{WHERE: Filtrar Filas}
                    C --> D{GROUP BY: Agrupar Filas}
                    D --> E{HAVING: Filtrar Grupos}
                    E --> F[SELECT: Proyectar Columnas/Cálculos]
                    F --> G[ORDER BY: Ordenar el Resultado]
                    G --> H[LIMIT/OFFSET: Limitar Filas Finales]

Sección 1: Consultas Básicas

Utilice estas consultas para seleccionar y filtrar datos de una tabla.

Seleccionar todas las columnas de una tabla:
```
SELECT * FROM employees;
```

Seleccionar columnas específicas:

SELECT first_name, last_name, hire_date FROM employees;

Contar todas las filas:
```
SELECT COUNT(*) FROM employees;
```
Contar el número de valores no nulos en una columna:
```
SELECT COUNT(salary) FROM employees;
```

Encontrar valores únicos en una columna:

SELECT DISTINCT department FROM employees;

Filtrar datos usando una cláusula WHERE:

SELECT * FROM employees WHERE department = 'Sales';

Filtrar con múltiples condiciones usando AND:

SELECT * FROM employees WHERE department = 'Sales' AND salary > 60000;

Filtrar con múltiples condiciones usando OR:

SELECT * FROM employees WHERE department = 'Sales' OR department = 'Marketing';

Combinar AND y OR con paréntesis para lógica compleja:

SELECT * FROM employees WHERE (department = 'Sales' OR department = 'Marketing') AND salary > 70000;

Excluir un valor usando NOT:

SELECT * FROM employees WHERE NOT department = 'IT';

Sección 2: Filtrado y Coincidencia de Patrones

Técnicas de filtrado avanzado utilizando IN, BETWEEN, y LIKE.

Filtrar por una lista de valores usando IN:

SELECT * FROM employees WHERE department IN ('Sales', 'Marketing', 'IT');

Excluir una lista de valores usando NOT IN:

SELECT * FROM employees WHERE department NOT IN ('Sales', 'Marketing');

Filtrar valores dentro de un rango usando BETWEEN:

SELECT * FROM employees WHERE salary BETWEEN 50000 AND 75000;

Encontrar filas donde una cadena contiene una subcadena (insensible a mayúsculas/minúsculas):
```
SELECT * FROM employees WHERE first_name ILIKE '%jo%';
```
Encontrar filas donde una cadena comienza con un patrón específico:
```
SELECT * FROM employees WHERE last_name LIKE 'Smi%';
```
Encontrar filas donde una cadena termina con un patrón específico:
```
SELECT * FROM employees WHERE email LIKE '%@gmail.com';
```
Encontrar filas con un patrón en una posición específica:
```
SELECT * FROM employees WHERE first_name LIKE '_a%';
```

Encontrar filas con valores NULL:

SELECT * FROM employees WHERE manager_id IS NULL;

Encontrar filas con valores no NULL:

SELECT * FROM employees WHERE manager_id IS NOT NULL;

Filtrar por rango de fechas:

SELECT * FROM employees WHERE hire_date BETWEEN '2023-01-01' AND '2023-12-31';

Sección 3: Ordenamiento y Limitación

Controle el orden de sus resultados y limite el número de filas.

Ordenar resultados en orden ascendente:

SELECT * FROM employees ORDER BY last_name ASC;

Ordenar resultados en orden descendente:

SELECT * FROM employees ORDER BY salary DESC;

Ordenar por múltiples columnas:

SELECT * FROM employees ORDER BY department ASC, salary DESC;

Obtener los 10 empleados mejor pagados:

SELECT * FROM employees ORDER BY salary DESC LIMIT 10;

Obtener los 5 empleados contratados más recientemente:

SELECT * FROM employees ORDER BY hire_date DESC LIMIT 5;

Combinar DISTINCT y ORDER BY:

SELECT DISTINCT department FROM employees ORDER BY department;

Obtener un rango específico de filas (e.g., filas 11-20):

SELECT * FROM employees ORDER BY employee_id OFFSET 10 LIMIT 10;

Obtener el empleado con el salario más alto:

SELECT * FROM employees ORDER BY salary DESC LIMIT 1;

Obtener el segundo salario más alto:

SELECT DISTINCT salary FROM employees ORDER BY salary DESC LIMIT 1 OFFSET 1;

Ordenar por un campo calculado (creando un alias):

SELECT first_name, last_name, (salary * 0.1) AS bonus FROM employees ORDER BY bonus DESC;

Sección 4: Agregación y Agrupación

Resuma y analice datos con funciones de agregación.

Contar filas para cada grupo:

SELECT department, COUNT(*) FROM employees GROUP BY department;

Calcular el salario promedio por departamento:

SELECT department, AVG(salary) FROM employees GROUP BY department;

Encontrar el gasto salarial total para cada departamento:

SELECT department, SUM(salary) FROM employees GROUP BY department;

Encontrar el salario máximo en cada departamento:

SELECT department, MAX(salary) FROM employees GROUP BY department;

Encontrar el salario mínimo en cada departamento:

SELECT department, MIN(salary) FROM employees GROUP BY department;

Filtrar grupos usando HAVING (e.g., departamentos con salario promedio > 65000):

SELECT department, AVG(salary) FROM employees GROUP BY department HAVING AVG(salary) > 65000;

Contar empleados en departamentos con más de 5 empleados:

SELECT department, COUNT(*) FROM employees GROUP BY department HAVING COUNT(*) > 5;

Filtrar y luego agrupar (e.g., solo empleados contratados después de 2022):

SELECT department, AVG(salary) FROM employees WHERE hire_date > '2022-01-01' GROUP BY department;

Agrupar por múltiples columnas:

SELECT department, job_title, AVG(salary) FROM employees GROUP BY department, job_title;

Encontrar el salario máximo por departamento (útil para encontrar el mejor pagado):
```
SELECT department, MAX(salary) FROM employees GROUP BY department;
```

Sección 5: Joins (Uniones)

Combine datos de múltiples tablas. Este es un tema central en los consejos de SQL.

INNER JOIN: Devuelve filas coincidentes de ambas tablas:

SELECT e.first_name, d.department_name FROM employees e INNER JOIN departments d ON e.department_id = d.department_id;

LEFT JOIN: Devuelve todas las filas de la tabla izquierda y las filas coincidentes de la derecha:

SELECT e.first_name, d.department_name FROM employees e LEFT JOIN departments d ON e.department_id = d.department_id;

LEFT JOIN para encontrar filas en la tabla izquierda sin coincidencia en la derecha (p. ej., empleados sin departamento):

SELECT e.first_name FROM employees e LEFT JOIN departments d ON e.department_id = d.department_id WHERE d.department_id IS NULL;

RIGHT JOIN: Devuelve todas las filas de la tabla derecha y las filas coincidentes de la izquierda:

SELECT e.first_name, d.department_name FROM employees e RIGHT JOIN departments d ON e.department_id = d.department_id;

FULL OUTER JOIN: Devuelve todas las filas cuando hay una coincidencia en cualquiera de las tablas:

SELECT e.first_name, d.department_name FROM employees e FULL OUTER JOIN departments d ON e.department_id = d.department_id;

Unión de tres tablas:

SELECT e.first_name, p.project_name, d.department_name FROM employees e JOIN projects p ON e.employee_id = p.employee_id JOIN departments d ON e.department_id = d.department_id;

Self-Join: Unir una tabla consigo misma (p. ej., para encontrar gerentes):

SELECT e.first_name AS employee, m.first_name AS manager FROM employees e JOIN employees m ON e.manager_id = m.employee_id;

Join en una columna no clave (p. ej., uniendo órdenes y clientes por código postal):

SELECT o.order_id, c.customer_name FROM orders o JOIN customers c ON o.customer_zip_code = c.customer_zip_code;

Cross Join: Devuelve el producto cartesiano de las dos tablas:
```
SELECT * FROM employees CROSS JOIN departments;
```

Left Join con filtrado (encontrar productos sin ventas):

SELECT * FROM products p LEFT JOIN sales s ON p.product_id = s.product_id WHERE s.sale_id IS NULL;

Encontrar empleados que no han sido asignados a un proyecto:

SELECT e.first_name, e.last_name FROM employees e LEFT JOIN employee_projects ep ON e.employee_id = ep.employee_id WHERE ep.project_id IS NULL;

Encontrar proyectos sin empleados asignados:

SELECT p.project_name FROM projects p LEFT JOIN employee_projects ep ON p.project_id = ep.project_id WHERE ep.employee_id IS NULL;

Encontrar el salario total de cada departamento, incluyendo departamentos sin empleados:

SELECT d.department_name, SUM(e.salary) AS total_salary FROM departments d LEFT JOIN employees e ON d.department_id = e.department_id GROUP BY d.department_name;

Encontrar el número de empleados en cada departamento, incluyendo aquellos con cero:

SELECT d.department_name, COUNT(e.employee_id) AS num_employees FROM departments d LEFT JOIN employees e ON d.department_id = e.department_id GROUP BY d.department_name;

Join basado en múltiples condiciones:

SELECT o.*, c.customer_name FROM orders o JOIN customers c ON o.customer_id = c.customer_id AND o.order_date = c.last_purchase_date;

(Tip Avanzado) Encontrar empleados y sus gerentes, y los departamentos de sus gerentes (requiere joins anidados o múltiples):

SELECT e.first_name, m.first_name AS manager_name, d.department_name FROM employees e JOIN employees m ON e.manager_id = m.employee_id JOIN departments d ON m.department_id = d.department_id;

Tabla: Resumen de Tipos de JOIN

Los joins son el corazón del análisis de datos en SQL. Aquí tienes un resumen de cuándo usar cada uno:

Tipo de JOIN	Descripción	Caso de Uso Común
INNER JOIN	Devuelve solo las filas que tienen coincidencias en ambas tablas.	Encontrar empleados que tienen asignado un departamento válido.
LEFT (OUTER) JOIN	Devuelve todas las filas de la tabla izquierda, más las filas coincidentes de la derecha. Si no hay coincidencia, devuelve `NULL` para las columnas de la derecha.	Encontrar todos los productos y, si tienen, la información de sus ventas.
RIGHT (OUTER) JOIN	Devuelve todas las filas de la tabla derecha, más las filas coincidentes de la izquierda.	Encontrar todos los departamentos y, si tienen, la información de sus empleados.
FULL (OUTER) JOIN	Devuelve filas cuando hay coincidencia en cualquiera de las tablas.	Ver todos los clientes y todos los pedidos, incluyendo clientes sin pedidos y pedidos sin cliente registrado.
SELF-JOIN	Unir una tabla consigo misma (usando alias).	Consultar jerarquías, como empleados y sus gerentes.

Temas Adicionales y DBA

Además de las consultas de análisis, los recursos sobre SQL a menudo incluyen enfoques en administración, duplicados y limpieza de datos. Tenga en cuenta que estos comandos pueden variar significativamente según el dialecto SQL utilizado (MS SQL Server, PostGresql, Oracle, DB2, MySQL).

**Indexación:** Encontrar índices faltantes para todas las tablas en una base de datos.
**Mantenimiento:** Reorganizar y reconstruir índices para todas las tablas en una base de datos.

💡 Práctica para Analistas de Datos: Recomendaciones Clave

Un conocimiento sólido de SQL para el análisis requiere más que solo memorizar queries; necesita práctica constante y enfocarse en la lógica.

Domine las Funciones de Ventana (Window Functions): Estas son cruciales para el análisis avanzado, permitiéndole realizar cálculos como RANK(), promedios móviles o totales acumulados sin colapsar las filas como lo hace GROUP BY.
Entienda los Diagramas Entidad-Relación (DER): Comprender cómo se relacionan las tablas, especialmente la normalización, le permite saber exactamente qué tipo de join usar y cómo estructurar sus consultas.
Use Proyectos Personales: Cree una base de datos sencilla (por ejemplo, para gestionar sus gastos o una colección de películas) y aplique las consultas para resolver problemas reales. La práctica regular es esencial.
Optimice el Rendimiento: Con grandes volúmenes de datos, el rendimiento es vital. Aprenda a dividir sentencias complejas en partes más pequeñas y a usar tablas temporales en lugar de subconsultas anidadas excesivas (CTE) para mejorar la eficiencia.

Conclusión: El SQL es su Súper-Poder Analítico

La capacidad de consultar, filtrar y unir datos de forma eficiente es el súper-poder fundamental del analista. El SQL no es solo un lenguaje; es el marco lógico que le permite transformar datos crudos en información valiosa para la toma de decisiones.

Hemos sintetizado las consultas más importantes en cinco categorías clave: la base de SELECT y WHERE, el refinamiento de LIKE y BETWEEN, el orden de ORDER BY, el resumen de GROUP BY y la integración de Joins. Al aplicar la estrategia del Mapa Mental, usted no solo memoriza código, sino que también visualiza la conexión lógica entre cada técnica.

Le animamos a tomar esta cheat sheet y desafiarse a usted mismo con problemas de datos del mundo real. Al dominar estas 100 consultas, no solo estará listo para cualquier entrevista, sino que podrá generar insights poderosos que impulsen el éxito en cualquier organización.

¡Ahora es su turno! ¿Cuál de estas 100 consultas cree que es la más importante para su trabajo diario?