QUERY (Consulta) en SQL: qué es, tipos y ejemplos prácticos

Una query (consulta) en SQL es una instrucción que enviamos a la base de datos para obtener, insertar, modificar o eliminar información.
Las queries son la forma en que los usuarios interactúan con un sistema gestor de bases de datos (SGBD) como MySQL, PostgreSQL, SQL Server u Oracle.

👉 En pocas palabras: una query es una pregunta en lenguaje SQL que la base de datos responde con resultados.

Tipos de queries en SQL

Las consultas se pueden clasificar en distintos tipos según su función:

1. Consultas de selección (lectura)

Son las más comunes, usan SELECT para recuperar datos de una o varias tablas.

SELECT nombre, salario
FROM empleados
WHERE salario > 2000
ORDER BY salario DESC;

👉 Devuelve a los empleados con salario mayor a 2000, ordenados de mayor a menor.

2. Consultas de modificación (DML)

Permiten insertar, actualizar o eliminar registros:

INSERT INTO clientes (nombre, email) 
VALUES ('Ana', 'ana@mail.com');

UPDATE clientes 
SET email = 'nuevo@mail.com' 
WHERE id = 1;

DELETE FROM clientes 
WHERE id = 1;

3. Consultas de definición (DDL)

Se utilizan para crear o modificar estructuras de base de datos (tablas, vistas, índices, etc.):

  • CREATE TABLE
CREATE TABLE productos (
  id INT PRIMARY KEY,
  nombre VARCHAR(100),
  precio DECIMAL(10,2)
);
  • ALTER TABLE
ALTER TABLE productos ADD COLUMN stock INT;

DROP TABLE temporal;

4. Consultas de control (DCL)

Otorgan o restringen permisos:

  • GRANT
GRANT SELECT ON empleados TO usuario1;
  • REVOKE
REVOKE SELECT ON empleados FROM usuario1;

5. Consultas de transacción (TCL)

Controlan operaciones dentro de una transacción:

  • BEGIN / START TRANSACTION
  • COMMIT → confirma cambios.
  • ROLLBACK → revierte cambios.

Ejemplo:

BEGIN;
UPDATE cuentas SET saldo = saldo - 100 WHERE id = 1;
UPDATE cuentas SET saldo = saldo + 100 WHERE id = 2;
COMMIT;

👉 Ambas operaciones se confirman juntas.

Estructura general de una query SELECT

SELECT columnas
FROM tabla
[WHERE condición]
[GROUP BY columna]
[HAVING condición]
[ORDER BY columna ASC | DESC]
[LIMIT n OFFSET m];

Explicación:

  • SELECT → qué columnas mostrar.
  • FROM → de qué tabla obtener datos.
  • WHERE → filtrar resultados.
  • GROUP BY → agrupar por categoría.
  • HAVING → filtrar resultados agrupados.
  • ORDER BY → ordenar los resultados.
  • LIMIT / OFFSET → limitar número de filas (paginación).

Ejemplos prácticos de queries

1. Obtener clientes de una ciudad

SELECT nombre, ciudad 
FROM clientes 
WHERE ciudad = 'Madrid';

2. Ventas totales por producto

SELECT producto_id, SUM(total) AS ventas_totales
FROM ventas
GROUP BY producto_id
ORDER BY ventas_totales DESC;

3. Primeros 5 empleados con mejor salario

SELECT nombre, salario
FROM empleados
ORDER BY salario DESC
LIMIT 5;

4. Clientes sin pedidos

SELECT c.nombre
FROM clientes c
LEFT JOIN pedidos p ON c.id = p.cliente_id
WHERE p.id IS NULL;

Queries simples vs queries complejas

  • Query simple: obtiene datos de una sola tabla con filtros básicos.
  • Query compleja: combina múltiples tablas, subconsultas, funciones agregadas y condiciones avanzadas.

Ejemplo de query compleja:

SELECT c.nombre, SUM(p.total) AS gasto_total
FROM clientes c
JOIN pedidos p ON c.id = p.cliente_id
WHERE p.fecha >= '2025-01-01'
GROUP BY c.nombre
HAVING SUM(p.total) > 1000
ORDER BY gasto_total DESC;

👉 Devuelve clientes que gastaron más de 1000 desde 2025.

Subqueries (consultas anidadas)

Una query puede estar dentro de otra.

Ejemplo:

SELECT nombre
FROM empleados
WHERE salario > (
  SELECT AVG(salario) FROM empleados
);

👉 Devuelve empleados que ganan más que el promedio.

Errores comunes al escribir queries

  1. Olvidar la condición de JOIN
    👉 Genera un producto cartesiano con miles de filas inesperadas.
  2. Confundir WHERE y HAVING
    👉 WHERE filtra filas antes de agrupar, HAVING después.
  3. No usar alias
    👉 Hace que queries largas sean difíciles de leer.
  4. Falta de índice en columnas filtradas
    👉 Puede hacer consultas muy lentas en tablas grandes.

Buenas prácticas al escribir queries

  • Usar alias cortos para tablas (c para clientes, p para pedidos).
  • Siempre especificar columnas en lugar de SELECT * en producción.
  • Agregar comentarios en queries complejas.
  • Asegurarse de usar índices en columnas de WHERE y JOIN.
  • Probar primero con LIMIT antes de ejecutar queries sobre millones de filas.

Casos de uso de queries en el día a día

  • Análisis de negocio → ventas por región, clientes más activos.
  • Reportes administrativos → empleados contratados por mes.
  • Aplicaciones web → mostrar productos con filtros dinámicos.
  • Big Data y BI → extracción de datos para dashboards.

Queries en distintos motores de bases de datos

  • MySQL / MariaDB: queries con LIMIT y OFFSET para paginación.
  • PostgreSQL: soporte avanzado para subconsultas y funciones de ventana.
  • SQL Server: utiliza TOP en lugar de LIMIT.
  • Oracle: usa ROWNUM y FETCH FIRST para limitar resultados.

👉 El concepto de query es universal, aunque cada motor tiene pequeñas diferencias de sintaxis.

Preguntas frecuentes (FAQ)

1. ¿Qué es una query en SQL?
Es una instrucción en lenguaje SQL que se ejecuta contra la base de datos.

2. ¿Todas las queries usan SELECT?
No. También hay queries de modificación (INSERT, UPDATE, DELETE) y definición (CREATE, ALTER).

3. ¿Cuál es la query más usada?
SELECT, porque permite leer datos.

4. ¿Puedo anidar queries?
Sí, mediante subconsultas.

5. ¿Una query siempre devuelve resultados?
No necesariamente. Puede devolver cero filas si no hay coincidencias.

Conclusión

Una query en SQL es la herramienta básica para interactuar con bases de datos:

  • Permite leer, insertar, actualizar o eliminar información.
  • Puede ser simple (con una tabla) o compleja (con múltiples joins y subconsultas).
  • Es esencial dominar la sintaxis y los distintos tipos de queries para trabajar con bases de datos en cualquier aplicación real.

Da tus primeros pasos en ¿Qué es SQL? y explora más definiciones en el Glosario SQL completo.

Scroll al inicio