Comillas simples en SQL INSERT: por qué hay que escaparlas

Contenido
Al pasar un archivo CSV a sentencias SQL INSERT, a veces aparece de repente un error de sintaxis. Cuando buscas la causa, casi siempre resulta que un solo valor contiene un apóstrofo (comilla simple). Por ejemplo, si el nombre de un producto es "Women's Shoes" y lleva un apóstrofo, en el momento en que pones ese valor tal cual en la sentencia SQL, el resto de la sentencia se rompe.
Este fenómeno no se produce porque los datos estén mal. Es una consecuencia inevitable de cómo SQL representa las cadenas de texto. Si entiendes el principio, queda claro por qué hace falta escapar los valores y por qué conviene hacerlo automáticamente durante la conversión en lugar de corregir los valores uno a uno a mano.
Resumen ① SQL envuelve los valores de texto entre un par de comillas simples para indicar "de aquí hasta aquí hay texto". ② Si dentro del valor aparece una comilla simple tal cual, el analizador de SQL entiende erróneamente que la cadena termina en ese punto. ③ Por eso, las comillas simples dentro de un valor deben escribirse duplicadas para que se distingan como "un carácter real y no como el símbolo que cierra la cadena".
Por qué SQL envuelve las cadenas entre comillas simples
En una sentencia SQL, los valores de texto siempre van entre un par de comillas simples. Por ejemplo, si quieres poner "monitor" en una columna de nombres, debes añadir comillas simples delante y detrás, así: 'monitor', para que la base de datos sepa que no es un número ni un comando, sino texto literal.
Esas comillas simples no son un adorno: son el delimitador que marca el inicio y el fin de la cadena. Cuando el analizador encuentra la comilla simple de apertura, entiende que "empieza el tramo de texto", y en el momento en que encuentra la siguiente comilla simple, determina que "aquí termina el texto". Esta regla se aplica igual sea cual sea el dialecto de SQL que uses.
Qué pasa si un valor contiene una comilla simple
El problema surge cuando el propio valor incluye una comilla simple. Supón que el nombre del producto es "Women's Shoes" y trasladas ese valor tal cual: se genera la sentencia VALUES ('Women's Shoes').
Para el analizador, esa sentencia se lee de otra manera. La cadena empieza en la primera comilla simple y, en el instante en que encuentra la segunda comilla simple, la que va justo detrás de Women, decide que "la cadena termina aquí". Entonces el resto, s Shoes', queda como un montón de caracteres sueltos fuera de la cadena, y en la posición donde el analizador esperaba otra cosa (una coma o un paréntesis de cierre) aparece un carácter inesperado, lo que desemboca en un error de sintaxis.
Por qué hay que escribir la comilla dos veces
La forma de resolver este problema es escribir dos veces seguidas la comilla simple que está dentro del valor. Es decir, en lugar de 'Women's Shoes' hay que escribir 'Women''s Shoes'. Cuando aparecen dos seguidas, el analizador lo interpreta no como "la señal de que la cadena termina", sino como "un carácter de comilla simple que realmente forma parte de la cadena".
Este método no es un truco de un programa concreto, sino la regla de escape establecida en el estándar SQL. Por eso, antes de poner un valor en una sentencia SQL, siempre hay que comprobar "cuántas comillas simples hay en este valor y si cada una se ha duplicado", para que la sintaxis no se rompa. Si un solo archivo CSV tiene cientos de filas y solo algunas contienen apóstrofos, repetir esta comprobación a mano valor por valor es algo que pasa desapercibido y que se escapa con facilidad.
Pega tu CSV y obtén al instante las sentencias CREATE TABLE e INSERT, con las comillas simples de los valores ya escapadas de forma automática.

Cómo la herramienta toma esta decisión por ti en cada valor
Esta herramienta que convierte CSV en SQL reemplaza automáticamente cada comilla simple dentro de un valor por dos comillas simples antes de incluirlo en la sentencia SQL. No importa cuántos apóstrofos haya en una línea del CSV ni en qué fila o columna estén: se aplica del mismo modo durante la conversión, así que en el momento en que pegas el CSV de entrada, la sentencia INSERT resultante ya muestra los valores escapados. Aquí es donde dejas de tener que abrir valor por valor y buscar comillas a ojo para corregirlas.
No todas las columnas van entre comillas
Eso sí, este tratamiento se aplica solo a las columnas que se consideran de texto. Al revisar el valor de cada columna del CSV, si todos son de forma numérica los trata como enteros o decimales, y si son de forma true/false o yes/no, como booleanos; las columnas que se determinan así como valores no textuales no se envuelven en comillas simples desde el principio y entran en la sentencia SQL tal cual. Como el problema de las comillas simples solo se da en los "literales de cadena", en las columnas numéricas o booleanas no hay nada que escapar. A la inversa, solo las columnas cuyos valores contienen letras y se determinan como texto se envuelven en comillas, y dentro de ellas solo las comillas simples son objeto de escape.
En resumen
- SQL envuelve los valores de texto entre un par de comillas simples para marcar el inicio y el fin del texto.
- Si dentro de un valor aparece una comilla simple tal cual, el analizador la confunde con el final de la cadena y el resto de la sentencia provoca un error de sintaxis.
- La solución es escribir dos veces seguidas la comilla simple que está dentro del valor, que es el método de escape establecido por el estándar SQL.
- Este problema solo se da en los valores tratados como texto; las columnas determinadas como numéricas o booleanas no se envuelven en comillas desde el principio, así que no les afecta.
- Cuantas más filas tenga el CSV, más seguro es escapar automáticamente durante la conversión que buscar y corregir a mano los valores con apóstrofos, sin riesgo de olvidos.
Pega tu CSV y obtén al instante las sentencias CREATE TABLE e INSERT, con las comillas simples de los valores ya escapadas de forma automática.
Preguntas frecuentes
Si envuelvo las cadenas con comillas dobles en lugar de simples, ¿desaparece el problema?
Depende del dialecto. Algunas bases de datos permiten usar comillas dobles para las cadenas, pero en dialectos como PostgreSQL o SQL Server las comillas dobles no sirven para las cadenas, sino para envolver identificadores como nombres de tablas o columnas. Por eso, cambiar a comillas dobles no es una solución de fondo y puede incluso generar otros errores de sintaxis. Escapar partiendo de la premisa de que los literales de cadena van con comillas simples es lo que mejor funciona entre dialectos.
¿Puedo escapar con barra invertida (') en lugar de escribir la comilla dos veces?
Algunas bases de datos también reconocen el escape con barra invertida, pero no es un método incluido en el estándar SQL, sino más bien una extensión propia de ciertos dialectos. Según la configuración o el dialecto, la barra invertida puede tratarse como un carácter literal y el valor acabar guardándose de forma extraña. Repetir dos veces la comilla simple es el método de escape estándar que funciona de forma común en varios dialectos.
Si no escapo, ¿siempre aparece un error visible?
No necesariamente. Cuando la cadena termina antes de lo previsto por culpa de una comilla simple, los caracteres que quedan detrás no encajan con la estructura de la sentencia y lo normal es que se produzca un error de sintaxis. Pero si esos caracteres restantes encajan por casualidad con la siguiente parte de la sentencia, en teoría podría ejecutarse sin error y guardarse un valor distinto del que querías. El resultado concreto depende de la estructura del resto de la sentencia y de la base de datos, así que es difícil generalizar; lo más seguro es escapar desde el principio y eliminar esa incertidumbre.
¿También hay que preocuparse por el escape en los valores de columnas numéricas o booleanas?
No hace falta. Envolver un valor entre comillas simples es una forma de notación que solo se aplica a los valores de cadena (texto), y los valores numéricos o booleanos entran en la sentencia SQL sin comillas desde el principio. Como el valor no va entre comillas, tampoco ocurre el problema de que una comilla corte la cadena. Esta herramienta también, cuando determina que una columna es numérica o booleana, escribe el valor sin comillas tal cual, y solo envuelve en comillas y aplica el escape a las columnas determinadas como texto.
Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano