Cuándo usar comillas simples, comillas dobles y últimos ticks en MySQL

Estoy tratando de aprender la mejor manera de escribir consultas. También entiendo la importancia de ser consistente. Hasta ahora, he utilizado al azar comillas simples, comillas dobles y marcas de retroceso sin pensarlo.

Ejemplo:

$query = 'INSERT INTO table (id, col1, col2) VALUES (NULL, val1, val2)'; 

Además, en el ejemplo anterior, considere que "table," "col[n]," and "val[n]" pueden ser variables.

¿Cuál es el estándar para esto? ¿Qué haces?

He estado leyendo respuestas a preguntas similares aquí durante unos 20 minutos, pero parece que no hay una respuesta definitiva a esta pregunta.

Los Backticks se deben usar para identificadores de tabla y columna, pero solo son necesarios cuando el identificador es una palabra reservada de MySQL o cuando el identificador contiene caracteres en blanco o caracteres más allá de un conjunto limitado. A menudo se recomienda evitar usar palabras clave reservadas como identificadores de columna o tabla cuando sea posible, evitando el problema de las citas.

Las comillas simples se deben usar para valores de cadena como en la lista VALUES() . Las comillas dobles son compatibles con MySQL para los valores de cadena también, pero las comillas simples son más ampliamente aceptadas por otros RDBMS, por lo que es una buena costumbre usar comillas simples en lugar de dobles.

MySQL también espera que los valores literales DATE y DATETIME sean citados como cadenas como '2001-01-01 00:00:00' . Consulte la documentación Literales de fecha y hora para obtener más detalles, en particular, alternativas al uso del guión - como un delimitador de segmento en cadenas de fechas.

Entonces, usando su ejemplo, citaría dos veces la cadena PHP y usaría comillas simples en los valores 'val1', 'val2' . NULL es una palabra clave MySQL, y un valor especial (no), y por lo tanto no está citado.

Ninguno de estos identificadores de tabla o columna son palabras reservadas o hacen uso de caracteres que requieren comillas, pero los he citado de todos modos con barras (más sobre esto más adelante …).

Las funciones nativas del RDBMS (por ejemplo, NOW() en MySQL) no se deben citar, aunque sus argumentos están sujetos a las mismas reglas de comillas de cadena o identificador ya mencionadas.

  Backtick (`)
 mesa y columna ───────┬─────┬──┬──┬──┬────┬──┬────┬──┬────┬──┬ ───────┐
                       ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
 $ query = " INSERT INTO` table` (`id`,` col1`, `col2`,` date`, `updated`)  
                         VALUES (NULL, 'val1', 'val2', '2001-01-01', NOW ()) ";
                                ↑↑↑↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ 
 Palabra clave sin cita ─────┴┴┴┘ │ │ │ │ │ │││││ │││││
 Cuerdas de una sola cita (') ───────────┴────┴──┴────┘ │ │ │││││
 Cita única (') FECHA ───────────────────────────┴──────────┘ ││││ │
 Función sin cita ─────────────────────────────────────────┴┴┴┴┘    

Interpolación variable

Los patrones de cotización para las variables no cambian, aunque si tiene la intención de interpolar las variables directamente en una cadena, debe tener una comilla doble en PHP. Solo asegúrese de haber escapado correctamente de las variables para usar en SQL. ( En su lugar, se recomienda utilizar una API que admita las declaraciones preparadas, como protección contra la inyección de SQL ).

  // Lo mismo con algunos reemplazos variables
 // Aquí, un nombre de tabla variable $ table es back-tick-quotated, y las variables
 // en la lista de VALORES son cita simple 
 $ query = "INSERT INTO` $ table` (`id`,` col1`, `col2`,` date`) VALUES (NULL, '$ val1' , '$ val2' , '$ date' ) ";

Declaraciones preparadas

Cuando trabaje con declaraciones preparadas, consulte la documentación para determinar si se deben citar o no los marcadores de posición de la statement. Las API más populares disponibles en PHP, PDO y MySQLi esperan marcadores de posición sin comillas , al igual que la mayoría de las API de statement preparadas en otros idiomas:

 // PDO example with named parameters, unquoted $query = "INSERT INTO `table` (`id`, `col1`, `col2`, `date`) VALUES (:id, :col1, :col2, :date)"; // MySQLi example with ? parameters, unquoted $query = "INSERT INTO `table` (`id`, `col1`, `col2`, `date`) VALUES (?, ?, ?, ?)"; 

Caracteres que requieren cotizaciones de retroceso en los identificadores:

De acuerdo con la documentación de MySQL , no necesita citar (retroceder) identificadores utilizando el siguiente juego de caracteres:

ASCII: [0-9,az,AZ$_] (letras latinas básicas, dígitos 0-9, dólar, guión bajo)

Puede usar caracteres más allá de ese conjunto como identificadores de tabla o columna, incluidos espacios en blanco, por ejemplo, pero luego debe citarlos (respaldarlos).

Hay dos tipos de citas en MySQL:

  1. ' para adjuntar literales de cadena
  2. ` para adjuntar identificadores como nombres de tabla y columna

Y luego está el " que es un caso especial. Podría usarse para uno de los propósitos mencionados anteriormente a la vez, dependiendo del modo sql_mode del servidor MySQL:

  1. Por defecto, el " carácter se puede usar para encerrar literales de cadena como '
  2. En el modo ANSI_QUOTES , el " carácter se puede usar para encerrar los identificadores ANSI_QUOTES

La siguiente consulta producirá resultados diferentes (o errores) según el modo SQL:

 SELECT "column" FROM table WHERE foo = "bar" 

ANSI_QUOTES desactivado

La consulta seleccionará la cadena literal "column" donde la columna foo es igual a la cadena "bar"

ANSI_QUOTES habilitado

La consulta seleccionará la columna column donde la columna foo es igual a la columna bar

Cuándo usar qué

  • Sugiero que evite usar " para que su código se vuelva independiente de los modos SQL
  • Siempre cite los identificadores, ya que es una buena práctica (bastantes preguntas sobre cómo discutir esto)

(Hay buenas respuestas arriba con respecto a la naturaleza de SQL de su pregunta, pero esto también puede ser relevante si es nuevo en PHP).

Quizás es importante mencionar que PHP maneja las cadenas entre comillas simples y dobles de forma diferente …

Las cadenas de una sola cita son ‘literales’ y son prácticamente cadenas WYSIWYG. Las cadenas dobles son interpretadas por PHP para una posible sustitución de variables (los backticks en PHP no son exactamente cadenas, ejecutan un comando en el shell y devuelven el resultado).

Ejemplos:

 $foo = "bar"; echo 'there is a $foo'; // There is a $foo echo "there is a $foo"; // There is a bar echo `ls -l`; // ... a directory list 

Las barras invertidas se usan generalmente para indicar un identifier y también para evitar el uso accidental de las Palabras clave reservadas .

Por ejemplo:

 Use `database`; 

Aquí los backticks ayudarán al servidor a comprender que la database es, de hecho, el nombre de la base de datos, no el identificador de la base de datos.

Lo mismo se puede hacer para los nombres de tabla y campo. Este es un muy buen hábito si envuelve su identificador de base de datos con palos de retroceso.

Verifique esta respuesta para comprender más sobre los palos de retroceso.


Ahora acerca de las comillas dobles y las comillas simples (Michael ya lo mencionó).

Pero, para definir un valor, debe usar comillas simples o dobles. Veamos otro ejemplo.

 INSERT INTO `tablename` (`id, `title`) VALUES ( NULL, title1); 

Aquí, deliberadamente, he olvidado ajustar el title1 con comillas. Ahora el servidor tomará el title1 como un nombre de columna (es decir, un identificador). Entonces, para indicar que es un valor, debe usar comillas dobles o simples.

 INSERT INTO `tablename` (`id, `title`) VALUES ( NULL, 'title1'); 

Ahora, en combinación con PHP, las comillas dobles y las comillas simples hacen que el tiempo de escritura de su consulta sea mucho más fácil. Veamos una versión modificada de la consulta en tu pregunta.

 $query = "INSERT INTO `table` (`id`, `col1`, `col2`) VALUES (NULL, '$val1', '$val2')"; 

Ahora, usando comillas dobles en el PHP, hará que las variables $val1 , y $val2 usen sus valores, creando así una consulta perfectamente válida. Me gusta

 $val1 = "my value 1"; $val2 = "my value 2"; $query = "INSERT INTO `table` (`id`, `col1`, `col2`) VALUES (NULL, '$val1', '$val2')"; 

hará

 INSERT INTO `table` (`id`, `col1`, `col2`) VALUES (NULL, 'my value 1', 'my value 2') 

Básicamente en Mysql, existen estos tipos de identificador que se utilizan en la consulta ` , " , ' y () .

  1. " o ' uso para adjuntar la cadena como valores "26-01-2014 00:00:00" o '26-01-2014 00:00:00' . Estos identificadores se usan solo para la función de cadena no agregada como now() or sum ,max etc.

  2. ` uso para adjuntar tabla o columna de tabla, por ejemplo, seleccione column_name from table_name donde id = ‘2’

  3. () se usan solo para adjuntar partes de la consulta, por ejemplo, seleccionar column_name de table_name donde (id = ‘2’ y gender = ‘male’) o name = ‘rakesh’.

Los literales de cadena en MySQL y PHP son los mismos.

Una cadena es una secuencia de bytes o caracteres, dentro de caracteres de comillas simples (“‘”) o comillas dobles (“” “).

Entonces, si su cadena contiene comillas simples, entonces podría usar comillas dobles para citar la cadena, o si contiene comillas dobles, entonces podría usar comillas simples para citar la cadena. Pero si su cadena contiene tanto comillas simples como comillas dobles, debe escapar la que solía citar la cadena.

Sobre todo, utilizamos comillas simples para un valor de cadena SQL, por lo que debemos usar comillas dobles para una cadena de PHP.

 $query = "INSERT INTO table (id, col1, col2) VALUES (NULL, 'val1', 'val2')"; 

Y podría usar una variable en la cadena de doble cita de PHP:

 $query = "INSERT INTO table (id, col1, col2) VALUES (NULL, '$val1', '$val2')"; 

Pero si $val1 o $val2 contienen comillas simples, eso hará que su SQL sea incorrecto. Por lo tanto, debe escapar antes de usarlo en sql; para eso sirve mysql_real_escape_string . (Aunque una statement preparada es mejor).

En combinación de PHP y MySQL, las comillas dobles y las comillas simples hacen que el tiempo para escribir consultas sea mucho más fácil.

 $query = "INSERT INTO `table` (`id`, `col1`, `col2`) VALUES (NULL, '$val1', '$val2')"; 

Ahora, supongamos que está utilizando una variable de publicación directa en la consulta de MySQL, utilícela de esta manera:

 $query = "INSERT INTO `table` (`id`, `name`, `email`) VALUES (' ".$_POST['id']." ', ' ".$_POST['name']." ', ' ".$_POST['email']." ')"; 

Esta es la mejor práctica para usar variables de PHP en MySQL.

Si las tablas cols y los valores son variables, existen dos formas:

Con comillas dobles "" la consulta completa:

 $query = "INSERT INTO $table_name (id, $col1, $col2) VALUES (NULL, '$val1', '$val2')"; 

O

  $query = "INSERT INTO ".$table_name." (id, ".$col1.", ".$col2.") VALUES (NULL, '".$val1."', '".$val2."')"; 

Con comillas simples '' :

 $query = 'INSERT INTO '.$table_name.' (id, '.$col1.', '.$col2.') VALUES (NULL, '.$val1.', '.$val2.')'; 

Use las marcas de retroceso `` cuando el nombre de una columna / valor sea similar a una palabra reservada de MySQL.

Nota: Si está indicando un nombre de columna con un nombre de tabla, use ticks de regreso como este:

`table_name` . `column_name` <- Nota: exclude . desde atrás tics.

Aquí ha habido muchas respuestas útiles, que generalmente culminan en dos puntos.

  1. BACKTICKS( ) `se usan alrededor de los nombres de los identificadores.
  2. QUOTES(') se usan alrededor de los valores.

Y como dijo @MichaelBerkowski

Los Backticks se deben usar para identificadores de tabla y columna, pero solo son necesarios cuando el identificador es una palabra reservada de MySQL o cuando el identificador contiene caracteres en blanco o caracteres más allá de un conjunto limitado. A menudo se recomienda evitar usar palabras clave reservadas como identificadores de columna o tabla cuando sea posible, evitando el problema de las citas.

Sin embargo, hay un caso en el que un identificador no puede ser una palabra clave reservada o contener espacios en blanco o caracteres más allá de un conjunto limitado, pero necesariamente requiere un backticks a su alrededor.

EJEMPLO

123E10 es un nombre de identificador válido, pero también un literal INTEGER válido.

[Sin entrar en detalles sobre cómo se obtendría dicho nombre de identificador], supongamos que quiero crear una tabla temporal llamada 123456e6 .

No hay ERROR en los palos de atrás.

 DB [XXX]> create temporary table `123456e6` (`id` char (8)); Query OK, 0 rows affected (0.03 sec) 

ERROR cuando no se utilizan palos de retroceso.

 DB [XXX]> create temporary table 123451e6 (`id` char (8)); ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near '123451e6 (`id` char (8))' at line 1 

Sin embargo, 123451a6 es un nombre de identificador perfectamente fino (sin 123451a6 retroceso).

 DB [XXX]> create temporary table 123451a6 (`id` char (8)); Query OK, 0 rows affected (0.03 sec) 

Esto es completamente porque 1234156e6 también es un número exponencial.

Las comillas simples se deben usar para valores de cadena como en la lista VALORES ().

Los backticks generalmente se usan para indicar un identificador y también para evitar el uso accidental de las palabras clave reservadas.

En combinación de PHP y MySQL, las comillas dobles y las comillas simples hacen que el tiempo de escritura de su consulta sea mucho más fácil.

Además de todas las respuestas (bien explicadas), no se ha mencionado lo siguiente y visito estas Preguntas y respuestas con bastante frecuencia.

En una palabra; MySQL cree que quiere hacer cálculos matemáticos en su propia tabla / columna e interpreta guiones como “correo electrónico” como e menos mail .


Descargo de responsabilidad: así que pensé que agregaría esto como un tipo de respuesta “FYI” para aquellos que son completamente nuevos en el trabajo con bases de datos y que pueden no entender los términos técnicos descritos anteriormente.

Los servidores SQL y MySQL, PostgreySQL, Oracle no entienden las comillas dobles (“). Por lo tanto, su consulta debe estar libre de comillas dobles (“) y solo debe usar comillas simples (‘).

Back-trip (`) es opcional para usar en SQL y se usa para nombre de tabla, nombre db y nombres de columna.

Si está intentando escribir una consulta en su back-end para llamar a MySQL, puede usar comillas dobles (“) o comillas simples (‘) para asignar consultas a una variable como:

 let query = "select id, name from accounts"; //Or let query = 'select id, name from accounts'; 

Si hay una instrucción where en su consulta y / o trata de insert un valor y / o una update de valor que es una cadena, use comillas simples (‘) para estos valores, como:

 let querySelect = "select id, name from accounts where name = 'John'"; let queryUpdate = "update accounts set name = 'John' where id = 8"; let queryInsert = "insert into accounts(name) values('John')"; //Please not that double quotes are only to be used in assigning string to our variable not in the query //All these below will generate error let querySelect = 'select id, name from accounts where name = "John"'; let queryUpdate = 'update accounts set name = "John" where id = 8'; let queryInsert = 'insert into accounts(name) values("John")'; //As MySQL or any SQL doesn't understand double quotes("), these all will generate error. 

Si desea permanecer fuera de esta confusión cuando utilice comillas dobles (“) y comillas simples (‘), le recomendamos que se quede con las comillas simples (‘) esto incluirá una barra diagonal inversa () como:

 let query = 'select is, name from accounts where name = \'John\''; 

El problema con las comillas dobles (“) o simples (‘) surge cuando tuvimos que asignar algún valor dynamic y realizar alguna concatenación de cadenas como:

 let query = "select id, name from accounts where name = " + fName + " " + lName; //This will generate error as it must be like name = 'John Smith' for SQL //However our statement made it like name = John Smith //In order to resolve such errors use let query = "select id, name from accounts where name = '" + fName + " " + lName + "'"; //Or using backslash(\) let query = 'select id, name from accounts where name = \'' + fName + ' ' + lName + '\''; 

Si necesita una autorización adicional, siga las citas en JavaScript