Almost every SQL statement refers in some way to a database or its constituent elements. This section describes the syntax rules for referring to databases, tables, columns, indexes, and aliases. Names are subject to case sensitivity considerations, which are described as well.
When you use names to refer to elements of databases, you are constrained by the characters you can use and the length that names can be. The form of names also depends on the context in which you use them. Another factor that affects naming rules is that the server can be started in different naming modes.
Legal characters in names. Unquoted names can consist of any alphanumeric characters in the server's default character set, plus the characters '_' and '$'. Names can start with any character that is legal in a name, including a digit. However, a name cannot consist entirely of digits because that would make it indistinguishable from a number. MySQL's support for names that begin with a number is somewhat unusual among database systems. If you use such a name, be particularly careful of names containing an 'E' or 'e' because those characters can lead to ambiguous expressions. For example, the expression 23e + 14 (with spaces surrounding the '+' sign) means column 23e plus the number 14, but what about 23e+14? Does it mean the same thing, or is it a number in scientific notation?
Aliases can be fairly arbitrary, but you should quote an alias within single or double quotes if it is a SQL keyword, is entirely numeric, or contains spaces or other special characters.
As of MySQL 3.23.6, names can be quoted within backtick characters ('`'), which allows use of any character except backtick, ASCII 0, and ASCII 255. This is useful when a name contains special characters or is a reserved word. Quoting a name also allows it to be entirely numeric, something that is not true of unquoted names.
There are also two additional constraints for database and table names, even if you quote them. First, you cannot use the '.' character because it is the separator in db_name.tbl_name and db_name.tbl_name.col_name notation. Second, you cannot use the UNIX or Windows pathname separator characters ('/' or '\'). The separator characters are disallowed in database and table names because databases are represented on disk by directories, and tables are represented on disk by at least one file. Consequently, these types of names must not contain characters that are illegal in directory names and filenames. The UNIX pathname separator is disallowed on Windows (and vice versa) to make it easier to transfer databases and tables between servers running on different platforms. For example, suppose you were allowed to use a slash in a table name on Windows. That would make it impossible to move the table to UNIX, because filenames on that platform cannot contain slashes.
Name length. Names for databases, tables, columns, and indexes can be up to 64 characters long. Alias names can be up to 256 characters long.
Name qualifiers. Depending on context, a name may need to be qualified to make it clear what the name refers to. To refer to a database, just specify its name:
USE db_name; SHOW TABLES FROM db_name;
To refer to a table, you have two choices. First, a fully qualified table name consists of a database name and a table name:
SHOW TABLES FROM db_name.tbl_name; SELECT * FROM db_name.tbl_name;
Second, a table name by itself refers to a table in the default (current) database. If sampdb is the default database, the following statements are equivalent:
SELECT * FROM member; SELECT * FROM sampdb.member;
If no database has been selected, naming a table without a database qualifier is illegal because the server cannot tell which database the table belongs to.
To refer to a column, there are three choices: fully qualified, partially qualified, and unqualified. A fully qualified name (written as db_name.tbl_name.col_name) is completely specified. A partially qualified name (written as tbl_name.col_name) refers to a column in the named table. An unqualified name (written simply as col_name) refers to whatever table is indicated by the surrounding context. The following two queries refer to the same pair of column names, but the context supplied by the FROM clause of each statement indicates from which table to select the columns:
SELECT last_name, first_name FROM president; SELECT last_name, first_name FROM members;
It's usually unnecessary to supply fully qualified names, although it's always legal to do so if you want. If you select a database with a USE statement, that database becomes the default database and is implicit in every unqualified table reference. If you're using a SELECT statement that refers to only one table, that table is implicit for every column reference in the statement. It's necessary to qualify names only when a table or database cannot be determined from context. For example, if a query refers to tables from multiple databases, any table not in the default database must be referenced using the db_name.tbl_name form to let MySQL know which database to look in to find the table. Similarly, if a query uses multiple tables and refers to a column name that is present in more than one table, it's necessary to qualify the name with a table name to make it clear which column you mean.
Server startup mode. If the server has been started with the --ansi or --sql-mode=ANSI_QUOTES option, names can be quoted with double quotes rather than backticks (although backticks can still be used).
Case sensitivity rules in SQL statements vary for different parts of the statement and also depend on what you referring to and the operating system of the machine on which the server is running:
SQL keywords and function names. Keywords and function names are not case sensitive. They can be given in any lettercase. The following statements are equivalent:
SELECT NOW(); select now(); sElEcT nOw();
Database and table names. Databases and tables in MySQL are implemented using directories and files in the underlying file system on the server host. As a result, case sensitivity of database and table names depends on the way the operating system on that host treats filenames. Windows filenames are not case sensitive, so a server running on Windows does not treat database and table names as case sensitive. Servers running on UNIX usually treat database and table names as case sensitive because UNIX filenames are case sensitive. (An exception is that names in HFS+ file systems under Mac OS X are not case sensitive.)
You should consider lettercase issues if you create a database on a server with case-sensitive filenames and you might someday move the database to a server where filenames are not case sensitive. For example, if you create two tables named abc and ABC on a UNIX server where those names are treated differently, you would have problems moving the tables to a Windows machine; there, abc and ABC would not be distinguishable because names are not case sensitive. One way to avoid having case sensitivity properties become an issue is to pick a given lettercase (for example, lowercase) and always create databases and tables using names in that lettercase. Then case of names won't be a problem if you move a database to a different server. Another approach to issues of name lettercase is to start the server with the lower_case_table_names variable set. This variable is discussed further in Chapter 10, "The MySQL Data Directory."
Column and index names. Column and index names are not case sensitive in MySQL. The following queries are equivalent:
SELECT name FROM student; SELECT NAME FROM student; SELECT nAmE FROM student;
Alias names. Aliases are case sensitive. You can specify an alias in any lettercase (upper, lower, or mixed), but you must refer to it elsewhere in the query using the same case.
Regardless of whether or not a database or table name is case sensitive on your system, you must refer to it using the same lettercase throughout a given query. That is not true for SQL keywords, function names, or column and index names, all of which can be referred to in varying lettercase style throughout a query. Naturally, the query will be more readable if you use a consistent lettercase rather than "ransom note" style (SelECt NamE FrOm ...).