SQL基础2

三 mysql中的字符串

　　mysql支持多种类型的运算符，来连接表达式的项。这些类型主要包括算术运算符，比较运算符，逻辑运算符和位运算符。

　　3.1 算术运算符

　　mysql支持的算术运算符包括加，减，乘，除和模运算，他们是最常使用，最简单的一类运算符。

　　下面通过几个例子来说明这些运算符的使用方法：

mysql> select 0.1+ 0.3333 ,0.1-0.3333, 0.1*0.3333, 1/2,1%2;
+-------------+------------+------------+--------+------+
| 0.1+ 0.3333 | 0.1-0.3333 | 0.1*0.3333 | 1/2    | 1%2  |
+-------------+------------+------------+--------+------+
|      0.4333 |    -0.2333 |    0.03333 | 0.5000 |    1 |
+-------------+------------+------------+--------+------+
1 row in set (0.06 sec)

　　+运算符用于获得一个或多个值得和。

　　-运算符用于从一个值中减去另一个值。

　　*运算符使数字想乘，得到两个或多个值得乘积。

　　/运算符用一个值除以另一个值得到商

　　%运算符用一个值除以另外一个值得到余数。

　　除法运算和模运算中，如果除数为0，将是非法除数，返回结果为NULL，如下例所示：

mysql> select 1/0, 100%0;
+------+-------+
| 1/0  | 100%0 |
+------+-------+
| NULL |  NULL |
+------+-------+
1 row in set (0.00 sec)

　　对于模运算，还有另外一种表达式，使用MOD(a,b)函数与a%b效果一样：

mysql> select 3%2,mod(3,2);
+------+----------+
| 3%2  | mod(3,2) |
+------+----------+
|    1 |        1 |
+------+----------+
1 row in set (0.00 sec)

　　3.2 比较运算符

　　熟悉了最简单的算术运算符，再来看一下比较运算符。当select语句进行查询时，mysql允许用户对表达式的左边操作数和右边操作数进行比较，比较结果为真，则返回为1，为假则返回0，比较结果不确定则返回NULL。

　　比较运算符可以用于比较数字，字符串和表达式。数字作为浮点数比较，而字符串以不区分大小写的方式进行比较。

 　　“=”运算符，用于比较运算符两侧的操作数是否相等，如果两侧操作数相等返回值为1，否则为0.注意NULL不能用于“=”比较

mysql> select 1=0,1=1,NULL=NULL;
+-----+-----+-----------+
| 1=0 | 1=1 | NULL=NULL |
+-----+-----+-----------+
|   0 |   1 |      NULL |
+-----+-----+-----------+
1 row in set (0.00 sec)

　　“<>”运算符，和“=”相反，如果两侧操作数不等，赋值为1，否则为0.NULL不能用于“<>”比较。

mysql> select 1<>0,1<>1,null<>null;
+------+------+------------+
| 1<>0 | 1<>1 | null<>null |
+------+------+------------+
|    1 |    0 |       NULL |
+------+------+------------+
1 row in set (0.00 sec)

　　“<=>”安全的等于运算符，和“=”类似，在操作数相等时值为1，不同之处在于即使操作的数为NULL也可以正确比较。

mysql> select 1<=>1,2<=>0,0<=>0,NULL<=>NULL;
+-------+-------+-------+-------------+
| 1<=>1 | 2<=>0 | 0<=>0 | NULL<=>NULL |
+-------+-------+-------+-------------+
|     1 |     0 |     1 |           1 |
+-------+-------+-------+-------------+
1 row in set (0.02 sec)

　　“<”运算符，当左侧操作数小于右边操作数时，其返回值为1，否则其值为0.

mysql> select 'a'<'b' ,'a'<'a' ,'a'<'c',1<2;
+---------+---------+---------+-----+
| 'a'<'b' | 'a'<'a' | 'a'<'c' | 1<2 |
+---------+---------+---------+-----+
|       1 |       0 |       1 |   1 |
+---------+---------+---------+-----+
1 row in set (0.00 sec)

　　“<=”运算符，当左侧操作数小于右边操作数时，其返回值为1，否则返回值为0.

mysql>  select 'bdf'<='b','b'<='b' ,0<1;
+------------+----------+-----+
| 'bdf'<='b' | 'b'<='b' | 0<1 |
+------------+----------+-----+
|          0 |        1 |   1 |
+------------+----------+-----+
1 row in set (0.00 sec)

　　“>”运算符，当左侧操作数大于右边操作数时，其返回值为1，否则返回值为0.

　　“<=”运算符，当左侧操作数大于等于右侧操作数时，其返回值为1，否则返回值为0.

　　“between”运算符的使用格式为“a between min and max”，当a大于等于min并且小于max，则返回值为1，否则返回值为0；当操作数a，min,max类型相同时，此表达式等价于（a>=min and a<=max）,当操作数类型不同时，比较会遵循类型转换原则进行转换后，再进行比较运算，下面描述了between的具体用法：

mysql> select 10 between 10 and 20, 9 between 10 and 20;
+----------------------+---------------------+
| 10 between 10 and 20 | 9 between 10 and 20 |
+----------------------+---------------------+
|                    1 |                   0 |
+----------------------+---------------------+
1 row in set (0.00 sec)

　　“in”运算符的使用格式为“a in(value1,value2)”,当a的值存在于列表中时，则整个比较表达式返回值为1，否则返回0.

mysql> select 1 in (1,2,3) , 't' in ('t','a','b','l','e'),0 in (1,2);
+--------------+------------------------------+------------+
| 1 in (1,2,3) | 't' in ('t','a','b','l','e') | 0 in (1,2) |
+--------------+------------------------------+------------+
|            1 |                            1 |          0 |
+--------------+------------------------------+------------+
1 row in set (0.00 sec)

　　“is null”运算符的使用格式为“a is null”，当a的值为null，则返回值为1，否则返回0.

mysql> select 0 is null, null is null;
+-----------+--------------+
| 0 is null | null is null |
+-----------+--------------+
|         0 |            1 |
+-----------+--------------+
1 row in set (0.00 sec)

　　“is not null”运算符的使用格式为“a is not null”.和“is null”相反，当a的值不为null，则返回值为1，否则返回0.

mysql> select 0 is not null, null is not null;
+---------------+------------------+
| 0 is not null | null is not null |
+---------------+------------------+
|             1 |                0 |
+---------------+------------------+
1 row in set (0.00 sec)

　　“like”运算符的使用格式为“a like %123%”,当a中含有字符串123时，则返回值为1，否则返回0.

mysql> select 123456 like '123%',123456 like '%123%',123456 like '%321%';
+--------------------+---------------------+---------------------+
| 123456 like '123%' | 123456 like '%123%' | 123456 like '%321%' |
+--------------------+---------------------+---------------------+
|                  1 |                   1 |                   0 |
+--------------------+---------------------+---------------------+
1 row in set (0.03 sec)

　　“regexp”运算符的使用格式为"str regexp str_pat",当str字符串中含有str_pat相匹配的字符串时，则返回值为1，否则返回0

mysql> select 'abcdef' regexp 'ab' ,'abcdefg' regexp 'k';
+----------------------+----------------------+
| 'abcdef' regexp 'ab' | 'abcdefg' regexp 'k' |
+----------------------+----------------------+
|                    1 |                    0 |
+----------------------+----------------------+
1 row in set (0.00 sec)

　　2.3 逻辑运算符

　　逻辑运算符又叫布尔运算符，来确认表达式的真和假

　　“not”和“！”表示逻辑非，返回和操作数相反的结果：当操作数为0（假），则返回值为1，否则返回为0.但是有一点例外，那就是not null的返回值为null，这一点需要注意。

mysql> select not 0, not 1, not null ;
+-------+-------+----------+
| not 0 | not 1 | not null |
+-------+-------+----------+
|     1 |     0 |     NULL |
+-------+-------+----------+
1 row in set (0.00 sec)

　　“and”和“&&”表示逻辑与运算。当所有操作数均为非零值并且不为null时，计算所得结果为1，当一个或者多个操作数为0时，所得结果为0，操作数中有任何一个为null则返回值为null，如图所示;

mysql> select (1 and 1),(0 and 1) ,(3 and 1 ) ,(1 and null);
+-----------+-----------+------------+--------------+
| (1 and 1) | (0 and 1) | (3 and 1 ) | (1 and null) |
+-----------+-----------+------------+--------------+
|         1 |         0 |          1 |         NULL |
+-----------+-----------+------------+--------------+
1 row in set (0.00 sec)

　　“or”或“||”表示逻辑或运算，当两个操作数均为非NULL值时，如果有任意一个操作数为非零值，则结果为1，否则结果为零。当有一个操作数为NULL时，如另一个操作数为非零值，则结果为1，否则结果为NULL。假如两个操作数均为NULL，则所得结果为NULL，如下图：

mysql> select (1 or 0) ,(0 or 0),(1 or null) ,(1 or 1),(null or null);
+----------+----------+-------------+----------+----------------+
| (1 or 0) | (0 or 0) | (1 or null) | (1 or 1) | (null or null) |
+----------+----------+-------------+----------+----------------+
|        1 |        0 |           1 |        1 |           NULL |
+----------+----------+-------------+----------+----------------+
1 row in set (0.03 sec)

　　“xor”表示逻辑异或，当任意一个操作数为NULL时，返回值为NULL。对于非NULL的操作数，如果两个的逻辑真假值相异，则返回结果1；否则返回0，如下图：

mysql>  select 1 xor 1 ,0 xor 0,1 xor 0,0 xor 1,null xor 1;
+---------+---------+---------+---------+------------+
| 1 xor 1 | 0 xor 0 | 1 xor 0 | 0 xor 1 | null xor 1 |
+---------+---------+---------+---------+------------+
|       0 |       0 |       1 |       1 |       NULL |
+---------+---------+---------+---------+------------+
1 row in set (0.01 sec)

四 常用函数

　　4.1 字符串函数

　　mysql中字符串函数也是最丰富的一类函数，如图：

　　1.concat（s1,s2）函数：把传入的参数连接成一个字符串。

　　下面的例子把“aaa”,“bbb”，“ccc”3个字符串连接成一个字符串“aaabbbccc”。另外，任何字符串与NULL进行连接的结果都是NULL。

mysql> select concat('aaa','bbb','ccc') ,concat('aaa',null);
+---------------------------+--------------------+
| concat('aaa','bbb','ccc') | concat('aaa',null) |
+---------------------------+--------------------+
| aaabbbccc                 | NULL               |
+---------------------------+--------------------+
1 row in set (0.05 sec)

　　insert(str,x,y,instr)函数：将字符串str从x位置开始，y个字符长的子串替换为字符串instr.

　　把字符串“shannxi2020you”中的从第十二个字符开始以后的3个字符替换为“me”。

mysql> select INSERT('shannxi2020you',12,3, 'me')
    -> ;
+-------------------------------------+
| INSERT('shannxi2020you',12,3, 'me') |
+-------------------------------------+
| shannxi2020me                       |
+-------------------------------------+
1 row in set (0.00 sec)

　　left（str,x）和right（str，x）函数：分别返回字符串最左边的x个字符和最右边的x个字符。如果第二个参数是NULL，那么将不返回任何字符串。

　　下面是对字符串“beijing2008”应用函数后的结果。

mysql> SELECT LEFT('beijing2008',7),LEFT('beijing',null),RIGHT('beijing2008',4);
+-----------------------+----------------------+------------------------+
| LEFT('beijing2008',7) | LEFT('beijing',null) | RIGHT('beijing2008',4) |
+-----------------------+----------------------+------------------------+
| beijing               | NULL                 | 2008                   |
+-----------------------+----------------------+------------------------+
1 row in set (0.00 sec)

　　lpad(str,n,pad)和rpad（str,n,pad）函数：用字符串pad对str最左边和最右边进行填充，直到长度为n个字符长度。

　　下面显示了对字符串“2008”和“beijing”分别填充后的结果。

mysql>  select lpad('2008',20,'beijing'),rpad('beijing',20,'2008');
+---------------------------+---------------------------+
| lpad('2008',20,'beijing') | rpad('beijing',20,'2008') |
+---------------------------+---------------------------+
| beijingbeijingbe2008      | beijing2008200820082      |
+---------------------------+---------------------------+
1 row in set (0.00 sec)

　　ltrim(str)和rtrim(str)函数：去掉字符串str左侧和右侧的空格。

　　下面例子中显示了字符串“beijing”加空格进行过滤后的结果

mysql> select ltrim(' |beijing'),rtrim('beijing| ');
+--------------------+--------------------+
| ltrim(' |beijing') | rtrim('beijing| ') |
+--------------------+--------------------+
| |beijing           | beijing|           |
+--------------------+--------------------+
1 row in set (0.00 sec)

　　repeat（str,x）函数：返回str重复x次的结果。

　　下面例子对字符串“mysql”重复显示了3次

mysql> select repeat('mysql ',3);
+--------------------+
| repeat('mysql ',3) |
+--------------------+
| mysql mysql mysql  |
+--------------------+
1 row in set (0.05 sec)

　　strcmp(s1,s2)函数，比较字符串s1和s2的ASCII码值得大小，如果s1比s2小，那么返回-1；如果s1与s2相等，那么返回0；如果s1比时大，那么返回1.如下所示：

mysql> select strcmp('a','b'),strcmp('b','b'),strcmp('c','b');
+-----------------+-----------------+-----------------+
| strcmp('a','b') | strcmp('b','b') | strcmp('c','b') |
+-----------------+-----------------+-----------------+
|              -1 |               0 |               1 |
+-----------------+-----------------+-----------------+
1 row in set (0.04 sec)

　　trim（str）函数：去掉目标字符串的开头和结尾的空格。

　　下面例子中“$ beijing2008 $     ”进行了前后空格的过滤。

mysql> select trim(' $ beijing2008 $ ');
+---------------------------+
| trim(' $ beijing2008 $ ') |
+---------------------------+
| $ beijing2008 $           |
+---------------------------+
1 row in set (0.00 sec)

　　substring(str,x,y)函数：返回从字符串str中的第x位置起y个字符长度的子串。

　　此函数经常用来对给定字符串进行字符串的提取，下图所示：

mysql> select substring('beijing2008',8,4),substring('beijing2008',1,7);
+------------------------------+------------------------------+
| substring('beijing2008',8,4) | substring('beijing2008',1,7) |
+------------------------------+------------------------------+
| 2008                         | beijing                      |
+------------------------------+------------------------------+
1 row in set (0.00 sec)

　　

五 索引的设计和使用

　　5.1 索引概述

　　所有mysql列类型都可以被索引，对相关列使用索引是提高select操作性能的最佳途径。根据存储引擎可以定义每个表的最大索引树和最大索引长度，每个存储引擎对每个表至少支持16个索引，总索引长度至少为256个字节，大多数的存储引擎有更高的限制。

　　myisam和innodb存储引擎的表默认创建的都是BTREE索引。mysql目前还不支持函数索引，但是支持前缀索引，即对索引字段的前n个字符创建索引，前缀索引的长度跟存储引擎有关，对于myisam存储引擎的表，索引长度可以达到1000字节长，而对于innodb存储的表，索引的前缀长度最长是767字节。

　　5.2 设计索引的原则

　　索引的设计可以遵循一些已有的原则，创建索引的时候请尽量考虑符合这些原则，便于提升索引的使用效率，更高效的使用索引。

　　1. 搜索的索引列，不一定是要所选择的列。换句话说，最适合索引的列是出现在where字句中的列，或连接字句中指定的列，而不是出现在select关键字后的选择列表中的列。或者连接句子中指定的列，而不是出现在select关键字后的选择列表中的列。

　　2. 使用唯一索引。考虑到某列中值得分布，索引的列的基数越大，索引的效果越好。例如存放出生日期的列具有不同值，很容易区分各行。而用来记录性别的列，只含有“M”和“F”，则对此列进行索引没有多大用处，因为不管搜索哪个值，都会得出大约一半的行。

　　3. 使用短索引。如果对字符串列进行索引，应该指定一个前缀长度，只要有可能就应该这么做。例如，如果有一个CHAR(200)列，如果在前10个或20个字符内，多数值是唯一的那么就不要对整个列进行索引。对前10个或者20个字符进行索引能够节省大量索引空间，也可能会使查询更快。较少的牵引涉及的磁盘io较少，较短的值比较起来更快，更为重要的事，对于较短的键值，索引高速缓存中的块能容纳更多的键值，因此，mysql也可以在内存中容纳更多的值。这样就增加了找到行而不用读索引中较多块的可能性。

　　4. 利用最左前缀。在创建一个n列的索引时，实际是创建了mysql可利用的n个索引。多列索引可引起几个索引的作用，因为可利用索引中最左边的列集来匹配行。这样的列集称为最左前缀。

　　5. 不要过度索引。不要以为索引“越多越好”，什么东西都用索引是错误的，每个额外的索引都要占用额外的磁盘空间，并降低写操作的性能。在修改表的内容时，索引必须进行更新，有时可能需要重构，因此，索引越多，所花的时间就越长。如果一个索引很少利用或从不使用，那么会不必要的减缓表的修改速度。此外，mysql在生成一个执行计划时，要考虑各个索引，这也要花费时间

　　6. 对于innodb存储引擎的表，记录默认会按照一定的顺序保存，如果有明确定义的主键，则按照主键顺序保存。如果没有主键，但是有唯一索引，那么就是按照唯一索引的顺序进行保存。如果既没有主键又没有唯一索引，那么表中会自动生成一个内部列，按照这个列的顺序保存。按照主键或者内部列进行的访问是最快的，所以innodb表可尽量自己指定主键，当表中同时又几个列都是唯一的，都可以作为主键的时候，要选择最常作为访问条件的列作为主键，提高查询效率。

六 视图

　　mysql从5.0.1版本开始提供视图功能。

　　6.1 什么是视图

　　视图是一种虚拟存在的表，对于使用使用视图的用户来说基本上是透明的。视图并不在数据库中实际存在，行和列数据来定义属兔的查询中使用的表，并且在使用视图时动态生成。

　　视图相对于普通的表的优势主要包括以下几项：

　　1.简单：使用视图的用户完全不需要关心后面对应的表的结构，关联条件和筛选条件，对用户来说已经是过滤好的复合条件的结果集。

　　2.安全：使用视图的用户只能访问他们被允许查询的结果集，对表的权限管理并不能限制某个行某个列，但是通过视图就可以简单的实现。

　　3.数据独立： 一旦视图的结构确定了，可以屏蔽表结构变化对用户的影响，源表增加列对视图没有影响；源表修改列名，则可以通过修改视图来解决，不会造成对访问者的影响。

　　6.2 视图操作

　　视图的操作包括创建或者修改视图，删除视图，以及查看视图定义。

 　　6.2.1 创建或者修改视图

　　创建视图需要有create view的权限，并且对于查询涉及的列有select权限。如果使用create or replace 或者alter修改视图，那么还需要该视图的drop权限。

　　创建视图的语法为：

CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]

　　修改视图的语法为：

ALTER [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
VIEW view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]

　　例如，要创建了视图staff_list_view,可以使用以下命令：

mysql> CREATE OR REPLACE VIEW staff_list_view AS
-> SELECT s.staff_id,s.first_name,s.last_name,a.address
-> FROM staff AS s,address AS a
-> where s.address_id = a.address_id ;
Query OK, 0 rows affected (0.00 sec）

　　mysql视图的定义有一些限制，例如，在from关键字后面不能包含子查询，这和其他数据库是不同的，如果视图是从其他数据库迁移过来的，那么可能需要因此做一些改动，可以将子查询的内容先定义成一个视图，然后对该视图再创建视图就可以实现类似的功能了。

　　视图的可更新性和视图中查询的定义有关系，以下类型的视图是不可更新的。

　　1. 包含以下关键字的sql语句：聚合函数（sum，min，max，count等），distinct，group by,having,union或者union all。

　　2. 常量视图。

　　3. select中包含子查询。

　　4. join。

　　5. from一个不能更新的视图。

　　6. where字句的子查询引用了from字句中的表。

　　例如，以下的视图都是不可更新的：

--包含聚合函数
mysql> create or replace view payment_sum as
-> select staff_id,sum(amount) from payment group by staff_id;
Query OK, 0 rows affected (0.00 sec)
--常量视图
mysql> create or replace view pi as select 3.1415926 as pi;
Query OK, 0 rows affected (0.00 sec)
--select 中包含子查询
mysql> create view city_view as
-> select (select city from city where city_id = 1) ;
Query OK, 0 rows affected (0.00 sec)

　　WITH [CASCADED | LOCAL] CHECK OPTION决定了是否允许更新数据使记录不再满足视图的条件。

　　1. local是只要满足本视图的条件就可以更新；

　　2. caseaded则是满足所有针对该视图的所有视图的条件才可以更新。

　　例如，对payment表创建两层视图，并进行更新操作：

mysql> create or replace view payment_view as
-> select payment_id,amount from payment
-> where amount < 10 WITH CHECK OPTION;
Query OK, 0 rows affected (0.00 sec)
mysql>
mysql> create or replace view payment_view1 as
-> select payment_id,amount from payment_view
-> where amount > 5 WITH LOCAL CHECK OPTION;
Query OK, 0 rows affected (0.00 sec)
mysql>
mysql> create or replace view payment_view2 as
-> select payment_id,amount from payment_view
-> where amount > 5 WITH CASCADED CHECK OPTION;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from payment_view1 limit 1;
+------------+--------+
?
| payment_id | amount |
+------------+--------+
| 3 | 5.99 |
+------------+--------+
1 row in set (0.00 sec)
mysql> update payment_view1 set amount=10
-> where payment_id = 3;
Query OK, 1 row affected (0.03 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> update payment_view2 set amount=10
-> where payment_id = 3;
ERROR 1369 (HY000): CHECK OPTION failed 'sakila.payment_view2'

　　从测试结果可以看出，payment_view1是with local check option的，座椅只要满足本视图的条件就可以更新，但是payment_view2是with cascaded check option的，必须满足针对该视图的所有视图才可以更新，因为更新后记录不再满足payment_view的条件，所以更新操作图示错误退出。

　　6.2.2 查看视图

　　从mysql5.1版本开始，使用show tables命令的时候不仅显示表的名字，同时也会显示视图的名字，而不存在单独显示视图的show views命令。

mysql> use sakila
Database changed
mysql> show tables;
+----------------------------+
| Tables_in_sakila |
+----------------------------+
| staff |
| staff_list |
| store |
+----------------------------+
26 rows in set (0.00 sec)

　　同样，在使用show table status命令的时候，不但可以显示表的信息，同时也可以显示视图的信息。所以，可以通过下面的命令显示视图的信息：

SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern']

　　下面演示的是查看staff_list视图信息的操作：

mysql> show table status like 'staff_list' G
*************************** 1. row ***************************
Name: staff_list
Engine: NULL
Version: NULL
Row_format: NULL
Rows: NULL
Avg_row_length: NULL
Data_length: NULL
Max_data_length: NULL
Index_length: NULL
Data_free: NULL
Auto_increment: NULL
Create_time: NULL
Update_time: NULL
Check_time: NULL
Collation: NULL
Checksum: NULL
Create_options: NULL
Comment: VIEW
1 row in set (0.01 sec)

　　如果需要查询某个视图的函数的定义，可以使用show create view 命令进行查看：

mysql> show create view staff_list G
*************************** 1. row ***************************
View: staff_list
Create View: CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`localhost` SQL SECURITY DEFINER
VIEW  `staff_list`  AS  select  `s`.`staff_id`  AS  `ID`,concat(`s`.`first_name`,_utf8'
',`s`.`last_name`)  AS  `name`,`a`.`address`  AS  `address`,`a`.`postal_code`  AS  `zip
code`,`a`.`phone`  AS  `phone`,`city`.`city`  AS  `city`,`country`.`country`  AS
`country`,`s`.`store_id` AS `SID` from (((`staff` `s` join `address` `a` on((`s`.`address_id`
= `a`.`address_id`))) join `city` on((`a`.`city_id` = `city`.`city_id`))) join `country`
on((`city`.`country_id` = `country`.`country_id`)))
1 row in set (0.00 sec)

　　最后，通过查看表系统 information_schema.views也可以进行视图的查看：

mysql> select * from views where table_name = 'staff_list' G
*************************** 1. row ***************************
TABLE_CATALOG: NULL
TABLE_SCHEMA: sakila
TABLE_NAME: staff_list
VIEW_DEFINITION:  select  `s`.`staff_id`  AS  `ID`,concat(`s`.`first_name`,_utf8'
',`s`.`last_name`)  AS  `name`,`a`.`address`  AS  `address`,`a`.`postal_code`  AS  `zip
code`,`a`.`phone` AS `phone`,`sakila`.`city`.`city` AS `city`,`sakila`.`country`.`country` AS
`country`,`s`.`store_id` AS `SID` from (((`sakila`.`staff` `s` join `sakila`.`address` `a`
on((`s`.`address_id` = `a`.`address_id`))) join `sakila`.`city` on((`a`.`city_id` =
`sakila`.`city`.`city_id`))) join `sakila`.`country` on((`sakila`.`city`.`country_id` =
`sakila`.`country`.`country_id`)))
CHECK_OPTION: NONE
IS_UPDATABLE: YES
DEFINER: root@localhost
SECURITY_TYPE: DEFINER
1 row in set (0.00 sec)

　　6.2.3. 删除视图

　　用户可以一次删除一个或者是多个视图，前提是必须有该视图的drop权限

DROP VIEW [IF EXISTS] view_name [, view_name] ...[RESTRICT | CASCADE]

　　例如删除staff_list视图：

mysql> drop view staff_list;
Query OK, 0 rows affected (0.00 sec)