SELECT语句：选取数据

SQL SELECT 语句用于从表中选取符合条件的数据，该数据以临时表的形式返回，称为结果集。

语法

SELECT 语句的基本语法如下：

SELECT column1, column2, columnN
FROM table_name
WHERE conditions;

column1, column2, columnN 表示选取的列，conditions 表示筛选条件，只有满足条件的数据才会被选取。

WHERE 子句是可选的，可以不写，此时 SELECT 语句将变成下面的形式：

SELECT column1, column2, columnN FROM table_name;

不使用 WHERE 子句意味着没有筛选条件，此时表中的所有数据都将被选取。

此外，如果希望选取所有的列，那么可以使用*代替所有列名，语法如下：

SELECT * FROM table_name;

 WHERE子句：指定查询条件

使用 SQL 从单个表或者多表联合查询数据时，可以使用 WHERE 子句指定查询条件。当给定查询条件时，只有满足条件的数据才会被返回。建议使用 WHERE 子句来过滤记录，以获取必要的结果集。

WHERE 子句不仅可以用在 SELECT 语句中，还可以用在 UPDATE、DELETE 等语句中。

语法

WHERE 子句用于 SELECT 语句时的基本语法如下：

SELECT column1, column2, columnN
FROM table_name
WHERE condition

可以在 condition 条件中使用 >、<、= 等比较运算符，或者使用 AND、OR 等逻辑运算符来指定多个条件，或者使用 LIKE、NOT LIKE 等进行模糊匹配。

 AND和OR运算符

 SQL 中的 AND 和 OR 运算符用来连接多个查询条件，以缩小返回的结果集，它们被称为连接符。

• AND 运算符

AND 运算符用于连接 WHERE 子句中的多个查询条件，只有当这些查询条件都被满足时，数据行（记录）才会被选取。

语法

WHERE 子句中 AND 运算符的基本语法如下：

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

可以使用 AND 运算符连接 N 个条件，只有当这些条件都被满足时，SQL 语句才会奏效。

• OR 运算符

OR 运算符用于连接 WHERE 子句中的多个查询条件，只要满足其中一个条件，数据行（记录）就能被选取。

语法

WHERE 子句中 OR 运算符的基本语法如下：

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

可以使用 OR 运算符连接 N 个条件，只要满足其中一个条件，SQL 语句就奏效。

UPDATE语句：修改数据 

SQL UPDATE 语句用于修改数据表中现有的记录（数据行）。UPDATE 通常和 WHERE 子句一起使用，用以筛选满足条件的记录；如果不使用 WHERE 子句，那么表中所有的记录都将被修改，这往往不是所期望的。

语法

带有 WHERE 子句的 UPDATE 命令的基本语法如下：

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

可以使用 AND 或者 OR 运算符组合多个条件。

SQL DELETE语句：删除数据 

 SQL DELETE 语句用于删除数据表中现有的记录。DELETE 命令通常和 WHERE 子句一起使用，用以删除满足条件的记录；如果不使用 WHERE 子句，那么表中所有的记录都将被删除，这往往不是所期望的。

语法

带有 WHERE 子句的 DELETE 命令的基本语法如下：

DELETE FROM table_name
WHERE [condition];

可以使用 AND 或者 OR 运算符连接多个条件。

LIKE子句：模糊匹配 

SQL LIKE 子句用于在 WHERE 语句中进行模糊匹配，它会将给定的匹配模式和某个字段进行比较，匹配成功则选取，否则不选取。

语法

SQL LIKE 子句的基本语法格式如下：

SELECT FROM table_name WHERE column LIKE 'pattern'

pattern 表示给定的匹配模式。

也可以使用 AND 或者 OR 运算符连接多个条件，例如：

SELECT FROM table_name
WHERE column1 LIKE 'pattern1' AND column2 LIKE 'pattern2'

 TOP子句：限制返回数据的条数

 SQL TOP 子句用于限定要返回的记录的数据，可以是一个具体的数字，也可以是一个百分数。

对于拥有成千上万条记录的大型数据表来说，TOP 子句非常有用，它能够压缩结果集的大小，提高程序查询效率。

注意，并不是所有的数据库都支持 TOP 子句，有些数据库使用其它的等价语句来替代，例如：

• MySQL 使用 LIMIT 子句获取指定数量的记录；
• Oracle 使用 ROWNUM 子句获取指定数量的记录。

语法

SELECT 语句中的 TOP 子句的基本语法如下：

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

 ORDER BY子句：排序

SQL ORDER BY 子句用于根据一个或者多个字段对查询结果（结果集）进行排序，可以是降序，也可以是升序。默认情况下，大部分数据库将查询结果按照升序排序。

语法

ORDER BY 子句的基本语法如下所示：

SELECT column_list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

可以在 ORDER BY 子句中指定多个用于排序的字段，它们之间以逗号,分隔；但是，您应该确保这些字段都位于 column_list 中。

ASC 关键字表示升序，DESC 关键字表示降序；如果不写，大部分数据库默认为 ASC。

GROUP BY子句：分组

SQL GROUP BY 子句用来根据指定的字段对结果集（选取的数据）进行分组，如果某些记录的指定字段具有相同的值，那么它们将被合并为一条数据。通俗地理解，GROUP BY 子句将根据指定的字段合并数据行。

借助 SQL 聚合函数，您可以对分组的数据进行再次加工，例如：

• SUM( ) 函数可以对指定字段的值进行求和；
• COUNT( ) 函数可以计算某个分组内数据的条数；
• AVG( ) 函数可以对指定字段的值求平均数。

语法

GROUP BY 子句的基本语法如下：

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

GROUP 子句使用说明：

• GROUP BY 子句需要和 SELECT 语句一起使用；
• 如果有 WHERE 子句，那么 WHERE 子句需要放在 GROUP BY 子句之前；
• 如果有 ORDER BY 子句，那么 ORDER BY 子句需要放在 GROUP 子句之后。

 DISTINCT关键字：删除重复记录

SQL DISTINCT 关键字需要和 SELECT 语句一起使用，用来删除结果集中所有重复的记录，仅保留唯一的一条记录。

数据表中有时候会有重复的记录，如果您只需要其中一条，就可以使用 DISTINCT 关键字。

语法

DISTINCT 关键字的基本语法格式如下：

SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]

 NULL：空值

在 SQL 中，关键字 NULL 用来表示缺失的值，也即空值，或者没有值。NULL 值不等同于零值，也不等同于包含空格的字段，理解这一点非常重要。

表的字段默认允许存放 NULL 值，这意味着，您在插入记录或者更新记录时，可以不为该字段指定值，此时该字段将存储 NULL 值。

在查询结果中，空值将显示为空白或者 NULL，如下所示：

sir_name	name	marks
TYAGI	SEEMA	NULL
SINGH	RAMAN	5.5
SHARMA	AMAR	NULL
JAISWAL	VICKY	6

第一条和第三条记录的 MARKS 字段就出现了 NULL 值。

语法

在创建数据表时可以指定某个字段是否允许为 NULL，基本语法如下：

CREATE TABLE website (

id INT NOT NULL AUTO_INCREMENT,

name VARCHAR(20) NOT NULL,

url VARCHAR(30),

age TINYINT UNSIGNED NOT NULL,

alexa INT UNSIGNED NOT NULL,

uv FLOAT DEFAULT '0',

country CHAR(3) NOT NULL DEFAULT '',

PRIMARY KEY (`id`)

);

NOT NULL 关键字表示不允许该字段为空值，在插入或者更新记录时必须为该字段指定一个具体的值。url 和 uv 两个字段没有使用 NOT NULL 关键字，这意味着它们保持默认，也即允许为 NULL。注意，uv 字段指定了默认值 0，如果不为该字段提供值，它的值将是 0；url 字段没有指定默认值，如果不为该字段提供值，它的值将是 NULL。

NOT NULL：非空约束 

默认情况下，表的字段可以包含 NULL 值，如果不希望某个字段出现 NULL 值，那么可以在该字段上添加 NOT NULL 约束（非空约束），此时就必须给该字段指定一个具体的值，不能留空。

注意，NULL 不等于没有数据，而是表示数据是未知的。

 DEFAULT：默认约束

SQL DEFAULT 约束用于给字段指定一个默认值，当使用 INSERT INTO 语句向表中插入数据时，如果没有为该字段提供具体的值，那么就使用这个默认值。

 UNIQUE：唯一约束

 SQL UNIQUE 约束也称“唯一约束”，设置了 UNIQUE 约束的字段，每条记录的值都必须是唯一的，因此 UNIQUE 约束可以防止两条记录在某个字段上出现重复值。例如在 CUSTOMERS 表中，要防止两个或者多个顾客出现相同的姓名。

UNIQUE 可以约束表的一个字段，也可以约束多个字段。此外，设置了 UNIQUE 约束的字段可以出现 NULL 值。

UNIQUE 和 PRIMARY KEY 的区别

• UNIQUE（唯一约束）和 PRIMARY KEY（主键）非常相似，但是 UNIQUE 允许字段中出现一次 NULL 值，而 PRIMARY KEY 不允许出现 NULL 值，因为可以认为：

  PRIMARY KEY = UNIQUE +  NOT NULL

• 一张表可以包含多个 UNIQUE 字段，但是只能有一个主键。

 主键：Primary Key

主键（Primary Key）由表中的一个或者多个字段构成，用来唯一标识表中的每一行记录。可以将主键类比为学号、身份证号、车牌号或者 ID。

主键必须包含唯一值，换句话说，所有记录的主键都不能出现相同的值。此外，主键必须是一个具体的值，不能是 NULL 值。

当主键包含多个字段时，又称为复合键（Composite Primary Key）。

注意事项

在设计主键时，应使用尽可能少的字段，这不但能减少存储空间，还能提升查询性能。主键包含的字段越少，所需要的存储空间就越小，就性能而言，更少的数据意味着更快速地处理。

SQL 规定，主键长度不能超过 900 个字节。Oracle 规定，主键不能超过 32 个字段。

外键：Foreign Key 

SQL 外键（Foreign Key）用于将两个表连接在一起，让两个表的数据保持同步。

外键由表中的一个字段或者多个字段构成，一个表的外键用来指向另一个表的主键（Primary Key）。包含外键的表称为从表，被指向的表称为主表。从表的数据受到主表的约束，向从表中插入或者更新数据时，外键的值必须存在于主表的主键中。

CHECK：检查性约束 

SQL CHECK 约束（检查性约束）用来限制字段的取值范围。您可以在 CHECK 约束中添加限制条件，只有满足这些条件的值才允许进入该字段。

可以为一个字段或者多个字段定义 CHECK 约束。

索引（INDEX）

SQL 索引（Index）用于提高数据表的查询速度。一个表可以创建多个索引，一个索引可以包含一个或者多个字段。

不使用索引，数据库引擎将遍历整个表。

从表面上看，索引类似于书的目录，在没有目录的情况下，要从书中查找某项内容就必须阅读全文，而有了目录之后，通过页码就可以很快定位到相关内容。

从本质上看，索引是根据表的一个或者多个字段生成的子表，该子表中的数据已经进行了排序。子表除了包含指定字段中的数据，还包含一个 rowid 列，用于存储当前记录在原始表中的位置。用户无法看到索引，它只是用来加快查询速度。

为了提高查询效率，便于后期维护，索引都是基于某种数据结构而创建的，比如 B+ 树、B- 树、位图等。

索引的使用成本

在表中插入、修改或者删除数据时，数据库引擎也必须维护索引，以保持索引和原始表的同步；也就是说，使用索引是有额外开销的。不适合的索引，或者过多的索引，都会降低插入、修改和删除数据的效率。

索引还会占用磁盘空间，增加 I/O 成本，过多的索引甚至会增加碎片。

鉴于以上两点，使用索引时应该遵循以下几条原则：

• 仅在被频繁检索的字段上创建索引。
• 针对大数据量的表创建索引，而不是针对只有少量数据的表创建索引。
• 通常来说，经常查询的记录数目少于表中总记录数据的 15% 时，可以创建索引。这个比例并不绝对，它与全表扫描速度成反比。
• 尽量不要在有大量重复值得字段上建立索引，比如性别字段、季度字段等。

语法

在某个字段上创建索引的基本语法如下：

CREATE INDEX index_name
ON table_name ( column1, column2.....);

index_name 是索引的名字，以后在删除索引时会用到。

 JOIN：联合表

Join 是“连接”的意思，顾名思义，SQL JOIN 子句用于将两个或者多个表联合起来进行查询。

联合表时需要在每个表中选择一个字段，并对这些字段的值进行比较，值相同的两条记录将合并为一条。联合表的本质就是将不同表的记录合并起来，形成一张新表。当然，这张新表只是临时的，它仅存在于本次查询期间。

数据库中的表可以通过键将彼此联合起来，一个典型的例子是，将一个表的主键和另一个表的外键进行匹配。在表中，每个主键的值都是唯一的，这样做的目的是在不重复每个表中所有记录的情况下，将表之间的数据交叉捆绑在一起。

语法

使用 SQL JOIN 连接两个表的基本语法如下：

SELECT table1.column1, table2.column2...
FROM table1
JOIN table2
ON table1.common_column1 = table2.common_column2;

table1.common_column1 = table2.common_column2 是连接条件，只有满足此条件的记录才会合并为一行。可以使用多个运算符来连接表，例如 =、>、<、<>、<=、>=、!=、BETWEEN、LIKE 或者 NOT，但是最常见的是使用 =。

当两个表中有同名的字段时，为了帮助数据库引擎区分是哪个表的字段，在书写同名字段名时需要加上表名，表名和字段名以点号.分隔，如下所示：

table_name.column_name

当然，如果书写的字段名在两个表中是唯一的，也可以不使用以上格式，只写字段名即可。

 INNER JOIN：内连接

INNER JOIN 是 SQL 中最重要、最常用的表连接形式，只有当连接的两个或者多个表中都存在满足条件的记录时，才返回行。

SQL INNER JOIN 子句将 table1 和 table2 中的每一条记录进行比较，以找到满足条件的所有记录，然后将每一对满足条件的记录的字段值，合并为一条新的结果行。

INNER JOIN 是默认的表连接方式。当不加任何修饰性的关键字，只写 JOIN 时，默认就是 INNER JOIN 连接。

语法

INNER JOIN 的基本语法如下：

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_column1 = table2.common_column2;

table1.common_column1 = table2.common_column2 是连接条件，只有满足此条件的记录才会合并为一行。

以上 SQL 语句将产生 table1 和 table2 的交集，只有 table1 和 table2 中匹配的行才被返回，如下图所示：
 

LEFT JOIN：左连接 

SQL LEFT JOIN 和 RIGHT JOIN 是相对的，LEFT JOIN 将返回左表（table1）中的所有记录，即使右表（table2）中没有匹配的记录也是如此。当右表中没有匹配的记录时，LEFT JOIN 仍然返回一行，只是该行的左表字段有值，而右表字段以 NULL 填充。

LEFT JOIN 以左表为主，即左表中的所有记录都会被返回，具体分为以下三种情况：

• 如果 table1 中的某条记录在 table2 中刚好只有一条记录可以匹配，那么在返回的结果中会生成一个新的行。
• 如果 table1 中的某条记录在 table2 中有 N 条记录可以匹配，那么在返回结果中也会生成 N 个新的行，这些行所包含的 table1 的字段值是重复的。
• 如果 table1 中的某条记录在 table2 中没有匹配的记录，那么在返回结果中仍然会生成一个新的行，只是该行所包含的 table2 的字段值都是 NULL。

语法

LEFT JOIN 的基本语法如下：

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_column1 = table2.common_column2;

table1.common_column1 = table2.common_column2 是两个表的连接条件。

以上 SQL 语句将产生 table1 的全集，而 table2 中匹配的则有值，不能匹配的则以 NULL 值取代，如下图所示：
 

 RIGHT JOIN：右连接

 SQL RIGHT JOIN 和 LEFT JOIN 是相对的，RIGHT JOIN 将返回右表（table2）中的所有记录，即使左表（table1）中没有匹配的记录也是如此。当左表中没有匹配的记录时，RIGHT JOIN 仍然返回一行，只是该行的右表字段有值，而左表字段以 NULL 填充。

RIGHT JOIN 以右表为主，即右表中的所有记录都会被返回，具体分为以下三种情况：

• 如果 table2 中的某条记录在 table1 中刚好只有一条记录可以匹配，那么在返回的结果中会生成一个新的行。
• 如果 table2 中的某条记录在 table1 中有 N 条记录可以匹配，那么在返回的结果中也会生成 N 个新的行，这些行所包含的 table2 的字段值是重复的。
• 如果 table2 中的某条记录在 table1 中没有匹配记录，那么在返回结果中仍然会生成一个新的行，只是该行所包含的 table1 的字段值都是 NULL。

语法

RIGHT LEFT 的基本语法如下：

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_column1 = table2.common_column2;

table1.common_column1 = table2.common_column2 是两个表的连接条件。

以上 SQL 语句将产生 table2 的全集，而 table1 中匹配的则有值，不能匹配的则以 NULL 值取代，如下图所示：
 

 FULL JOIN：全连接

 SQL FULL JOIN 将返回左表（table1）和右表（table1）中的所有记录，相当于 LEFT JOIN 和 RIGHT JOIN 的叠加。

FULL JOIN 先执行 LEFT JOIN 遍历左表，再执行 RIGHT JOIN 遍历右表，最后将 RIGHT JOIN 的结果直接追加到 LEFT JOIN 后面。注意，FULL JOIN 会返回重复的行，它们会被保留，不会被删除。

语法

FULL JOIN 的基本语法如下：

SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_column1 = table2.common_column2;

table1.common_column1 = table2.common_column2 是两个表的连接条件。

以上 SQL 语句将产生 table1 和 table2 的并集，如下图所示：
 

 SELF JOIN：自连接

SQL SELF JOIN 用于将一个表和自身连接，就好像存在两个表一样。为了区分两个表，在 SQL 语句中需要至少重命名一个表。

自连接通常用于将表的某个字段与该表的同一字段的其它值进行比较。

语法

SELF JOIN 的基本语法如下：

SELECT a.column1, b.column1...
FROM table1 AS a, table1 AS b
WHERE a.common_column < b.common_column;

SQL 并没有 SELF JOIN 关键字，而是使用 WHERE 子句来达到自连接的目的。

CROSS JOIN：交叉连接 

CROSS JOIN 称为“交叉连接”或者“笛卡尔连接”。SQL CROSS JOIN 连接用于从两个或者多个连接表中返回记录集的笛卡尔积，即将左表的每一行与右表的每一行合并。

什么是笛卡尔积？

笛卡尔积（Cartesian product）是指两个集合 A 和 B 的乘积。

例如，A 集合和 B 集合分别包含如下的值：

A = {1,2}
B = {3,4,5}

A×B 和 B×A 的结果集分别表示为：

A×B={(1,3), (1,4), (1,5), (2,3), (2,4), (2,5) };
B×A={(3,1), (3,2), (4,1), (4,2), (5,1), (5,2) };

A×B 和 B×A 的结果就叫做两个集合的笛卡尔积。

从以上结果可以看出：

• 笛卡尔积不满足交换率，即 A×B≠B×A。
• 笛卡尔积的元素个数 = A 集合元素个数 × B 集合元素个数。

语法

笛卡尔连接有两种语法，可以使用 CROSS JOIN 关键字，也可以使用不带 WHERE 子句的 SELECT FROM 命令，如下所示：

#第一种写法
SELECT table1.column1, table2.column2...
FROM table1 CROSS JOIN table2

#第二种写法
SELECT table1.column1, table2.column2...
FROM  table1, table2

第一种写法见名知意，是 SQL 标准推荐的写法。

之所以会产生笛卡尔积，是因为以上两种写法既没有使用 WHERE 子句也没有使用 ON 子句，数据库引擎不知道根据什么条件来连接两个表，也不知道根据什么条件来筛选结果集，只能返回笛卡尔积。如果给 CROSS JOIN 加上 ON 子句或者 WHERE 子句，它返回的结果和 INNER JOIN 是一样的。

UNION和UNION ALL子句

SQL UNION 子句/运算符用于合并两个或者多个 SELECT 语句的结果集。

默认地，UNION 运算符会过滤掉两个结果集中重复的记录，只保留其中一条，也就是对两个结果集进行并集操作；此外，UNION 还会按照默认规则对结果集进行排序。

如果您希望保留原始结果，请使用 UNION ALL。UNION ALL 只是对结果集进行简单粗暴的合并，不会过滤重复的记录，也不会进行排序。

语法

UNION 子句的基本语法如下：

SELECT column1, column2 ...
FROM table1, table2
[WHERE condition1]

UNION / UNION ALL

SELECT column1, column2 ...
FROM table1, table2
[WHERE condition2]

UNION 运算符使用注意事项：

• 每个 SELECT 语句都必须拥有相同数量的字段；
• 不同 SELECT 语句的对应字段必须拥有相似的类型。

不同 SELECT 语句的字段名不需要相同，SQL 会将第一个 SELECT 语句的字段名作为结果集的字段名。

AS：表别名和字段别名 

SQL AS 关键字用于为表或字段起一个临时的别名。别名是临时的，它仅在当前 SQL 语句中奏效，数据库中的实际表名和字段名不会更改。

SELECT 命令的结果集中将显示别名，而不是原始名。

通常在下列情况中使用别名：

• 有两个名字重复的表，需要为其中一个表起一个别名加以区分，比如 SELF JOIN。
• 两个表中有重复的字段名，起别名加以区分。
• 表名/字段名较长，或者可读性差。

语法

表别名的基本语法如下：

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

字段别名的基本语法如下：

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

 ALTER TABLE语句

使用  ALTER TABLE 为表添加一个新字段的基本语法如下：

ALTER TABLE table_name ADD column_name datatype;

使用  ALTER TABLE 删除表中某个字段的基本语法如下：

ALTER TABLE table_name DROP COLUMN column_name;

使用  ALTER TABLE 修改字段数据类型的基本语法如下：

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

使用  ALTER TABLE 添加 NOT NULL 约束的基本语法如下：

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

使用  ALTER TABLE 添加 UNIQUE 约束的基本语法如下：

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

使用  ALTER TABLE 添加 CHECK 约束的基本语法如下：

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

使用  ALTER TABLE 添加主键约束的基本语法如下：

ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

使用  ALTER TABLE 删除 UNIQUE 约束的基本语法如下：

ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;

 TRUNCATE TABLE：清空表

SQL TRUNCATE TABLE 语句用来删除表中的所有记录，也即清空表，它类似于不带 WHERE 子句的 DELETE FROM 语句。

TRUNCATE TABLE 和 DROP TABLE

DROP TABLE 用来删除表，包括删除该表的数据、结构、索引、触发器、约束等所有信息。一旦使用 DROP TABLE 删除了表，则该表的所有信息都将丢失，该表再也无法使用了。如果您希望存储一些数据，就只能重新创建该表。

TRUNCATE TABLE 仅仅删除表的所有记录，表的结构、索引、触发器、约束等将被保留，后续仍然可以使用该表。

TRUNCATE TABLE 和 DELETE FROM

不带 WHERE 子句的 DELETE FROM 语句同样可以达到清空表的效果，但是 TRUNCATE TABLE 使用的系统资源和日志资源更少，因此比 DELETE FROM 更加快速。

DELETE FROM 语句每删除一行，都会在事务日志中为所删除的行记录一项。TRUNCATE TABLE 通过释放表中数据所用的数据页来删除数据，只会在事务日志中记录页的释放。

此外，TRUNCATE TABLE 还能重置具有自动递增（AUTO_INCREMENT）属性的字段，而 DELETE FROM 却不具备该功能。

总结

• 当不再需要该表时，使用 DROP TABLE；
• 当仍要保留该表，只是想删除所有记录时，使用 TRUNCATE TABLE；
• 当要删除部分记录时，使用带有 WHERE 子句的 DELETE FROM。

语法

TRUNCATE TABLE 命令的基本语法如下：

TRUNCATE TABLE  table_name;

table_name 为表名。

视图：CREATE VIEW 

视图（View）是一个由 SELECT 查询所定义出来的虚拟表。

我们知道，SELECT 查询会产生一个包含行和列的结果集，它在结构上和真实的物理表是类似的，可以把这个结果集看做一个临时表或者虚拟表；给结果集起一个名字，放在数据库中供大家使用，它就叫做“视图”了。

语法

在 SQL 中，可以基于一个表、多个表或者另外一个视图来创建新的视图，被视图引用的表通常称为“基础表”。

注意，用户必须拥有足够的权限才能创建视图。

SQL 使用 CREATE VIEW 语句用来创建视图，基本的语法格式如下：

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

view_name 是视图的名字，以后可以通过 view_name 来使用此视图。所谓的视图，就是给某个普通的 SELECT 查询起了一个名字，方便以后使用而已。

子查询（嵌套查询）

子查询也称“内部查询”或者“嵌套查询”，是指将一个 SELECT 查询（子查询）的结果作为另一个 SQL 语句（主查询）的数据来源或者判断条件。

子查询可以嵌入 SELECT、INSERT、UPDATE 和 DELETE 语句中，也可以和 =、<、>、IN、BETWEEN、EXISTS 等运算符一起使用。

子查询常用在 WHERE 子句和 FROM 子句后边：

• 当用于 WHERE 子句时，根据不同的运算符，子查询可以返回单行单列、多行单列、单行多列数据。子查询就是要返回能够作为 WHERE 子句查询条件的值。
• 当用于 FROM 子句时，一般返回多行多列数据，相当于返回一张临时表，这样才符合 FROM 后面是表的规则。这种做法能够实现多表联合查询。

语法

用于 WHERE 子句的子查询的基本语法如下：

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
    (SELECT column_name [, column_name ]
    FROM table1 [, table2 ]
    [WHERE])

子查询需要放在括号( )内。OPERATOR 表示用于 WHERE 子句的运算符。

用于 FROM 子句的子查询的基本语法如下：

SELECT column_name [, column_name ]
FROM (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE]) AS temp_table_name
WHERE  condition

用于 FROM 的子查询返回的结果相当于一张临时表，所以需要使用 AS 关键字为该临时表起一个名字。