Buenas prácticas de formateo SQL: Escribe consultas limpias y escalables

Por qué importa el formateo SQL

SQL es uno de los lenguajes más utilizados en el desarrollo de software. Cada desarrollador backend, analista de datos e ingeniero DevOps escribe consultas SQL regularmente.

Pero la mayoría de las consultas SQL en bases de código de producción lucen así:

SELECT u.id,u.name,u.email,o.total,o.created_at FROM users u JOIN orders o ON u.id=o.user_id WHERE o.total>100 AND u.active=1 ORDER BY o.created_at DESC LIMIT 50;

Esto funciona. A la base de datos no le importa el formateo. Pero a los humanos sí.

Cuando una consulta está en una sola línea, es:

difícil de leer durante la revisión de código
difícil de depurar cuando algo falla
difícil de modificar cuando cambian los requisitos
imposible de entender a las 2 AM durante un incidente

Un formateo SQL limpio no se trata de estética. Se trata de reducir el costo de comprender el código.

Lo básico: una cláusula por línea

La regla de formateo más impactante es: coloca cada cláusula SQL principal en su propia línea.

SELECT
  u.id,
  u.name,
  u.email,
  o.total,
  o.created_at
FROM users u
JOIN orders o ON u.id = o.user_id
WHERE o.total > 100
  AND u.active = 1
ORDER BY o.created_at DESC
LIMIT 50;

Misma consulta. Mismo resultado. Pero ahora puedes ver instantáneamente:

qué columnas se seleccionan
qué tablas se unen
qué condiciones se aplican
cómo se ordenan los resultados

Listas de columnas

Cuando selecciones múltiples columnas, coloca cada una en su propia línea:

-- Malo
SELECT id, name, email, created_at, updated_at, status FROM users;

-- Bueno
SELECT
  id,
  name,
  email,
  created_at,
  updated_at,
  status
FROM users;

Esto facilita:

agregar o eliminar columnas
comentar una sola columna para depuración
ver exactamente qué datos se están recuperando

Formateo de JOIN

Los JOIN son donde las consultas se vuelven complejas. Un formateo claro previene la confusión:

-- Malo
SELECT u.name,o.total,p.name FROM users u JOIN orders o ON u.id=o.user_id JOIN products p ON o.product_id=p.id WHERE o.status='completed';

-- Bueno
SELECT
  u.name,
  o.total,
  p.name AS product_name
FROM users u
JOIN orders o
  ON u.id = o.user_id
JOIN products p
  ON o.product_id = p.id
WHERE o.status = 'completed';

Reglas para los JOIN:

cada JOIN tiene su propia línea
la condición ON se indenta debajo del JOIN
usa tipos de JOIN explícitos (INNER JOIN, LEFT JOIN) en lugar de solo JOIN cuando el tipo importa
usa alias cortos y significativos para las tablas

Cláusulas WHERE

Para múltiples condiciones, indenta cada condición:

-- Malo
WHERE status='active' AND created_at>'2025-01-01' AND total>100 AND country IN ('US','UK','FR')

-- Bueno
WHERE status = 'active'
  AND created_at > '2025-01-01'
  AND total > 100
  AND country IN ('US', 'UK', 'FR')

Para lógica compleja con OR, usa paréntesis claramente:

WHERE status = 'active'
  AND (
    country = 'US'
    OR country = 'UK'
  )
  AND total > 100

Subconsultas

Las subconsultas son la parte más difícil de formatear. La clave es una indentación consistente:

SELECT
  u.name,
  u.email,
  order_summary.total_spent
FROM users u
JOIN (
  SELECT
    user_id,
    SUM(total) AS total_spent
  FROM orders
  WHERE status = 'completed'
  GROUP BY user_id
) AS order_summary
  ON u.id = order_summary.user_id
WHERE order_summary.total_spent > 1000
ORDER BY order_summary.total_spent DESC;

Reglas:

indenta el cuerpo de la subconsulta
cierra el paréntesis al mismo nivel que la palabra clave de apertura
siempre dale un alias significativo a las subconsultas

Common Table Expressions (CTEs)

Para consultas complejas, los CTEs son más limpios que las subconsultas anidadas:

WITH active_users AS (
  SELECT
    id,
    name,
    email
  FROM users
  WHERE status = 'active'
    AND last_login > '2025-01-01'
),
user_orders AS (
  SELECT
    user_id,
    COUNT(*) AS order_count,
    SUM(total) AS total_spent
  FROM orders
  WHERE status = 'completed'
  GROUP BY user_id
)
SELECT
  au.name,
  au.email,
  uo.order_count,
  uo.total_spent
FROM active_users au
JOIN user_orders uo
  ON au.id = uo.user_id
WHERE uo.total_spent > 500
ORDER BY uo.total_spent DESC;

Los CTEs hacen las consultas complejas legibles al dividirlas en pasos lógicos con nombre.

Convenciones de nombres

Nombres consistentes previenen la confusión:

| Elemento | Convención | Ejemplo | |---|---|---| | Tablas | minúsculas, plural | users, orders, products | | Columnas | minúsculas, snake_case | created_at, user_id, total_amount | | Alias | cortos, significativos | u para users, o para orders | | CTEs | snake_case descriptivo | active_users, monthly_revenue | | Palabras clave SQL | MAYÚSCULAS | SELECT, FROM, WHERE, JOIN |

La regla más importante: sé consistente. Elige una convención y úsala en todas partes.

Formateo de INSERT y UPDATE

-- INSERT
INSERT INTO users (
  name,
  email,
  status,
  created_at
) VALUES (
  'Alice',
  'alice@example.com',
  'active',
  NOW()
);

-- UPDATE
UPDATE users
SET
  status = 'inactive',
  updated_at = NOW()
WHERE last_login < '2024-01-01'
  AND status = 'active';

Comentarios en SQL

Usa comentarios para explicar el por qué, no el qué:

-- Mal comentario (explica el qué)
-- Seleccionar usuarios donde status es activo
SELECT * FROM users WHERE status = 'active';

-- Buen comentario (explica el por qué)
-- Solo incluir usuarios activos para excluir
-- cuentas eliminadas del reporte
SELECT * FROM users WHERE status = 'active';

Herramientas de formateo

Formatear manualmente cada consulta es tedioso. Usa un formateador para hacer el trabajo pesado, luego ajusta según sea necesario.

Al usar un formateador SQL en línea, ten cuidado con lo que pegas. Si tu consulta contiene nombres reales de tablas, columnas o lógica de negocio, podrías estar exponiendo el esquema de tu base de datos a un servidor de terceros.

Usa un formateador que funcione completamente en tu navegador para que tus consultas nunca salgan de tu máquina.

El Formateador SQL de FmtDev procesa todo localmente. Tu SQL nunca sale de tu navegador.

Checklist de formateo SQL

Una cláusula por línea — SELECT, FROM, JOIN, WHERE, ORDER BY, LIMIT
Una columna por línea en las listas SELECT
Indentar condiciones bajo WHERE y ON
Tipos de JOIN explícitos — escribir INNER JOIN o LEFT JOIN, no solo JOIN
Alias significativos — u para users, no t1
Palabras clave en MAYÚSCULAS — SELECT, FROM, WHERE, JOIN
Identificadores en minúsculas — nombres de tablas, nombres de columnas
CTEs en lugar de subconsultas para lógica compleja
Los comentarios explican el por qué, no el qué
Formatea localmente — nunca pegues SQL propietario en herramientas en línea