This chapter is from the book

This chapter is from the book

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

USE

CREATE DATABASE

DROP DATABASE

ALTER DATABASE

Creating, Altering, and Dropping Tables and Indexes

CREATE TABLE

DROP TABLE

CREATE INDEX

DROP INDEX

ALTER TABLE

Getting Information About Databases and Tables

DESCRIBE

SHOW

Retrieving Information from Tables

SELECT

UNION

Performing Transactions

BEGIN

COMMIT

ROLLBACK

SET AUTOCOMMIT

Modifying Information in Tables

DELETE

INSERT

LOAD DATA

REPLACE

UPDATE

Administrative Statements

FLUSH

GRANT

REVOKE

The final section of the chapter describes what MySQL does not
includethat 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:

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