ERROR 1064: Error de sintaxis

El ERROR 1064 es el error más frecuente de MySQL. Aparece cuando el servidor recibe una sentencia que no puede interpretar porque no respeta la gramática de SQL: una coma de más, una comilla sin cerrar, una palabra reservada usada como nombre de columna o una instrucción copiada de otro sistema de bases de datos. MySQL no llega a ejecutar nada, porque falla en la fase de análisis, antes incluso de comprobar si las tablas o las columnas existen.

La buena noticia es que casi siempre se resuelve en segundos si sabes leer el mensaje. El texto del error indica con bastante precisión dónde se ha perdido el analizador, y la mayoría de las causas se repiten una y otra vez. En este artículo verás cómo interpretar el mensaje, las causas más habituales con su consulta errónea y su corrección, un método de depuración para los casos difíciles y algunas costumbres que evitan que el error vuelva a aparecer.

El mensaje del error y cómo leerlo

Este es el aspecto que tiene el mensaje en MySQL 8 cuando ejecutas una consulta mal escrita desde el cliente de línea de comandos o desde cualquier herramienta gráfica:

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'FROM productos' at line 1

El número 1064 es el código de error de MySQL y 42000 es el código SQLSTATE estándar, que agrupa los errores de sintaxis y de acceso. La parte realmente útil es la que viene después de near: el fragmento entre comillas simples es el texto de la consulta a partir del punto exacto en el que el analizador dejó de entender lo que leía. El final del mensaje, at line 1, indica la línea de la sentencia donde empieza ese fragmento, algo muy útil en consultas largas escritas en varias líneas.

La clave para interpretarlo es entender que el error casi nunca está dentro del fragmento que aparece en near, sino justo antes. MySQL lee la sentencia de izquierda a derecha y solo se da cuenta de que algo va mal cuando encuentra un elemento que no encaja con lo que esperaba. Por ejemplo, esta consulta produce el mensaje anterior:

SELECT id, nombre, precio, FROM productos;

El fragmento señalado es FROM productos, pero el problema real es la coma que hay después de precio. Tras una coma, MySQL espera otra columna o expresión, y al encontrar la palabra FROM se detiene. Por eso, cuando veas el mensaje, mira el último elemento que aparece antes del fragmento near.

Hay un caso especial que conviene reconocer: cuando el fragmento está vacío (near '' at line 1), significa que la sentencia terminó antes de lo esperado. Suele deberse a un paréntesis sin cerrar, una comilla abierta o una consulta que se cortó al construirse en el código de una aplicación.

Causas más habituales y cómo corregirlas

Las causas del ERROR 1064 son muy variadas, pero en la práctica un puñado de ellas explica la inmensa mayoría de los casos. A continuación tienes cada una con un ejemplo real sobre la base de datos tienda_mysql y su versión corregida.

Palabras reservadas usadas como nombres

MySQL reserva ciertas palabras para su propia sintaxis, como ORDER, GROUP, KEY, SELECT o DESC. Si una columna o una tabla se llama igual que una de ellas, el analizador la interpreta como parte de la instrucción y la sentencia deja de tener sentido. Es muy común al crear tablas de pedidos con una columna llamada order o tablas de clasificación con una columna rank:

CREATE TABLE ranking_productos (
    producto_id INT,
    rank INT,
    ventas INT
);

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'rank INT,
    ventas INT
)' at line 3

Este caso es especialmente traicionero porque RANK no era una palabra reservada en MySQL 5.7 y pasó a serlo en MySQL 8.0 con la llegada de las funciones de ventana. Una tabla que se creaba sin problemas en un servidor antiguo puede fallar al migrarla. Lo mismo ocurre con ROW_NUMBER, GROUPS o LEAD. La solución es rodear el nombre con comillas invertidas (backticks), que le indican a MySQL que se trata de un identificador:

CREATE TABLE ranking_productos (
    producto_id INT,
    `rank` INT,
    ventas INT
);
 
SELECT producto_id, `rank` FROM ranking_productos ORDER BY `rank`;

Funciona, pero tendrás que acordarte de las comillas invertidas en cada consulta. La mejor solución a largo plazo es renombrar la columna con un nombre que no sea reservado, como posicion o puesto_ranking.

Comillas sin cerrar o comillas tipográficas

Una cadena de texto que se abre con una comilla simple y no se cierra hace que MySQL considere todo lo que viene detrás como parte del texto. En el cliente mysql de línea de comandos esto se nota porque el prompt cambia a '> y se queda esperando a que cierres la comilla. Desde una aplicación, en cambio, recibirás directamente el error:

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

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''Madrid;' at line 1

Otra variante muy frecuente aparece al copiar consultas desde un documento de Word, un correo o una página web. Estos programas sustituyen las comillas rectas por comillas tipográficas (‘ y ’), que MySQL no reconoce como delimitadores de texto. Si el valor tiene espacios, obtendrás un 1064:

SELECT * FROM clientes WHERE nombre = ‘María García’;

Curiosamente, si el valor es una sola palabra, como ‘Madrid’, MySQL lo interpreta como un nombre de columna y el error que verás será distinto: ERROR 1054 (42S22): Unknown column '‘Madrid’' in 'where clause'. En ambos casos la solución es la misma: sustituir las comillas tipográficas por comillas simples rectas.

SELECT * FROM clientes WHERE nombre = 'María García';

Comas sobrantes o que faltan

La coma sobrante ante FROM que viste al principio tiene una variante igual de común al crear tablas: dejar una coma después de la última columna o restricción, algo que suele pasar al borrar la última línea de una definición.

CREATE TABLE proveedores (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(150) NOT NULL,
    telefono VARCHAR(20),
);

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ')' at line 5

El caso contrario, una coma que falta, se comporta de forma distinta según dónde ocurra. En un CREATE TABLE produce un 1064 que señala a la columna siguiente, porque MySQL cree que la columna anterior continúa. Sin embargo, en la lista de columnas de un SELECT no produce ningún error: SELECT nombre precio FROM productos es válido y devuelve la columna nombre con el alias precio. Es un fallo silencioso que conviene tener presente cuando una consulta devuelve menos columnas de las esperadas. Para repasar la sintaxis completa de definición de tablas, consulta el artículo sobre CREATE TABLE.

Paréntesis sin cerrar

Las condiciones agrupadas con paréntesis, las subconsultas y las llamadas a funciones anidadas son terreno abonado para olvidar un paréntesis de cierre. Cuando esto ocurre, MySQL llega al final de la sentencia esperando todavía un ) y el fragmento near aparece vacío:

SELECT nombre, precio
FROM productos
WHERE (precio > 100 AND stock > 0;

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 3

La corrección consiste en cerrar el paréntesis en el lugar correcto. En consultas largas, la forma más fiable de encontrar el desequilibrio es usar un editor que resalte las parejas de paréntesis.

SELECT nombre, precio
FROM productos
WHERE (precio > 100 AND stock > 0);

Sintaxis de otros sistemas de bases de datos

Cada motor tiene sus propias extensiones de SQL, y una consulta que funciona en SQL Server o PostgreSQL puede no ser válida en MySQL. El ejemplo clásico es TOP, que SQL Server usa para limitar el número de filas:

SELECT TOP 5 nombre, precio FROM productos ORDER BY precio DESC;

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '5 nombre, precio FROM productos ORDER BY precio DESC' at line 1

En MySQL se usa LIMIT, que además debe ir siempre al final de la consulta, después de ORDER BY. Colocarlo antes también provoca un 1064. Encontrarás todos los detalles en el artículo sobre LIMIT.

SELECT nombre, precio FROM productos ORDER BY precio DESC LIMIT 5;

Otros casos habituales son el operador ILIKE de PostgreSQL, que no existe en MySQL (basta con LIKE, que ya no distingue mayúsculas con las intercalaciones por defecto), y las comillas dobles para delimitar nombres de tablas o columnas. En SQL estándar y en PostgreSQL, "pedidos_archivo" es un identificador, pero MySQL trata las comillas dobles como texto salvo que el modo ANSI_QUOTES esté activado. Por eso CREATE TABLE "pedidos_archivo" (id INT) falla con un 1064. En MySQL, los identificadores se delimitan con comillas invertidas.

DELIMITER al crear procedimientos y triggers

Al crear un procedimiento almacenado, una función o un trigger desde el cliente de línea de comandos, el cuerpo contiene varias sentencias separadas por punto y coma. El cliente envía la sentencia al servidor en cuanto encuentra el primer ;, así que el servidor recibe un CREATE PROCEDURE incompleto:

CREATE PROCEDURE productos_sin_stock()
BEGIN
    SELECT nombre FROM productos WHERE stock = 0;
END;

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 3

La solución es cambiar temporalmente el delimitador para que el cliente no corte la sentencia a mitad. Se explica en profundidad en el artículo sobre DELIMITER.

DELIMITER //
CREATE PROCEDURE productos_sin_stock()
BEGIN
    SELECT nombre FROM productos WHERE stock = 0;
END //
DELIMITER ;

Sintaxis de una versión más nueva que tu servidor

Si sigues un tutorial escrito para MySQL 8 y tu servidor es MySQL 5.7 o una versión antigua de MariaDB, algunas construcciones no existirán. Las expresiones de tabla comunes con WITH, las funciones de ventana como ROW_NUMBER() OVER (...) o JSON_TABLE producen un 1064 en versiones que no las soportan. Antes de revisar la consulta durante horas, comprueba la versión del servidor:

SELECT VERSION();

Si el resultado es anterior a la 8.0, tendrás que reescribir la consulta con subconsultas o actualizar el servidor. El texto del mensaje, que recomienda consultar el manual correspondiente a tu versión, apunta precisamente a este tipo de problemas.

Variables vacías en consultas construidas por la aplicación

Cuando una aplicación construye la consulta concatenando texto, basta con que una variable llegue vacía para que la sentencia quede incompleta. Este código PHP es un ejemplo típico:

$sql = "SELECT nombre, precio FROM productos WHERE categoria_id = " . $categoria;

Si $categoria está vacía, MySQL recibe SELECT nombre, precio FROM productos WHERE categoria_id = y responde con un 1064 con el fragmento near ''. Además de este fallo, concatenar valores abre la puerta a la inyección SQL. La solución correcta es usar consultas preparadas, en las que los valores viajan separados del texto de la sentencia. Tienes ejemplos completos en el artículo sobre prepared statements.

Cómo depurar un ERROR 1064 paso a paso

Cuando la causa no salta a la vista, conviene seguir un método en lugar de probar cambios al azar. El primer paso es localizar el fragmento near en la consulta y examinar con atención lo que hay justo antes: una coma, una comilla, una palabra reservada o un paréntesis. Esto resuelve la mayoría de los casos.

Si la consulta la genera una aplicación, el segundo paso es imprimir o registrar la sentencia final tal y como llega a MySQL, con los valores ya sustituidos. Muchas veces el error no está en la consulta que escribiste, sino en lo que produjo el código al montarla. Copia esa sentencia y ejecútala directamente en el cliente de MySQL para ver el error aislado.

El tercer paso, para consultas largas, es simplificar. Elimina cláusulas una a una (primero ORDER BY, luego las condiciones del WHERE, luego los JOIN) hasta que la consulta funcione. La última parte que eliminaste contiene el error. También puedes comentar líneas temporalmente, como se explica en el artículo sobre comentarios, para aislar la parte problemática sin borrarla. Por último, si todo parece correcto, comprueba la versión del servidor y busca en la lista de palabras reservadas de MySQL cualquier nombre de tabla o columna que te resulte sospechoso.

Cómo evitar el ERROR 1064

La mayoría de estos errores se previenen con unas pocas costumbres. Escribir las consultas en un editor con resaltado de sintaxis para MySQL hace visibles las comillas sin cerrar y los paréntesis desequilibrados, y colorea de forma distinta las palabras reservadas, de modo que un rank o un order usados como nombre llaman la atención de inmediato.

Al diseñar tablas, elige nombres de columna descriptivos en español o con prefijos (fecha_pedido, posicion_ranking) en lugar de palabras genéricas en inglés que pueden estar reservadas ahora o en futuras versiones. Evita copiar consultas desde procesadores de texto, y si lo haces, revisa las comillas antes de ejecutarlas. En el código de tus aplicaciones, usa siempre consultas preparadas en lugar de concatenar valores: evitarás tanto los errores de sintaxis por variables vacías como los problemas de seguridad. Y cuando sigas documentación o ejemplos, asegúrate de que corresponden a la versión de MySQL que tienes instalada.

Resumen

El ERROR 1064 indica que MySQL no ha podido entender la sintaxis de una sentencia. El fragmento que aparece tras near marca el punto donde el analizador se perdió, y el error real suele estar justo antes de ese punto; si el fragmento está vacío, la sentencia terminó antes de tiempo. Las causas más comunes son las palabras reservadas usadas como nombres (con especial atención a RANK desde MySQL 8), las comillas sin cerrar o tipográficas, las comas sobrantes, los paréntesis sin cerrar, la sintaxis de otros motores como TOP o ILIKE, la falta de DELIMITER al crear procedimientos, las funciones que no existen en tu versión y las variables vacías en consultas concatenadas. Con un editor con resaltado de sintaxis, nombres de columna bien elegidos y consultas preparadas en tu código, este error pasará a ser una molestia puntual que resolverás en segundos. Si quieres repasar la estructura básica de una consulta, vuelve al artículo sobre SELECT.