.重命名表
ALTER TABLE tbl1 RENAME tbl2;

.重命名表
RENAME TABLE old_table TO backup_table;

重命名多个表
RENAME TABLE old_table TO backup_table, new_table TO old_table;

.把表从一个库移动到另一个库
RENAME TABLE db1.tbl_name TO db2.tbl_name;

.删去字段
ALTER TABLE tbl DROP COLUMN filed1, DROP COLUMN field2;

删除列c：
ALTER TABLE t2 DROP COLUMN c;

.把INTEGER类型的列的名称从old_name变更到new_name
mysql> ALTER TABLE tbl CHANGE old_name new_name INTEGER;


.修改列的类型 (需要列出两次列名)
ALTER TABLE tbl CHANGE filed1 filed1 BIGINT NOT NULL;

或用modify(只需列出一次列名即可)
ALTER TABLE tbl MODIFY field1 BIGINT NOT NULL;


把列a从INTERGER更改为TINYINT NOT NULL（名称保持不变），并把列b从CHAR(10)更改为CHAR(20)，同时把列b重新命名为列c：
ALTER TABLE tbl MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);


.添加列
添加一个新的TIMESTAMP列，名称为d：
ALTER TABLE t2 ADD d TIMESTAMP;

.在列d和列a中添加索引：
ALTER TABLE t2 ADD INDEX (d), ADD INDEX (a);


.创建有名索引
CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name [USING index_type] ON tbl_name (index_col_name,...)

列表(index_col_name,...)用于创建一个多列的组合索引

创建索引时，可以指定var或char类型的前几个字符即可，索引使用列名称的前10个字符。
CREATE INDEX part_of_name ON customer (name(10));

.创建索引时指定类型
部分储存引擎允许在创建索引时指定索引类型。index_type指定语句的语法是USING type_name。
不同的储存引擎所支持的type_name值已显示在下表中。如果列有多个索引类型，当没有指定index_type时，第一个类型是默认值。

存储引擎 允许的索引类型
MyISAM BTREE
InnoDB BTREE
MEMORY/HEAP HASH, BTREE

示例：
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不是保留词，因此会被认为是一个索引名称。


.添加一个新的AUTO_INCREMENT整数列，名称为c：
ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT, ADD PRIMARY KEY (c);


.InnoDB取消外键：
ALTER TABLE tbl DROP FOREIGN KEY fk_symbol;


.要把表默认的字符集和所有字符列（CHAR, VARCHAR, TEXT）改为新的字符集，应使用如下语句：
ALTER TABLE tbl CONVERT TO CHARACTER SET new_charset_name;


.修改列的字符集
ALTER TABLE tbl CHANGE field1 field1 TEXT CHARACTER SET utf8;


.仅仅改变表的默认字符集
ALTER TABLE tbl DEFAULT CHARACTER SET new_charset_name;


.如果InnoDB表在创建时，使用了.ibd文件中的表空间，则这样的文件可以被删除和导入。使用此语句删除.ibd文件：
ALTER TABLE tbl_name DISCARD TABLESPACE;


.要把备份的.ibd文件还原到表中，需把此文件复制到数据库目录中，然后书写此语句：
ALTER TABLE tbl_name IMPORT TABLESPACE;


.ALTER 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向一个没有进行分区的表添加分区。


以采用如下方法取消名称为p0和p1的分区：
ALTER TABLE DROP PARTITION p0, p1;



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;



[注] ADD PARTITION和DROP PARTITION目前不支持IF [NOT] EXISTS
也不可能对一个分区或一个已分区的表进行重命名。
要对一个分区进行重命名，您必须取消分区，再重新建立；
如果您希望对一个已分区的表进行重新命名，您必须取消所有分区，然后对表进行重命名，再添加被取消的分区



.创建表
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(
create_definition1,
create_definition2,
...
)]
[table_options] [select_statement];

或：

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name 
[(] LIKE old_tbl_name [)];


column_definition:
col_name type [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]
[COMMENT ‘string‘] [reference_definition]


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)


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权限。


.字符列的定义可以包括一个CHARACTER SET属性，用来指定字符集，也可以指定列的整序。CHARSET是CHARACTER SET的同义词。
CREATE TABLE t ( 
c CHAR(20) CHARACTER SET utf8 COLLATE utf8_bin
);


对于一个给定的表，您可以使用SHOW CREATE TABLE语句来查看那些列有明确的DEFAULT子句。

COMMENT : 对于列的评注。评注通过SHOW CREATE TABLE和SHOW FULL COLUMNS语句显示。

SERIAL : 属性SERIAL可以用作BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE的别名。

KEY : 通常是INDEX同义词。如果关键字属性PRIMARY KEY在列定义中已给定，则PRIMARY KEY也可以只指定为KEY。
这么做的目的是与其它数据库系统兼容。

UNIQUE : 在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。


.部分存储引擎允许您在创建索引时指定索引类型。index_type指示语句的语法是USING type_name。
CREATE TABLE lookup (
id INT, 
INDEX USING BTREE (id)
)
ENGINE = MEMORY;


.重新设置AUTO_INCREMENT值
ALTER TABLE tbl_name AUTO_INCREMENT = n;


.COMMENT 表的注释，最长60个字符。


.MySQL会对SELECT中的所有项创建新列。举例说明：
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> CREATE TABLE bar (m INT) SELECT n FROM foo;
Query OK, 1 row affected (0.02 sec)

mysql> SELECT * FROM bar;
+------+---+
| m | n |
+------+---+
| NULL | 1 |
+------+---+
1 row in set (0.00 sec)


.删除数据库
DROP {DATABASE | SCHEMA} [IF EXISTS] db_name；


.删除索引
DROP INDEX index_name ON tbl_name;


.删除表
DROP [TEMPORARY] TABLE [IF EXISTS] tbl_name [, tbl_name] ... [RESTRICT | CASCADE]；

例:删除一个表
DROP TABLE IF EXISTS my_tbl1;

删除多个表
DROP TABLE IF EXISTS my_tbl1, my_tbl2;


.可以同时删除许多个表中的行，并使用其它的表进行搜索：
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;


.向表中插入数据语法
INSERT INTO tbl_name (f1, f2, f3) VALUES(val1, val2, val3);


.指定了ON DUPLICATE KEY UPDATE，插入行后会导致在一个UNIQUE索引或PRIMARY KEY中出现重复值，则执行旧行UPDATE。

例如，如果列a被定义为UNIQUE，并且包含值1，则以下两个语句具有相同的效果：
INSERT INTO table (a,b,c) VALUES (1,2,3) ON DUPLICATE KEY UPDATE c=c+1;

INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6) ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);


.Load data导入数据
LOAD DATA INFILE ‘data.txt‘ INTO TABLE db2.my_table;


.如果需要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关键字用于控制这些输入记录的操作。


.如果所有读入的行都含有一个共用前缀，则您可以使用‘prefix_string‘来跳过前缀（和前缀前的字符）。
如果某行不包括前缀，则整个行被跳过。注释：prefix_string会出现在一行的中间。

LOAD DATA INFILE ‘/tmp/test.txt‘ INTO TABLE test LINES STARTING BY "xxx";


.给定别名时，AS关键词是自选的
SELECT CONCAT(last_name,‘, ‘,first_name) AS full_name FROM mytable ORDER BY full_name;
或
SELECT CONCAT(last_name,‘, ‘,first_name) full_name FROM mytable ORDER BY full_name;


.连接表 (您不应对ON部分有任何条件。ON部分用于限定在结果集合中您想要哪些行。但是，您应在WHERE子句中指定这些条件)
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)；


.子查询
SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);


.多步子查询
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 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 NOT 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);

SELECT s1 FROM t1 WHERE s1 > ALL (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);
如果在表t2的一个行中，column1=1并且column2=2，则查询结果均为TRUE。

表达式（1，2）和ROW（1，2）有时被称为行构造符。两者是等同的，在其它的语境中，也是合法的。
例如，以下两个语句在语义上是等同的（但是目前只有第二个语句可以被优化）：

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

行构造符通常用于与对能返回两个或两个以上列的子查询进行比较。

例如，以下查询可以答复请求，“在表t1中查找同时也存在于表t2中的所有的行”：
SELECT column1,column2,column3
FROM t1
WHERE (column1,column2,column3) IN (SELECT column1,column2,column3 FROM t2);


.如果一个子查询返回任何的行，则EXISTS subquery为FALSE。例如：
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);

.完全清空一个表
TRUNCATE TABLE my_tbl;

与DELETE语句不同的是: 对于InnoDB表，如果有需要引用表的外键限制，则TRUNCATE TABLE被映射到DELETE上；
否则使用快速删减（取消和重新创建表）。使用TRUNCATE TABLE重新设置AUTO_INCREMENT计数器，设置时不考虑是否有外键限制。


.事务
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;


.LOCK TABLES和UNLOCK TABLES语法
LOCK TABLES tbl_name [AS alias] {READ [LOCAL] | [LOW_PRIORITY] WRITE}
[, tbl_name [AS alias] {READ [LOCAL] | [LOW_PRIORITY] WRITE}] ...

UNLOCK TABLES

mysql> LOCK TABLE t WRITE, t AS t1 WRITE;
mysql> INSERT INTO t SELECT * FROM t;
ERROR 1100: Table ‘t‘ was not locked with LOCK TABLES
mysql> INSERT INTO t SELECT * FROM t AS t1;
如果您的查询使用一个别名引用一个表，那么您必须使用同样的别名锁定该表。如果没有指定别名，则不会锁定该表。

mysql> LOCK TABLE t READ;
mysql> SELECT * FROM t AS myalias;
ERROR 1100: Table ‘myalias‘ was not locked with LOCK TABLES
相反的，如果您使用一个别名锁定一个表，您必须使用该别名在您的查询中引用该表。

mysql> LOCK TABLE t AS myalias READ;
mysql> SELECT * FROM t;
ERROR 1100: Table ‘t‘ was not locked with LOCK TABLES
mysql> SELECT * FROM t AS myalias


果您正在使用MySQL中的一个不支持事务的存储引擎，则如果您想要确定在SELECT和UPDATE之间没有其它线程，您必须使用LOCK TABLES。本处所示的例子要求LOCK TABLES，以便安全地执行：

mysql> LOCK TABLES trans READ, customer WRITE;
mysql> SELECT SUM(value) FROM trans WHERE customer_id=some_id;
mysql> UPDATE customer
-> SET total_value=sum_from_previous_statement
-> WHERE customer_id=some_id;
mysql> UNLOCK TABLES;
如果没有LOCK TABLES，有可能另一个线程会在执行SELECT和UPDATE语句之间在trans表中插入一个新行。


.分析表
ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...


.CHECK TABLE语法
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
option = {QUICK | FAST | MEDIUM | EXTENDED | CHANGED}


.OPTIMIZE TABLE语法
OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...

如果您已经删除了表的一大部分，或者如果您已经对含有可变长度行的表（含有VARCHAR, BLOB或TEXT列的表）进行了很多更改，则应使用OPTIMIZE TABLE。被删除的记录被保持在链接清单中，后续的INSERT操作会重新使用旧的记录位置。您可以使用OPTIMIZE TABLE来重新利用未使用的空间，并整理数据文件的碎片。

在多数的设置中，您根本不需要运行OPTIMIZE TABLE。即使您对可变长度的行进行了大量的更新，您也不需要经常运行，每周一次或每月一次即可，只对特定的表运行。

OPTIMIZE TABLE只对MyISAM, BDB和InnoDB表起作用。

对于MyISAM表，OPTIMIZE TABLE按如下方式操作：

1.如果表已经删除或分解了行，则修复表。
2.如果未对索引页进行分类，则进行分类。
3.如果表的统计数据没有更新（并且通过对索引进行分类不能实现修复），则进行更新。

对于BDB表，OPTIMIZE TABLE目前被映射到ANALYZE TABLE上。对于InnoDB表，OPTIMIZE TABLE被映射到ALTER TABLE上，这会重建表。重建操作能更新索引统计数据并释放成簇索引中的未使用的空间。

使用—skip-new或—safe-mode选项可以启动mysqld。通过启动mysqld，您可以使OPTIMIZE TABLE对其它表类型起作用。

注意，在OPTIMIZE TABLE运行过程中，MySQL会锁定表。

OPTIMIZE TABLE语句被写入到二进制日志中，除非使用了自选的NO_WRITE_TO_BINLOG关键词（或其别名LOCAL）。已经这么做了，因此，用于MySQL服务器的OPTIMIZE TABLE命令的作用相当于一个复制主服务器，在默认情况下，这些命令将被复制到复制从属服务器中。



.REPAIR TABLE语法
REPAIR [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ... [QUICK] [EXTENDED] [USE_FRM]


.RESTORE TABLE语法
RESTORE TABLE tbl_name [, tbl_name] ... FROM ‘/path/to/backup/directory‘
用于恢复来自用BACKUP TABLE制作的备份的表。原有的表不会被覆盖；如果您试图覆盖一个原有的表，会发生错误。


.SHOW系列
SHOW [FULL] COLUMNS FROM tbl_name [FROM db_name] [LIKE ‘pattern‘]
SHOW CREATE DATABASE db_name
SHOW CREATE TABLE tbl_name
SHOW DATABASES [LIKE ‘pattern‘]
SHOW ENGINE engine_name {LOGS | STATUS }
SHOW [STORAGE] ENGINES
SHOW ERRORS [LIMIT [offset,] row_count]
SHOW GRANTS [FOR user]
SHOW INDEX FROM tbl_name [FROM db_name]
SHOW INNODB STATUS
SHOW [BDB] LOGS
SHOW PRIVILEGES
SHOW [FULL] PROCESSLIST
SHOW [GLOBAL | SESSION] STATUS [LIKE ‘pattern‘]
SHOW TABLE STATUS [FROM db_name] [LIKE ‘pattern‘]
SHOW [OPEN] TABLES [FROM db_name] [LIKE ‘pattern‘]
SHOW TRIGGERS
SHOW [GLOBAL | SESSION] VARIABLES [LIKE ‘pattern‘]
SHOW WARNINGS [LIMIT [offset,] row_count]

SHOW BINLOG EVENTS
SHOW MASTER LOGS
SHOW MASTER STATUS
SHOW SLAVE HOSTS
SHOW SLAVE STATUS

SHOW PROCESSLIST语法
SHOW [FULL] PROCESSLIST
SHOW PROCESSLIST显示哪些线程正在运行。您也可以使用mysqladmin processlist语句得到此信息。如果您有SUPER权限，您可以看到所有线程。否则，您只能看到您自己的线程（也就是，与您正在使用的MySQL账户相关的线程）。请参见13.5.5.3节，“KILL语法”。如果您不使用FULL关键词，则只显示每个查询的前100个字符。

本语句报告TCP/IP连接的主机名称（采用host_name:client_port格式），以方便地判定哪个客户端正在做什么。

如果您得到“too many connections”错误信息，并且想要了解正在发生的情况，本语句是非常有用的。MySQL保留一个额外的连接，让拥有SUPER权限的 账户使用，以确保管理员能够随时连接和检查系统（假设您没有把此权限给予所有的用户）。

在来自SHOW PROCESSLIST的输出中常见的一些状态：

Checking table 
线程正在执行（自动）表格检查。

Closing tables 
意味着线程正在刷新更改后的表数据，并正在关闭使用过的表。这应该是一个快速的操作。如果不快，则您应该验证您的磁盘没有充满，并且磁盘没有被超负荷使用。

Connect Out 
连接到主服务器上的从属服务器。

Copying to tmp table on disk 
临时结果集合大于tmp_table_size。线程把临时表从存储器内部格式改变为磁盘模式，以节约存储器。

Creating tmp table 
线程正在创建一个临时表，以保持部分结果。

deleting from main table 
服务器正在执行多表删除的第一部分，只从第一个表中删除。

deleting from reference tables 
服务器正在执行多表删除的第二部分，从其它表中删除匹配的行。

Flushing tables 
线程正在执行FLUSH TABLES，并正在等待所有线程，以关闭表。

FULLTEXT initialization 
服务器正在准备执行一个自然语言全文本搜索。

Killed 
有人已经向线程发送了一个KILL命令。在下一次检查终止标记时，应放弃。该标记在MySQL的每个大循环中都检查，但是在有些情况下，线程终止只需要较短的时间。如果该线程被其它线程锁定，则只要其它线程接触锁定，终止操作就会生效。

Locked 
该查询被其它查询锁定。

Sending data 
线程正在为SELECT语句处理行，同时正在向客户端发送数据。

Sorting for group 
线程正在进行分类，以满足GROUP BY要求。

Sorting for order 
线程正在进行分类，以满足ORDER BY要求。

Opening tables 
线程正在试图打开一个表。这应该是非常快的过程，除非打开操作受到阻止。例如，一个ALTER TABLE或一个LOCK TABLE语句可以阻止打开一个表，直到语句完成为止。

Removing duplicates 
查询正在使用SELECT DISTINCT。使用时，在早期阶段，MySQL不能优化不同的操作。因此，MySQL要求一个额外的阶段，以便在把结果发送给客户端之前取消所有的复制行。

Reopen table 
线程得到一个表锁定，但是在得到锁定后被通知带下方的表结构已更改了。它已经释放了锁定，关闭了表，并试图重新打开它。

Repair by sorting 
修复代码正在使用一个分类来创建索引。

Repair with keycache 
修复代码正在通过关键缓存一个接一个地使用创建关键字。这比通过分类修复要慢很多。

Searching rows for update 
线程正在进行第一阶段，以在更新之前，查找所有匹配的行。如果UPDATE正在更改用于查找相关行的索引，则必须这么做。

Sleeping 
线程正在等待客户端，以向它发送一个新语句。

System lock 
线程正在等待得到一个用于表的外部系统锁定。如果您没有正在使用多个正在访问同一个表的mysqld服务器，则您可以使用--skip-external-locking选项禁用系统锁定。

Upgrading lock 
INSERT DELAYED管理程序正在试图得到一个表锁定，以插入行。

Updating 
线程正在搜索行，并正在更新这些行。

User Lock 
线程正在等待GET_LOCK()。

Waiting for tables 
线程得到一个通知，表的底层结构已经改变，需要重新打开表以得到新的结构。但是，为了能重新打开表，必须等待，直到所有其它的线程已经关闭了正在被质询的表。

如果其它线程已经对正在被质询的表使用了FLUSH TABLES或以下语句之一：FLUSH TABLES tbl_name, ALTER TABLE, RENAME TABLE, REPAIR TABLE, ANALYZE TABLE或OPTIMIZE TABLE；则会出现通知。

waiting for handler insert 
INSERT DELAYED管理程序已经处理了所有处于等待状态的插入，并正在等待新插入。

多数状态对应于非常快的操作。如果一个线程在这些状态下停留了数秒，则可能是有问题，需要进行调查。

有一些其它的状态，在前面的清单中没有提及，但是其中有很多状态对于查找服务器中的程序错误是有用的