ALTER {DATABASE | SCHEMA} [db_name]
    alter_specification [, alter_specification] ...

alter_specification:
    [DEFAULT] CHARACTER SET charset_name
  | [DEFAULT] COLLATE collation_name

ALTER DATABASE用於更改資料庫的全局特性。這些特性儲存在資料庫目錄中的db.opt檔案中。要使用ALTER DATABASE，您需要獲得資料庫ALTER權限。

CHARACTER SET子句用於更改預設的資料庫字元編碼。COLLATE子句用於更改預設的資料庫整序。在第10章：字元編碼支援中對字元編碼和整序名稱進行了討論。

資料庫名稱可以忽略，此時，語句對應於預設資料庫。也可以使用ALTER SCHEMA。

ALTER [IGNORE] TABLE tbl_name
    alter_specification [, alter_specification] ...

alter_specification:
    ADD [COLUMN] column_definition [FIRST | AFTER col_name ]
  | ADD [COLUMN] (column_definition,...)
  | ADD INDEX [index_name] [index_type] (index_col_name,...)
  | ADD [CONSTRAINT [symbol]]
        PRIMARY KEY [index_type] (index_col_name,...)
  | ADD [CONSTRAINT [symbol]]
        UNIQUE [index_name] [index_type] (index_col_name,...)
  | ADD [FULLTEXT|SPATIAL] [index_name] (index_col_name,...)
  | ADD [CONSTRAINT [symbol]]
        FOREIGN KEY [index_name] (index_col_name,...)
        [reference_definition]
  | ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
  | CHANGE [COLUMN] old_col_name column_definition
        [FIRST|AFTER col_name]
  | MODIFY [COLUMN] column_definition [FIRST | AFTER col_name]
  | DROP [COLUMN] col_name
  | DROP PRIMARY KEY
  | DROP INDEX index_name
  | DROP FOREIGN KEY fk_symbol
  | DISABLE KEYS
  | ENABLE KEYS
  | RENAME [TO] new_tbl_name
  | ORDER BY col_name
  | CONVERT TO CHARACTER SET charset_name [COLLATE collation_name]
  | [DEFAULT] CHARACTER SET charset_name [COLLATE collation_name]
  | DISCARD TABLESPACE
  | IMPORT TABLESPACE
  | table_options
  | partition_options
  | ADD PARTITION partition_definition
  | DROP PARTITION partition_names
  | COALESCE PARTITION number
  | REORGANIZE PARTITION partition_names INTO (partition_definitions)
  | ANALYZE PARTITION partition_names
  | CHECK PARTITION partition_names
  | OPTIMIZE PARTITION partition_names
  | REBUILD PARTITION partition_names
  | REPAIR PARTITION partition_names

ALTER TABLE用於更改原有資料表的結構。例如，您可以增加或刪減列，建立或取消索引，更改原有列的類型，或重新命名列或資料表。您還可以更改資料表的評注和資料表的類型。

允許進行的變更中，許多子句的語法與CREATE TABLE中的子句的語法相近。其中包括table_options修改，選項有ENGINE, AUTO_INCREMENT和AVG_ROW_LENGTH等。請見13.1.5節，「CREATE TABLE語法」。

儲存引擎不支援有些操作，如果進行這些操作，會出現警告。使用SHOW WARNINGS可以顯示出這些警告。請參見13.5.4.22節，「SHOW WARNINGS語法」。

如果您使用ALTER TABLE更改列規約，但是DESCRIBE tbl_name提示您列規約並沒有改變，則可能是因為MySQL忽略了您所做的更改。忽略更改的原因見13.1.5.1節，「沉寂的列規格變更」。例如，如果您試圖把VARCHAR列更改為CHAR列，此時，如果資料表包含其它長度可變的列，則MySQL仍會使用VARCHAR。

ALTER TABLE運行時會對原資料表進行臨時複製，在副本上進行更改，然後刪除原資料表，再對新資料表進行重命名。在執行ALTER TABLE時，其它用戶可以閱讀原資料表，但是對資料表的更新和修改的操作將被延遲，直到新資料表生成為止。新資料表生成後，這些更新和修改訊息會自動轉移到新資料表上。

注意，如果您在執行ALTER TABLE時使用除了RENAME以外的選項，則MySQL會建立一個臨時資料表。即使數據並不需要進行複製（例如當您更改列的名稱時），MySQL也會這麼操作。對於MyISAM資料表，您可以通過把myisam_sort_buffer_size系統變數設置到一個較高的值，來加快重新建立索引（該操作是變更過程中速度最慢的一部分）的速度。

·         要使用ALTER TABLE，您需要獲得資料表的ALTER, INSERT和CREATE權限。

·         IGNORE是MySQL相對於標準SQL的延伸。如果在新資料表中有重複關鍵字，或者當STRICT模式啟動後出現警告，則使用IGNORE控制ALTER TABLE的運行。如果沒有指定IGNORE，當重複關鍵字錯誤發生時，複製操作被放棄，返回前一步驟。如果指定了IGNORE，則對於有重複關鍵字的行，只使用第一行，其它有衝突的行被刪除。並且，對錯誤值進行修正，使之盡量接近正確值。

·         您可以在一個ALTER TABLE語句裡寫入多個ADD, ALTER, DROP和CHANGE子句，中間用逗號分開。這是MySQL相對於標準SQL的延伸。在標準SQL中，每個ALTER TABLE語句中每個子句只允許使用一次。例如，在一個語句中取消多個列：

·                mysql> ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;

·         CHANGE col_name, DROP col_name和DROP INDEX是MySQL相對於標準SQL的延伸。

·         MODIFY是Oracle對ALTER TABLE的延伸。

·         COLUMN只是自選項目，可以忽略。

·         如果您使用ALTER TABLE tbl_name RENAME TO new_tbl_name並且沒有其它選項，則MySQL只對與table tbl_name相對應的檔案進行重命名。不需要建立一個臨時資料表。（您也可以使用RENAME TABLE語句對資料表進行重命名。請參見13.1.9節，「RENAME TABLE語法」。）

·         column_definition子句使用與CREATE TABLE中的ADD和CHANGE子句相同的語法。注意，此語法包括列名稱，而不只是列類型。請參見13.1.5節，「CREATE TABLE語法」。

·         您可以使用CHANGE old_col_name column_definition子句對列進行重命名。重命名時，需給定舊的和新的列名稱和列當前的類型。例如：要把一個INTEGER列的名稱從a變更到b，您需要如下操作：

·                mysql> ALTER TABLE t1 CHANGE a b INTEGER;

如果您想要更改列的類型而不是名稱， CHANGE語法仍然要求舊的和新的列名稱，即使舊的和新的列名稱是一樣的。例如：

mysql> ALTER TABLE t1 CHANGE b b BIGINT NOT NULL;

您也可以使用MODIFY來改變列的類型，此時不需要重命名：

mysql> ALTER TABLE t1 MODIFY b BIGINT NOT NULL;

·         如果您使用CHANGE或MODITY縮短列長時，列中存在有索引，並且縮短後的列長小於索引長度，則MySQL會自動縮短索引的長度。

·         當您使用CHANGE或MODIFY更改列的類型時，MySQL會盡量把原有的列值轉化為新的類型。

·         您可以使用FIRST或AFTER col_name在一個資料表行中的某個特定位置新增列。預設把列新增到最後。您也可以在CHANGE或MODIFY語句中使用FIRST和AFTER。

·         AFTER COLUMN用於指定列的新預設值，或刪除舊的預設值。如果舊的預設值被刪除同時列值為NULL，則新的預設值為NULL。如果列值不能為NULL，MySQL會指定一個預設值，請參見13.1.5節，「CREATE TABLE語法」。

·         DROP INDEX用於取消索引。這是MySQL相對於標準SQL的延伸。請參見13.1.7節，「DROP INDEX語法」。

·         如果列從資料表中被取消了，則這些列也從相應的索引中被取消。如果組成一個索引的所有列均被取消，則該索引也被取消。

·         如果一個資料表只包含一列，則此列不能被取消。如果您想要取消資料表，應使用DROP TABLE。

·         DROP PRIMAY DEY用於取消主索引。註釋：在MySQL較早的版本中，如果沒有主索引，則DROP PRIMARY KEY會取消資料表中的第一個UNIQUE索引。在MySQL 5.1中不會出現這種情況。如果在MySQL 5.1中對沒有主鍵的資料表使用DROP PRIMARY KEY，則會出現錯誤訊息。

如果您向資料表中新增UNIQUE KEY或PRIMARY KEY，則UNIQUE KEY或PRIMARY KEY會被儲存在非唯一索引之前，這樣MySQL就可以盡早地檢查出重複關鍵字。

·         ORDER BY用於在建立新資料表時，讓各行按一定的順序排列。注意，在插入和刪除後，資料表不會仍保持此順序。當您知道多數情況下您會按照特定的順序查詢各行時，可以使用這個選項；在對資料表進行了大的改動後，通過使用此選項，您可以提高查詢效率。在有些情況下，如果資料表按列排序，對於MySQL來說，排序可能會更簡單。

·         如果您對一個MyISAM資料表使用ALTER TABLE，則所有非唯一索引會被建立到一個單獨的批裡（和REPAIR TABLE相同）。當您有許多索引時，這樣做可以使ALTER TABLE的速度更快。

這項功能可以明確激活。ALTER TABLE...DISABLE KEYS讓MySQL停止更新MyISAM資料表中的非唯一索引。然後使用ALTER TABLE ... ENABLE KEYS重新建立丟失的索引。進行此操作時，MySQL採用一種特殊的算法，比一個接一個地插入關鍵字要快很多。因此，在進行成批插入操作前先使關鍵字禁用可以大大地加快速度。使用ALTER TABLE ... DISABLE KEYS除了需要獲得以前提到的權限以外，還需要獲得INDEX權限。

·         Innodb儲存引擎支援FOREIGN KEY和REFERENCES子句。Innodb儲存引擎執行ADD [CONSTRAINT [symbol]] FOREIGN KEY (...) REFERENCES ... (...)。請參見15.2.6.4節，「FOREIGN KEY約束」。對於其它儲存引擎，這些子句會被分析，但是會被忽略。對於所有的儲存引擎，CHECK子句會被分析，但是會被忽略。請參見13.1.5節，「CREATE TABLE語法」。接受這些子句但又忽略子句的原因是為了提高相容性，以便更容易地從其它SQL伺服器中導入代碼，並運行應用程式，建立帶參考數據的資料表。請參見1.8.5節，「MySQL與標準SQL的差別」。

·         InnoDB支援使用ALTER TABLE來取消外部鍵：

·                ALTER TABLE yourtablename DROP FOREIGN KEY fk_symbol;

要瞭解更多訊息，請參見15.2.6.4節，「FOREIGN KEY約束」。

·         ALTER TABLE忽略DATA DIRECTORY和INDEX DIRECTORY資料表選項。

·         如果您想要把資料表預設的字元編碼和所有字元列（CHAR, VARCHAR, TEXT）改為新的字元編碼，應使用如下語句：

·                ALTER TABLE tbl_name CONVERT TO CHARACTER SET charset_name;

警告：前面的操作轉換了字元編碼之間的列類型。如果您有一列使用一種字元編碼（如latin1），但是儲存的值實際上使用了其它的字元編碼（如utf8），這種情況不是您想要的。此時，您必須對這樣的列進行以下操作。

ALTER TABLE t1 CHANGE c1 c1 BLOB;

ALTER TABLE t1 CHANGE c1 c1 TEXT CHARACTER SET utf8;

這種方法能夠實現此功能的原因是，當您轉換到BLOB列或從BLOB列轉換過來時，並沒有發生轉換。

如果您指定CONVERT TO CHARACTER SET為二進制，則TEXT列被轉換到相應的二進制字串類型（BINARY, VARBINARY, BLOB）。這意味著這些列將不再有字元編碼，接下來的CONVERT TO操作也將不適用於這些列。

要僅僅改變一個資料表的預設字元編碼，應使用此語句：

ALTER TABLE tbl_name DEFAULT CHARACTER SET charset_name;

詞語DEFAULT為自選項。如果您在向資料表中新增一個新列時（例如，使用ALTER TABLE...ADD column）沒有指定字元編碼，則此時使用的字元編碼為預設字元編碼。

警告：ALTER TABLE...DEFAULT CHARACTER SET和ALTER TABLE...CHARACTER SET是等價的，只用於更改預設的資料表字元編碼。

·         如果InnoDB資料表在建立時，使用了.ibd檔案中的自己的資料表空間，則這樣的檔案可以被刪除和導入。使用此語句刪除.ibd檔案：

·                ALTER TABLE tbl_name DISCARD TABLESPACE;

此語句用於刪除當前的.ibd檔案，所以應首先確認您有一個備份。如果在資料表空間被刪除後嘗試打開資料表格，則會出現錯誤。

要把備份的.ibd檔案還原到資料表中，需把此檔案複製到資料庫目錄中，然後書寫此語句：

ALTER TABLE tbl_name IMPORT TABLESPACE;

見15.2.6.6節，「使用按資料表的資料表空間」。

·         使用mysql_info() C API函數，您可以瞭解有多少記錄已被複製，以及（當使用IGNORE時）有多少記錄由於重複關鍵字的原因已被刪除。請參見25.2.3.34節，「mysql_info()」。

·         ALTER TABLE也可以用於對帶分區的資料表進行重新分區，功能包括新增、取消、合併和拆分各分區，還可以用於進行分區維護。

對帶分區的資料表使用partition_options子句和ALTER TABLE可以對資料表進行重新分區，使用時依據partition_options定義的分區方法。本子句以PARTITION BY為開頭，然後使用與用於CREATE TABLE的partition_options子句一樣的語法和規則（要瞭解詳細訊息，請參見13.1.5節，「CREATE TABLE語法」）。註釋：MySQL 5.1伺服器目前接受此語法，但是不實際執行；等MySQL 5.1開發出來後，將執行此語法。

用於ALTER TABLE ADD PARTITION的partition_definition子句支援用於CREATE TABLE語句的partition_definition子句的同樣名稱的選項。（要瞭解語法和介紹，請參見13.1.5節，「CREATE TABLE語法」。）例如，假設您有一個按照以下方式建立的帶分區的資料表：

CREATE TABLE t1 (

    id INT,

    year_col INT

)

PARTITION BY RANGE (year_col) (

    PARTITION p0 VALUES LESS THAN (1991),

    PARTITION p1 VALUES LESS THAN (1995),

    PARTITION p2 VALUES LESS THAN (1999)

);    

您可以在資料表中增加一個新的分區p3，該分區用於儲存小於2002的值。新增方法如下：

ALTER TABLE t1 ADD PARTITION p3 VALUES LESS THAN (2002);

註釋：您不能使用ALTER TABLE向一個沒有進行分區的資料表新增分區。

DROP PARTITION用於取消一個或多個RANGE或LIST分區。此命令不能用於HASH或KEY 分區；用於這兩個分區時，應使用COALESCE PARTITION（見後）。如果被取消的分區其名稱列於partition_names清單中，則儲存在此分區中的數據也被取消。例如，如果以前已定義的資料表t1，您可以採用如下方法取消名稱為p0和p1的分區：

ALTER TABLE DROP PARTITION p0, p1;

ADD PARTITION和DROP PARTITION目前不支援IF [NOT] EXISTS。也不可能對一個分區或一個已分區的資料表進行重命名。如果您希望對一個分區進行重命名，您必須取消分區，再重新建立；如果您希望對一個已分區的資料表進行重新命名，您必須取消所有分區，然後對資料表進行重命名，再新增被取消的分區。

COALESCE PARTITION可以用於使用HASH或KEY進行分區的資料表，以便使用number來減少分區的數目。例如，假設您使用下列方法建立了資料表t2：

CREATE TABLE t2 (

    name VARCHAR (30),

    started DATE

)

PARTITION BY HASH(YEAR(started))

PARTITIONS (6);

您可以使用以下命令，把t2使用的分區的數目由6個減少到4個：

ALTER TABLE t2 COALESCE PARTITION 2;

包含在最後一個number分區中的數據將被合併到其餘的分區中。在此情況下，分區4和分區5將被合併到前4個分區中（編號為0、1、2和3的分區）。

如果要更改部分分區，但不更改所有的分區，您可以使用REORGANIZE PARTITION。這個命令有多種使用方法：

o        把多個分區合併為一個分區。通過把多個分區的名稱列入partition_names清單，並為partition_definition提供一個單一的定義，可以實現這個功能。

o        把一個原有的分區拆分為多個分區。通過為partition_names命名一個分區，並提供多個partition_definitions，可以實現這個功能。

o        更改使用VALUES LESS THAN定義的分區子集的範圍或更改使用VALUES IN定義的分區子集的值清單。

註釋：對於沒有明確命名的分區，MySQL會自動提供預設名稱p0, p1, p2等。

要瞭解有關ALTER TALBE...REORANIZE PARTITION命令的詳細訊息，請參見18.3節，「分區管理」。

·         多個附加子句用於提供分區維護和修補功能。這些功能與用於非分區資料表的功能類似。這些功能由CHECK TABLE和REPAIR TABLE等命令（這些命令不支援用於分區資料表）執行。這些子句包括ANALYZE PARTITION, CHECK PARTITION, OPTIMIZE PARTITION, REBUILD PARTITION和REPAIR PARTITION.每個選項均為一個partition_names子句，包括一個或多個分區名稱。需要更改的資料表中必須已存在這些分區。多個分區名稱用逗號分隔。要瞭解更多訊息，或要瞭解舉例說明，請參見18.3.3節，「分區維護」。

以下例子展示了ALTER TABLE的使用。首先展示資料表t1。資料表t1採用如下方法建立：

mysql> CREATE TABLE t1 (a INTEGER,b CHAR(10));

把資料表t1重新命名為t2：

mysql> ALTER TABLE t1 RENAME t2;

把列a從INTERGER更改為TINYINT NOT NULL（名稱保持不變），並把列b從CHAR(10)更改為CHAR(20)，同時把列b重新命名為列c：

mysql> ALTER TABLE t2 MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);

新增一個新的TIMESTAMP列，名稱為d：

mysql> ALTER TABLE t2 ADD d TIMESTAMP;

在列d和列a中新增索引：

mysql> ALTER TABLE t2 ADD INDEX (d), ADD INDEX (a);

刪除列c：

mysql> ALTER TABLE t2 DROP COLUMN c;

新增一個新的AUTO_INCREMENT整數列，名稱為c：

mysql> ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT,

    ->     ADD PRIMARY KEY (c);

注意我們為c編製了索引（作為PRIMARY KEY），因為AUTO_INCREMENT列必須編製索引。同時我們定義c為NOT NULL，因為主鍵列不能為NULL。

當您新增一個AUTO_INCREMENT列時，列值被自動地按序號填入。對於MyISAM資料表，您可以在ALTER TABLE之前執行SET INSERT_ID=value來設置第一個序號，也可以使用AUTO_INCREMENT=value資料表選項來設置。請參見13.5.3節，「SET語法」。

如果值大於AUTO_INCREMENT列中的最大值，則您可以使用用於InnoDB資料表的ALTER TALBE...AUTO_INCREMENT=value資料表選項，來為新行設置序號。如果值小於列中當前的最大值，不會出現錯誤訊息，當前的序列值也不改變。

使用MyISAM資料表時，如果您不更改AUTO_INCREMENT列，則序列號不受影響。如果您取消一個AUTO_INCREMENT列，然後新增另一個AUTO_INCREMENT列，則序號重新排列，從1開始。

見A.7.1節，「與ALTER TABLE有關的問題」。

CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name

    [create_specification [, create_specification] ...]

create_specification:

    [DEFAULT] CHARACTER SET charset_name

  | [DEFAULT] COLLATE collation_name

CREATE DATABASE用於建立資料庫，並進行命名。如果要使用CREATE DATABASE，您需要獲得資料庫CREATE權限。

有關合法資料庫名稱的規定列於9.2節，「資料庫、資料表、索引、列和別名」。如果存在資料庫，並且您沒有指定IF NOT EXISTS，則會出現錯誤。

create_specification選項用於指定資料庫的特性。資料庫特性儲存在資料庫目錄中的db.opt檔案中。CHARACTER SET子句用於指定預設的資料庫字元編碼。COLLATE子句用於指定預設的資料庫整序。字元編碼和整序名稱在第10章：字元編碼支援中討論。

有些目錄包含檔案，這些檔案與資料庫中的資料表對應。MySQL中的資料庫的執行方法與這些目錄的執行方法相同。因為當資料庫剛剛被建立時，在資料庫中沒有資料表，所以CREATE DATABASE只建立一個目錄。這個目錄位於MySQL數據目錄和db.opt檔案之下。

如果您手動在數據目錄之下建立一個目錄（例如，使用mkdir），則伺服器會認為這是一個資料庫目錄，並在SHOW DATABASES的輸出中顯示出來。

也可以使用CREATE SCHEMA。

您還可以使用mysqladmin程式建立資料庫。請參見8.5節，「mysqladmin：用於管理MySQL伺服器的客戶端」。

CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name

    [USING index_type]

    ON tbl_name (index_col_name,...)

index_col_name:

    col_name [(length)] [ASC | DESC]

CREATE INDEX被映射到一個ALTER TABLE語句上，用於建立索引。請參見13.1.2節，「ALTER TABLE語法」。

通常，當使用CREATE TABLE建立資料表時，也同時在資料表中建立了所有的索引。請參見13.1.5節，「CREATE TABLE語法」。CREATE INDEX允許您向已有的資料表中新增索引。

格式為（col1, col2,...）的一個列清單建立出一個多列索引。通過串接給定列中的值，確定索引值的格式。

對於CHAR和VARCHAR列，只用一列的一部分就可建立索引。建立索引時，使用col_name(length)語法，對前綴編製索引。前綴包括每列值的前length個字元。BLOB和TEXT列也可以編製索引，但是必須給出前綴長度。

此處展示的語句用於建立一個索引，索引使用列名稱的前10個字元。

CREATE INDEX part_of_name ON customer (name(10));

因為多數名稱的前10個字元通常不同，所以此索引不會比使用列的全名建立的索引速度慢很多。另外，使用列的一部分建立索引可以使索引檔案大大減小，從而節省了大量的磁盤空間，有可能提高INSERT操作的速度。

前綴最長為255字節。對於MyISAM和InnoDB資料表，前綴最長為1000字節。注意前綴的限長以字節計，而CREATE INDEX語句中的前綴長度指的是字元的數目。對於使用多字節字元編碼的列，在指定列的前綴長度時，要考慮這一點。

在MySQL 5.1中：

·         只有當您正在使用MyISAM, InnoDB或BDB資料表類型時，您可以向有NULL值的列中新增索引。

·         只有當您正在使用MyISAM, BDB或InnoDB資料表類型時，您可以向BLOB或TEXT列中新增索引。

一個index_col_name規約可以以ASC或DESC為結尾。這些關鍵詞將來可以延伸，用於指定遞增或遞減索引值儲存。目前，這些關鍵詞被分析，但是被忽略；索引值均以遞增順序儲存。

部分儲存引擎允許在建立索引時指定索引類型。index_type指定語句的語法是USING type_name。不同的儲存引擎所支援的type_name值已顯示在下資料表中。如果列有多個索引類型，當沒有指定index_type時，第一個類型是預設值。

示範：

CREATE TABLE lookup (id INT) ENGINE = MEMORY;

CREATE INDEX id_index USING BTREE ON lookup (id);

TYPE type_name可以作為USING type_name的同義詞，用於指定索引類型。但是，USING是首選的格式。另外，在索引規約語法中，位於索引類型前面的索引名稱不能使用TYPE。這是因為，與USING不同，TYPE不是保留詞，因此會被認為是一個索引名稱。

如果您指定的索引類型在給定的儲存引擎中不合法，但是有其它的索引類型適合引擎使用，並且不會影響查詢功能，則引擎應使用此類型。

要瞭解更多有關MySQL如何使用索引的訊息，請參見7.4.5節，「MySQL如何使用索引」。

FULLTEXT索引只能對CHAR, VARCHAR和TEXT列編製索引，並且只能在MyISAM資料表中編製。請參見12.7節，「全文搜索功能」。

SPATIAL索引只能對空間列編製索引，並且只能在MyISAM資料表中編製。空間列類型在第19章：MySQL中的空間延伸中進行了描述。

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name

    [(create_definition,...)]

    [table_options] [select_statement]

或：

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name

    [(] LIKE old_tbl_name [)];

create_definition:

    column_definition

  | [CONSTRAINT [symbol]] PRIMARY KEY [index_type] (index_col_name,...)

  | KEY [index_name] [index_type] (index_col_name,...)

  | INDEX [index_name] [index_type] (index_col_name,...)

  | [CONSTRAINT [symbol]] UNIQUE [INDEX]

        [index_name] [index_type] (index_col_name,...)

  | [FULLTEXT|SPATIAL] [INDEX] [index_name] (index_col_name,...)

  | [CONSTRAINT [symbol]] FOREIGN KEY

        [index_name] (index_col_name,...) [reference_definition]

  | CHECK (expr)

column_definition:

    col_name type [NOT NULL | NULL] [DEFAULT default_value]

        [AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]

        [COMMENT 'string'] [reference_definition]

type:

    TINYINT[(length)] [UNSIGNED] [ZEROFILL]

  | SMALLINT[(length)] [UNSIGNED] [ZEROFILL]

  | MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]

  | INT[(length)] [UNSIGNED] [ZEROFILL]

  | INTEGER[(length)] [UNSIGNED] [ZEROFILL]

  | BIGINT[(length)] [UNSIGNED] [ZEROFILL]

  | REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]

  | DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]

  | FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]

  | DECIMAL(length,decimals) [UNSIGNED] [ZEROFILL]

  | NUMERIC(length,decimals) [UNSIGNED] [ZEROFILL]

  | DATE

  | TIME

  | TIMESTAMP

  | DATETIME

  | CHAR(length) [BINARY | ASCII | UNICODE]

  | VARCHAR(length) [BINARY]

  | TINYBLOB

  | BLOB

  | MEDIUMBLOB

  | LONGBLOB

  | TINYTEXT [BINARY]

  | TEXT [BINARY]

  | MEDIUMTEXT [BINARY]

  | LONGTEXT [BINARY]

  | ENUM(value1,value2,value3,...)

  | SET(value1,value2,value3,...)

  | spatial_type

index_col_name:

    col_name [(length)] [ASC | DESC]

reference_definition:

    REFERENCES tbl_name [(index_col_name,...)]

               [MATCH FULL | MATCH PARTIAL | MATCH SIMPLE]

               [ON DELETE reference_option]

               [ON UPDATE reference_option]

reference_option:

    RESTRICT | CASCADE | SET NULL | NO ACTION

table_options: table_option [table_option] ...

table_option:

    {ENGINE|TYPE} = engine_name

  | AUTO_INCREMENT = value

  | AVG_ROW_LENGTH = value

  | [DEFAULT] CHARACTER SET charset_name [COLLATE collation_name]

  | CHECKSUM = {0 | 1}

  | COMMENT = 'string'

  | CONNECTION = 'connect_string'

  | MAX_ROWS = value

  | MIN_ROWS = value

  | PACK_KEYS = {0 | 1 | DEFAULT}

  | PASSWORD = 'string'

  | DELAY_KEY_WRITE = {0 | 1}

  | ROW_FORMAT = {DEFAULT|DYNAMIC|FIXED|COMPRESSED|REDUNDANT|COMPACT}

  | UNION = (tbl_name[,tbl_name]...)

  | INSERT_METHOD = { NO | FIRST | LAST }

  | DATA DIRECTORY = 'absolute path to directory'

  | INDEX DIRECTORY = 'absolute path to directory'

partition_options:

    PARTITION BY

           [LINEAR] HASH(expr)

        |  [LINEAR] KEY(column_list)

        |  RANGE(expr)

        |  LIST(column_list)

    [PARTITIONS num]

    [  SUBPARTITION BY

           [LINEAR] HASH(expr)

         | [LINEAR] KEY(column_list)

      [SUBPARTITIONS(num)]  

    ]

    [(partition_definition), [(partition_definition)], ...]

partition_definition:

    PARTITION partition_name

        [VALUES { 

                  LESS THAN (expr) | MAXVALUE 

                | IN (value_list) }]

        [[STORAGE] ENGINE [=] engine-name]

        [COMMENT [=] 'comment_text' ]

        [DATA DIRECTORY [=] 'data_dir']

        [INDEX DIRECTORY [=] 'index_dir']

        [MAX_ROWS [=] max_number_of_rows]

        [MIN_ROWS [=] min_number_of_rows]

        [TABLESPACE [=] (tablespace_name)]

        [NODEGROUP [=] node_group_id]

        [(subpartition_definition), [(subpartition_definition)], ...]

subpartition_definition:

    SUBPARTITION logical_name

        [[STORAGE] ENGINE [=] engine-name]

        [COMMENT [=] 'comment_text' ]

        [DATA DIRECTORY [=] 'data_dir']

        [INDEX DIRECTORY [=] 'index_dir']

        [MAX_ROWS [=] max_number_of_rows]

        [MIN_ROWS [=] min_number_of_rows]

        [TABLESPACE [=] (tablespace_name)]

        [NODEGROUP [=] node_group_id]

select_statement:

    [IGNORE | REPLACE] [AS] SELECT ...   (Some legal select statement)

CREATE TABLE用於建立帶給定名稱的資料表。您必須擁有資料表CREATE權限。

允許的資料表名稱的規則列於9.2節，「資料庫、資料表、索引、列和別名」中。預設的情況是，資料表被建立到當前的資料庫中。如果資料表已存在，或者如果沒有當前資料庫，或者如果資料庫不存在，則會出現錯誤。

資料表名稱被指定為db_name.tbl_name，以便在特定的資料庫中建立資料表。不論是否有當前資料庫，都可以通過這種方式建立資料表。如果您使用加引號的識別名，則應對資料庫和資料表名稱分別加引號。例如，`mydb`.`mytbl`是合法的，但是`mydb.mytbl`不合法。

在建立資料表格時，您可以使用TEMPORARY關鍵詞。只有在當前連接情況下，TEMPORARY資料表才是可見的。當連接關閉時，TEMPORARY資料表被自動取消。這意味著兩個不同的連接可以使用相同的臨時資料表名稱，同時兩個臨時資料表不會互相衝突，也不與原有的同名的非臨時資料表衝突。（原有的資料表被隱藏，直到臨時資料表被取消時為止。）您必須擁有CREATE TEMPORARY TABLES權限，才能建立臨時資料表。

如果資料表已存在，則使用關鍵詞IF NOT EXISTS可以防止發生錯誤。注意，原有資料表的結構與CREATE TABLE語句中資料表示的資料表的結構是否相同，這一點沒有驗證。註釋：如果您在CREATE TABLE...SELECT語句中使用IF NOT EXISTS，則不論資料表是否已存在，由SELECT部分選擇的記錄都會被插入。

MySQL通過資料庫目錄中的.frm資料表格式（定義）檔案資料表示每個資料表。資料表的儲存引擎也可能會建立其它檔案。對於MyISAM資料表，儲存引擎可以建立數據和索引檔案。因此，對於每個MyISAM資料表tbl_name，有三個磁盤檔案：

用於資料表示資料表的由儲存引擎建立的檔案在第15章：儲存引擎和資料表類型中描述。

要瞭解有關各種列類型的性質的一般說明，請參見第11章：列類型。要瞭解有關空間列類型的說明，請參見第19章：MySQL中的空間延伸。

·         如果沒有指定是NULL或是NOT NULL，則列在建立時假定指定為NULL。

·         一個整數列可以擁有一個附加屬性AUTO_INCREMENT。當您向一個已編入索引的AUTO_INCREMENT列中插入一個NULL值（建議）或0時，此列被設置為下一個序列的值。通常情況下為value+1，此處value是當前在資料表中的列的最大值。AUTO_INCREMENT序列從1開始。這樣的列必須被定義為一種整數類型，請參見11.1.1節，「數值類型概述」中的敘述。（值1.0不是整數）。請參見25.2.3.36節，「mysql_insert_id()」。

為--sql-mode伺服器選項或sql_mode系統變數指定NO_AUTO_VALUE_ON_ZERO特徵位，這樣可以把0儲存到AUTO_INCREMENT列中，同時不生成一個新的序列值。請參見5.3.1節，「mysqld命令行選項」。

註釋：有時候，每個資料表只有一個AUTO_INCREMENT列，此列必須編製索引，不能有DEFAULT值。一個AUTO_INCREMENT列只有在只包含正數的情況下，才能運行正常。插入一個負數會被認為是插入了一個非常大的正數。這樣做是為了避免當數字由正數轉為負數時出現精度問題，同時也為了確保AUTO_INCREMENT列中不會包含0。

對於MyISAM和BDB資料表，您可以在一個多列關鍵字中指定一個AUTO_INCREMENT次級列。請參見3.6.9節，「使用AUTO_INCREMENT」。

為了讓MySQL與部分ODBC應用軟件相兼容，您可以使用以下查詢方法找到最後一個插入行的AUTO_INCREMENT值：

SELECT * FROM tbl_name WHERE auto_col IS NULL

·         字元列的定義可以包括一個CHARACTER SET屬性，用來指定字元編碼，也可以指定列的整序。要瞭解詳細情況，請參見第10章：字元編碼支援。CHARSET是CHARACTER SET的同義詞。

·                CREATE TABLE t (c CHAR(20) CHARACTER SET utf8 COLLATE utf8_bin);

MySQL 5.1理解，在字元列定義中的長度規約以字元為單位。（有些早期版本以字節為單位。）

·         DEFAULT子句用於為列指定一個預設值。預設值必須為一個常數，不能為一個函數或一個資料表達式，有一種情況例外。例如，一個日期列的預設值不能被設置為一個函數，如NOW()或CURRENT_DATE。不過，有一種例外，您可以對TIMESTAMP列指定CURRENT_TIMESTAMP為預設值。請參見11.3.1.1節，「MySQL 4.1中的TIMESTAMP屬性」。

BLOB和TEXT列不能被賦予預設值。

如果在列定義中沒有明確的DEFAULT值，則MySQL按照如下規則確定預設值：

如果列可以使用NULL作為值，則使用DEFAULT NULL子句對列進行定義。（在MySQL的早期版本中也如此。）

如果列不能使用NULL作為值，則MySQL對列進行定義時不使用DEFAULT子句。輸入數據時，如果INSERT或REPLACE語句不包括列的值，則MySQL依據當時的有效的SQL模式操作列：

o        如果嚴格模式沒有被啟用，則MySQL會根據列數據類型，把列設置為明確的預設值。

o        如果嚴格模式已被啟用，則事務資料表會出現錯誤，語句被回滾。對於非事務資料表，會出現錯誤，不過，如果錯誤出現在一個多行語句中的第二行或後續行，則以前的各行將被插入。

假設資料表t按下面的方法進行定義：

CREATE TABLE t (i INT NOT NULL);

在這種情況下，i沒有明確的預設值，所以在嚴格模式中，每個後續語句都會產生一個錯誤，並且沒有行被插入。當未使用嚴格模式時，只有第三個語句產生錯誤；明確的預設值被插入到前兩個語句中，但是第三個語句會出現錯誤，因為DEFAULT(i)不會產生一個值：

INSERT INTO t VALUES();

INSERT INTO t VALUES(DEFAULT);

INSERT INTO t VALUES(DEFAULT(i));

見5.3.2節，「SQL伺服器模式」。

對於一個給定的資料表，您可以使用SHOW CREATE TABLE語句來查看那些列有明確的DEFAULT子句。

·         對於列的評注可以使用COMMENT選項來進行指定。評注通過SHOW CREATE TABLE和SHOW FULL COLUMNS語句顯示。

·         屬性SERIAL可以用作BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE的別名。

·         KEY通常是INDEX同義詞。如果關鍵字屬性PRIMARY KEY在列定義中已給定，則PRIMARY KEY也可以只指定為KEY。這麼做的目的是與其它資料庫系統兼容。

·         在UNIQUE索引中，所有的值必須互不相同。如果您在新增新行時使用的關鍵字與原有行的關鍵字相同，則會出現錯誤。例外情況是，如果索引中的一個列允許包含NULL值，則此列可以包含多個NULL值。此例外情況不適用於BDB資料表。在BDB中，帶索引的列只允許一個單一NULL。

·         PRIMARY KEY是一個唯一KEY，此時，所有的關鍵字列必須定義為NOT NULL。如果這些列沒有被明確地定義為NOT NULL，MySQL應隱含地定義這些列。一個資料表只有一個PRIMARY KEY。如果您沒有PRIMARY KEY並且一個應用程式要求在資料表中使用PRIMARY KEY，則MySQL返回第一個UNIQUE索引，此索引沒有作為PRIMARY KEY的NULL列。

·         在已建立的資料表中，PRIMARY KEY的位置最靠前，然後是所有的UNIQUE索引，然後是非唯一索引。這可以幫助MySQL最佳化程式選擇優先使用哪個索引，並且更快速的檢測出重複的UNIQUE關鍵字。

·         PRIMARY KEY可以是一個多列索引。但是，在列規約中使用PRIMARY KEY關鍵字屬性無法建立多列索引。這麼做只能把一個列標記為主列。您必須使用一個單獨的PRIMARY KEY（index_col_name, ...）子句。

·         如果PRIMARY KEY或UNIQUE索引只包括一個列，並且此列為整數類型，則您也可以在SELECT語句中把此列作為_rowid引用。

·         在MySQL中，PRIMARY KEY的名稱為PRIMARY。對於其它索引，如果您沒有賦予名稱，則索引被賦予的名稱與第一個已編入索引的列的名稱相同，並自選新增後綴（_2, _3,...），使名稱為唯一名稱。您可以使用SHOW INDEX FROM tbl_name來查看資料表的索引名稱。請參見13.5.4.11節，「SHOW INDEX語法」。

·         部分儲存引擎允許您在建立索引時指定索引類型。index_type指示語句的語法是USING type_name。

示範：

CREATE TABLE lookup

  (id INT, INDEX USING BTREE (id))

  ENGINE = MEMORY;

要瞭解有關USING的詳細說明，請參見13.1.4節，「CREATE INDEX語法」。

要瞭解有關MySQL如何使用索引的更多訊息，請參見7.4.5節，「MySQL如何使用索引」。

·         在MySQL 5.1中，只有MyISAM，InnoDB, BDB和MEMORY儲存引擎支援在含有NULL值的列中編索引。在其它情況下，您必須定義已編索引的列為NOT NULL，否則會出現錯誤。

·         在一個索引規約中使用col_name(length)語法，您可以建立一個索引，此索引只使用一個CHAR或VARCHAR列的第一個length字元。只對列值的前綴編製索引可以使索引檔案大大減小。請參見7.4.3節，「列索引」。

MyISAM和InnoDB儲存引擎也支援對BLOB和TEXT列編索引。當對BLOB或TEXT列編索引時，您必須為索引指定一個前綴長度。例如：

CREATE TABLE test (blob_col BLOB, INDEX(blob_col(10)));

對於MyISAM和InnoDB資料表，前綴最長可以為1000字節，對於其它資料表格類型，最長可以為255字節。注意前綴長度限值以字節為單位，而在CREATE TABLE語句中的前綴長度用字元數目來資料表述。當為一個使用多字節字元編碼的列指定前綴長度時，一定要考慮到這一點。

·         一個index_col_name規約可以以ASC或DESC結尾。這些關鍵詞可以在將來進行延伸，用於指定升序或降序的索引值儲存。當前，這些關鍵詞被分析但是被忽略；索引值均以升序儲存。

·         當您在SELECT中的TEXT列或BLOB列中使用ORDER BY或GROUP BY時，伺服器只使用初始的字節數目對值進行分類。字節數目由max_sort_length系統變數進行指示。請參見11.4.3節，「BLOB和TEXT類型」。

·         您可以建立特殊的FULLTEXT索引，用於全文搜索。只有MyISAM資料表類型支援FULLTEXT索引。FULLTEXT索引只可以從CHAR, VARCHAR和TEXT列中建立。整個列都會被編入索引；不支援對部分列編索引。如果已指定，前綴長度會被忽略。要瞭解運行的詳細說明，請參見12.7節，「全文搜索功能」。

·         您可以為空間列類型建立SPATIAL索引。只有MyISAM資料表支援空間類型，已編索引的列必須聲明為NOT NULL。請參見第19章：MySQL中的空間延伸。

·         InnoDB資料表支援對外部鍵限制條件進行檢查。請參見15.2節，「InnoDB儲存引擎」。注意，在InnoDB中，FOREIGN KEY語法比本節開始時介紹的CREATE TABLE語句的語法更嚴格：被引用的資料表中的列必須有明確的命名。InnoDB支援外部鍵的ON DELETE和ON UPDATE兩種操作。有關精確語法的說明，請參見15.2.6.4節，「FOREIGN KEY約束」。

對於其它儲存引擎，MySQL伺服器對CREATE TABLE語句中的FOREIGN KEY和REFERENCES語法進行分析，但不採取進一步的行動。所有的儲存引擎均對CHECK子句進行分析，但是忽略CHECK子句。請參見1.8.5.5節，「外部鍵」。

·         對於MyISAM資料表，每個NULL列要多佔用一位，進位到距離最近的字節。最大記錄長度（以字節為單位）按照如下方法計算：

·                row length = 1

·                             + (sum of column lengths)

·                             + (number of NULL columns + delete_flag + 7)/8

·                             + (number of variable-length columns)

對於採用靜態記錄格式的資料表，delete_flag為1。靜態資料表在行記錄中使用一位用作位標記。位標記指示該行是否已被刪除。對於動態資料表，delete_flag為0，因為在動態行標題中已儲存了位標記。

這些計算方法不適用於InnoDB資料表。對於InnoDB資料表，NULL列的儲存量與NOT NULL列的儲存量沒有區別。

ENGINE和TYPE選項用於為資料表指定儲存引擎。ENGINE是首選的選項名稱。

ENGINE和TYPE選項採用以下值：

要瞭解有關MySQL儲存引擎的更多訊息，請參見第15章：儲存引擎和資料表類型。

如果被指定的儲存引擎無法利用，則MySQL使用MyISAM代替。例如，一個資料表定義包括ENGINE=BDB選項，但是MySQL伺服器不支援BDB資料表，則資料表被建立為MyISAM資料表。這樣，如果您在主機上有事務資料表，但在從屬機上建立的是非交互式資料表（以加快速度）時，可以進行複製設置。在MySQL 5.1中，如果沒有遵守儲存引擎規約，則會出現警告。

其它資料表選項用於最佳化資料表的性質。在多數情況下，您不必指定資料表選項。這些選項適用於所有儲存引擎，另有說明除外：

·         AUTO_INCREMENT

資料表的初始AUTO_INCREMENT值。在MySQL 5.1中，本選項只適用於MyISAM和MEMORY資料表。InnoDB也支援本選項。如果引擎不支援AUTO_INCREMENT資料表選項，則要設置引擎的第一個auto-increment值，需插入一個「假」行。該行的值比建立資料表後的值小一，然後刪除該假行。

對於在CREATE TABLE語句中支援AUTO_INCREMENT資料表選項的引擎，您也可以使用ALTER TABLE tbl_name AUTO_INCREMENT = n來重新設置AUTO_INCREMENT值。

·         AVG_ROW_LENGTH

資料表中平均行長度的近似值。只需要對含尺寸可變的記錄的大型資料表進行此項設置。

當建立一個MyISAM資料表時，MySQL使用MAX_ROWS和AVG_ROW_LENGTH選項的乘積來確定得出的資料表有多大。如果有一個選項未指定，則資料表的最大尺寸為65,536TB數據。（如果作業系統不支援這麼大的檔案，則資料表的尺寸被限定在作業系統的限值處。）如果您想縮小指針尺寸使索引更小，速度更快，並且您不需要大檔案，則您可以通過設置myisam_data_pointer_size系統變數來減少預設指針的尺寸。（見5.3.3節，「伺服器系統變數」。）如果您希望所有的資料表可以擴大，超過預設限值，並且願意讓資料表稍微慢點，並稍微大點，則您可以通過設置此變數增加預設指針的尺寸。

·         [DEFAULT] CHARACTER SET

用於為資料表指定一個預設字元編碼。CHARSET是CHARACTER SET的同義詞。

對於CHARACTER SET.

·         COLLATE

用於為資料表指定一個預設整序。

·         CHECKSUM

如果您希望MySQL隨時對所有行進行實時檢驗求和（也就是，資料表變更後，MySQL自動更新檢驗求和），則應把此項設置為1。這樣做，資料表的更新速度會略微慢些，但是更容易尋找到受損的資料表。CHECKSUM TABLE語句用於報告檢驗求和（僅限於MyISAM）。

·         COMMENT

資料表的註釋，最長60個字元。

·         CONNECTION

FEDERATED資料表的連接字串。（ 註釋：較早版本的MySQL使用COMMENT選項用於連接字串。

·         MAX_ROWS

您打算儲存在資料表中的行數目的最大值。這不是一個硬性限值，而更像一個指示語句，指示出資料表必須能儲存至少這麼多行。

·         MIN_ROWS

您打算儲存在資料表中的行數目的最小值。

·         PACK_KEYS

如果您希望索引更小，則把此選項設置為1。這樣做通常使更新速度變慢，同時閱讀速度加快。把選項設置為0可以取消所有的關鍵字壓縮。把此選項設置為DEFAULT時，儲存引擎只壓縮長的CHAR或VARCHAR列（僅限於MyISAM）。

如果您不使用PACK_KEYS，則預設操作是只壓縮字串，但不壓縮數字。如果您使用PACK_KEYS=1，則對數字也進行壓縮。

在對二進制數字關鍵字進行壓縮時，MySQL採用前綴壓縮：

o        每個關鍵字需要一個額外的字節來指示前一個關鍵字中有多少字節與下一個關鍵字相同。

o        指向行的指針以高位字節優先的順序儲存在關鍵字的後面，用於改進壓縮效果。

這意味著，如果兩個連續行中有許多相同的關鍵字，則後續的「相同」的關鍵字通常只佔用兩個字節（包括指向行的指針）。與此相比，常規情況下，後續的關鍵字佔用storage_size_for_key + pointer_size（指針尺寸通常為4）。但是，只有在許多數字相同的情況下，前綴壓縮才有好處。如果所有的關鍵字完全不同，並且關鍵字不能含有NULL值，則每個關鍵字要多使用一個字節。（在這種情況中，儲存壓縮後的關鍵字的長度的字節與用於標記關鍵字是否為NULL的字節是同一字節。）

·         PASSWORD

使用密碼對.frm檔案加密。在標準MySQL版本中，本選項不起任何作用。

·         DELAY_KEY_WRITE

如果您想要延遲對關鍵字的更新，等到資料表關閉後再更新，則把此項設置為1（僅限於MyISAM）。

·         ROW_FORMAT

定義各行應如何儲存。當前，此選項只適用於MyISAM資料表。對於靜態行或長度可變行，此選項值可以為FIXED或DYNAMIC。myisampack用於把類型設置為COMPRESSED。請參見15.1.3節，「MyISAM資料表的儲存格式」。

在預設情況下，InnoDB記錄以壓縮格式儲存（ROW_FORMAT=COMPACT）。通過指定ROW_FORMAT=REDUNDANT，仍然可以申請用於較早版本的MySQL中的非壓縮格式。

·         RAID_TYPE

在MySQL 5.0中,RAID支援被刪除了。要瞭解有關RAID的說明，請參見http://dev.mysql.com/doc/refman/4.1/en/create-table.html。

·         UNION

當您想要把一組相同的資料表當作一個資料表使用時，採用UNION。UNION僅適用於MERGE資料表。請參見15.3節，「MERGE儲存引擎」。

對於您映射到一個MERGE資料表上的資料表，您必須擁有SELECT, UPDATE和DELETE權限。（註釋：以前，所有被使用的資料表必須位於同一個資料庫中，並作為MERGE資料表。這些限制不再適用。）

·         INSERT_METHOD

如果您希望在MERGE資料表中插入數據，您必須用INSERT_METHOD指定應插入行的資料表。INSERT_METHOD選項僅用於MERGE資料表。使用FIRST或LAST把行插入到第一個或最後一個資料表中；或者使用NO，阻止插入行。請參見15.3節，「MERGE儲存引擎」。

·         DATA DIRECTORY, INDEX DIRECTORY

通過使用DATA DIRECTORY='directory'或INDEX DIRECTORY='directory'，您可以指定MyISAM儲存引擎放置資料表格數據檔案和索引檔案的位置。注意，目錄應是通向目錄的完整路徑（不是相對路徑）。

僅當您沒有使用--skip-symbolic-links選項時，DATA DIRECTORY, INDEX DIRECTORY才能使用。作業系統必須有一個正在工作的、線程安全的realpath()使用。要瞭解全面訊息，請參見7.6.1.2節，「在Unix平台上使用資料表的符號連結」。

·         對於用CREATE TABLE建立的資料表，可以使用partition_options控制分區。如果使用了partition_options，則其中必須包含至少一個PARTITION BY子句。本子句包含用於確定分區的函數；該函數會返回一個整值，範圍從1到num。此處num為分區的數目。此函數中可以使用的選項顯示在下面的清單中。 要點：在本節開始時介紹的用於partition_options的語法中顯示的選項，並不是都能用於所有分區類型。要瞭解各種類型具體的訊息 ，請參見以下各類型的清單。要瞭解有關在MySQL中的分區的操作和使用情況的全面說明，以及要瞭解資料表建立的示範和與MySQL分區有關的其它命令，請參見第18章：分區。

o        HASH（expr）：用於混編一個或多個列，建立一個關鍵字，用於放置行，並確定行的位置。expr是一個資料表達式，使用一個或多個資料表中的列。該資料表達式可以是任何能夠生成單一整值的合法的MySQL資料表達式（包括MySQL函數）。例如，這些都是有效的CREATE TABLE語句，語句中使用了PARTITION BY HASH：

o                     CREATE TABLE t1 (col1 INT, col2 CHAR(5)) 

o                         PARTITION BY HASH(col1);

o                      

o                     CREATE TABLE t1 (col1 INT, col2 CHAR(5))

o                         PARTITION BY HASH( ORD(col2) );

o                      

o                     CREATE TABLE t1 (col1 INT, col2 CHAR(5), col3 DATETIME)

o                         PARTITION BY HASH ( YEAR(col3) );

VALUES LESS THAN或VALUES IN子句不能和PARTITION BY HASH一起使用。

PARTITION BY HASH使用expr被分區數目所除後的餘數（也就是模數）。要瞭解示範和其它訊息，請參見18.2.3節，「HASH分區」。

LENEAR關鍵詞需要一種不同的算法。在這種情況下，通過一次或多次邏輯AND運算得出的結果，計算出儲存記錄的分區的數目。要瞭解線形混編的討論和示範，請參見18.2.3.1節，「LINEAR HASH分區」。

o        KEY(column_list)：與HASH近似，除了有一點不一樣，即MySQL提供了混編函數，以保證均勻的數據分佈。column_list自變數只是各列的一個清單。本示範顯示了由關鍵字進行分區的一個簡單的資料表，分為4個分區：

o                     CREATE TABLE tk (col1 INT, col2 CHAR(5), col3 DATE)

o                         PARTITION BY KEY(col3)

o                         PARTITIONS 4;

採用LINEAR關鍵詞，您可以對由關鍵字分區的資料表進行線形分區。這與由HASH進行分區的資料表格有同樣的效果；也就是說，使用&操作符搜尋分區數目，而不是使用模數（詳細說明見18.2.3.1節，「LINEAR HASH分區」和18.2.4節，「KEY分區」）。本示範採用了關鍵字線形分區，用來在5個分區之間分配數據：

CREATE TABLE tk (col1 INT, col2 CHAR(5), col3 DATE)

    PARTITION BY LINEAR KEY(col3)

    PARTITIONS 5;

VALUES LESS THAN或VALUES IN子句不能和PARTITION BY KEY一起使用。

o        RANGE：在此情況下，expr使用一套VALUES LESS THAN操作符顯示了某一範圍內的值。當使用範圍分區時，您必須使用VALUES LESS THAN定義至少一個分區。VALUES IN不能和範圍分區一起使用。

VALUES LESS THAN可以與一個文字值同時使用，或者與一個可以求算單一值的資料表達式同時使用。

舉例說明，假設您有一個資料表，您希望採用以下方法對包含年份值的一列進行分區：

採用這種分區方法的資料表可以通過如下CREATE TABLE語句實現：

CREATE TABLE t1 (

    year_col INT, 

    some_data INT 

) 

PARTITION BY RANGE (year_col) (

    PARTITION p0 VALUES LESS THAN (1991),

    PARTITION p1 VALUES LESS THAN (1995),

    PARTITION p2 VALUES LESS THAN (1999),

    PARTITION p3 VALUES LESS THAN (2002),

    PARTITION p4 VALUES LESS THAN (2006),

    PARTITION p5 VALUES LESS THAN MAXVALUE

);

PARTITION ... VALUES LESS THAN ...語句按順序執行。VALUES LESS THAN MAXVALUE的作用是指定大於最大值的「其餘」的值。

注意，VALUES LESS THAN子句按順序執行，執行方式類似於switch ... case語段的一部分（許多編程語言，如C, Java和PHP也如此）。也就是說，子句必須按照這樣一種方法排列，每一個後續的VALUES LESS THAN中指定的上限值大於前一個VALUES LESS THAN中指定的上限值，並在清單的最後加一個參照性的MAXVALUE。

VALUES IN與一系列的值同時使用。舉例說明，您可以建立如下的分區方法：

CREATE TABLE client_firms (

    id INT,

    name VARCHAR(35)

)

PARTITION BY RANGE (id) (

    PARTITION r0 VALUES IN (1, 5, 9, 13, 17, 21),

    PARTITION r1 VALUES IN (2, 6, 10, 14, 18, 22),

    PARTITION r2 VALUES IN (3, 7, 11, 15, 19, 23),

    PARTITION r3 VALUES IN (4, 8, 12, 16, 20, 24)

);

當前，與VALUES IN...同時使用的值必須只包含整數值。

（因為此資料表只使用VALUES IN資料表達式進行分區，您也可以用PARTITION BY LIST代替，而不是使用PARTITION BY RANGE。請參見下一條。）

在使用VALUES LESS THAN或VALUES IN情況下，每個分區使用PARTITION name定義，此處name是分區的標識名，後面接VALUES...子句。

o        LIST(expr)：當根據含有一系列限定性值（例如州代碼或國家代碼）的列進行分區時使用。在這種情況下，所有與特定的州或國家有關的記錄都被分配到一個單一分區中，或者可以預留出一個分區，用於一系列特定的州或國家。LIST(expr)與RANGE類似，除了一點以外，即只有VALUES IN可以被用於為每個分區指定值。

當使用清單分區時，您必須使用VALUES IN定義至少一個分區。VALUES LESS THAN不能與PARTITION BY LIST一起使用。

o        分區數目可以使用PARTITION num子句，自選進行指定，此處，num是分區的數目。如果本子句和其它PARTITION子句同時使用，則num必須與使用PARTITION子句說明的分區的總數相等。

註釋：不論您在建立一個由RANGE或LIST進行分區的資料表時是否使用了PARTITIONS子句，您必須在資料表定義中包括至少一個PARTITION VALUES（見後）。

o        一個分區可以自選分隔成多個子分區。使用自選的SUBPARTITION BY子句可以指示。子分區可以由HASH或KEY進行分隔。兩種方法建立的子分區均為LINEAR。分隔子分區時的操作方式與以前描述的分區類型的操作方式一樣。（無法由LIST或RANGE進行子分區分隔。）

使用SUBPARTITIONS關鍵詞，後面接一個整值，可以對子分區的數目進行指示。

·         使用一個partition_definition子句可以對每個分區分別進行定義。下面是組成這個子句的各個部分：

o        PARTITION partition_name：用於為分區指定一個邏輯名稱。

o        VALUE子句：對於範圍分區，每個分區必須包括一個VALUES LESS THAN子句；對於清單分區，您必須為每個分區指定一個VALUES IN子句。本子句用於確定哪些行將被儲存到此分區中。要瞭解語法示範，請參見第18章：分區中對分區類型的討論。

o        自選的COMMENT子句可以用於描述分區。註釋必須加單引號。舉例說明：

o                     COMMENT = 'Data for the years previous to 1999'

o        DATA DIRECTORY和INDEX DIRECTORY可以被用於指示本分區的數據和索引各自的儲存位置的目錄。data_dir和index_dir都必須是絕對系統路徑。例如：

o                     CREATE TABLE th (id INT, name VARCHAR(30), adate DATE)

o                     PARTITION BY LIST(YEAR(adate))

o                     (

o                         PARTITION p1999 VALUES IN (1995, 1999, 2003) DATA DIRECTORY = '/var/appdata/95/data' INDEX DIRECTORY = '/var/appdata/95/idx',

o                         PARTITION p2000 VALUES IN (1996, 2000, 2004) DATA DIRECTORY = '/var/appdata/96/data' INDEX DIRECTORY = '/var/appdata/96/idx',

o                         PARTITION p2001 VALUES IN (1997, 2001, 2005) DATA DIRECTORY = '/var/appdata/97/data' INDEX DIRECTORY = '/var/appdata/97/idx',

o                         PARTITION p2000 VALUES IN (1998, 2002, 2006) DATA DIRECTORY = '/var/appdata/98/data' INDEX DIRECTORY = '/var/appdata/98/idx'

);

DATA DIRECTORY和INDEX DIRECTORY的操作方法與CREATE TABLE語句中的table_option子句的操作方法一樣。此table_option子句用於位於MyISAM資料表管理程式下的各資料表。

可以為每個分區指定一個數據目錄和一個索引目錄。如果不指定，則數據和索引被儲存在預設的MySQL數據目錄中。

o        MAX_ROWS和MIN_ROWS分別用於將被儲存在分區中的行數目最大值和行數目最小值。max_number_of_rows和min_number_of_rows的值必須為正整數。和具有同樣名稱的桌面選項一樣，max_number_of_rows和min_number_of_rows只作為對伺服器的「建議」值，並不是硬性限值。

o        自選的TABLESPACE子句可以用於為分區指定一個桌面空間。僅用於MySQL Cluster。

o        自選的[STORAGE] ENGINE子句可以把本分區中資料表的類型改為指定的類型。資料表的類型可以是本MySQL伺服器支援的所有類型。STORAGE關鍵字和等號(=)均為自選項。如果沒有使用此選項設置分區儲存引擎，則適用於整個資料表的引擎可以用於此分區。

註釋：分區管理程式對於PARTITION和SUBPARTITION均接受[STORAGE] ENGINE選項。目前，此子句的使用方式僅限於對所有的分區或子分區設置同一個儲存引擎，如果試圖在同一個資料表內對不同的分區或子分區設置不同的儲存引擎，則會出現錯誤ERROR 1469 (HY000)：在本版本的MySQL中，不允許在各分區中混用管理程式。我們打算在將來的MySQL 5.1版本中加入這種對分區的限定。

o        NODEGROUP選項可以用於使本分區可以作為節點組的一部分，節點組使用node_group_id識別。本選項僅適用於MySQL Cluster。

o        分區定義可以自選地包含一個或多個subpartition_definition子句。每個這種子句至少包括SUBPARTITION name，此處，name是子分區的識別名稱。除了用SUBPARTITION代替PARTITION關鍵詞外，用於子分區定義的語法與用於分區定義的語法一樣。

子分區必須由HASH或KEY完成，並且只能對RANGE或LIST分區進行子分區。請參見18.2.5節，「子分區」。

·         分區可以修改、合併、新增到資料表中，或從資料表中刪去。要瞭解有關完成這些任務的MySQL命令的基本說明，請參見13.1.2節，「ALTER TABLE語法」。要瞭解詳細的說明和示範，請參見18.3節，「分區管理」。

您可以在CREATE TABLE語句的末尾新增一個SELECT語句，在一個資料表的基礎上建立資料表。

CREATE TABLE new_tbl SELECT * FROM orig_tbl;

MySQL會對SELECT中的所有項建立新列。舉例說明：

mysql> CREATE TABLE test (a INT NOT NULL AUTO_INCREMENT,

    ->        PRIMARY KEY (a), KEY(b))

    ->        TYPE=MyISAM SELECT b,c FROM test2;

本語句用於建立含三個列（a, b, c）的MyISAM資料表。注意，用SELECT語句建立的列附在資料表的右側，而不是覆蓋在資料表上。參考以下示範：

mysql> SELECT * FROM foo;

+---+

| n |

+---+

| 1 |

+---+

mysql> CREATE TABLE bar (m INT) SELECT n FROM foo;

Query OK, 1 row affected (0.02 sec)

Records: 1  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM bar;

+------+---+

| m    | n |

+------+---+

| NULL | 1 |

+------+---+

1 row in set (0.00 sec)

對應於資料表foo中的每一行，在資料表bar中插入一行，含有資料表foo中的值以及新列中的預設值。

在由CREATE TABLE...SELECT生成的資料表中，只在CREATE TABLE部分中命名的列首先出現。在兩個部分中都命名的列和只在SELECT部分中命名的列隨後出現。也可以通過指定CREATE TABLE部分中的列覆蓋SELECT列中的數據類型。

如果在把數據複製到資料表中時出現錯誤，則資料表會自動被取消，不會被建立。

CREATE TABLE...SELECT不會自動建立任何索引。索引需要專門建立，以便使語句的靈活性更強。如果您希望為已建立的資料表建立索引，您應在SELECT語句前指定索引。

mysql> CREATE TABLE bar (UNIQUE (n)) SELECT n FROM foo;

列的類型會發生部分轉化。例如，AUTO_INCREAMENT屬性不會被保留，VARCHAR列會變成CHAR列。

當使用CREATE...SELECT建立資料表時，在查詢時一定要對功能使用和資料表達式起別名。如果不起別名，則CREATE語句會出現錯誤或者生成不符合需要的列名稱。

CREATE TABLE artists_and_works

SELECT artist.name, COUNT(work.artist_id) AS number_of_works

FROM artist LEFT JOIN work ON artist.id = work.artist_id

GROUP BY artist.id;

您也可以明確地為一個已生成的列指定類型：

CREATE TABLE foo (a TINYINT NOT NULL) SELECT b+1 AS a FROM bar;

根據其它資料表的定義（包括在原資料表中定義的所有的列屬性和索引），使用LIKE建立一個空資料表:

CREATE TABLE new_tbl LIKE orig_tbl;

CREATE TABLE...LIKE不會複製對原資料表或外部鍵定義指定的DATA DIRECTORY或INDEX DIRECTORY資料表選項。

您可以在SELECT前增加IGNORE或REPLACE，指示如何對複製唯一關鍵字值的記錄進行操縱。使用IGNORE後，如果新記錄複製了原有的唯一關鍵字值的記錄，則新記錄被丟棄。使用REPLACE後，新記錄替換具有相同的唯一關鍵字值的記錄。如果沒有指定IGNORE或REPLACE，則出現多重唯一關鍵字值時會導致發生錯誤。

為了確保更新日誌/二進位日誌可以被用於再次建立原資料表，MySQL不允許在CREATE TABLE...SELECT過程中進行聯合插入。

DROP {DATABASE | SCHEMA} [IF EXISTS] db_name

DROP DATABASE用於取消資料庫中的所用資料表格和取消資料庫。使用此語句時要非常小心！如果要使用DROP DATABASE，您需要獲得資料庫DROP權限。

IF EXISTS用於防止當資料庫不存在時發生錯誤。

也可以使用DROP SCHEMA。

如果您對一個帶有符號連結的資料庫使用DROP DATABASE，則連結和原資料庫都被取消。

DROP DATABASE會返回已被取消的資料表的數目。此數目相當於被取消的.frm檔案的數目。

在正常操作中MySQL自身會建立出一些檔案和目錄。DROP DATABASE語句會從給定的資料庫目錄中取消這些檔案和目錄：

·         所有帶這些延伸名的檔案：

·         名稱中包含兩位16進制數00-ff的所有子目錄。這些子目錄用於RAID資料表。（當對RAID資料表的支援被取消時，在MySQL 5.0中，這些目錄不會被取消。您應該在升級到MySQL 5.0或更新的版本前轉化原有的RAID資料表，並人工取消這些目錄。請參見MySQL 5.0參考手冊中有關從較早版本升級到MySQL 5.0的章節。MySQL 5.0參考手冊可以從MySQL網站中獲取。）

·         db.opt檔案

如果在MySQL取消了上述這些檔案之後，在資料庫目錄中仍保留有其它檔案和目錄，則資料庫目錄不能被取消。在這種情況下，您必須人工取消所有保留下的檔案或目錄，並再次發送DROP DATABASE語句。

您還可以使用mysqladmin來取消檔案。請參見8.5節，「mysqladmin：用於管理MySQL伺服器的客戶端」。

DROP INDEX index_name ON tbl_name

DROP INDEX用於從資料表tbl_name中取消名稱為index_name的索引。本語句被映射到一個ALTER TABLE語句中，用於取消索引。請參見13.1.2節，「ALTER TABLE語法」。

DROP [TEMPORARY] TABLE [IF EXISTS]

    tbl_name [, tbl_name] ...

    [RESTRICT | CASCADE]

DROP TABLE用於取消一個或多個資料表。您必須有每個資料表的DROP權限。所有的資料表數據和資料表定義會被取消，所以使用本語句要小心！

注意，對於一個帶分區的資料表，DROP TABLE會永久性地取消資料表定義，取消各分區，並取消儲存在這些分區中的所有數據。DROP TABLE還會取消與被取消的資料表有關聯的分區定義（.par）檔案。

對與不存在的資料表，使用IF EXISTS用於防止錯誤發生。當使用IF EXISTS時，對於每個不存在的資料表，會生成一個NOTE。請參見13.5.4.22節，「SHOW WARNINGS語法」。

RESTRICT和CASCADE可以使分區更容易。目前，RESTRICT和CASCADE不起作用。

註釋：除非您使用TEMPORARY關鍵詞，DROP TABLE會自動提交當前的有效的事務。

TEMPORARY關鍵詞具有以下作用：

·         語句只取消TEMPORARY資料表。

·         語句不會終止正在進行中的事務。

·         不會查驗存取權。（TEMPORARY資料表僅對於建立該資料表的客戶端是可見的，所以查驗是不必要的。）

使用TEMPORARY是確保您不會意外取消一個非TEMPORARY資料表的良好方法。

單資料表語法：

DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name

    [WHERE where_definition]

    [ORDER BY ...]

    [LIMIT row_count]

多資料表語法：

DELETE [LOW_PRIORITY] [QUICK] [IGNORE]

    tbl_name[.*] [, tbl_name[.*] ...]

    FROM table_references

    [WHERE where_definition]

或：

DELETE [LOW_PRIORITY] [QUICK] [IGNORE]

    FROM tbl_name[.*] [, tbl_name[.*] ...]

    USING table_references

    [WHERE where_definition]

tbl_name中有些行滿足由where_definition給定的條件。DELETE用於刪除這些行，並返回被刪除的記錄的數目。

如果您編寫的DELETE語句中沒有WHERE子句，則所有的行都被刪除。當您不想知道被刪除的行的數目時，有一個更快的方法，即使用TRUNCATE TABLE。請參見13.2.9節，「TRUNCATE語法」。

如果您刪除的行中包括用於AUTO_INCREMENT列的最大值，則該值被重新用於BDB資料表，但是不會被用於MyISAM資料表或InnoDB資料表。如果您在AUTOCOMMIT模式下使用DELETE FROM tbl_name（不含WHERE子句）刪除資料表中的所有行，則對於所有的資料表類型（除InnoDB和MyISAM外），序列重新編排。對於InnoDB資料表，此項操作有一些例外，在15.2.6.3節，「AUTO_INCREMENT列如何在InnoDB中運行」中進行了討論。

對於MyISAM和BDB資料表，您可以把AUTO_INCREMENT次級列指定到一個多列關鍵字中。在這種情況下，從序列的頂端被刪除的值被再次使用，甚至對於MyISAM資料表也如此。請參見3.6.9節，「使用AUTO_INCREMENT」。

DELETE語句支援以下修飾符：

·         如果您指定LOW_PRIORITY，則DELETE的執行被延遲，直到沒有其它客戶端讀取本資料表時再執行。

·         對於MyISAM資料表，如果您使用QUICK關鍵詞，則在刪除過程中，儲存引擎不會合併索引端結點，這樣可以加快部分種類的刪除操作的速度。

·         在刪除行的過程中，IGNORE關鍵詞會使MySQL忽略所有的錯誤。（在分析階段遇到的錯誤會以常規方式處理。）由於使用本選項而被忽略的錯誤會作為警告返回。

刪除操作的速度會受到一些因素的影響，這些因素在7.2.18節，「DELETE語句的速度」中進行了討論。

在MyISAM資料表中，被刪除的記錄被保留在一個帶連結的清單中，後續的INSERT操作會重新使用舊的記錄位置。要重新使用未使用的空間並減小檔案的尺寸，則使用OPTIMIZE TABLE語句或myisamchk應用程式重新編排資料表。OPTIMIZE TABLE更簡便，但是myisamchk速度更快。請參見13.5.2.5節，「OPTIMIZE TABLE語法」和第7章：最佳化。

QUICK修飾符會影響到在刪除操作中索引端結點是否合併。當用於被刪除的行的索引值被來自後插入的行的相近的索引值代替時，DELETE QUICK最為適用。在此情況下，被刪除的值留下來的空穴被重新使用。

未充滿的索引塊跨越某一個範圍的索引值，會再次發生新的插入。當被刪除的值導致出現未充滿的索引塊時，DELETE QUICK沒有作用。在此情況下，使用QUICK會導致未利用的索引中出現廢棄空間。下面是此種情況的舉例說明：

1.    建立一個資料表，資料表中包含已編索引的AUTO_INCREMENT列。

2.    在資料表中插入很多記錄。每次插入會產生一個索引值，此索引值被新增到索引的高端處。

3.    使用DELETE QUICK從列的低端處刪除一組記錄。

在此情況下，與被刪除的索引值相關的索引塊變成未充滿的狀態，但是，由於使用了QUICK，這些索引塊不會與其它索引塊合併。當插入新值時，這些索引塊仍為未充滿的狀態，原因是新記錄不含有在被刪除的範圍內的索引值。另外，即使您此後使用DELETE時不包含QUICK，這些索引塊也仍是未充滿的，除非被刪除的索引值中有一部分碰巧位於這些未充滿的塊的之中，或與這些塊相鄰。在這些情況下，如果要重新利用未使用的索引空間，需使用OPTIMIZE TABLE。

如果您打算從一個資料表中刪除許多行，使用DELETE QUICK再加上OPTIMIZE TABLE可以加快速度。這樣做可以重新建立索引，而不是進行大量的索引塊合併操作。

用於DELETE的MySQL唯一的LIMIT row_count選項用於告知伺服器在控制命令被返回到客戶端前被刪除的行的最大值。本選項用於確保一個DELETE語句不會佔用過多的時間。您可以只重複DELETE語句，直到相關行的數目少於LIMIT值為止。

如果DELETE語句包括一個ORDER BY子句，則各行按照子句中指定的順序進行刪除。此子句只在與LIMIT聯用是才起作用。例如，以下子句用於搜尋與WHERE子句對應的行，使用timestamp_column進行分類，並刪除第一（最舊的）行：

DELETE FROM somelog

WHERE user = 'jcole'

ORDER BY timestamp_column

LIMIT 1;

您可以在一個DELETE語句中指定多個資料表，根據多個資料表中的特定條件，從一個資料表或多個資料表中刪除行。不過，您不能在一個多資料表DELETE語句中使用ORDER BY或LIMIT。

table_references部分列出了包含在聯合中的資料表。此語法在13.2.7.1節，「JOIN語法」中進行了說明。

對於第一個語法，只刪除列於FROM子句之前的資料表中的對應的行。對於第二個語法，只刪除列於FROM子句之中（在USING子句之前）的資料表中的對應的行。作用是，您可以同時刪除許多個資料表中的行，並使用其它的資料表進行搜索：

DELETE t1, t2 FROM t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;

或：

DELETE FROM t1, t2 USING t1, t2, t3 WHERE t1.id=t2.id AND t2.id=t3.id;

當搜索待刪除的行時，這些語句使用所有三個資料表，但是只從資料表t1和資料表t2中刪除對應的行。

以上例子顯示了使用逗號操作符的內部聯合，但是多資料表DELETE語句可以使用SELECT語句中允許的所有類型的聯合，比如LEFT JOIN。

本語法允許在名稱後面加.*，以便與Access相容。

如果您使用的多資料表DELETE語句包括InnoDB資料表，並且這些資料表受外部鍵的限制，則MySQL最佳化程式會對資料表進行處理，改變原來的從屬關係。在這種情況下，該語句出現錯誤並返回到前面的步驟。要避免此錯誤，您應該從單一資料表中刪除，並依靠InnoDB提供的ON DELETE功能，對其它資料表進行相應的修改。

註釋：當引用資料表名稱時，您必須使用別名（如果已給定）：

DELETE t1 FROM test AS t1, test2 WHERE ...

進行多資料表刪除時支援跨資料庫刪除，但是在此情況下，您在引用資料表時不能使用別名。舉例說明：

DELETE test1.tmp1, test2.tmp2 FROM test1.tmp1, test2.tmp2 WHERE ...

目前，您不能從一個資料表中刪除，同時又在子查詢中從同一個資料表中選擇。

DO expr [, expr] ...

HANDLER tbl_name OPEN [ AS alias ]
HANDLER tbl_name READ index_name { = | >= | <= | < } (value1,value2,...)
    [ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
    [ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name READ { FIRST | NEXT }
    [ WHERE where_condition ] [LIMIT ... ]
HANDLER tbl_name CLOSE

HANDLER語句提供通往資料表儲存引擎接口的直接通道。HANDLER可以用於MyISAM和InnoDB資料表。

HANDLER...OPEN語句用於打開一個資料表，通過後續的HANDLER...READ語句建立讀取資料表的通道。本資料表目標不會被其它線程共享，也不會關閉，直到線程使用HANDLER...CLOSE或線程中止時為止。如果您使用一個別名打開資料表，則使用其它HANDLER語句進一步參閱資料表是必須使用此別名，而不能使用資料表名。

如果被指定的索引滿足給定的值並且符合了WHERE條件，則第一個HANDLER...READ語法取出一行。如果您有一個多列索引，則指定索引列值為一個用逗號隔開的清單。既可以為索引中的所有列指定值，也可以為索引列的最左邊的前綴指定值。假設一個索引包括三個列，名稱為col_a, col_b,和col_c，並按此順序排列。HANDLER語句可以為索引中的所有三個列指定值，或者為一個最左邊前綴中的各列指定值。舉例說明：

HANDLER ... index_name = (col_a_val,col_b_val,col_c_val) ...

HANDLER ... index_name = (col_a_val,col_b_val) ...

HANDLER ... index_name = (col_a_val) ...

第二個HANDLER...READ語法按索引的順序從資料表中取出一行。索引的順序符合WHERE條件。

第三個HANDLER...READ語法按自然行的順序從資料表中取出一行。自然行的順序符合WHERE條件。當想要對整個資料表進行掃瞄時，此語句比HANDLER tbl_name READ index_name更快。自然行的順序指的是行儲存在MyISAM資料表數據檔案的順序。本語句也適用於InnoDB資料表，但是因為沒有獨立的數據檔案，所以沒有這類概念。

不使用LIMIT子句時，所有形式的HANDLER...READ語句均只取出一行。 如果要返回多個行，應加入一個LIMIT子句。本語句於SELECT語句的語法一樣。請參見13.2.7節，「SELECT語法」。

HANDLER...CLOSE用於關閉使用HANDLER...OPEN打開的資料表。

註釋：要使用HANDLER接口來查閱一個資料表的PRIMARY KEY，應使用帶引號的識別符`PRIMARY`：

HANDLER tbl_name READ `PRIMARY` > (...);

HANDLER是比較低級別的語句。例如，它不能提供一致性。也就是說，HANDLER...OPEN不能為資料表做快照，也不能鎖定資料表。這意味著，當一個HANDLER...OPEN語句被編寫後，資料表數據可以被更改（用此線程或用其它線程），並且這些更改只會部分地出現在HANDLER...NEXT或HANDLER...PREV掃瞄中。

使用HANDLER接口代替常規的SELECT語句有多個原因：

·         HANDLER比SELECT更快：

o        一個指定的儲存引擎管理程式目標為了HANDLER...OPEN進行整序。該目標被重新用於該資料表的後續的HANDLER語句；不需要對每個語句進行重新初始化。

o        涉及的分析較少。

o        沒有最佳化程式或查詢校驗開銷。

o        在兩個管理程式請求之間，不需要鎖定資料表。

o        管理程式接口不需要提供外觀一致的數據（例如，允許無條理的讀取），所以儲存引擎可以使用最佳化，而SELECT通常不允許使用最佳化。

·         有些應用程式使用與ISAM近似的接口與MySQL連接。使用HANDLER可以更容易地與這些應用程式連接。

·         HANDLER允許您採用一種特殊的方式進出資料庫。而使用SELECT時難以採用（或不可能採用）這種方式。有些應用程式可以提供一個交互式的用戶接口與資料庫連接。當與這些應用程式同時使用時，用HANDLER接口觀看數據更加自然。

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]

    [INTO] tbl_name [(col_name,...)]

    VALUES ({expr | DEFAULT},...),(...),...

    [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

或：

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]

    [INTO] tbl_name

    SET col_name={expr | DEFAULT}, ...

    [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

或：

INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]

    [INTO] tbl_name [(col_name,...)]

    SELECT ...

    [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

INSERT用於向一個已有的資料表中插入新行。INSERT...VALUES和INSERT...SET形式的語句根據明確指定的值插入行。INSERT...SELECT形式的語句插入從其它資料表中選出的行。在13.2.4.1節，「INSERT ... SELECT語法」中對INSERT...SELECT進行了進一步的討論。

行應被插入到tbl_name資料表中。可以按以下方法指定列。本語句向這些列提供值。

·         列名稱清單或SET子句明確的指示了列。

·         如果您不為INSERT...VALUES或INSERT...SELECT指定列的清單，則資料表中每列的值必須在VALUES清單中提供，或由SELECT提供。如果您不知道資料表中各列的順序，則使用DESCRIBE tbl_name查詢。

列值可以採用多種方法給定：

·         如果不是在嚴格模式下運行，則所有沒有明確給定值的列都被設置為預設值（明確的或隱含的）。例如，如果您指定了一個列清單，但此清單沒有對資料表中所有的列進行命名，則未命名的各列被設置為預設值。預設值的賦值在13.1.5節，「CREATE TABLE語法」中進行了說明。也可參見1.8.6.2節，「對無效數據的約束」。

有時候，您需要對所有沒有預設值的列明確地指定值。如果您希望，在沒有明確指定值時，INSERT語句可以生成錯誤訊息，則您應該使用STRICT模式。請參見5.3.2節，「SQL伺服器模式」。

·         使用關鍵詞DEFAULT，明確地把列設置為預設值。這樣，編寫向所有列賦值的INSERT語句時可以更容易，因為使用DEFAULT可以避免編寫出不完整的、未包含全部列值的VALUES清單。如果不使用DEFUALT，您必須編寫一個列名稱清單，與VALUES清單中的每個值對應。

您還可以使用DEFAULT(col_name)作為一種更通用的形式，在資料表達式中使用，用於生成一個列的預設值。

·         如果列清單和VALUES清單均為空清單，則INSERT會建立一個行，每個列都被設置為預設值：

·                mysql> INSERT INTO tbl_name () VALUES();

在STRICT模式中，如果有一列沒有預設值，則會出現錯誤。或者，MySQL會對所有沒有明確定義預設值的列使用隱含的預設值。

·         您可以指定一個資料表達式expr來提供一個列值。如果資料表達式的類型與列值不匹配，這樣做會造成類型轉化。並且，給定值的轉化會導致不同的插入值，插入何值由列類型而定。例如，向一個INT, FLOAT, DECIMAL(10,6)或YEAR列插入字串'1999.0e-2'，插入值分別是1999，19.9921，19.992100和1999。儲存在INT和YEAR列中的值為1999的原因是，在從字串到整數的轉化中，只把字串的前面部分看作有效的整數或年份。對於浮點列和固定點列，在從字串到浮點的轉化中，把整個字串均看作有效的浮點值。

資料表達式expr可以引用在值清單中已設置的所有列。例如，您可以這麼操作，因為用於col2的值引用了col1，而col1已經被賦值：

mysql> INSERT INTO tbl_name (col1,col2) VALUES(15,col1*2);

但是以下語句不合法，因為用於col1的值引用了col2，而col2在col1之後被賦值：

mysql> INSERT INTO tbl_name (col1,col2) VALUES(col2*2,15);

有一種例外情況，那就是含有AUTO_INCREMENT值的列。因為AUTO_INCREMENT值在其它值賦值之後被生成，所以任何在賦值時對AUTO_INCREMENT列的引用都會返回0。

INSERT語句支援下列修改符：

·         如果您使用DELAYED關鍵字，則伺服器會把待插入的行放到一個緩衝器中，而發送INSERT DELAYED語句的客戶端會繼續運行。如果資料表正在被使用，則伺服器會保留這些行。當資料表空閒時，伺服器開始插入行，並定期檢查是否有新的讀取請求。如果有新的讀取請求，則被延遲的行被延緩執行，直到資料表再次空閒時為止。請參見13.2.4.2節，「INSERT DELAYED語法」。

·         如果您使用LOW_PRIORITY關鍵詞，則INSERT的執行被延遲，直到沒有其它客戶端從資料表中讀取為止。當原有客戶端正在讀取時，有些客戶端剛開始讀取。這些客戶端也被包括在內。此時，INSERT LOW_PRIORITY語句等候。因此，在讀取量很大的情況下，發出INSERT LOW_PRIORITY語句的客戶端有可能需要等待很長一段時間（甚至是永遠等待下去）。（這與INSERT DELAYED形成對比，INSERT DELAYED立刻讓客戶端繼續執行。請參見13.2.4.2節，「INSERT DELAYED語法」。）注意LOW_PRIORITY通常不應用於MyISAM資料表，因為這麼做會取消同時進行的插入。請參見15.1節，「MyISAM儲存引擎」。

·         如果您指定了HIGH_PRIORITY，同時伺服器採用--low-priority-updates選項啟動，則HIGH_PRIORITY將覆蓋--low-priority-updates選項。這麼做還會導致同時進行的插入被取消。

·         使用mysql_affected_rows() C API函數，可以獲得用於INSERT的受影響行的值。請參見25.2.3.1節，「mysql_affected_rows()」。

·         如果您在一個INSERT語句中使用IGNORE關鍵詞，在執行語句時出現的錯誤被當作警告處理。例如，沒有使用IGNORE時，如果一個行複製了原有的UNIQUE索引或PRIMARY KEY值，會導致出現重複關鍵字錯誤，語句執行失敗。使用IGNORE時，該行仍然未被插入，但是不會出現錯誤。IGNORE未被指定時，如果數據轉化引發錯誤，則會使語句執行失敗。使用IGNORE後，無效數據被調整到最接近的值，並被插入；此時，生成警告，但是語句執行不會失敗。您可以使用mysql_info() C API函數測定有多少行被插入到資料表中。

如果您指定了ON DUPLICATE KEY UPDATE，並且插入行後會導致在一個UNIQUE索引或PRIMARY KEY中出現重複值，則執行舊行UPDATE。例如，如果列a被定義為UNIQUE，並且包含值1，則以下兩個語句具有相同的效果：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3)

    -> ON DUPLICATE KEY UPDATE c=c+1;

mysql> UPDATE table SET c=c+1 WHERE a=1;

如果行作為新記錄被插入，則受影響行的值為1；如果原有的記錄被更新，則受影響行的值為2。

註釋：如果列b也是唯一列，則INSERT與此UPDATE語句相當：

mysql> UPDATE table SET c=c+1 WHERE a=1 OR b=2 LIMIT 1;

如果a=1 OR b=2與多個行向匹配，則只有一個行被更新。通常，您應該盡量避免對帶有多個唯一關鍵字的資料表使用ON DUPLICATE KEY子句。

您可以在UPDATE子句中使用VALUES(col_name)函數從INSERT...UPDATE語句的INSERT部分引用列值。換句話說，如果沒有發生重複關鍵字衝突，則UPDATE子句中的VALUES(col_name)可以引用被插入的col_name的值。本函數特別適用於多行插入。VALUES()函數只在INSERT...UPDATE語句中有意義，其它時候會返回NULL。

示範：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)

    -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);

本語句與以下兩個語句作用相同：

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3)

    -> ON DUPLICATE KEY UPDATE c=3;

mysql> INSERT INTO table (a,b,c) VALUES (4,5,6)

    -> ON DUPLICATE KEY UPDATE c=9;

當您使用ON DUPLICATE KEY UPDATE時，DELAYED選項被忽略。

您可以使用SQL LAST_INSERT_ID()函數搜尋用於AUTO_INCREMENT列的值。從C API的內部，使用mysql_insert_id()函數。不過，您應該注意，兩個函數的作用並不總是相同的。在12.9.3節，「訊息函數」和25.2.3.36節，「mysql_insert_id()」中進一步討論了與AUTO_INCREMENT列有關的INSERT語句的作用。

如果您使用INSERT...VALUES語句時採用了多個值清單或INSERT...SELECT，則該語句按以下格式返回一個訊息字串：

Records: 100 Duplicates: 0 Warnings: 0

記錄指示了經過語句處理的行的數目。（因為重複數目可以不是零，所以該數目不一定是實際被插入的行的數目。）重複數目指的是不能被插入的行的數目，因為這些行會複製部分原有的唯一索引值。警告指的是插入有錯誤或有問題的列值的次數。在以下情況下會出現警告：

·         向一個已定義為NOT NULL的列中插入NULL。對於一個多行INSERT語句或INSERT INTO...SELECT語句，根據列數據的類型，列被設置為隱含的預設值。對於數字類型，預設值為0；對於字串類型，預設值為空字串('')；對於日期和時間類型，預設值為「zero」值。對INSERT INTO...SELECT語句的處理方法與對多行插入的處理方法一樣，因為伺服器不能檢測來自SELECT的結果，不能判斷是否返回單一行。（對於單一行INSERT，當NULL被插入一個NOT NULL列時，不會出現警告，而是出現錯誤，並且語句運行失敗。）

·         數字列的值被設置在列的值範圍之外。此值被修改為未最接近的值範圍端點。

·         向一個數字列賦予一個例如'10.34 a'的值。尾部的非數字文本被刪節，其餘的數字部分被插入，如果字串值沒有前導的數字部分，則該列被設置為0。

·         向一個字串列（CHAR, VARCHAR, TEXT或BLOB）中插入的字串超過了列的最大長度。此值被刪節到列的最大長度。

·         向日期或時間列中插入的值對於該列的類型是不合法的。根據列的類型，該列被設置到相應的零值。

如果您正在使用C API，則可以通過使用mysql_info()函數獲取訊息字串。請參見25.2.3.34節，「mysql_info()」。

INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]

    [INTO] tbl_name [(col_name,...)]

    SELECT ...

    [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

INSERT INTO tbl_temp2 (fld_id)

    SELECT tbl_temp1.fld_order_id

    FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;

INSERT DELAYED ...

LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name.txt'

    [REPLACE | IGNORE]

    INTO TABLE tbl_name

    [FIELDS

        [TERMINATED BY 'string']

        [[OPTIONALLY] ENCLOSED BY 'char']

        [ESCAPED BY 'char' ]

    ]

    [LINES

        [STARTING BY 'string']

        [TERMINATED BY 'string']

    ]

    [IGNORE number LINES]

    [(col_name_or_user_var,...)]

    [SET col_name = expr,...)]

LOAD DATA INFILE語句用於高速地從一個文本檔案中讀取行，並裝入一個資料表中。檔案名稱必須為一個文字字串。

要瞭解有關INSERT和LOAD DATA INFILE的效率的對比和有關LOAD DATA INFILE加速的更多訊息，請參見7.2.16節，「INSERT語句的速度」。

由character_set_database系統變數指示的字元編碼被用於解釋檔案中的訊息。SET NAMES和character_set_client的設置不會影響對輸入的解釋。

注意，目前不能載入UCS2數據檔案。

您也可以通過使用mysqlimport應用程式載入數據檔案；通過向伺服器發送一個LOAD DATA INFILE語句實現此功能。--local選項用於使mysqlimport從客戶主機中讀取數據檔案。如果客戶端和伺服器支援壓縮協議，則您可以指定—compress選項提高在慢速網絡中的性能。請參見8.10節，「mysqlimport：數據導入程式。

如果您使用LOW_PRIORITY，則LOAD DATA語句的執行被延遲，直到沒有其它的客戶端從資料表中讀取為止。

如果一個MyISAM資料表滿足同時插入的條件（即該資料表在中間有空閒塊），並且您對這個MyISAM資料表指定了CONCURRENT，則當LOAD DATA正在執行時，其它線程會從資料表中重新獲取數據。即使沒有其它線程在同時使用本資料表格，使用本選項也會略微影響LOAD DATA的性能。

如果指定了LOCAL，則被認為與連接的客戶端有關：

·         如果指定了LOCAL，則檔案會被客戶主機上的客戶端讀取，並被發送到伺服器。檔案會被給予一個完整的路徑名稱，以指定確切的位置。如果給定的是一個相對的路徑名稱，則此名稱會被理解為相對於啟動客戶端時所在的目錄。

·         如果LOCAL沒有被指定，則檔案必須位於伺服器主機上，並且被伺服器直接讀取。

當在伺服器主機上為檔案定位時，伺服器使用以下規則：

·         如果給定了一個絕對的路徑名稱，則伺服器使用此路徑名稱。

·         如果給定了帶有一個或多個引導組件的相對路徑名稱，則伺服器會搜索相對於伺服器數據目錄的檔案。

·         如果給定了一個不帶引導組件的檔案名稱，則伺服器會在預設資料庫的資料庫目錄中尋找檔案。

注意，這些規則意味著名為./myfile.txt的檔案會從伺服器數據目錄中被讀取，而名為myfile.txt的同樣的檔案會從預設資料庫的資料庫目錄中讀取。例如，下面的LOAD DATA語句會從db1資料庫目錄中讀取檔案data.txt，因為db1是當前資料庫。即使語句明確把檔案載入到db2資料庫中的資料表裡，也會從db1目錄中讀取。

mysql> USE db1;

mysql> LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;

注意，使用正斜槓指定Windows路徑名稱，而不是使用反斜槓。如果您使用反斜槓，您必須使用兩個。

出於安全原因，當讀取位於伺服器中的文本檔案時，檔案必須位於資料庫目錄中，或者是全體可讀的。另外，要對伺服器檔案使用LOAD DATA INFILE，您必須擁有FILE權限。

見5.7.3節，「MySQL提供的權限」。

與讓伺服器直接讀取檔案相比，使用LOCAL速度略慢，這是因為檔案的內容必須通過客戶端發送到伺服器上。不過，您不需要FILE權限來載入本地檔案。

只有當您的伺服器和您的客戶端都授權時，LOCAL才可運行。例如，如果使用—local-infile=0啟動mysqld，則LOCAL不運行。請參見5.6.4節，「LOAD DATA LOCAL安全問題」。

如果您需要LOAD DATA來從一個管道中讀取，您可以使用以下方法（此處我們把/目錄清單載入一個資料表格）：

mkfifo /mysql/db/x/x

chmod 666 /mysql/db/x/x

find / -ls > /mysql/db/x/x

mysql -e "LOAD DATA INFILE 'x' INTO TABLE x" x

有些輸入記錄把原有的記錄複製到唯一關鍵字值上。REPLACE和IGNORE關鍵字用於控制這些輸入記錄的操作。

如果您指定了REPLACE，則輸入行會替換原有行（換句話說，與原有行一樣，對一個主索引或唯一索引具有相同值的行）。請參見13.2.6節，「REPLACE語法」。

如果您指定IGNORE，則把原有行複製到唯一關鍵字值的輸入行被跳過。如果您這兩個選項都不指定，則運行情況根據LOCAL關鍵詞是否被指定而定。不使用LOCAL時，當出現重複關鍵字值時，會發生錯誤，並且剩下的文本檔案被忽略。使用LOCAL時，預設的運行情況和IGNORE被指定時的情況相同；這是因為在運行中間，伺服器沒有辦法中止檔案的傳輸。

如果您希望在載入運行過程中忽略外部鍵的限制，您可以在執行LOAD DATA前發送一個SET FOREIGN_KEY_CHECKS=0語句。

如果您對一個空的MyISAM資料表使用LOAD DATA INFILE，則所有的非唯一索引會被建立在一個獨立批中（對於REPAIR TABLE）。當您有許多索引時，這通常會使LOAD DATA INFILE大大加快。通常，LOAD DATA INFILE的速度會非常快，但是在某些極端情況下，您可以在把檔案載入到資料表中之前使用ALTER TABLE...DISABLE KEYS關閉LOAD DATA INFILE，或者在載入檔案之後使用ALTER TABLE...ENABLE KEYS再次建立索引，使建立索引的速度更快。請參見7.2.16節，「INSERT語句的速度」。

LOAD DATA INFILE是SELECT...INTO OUTFILE的補語。（見13.2.7節，「SELECT語法」。）要從一個資料表中把數據寫入一個檔案中，應使用SELECT...INTO OUTFILE。要讀取檔案，放回到資料表中，應使用LOAD DATA INFILE。FIELDS和LINES子句的語法對於兩個語句是一樣的。兩個子句都是自選的，但是如果兩個都被指定了，FIELDS必須位於LINES的前面。

如果您指定了一個FIELDS子句，則每個亞子句（TERMINATED BY, [OPTIONALLY] ENCLOSED BY和ESCAPED BY）也是自選的。不過，您必須指定其中至少一個。

如果您不指定FIELDS子句，則預設值為假設您寫下如下語句時的值：

FIELDS TERMINATED BY '\t' ENCLOSED BY '' ESCAPED BY '\\'

如果您不指定LINES子句，則預設值為假設您寫下如下語句時的值：

LINES TERMINATED BY '\n' STARTING BY ''

換句話說，當讀取輸入值時，預設值會使LOAD DATA INFILE按如下方式運行：

·         在新行處尋找行的邊界。

·         不會跳過任何行前綴。

·         在製表符處把行分解為字段。

·         不希望字段被包含在任何引號字元之中。

·         出現製表符、新行、或在『\』前有『\』時，理解為作為字段值一部分的文字字元。

相反的，當編寫輸出值時，預設值會使SELECT...INTO OUTFILE按如下方式運行：

·         在字段之間寫入製表符。

·         不把字段包含在任何引號字元中。

·         當字段值中出現製表符、新行或『\』時，使用『\』進行轉義。

·         在行的末端寫入新行。

注意，要寫入FIELDS ESCAPED BY 『\\』，您必須為待讀取的值指定兩個反斜槓，作為一個單反斜槓使用。

註釋：如果您已經在Windows系統中生成了文本檔案，您可能必須使用LINES TERMINATED BY 『\r\n』來正確地讀取檔案，因為Windows程式通常使用兩個字元作為一個行終止符。部分程式，比如WordPad，當編寫檔案時，可能會使用\r作為行終止符。要讀取這樣的檔案，應使用LINES TERMINATED BY 『\r』。

如果所有您希望讀入的行都含有一個您希望忽略的共用前綴，則您可以使用'prefix_string'來跳過前綴（和前綴前的字元）。如果某行不包括前綴，則整個行被跳過。註釋：prefix_string會出現在一行的中間。

示範：

mysql> LOAD DATA INFILE '/tmp/test.txt'

    -> INTO TABLE test LINES STARTING BY "xxx";

使用此語句，您可以讀入包含有如下內容的檔案：

xxx"row",1

something xxx"row",2

並只得到數據("row",1)和("row",2)。

IGNORE number LINES選項可以被用於在檔案的開始處忽略行。例如，您可以使用IGNORE 1 LINES來跳過一個包含列名稱的起始標題行：

mysql> LOAD DATA INFILE '/tmp/test.txt'

    -> INTO TABLE test IGNORE 1 LINES;

當您聯合使用SELECT...INTO OUTFILE和LOAD DATA INFILE來從一個資料庫中把數據寫入一個檔案中，然後再讀取檔案，返回到資料庫中時，用於兩個語句的field-和line-handling選項必須匹配。否則，LOAD DATA INFILE不會正確地理解檔案的內容。假設您使用SELECT...INTO OUTFILE來編寫一個的檔案，字段由逗號分隔：

mysql> SELECT * INTO OUTFILE 'data.txt'

    ->          FIELDS TERMINATED BY ','

    ->          FROM table2;

要讀取由逗號分隔的檔案並返回，則正確的語句應該是：

mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2

    ->           FIELDS TERMINATED BY ',';

如果您嘗試使用以下所示的語句讀入檔案，則不會運行，因為該語句命令LOAD DATA INFILE尋找位於字段之間的製表符：

mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2

    ->           FIELDS TERMINATED BY '\t';

結果很可能是，每個輸入行被理解為一個單一字段。

LOAD DATA INFILE也可以被用於讀取從外源中獲取的檔案。例如，一個dBASE格式的檔案具有以逗號分隔並且包含在雙引號中的字段。如果檔案中的各行以新行為結尾，則此處所示的語句描述了您可以用於載入檔案的field-和line-handling選項：

mysql> LOAD DATA INFILE 'data.txt' INTO TABLE tbl_name

    ->           FIELDS TERMINATED BY ',' ENCLOSED BY '"'

    ->           LINES TERMINATED BY '\n';

所有field-或line-handling選項都可以指定一個空字串('')。如果字串不是空的，則FIELDS [OPTIONALLY] ENCLOSED BY和FIELDS ESCAPED BY值必須為單一字元。FIELDS TERMINATED BY, LINES STARTING BY和LINES TERMINATED BY值可以超過一個字元。例如，要編寫由回車/換行成對字元作為結尾的行，或讀取包含這類行的檔案，則應指定一個LINES TERMINATED BY 『\r\n』子句。

如果jokes被由%%組成的行分隔，要讀取包含jokes的檔案，您可以這麼操作：

mysql> CREATE TABLE jokes

    ->     (a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,

    ->     joke TEXT NOT NULL);

mysql> LOAD DATA INFILE '/tmp/jokes.txt' INTO TABLE jokes

    ->     FIELDS TERMINATED BY ''

    ->     LINES TERMINATED BY '\n%%\n' (joke);

FIELDS [OPTIONALLY] ENCLOSED BY用於控制字段的引號。對於（SELECT...INTO OUTFILE），如果您忽略了詞語OPTIONALLY，則所有的字段都被包含在ENCLOSED BY字串中。此處展示了此類輸出的一個示範（使用逗號作為字段分隔符）：

"1","a string","100.20"

"2","a string containing a , comma","102.20"

"3","a string containing a \" quote","102.20"

"4","a string containing a \", quote and comma","102.20"

如果您指定了OPTINALLY，則ENCLOSED BY字元只被用於包含具有字串數據類型（比如CHAR, BINARY, TEXT或ENUM）的列中的值：

1,"a string",100.20

2,"a string containing a , comma",102.20

3,"a string containing a \" quote",102.20

4,"a string containing a \", quote and comma",102.20

注意，如果在字段值內出現ENCLOSED BY字元，則通過使用ESCAPED BY字元作為前綴，對ENCLOSED BY字元進行轉義。另外，要注意，如果您指定了一個空的ESCAPED BY值，則可能會生成不能被LOAD DATA INFILE正確讀取的輸出值。例如，如果轉義符為空字元，則剛顯示的先前輸出值應顯示如下。請觀察，第四行中的第二個字段在引號後面包含一個逗號，該引號（錯誤地）顯示出來，作為字段的結尾：

1,"a string",100.20

2,"a string containing a , comma",102.20

3,"a string containing a " quote",102.20

4,"a string containing a ", quote and comma",102.20

對於輸入值，ENCLOSED BY字元被從字段字的末尾剝離。（不論OPTIONALLY是否被指定都會剝離；OPTIONALLY對輸入值的解釋沒有影響。）如果ENCLOSED BY字元前面帶有ESCAPED BY字元，則被理解為當前字段值的一部分。

如果字段以ENCLOSED BY字元為開始，當出現這類字元時，只有後面接著字段或行TERMINATED BY序列時，這類字元被認為是一個字段值的結尾。為了避免意思不明確，當在一個字段值中出現ENCLOSED BY字元時，此字元可以重複書寫，並被理解為單一的字元。例如，如果指定了ENCLOSED BY '"'，則按照以下方法操作引號：

"The ""BIG"" boss"  -> The "BIG" boss

The "BIG" boss      -> The "BIG" boss

The ""BIG"" boss    -> The ""BIG"" boss

FIELDS ESCAPED BY用於控制如何寫入或讀取特殊字元。如果FIELDS ESCAPED BY字元不是空字元，則可以在輸出中用於對以下字元加前綴：

·         FIELDS ESCAPED BY字元

·         FIELDS [OPTIONALLY] ENCLOSED BY字元

·         FIELDS TERMINATED BY和LINES TERMINATED BY值的第一個字元

·         ASCII 0（在轉義符之後編寫的字元實際上是ASCII『0』，而不是一個值為0的字節）

如果FIELDS ESCAPED BY字元為空字元，則沒有字元被轉義，並且NULL被作為NULL輸出，而不是\N。去指定一個空的轉義符不是一個好辦法，特別是如果數據的字段值包含任何剛給定的清單中的字元時，更不能這麼做。

對於輸入值，如果FIELDS ESCAPED BY字元不是空字元，則出現這種字元時會被剝離，然後以下字元被作為字段值的一部分。例外情況是，被轉義的『0』或『N』（例如，\0或\N，此時轉義符為『\』）。這些序列被理解為ASCII NUL（一個零值字節）和NULL。用於NULL處理的規則在本節的後部進行說明。

要瞭解有關『\』-escape語法的更多訊息，請參見9.1節，「文字值」。

在特定情況下，field-和line-handling選項相互影響：

·         如果LINES TERMINATED BY是空字串，並且FIELDS TERMINATED BY不是空字串，則各行以FIELDS TERMINATED BY作為結尾。

·         如果FIELDS TERMINATED BY和FIELDS ENCLOSED BY值均為空值('')，則使用固定行（無分隔）格式。使用固定行格式時，在字段之間不使用分隔符（但是您仍然可以有行終止符）。列值使用列的顯示寬度進行寫入和讀取。例如，如果某列被定義為INT(7)，則使用7字元字段寫入列值。輸出時，通過讀取7個字元獲取列值。

LINES TERMINATED BY仍然用於分隔行。如果某行不包含所有字段，則其餘的各列被設置到預設值。如果您沒有行終止符，您應該把終止符設置為''。在此情況下，文本檔案必須包含每行的所有字段。

固定行格式也會影響NULL值的操作，這將在以後進行介紹。注意，如果您正在使用一個多字節字元編碼，則固定規格格式不會運行。

根據正在使用中的FIELDS和LINES選項的不同，NULL值的操作有所變化：

·         對於預設的FIELDS和LINES值，NULL被作為\N的字段值編寫，用於輸出；\N字段值被作為NULL讀取，用於輸入（假設ESCAPED BY字元為『\』）。

·         如果FIELDS ENCLOSED BY不是空值，則包含以文字詞語NULL為值的字段被作為NULL值讀取。這與被FIELDS ENCLOSED BY字元包圍的詞語NULL不同。該詞語被作為字串'NULL'讀取。

·         如果FIELDS ESCAPED BY是空值，則NULL被作為詞語NULL寫入。

·         採用固定行格式時（當FIELDS TERMINATED BY和FIELDS ENCLOSED BY均為空值時採用），NULL被作為一個空字串寫入。注意，這會導致在被寫入檔案時，資料表中的NULL值和空字串均無法辨別，這是因為兩者都被作為空字串寫入。如果您需要在讀取檔案並返回時能夠分辨兩者，則您不應使用固定行格式。

LOAD DATA INFILE不支援有些情況：

·         固定規格行（FIELDS TERMINATED BY和FIELDS ENCLOSED BY均為空值）和BLOB或TEXT列。

·         如果您指定了一個分隔符，並且該分隔符與其它的前綴一樣，則LOAD DATA INFILE不能正確地理解輸入值。例如，下面的FIELDS子句會導致問題：

·                FIELDS TERMINATED BY '"' ENCLOSED BY '"'

·         如果FIELDS ESCAPED BY為空值，則包含FIELDS ENCLOSED BY或LINES TERMINATED BY的字段值後面再接FIELDS TERMINATED BY值會導致LOAD DATA INFILE過早地停止讀取一個字段或行。出現這種情況的原因是LOAD DATA INFILE不能正確地決定字段或行值在哪裡結束。

以下的例子載入了persondata資料表中的所有列：

mysql> LOAD DATA INFILE 'persondata.txt' INTO TABLE persondata;

預設情況下，如果在LOAD DATA INFILE語句的末尾處沒有設列清單時，則輸入行預計會包含一個字段，用於資料表中的每個列。如果您只想載入一個資料表的部分列，則應指定一個列清單：

mysql> LOAD DATA INFILE 'persondata.txt'

    ->           INTO TABLE persondata (col1,col2,...);

如果輸入檔案中各字段的順序與資料表中各列的順序不同，您也必須指定一個列清單。否則，MySQL不能把輸入字段和資料表中的列匹配起來。

列清單可以包含列名稱或用戶變數。支援SET子句。這使您可以把輸入值賦予用戶變數，然後在把結果賦予列之前，對這些值進行變換。

SET子句中的用戶變數可以採用多種方式使用。以下例子使用數據檔案中的第一列，直接用於t1.column1的值。在用戶變數被用於t2.column2值之前，把第二列賦予用戶變數。該變數從屬於一個分割運行。

LOAD DATA INFILE 'file.txt'

  INTO TABLE t1

  (column1, @var1)

  SET column2 = @var1/100;

SET子句可以被用於提供不是來源於輸入檔案的值。以下語句把column3設置為當前的日期和時間：

LOAD DATA INFILE 'file.txt'

  INTO TABLE t1

  (column1, column2)

  SET column3 = CURRENT_TIMESTAMP;

您也可以通過把輸入值賦予一個用戶變數，同時不把變數賦予資料表中的列，來丟棄此輸入值：

LOAD DATA INFILE 'file.txt'

  INTO TABLE t1

  (column1, @dummy, column2, @dummy, column3);

列/變數清單和SET子句的使用受到以下限定：

·         在SET子句中的賦值應只含有位於賦值操作符的左側的列名稱。

·         您可以在SET賦值的右側使用子查詢。如果子查詢可以返回一個值，並且此值將被賦予到一個列中，則此子查詢只能是標量子查詢。另外，您不能使用子查詢從一個正在被載入的資料表中選擇。

·         對于于列/變數清單或SET子句，被IGNORE子句忽略的行不被處理。

·         當載入採用固定行格式的數據時，不能使用用戶變數，因為用戶變數沒有顯示寬度。

當處理一個輸入行時，LOAD DATA會依據列/變數清單和SET子句，把行拆分成字段，並使用值。然後，得到的行被插入資料表中。如果有用於資料表的BEFORE INSERT或AFTER INSERT觸發器，則在插入行之前和插入行之後分別啟動觸發器。

如果一個輸入行含有過多的字段，則多餘的字段被忽略，並且警告的數量增加。

如果一個輸入行含有的字段過少，則輸入字段缺失的資料表中的列被設置為預設值。預設值賦值在13.1.5節，「CREATE TABLE語法」中進行了說明。

如果字段值缺失，則對一個空字段值會被按不同方式理解：

·         對於字串類型，列被設置為空字串。

·         對於數字類型，列被設置為0。

·         對於日期和時間類型，列被設置為該類型相應的「zero」。請參見11.3節，「日期和時間類型」。

如果您明確地把一個空字串賦予一個INSERT或UPDATE語句中的字串類型、數字類型或日期或時間類型，則產生的這些值相同。

只有在兩種情況下TIMESTAMP列被設置為當前日期和時間。一種情況時當列有一個NULL值（也就是\N）時；另一種情況是（僅對於第一個TIMESTAMP列），當一個字段清單被指定時，TIMESTAMP列會從字段清單中被略去。

LOAD DATA INFILE把所有的輸入值當作字串，所以您不能按照使用INSERT語句的方式使用ENUM或SET列的數字值。所有的ENUM和SET值必須被指定為字串。

當LOAD DATA INFILE語句結束時，會按以下格式返回一個訊息字串：

Records: 1  Deleted: 0  Skipped: 0  Warnings: 0

如果您正在使用C API，您可以通過使用mysql_info()函數獲取有關語句的訊息。請參見25.2.3.34節，「mysql_info()」。

當值通過INSERT語句被插入時或出現相同情況時，會發生警告（見13.2.4節，「INSERT語法」）。例外情況是，當輸入行中字段過多或過少時，LOAD DATA INFILE也生成警告。這些警告並不儲存；警告的數量只用於指示運行是否良好。

您可以使用SHOW WARNINGS來得到第一批max_error_count警告的清單，作為有關運行錯誤的訊息。請參見13.5.4.22節，「SHOW WARNINGS語法」。

REPLACE [LOW_PRIORITY | DELAYED]

    [INTO] tbl_name [(col_name,...)]

    VALUES ({expr | DEFAULT},...),(...),...

或：

REPLACE [LOW_PRIORITY | DELAYED]

    [INTO] tbl_name

    SET col_name={expr | DEFAULT}, ...

或：

REPLACE [LOW_PRIORITY | DELAYED]

    [INTO] tbl_name [(col_name,...)]

    SELECT ...

REPLACE的運行與INSERT很相像。只有一點除外，如果資料表中的一個舊記錄與一個用於PRIMARY KEY或一個UNIQUE索引的新記錄具有相同的值，則在新記錄被插入之前，舊記錄被刪除。請參見13.2.4節，「INSERT語法」。

注意，除非資料表有一個PRIMARY KEY或UNIQUE索引，否則，使用一個REPLACE語句沒有意義。該語句會與INSERT相同，因為沒有索引被用於確定是否新行複製了其它的行。

所有列的值均取自在REPLACE語句中被指定的值。所有缺失的列被設置為各自的預設值，這和INSERT一樣。您不能從當前行中引用值，也不能在新行中使用值。如果您使用一個例如「SET col_name = col_name + 1」的賦值，則對位於右側的列名稱的引用會被作為DEFAULT(col_name)處理。因此，該賦值相當於SET col_name = DEFAULT(col_name) + 1。

為了能夠使用REPLACE，您必須同時擁有資料表的INSERT和DELETE權限。

REPLACE語句會返回一個數，來指示受影響的行的數目。該數是被刪除和被插入的行數的和。如果對於一個單行REPLACE該數為1，則一行被插入，同時沒有行被刪除。如果該數大於1，則在新行被插入前，有一個或多個舊行被刪除。如果資料表包含多個唯一索引，並且新行複製了在不同的唯一索引中的不同舊行的值，則有可能是一個單一行替換了多個舊行。

受影響的行數可以容易地確定是否REPLACE只新增了一行，或者是否REPLACE也替換了其它行：檢查該數是否為1（新增）或更大（替換）。

如果您正在使用C API，則可以使用mysql_affected_rows()函數獲得受影響的行數。

目前，您不能在一個子查詢中，向一個資料表中更換，同時從同一個資料表中選擇。

以下是所用算法的更詳細的說明（該算法也用於LOAD DATA...REPLACE）：

1.    嘗試把新行插入到資料表中

2.    當因為對於主鍵或唯一關鍵字出現重複關鍵字錯誤而造成插入失敗時：

a.    從資料表中刪除含有重複關鍵字值的衝突行

b.    再次嘗試把新行插入到資料表中

SELECT

    [ALL | DISTINCT | DISTINCTROW ]

      [HIGH_PRIORITY]

      [STRAIGHT_JOIN]

      [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]

      [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]

    select_expr, ...

    [INTO OUTFILE 'file_name' export_options

      | INTO DUMPFILE 'file_name']

    [FROM table_references

    [WHERE where_definition]

    [GROUP BY {col_name | expr | position}

      [ASC | DESC], ... [WITH ROLLUP]]

    [HAVING where_definition]

    [ORDER BY {col_name | expr | position}

      [ASC | DESC] , ...]

    [LIMIT {[offset,] row_count | row_count OFFSET offset}]

    [PROCEDURE procedure_name(argument_list)]

    [FOR UPDATE | LOCK IN SHARE MODE]]

SELECT用於恢復從一個或多個資料表中選擇的行，並可以加入UNION語句和子查詢。請參見13.2.7.2節，「UNION語法
」和13.2.8節，「Subquery語法」。

·         每個select_expr都指示一個您想要恢復的列。

·         table_references指示行從哪個資料表或哪些資料表中被恢復。在13.2.7.1節，「JOIN語法」中對該語法進行了說明。

·         where_definition包括關鍵詞WHERE，後面接一個資料表達式。該資料表達式指示被選擇的行必須滿足的條件。

有的行在計算時未引用任何資料表。SELECT也可以用於恢復這類行。

舉例說明：

mysql> SELECT 1 + 1;

        -> 2

所有被使用的子句必須按語法說明中顯示的順序嚴格地排序。例如，一個HAVING子句必須位於GROUP BY子句之後，並位於ORDER BY子句之前。

·         使用AS alias_name可以為select_expr給定一個別名。此別名用作資料表達式的列名，可以用於GROUP BY、ORDER BY或HAVING子句。例如：

·                mysql> SELECT CONCAT(last_name,', ',first_name) AS full_name

·                    -> FROM mytable ORDER BY full_name;

在為select_expr給定別名時，AS關鍵詞是自選的。前面的例子可以這樣編寫：

mysql> SELECT CONCAT(last_name,', ',first_name) full_name

    -> FROM mytable ORDER BY full_name;

因為AS是自選的，如果您忘記在兩個select_expr資料表達式之間加逗號，則會出現一個小問題：MySQL會把第二個資料表達式理解為一個別名。例如，在以下語句中，columnb被作為別名對待：

mysql> SELECT columna columnb FROM mytable;

因此，使用AS明確地指定列的別名，把它作為習慣，是一個良好的操作規範。

·         在一個WHERE子句中使用列別名是不允許的，因為當執行WHERE子句時，列值可能還沒有被確定。請參見A.5.4節，「與列別名有關的問題」。

·         FROM table_references子句指示行從哪些資料表中被恢復。如果您命名的資料表多於一個，則您在進行一個聯合操作。要瞭解有關聯合語法的說明，請參見13.2.7.1節，「JOIN語法」。對於每一個被指定的資料表，您可以自選地指定一個別名。

·                tbl_name [[AS] alias]

·                    [{USE|IGNORE|FORCE} INDEX (key_list)]

使用USE INDEX、IGNORE INDEX、FORCE INDEX可以向最佳化符提示如何選擇索引。這部分內容在13.2.7.1節，「JOIN語法」中進行了討論。

您可以使用SET max_seeks_for_key=value作為一種替代方法，來促使MySQL優先採用關鍵字掃瞄，替代資料表掃瞄。

·         您可以把當前資料庫中的一個資料表作為tbl_name（在當前資料庫中）引用，或作為db_name.tbl_name引用，來明確地指定一個資料庫。您可以把一列作為col_name, tbl_name.col_name引用或作為db_name.tbl_name.col_name引用。您不需要對一個列引用指定一個tbl_name或db_name.tbl_name前綴，除非此引用意義不明確。意義不明確時，要求指定明確的列引用格式。有關示範見9.2節，「資料庫、資料表、索引、列和別名」。

·         在沒有資料表被引用的情況下，允許您指定DUAL作為一個假的資料表名。

·                mysql> SELECT 1 + 1 FROM DUAL;

·                        -> 2

有些伺服器要求一個FROM子句。DUAL僅用於與這些伺服器兼容。如果沒有資料表被引用，則MySQL不要求該子句，前面的語句可以按以下方法編寫：

mysql> SELECT 1 + 1;

        -> 2

·         使用tbl_name AS alias_name或tbl_name alias_name可以為一個資料表引用起別名：

·                mysql> SELECT t1.name, t2.salary FROM employee AS t1, info AS t2

·                    ->     WHERE t1.name = t2.name;

·                mysql> SELECT t1.name, t2.salary FROM employee t1, info t2

·                    ->     WHERE t1.name = t2.name;

·         在WHERE子句中，您可以使用MySQL支援的所有函數，不過總計（總結）函數除外。請參見第12章：函數和操作符。

·         被選擇的用於輸出的列可以使用列名稱、列別名或列位置被引用到ORDER BY和GROUP BY子句中。列位置為整數，從1開始：

·                mysql> SELECT college, region, seed FROM tournament

·                    ->     ORDER BY region, seed;

·                mysql> SELECT college, region AS r, seed AS s FROM tournament

·                    ->     ORDER BY r, s;

·                mysql> SELECT college, region, seed FROM tournament

·                    ->     ORDER BY 2, 3;

要以相反的順序進行分類，應把DESC（降序）關鍵字新增到ORDER BY子句中的列名稱中。預設值為升序；該值可以使用ASC關鍵詞明確地指定。

不建議使用列位置，因為該語法已經從SQL標準中刪除。

·         如果您使用GROUP BY，則輸出行根據GROUP BY列進行分類，如同您對相同的列進行了ORDER BY。MySQL對GROUP BY進行了延伸，因此您可以在各列（在子句中進行命名）的後面指定ASC和DESC：

·                SELECT a, COUNT(b) FROM test_table GROUP BY a DESC

·         MySQL對GROUP BY的使用進行了延伸，允許選擇在GROUP BY子句中沒有被提到的字段。如果您沒有得到預期的結果，請閱讀GROUP BY的說明，請參見12.10節，「與GROUP BY子句同時使用的函數和修改程式」。

·         GROUP BY允許一個WITH ROLLUP修飾符。請參見12.10.2節，「GROUP BY修改程式」。

·         HAVING子句基本上是最後使用，只位於被發送給客戶端的條目之前，沒有進行最佳化。（LIMIT用於HAVING之後。）

SQL標準要求HAVING必須引用GROUP BY子句中的列或用於總計函數中的列。不過，MySQL支援對此工作性質的延伸，並允許HAVING因為SELECT清單中的列和外部子查詢中的列。

如果HAVING子句引用了一個意義不明確的列，則會出現警告。在下面的語句中，col2意義不明確，因為它既作為別名使用，又作為列名使用：

mysql> SELECT COUNT(col1) AS col2 FROM t GROUP BY col2 HAVING col2 = 2;

標準SQL工作性質具有優先權，因此如果一個HAVING列名既被用於GROUP BY，又被用作輸出列清單中的起了別名的列，則優先權被給予GROUP BY列中的列。

·         HAVING不能用於應被用於WHERE子句的條目。例如，不能編寫如下語句：

·                mysql> SELECT col_name FROM tbl_name HAVING col_name > 0;

而應這麼編寫：

mysql> SELECT col_name FROM tbl_name WHERE col_name > 0;

·         HAVING子句可以引用總計函數，而WHERE子句不能引用：

·                mysql> SELECT user, MAX(salary) FROM users

·                    ->     GROUP BY user HAVING MAX(salary)>10;

（在有些較早版本的MySQL中，本語句不運行。）

·         LIMIT子句可以被用於限制被SELECT語句返回的行數。LIMIT取一個或兩個數字自變數，自變數必須是非負的整數常數（當使用已預備的語句時除外）。

使用兩個自變數時，第一個自變數指定返回的第一行的偏移量，第二個自變數指定返回的行數的最大值。初始行的偏移量為0（不是1）：

mysql> SELECT * FROM tbl LIMIT 5,10;  # Retrieve rows 6-15

為了與PostgreSQL兼容，MySQL也支援LIMIT row_count OFFSET offset語法。

如果要恢復從某個偏移量到結果集合的末端之間的所有的行，您可以對第二個參數是使用比較大的數。本語句可以恢復從第96行到最後的所有行：

mysql> SELECT * FROM tbl LIMIT 95,18446744073709551615;

使用1個自變數時，該值指定從結果集合的開頭返回的行數：

mysql> SELECT * FROM tbl LIMIT 5;     # Retrieve first 5 rows

換句話說，LIMIT n與LIMIT 0,n等價。

對於已預備的語句，您可以使用位置保持符。以下語句將從tb1資料表中返回一行：

mysql> SET @a=1;

mysql> PREPARE STMT FROM "SELECT * FROM tbl LIMIT ?";

mysql> EXECUTE STMT USING @a;

以下語句將從tb1資料表中返回第二到第六行：

mysql> SET @skip=1; SET @numrows=5;

mysql> PREPARE STMT FROM "SELECT * FROM tbl LIMIT ?, ?";

mysql> EXECUTE STMT USING @skip, @numrows;

·         SELECT...INTO OUTFILE 'file_name'形式的SELECT可以把被選擇的行寫入一個檔案中。該檔案被建立到伺服器主機上，因此您必須擁有FILE權限，才能使用此語法。file_name不能是一個原有的檔案。原有檔案會阻止例如「/etc/passwd」的檔案和資料庫資料表被銷毀。

SELECT...INTO OUTFILE語句的主要作用是讓您可以非常快速地把一個資料表轉儲到伺服器機器上。如果您想要在伺服器主機之外的部分客戶主機上建立結果檔案，您不能使用SELECT...INTO OUTFILE。在這種情況下，您應該在客戶主機上使用比如「mysql –e "SELECT ..." > file_name」的命令，來生成檔案。

SELECT...INTO OUTFILE是LOAD DATA INFILE的補語；用於語句的exort_options部分的語法包括部分FIELDS和LINES子句，這些子句與LOAD DATA INFILE語句同時使用。請參見13.2.5節，「LOAD DATA INFILE語法」。

FIELDS ESCAPED BY用於控制如何寫入特殊字元。如果FIELDS ESCAPED BY字元不是空字元，則被用於在輸出中對以下字元設前綴：

o        FIELDS ESCAPED BY字元

o        FIELDS [OPTIONALLY] ENCLOSED BY字元

o        FIELDS TERMINATED BY和LINES TERMINATED BY值的第一個字元

o        ASCII 0（在編寫時接在轉義符後面的是ASCII 『0』，而不是一個零值字節）

如果FIELDS ESCAPED BY字元是空字元，則沒有字元被轉義，並且NULL被作為NULL輸出，而不是作為\N輸出。指定一個空的轉義符不是一個好的主意。特別是當您的數據中的字段值包含剛被給予的清單中的字元時，更是如此。

其原因是您必須對所有FIELDS TERMINATED BY, ENCLOSED BY, ESCAPED BY或LINES TERMINATED BY字元進行轉義，才能可靠地讀取檔案並返回。ASCII NUL被轉義，以便更容易地使用調頁程式觀看。

生成的檔案不必符合SQL語法，所以沒有其它的字元需要被轉義。

在下面的例子中，生成一個檔案，各值用逗號隔開。這種格式可以被許多程式使用。

SELECT a,b,a+b INTO OUTFILE '/tmp/result.text'

FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'

LINES TERMINATED BY '\n'

FROM test_table;

·         如果您使用INTO DUMPFILE代替INTO OUTFILE，則MySQL只把一行寫入到檔案中，不對任何列或行進行終止，也不執行任何轉義處理。如果您想要把一個BLOB值儲存到檔案中，則這個語句是有用的。

·         註釋：任何由INTO OUTFILE或INTO DUMPFILE建立的檔案都可以被伺服器主機上的所有用戶編寫。原因是，MySQL伺服器不能建立這樣的檔案，即檔案的所有者不是該檔案運行時所屬的用戶（任何時候，您都不能出於此原因或出於其它原因把mysqld作為根段運行）。該檔案必須是全局可寫的，這樣您就可以操作其中的內容。

·         有的過程應在結果集合內處理數據。PROCEDURE子句用於對這些過程進行命名。要瞭解示範，請參見27.3.1節，「步驟分析」。

·         儲存引擎使用頁面或行鎖。如果您對儲存引擎使用FOR UPDATE，則受到查詢檢驗的行會被進行寫鎖定，直到當前事務結束為止。使用LOCK IN SHARE MODE可以設置一個共享鎖。共享鎖可以防止其它事務更新或刪除被檢驗的行。請參見15.2.10.5節，「鎖定讀取SELECT ... FOR UPDATE和SELECT ... LOCK IN SHARE MODE」。

在SELECT關鍵詞的後面，您可以使用許多選項。這些選項可以影響語句的運行。

ALL, DISTINCT和DISTINCTROW選項指定是否重複行應被返回。如果這些選項沒有被給定，則預設值為ALL（所有的匹配行被返回）。DISTINCT和DISTINCTROW是同義詞，用於指定結果集合中的重複行應被刪除。

HIGH_PRIORITY, STRAIGHT_JOIN和以SQL_為開頭的選項是MySQL相對於標準SQL的延伸。

·         HIGH_PRIORITY給予SELECT更高的優先權，高於用於更新資料表的語句。您應該只對查詢使用HIGH_PRIORITY。查詢速度非常快，而且立刻被執行。SELECT HIGH_PRIORITY查詢在資料表被鎖定用於讀取時被發出。即使有一個新的語句正在等待資料表變為空閒，查詢也會運行。

HIGH_PRIORITY不能和SELECT語句同時使用。SELECT語句是UNION的一部分。

·         STRAIGHT_JOIN用於促使最佳化符把資料表聯合在一起，順序按照這些資料表在FROM子句中排列的順序。如果最佳化符聯合資料表時順序不佳，您可以使用STRAIGHT_JOIN來加快查詢的速度。請參見7.2.1節，「EXPLAIN語法（獲取關於SELECT的訊息）」。STRAIGHT_JOIN也可以被用於table_references清單中。請參見13.2.7.1節，「JOIN語法」。

·         SQL_BIG_RESULT可以與GROUP BY或DISTINCT同時使用，來告知最佳化符結果集合有很多行。在這種情況下，MySQL直接使用以磁盤為基礎的臨時資料表（如果需要的話）。在這種情況下，MySQL還會優先進行分類，不優先使用臨時資料表。臨時資料表對於GROUP BY組分帶有關鍵字。

·         SQL_BUFFER_RESULT促使結果被放入一個臨時資料表中。這可以幫助MySQL提前解開資料表鎖定，在需要花費較長時間的情況下，也可以幫助把結果集合發送到客戶端中。

·         SQL_SMALL_RESULT可以與GROUP BY或DISTINCT同時使用，來告知最佳化符結果集合是較小的。在此情況下，MySAL使用快速臨時資料表來儲存生成的資料表，而不是使用分類。在MySQL 5.1中，通常不需要這樣。

·         SQL_CALC_FOUND_ROWS告知MySQL計算有多少行應位於結果集合中，不考慮任何LIMIT子句。行的數目可以使用SELECT FOUND_ROWS()恢復。請參見12.9.3節，「訊息函數」。

·         如果您正在使用一個query_cache_type值，值為2或DEMAND，則SQL_CACHE告知MySQL把查詢結果儲存在查詢緩存中。對於使用UNION的查詢或子查詢，本選項會影響查詢中的所有SELECT。請參見5.13節，「MySQL查詢高速緩衝」。

·         SQL_NO_CACHE告知MySQL不要把查詢結果儲存在查詢緩存中。請參見5.13節，「MySQL查詢高速緩衝」。對於一個使用UNION或子查詢的查詢，本選項會影響查詢中的SELECT。

table_references:
    table_reference [, table_reference] …

table_reference:
    table_factor
  | join_table

table_factor:
    tbl_name [[AS] alias]
        [{USE|IGNORE|FORCE} INDEX (key_list)]
  | ( table_references )
  | { OJ table_reference LEFT OUTER JOIN table_reference
        ON conditional_expr }

join_table:
    table_reference [INNER | CROSS] JOIN table_factor [join_condition]
  | table_reference STRAIGHT_JOIN table_factor
  | table_reference STRAIGHT_JOIN table_factor ON condition
  | table_reference LEFT [OUTER] JOIN table_reference join_condition
  | table_reference NATURAL [LEFT [OUTER]] JOIN table_factor
  | table_reference RIGHT [OUTER] JOIN table_reference join_condition
  | table_reference NATURAL [RIGHT [OUTER]] JOIN table_factor

join_condition:
    ON conditional_expr
  | USING (column_list)

SELECT * FROM t1 LEFT JOIN (t2, t3, t4)

                 ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4)

                 ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

·                mysql> SELECT t1.name, t2.salary FROM employee AS t1, info AS t2

·                    ->        WHERE t1.name = t2.name;

·                mysql> SELECT t1.name, t2.salary FROM employee t1, info t2

·                    ->        WHERE t1.name = t2.name;

·                mysql> SELECT table1.* FROM table1

·                    ->        LEFT JOIN table2 ON table1.id=table2.id

·                    ->        WHERE table2.id IS NULL;

·                a LEFT JOIN b USING (c1,c2,c3)

mysql> SELECT * FROM table1,table2 WHERE table1.id=table2.id;

mysql> SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id;

mysql> SELECT * FROM table1 LEFT JOIN table2 USING (id);

mysql> SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id

    ->          LEFT JOIN table3 ON table2.id=table3.id;

mysql> SELECT * FROM table1 USE INDEX (key1,key2)

    ->          WHERE key1=1 AND key2=2 AND key3=3;

mysql> SELECT * FROM table1 IGNORE INDEX (key3)

    ->          WHERE key1=1 AND key2=2 AND key3=3;

CREATE TABLE t1 (i INT, j INT);

CREATE TABLE t2 (k INT, j INT);

INSERT INTO t1 VALUES(1,1);

INSERT INTO t2 VALUES(1,1);

SELECT * FROM t1 NATURAL JOIN t2;

SELECT * FROM t1 JOIN t2 USING (j);

+------+------+------+------+

| i    | j    | k    | j    |

+------+------+------+------+

|    1 |    1 |    1 |    1 |

+------+------+------+------+

+------+------+------+------+

| i    | j    | k    | j    |

+------+------+------+------+

|    1 |    1 |    1 |    1 |

+------+------+------+------+

+------+------+------+

| j    | i    | k    |

+------+------+------+

|    1 |    1 |    1 |

+------+------+------+

+------+------+------+

| j    | i    | k    |

+------+------+------+

|    1 |    1 |    1 |

+------+------+------+

·                SELECT … FROM t1 NATURAL JOIN t2 NATURAL JOIN t3;

SELECT … FROM t1, t2, t3

  WHERE t1.b = t2.b AND t2.c = t3.c;

SELECT … FROM t1, t2, t3

  WHERE t1.b = t2.b AND t2.c = t3.c AND t1.a = t3.a;

CREATE TABLE t1 (i1 INT, j1 INT);

CREATE TABLE t2 (i2 INT, j2 INT);

CREATE TABLE t3 (i3 INT, j3 INT);

INSERT INTO t1 VALUES(1,1);

INSERT INTO t2 VALUES(1,1);

INSERT INTO t3 VALUES(1,1);

SELECT * FROM t1, t2 JOIN t3 ON (t1.i1 = t3.i3);

SELECT * FROM (t1, t2) JOIN t3 ON (t1.i1 = t3.i3);

CREATE TABLE t1 (i1 INT);

CREATE TABLE t2 (i2 INT);

CREATE TABLE t3 (i3 INT);

SELECT * FROM t1 JOIN t2 ON (i1 = i3) JOIN t3;

SELECT * FROM t1 JOIN t2 JOIN t3 ON (i1 = i3);

·                a LEFT JOIN b USING (c1,c2,c3)

·                a LEFT JOIN b ON a.c1=b.c1 AND a.c2=b.c2 AND a.c3=b.c3

o                     COALESCE(a.c1,b.c1), COALESCE(a.c2,b.c2), COALESCE(a.c3,b.c3)

a.c1, a.c2, a.c3, b.c1, b.c2, b.c3

SELECT ...

UNION [ALL | DISTINCT]

SELECT ...

[UNION [ALL | DISTINCT]

SELECT ...]

(SELECT a FROM tbl_name WHERE a=10 AND B=1)

UNION

(SELECT a FROM tbl_name WHERE a=11 AND B=2)

ORDER BY a LIMIT 10;

(SELECT a AS b FROM t) UNION (SELECT ...) ORDER BY b;

(SELECT a AS b FROM t) UNION (SELECT ...) ORDER BY a;

(SELECT a FROM tbl_name WHERE a=10 AND B=1 ORDER BY a LIMIT 10)

UNION

(SELECT a FROM tbl_name WHERE a=11 AND B=2 ORDER BY a LIMIT 10);

mysql> SELECT REPEAT('a',1) UNION SELECT REPEAT('b',10);

+---------------+

| REPEAT('a',1) |

+---------------+

| a             |

| bbbbbbbbbb    |

+---------------+

子查詢是另一個語句中的一個SELECT語句。

MySQL支援SQL標準要求的所有子查詢格式和操作，也支援MySQL特有的幾種特性。

以下是一個子查詢的例子：

SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);

在本例中，SELECT * FROM t1...是外部查詢（或外部語句）,（SELECT column1 FROM t2）是子查詢。我們可以說子查詢嵌套在外部查詢中。實際上，子查詢也可以嵌套在其它子查詢中，嵌套程度可以很深。子查詢必須要位於圓括號中。

子查詢的主要優勢為：

·         子查詢允許結構化的查詢，這樣就可以把一個語句的每個部分隔離開。

·         有些操作需要複雜的聯合和關聯。子查詢提供了其它的方法來執行這些操作。

·         在許多人看來，子查詢是可讀的。實際上，子查詢給予人們使用早期SQL「結構化查詢語言」的原本的想法，這是子查詢的創新。

以下是一個示範語句。該語句顯示了有關子查詢語法的要點。子查詢語法由SQL標準指定並被MySQL支援。

DELETE FROM t1

WHERE s11 > ANY

(SELECT COUNT(*) /* no hint */ FROM t2

WHERE NOT EXISTS

(SELECT * FROM t3

WHERE ROW(5*t2.s1,77)=

(SELECT 50,11*s1 FROM t4 UNION SELECT 50,77 FROM

(SELECT * FROM t5) AS t5)));

一個子查詢會返回一個標量（單一值）、一個行、一個列或一個資料表（一行或多行及一列或多列）。這些子查詢被稱為標量、列、行和資料表子查詢。可返回一個特定種類結果的子查詢經常只被用於特定的語境中，在後面各節中有說明。

有些語句可以使用子查詢。對這些語句的類型基本沒有限定。子查詢可以包括普通SELECT可以包括的任何關鍵詞或子句：DISTINCT, GROUP BY, ORDER BY, LIMIT, 聯合, 索引提示, UNION結構化, 評注和函數等。

有一個限定是，一個子查詢的外部語句必須是以下語句之一：SELECT, INSERT, UPDATE, DELETE, SET或DO。還有一個限定是，目前，您不能在一個子查詢中修改一個資料表，又在同一個資料表中選擇。這適用於DELETE, INSERT, REPLACE和UPDATE語句。在附錄I：特性限制中給出了對子查詢使用的更綜合的討論。

CREATE TABLE t1 (s1 INT, s2 CHAR(5) NOT NULL);

INSERT INTO t1 VALUES(100, 'abcde');

SELECT (SELECT s2 FROM t1);

CREATE TABLE t1 (s1 INT);

INSERT INTO t1 VALUES (1);

CREATE TABLE t2 (s1 INT);

INSERT INTO t2 VALUES (2);

SELECT (SELECT s1 FROM t2) FROM t1;

SELECT UPPER((SELECT s1 FROM t1)) FROM t2;

non_subquery_operand comparison_operator (subquery)

=  >  <  >=  <=  <>

  ... 'a' = (SELECT column1 FROM t1)

SELECT column1 FROM t1

WHERE column1 = (SELECT MAX(column2) FROM t2);

SELECT * FROM t1 AS t

WHERE 2 = (SELECT COUNT(*) FROM t1 WHERE t1.id = t.id);

operand comparison_operator ANY (subquery)

operand IN (subquery)

operand comparison_operator SOME (subquery)

SELECT s1 FROM t1 WHERE s1 > ANY (SELECT s1 FROM t2);

SELECT s1 FROM t1 WHERE s1 = ANY (SELECT s1 FROM t2);

SELECT s1 FROM t1 WHERE s1 IN    (SELECT s1 FROM t2);

SELECT s1 FROM t1 WHERE s1 <> ANY  (SELECT s1 FROM t2);

SELECT s1 FROM t1 WHERE s1 <> SOME (SELECT s1 FROM t2);

operand comparison_operator ALL (subquery)

SELECT s1 FROM t1 WHERE s1 > ALL (SELECT s1 FROM t2);

SELECT * FROM t1 WHERE 1 > ALL (SELECT s1 FROM t2);

SELECT * FROM t1 WHERE 1 > (SELECT s1 FROM t2);

SELECT * FROM t1 WHERE 1 > ALL (SELECT MAX(s1) FROM t2);

SELECT s1 FROM t1 WHERE s1 <> ALL (SELECT s1 FROM t2);

SELECT s1 FROM t1 WHERE s1 NOT IN (SELECT s1 FROM t2);

SELECT * FROM t1 WHERE (1,2) = (SELECT column1, column2 FROM t2);

SELECT * FROM t1 WHERE ROW(1,2) = (SELECT column1, column2 FROM t2);

  SELECT * FROM t1 WHERE (column1,column2) = (1,1);

  SELECT * FROM t1 WHERE column1 = 1 AND column2 = 1;

SELECT column1,column2,column3

FROM t1

WHERE (column1,column2,column3) IN

(SELECT column1,column2,column3 FROM t2);

SELECT column1 FROM t1 WHERE EXISTS (SELECT * FROM t2);

·                SELECT DISTINCT store_type FROM stores

·                  WHERE EXISTS (SELECT * FROM cities_stores

·                                WHERE cities_stores.store_type = stores.store_type);

·                SELECT DISTINCT store_type FROM stores

·                  WHERE NOT EXISTS (SELECT * FROM cities_stores

·                                    WHERE cities_stores.store_type = stores.store_type);

·                SELECT DISTINCT store_type FROM stores s1

·                  WHERE NOT EXISTS (

·                    SELECT * FROM cities WHERE NOT EXISTS (

·                      SELECT * FROM cities_stores

·                       WHERE cities_stores.city = cities.city

·                       AND cities_stores.store_type = stores.store_type));

SELECT * FROM t1 WHERE column1 = ANY

(SELECT column1 FROM t2 WHERE t2.column2 = t1.column2);

SELECT column1 FROM t1 AS x

WHERE x.column1 = (SELECT column1 FROM t2 AS x

WHERE x.column1 = (SELECT column1 FROM t3

WHERE x.column2 = t3.column1));

val IN (SELECT key_val FROM tbl_name WHERE correlated_condition)

SELECT ... FROM (subquery) [AS] name ...

CREATE TABLE t1 (s1 INT, s2 CHAR(5), s3 FLOAT);

INSERT INTO t1 VALUES (1,'1',1.0);

INSERT INTO t1 VALUES (2,'2',2.0);

SELECT sb1,sb2,sb3

FROM (SELECT s1 AS sb1, s2 AS sb2, s3*2 AS sb3 FROM t1) AS sb

WHERE sb1 > 1;

SELECT AVG(SUM(column1)) FROM t1 GROUP BY column1;

SELECT AVG(sum_column1)

FROM (SELECT SUM(column1) AS sum_column1

FROM t1 GROUP BY column1) AS t1;

·                ERROR 1241 (ER_OPERAND_COL)

·                SQLSTATE = 21000

·                Message = "Operand should contain 1 column(s)"

SELECT (SELECT column1, column2 FROM t2) FROM t1;

·                ERROR 1242 (ER_SUBSELECT_NO_1_ROW)

·                SQLSTATE = 21000

·                Message = "Subquery returns more than 1 row"

SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);

SELECT * FROM t1 WHERE column1 = ANY (SELECT column1 FROM t2);

·                Error 1093 (ER_UPDATE_TABLE_USED)

·                SQLSTATE = HY000

·                Message = "You can't specify target table 'x'

·                for update in FROM clause"

UPDATE t1 SET column2 = (SELECT MAX(column1) FROM t1);

·                SELECT * FROM t1 WHERE t1.column1 IN

·                (SELECT column1 FROM t2 ORDER BY column1);

·                SELECT * FROM t1 WHERE t1.column1 IN

·                (SELECT DISTINCT column1 FROM t2);

·                SELECT * FROM t1 WHERE EXISTS

·                (SELECT * FROM t2 LIMIT 1);

·                SELECT DISTINCT column1 FROM t1 WHERE t1.column1 IN (

·                SELECT column1 FROM t2);

SELECT DISTINCT t1.column1 FROM t1, t2

WHERE t1.column1 = t2.column1;

·                SELECT * FROM t1

·                WHERE s1 IN (SELECT s1 FROM t1 UNION ALL SELECT s1 FROM t2);

SELECT * FROM t1

WHERE s1 IN (SELECT s1 FROM t1) OR s1 IN (SELECT s1 FROM t2);

SELECT (SELECT column1 + 5 FROM t1) FROM t2;

SELECT (SELECT column1 FROM t1) + 5 FROM t2;

·                SELECT * FROM t1

·                WHERE (column1,column2) IN (SELECT column1,column2 FROM t2);

SELECT * FROM t1

WHERE EXISTS (SELECT * FROM t2 WHERE t2.column1=t1.column1

AND t2.column2=t1.column2);

·                SELECT * FROM t1 WHERE t1.col_name

·                = (SELECT a FROM t2 WHERE b = some_const);

SELECT * FROM t1 WHERE t1.col_name

IN (SELECT a FROM t2 WHERE b = some_const);

·                ... IN (SELECT indexed_column FROM single_table ...)

·                value {ALL|ANY|SOME} {> | < | >= | <=} (non-correlated subquery)

WHERE 5 > ALL (SELECT x FROM t)

WHERE 5 > (SELECT MAX(x) FROM t)

TRUNCATE [TABLE] tbl_name

Single-table語法：

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name

    SET col_name1=expr1 [, col_name2=expr2 ...]

    [WHERE where_definition]

    [ORDER BY ...]

    [LIMIT row_count]

Multiple-table語法：

UPDATE [LOW_PRIORITY] [IGNORE] table_references

    SET col_name1=expr1 [, col_name2=expr2 ...]

    [WHERE where_definition]

UPDATE語法可以用新值更新原有資料表行中的各列。SET子句指示要修改哪些列和要給予哪些值。WHERE子句指定應更新哪些行。如果沒有WHERE子句，則更新所有的行。如果指定了ORDER BY子句，則按照被指定的順序對行進行更新。LIMIT子句用於給定一個限值，限制可以被更新的行的數目。

UPDATE語句支援以下修飾符：

·         如果您使用LOW_PRIORITY關鍵詞，則UPDATE的執行被延遲了，直到沒有其它的客戶端從資料表中讀取為止。

·         如果您使用IGNORE關鍵詞，則即使在更新過程中出現錯誤，更新語句也不會中斷。如果出現了重複關鍵字衝突，則這些行不會被更新。如果列被更新後，新值會導致數據轉化錯誤，則這些行被更新為最接近的合法的值。

如果您在一個資料表達式中通過tbl_name訪問一列，則UPDATE使用列中的當前值。例如，以下語句把年齡列設置為比當前值多一：

mysql> UPDATE persondata SET age=age+1;

UPDATE賦值被從左到右評估。例如，以下語句對年齡列加倍，然後再進行增加：

mysql> UPDATE persondata SET age=age*2, age=age+1;

如果您把一列設置為其當前含有的值，則MySQL會注意到這一點，但不會更新。

如果您把被已定義為NOT NULL的列更新為NULL，則該列被設置到與列類型對應的預設值，並且累加警告數。對於數字類型，預設值為0；對於字串類型，預設值為空字串('')；對於日期和時間類型，預設值為「zero」值。

UPDATE會返回實際被改變的行的數目。Mysql_info() C API函數可以返回被匹配和被更新的行的數目，以及在UPDATE過程中產生的警告的數量。

您可以使用LIMIT row_count來限定UPDATE的範圍。LIMIT子句是一個與行匹配的限定。只要發現可以滿足WHERE子句的row_count行，則該語句中止，不論這些行是否被改變。

如果一個UPDATE語句包括一個ORDER BY子句，則按照由子句指定的順序更新行。

您也可以執行包括多個資料表的UPDATE操作。table_references子句列出了在聯合中包含的資料表。該語法在13.2.7.1節，「JOIN語法」中進行了說明。以下是一個例子：

UPDATE items,month SET items.price=month.price

WHERE items.id=month.id;

以上的例子顯示出了使用逗號操作符的內部聯合，但是multiple-table UPDATE語句可以使用在SELECT語句中允許的任何類型的聯合，比如LEFT JOIN。

註釋：您不能把ORDER BY或LIMIT與multiple-table UPDATE同時使用。

在一個被更改的multiple-table UPDATE中，有些列被引用。您只需要這些列的UPDATE權限。有些列被讀取了，但是沒被修改。您只需要這些列的SELECT權限。

如果您使用的multiple-table UPDATE語句中包含帶有外部鍵限制的InnoDB資料表，則MySQL最佳化符處理資料表的順序可能與上下層級關係的順序不同。在此情況下，語句無效並被 回滾。同時，更新一個單一資料表，並且依靠ON UPDATE功能。該功能由InnoDB提供，用於對其它資料表進行相應的修改。請參見15.2.6.4節，「FOREIGN KEY約束」。

目前，您不能在一個子查詢中更新一個資料表，同時從同一個資料表中選擇。

{DESCRIBE | DESC} tbl_name [col_name | wild]

DESCRIBE可以提供有關資料表中各列的訊息。它是SHOW COLUMNS FROM的快捷方式。這些語句也可以顯示語句，用於閱覽。

見13.5.4.3節，「SHOW COLUMNS語法」。

col_name可以是一個列名稱，或一個包含『％』和『_』的通配符的字串，用於獲得對於帶有與字串相匹配的名稱的各列的輸出。沒有必要在引號中包含字串，除非其中包含空格或其它特殊字元。

mysql> DESCRIBE city;

+------------+----------+------+-----+---------+----------------+

| Field      | Type     | Null | Key | Default | Extra          |

+------------+----------+------+-----+---------+----------------+

| Id         | int(11)  | NO   | PRI | NULL    | auto_increment |

| Name       | char(35) | NO   |     |         |                |

| Country    | char(3)  | NO   | UNI |         |                |

| District   | char(20) | YES  | MUL |         |                |

| Population | int(11)  | NO   |     | 0       |                |

+------------+----------+------+-----+---------+----------------+

5 rows in set (0.00 sec)

NULL字段指示是否NULL可以被儲存在列中。

Key字段指示是否該列已編製索引。PRI的值指示該列是資料表的主鍵的一部分。UNI指示，該列是UNIQUE索引的一部分。MUL值指示，在列中某個給定值多次出現是允許的。

MUL將被顯示在UNIQUE索引中，原因之一是多個列會組合成一個復合UNIQUE索引；儘管列的組合是唯一的，但每個列仍可以多次出現同一個給定值。注意，在復合索引中，只有索引最左邊的列可以進入Key字段中。

預設字段指示，預設值被賦予該列。

Extra字段包含可以獲取的與給定列有關的附加訊息。在我們的例子中，Extra字段指示，Id列使用AUTO_INCREMENT關鍵詞建立。

如果列類型與您預計的依據CREATE TABLE語句得出的列類型不同，則請注意，MySQL有時會改變列類型。請參見13.1.5.1節，「沉寂的列規格變更」。

DESCRIBE語句被設立出來，用於與Oracle相兼容。

SHOW CREATE TABLE和SHOW TABLE STATUS語句也可以提供有關資料表的訊息。請參見13.5.4節，「SHOW語法」。

USE db_name

USE db_name語句可以通告MySQL把db_name資料庫作為預設（當前）資料庫使用，用於後續語句。該資料庫保持為預設資料庫，直到語段的結尾，或者直到發佈一個不同的USE語句：

mysql> USE db1;

mysql> SELECT COUNT(*) FROM mytable;   # selects from db1.mytable

mysql> USE db2;

mysql> SELECT COUNT(*) FROM mytable;   # selects from db2.mytable

使用USE語句為一個特定的當前的資料庫做標記，不會阻礙您訪問其它資料庫中的資料表。下面的例子可以從db1資料庫訪問作者資料表，並從db2資料庫訪問編輯資料表：

mysql> USE db1;

mysql> SELECT author_name,editor_name FROM author,db2.editor

    ->        WHERE author.editor_id = db2.editor.editor_id;

USE語句被設立出來，用於與Sybase相兼容。

START TRANSACTION | BEGIN [WORK]

COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]

ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]

SET AUTOCOMMIT = {0 | 1}

START TRANSACTION或BEGIN語句可以開始一項新的事務。COMMIT可以提交當前事務，是變更成為永久變更。ROLLBACK可以 回滾當前事務，取消其變更。SET AUTOCOMMIT語句可以禁用或啟用預設的autocommit模式，用於當前連接。

自選的WORK關鍵詞被支援，用於COMMIT和RELEASE，與CHAIN和RELEASE子句。CHAIN和RELEASE可以被用於對事務完成進行附加控制。Completion_type系統變數的值決定了預設完成的性質。請參見5.3.3節，「伺服器系統變數」。

AND CHAIN子句會在當前事務結束時，立刻啟動一個新事務，並且新事務與剛結束的事務有相同的隔離等級。RELEASE子句在終止了當前事務後，會讓伺服器中斷與當前客戶端的連接。包含NO關鍵詞可以抑制CHAIN或RELEASE完成。如果completion_type系統變數被設置為一定的值，使連鎖或釋放完成可以預設進行，此時NO關鍵詞有用。

預設情況下，MySQL採用autocommit模式運行。這意味著，當您執行一個用於更新（修改）資料表的語句之後，MySQL立刻把更新儲存到磁盤中。

如果您正在使用一個事務安全型的儲存引擎（如InnoDB, BDB或NDB叢集），則您可以使用以下語句禁用autocommit模式：

SET AUTOCOMMIT=0;

通過把AUTOCOMMIT變數設置為零，禁用autocommit模式之後，您必須使用COMMIT把變更儲存到磁盤中，或著如果您想要忽略從事務開始進行以來做出的變更，使用ROLLBACK。

如果您想要對於一個單一系列的語句禁用autocommit模式，則您可以使用START TRANSACTION語句：

START TRANSACTION;

SELECT @A:=SUM(salary) FROM table1 WHERE type=1;

UPDATE table2 SET summary=@A WHERE type=1;

COMMIT;

使用START TRANSACTION，autocommit仍然被禁用，直到您使用COMMIT或ROLLBACK結束事務為止。然後autocommit模式恢復到原來的狀態。

BEGIN和BEGIN WORK被作為START TRANSACTION的別名受到支援，用於對事務進行初始化。START TRANSACTION是標準的SQL語法，並且是啟動一個ad-hoc事務的推薦方法。BEGIN語句與BEGIN關鍵詞的使用不同。BEGIN關鍵詞可以啟動一個BEGIN...END復合語句。後者不會開始一項事務。請參見20.2.7節，「BEGIN ... END復合語句」。

您也可以按照如下方法開始一項事務：

START TRANSACTION WITH CONSISTENT SNAPSHOT;

WITH CONSISTENT SNAPSHOT子句用於啟動一個一致的讀取，用於具有此類功能的儲存引擎。目前，該子句只適用於InnoDB。該子句的效果與發佈一個START TRANSACTION，後面跟一個來自任何InnoDB資料表的SELECT的效果一樣。請參見15.2.10.4節，「一致的非鎖定讀」。

開始一項事務會造成一個隱含的UNLOCK TABLES被執行。

為了獲得最好的結果，事務應只使用由單一事務儲存引擎管理的資料表執行。否則，會出現以下問題：

·         如果您使用的資料表來自多個事務安全型儲存引擎（例如InnoDB和BDB），並且事務隔離等級不是SERIALIZABLE，則有可能當一個事務提交時，其它正在進行中的、使用同樣的資料表的事務將只會發生由第一個事務產生的變更。也就是，用混合引擎不能保證事務的原子性，並會造成不一致。（如果混合引擎事務不經常有，則您可以根據需要使用SET TRANSACTION ISOLATION LEVEL把隔離等級設置到SERIALIZABLE。）

·         如果您在事務中使用非事務安全型資料表，則對這些資料表的任何變更被立刻儲存，不論autocommit模式的狀態如何。

如果您在更新了事務中一個事務資料表之後，發佈一個ROLLBACK語句，則會出現一個ER_WARNING_NOT_COMPLETE_ROLLBACK警告。對事務安全型資料表的變更被 回滾，但是對非事務安全型資料表沒有變更。

每個事務被儲存在一個組塊中的二進制日誌中，在COMMIT之上。被回滾的事務不被計入日誌。（例外情況：對非事務資料表的更改不會被 回滾。如果一個被回滾的事務包括對非事務資料表的更改，則整個事務使用一個在末端的ROLLBACK語句計入日誌，以確保對這些資料表的更改進行複製。）見5.11.3節，「二進制日誌」。

您可以使用SET TRANSACTION ISOLATION LEVEL更改事務的隔離等級。請參見13.4.6節，「SET TRANSACTION語法」。

回滾可以慢速運行。在用戶沒有明確要求時，也可以進行回滾（例如，當錯誤發生時）。因此，在明確地和隱含的（ROLLBACK SQL命令）回滾時，SHOW PROCESSLIST會在Stage列中顯示Rolling back，用於連接。

有些語句不能被回滾。通常，這些語句包括數據定義語言（DDL）語句，比如建立或取消資料庫的語句，和建立、取消或更改資料表或儲存的子程式的語句。

您在設計事務時，不應包含這類語句。如果您在事務的前部中發佈了一個不能被回滾的語句，則後部的其它語句會發生錯誤，在這些情況下，通過發佈ROLLBACK語句不能 回滾事務的全部效果。

以下語句（以及同義詞）均隱含地結束一個事務，似乎是在執行本語句前，您已經進行了一個COMMIT。

·         ALTER FUNCTION, ALTER PROCEDURE, ALTER TABLE, BEGIN, CREATE DATABASE, CREATE FUNCTION, CREATE INDEX, CREATE PROCEDURE, CREATE TABLE, DROP DATABASE, DROP FUNCTION, DROP INDEX, DROP PROCEDURE, DROP TABLE, LOAD MASTER DATA, LOCK TABLES, RENAME TABLE, SET AUTOCOMMIT=1, START TRANSACTION, TRUNCATE TABLE, UNLOCK TABLES.

·         當當前所有的資料表均被鎖定時，UNLOCK TABLES可以提交事務。

·         CREATE TABLE, CREATE DATABASE DROP DATABASE, TRUNCATE TABLE, ALTER FUNCTION, ALTER PROCEDURE, CREATE FUNCTION, CREATE PROCEDURE, DROP FUNCTION和DROP PROCEDURE等語句會導致一個隱含提交。

·         InnoDB中的CREATE TABLE語句被作為一個單一事務進行處理。這意味著，來自用戶的ROLLBACK不會撤銷用戶在事務處理過程中建立的CREATE TABLE語句。

事務不能被嵌套。這是隱含COMMIT的結果。當您發佈一個START TRANSACTION語句或其同義詞時，該COMMIT被執行，用於任何當前事務。