Buenas prácticas para nombrar columnas y tablas con alias en SQL

Nombrar bien los alias en SQL parece un detalle, pero marca la diferencia entre una consulta difícil de entender y un reporte profesional, claro y fácil de mantener. En esta guía vas a aprender, paso a paso y desde cero, cómo elegir buenos nombres de alias para columnas, tablas, subconsultas y CTE, con ejemplos prácticos y tablas que muestran cómo se ven los resultados. Está pensada para principiantes, pero recoge prácticas que usan equipos de datos en proyectos reales.

1) ¿Qué es un alias y qué NO es?

Un alias es un nombre temporal que le das a una columna o a una tabla dentro de una consulta. Solo vive mientras se ejecuta la consulta y no modifica la estructura de la base de datos.

• Alias de columna: SELECT columna AS nombre_claro FROM tabla;
• Alias de tabla: SELECT t.columna FROM tabla AS t;

No es lo mismo que renombrar una columna de forma permanente. Para cambios definitivos se usan sentencias como ALTER TABLE ... RENAME COLUMN .... El alias, en cambio, solo mejora la lectura y simplifica tu SELECT.

2) Principios para elegir buenos nombres de alias

1. Claridad para humanos. El alias debería explicarle al lector “qué es” esa columna: total_linea, ventas_mes, nombre_completo.
2. Consistencia. Usar siempre el mismo estilo (ej., snake_case) y patrones repetibles.
3. Orientado al negocio. Preferí nombres que entienda quien mira el informe: cliente, importe, ticket_promedio.
4. Evitar abreviaturas crípticas. A menos que todo el equipo las conozca (ej., cli por “cliente”), evitá c1, nmb, etc.
5. Compatibilidad. No uses palabras reservadas (user, order, group, rank). Evitá espacios si podés. Si los usás, comillá.
6. Brevedad con sentido. Corto, pero no confuso. Mejor ventas que suma_total_importes_clientes_periodo.

Estilo recomendado: snake_case en minúsculas y en español (si tu sitio y equipo trabajan en español): ventas_ciudad, total_linea, acumulado_cliente.

3) Alias de columna: del “técnico” al “legible”

3.1 Ejemplo básico

SELECT
  id         AS cliente_id,
  nombre     AS cliente,
  fecha_alta AS alta,
  activo     AS esta_activo
FROM clientes;

Resultado sin alias:

Resultado con alias:

El alias traduce el lenguaje técnico a un título entendible para cualquiera.

3.2 Alias para expresiones calculadas

SELECT
  precio,
  cantidad,
  precio * cantidad AS total_linea
FROM ventas;

Salida sin alias:

Salida con alias:

3.3 Transformaciones de texto o fecha

-- PostgreSQL (|| concatena texto)
SELECT
  nombre || ' ' || apellido AS nombre_completo
FROM usuarios;

Resultado:

Nombrá el resultado (qué es), no la técnica (cómo lo calculaste).

3.4 Espacios y mayúsculas en alias (compatibilidad)

• Preferible: evitar espacios y mayúsculas para no depender de comillas.
• Si los usás, recordá:
  • Estándar/PG/Oracle: SELECT nombre AS "Nombre completo" FROM usuarios;
  • SQL Server: SELECT nombre AS [Nombre completo] FROM usuarios;
  • MySQL: admite comillas dobles o invertidas (`Nombre completo`), según configuración.

4) Alias de tabla: imprescindibles con JOIN

Cuando unís tablas, escribir clientes.nombre y pedidos.total mil veces cansa. Alias de tabla lo hace corto y claro.

SELECT c.nombre, p.total
FROM clientes AS c
JOIN pedidos  AS p ON p.cliente_id = c.id;

Convenciones de alias de tabla:

• Una letra con sentido: c (clientes), p (pedidos), e (empleados).
• Dos letras para evitar choques o ser más específicos: em (empleados), dp (departamentos).
• Prefijos por dominio si tenés muchas tablas (cli_, ped_), aunque esto se usa más en nombres de tablas que en alias.

Auto-join (la misma tabla dos veces):

SELECT
  e1.nombre AS empleado,
  e2.nombre AS jefe
FROM empleados e1
JOIN empleados e2 ON e1.jefe_id = e2.id;

Resultado:

Si no ponés alias, no hay forma de distinguir las dos instancias de la misma tabla.

5) Subconsultas y CTE: alias obligatorio y nombres descriptivos

• En una subconsulta dentro de FROM, el alias es obligatorio: SELECT t.ciudad, t.total_clientes FROM ( SELECT ciudad, COUNT(*) AS total_clientes FROM clientes GROUP BY ciudad ) AS t ORDER BY t.total_clientes DESC;
• En un CTE (WITH), usá nombres que cuenten qué hace: WITH ventas_30d AS ( SELECT cliente_id, SUM(total) AS ventas FROM pedidos WHERE fecha >= CURRENT_DATE - INTERVAL '30 days' GROUP BY cliente_id ) SELECT c.nombre AS cliente, v.ventas FROM clientes c JOIN ventas_30d v ON v.cliente_id = c.id ORDER BY v.ventas DESC;

Buenas prácticas de nombres para CTE/subconsultas:

• base, agg, resumen, ventas_30d, top_clientes, acumulados_mes.
• Evitá t1, tmp, xxx salvo en ejemplos mínimos.

6) Alias con agregaciones (COUNT, SUM, AVG…) y métricas de negocio

Las funciones de agregación son más legibles con alias semánticos:

SELECT
  departamento,
  COUNT(*)           AS empleados,
  SUM(salario)       AS masa_salarial,
  ROUND(AVG(salario),2) AS salario_promedio
FROM empleados
GROUP BY departamento
ORDER BY salario_promedio DESC;

Resultado:

Patrones útiles de nombres (métricas):

• total_*, suma_*, promedio_*, max_*, min_*, conteo_*.
• *_mes, *_ciudad, *_cliente cuando la métrica depende de una dimensión.

7) Alias con funciones de ventana (OVER): nombres que “se explican solos”

Las funciones de ventana calculan métricas fila por fila sin colapsar la tabla. Alias claros evitan confusiones:

SELECT
  c.cliente_id,
  c.mes,
  SUM(c.total) OVER (PARTITION BY c.cliente_id ORDER BY c.mes) AS acumulado_cliente,
  RANK()      OVER (PARTITION BY c.mes ORDER BY c.total DESC)  AS ranking_mes
FROM consumos c;

Resultado simplificado:

Patrones útiles para ventana:

• acumulado_*, ranking_*, percentil_*, promedio_movil_*.

8) Alias para datos JSON: exponer claves con nombres limpios

Cuando los detalles están en JSON, el alias traduce expresiones largas a columnas legibles.

-- PostgreSQL / MySQL 5.7+
SELECT
  o.id,
  o.detalle->>'sku'               AS sku,
  (o.detalle->>'precio')::numeric AS precio,
  o.detalle->>'moneda'            AS moneda
FROM ordenes o
WHERE o.detalle->>'moneda' = 'USD';

Resultado:

Sin alias, los encabezados serían expresiones JSON difíciles de leer.

9) Orden de evaluación en SQL y alias (por qué falla WHERE total > 100)

Orden lógico (simplificado):

1. FROM / JOIN
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY
7. LIMIT / OFFSET

Consecuencias:

• El alias de la lista SELECT no existe cuando se evalúa WHERE.
• Sí podés usar alias en ORDER BY.
• HAVING suele permitir alias (depende del motor).

Error típico y solución:

-- ❌ Falla: 'total' aún no existe en WHERE
SELECT precio * cantidad AS total
FROM ventas
WHERE total > 100;

-- ✅ Solución 1: repetir la expresión
SELECT precio * cantidad AS total
FROM ventas
WHERE (precio * cantidad) > 100;

-- ✅ Solución 2: subconsulta o CTE
WITH base AS (
  SELECT precio * cantidad AS total
  FROM ventas
)
SELECT *
FROM base
WHERE total > 100;

10) Compatibilidad entre motores: comillas y palabras reservadas

• MySQL/MariaDB: AS opcional; alias con espacios usando comillas dobles o invertidas (`...`).
• PostgreSQL: AS opcional; para espacios, comillas dobles "...".
• SQL Server: AS opcional; para espacios, corchetes [ ... ] o comillas dobles.
• Oracle: AS opcional; para espacios, comillas dobles.

Recomendación universal:

• Usar AS por claridad.
• Evitar espacios y acentos. Si los usás, comillá.
• Evitar palabras reservadas como alias (o comillarlas, pero mejor evitarlas).

11) Anti-patrones (malas prácticas) y cómo corregirlos

A) Alias crípticos o inconsistentes

• ❌ SELECT p.id AS a1, p.total AS a2 FROM pedidos p;
• ✅ SELECT p.id AS pedido_id, p.total AS importe FROM pedidos p;

B) Alias duplicados

• ❌ Dos columnas con el alias total → confunde y rompe exportaciones.
• ✅ Alias únicos: total_linea, total_pedido, ventas_mes.

C) Alias que describen la técnica, no el significado

• ❌ SELECT CONCAT(nombre, ' ', apellido) AS concat_nombre_apellido
• ✅ SELECT CONCAT(nombre, ' ', apellido) AS nombre_completo

D) Mezclar idiomas y estilos

• ❌ SELECT SUM(total) AS totalSales (camelCase + inglés en sitio en español)
• ✅ SELECT SUM(total) AS ventas_totales (snake_case + español)

E) Usar alias en WHERE

• Ya vimos por qué falla. Solución: repetir la expresión o usar subconsulta/CTE.

12) Guía de estilo

Reglas generales

• Estilo: snake_case, minúsculas, español.
• Alias de tabla: una o dos letras (c = clientes, p = pedidos, e = empleados).
• Alias de columna: nombres de negocio y únicos.
• Evitar palabras reservadas; si hay espacios, comillas dobles.

Prefijos útiles para métricas

• total_*, suma_*, promedio_*, max_*, min_*, conteo_*, acumulado_*, ranking_*.

Diccionario sugerido (ejemplos)

• id → cliente_id, pedido_id, empleado_id (según tabla).
• total → importe, ventas, total_linea (si es precio × cantidad).
• fecha → fecha_pedido, fecha_alta, mes (si es el primer día del mes).
• nombre + apellido → nombre_completo.
• SUM(total) → ventas_totales o ventas_mes (si hay dimensión temporal).

CTE y subconsultas (nombres)

• ventas_30d, top_clientes, resumen_mensual, agg_pedidos, base_productos.

Pegá estas reglas en tu README o wiki. La consistencia baja errores y acelera revisiones.

13) Caso completo aplicando las buenas prácticas

Objetivo: informe de top clientes (30 días) con métricas claras y nombres amigables.

WITH ventas_30d AS (
  SELECT
    p.cliente_id,
    COUNT(p.id)            AS pedidos,
    SUM(p.total)           AS ventas,
    ROUND(AVG(p.total), 2) AS ticket_promedio
  FROM pedidos p
  WHERE p.fecha >= CURRENT_DATE - INTERVAL '30 days'
  GROUP BY p.cliente_id
),
ranking AS (
  SELECT
    cliente_id,
    ventas,
    RANK() OVER (ORDER BY ventas DESC) AS ranking_global
  FROM ventas_30d
)
SELECT
  c.id         AS cliente_id,
  c.nombre     AS cliente,
  v.pedidos,
  v.ventas,
  v.ticket_promedio,
  r.ranking_global
FROM clientes c
JOIN ventas_30d v ON v.cliente_id = c.id
JOIN ranking   r ON r.cliente_id  = c.id
ORDER BY v.ventas DESC
LIMIT 10;

Resultado (ejemplo):

Qué aprendemos del ejemplo:

• CTE descriptivos (ventas_30d, ranking).
• Alias de medidas que cuentan qué son (pedidos, ventas, ticket_promedio).
• Alias de salida legibles: la tabla final se entiende como un reporte.

14) ¿Cuándo conviene no usar alias?

• Cuando el nombre original ya es perfecto y el reporte no lo va a ver nadie más.
• En consultas de exploración rápida donde el alias no aporta claridad extra (pero aun así, es buena práctica ir poniéndolos desde el principio si la consulta va a “vivir”).

15) Conclusión

Elegir buenos alias no es cosmética: es la base para escribir SQL claro, mantenible y profesional.
Recordá estas ideas clave:

• Aliases explican el significado de las columnas y acortan el código en JOIN.
• Usá nombres de negocio, snake_case, consistentes y sin palabras reservadas.
• Subconsultas y CTE siempre con alias descriptivos.
• En agregaciones y funciones de ventana, elegí alias que “se expliquen solos”.
• Si necesitás reutilizar cálculos o filtrar por un alias, subí la lógica a un CTE.

Con estas buenas prácticas, tus consultas serán más fáciles de leer para ti y tu equipo, y tus reportes se van a entender sin traducción. A partir de ahora, cada alias cuenta una historia clara sobre tus datos.

📚 Artículos relacionados

• Cómo usar alias en SQL para simplificar consultas SELECT con ejemplos
  Guía paso a paso para principiantes donde aprenderás a usar alias en combinación con SELECT, con ejemplos prácticos y resultados claros.
• Cómo aplicar alias en subconsultas SQL para mejorar la legibilidad
  Explicación detallada y práctica de cómo usar alias en subconsultas para que las consultas sean más claras, organizadas y fáciles de mantener.
• Uso de alias en SQL con funciones de agregación como COUNT y SUM
  Ejemplos prácticos y explicaciones para aplicar alias en funciones de agregación y generar reportes legibles y profesionales.
• Errores comunes al trabajar con alias en SQL y cómo evitarlos
  Lista de errores frecuentes al usar alias en SQL con soluciones claras para evitarlos y escribir consultas sin fallos.