ERROR 1054: Unknown column

El error 1054 es uno de los más frecuentes al escribir consultas en MySQL. Aparece cuando la consulta hace referencia a una columna que MySQL no encuentra en ninguna de las tablas implicadas. Puede tratarse de una simple errata, de una columna que existe en otra tabla, de un alias usado donde no está permitido o de un valor de texto que MySQL ha interpretado como nombre de columna por culpa de las comillas. La buena noticia es que el propio mensaje indica qué columna falla y en qué parte de la consulta, así que con un poco de método se resuelve en pocos minutos.

El mensaje de error

El mensaje completo tiene siempre la misma forma: el código 1054, el estado SQL 42S22, el nombre de la columna que no se reconoce y la parte de la consulta donde apareció. Por ejemplo, si escribimos mal el nombre de la columna precio en un SELECT:

SELECT nombre, precoi FROM productos;

ERROR 1054 (42S22): Unknown column 'precoi' in 'field list'

Lo que aparece entre las segundas comillas es la pista más útil del mensaje, porque indica en qué cláusula de la consulta está la referencia problemática. Estas son las variantes más habituales:

Si la columna aparece con prefijo, como 'p.precio', el mensaje también lo incluye. Eso ya indica que el problema puede estar en el alias de tabla y no solo en el nombre de la columna.

Causas y soluciones

A continuación repasamos las causas más habituales de este error, cada una con la consulta que falla y su versión corregida. Los ejemplos usan las tablas de la base de datos de ejemplo del tutorial: productos, clientes, pedidos y detalle_pedidos.

Errata en el nombre de la columna

Es la causa más común y la más fácil de pasar por alto, sobre todo en consultas largas. Una letra cambiada, un plural de más o una tilde bastan para que MySQL no encuentre la columna. En la tabla clientes la columna se llama apellidos, en plural, y escribirla en singular provoca el error:

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

ERROR 1054 (42S22): Unknown column 'apellido' in 'field list'

La solución es corregir el nombre. Conviene copiarlo directamente de la definición de la tabla en lugar de escribirlo de memoria:

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

La columna no existe en esa tabla

A veces el nombre está bien escrito, pero la columna pertenece a otra tabla. Es muy habitual confundir columnas de tablas relacionadas, como pedir el total directamente a detalle_pedidos cuando esa columna está en pedidos:

SELECT pedido_id, total
FROM detalle_pedidos;

ERROR 1054 (42S22): Unknown column 'total' in 'field list'

En detalle_pedidos no hay columna total: cada línea tiene cantidad y precio_unitario. Si necesitamos el total del pedido, podemos leerlo de la tabla pedidos con un INNER JOIN o calcularlo a partir de las líneas:

SELECT pedido_id, SUM(cantidad * precio_unitario) AS total
FROM detalle_pedidos
GROUP BY pedido_id;

Cuando no estés seguro de qué columnas tiene una tabla, compruébalo antes de seguir. La forma más rápida es DESCRIBE, que equivale a SHOW COLUMNS:

DESCRIBE detalle_pedidos;

+-----------------+---------------+------+-----+---------+----------------+
| Field           | Type          | Null | Key | Default | Extra          |
+-----------------+---------------+------+-----+---------+----------------+
| id              | int           | NO   | PRI | NULL    | auto_increment |
| pedido_id       | int           | NO   | MUL | NULL    |                |
| producto_id     | int           | NO   | MUL | NULL    |                |
| cantidad        | int           | NO   |     | NULL    |                |
| precio_unitario | decimal(10,2) | NO   |     | NULL    |                |
+-----------------+---------------+------+-----+---------+----------------+

Si no recuerdas en qué tabla está una columna, puedes buscarla en information_schema.COLUMNS. Esta consulta devuelve todas las tablas de la base de datos actual que tienen una columna llamada total:

SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE()
  AND COLUMN_NAME = 'total';

Si la columna realmente no existe en ninguna tabla y la necesitas, tendrás que crearla con ALTER TABLE ADD COLUMN.

Comillas incorrectas alrededor de un valor de texto

En MySQL, los valores de texto van entre comillas simples y los nombres de columnas o tablas pueden ir entre acentos graves (backticks). Si por error envolvemos un valor de texto en backticks, MySQL lo interpreta como un nombre de columna:

SELECT id, total
FROM pedidos
WHERE estado = `enviado`;

ERROR 1054 (42S22): Unknown column 'enviado' in 'where clause'

El mensaje dice que no encuentra la columna enviado, lo que resulta desconcertante hasta que te fijas en las comillas. La corrección es usar comillas simples:

SELECT id, total
FROM pedidos
WHERE estado = 'enviado';

Con las comillas dobles ocurre algo parecido, pero depende de la configuración del servidor. Por defecto, MySQL acepta comillas dobles para cadenas de texto, así que WHERE estado = "enviado" funciona. Sin embargo, si el modo SQL incluye ANSI_QUOTES (algo habitual en servidores configurados para ser compatibles con el estándar), las comillas dobles pasan a delimitar identificadores y la consulta produce exactamente el mismo error 1054. Por eso es buena costumbre usar siempre comillas simples para los valores de texto: funcionan con cualquier configuración.

Alias de columna usado en el WHERE

Este caso confunde a mucha gente porque la consulta parece lógica. Definimos un alias en el SELECT e intentamos filtrar por él en el WHERE:

SELECT nombre, precio * 1.21 AS precio_con_iva
FROM productos
WHERE precio_con_iva > 100;

ERROR 1054 (42S22): Unknown column 'precio_con_iva' in 'where clause'

El motivo es el orden en que MySQL procesa la consulta: primero evalúa el FROM y el WHERE para decidir qué filas intervienen, y solo después calcula las expresiones del SELECT y les asigna sus alias. Cuando se evalúa el WHERE, el alias todavía no existe. La solución más sencilla es repetir la expresión en la condición:

SELECT nombre, precio * 1.21 AS precio_con_iva
FROM productos
WHERE precio * 1.21 > 100;

Si la expresión es larga y no quieres repetirla, puedes envolver la consulta en una subconsulta en el FROM, donde el alias ya se ha convertido en una columna más:

SELECT nombre, precio_con_iva
FROM (
    SELECT nombre, precio * 1.21 AS precio_con_iva
    FROM productos
) AS p
WHERE precio_con_iva > 100;

MySQL también permite usar alias del SELECT en el HAVING y en el ORDER BY, porque esas cláusulas se evalúan después. En consultas con agregación es la opción natural: HAVING total_vendido > 1000 funciona aunque total_vendido sea un alias.

Alias de tabla incorrecto en un JOIN

Cuando una consulta combina varias tablas con alias, es fácil anteponer a una columna el alias de la tabla equivocada. En este ejemplo, ciudad pertenece a clientes (alias c), pero la hemos pedido a pedidos (alias p):

SELECT p.id, p.fecha_pedido, p.ciudad
FROM pedidos p
INNER JOIN clientes c ON c.id = p.cliente_id;

ERROR 1054 (42S22): Unknown column 'p.ciudad' in 'field list'

El mensaje incluye el prefijo p., lo que indica que el nombre de la columna puede ser correcto y lo que falla es la tabla a la que se lo pedimos. Basta con cambiar el alias:

SELECT p.id, p.fecha_pedido, c.ciudad
FROM pedidos p
INNER JOIN clientes c ON c.id = p.cliente_id;

Un detalle a tener en cuenta: si una tabla tiene alias, hay que usar el alias y no el nombre original. Escribir pedidos.fecha_pedido después de haber declarado FROM pedidos p también produce el error 1054.

Alias usado en el ON antes de declararse

En los JOIN encadenados, la condición ON de cada unión solo puede referirse a las tablas que ya se han declarado hasta ese punto. Si adelantamos una referencia a una tabla que se une más tarde, MySQL no la reconoce:

SELECT c.nombre, d.cantidad
FROM pedidos p
INNER JOIN detalle_pedidos d ON d.pedido_id = p.id AND c.ciudad = 'Sevilla'
INNER JOIN clientes c ON c.id = p.cliente_id;

ERROR 1054 (42S22): Unknown column 'c.ciudad' in 'on clause'

Cuando se evalúa el primer ON, la tabla clientes todavía no forma parte de la consulta. La solución es mover la condición al ON de la unión correspondiente o, si es un filtro, llevarla al WHERE:

SELECT c.nombre, d.cantidad
FROM pedidos p
INNER JOIN detalle_pedidos d ON d.pedido_id = p.id
INNER JOIN clientes c ON c.id = p.cliente_id
WHERE c.ciudad = 'Sevilla';

Columnas NEW y OLD en triggers

Dentro de un trigger, las columnas de la fila afectada se leen con los prefijos NEW y OLD. Si el nombre de la columna no existe en la tabla del trigger, MySQL rechaza la creación del trigger con una variante específica del error:

CREATE TRIGGER antes_insertar_producto
BEFORE INSERT ON productos
FOR EACH ROW
SET NEW.precio_venta = ROUND(NEW.precio, 2);

ERROR 1054 (42S22): Unknown column 'precio_venta' in 'NEW'

La tabla productos no tiene una columna precio_venta. Hay que usar el nombre real (NEW.precio) o añadir antes la columna a la tabla. Ten en cuenta también que OLD no existe en los triggers INSERT y NEW no existe en los triggers DELETE. Puedes ver más ejemplos en el artículo sobre BEFORE INSERT.

La columna existe en local pero no en producción

Este es un clásico en aplicaciones web: la consulta funciona perfectamente en tu máquina y falla en el servidor. Casi siempre significa que las bases de datos de los dos entornos no tienen la misma estructura, normalmente porque una migración que añade la columna se ejecutó en local pero no en producción, o porque alguien modificó la tabla a mano en uno de los entornos.

Para confirmarlo, ejecuta DESCRIBE sobre la tabla en ambos entornos y compara el resultado. Si la columna falta en producción, la solución correcta es ejecutar la migración pendiente con la herramienta del proyecto (por ejemplo, php artisan migrate en Laravel) y no añadir la columna a mano, para que el historial de migraciones siga siendo coherente. Comprueba también que la aplicación se conecta a la base de datos que crees: un fichero de configuración que apunta a otro esquema produce exactamente el mismo síntoma.

Mayúsculas, minúsculas y caracteres invisibles

Los nombres de columna no distinguen entre mayúsculas y minúsculas en MySQL, en ningún sistema operativo. SELECT Precio FROM productos funciona igual que SELECT precio FROM productos, así que un cambio de mayúsculas nunca es la causa del error 1054 por sí solo. Lo que sí puede distinguirlas son los nombres de tabla y los alias de tabla en Linux, según la variable lower_case_table_names. Si declaras FROM productos p y luego escribes P.precio, en un servidor Linux obtendrás Unknown column 'P.precio' in 'field list'.

Otra causa difícil de detectar son los caracteres invisibles. Al copiar un nombre de columna desde un documento, un correo o una página web, puede colarse un espacio de no separación o un espacio al final. Si el nombre va entre backticks, ese carácter forma parte del identificador y MySQL busca una columna que no existe:

SELECT `precio ` FROM productos;

ERROR 1054 (42S22): Unknown column 'precio ' in 'field list'

Fíjate en el espacio antes de la comilla de cierre en el mensaje. Si el nombre parece correcto pero el error persiste, vuelve a escribirlo a mano en lugar de copiarlo.

Cómo diagnosticar el error paso a paso

Ante un error 1054, lo más eficaz es seguir siempre el mismo orden. Primero, lee el mensaje completo: el nombre entre las primeras comillas te dice qué columna falla, con su prefijo de tabla si lo lleva, y la cláusula entre las segundas comillas te dice dónde buscarla. En una consulta larga, eso reduce mucho el trabajo.

Después, comprueba si la columna existe en la tabla que crees con DESCRIBE o con information_schema.COLUMNS. Si existe, el problema está en cómo la referencias: el alias de tabla, las comillas, el orden de los JOIN o un alias de columna usado en el WHERE. Si no existe, puede que esté en otra tabla, que tenga otro nombre o que falte una migración en ese entorno.

Si aun así no das con la causa, simplifica la consulta. Quita columnas y condiciones hasta que funcione y vuelve a añadirlas una a una. La última que añadas antes de que reaparezca el error es la culpable. Es un método poco elegante, pero no falla.

Cómo evitar el error

La mejor prevención es no escribir nombres de columna de memoria. Los editores de SQL como MySQL Workbench, DBeaver o las extensiones para VS Code autocompletan los nombres a partir del esquema real, lo que elimina casi todas las erratas. En el código de una aplicación, los ORM y los query builders también ayudan, porque centralizan los nombres de columna en los modelos.

Acostúmbrate también a usar comillas simples para los valores de texto y a reservar los backticks para los identificadores, solo cuando los necesites (por ejemplo, si una columna coincide con una palabra reservada). En consultas con varias tablas, usa alias cortos y coherentes y califica todas las columnas con su alias: así cualquier referencia a la tabla equivocada salta a la vista.

Por último, mantén sincronizada la estructura de todos los entornos mediante migraciones versionadas en lugar de cambios manuales. Es la única forma fiable de evitar el clásico "en mi máquina funciona". Si el error que ves no es 1054 sino un fallo de sintaxis, consulta el artículo sobre el ERROR 1064.

Resumen

El ERROR 1054 (42S22): Unknown column significa que MySQL no encuentra una columna que la consulta menciona. El mensaje indica qué columna es y en qué cláusula aparece (field list, where clause, on clause, order clause, having clause o NEW en un trigger). Las causas más habituales son las erratas, las columnas que pertenecen a otra tabla, los valores de texto escritos entre backticks o entre comillas dobles con ANSI_QUOTES, los alias de columna usados en el WHERE, los alias de tabla equivocados o adelantados en un JOIN y las migraciones que no se han ejecutado en todos los entornos. Para resolverlo, lee con atención el mensaje, comprueba la estructura real de la tabla con DESCRIBE y corrige la referencia.