guardar - Cuándo usar comillas simples, comillas dobles y marcas anteriores en MySQL

comillas dobles sql (12)

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 piensa que desea hacer matemáticas en su propia tabla / columna e interpreta guiones como "correo electrónico" como e mail negativo .

Descargo de responsabilidad: 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 tal vez no entiendan los términos técnicos ya descritos.

Estoy tratando de aprender la mejor manera de escribir consultas. También entiendo la importancia de ser consistente. Hasta ahora, he usado al azar comillas simples, comillas dobles y marcas anteriores sin ningún pensamiento real.

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.}

Básicamente, en Mysql, existen estos tipos de identificadores que se utilizan en las consultas ` , " , '' y () .

" o '' use para encerrar los valores de tipo cadena "26-01-2014 00:00:00" o ''26-01-2014 00:00:00'' . Este identificador se usa solo para la función de cadena no agregada como now() or sum ,max etc.
` uso para adjuntar una tabla o columna de tabla, por ejemplo, seleccione column_name from table_name donde id = ''2''
() se usan solo para encerrar partes de la consulta, por ejemplo, seleccione column_name from table_name where (id = ''2'' and gender = ''male'') o name = ''rakesh''.

En combinación con PHP y MySQL, las comillas dobles y las comillas simples hacen que su tiempo de escritura de 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.

Ha habido muchas respuestas útiles aquí, que generalmente culminan en dos puntos.

Los BACKTICKS (`) se usan alrededor de nombres de identificadores.
Las CITAS ÚNICAS ('') 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 clave reservada de MySQL , o cuando el identificador contiene caracteres de espacio en blanco o caracteres más allá de un conjunto limitado (ver a continuación) A menudo se recomienda evitar el uso de palabras clave reservadas como identificadores de columna o tabla cuando sea posible, evitando el problema de comillas.

Sin embargo, existe un caso en el que un identificador no puede ser una palabra clave reservada ni contener espacios en blanco o caracteres más allá del conjunto limitado, sino que necesariamente requiere backticks alrededor de ellos.

EJEMPLO

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

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

No hay ERROR en backticks.

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

ERROR al no utilizar backticks.

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.

Hay dos tipos de citas en MySQL:

'' para encerrar literales de cuerda
` para encerrar identificadores tales como nombres de tablas y columnas

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

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

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

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

ANSI_QUOTES deshabilitado

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

ANSI_QUOTES habilitados

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

Cuando usar que

Le sugiero que evite usar " para que su código se vuelva independiente de los modos SQL
Cita siempre los identificadores, ya que es una buena práctica (bastantes preguntas sobre SO discutir esto)

Las comillas inversas se utilizan generalmente para indicar un identifier y también están a salvo de usar accidentalmente las palabras clave reservadas .

Por ejemplo:

Use `database`;

En este caso, 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 tablas y campos. Este es un hábito muy bueno si envuelve su identificador de base de datos con backticks.

Marque this respuesta para entender más sobre backticks.

Ahora sobre Double quotes & Single Quotes (Michael ya lo ha mencionado).

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

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

Aquí me he olvidado deliberadamente de envolver el title1 con citas. 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 la consulta sea mucho más fácil. Veamos una versión modificada de la consulta en su 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 utilicen 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'')

Los backticks se deben usar para identificadores de tabla y columna, pero solo son necesarios cuando el identificador es una palabra clave reservada de MySQL , o cuando el identificador contiene caracteres de espacio en blanco o caracteres más allá de un conjunto limitado (ver a continuación) A menudo se recomienda evitar el uso de palabras clave reservadas como identificadores de columna o tabla cuando sea posible, evitando el problema de comillas.

Se deben usar comillas simples para los valores de cadena como en la lista VALUES() . MySQL también admite las comillas dobles para los valores de cadena, pero otras RDBMS aceptan las comillas simples, por lo que es un buen hábito usar comillas simples en lugar de dobles.

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

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

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

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

Backtick (`) table & column ───────┬─────┬──┬──┬──┬────┬──┬────┬──┬────┬──┬───────┐ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ $query = "INSERT INTO `table` (`id`, `col1`, `col2`, `date`, `updated`) VALUES (NULL, ''val1'', ''val2'', ''2001-01-01'', NOW())"; ↑↑↑↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑↑↑↑↑ Unquoted keyword ─────┴┴┴┘ │ │ │ │ │ │ │││││ Single-quoted ('') strings ───────────┴────┴──┴────┘ │ │ │││││ Single-quoted ('') DATE ───────────────────────────┴──────────┘ │││││ Unquoted function ─────────────────────────────────────────┴┴┴┴┘

Interpolacion variable

Los patrones de cotización de las variables no cambian, aunque si pretende interpolar las variables directamente en una cadena, se debe hacer doble cita en PHP. Solo asegúrese de haber escapado correctamente de las variables para su uso en SQL. ( Se recomienda utilizar una API que admita declaraciones preparadas, como protección contra la inyección de SQL ).

// Same thing with some variable replacements // Here, a variable table name $table is backtick-quoted, and variables // in the VALUES list are single-quoted $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 los marcadores de posición de la declaración. Las API más populares disponibles en PHP, PDO y MySQLi, esperan marcadores de posición no citados, al igual que las API de declaraciones más 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 comillas inversas en identificadores:

De acuerdo con la documentación de MySQL , no es necesario citar los identificadores (comillas) utilizando el siguiente conjunto 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 los espacios en blanco, por ejemplo, pero luego debe citarlos.

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

Una cadena es una secuencia de bytes o caracteres, encerrada entre 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, podría usar comillas simples para citar la cadena. Pero si su cadena contiene tanto comillas simples como comillas dobles, necesita escapar de la que solía citar la cadena.

Principalmente, usamos comillas simples para un valor de cadena de SQL, por lo que necesitamos usar comillas dobles para una cadena de PHP.

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

Y podrías usar una variable en la cadena de doble comillas 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 esté equivocado. Así que necesitas escapar de él antes de que sea usado en sql; para eso es mysql_real_escape_string . (Aunque una declaración preparada es mejor.)

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 nombres de tablas, nombres de db y columnas.

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

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

Si hay una declaración de where en su consulta y / o intentar 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 use comillas dobles (") y comillas simples (''), recomendaría seguir con comillas simples ('') esto incluirá la barra invertida () 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 dinámico y realizar una 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 más autorización, siga las citas en JavaScript

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

Las comillas inversas se utilizan generalmente para indicar un identificador y también para evitar el uso accidental de las palabras clave reservadas.

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

Si las columnas y los valores de la tabla son variables, hay dos formas:

Con comillas dobles "" la consulta completa:

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

$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 anteriores `` cuando un nombre de columna / valor es similar a una palabra clave reservada de MySQL.

Nota: Si está denotando un nombre de columna con un nombre de tabla, use marcas atrás como esta:

`table_name` . `column_name` <- Nota: excluir . De las garrapatas de la espalda.

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

Quizás es importante mencionar que PHP maneja cadenas entre comillas simples y dobles de manera diferente ...

Las cadenas de comillas simples son ''literales'' y son prácticamente cadenas WYSIWYG. PHP interpreta las cadenas entre comillas dobles para una posible sustitución de variables (las marcas inversas 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