MySQL SQL Syntax and Use
- MySQL Naming Rules
- Selecting, Creating, Dropping, and Altering Databases
- Creating, Dropping, Indexing, and Altering Tables
- Getting Information about Databases and Tables
- Retrieving Records from Multiple Tables
- Multiple-Table Deletes and Updates
- Performing Transactions
- Foreign Keys and Referential Integrity
- Using FULLTEXT Searches
- Writing Comments
- Features That MySQL Does Not Support
Get down and dirty with mySQL by learning the basics of SQL syntax and useful functions for maintaining tables and integrity.
This excerpt is from the 2nd Edition of "MySQL".
Fluency with SQL is necessary for effective communication with the MySQL server, because that is the language that it understands. For example, when you use a program such as the mysql client, it functions primarily as a means for you to send SQL statements to the server to be executed. You must also know SQL if you write programs that use the MySQL interface provided by your programming language because the interface functions as the means that allows you to communicate with the server by sending SQL statements to it.
Chapter 1, "Getting Started with MySQL and SQL," presented a tutorial introduction to many of MySQL's capabilities. This chapter builds on that material to go into more detail on several areas of SQL implemented by MySQL. It discusses how to refer to elements of databases, including the rules for naming and the case sensitivity constraints that apply. It also describes many of the more important SQL statements that are used for the following types of operations:
Creating and destroying databases, tables, and indexes
Obtaining information about your databases and tables
Retrieving data using joins, subselects, and unions
Using multiple-table deletes and updates
Performing transactions that allow multiple statements to be treated as a unit
Setting up foreign key relationships
Using the FULLTEXT search engine
MySQL's SQL statements can be grouped into several broad categories; Table 3.1 lists some representative statements for each. In some cases, a utility program is available that provides a command-line interface to a statement. For example, mysqlshow allows SHOW operations to be performed from the command line. This chapter points out such equivalences where appropriate.
Some of the statements in the table are not covered here because they are more appropriately discussed in other chapters. For example, the administrative statements GRANT and REVOKE for setting up user privileges are dealt with in Chapter 11, "General MySQL Administration." Chapter 12, "Security," provides further details on what privileges are available and what they allow. The syntax for all SQL statements implemented by MySQL is listed in Appendix D, "SQL Syntax Reference." In addition, you should consult the MySQL Reference Manual for additional information, especially for changes made in recent versions of MySQL.
Table 3.1 Types of SQL Statements Supported by MySQL
Selecting, Creating, Dropping, and Altering Databases
Creating, Altering, and Dropping Tables and Indexes
Getting Information About Databases and Tables
Retrieving Information from Tables
Modifying Information in Tables
The final section of the chapter describes what MySQL does not includethat is, what features it lacks. These are capabilities found in some other databases but not in MySQL. Such features include triggers, stored procedures, and views. Do these omissions mean that MySQL isn't a "real" database system? Some people think so, but in response I'll simply observe that the lack of these capabilities in MySQL hasn't stopped large numbers of people from using it. That's probably because for many or most applications, those features don't matter.
I should also point out that the set of features missing from MySQL continues to shrink over time. For the first edition of this book, the list of missing features included transactions, subselects, foreign keys, and referential integrity. A significant amount of progress has been made in improving MySQL since then, and those capabilities all have been added now. Triggers, stored procedures, and views are scheduled for implementation in the future.
MySQL Naming Rules
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.
Referring to Elements of Databases
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 in SQL Statements
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
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 ...).