Ejemplos de consultas SQL básicas: Guía para principiantes

¿Quieres saber cómo obtener resultados claros y útiles de una base datos en minutos?

En esta guía práctica te muestro, paso a paso, cómo escribir una consulta que devuelva lista de resultados legible. Trabajaremos con bases reales como tienda y empleados, y con conjuntos como employees y quarterly_sales para ver selección, filtros y orden. Ejemplos de consultas SQL básicas

Aprenderás a elegir una columna o varias columnas, limitar filas con una condición y ordenar por nombre o fecha. También veremos funciones como SUM, COUNT y AVG para resumir datos por departamento o categoría.

Verás cómo unir tablas con INNER JOIN y LEFT JOIN, usar LIKE, IN y BETWEEN, y crear alias para valores calculados que resulten claros al analizar ventas en dólares o el salario por empleado.

La ruta incluye ejemplos que devuelven resultados comprensibles y ejercicios aplicables en una empresa en España, con sintaxis compatible con MySQL.

Puntos clave

Guía práctica con ejemplos reales en dos bases de prueba.
Selección, filtrado y ordenación de columnas y filas.
Funciones de agregación y uso de GROUP BY y HAVING.
Combinación de tablas con distintos JOIN para no perder datos.
Patrones, rangos, paginación y subconsultas para casos complejos.
Resultados aplicables a empresas y ejercicios listos para practicar.

Introducción: qué es SQL y cómo “habla” con tu base de datos

Antes de escribir una consulta, conviene entender cómo el lenguaje habla con la base de datos.

SQL es un estándar ISO con variaciones según el SGBD. En MySQL, por ejemplo, se usa USE para seleccionar la base sobre la que operan las sentencias.

Una consulta típicamente sigue esta forma: SELECT indica qué columnas mostrar y FROM señala el nombre de la tabla. WHERE limita filas con condiciones como AND, OR, IN, BETWEEN o LIKE.

ORDER BY organiza el resultado en orden ascendente o descendente. GROUP BY agrupa filas y aplica funciones de agregación. HAVING filtra después de agrupar, útil para mostrar sólo grupos con un número mínimo de elementos.

«Seleccionar la base correcta y usar cláusulas claras reduce errores y aporta resultados útiles para la empresa.»

SELECT + FROM: elegir columnas y tabla.
WHERE: condición sobre valores numéricos, texto o fecha.
ORDER BY / GROUP BY / HAVING: ordenar y resumir datos.

Cláusula	Propósito	Ejemplo
SELECT	Elegir columnas	SELECT nombre, salario
FROM	Indicar tabla	FROM empleados
WHERE	Filtrar filas	WHERE fecha > ‘2024-01-01’

Primeros pasos: seleccionar todas las columnas y filas de una tabla

Al comenzar, conviene ver cómo recuperar todas las columnas y filas para comprender la estructura de una tabla.

SELECT * FROM tabla: cuándo usarlo y cuándo evitarlo

SELECT * FROM employees; devuelve todas las columnas y todas las filas de la tabla employees: id, first_name, last_name, department y salary.

Este uso es útil para explorar el esquema y validar qué nombres y tipos contienen los datos. Muestra una lista clara con nombres de columnas y los valores por fila.

No obstante, evita SELECT * en producción: trae más datos de los necesarios, afecta la red y la memoria, y puede romper integraciones si cambian columnas.

Entender columnas, filas y nombres de tabla

Cada fila representa un registro; cada columna un valor concreto. En FROM debes indicar el nombre exacto de la tabla para obtener el resultado esperado.

Si necesitas sólo algunas columnas, selecciona explicitamente esos nombres. Para tablas grandes, combina la cláusula con LIMIT o usa alias como e.* cuando trabajes con varias tablas.

Consejo: documenta los nombres y el significado de cada columna clave para facilitar el mantenimiento y la comprensión por parte de otros analistas.

Seleccionar columnas específicas: una columna, dos columnas y más

Elegir solo las columnas necesarias hace la salida más clara y eficiente.

Devolver lista de nombres:

SELECT nombre desde una tabla: Ejemplos de consultas SQL básicas

Para pedir un único campo, especifica la columna. Por ejemplo: SELECT first_name FROM employees; devuelve la lista de nombres y reduce el volumen de datos.

Dos columnas y alias para lectura

Combinar dos columnas y mejorar etiquetas

Si necesitas nombre y apellido usa: SELECT first_name, last_name FROM employees; Las columnas van separadas por coma y el resultado es más fácil de consumir que SELECT *.

Para valores calculados o cabeceras legibles, añade AS. Por ejemplo: SELECT q1_2022 + q2_2022 AS h1_2022 FROM quarterly_sales; Aquí el alias aclara el significado del valor.

Usa alias de tabla (e, p) al combinar tablas para evitar ambigüedad entre columnas.
No repitas columnas innecesarias; cada campo aumenta el tamaño de la lista.
Documenta por qué cada columna aparece en la salida para que el resultado sirva a la base de negocio.

Filtrado con WHERE: igualdad, comparación numérica y condiciones lógicas

La cláusula WHERE reduce una tabla a las filas que cumplen una condición concreta.

Igualdad con texto: para comparar nombres usa comillas simples. Por ejemplo: SELECT first_name, last_name FROM employees WHERE first_name = 'Luca'; Esto devuelve lista con los empleados cuyo nombre coincide exactamente.

Comparación numérica y fechas: emplea operadores como =, >, <, >=, <=, <>. Ejemplo: SELECT first_name, last_name, salary FROM employees WHERE salary > 3800; Para fechas, compara con literales ‘YYYY-MM-DD’ o funciones de fecha según el tipo.

Condiciones lógicas: combina con AND, OR y NOT. Por ejemplo: SELECT first_name, last_name, salary FROM employees WHERE salary > 5000 OR salary < 3000; Use paréntesis para controlar la forma de evaluación y evitar ambigüedad.

Verifica el tipo de columna antes de comparar valores y fecha.
Evita problemas de collations al filtrar texto para obtener resultados coherentes.
Indexa las columnas que filtras con frecuencia para mejorar rendimiento en tablas con muchas filas.

Consejo: valida que la condición refleja la pregunta de negocio y no excluye registros relevantes.

Ordenar resultados: ORDER BY ascendente y orden descendente

Poner un criterio de orden transforma una lista cruda en un resultado fácil de analizar.

ORDER BY organiza el resultado tras aplicar filtros y selección. Mejora la lectura de una tabla y facilita localizar valores relevantes.

Para ordenar por una sola columna usa, por ejemplo:

SELECT first_name, last_name FROM employees ORDER BY last_name;

Ordenar por una o varias columnas: Ejemplos de consultas SQL básicas

Si necesitas prioridad entre criterios, especifica varias columnas. La primera define la prioridad y las siguientes actúan como desempate.

Ejemplo con múltiples criterios:

SELECT first_name, last_name, salary FROM employees ORDER BY salary DESC, last_name ASC;

ASC vs DESC y prioridades de ordenación

Por defecto el orden es ascendente (ASC). Usa DESC para ver primero los valores más altos, es decir, el orden descendente.

Consejo: evita ordenar por expresiones complejas si la tabla tiene muchas filas; añade índices que apoyen el patrón de orden.

ORDER BY ordena la lista final y afecta cómo se presentan los datos.
Si ordenas por columnas no mostradas, MySQL lo permite, pero documenta la forma y el propósito.
Considera collation y sensibilidad a mayúsculas al ordenar nombres.

Cálculos en la consulta: operadores aritméticos y alias: Ejemplos de consultas SQL básicas

Puedes transformar columnas numéricas en nuevos valores usando operadores dentro de la consulta.

Los operadores +, -, * y / permiten sumar, restar, multiplicar y dividir columnas en la misma SELECT. Así obtienes un resultado inmediato sin alterar la tabla.

Por ejemplo, para sumar ventas de dos trimestres:

SELECT employee_id, q1_2022 + q2_2022 AS h1_2022 FROM quarterly_sales;

Suma, resta, multiplicación y división en columnas

Combina columnas con operadores aritméticos para crear métricas: q1 + q2, total – descuento o precio * cantidad. Verifica que los tipos número sean compatibles antes de operar.

Alias con AS para nombres comprensibles: Ejemplos de consultas SQL básicas

Define alias con AS para que el nombre resultante sea claro en informes. Un alias legible facilita el uso posterior del valor en herramientas o exportes.

Consejo: usa COALESCE si hay nulos y estandariza la moneda (euros o dólares) en la base para evitar confusiones.

Operación	Expresión	Resultado
Suma	q1_2022 + q2_2022	h1_2022 (ventas primer semestre)
Multiplicación	price * quantity	total_venta
División	amount / 100	euros desde céntimos
Relleno	COALESCE(metric,0)	evita NULL en valores

Evita repetir expresiones; reutiliza alias o subconsultas si necesitas el mismo cálculo varias veces.
Documenta el nombre y la forma del cálculo para que otros analistas entiendan la lista de columnas y filas.

Funciones de agregación y agrupación: SUM, COUNT, AVG, MIN, MAX con GROUP BY

Agrupar filas y aplicar SUM, COUNT o AVG convierte datos dispersos en métricas claras.

GROUP BY agrupa una tabla por una columna, como fabricante o departamento, y permite calcular totales por grupo.

En la base tienda puedes obtener el número de productos por fabricante y el precio medio por cada uno. En empleados, un informe por departamento muestra la suma de presupuestos y la cuenta de empleado por área.

Contar filas y diferencias clave: Ejemplos de consultas SQL básicas

COUNT(*) cuenta todas las filas del grupo. COUNT(columna) ignora valores nulos y ofrece otra forma de contar cuando faltan datos.

Promedios, mínimos y máximos por grupo

SUM acumula un valor numérico. AVG devuelve el promedio. MIN y MAX aportan el valor extremo por grupo.

«Incluye en SELECT solo columnas agregadas o las columnas usadas en GROUP BY para evitar errores.»

Usa alias descriptivos: total_productos, precio_medio, min_precio.
Considera LEFT JOIN + COALESCE para mostrar fabricantes sin productos y evitar NULL en la cuenta.
Revisa la distribución: grupos con pocas filas pueden distorsionar el promedio.

Función	Propósito	Ejemplo
COUNT(*)	Cuenta todas las filas	COUNT(*) AS cuenta
SUM	Suma valores numéricos	SUM(precio) AS total
AVG/MIN/MAX	Promedio / mínimo / máximo	AVG(precio), MIN(precio), MAX(precio)

Filtrar agregados con HAVING: cuándo usarlo en vez de WHERE

HAVING sirve para aplicar condiciones sobre métricas que resultan tras agrupar filas.

WHERE filtra a nivel de fila antes del GROUP BY. HAVING filtra después, cuando ya existen funciones como SUM, COUNT o AVG.

Un ejemplo real:

SELECT Candidate, Election_year, SUM(Total_$), COUNT(*) FROM combined_party_data WHERE Election_year = 2016 GROUP BY Candidate, Election_year HAVING COUNT(*) > 80 ORDER BY COUNT(*) DESC;

También puedes usar BETWEEN en HAVING para acotar totales. Por ejemplo:

HAVING SUM(Total_$) BETWEEN 3000000 AND 18000000

Recuerda que BETWEEN es inclusivo. Define con claridad los límites para evitar malentendidos en un informe.

Usa HAVING cuando necesites filtrar por una función agregada; WHERE no accede a agregados.
Aplica primero WHERE para reducir filas y mejorar rendimiento antes de agrupar.
Si hay muchos grupos, añade índices y documenta la razón del filtro para que el resultado tenga valor para la base del negocio.

Propósito	Cláusula	Uso típico
Filtrar filas	WHERE	Restricción por fecha o tipo
Filtrar grupos	HAVING	Contar o sumar y filtrar por número
Rangos agregados	HAVING + BETWEEN	Sumas o cuentas entre dos valores

Consultas multitabla: JOIN interno para combinar tablas

Un INNER JOIN une registros relacionados para devolver una lista con valores de varias tablas.

¿Qué hace un INNER JOIN? Combina dos tablas cuando existe coincidencia entre una clave foránea y su clave primaria. El resultado incluye solo las filas que aparecen en ambas tablas.

Sintaxis: forma antigua y forma moderna

La forma moderna es clara y mantenible:

SELECT p.nombre, p.precio, f.nombre FROM producto p INNER JOIN fabricante f ON f.id = p.id_fabricante;

La forma antigua usa coma y condición en WHERE:

SELECT p.nombre, p.precio, f.nombre FROM producto p, fabricante f WHERE f.id = p.id_fabricante;

Seleccionar columnas de varias tablas con alias

Usa alias de tabla para desambiguar nombres y acortar la escritura. Selecciona solo las columnas relevantes y pon alias legibles, por ejemplo nombre_producto y nombre_fabricante.

Verifica la condición ON para evitar duplicados o pérdida de filas.
Documenta la relación si hay varias claves posibles.
Asegura índices en las columnas de unión para mejorar rendimiento y validar el resultado con muestras.

LEFT JOIN y RIGHT JOIN: incluir filas sin coincidencia

Aprender a conservar filas sin coincidencia ayuda a detectar huecos en tus datos maestros.

LEFT JOIN devuelve todas las filas de la tabla izquierda y las coincidencias de la derecha.
Las columnas de la tabla derecha aparecen como NULL cuando no hay relación.
Esto facilita listar nombres maestros aunque no tengan detalle asociado.

RIGHT JOIN actúa al contrario: prioriza la tabla derecha.
Ambas formas son equivalentes en resultado si se cambian las posiciones; elige la que exprese mejor la intención.

Detectar fabricantes o departamentos sin productos

Para encontrar fabricantes sin producto, une fabricante con producto y filtra las filas sin coincidencia:

SELECT f.nombre FROM fabricante f LEFT JOIN producto p ON p.id_fabricante = f.id WHERE p.id IS NULL;

En empleados, un LEFT JOIN entre departamento y empleado revela áreas vacías usando la misma condición NULL.

LEFT JOIN conserva filas del maestro aunque falten valores relacionados en la otra tabla.
No muevas filtros de la tabla derecha al WHERE si quieres mantener las no coincidencias; usa ON o IS NULL.
Usa COALESCE al agregar para convertir NULL en cero y obtener cuentas claras.
Verifica la clave foránea para no perder filas huérfanas y revisa cardinalidades para evitar duplicados.

Situación	Cláusula	Resultado
Fabricantes sin producto	LEFT JOIN + WHERE p.id IS NULL	Lista de nombres de fabricantes sin productos
Departamentos vacíos	LEFT JOIN departamento d LEFT JOIN empleado e ON e.id_departamento = d.id WHERE e.id IS NULL	Listado de secciones sin empleados
Preferir tabla derecha	RIGHT JOIN	Conserva filas de la tabla derecha y NULL en la izquierda

Patrones de texto y rangos: LIKE, IN, NOT IN y BETWEEN: Ejemplos de consultas SQL básicas

Buscar patrones en texto y acotar rangos numéricos facilita extraer la lista que necesitas.

LIKE permite matching por patrones en cadenas. Por ejemplo, 'S%' devuelve nombres que empiezan por S, '%e' los que terminan en e y '%Portátil%' los que contienen la palabra.

IN filtra por una lista explícita de valores, por ejemplo id_fabricante IN (1,3,5). NOT IN excluye esos valores, pero cuidado: si hay NULL en la lista el resultado puede ser inesperado.

BETWEEN define rangos inclusivos. Ejemplo práctico:

SELECT studentID, FullName FROM student WHERE studentID BETWEEN 2 AND 7;

En tienda, para precios puedes usar precio BETWEEN 60 AND 200. Si prefieres no usar BETWEEN, logra el mismo efecto con comparadores: precio >= 80 AND precio <= 300.

Las búsquedas con '%x' al inicio son costosas; considera índices de texto o búsqueda por prefijos.
Para fechas, BETWEEN '2022-01-01' AND '2022-12-31' incluye ambos extremos; otra opción es usar >= y < con límite superior exclusivo.
Si la lista en IN es larga, usa una tabla de referencia y evita mantener muchos valores en la cláusula.

Consejo: define la collation y sensibilidad a acentos al buscar nombres en español y usa NOT EXISTS en vez de NOT IN cuando haya NULLs.

Limitación y paginación: LIMIT y OFFSET para listas

La paginación convierte una lista extensa en ventanas manejables.

LIMIT acota el número de filas que devuelve una consulta. En MySQL, LIMIT n devuelve las primeras n filas. Para desplazar la ventana usa LIMIT offset, n, que es útil para paginar resultados en una interfaz.

Top-N y ejemplos prácticos

Para obtener los productos más caros aplica ORDER BY precio DESC LIMIT N. Para los más baratos cambia a ORDER BY precio ASC LIMIT N.

En la base tienda, devuelve cinco primeras filas de fabricante con LIMIT 5. Para obtener 2 filas a partir de la cuarta usa LIMIT 3,2 (incluye la cuarta).

Consejo: siempre especifica un criterio de orden. Paginar sin ORDER BY puede producir un resultado no determinista.

LIMIT reduce transferencia y acelera vistas previas.
OFFSET desplaza la ventana; para offsets grandes evalúa paginación por cursor.
Expón el número por página y muestra el total de filas para contexto.

Ejemplos de consultas SQL básicas

Ver cómo una consulta muestra columnas y filas ayuda a interpretar cualquier base.

Todas columnas y todas filas: para una revisión rápida usa SELECT * FROM employees;. Esta forma devuelve lista completa y permite inspeccionar nombres de columnas y tipos.

Lista de nombres y dos columnas: si sólo necesitas un campo, SELECT first_name FROM employees; centra el resultado en una sola columna. Para dos columnas y alias legibles usa SELECT first_name AS nombre, last_name AS apellido FROM employees;.

Orden y prioridad

Ordena un resultado para facilitar su lectura. Por ejemplo:

ORDER BY last_name DESC para apellidos de Z a A.
ORDER BY salary DESC, last_name ASC prioriza salarios altos y desempata por apellido.

Resumen por departamento

Para contar empleados por unidad y mostrar departamentos sin personal:

SELECT d.nombre, COUNT(e.id) AS total_empleados FROM departamento d LEFT JOIN empleado e ON e.id_departamento = d.id GROUP BY d.nombre;

Propósito	Ejemplo	Resultado
Revisión rápida	SELECT * FROM employees;	Todas columnas tabla y todas filas tabla
Lista de nombres	SELECT first_name FROM employees;	Lista con un valor por fila
Cuenta por departamento	GROUP BY d.nombre + COUNT(e.id)	Cuenta total_empleados por departamento

Subconsultas: en WHERE, HAVING, con IN/EXISTS y correlacionadas

Las subconsultas permiten usar un resultado interno como referencia en otra consulta. Son útiles cuando necesitas comparar un valor contra un agregado o verificar relaciones sin traer todas las filas.

Comparar contra el precio máximo

Una subconsulta en WHERE puede devolver el máximo por fabricante. Por ejemplo, para ver productos cuyo precio sea igual o superior al más caro de Lenovo:

WHERE precio >= (SELECT MAX(precio) FROM producto WHERE nombre_fabricante = ‘Lenovo’)

EXISTS y NOT EXISTS para relaciones

EXISTS verifica si hay al menos una fila relacionada sin traer detalles. Use NOT EXISTS en vez de NOT IN cuando la subconsulta puede devolver NULLs.

N-ésimo salario o precio

En MySQL combina DISTINCT, ORDER BY y LIMIT para el enésimo valor. Anida una subconsulta con LIMIT N-1,1 o usa dos niveles con ORDER BY y LIMIT para obtener el N-ésimo salario.

HAVING admite subconsultas para filtrar grupos según otro total.
Las correlacionadas referencian columnas externas; cuidado con rendimiento.
Verifica tipos y añade índices si la subconsulta se repite por fila.

Caso	Forma	Nota
Máximo por fabricante	WHERE columna >= (SELECT MAX(…))	Sin JOIN
Existencia	WHERE EXISTS (SELECT 1 FROM tabla WHERE …)	Eficiente
N-ésimo valor	SELECT … FROM (SELECT DISTINCT … ORDER BY … LIMIT n) t	Usar LIMIT

Vistas y fundamentos de DDL/DCL: CREATE VIEW, CREATE USER y privilegios

Con vistas y roles puedes exponer solo las columnas necesarias sin compartir la tabla entera.

Las vistas encapsulan una consulta y muestran únicamente los datos que quieres ofrecer. Funcionan como una interfaz lógica: el usuario ve una lista con columnas y filas seleccionadas sin acceder a las tablas base.

Sintaxis básica:

CREATE VIEW view_name AS select_statement;

Ejemplo:

create view `programming-students-v` as SELECT FullName, programOfStudy FROM student WHERE programOfStudy=’Programming’;

Usuarios, roles y privilegios: Ejemplos de consultas SQL básicas

Crea usuarios y roles para controlar quién puede ver o modificar objetos en la base. Usa DDL/DCL como CREATE USER y CREATE ROLE y gestiona permisos con GRANT y REVOKE.

Crear un usuario: CREATE USER my723acct IDENTIFIED BY ‘…’;
Rol ejemplo: CREATE ROLE role_tables_and_views;
Privilegios: GRANT create session, create table, create view TO role_tables_and_views;
Conceder acceso: GRANT SELECT ON inventory TO rita, anny;
Revocar y eliminar: REVOKE create table, create view FROM rita; DROP USER rita CASCADE;

Propósito	Sentencia	Resultado
Exponer columnas necesarias	CREATE VIEW … AS SELECT	Lista con columnas y filas filtradas
Control de acceso	CREATE ROLE + GRANT	Usuarios con privilegios mínimos
Retirar permisos	REVOKE / DROP USER	Quitar acceso y limpiar cuentas

Buenas prácticas: documenta el propósito y el nombre de cada vista, aplica el principio de menor privilegio y evita anidar vistas costosas para no afectar el rendimiento.

Práctica guiada con dos bases: “tienda” y “empleados”

Usa estas prácticas para aplicar lo aprendido en ejemplos reales. Trabaja sobre las bases tienda (fabricante, producto) y empleados (departamento, empleado) para convertir datos en respuestas accionables.

Consultas sobre una tabla: lista, filtros, alias y orden

Lista productos con precio y aplica alias claros: euros por columna. Usa LIKE para buscar ‘%Portátil%’ o ‘%Monitor%’.

Consultas multitabla: producto y fabricante con JOIN

Compara la sintaxis moderna (INNER JOIN … ON) con la forma antigua (coma + WHERE). Une producto y fabricante para mostrar el nombre del fabricante junto al producto.

Consultas resumen: totales, medias y conteos por fabricante

Calcula COUNT(*), AVG(precio), MIN y MAX por fabricante. Emplea LEFT JOIN + COALESCE para incluir fabricantes sin producto y ver cuenta 0.

Subconsultas: productos al nivel del máximo de un fabricante

Usa subconsultas para listar productos cuyo precio = (SELECT MAX(precio) FROM producto WHERE id_fabricante = p.id_fabricante). Extiende con LIMIT para Top-5.

Caso	Sentencia	Resultado
Lista productos	SELECT nombre, precio AS euros FROM producto ORDER BY precio DESC;	lista ordenada por precio
Resumen por fabricante	SELECT f.nombre, COUNT(p.id) FROM fabricante f LEFT JOIN producto p ON p.id_fabricante=f.id GROUP BY f.nombre;	cuenta por fabricante
Máximo por fabricante	SELECT * FROM producto p WHERE precio = (SELECT MAX(precio) FROM producto WHERE id_fabricante = p.id_fabricante);	productos al máximo

Conclusión: Ejemplos de consultas SQL básicas

Termina consolidando las piezas clave que convierten datos en respuestas claras y útiles para la empresa.

Ya dominas la sintaxis esencial: selección de columnas, filtros, orden y agregados, JOINs, rangos, paginación y subconsultas aplicadas sobre la base tienda y empleados.

Practica con listas reales: transforma una pregunta en una consulta que devuelva un resultado reproducible y valida el número y la calidad de filas antes de usarlo en producción.

Avanza creando vistas y gestionando permisos para exponer solo lo necesario. El siguiente paso es estudiar ventanas y optimización para llevar tu dominio al total esperado.

FAQ: Ejemplos de consultas SQL básicas

¿Qué es SQL y cómo se comunica con una base de datos?

SQL (Structured Query Language) es el lenguaje estándar para consultar y manipular bases de datos relacionales. Envías instrucciones como SELECT, INSERT, UPDATE o DELETE; el motor de la base de datos interpreta esas órdenes, busca los datos en tablas y devuelve filas y columnas según la consulta.

¿Cuándo conviene usar SELECT * FROM tabla y cuándo evitarlo?

SELECT * devuelve todas las columnas y filas de una tabla, útil en pruebas o para explorar datos. Evítalo en producción cuando solo necesites columnas concretas: reduce ancho de banda, mejora rendimiento y previene revelar datos sensibles.

¿Cómo devuelvo solo una columna de nombres de una tabla?

Usa SELECT nombre FROM empleados; esto devuelve una lista de valores de la columna nombre para todas las filas que cumplen la condición (si hay WHERE). Es eficiente y claro para mostrar solo lo necesario.

¿Cómo seleccionar dos columnas y darles alias para mejor lectura?

Escribe SELECT nombre AS empleado, salario AS sueldo FROM empleados; AS crea alias legibles en el resultado, útiles para informes y presentaciones de datos.

¿Cómo filtrar por igualdad de texto sin errores con comillas?

En SQL las cadenas van entre comillas simples: WHERE departamento = ‘Ventas’. Evita comillas dobles a menos que el motor las acepte para cadenas; las comillas dobles suelen reservarse para identificadores.

¿Qué operadores uso para comparar números y fechas?

Emplea operadores como =, , = y BETWEEN para rangos. Para fechas, trata los literales según el formato del motor (por ejemplo ‘2025-01-01’) y convierte tipos si es necesario.

¿Cómo combinar condiciones con AND, OR y NOT?

Usa AND para exigir varias condiciones, OR para aceptar alternativas y NOT para negar. Agrupa con paréntesis para controlar prioridad: WHERE (categoria = ‘A’ AND activo = 1) OR prioridad = ‘alta’.

¿Cómo ordenar resultados en orden ascendente o descendente?

Añade ORDER BY columna ASC para ascendente o ORDER BY columna DESC para descendente. Puedes listar varias columnas para prioridades de orden.

¿Qué diferencia hay entre ASC y DESC cuando ordenas por varias columnas?

Cada columna puede llevar ASC o DESC. La primera columna define la prioridad principal; si hay empate, se aplica la siguiente columna y su respectiva dirección.

¿Cómo hacer cálculos simples en la consulta y nombrar la columna resultante?

Aplica operadores aritméticos: SELECT precio, cantidad, precio * cantidad AS total FROM ventas; el alias total muestra el resultado de la operación por fila.

¿Cuándo usar SUM, COUNT, AVG, MIN y MAX con GROUP BY?

Usa estas funciones para agregar datos por grupos: por ejemplo, SUM(sueldo) y GROUP BY departamento muestra el total por departamento. GROUP BY es obligatorio cuando mezclas columnas no agregadas con funciones de agregación.

¿Qué diferencia hay entre COUNT(*) y COUNT(columna)?

COUNT(*) contabiliza todas las filas del grupo, incluso con valores NULL. COUNT(columna) cuenta solo las filas donde esa columna no es NULL.

¿Cuándo usar HAVING en lugar de WHERE para filtrar resultados agregados?

WHERE filtra filas antes de agrupar; HAVING filtra grupos después de aplicar funciones de agregación. Por ejemplo: GROUP BY departamento HAVING SUM(ventas) > 10000.

¿Cómo se hace un INNER JOIN y cuándo usarlo?

INNER JOIN combina filas de dos tablas cuando existe coincidencia en la condición ON. Es ideal para obtener datos relacionados, por ejemplo productos con su fabricante: FROM producto p INNER JOIN fabricante f ON p.fabricante_id = f.id.

¿Cuál es la utilidad de los alias al seleccionar columnas de varias tablas?

Los alias (p, f, etc.) evitan ambigüedad y hacen las consultas más cortas: SELECT p.nombre, f.nombre AS fabricante FROM producto p JOIN fabricante f ON….

¿Qué hacen LEFT JOIN y RIGHT JOIN y cuándo aplicarlos?

LEFT JOIN incluye todas las filas de la tabla izquierda aunque no tengan coincidencia en la derecha; RIGHT JOIN hace lo opuesto. Úsalos para detectar elementos sin relación, por ejemplo fabricantes sin productos.

¿Cómo buscar patrones de texto con LIKE e IN para listas?

LIKE permite patrones con % y _: WHERE nombre LIKE ‘Ana%’ busca nombres que empiezan por Ana. IN filtra por lista de valores: WHERE departamento IN (‘Ventas’,’Soporte’).

¿Cómo usar BETWEEN para rangos y qué alternativas hay?

BETWEEN incluye los extremos: WHERE precio BETWEEN 10 AND 50. Alternativas son comparaciones combinadas: WHERE precio >= 10 AND precio

¿Cómo limitar resultados y paginar con LIMIT y OFFSET?

LIMIT controla cuántas filas devuelve la consulta; OFFSET salta filas iniciales. Por ejemplo: ORDER BY fecha DESC LIMIT 10 OFFSET 20 para la tercera página de 10 registros.

¿Cómo obtener los Top-N productos más caros con ORDER BY y LIMIT?

Ordena por precio descendente y limita el resultado: SELECT nombre, precio FROM producto ORDER BY precio DESC LIMIT 5 para los 5 más caros.

¿Cómo escribir subconsultas en WHERE o HAVING y cuándo usarlas?

Puedes anidar SELECT dentro de WHERE: WHERE precio > (SELECT MAX(precio) FROM producto WHERE fabricante_id = 5). Úsalas para comparar contra resultados agregados o condiciones derivadas.

¿Qué ventajas ofrecen las vistas y cuándo crear una?

CREATE VIEW permite exponer solo columnas necesarias y simplificar consultas repetitivas. Protege datos sensibles y mejora mantenibilidad de consultas complejas.

¿Cómo crear usuarios y otorgar permisos básicos para SELECT?

Usa CREATE USER y GRANT SELECT ON base.tabla TO usuario; así limitas accesos y garantizas que cada cuenta solo vea lo necesario.

¿Qué ejercicios prácticos puedo hacer con dos bases llamadas tienda y empleados?

Practica SELECT y filtros en cada tabla, JOIN entre producto y fabricante, agregados por fabricante, y subconsultas para comparar precios máximos por fabricante.

¿Cómo obtener el número total y la suma de salarios por departamento?

SELECT departamento, COUNT(*) AS empleados, SUM(salario) AS total_salarios FROM empleados GROUP BY departamento ORDER BY total_salarios DESC; esto muestra conteo y suma por departamento.

¿Qué técnicas sirven para hallar el N-ésimo salario o precio?

Puedes usar subconsultas con ORDER BY y LIMIT/OFFSET, o funciones de ventana como ROW_NUMBER() en motores que las soportan para seleccionar el enésimo valor ordenado.