Table of Contents
This chapter discusses the rules for writing the following elements of SQL statements when using MySQL:
-
Literal values such as strings and numbers
-
Identifiers such as database, table, and column names
-
User-defined and system variables
-
Comments
-
Reserved words
This section describes how to write literal values in MySQL. These
include strings, numbers, hexadecimal values, boolean values, and
NULL
. The section also covers the various
nuances and “gotchas” that you may run into when
dealing with these basic types in MySQL.
A string is a sequence of bytes or characters, enclosed within
either single quote (‘'
’) or
double quote (‘"
’) characters.
Examples:
'a string' "another string"
If the ANSI_QUOTES
SQL mode is enabled,
string literals can be quoted only within single quotes because
a string quoted within double quotes is interpreted as an
identifier.
A binary string is a string of bytes that has no character set or collation. A non-binary string is a string of characters that has a character set and collation. For both types of strings, comparisons are based on the numeric values of the string unit. For binary strings, the unit is the byte. For non-binary strings the unit is the character and some character sets allow multi-byte characters. Character value ordering is a function of the string collation.
String literals may have an optional character set introducer
and COLLATE
clause:
[_charset_name
]'string
' [COLLATEcollation_name
]
Examples:
SELECT _latin1'string
'; SELECT _latin1'string
' COLLATE latin1_danish_ci;
For more information about these forms of string syntax, see Section 10.3.5, “Character String Literal Character Set and Collation”.
Within a string, certain sequences have special meaning. Each of
these sequences begins with a backslash
(‘\
’), known as the
escape character. MySQL recognizes the
following escape sequences:
For all other escape sequences, backslash is ignored. That is,
the escaped character is interpreted as if it was not escaped.
For example, ‘\x
’ is just
‘x
’.
These sequences are case sensitive. For example,
‘\b
’ is interpreted as a
backspace, but ‘\B
’ is
interpreted as ‘B
’.
The ASCII 26 character can be encoded as
‘\Z
’ to enable you to work around
the problem that ASCII 26 stands for END-OF-FILE on Windows.
ASCII 26 within a file causes problems if you try to use
mysql
db_name
<
file_name
.
The ‘\%
’ and
‘\_
’ sequences are used to search
for literal instances of ‘%
’ and
‘_
’ in pattern-matching contexts
where they would otherwise be interpreted as wildcard
characters. See the description of the LIKE
operator in Section 12.3.1, “String Comparison Functions”. If
you use ‘\%
’ or
‘\_
’ in non-pattern-matching
contexts, they evaluate to the strings
‘\%
’ and
‘\_
’, not to
‘%
’ and
‘_
’.
There are several ways to include quote characters within a string:
-
A ‘
'
’ inside a string quoted with ‘'
’ may be written as ‘''
’. -
A ‘
"
’ inside a string quoted with ‘"
’ may be written as ‘""
’. -
Precede the quote character by an escape character (‘
\
’). -
A ‘
'
’ inside a string quoted with ‘"
’ needs no special treatment and need not be doubled or escaped. In the same way, ‘"
’ inside a string quoted with ‘'
’ needs no special treatment.
The following SELECT
statements demonstrate
how quoting and escaping work:
mysql>SELECT 'hello', '"hello"', '""hello""', 'hel''lo', '\'hello';
+-------+---------+-----------+--------+--------+ | hello | "hello" | ""hello"" | hel'lo | 'hello | +-------+---------+-----------+--------+--------+ mysql>SELECT "hello", "'hello'", "''hello''", "hel""lo", "\"hello";
+-------+---------+-----------+--------+--------+ | hello | 'hello' | ''hello'' | hel"lo | "hello | +-------+---------+-----------+--------+--------+ mysql>SELECT 'This\nIs\nFour\nLines';
+--------------------+ | This Is Four Lines | +--------------------+ mysql>SELECT 'disappearing\ backslash';
+------------------------+ | disappearing backslash | +------------------------+
If you want to insert binary data into a string column (such as
a BLOB
column), the following characters must
be represented by escape sequences:
NUL
|
NUL byte (ASCII 0). Represent this character by
‘\0 ’ (a backslash
followed by an ASCII ‘0 ’
character). |
\
|
Backslash (ASCII 92). Represent this character by
‘\\ ’. |
'
|
Single quote (ASCII 39). Represent this character by
‘\' ’. |
"
|
Double quote (ASCII 34). Represent this character by
‘\" ’. |
When writing application programs, any string that might contain any of these special characters must be properly escaped before the string is used as a data value in an SQL statement that is sent to the MySQL server. You can do this in two ways:
-
Process the string with a function that escapes the special characters. In a C program, you can use the
mysql_real_escape_string()
C API function to escape characters. See Section 22.2.3.52, “mysql_real_escape_string()
”. The Perl DBI interface provides aquote
method to convert special characters to the proper escape sequences. See Section 22.4, “MySQL Perl API”. Other language interfaces may provide a similar capability. -
As an alternative to explicitly escaping special characters, many MySQL APIs provide a placeholder capability that enables you to insert special markers into a statement string, and then bind data values to them when you issue the statement. In this case, the API takes care of escaping special characters in the values for you.
Integers are represented as a sequence of digits. Floats use
‘.
’ as a decimal separator.
Either type of number may be preceded by
‘-
’ or
‘+
’ to indicate a negative or
positive value, respectively
Examples of valid integers:
1221 0 -32
Examples of valid floating-point numbers:
294.42 -32032.6809e+10 148.00
An integer may be used in a floating-point context; it is interpreted as the equivalent floating-point number.
MySQL supports hexadecimal values. In numeric contexts, these act like integers (64-bit precision). In string contexts, these act like binary strings, where each pair of hex digits is converted to a character:
mysql>SELECT x'4D7953514C';
-> 'MySQL' mysql>SELECT 0xa+0;
-> 10 mysql>SELECT 0x5061756c;
-> 'Paul'
The default type of a hexadecimal value is a string. If you want
to ensure that the value is treated as a number, you can use
CAST(... AS UNSIGNED)
:
mysql> SELECT 0x41, CAST(0x41 AS UNSIGNED);
-> 'A', 65
The x'
hexstring
'
syntax is based on standard SQL. The 0x
syntax is based on ODBC. Hexadecimal strings are often used by
ODBC to supply values for BLOB
columns.
You can convert a string or a number to a string in hexadecimal
format with the HEX()
function:
mysql>SELECT HEX('cat');
-> '636174' mysql>SELECT 0x636174;
-> 'cat'
The constants TRUE
and
FALSE
evaluate to 1
and
0
, respectively. The constant names can be
written in any lettercase.
mysql> SELECT TRUE, true, FALSE, false;
-> 1, 1, 0, 0
Beginning with MySQL 5.0.3, bit-field values can be written
using b'
value
'
notation. value
is a binary value
written using zeros and ones.
Bit-field notation is convenient for specifying values to be
assigned to BIT
columns:
mysql>CREATE TABLE t (b BIT(8));
mysql>INSERT INTO t SET b = b'11111111';
mysql>INSERT INTO t SET b = b'1010';
+------+----------+----------+----------+ | b+0 | BIN(b+0) | OCT(b+0) | HEX(b+0) | +------+----------+----------+----------+ | 255 | 11111111 | 377 | FF | | 10 | 1010 | 12 | A | +------+----------+----------+----------+
The NULL
value means “no data.”
NULL
can be written in any lettercase.
Be aware that the NULL
value is different
from values such as 0
for numeric types or
the empty string for string types. See
Section A.5.3, “Problems with NULL
Values”.
For text file import or export operations performed with
LOAD DATA INFILE
or SELECT ... INTO
OUTFILE
, NULL
is represented by the
\N
sequence. See Section 13.2.5, “LOAD DATA INFILE
Syntax”.