一、 show 命令
show databases; ——查看模式，数据库
show tables; ——查看所有表格
show columns from biao1; ——查看biao1的数据
describe biao1; ——查看biao1的数据
show grants; ——查看所有用户
show eeors; ——查看错误信息
show warnings; ——查看错误信息
show create database data_name; ——查看数据库的相信信息
show create table table_name; ——查看表格的详细信息
二、 select 命令
1. 普通查询
select 列 from 表名;
select 列,列,列, from 表名; ——查看多列
#使用通配符*虽然可以检索出所有的信息，自己省事，但是会降低检索的效率和应用程序的性能。
2. 检索查询(distinct)
select distinct 列 from 表名; ——查看表中不重复的数据
#如果检查多列，建议不使用distinct，除非多列都不相同，不然会全部检索
3. 限制查询(limit)
select 列名 from 表名 limit 5; ——提取前五行
select 列名 from 表名 limit 5,5; ——前五行不查询，从第六行到第十行
select 列名 from 表名 limit 5 offset 2; ——从行2开始取5行，不包括行2
4. 使用完全限定的表名
select 表名.列名 from 表名; ——通过表名来引入列
select 表名.列名 from 库名.表名; ——通过库名来引入表
三、 排序检索数据
select 列名 from 表名 order by 列名; ——按顺序排序，字符优先->数字->英文
1. 升序排序（aes（默认的））
mysql> select 列1, 列2, 列3 ——需要查询的列
-> from 表名 ——从哪个表里来
-> order by 列2, 列3; ——需要排序的列，正向排序，先排列2，后排列3，列3依照列2排序
-
2. 降序排序 desc（关键字）
mysql> select 列1, 列2, 列3
-> from 表名
-> order by 列2 desc; ——降序排序，列1和列3也会根据列2进行排序
#应用实例，在表格中寻找最贵的
3. mysql> select 列1
-> from 表名
-> order by 列1 desc ——降序排序，必须位于 from 之后
-> limit 1; ——只显示第一行，必须位于 order 之后
四、 过滤数据
1. 运算符
mysql> select prod_name, prod_price ——需要查询的列名
-> from products ——连接表名
-> where prod_price = 2.50; ——查询列prod_price，有没有2.50
#除了等于还可以用: > < != <>(不等于) <= >=
#执行匹配时，不区分大小写
#尽量使数据在数据库端进行过滤，因为到客户端使用程序代码进行过滤，不仅会浪费服务器的资源，也会占用客户机的资源，影响带宽
2. BETMEEN...AND...（范围规定，多少到多少）
mysql> select prod_name, prod_price ——指定列名
-> from products ——指定需要连接的表名
-> where prod_price BETMEEN 5 AND 10; ——输出范围是5到10的商品
3. 判定是否为空NULL
mysql> select user_id ——查看用户id
-> from customers ——连接表
-> where cust_email IS NULL; ——邮箱为空的
输出结果:会输出没有填写邮箱的用户id号
#不能过滤出返回不具有NULL的行，因为未知具有特殊含义，数据库不知道他们是否匹配
#IS NOT NULL是查询非空的行
4. 多重筛选
1) and（并且）
mysql> select prod_id, prod_price, prod_name
-> from products
-> where vend_id = 1003 and prod_price <= 10;
#在表中查找vend_id等于1003，并且prod_price小于等于10的。
2) or（或）
mysql> select vend_id, prod_id, prod_price, prod_name
-> from products
-> where vend_id = 1002 or vend_id = 1003;
#在表中查找vend_id等于1002，或者vend_id等于1003的。
3) and和or组合（and的优先级高）
mysql> select prod_id, prod_price, prod_name
-> from products
-> where (vend_id = 1002 or vend_id = 1003) and prod_price >= 10
#在表中查找vend_id等于1002或者vend_id等于1003的，必须要大于等于10。
4) in（类似于python中的for in），与or同样的功能
mysql> select prod_id, prod_name, prod_price
-> from products
-> where vend_id in (1002,1003)
-> order by prod_id;
#在表中查找vend_id等于1002，或者vend_id等于1003的，并且对prod_id进行顺序排序。
也可与and进行组合
5) not（取反）
mysql> select prod_name, prod_price
-> from products
-> where vend_id not in (1002,1003)
-> order by prod_name desc;
#在表中不查找vend_id等于1002和1003的，并对prod_name进行降序排序。
5. like使用通配符进行过滤
#'%'代表多个字符，'_'只代表一个字符
1) ‘%’在后
mysql> select prod_id, prod_name
-> from products
-> where prod_name like 'jet%'
-> order by prod_name;
#在表中prod_name这一列查找jet开头的字段。
2) ‘%’在两边
mysql> select prod_id, prod_name
-> from products
-> where prod_name like '%anv%';
#在表中查找prod_name这一列中有anv字样的字段。
3) ‘%’在中间
mysql> select prod_id, prod_name
-> from products
-> where prod_name like 's%e';
#在表中prod_name这一列查找以s开头，以e结尾的字段。
4) ‘_’占位符
mysql> select prod_id, prod_name
-> from products
-> where prod_name like '_ ton anvil'; ——这个_占位符，只表示一个字符，查找汉字的话需要两个占位符。
五、 使用MySQL正则表达式（regexp）
#与like不同的是，这个是对整个表进行搜索，而like只对单列进行搜索。
关键字：regexp
1. ’.’表达任何一个字符
mysql> select prod_name
-> from products
-> where prod_name regexp '.000'
-> order by prod_name;
#'.'这个字符在MySQL正则表达式是一个特殊的字符，它表示匹配任意一个字符。
#搜索其中以.000结尾的prod_name
2. ‘binary’区分大小写
mysql> select prod_name
-> from products
-> where prod_name regexp binary 'JetPack .000';
#因为表达式是不区分大小写的，所以使用binary，搜索其中JetPack 中以000结尾的prod_name。
3. ‘|’与or是同一个意思
mysql> select prod_name
-> from products
-> where prod_name regexp '1000|2000';
#在prod_name这一列中查找1000或者2000的字段。
4. ‘[]’特殊的or与字符串组合的or
1) 几个字符的其中一个
mysql> select prod_name
-> from products
-> where prod_name regexp '[123] Ton';
#在prod_name这一列中查找’1 Ton’,’2 Ton’,’3 Ton’
2) 匹配范围
mysql> select prod_name
-> from products
-> where prod_name regexp '[1-5] Ton';
#在prod_name这一列中查找1-5的 Ton，也可以使用[a-z]
5. ’\\’匹配特殊字符
mysql> select vend_name
-> from vendors
-> where vend_name regexp '\\.';
#匹配特殊字符，必须用\\来做为前导，查找‘_’需要\\_，查找.需要\\.。
6. ‘？’前一个字符为可选
mysql> select prod_name
-> from products
-> where prod_name regexp '\\([0-9] sticks?\\)';
输出：+----------------+
| prod_name |
+----------------+
| TNT (1 stick) |
| TNT (5 sticks) |
+----------------+
7. 定位元字符，使其与like的作用一致
mysql> select prod_name
-> from products
-> where prod_name regexp '^[0-1\\.]';
#’^’这个符号表示了以’.’或者0-1开头的字段。
#’$’表示文件的末尾，[:<:]词的开始，[:>:]词的末尾。
六、 创建拼接字段
1. concat()拼接函数
mysql> select concat (vend_name, '(', vend_country, ')' )
-> from vendors
-> order by vend_name;
#使用concat函数，对字段进行拼接(vend_name(vend_country))
2. Trim去除空格函数
mysql> select concat (RTrim(vend_name), '(', RTrim(vend_country), ')' )
-> from vendors
-> order by vend_name;
#Trim去掉字符串两边的空格，RTrim去掉字符串右边的空格，LTrim去掉字符串左边的空格
3. AS别名函数
mysql> select concat(RTrim(vend_name), '(', RTrim(vend_country), ')' ) AS vend_title
-> from vendors;
#将这个拼接起来的字段没有名字，通过AS来为这个字段起一个别名为vend_title，任何客户机就可以按名引用这个列
mysql> select cust_name, cust_contact
-> from customers AS c, orders AS o, orderitems AS oi
-> where c.cust_id = o.cust_id
-> and oi.order_num = o.order_num
-> and prod_id = 'TNT2';
#为from定义的表名起别名，这样可以缩短sql语句，可以让一条select语句中多次使用相同的表
4. 执行算数计算
mysql> select prod_id, quantity, item_price,
-> quan*item_price AS expanded_price ——进行计算
-> from orderitems
-> where order_num = 20005;
#使用select对数值进行计算，并用AS进行起别名，并且只查询order = 20005的。
#操作符：+ - * /
七、 函数
1. 文本处理函数
1） Upper()将文本格式转为大写
mysql> select vend_name, Upper(vend_name) AS vend_name_upcase
-> from vendors;
#见mysql必知必会的90页
2） lower()将大写字母转换为小写字母
mysql> select lower('ASDAFSDFG');
+--------------------+
| lower('ASDAFSDFG') |
+--------------------+
| asdafsdfg |
+--------------------+
2. 日期处理函数
1） Date查询日期（查询日期）
mysql> select cust_id, order_num
-> from orders
-> where Date(order_date) BETWEEN '2005-09-01' AND '2005-09-30';
#使用Date函数，查找范围为9月1日到30日的数据。
2） Year……Month……Day（查询日期）
mysql> select cust_id, order_num
-> from orders
-> where Year(order_date) = 2005 AND Month(order_date) = 9;
#使用Year函数定义年数为2005，使用Month定义月份为9月。
3） interval给当前日期添加指定的数值
mysql> select date_add('2020/03/24',interval 742 day);
#在原有的基础的日期上添加742天
mysql> select date_add('2020/03/24',interval 2 year);
#在原有的基础上添加2年
4） timestampdiff比较两个日期相差的时间
mysql> select timestampdiff(year,'2000/3/21','2020/3/24');
#获取2000年到2020年所经历的年数
mysql> select timestampdiff(day,'2000/3/21','2020/3/24');
#获取2000年的3月21日到2020年的3月24日过了多少天
5） 获取date数据类型的指定数据
mysql> select year('2020/3/24');
#获取年的数据
mysql> select month('2020/3/24');
#获取月的数据
mysql> select day('2020/3/24');
#获取日的数据
6） date_format()判断日期中的日期为星期几
mysql> select date_format('2020/3/25','%a');
#输出简写英文
mysql> select date_format('2020/3/25','%w');
#输出数字星期几
mysql> select date_format('2020/3/25','%W');
#输出非简写英文
3. 统计函数
1) AVG函数（返回某列的平均值）
mysql> select AVG(prod_price) AS avg_price
-> from products
-> where vend_id = 1005;
#计算prod_price的平均值，并取别名为avg_price，只输出vend_id为1005的产品
2) COUNT函数（返回某列的行数）
mysql> select COUNT(prod_price) AS count_price
-> from products;
#返回prod_price这一列的最大值
#这样会忽略prod_price中的NULL，如果函数的参数为‘*’的话则不会被忽略
3) MAX函数（返回某列的最大值）
mysql> select MAX(prod_price) AS avg_price
-> from products;
#返回prod_price这一列最小的值，并取别名为avg_price
#如果使用MAX来查找字符串中的最大值，则返回的是按照排序方式的最后一个
4) MIN函数（返回某列的最小值）
mysql> select MIN(prod_price) AS min_price
-> from products;
#返回prod_price这一列最小的值
#如果使用MIN来查找字符串中的最小值，则返回的是按照排序方式的最前面的那个
5) SUM函数（返回某列值之和）
mysql> select SUM(prod_price)
-> from products
-> where vend_id = 1005;
#统计vend_id等于1005的和
mysql> select SUM(item_price*quantity) AS total_price
-> from orderitems
-> where order_num = 20005;
#统计item_price乘以quantity的和。
6) 聚集不同值（distinct）
mysql> select AVG(distinct prod_price) AS avg_price
-> from products
-> where vend_id = 1003;
#相同的值只取一个，对vend_id等于1003的求平均数
7) 组合聚集函数
mysql> select count(*) AS num_items,
-> MIN(prod_price) AS min_price,
-> MAX(prod_price) AS max_price,
-> AVG(prod_price) AS avg_price
-> from products;
#对函数进行一起使用，返回行数，最小值，最大值，平均值
4. 字符串处理函数
1) right获取字符串从右数的指定数目字符
mysql> select right('ABCDEFG',3);
+--------------------+
| right('ABCDEFG',3) |
+--------------------+
| EFG |
+--------------------+
2) left获取字符串从左数的指定数目字符
mysql> select left('ABCDEFG',3);
+-------------------+
| left('ABCDEFG',3) |
+-------------------+
| ABC |
+-------------------+
3) substring获取从左边指定位置到指定数量的字符
mysql> select substring('ABCDEFG',3,2); --从第三个开始数两个，包括第三个
+--------------------------+
| substring('ABCDEFG',3,2) |
+--------------------------+
| CD |
+--------------------------+
4) replace指定替换的字符
mysql> select replace('ABCDEFG','C','D'); --将字符串中的C改为D
+----------------------------+
| replace('ABCDEFG','C','D') |
+----------------------------+
| ABDDEFG |
+----------------------------+
八、 分组数据
1. 创建分组（group by）
mysql> select vend_id, sum(prod_price) AS sum_prods
-> from products
-> group by vend_id;
#对数据进行分组输出，按照vend_id进行分组，求出prod_price的和之后。
mysql> select vend_id, sum(prod_price) AS num_prods
-> from products
-> group by vend_id with rollup;
#对数据进行分组，并且NULL也会输出
2. 过滤分组（having）
mysql> select cust_id, count(*) AS orders
-> from orders
-> group by cust_id
-> having count(*) >= 2;
#对数据进行分组，并统计两个以上的订单。
3. having与where的结合
mysql> select vend_id, count(*) AS num_prods
-> from products
-> where prod_price >= 10
-> group by vend_id
-> having count(*) >= 2;
#过滤出prod_price大于10的，再将vend_id进行分组，having再vend_id内找出大于2的同样的数据
4. 分组和排序（group和order）
mysql> select order_num, sum(quantity*item_price) AS ordertotal
-> from orderitems
-> group by order_num
-> having sum(quantity*item_price) >= 50
-> order by ordertotal
-> limit 3;
#对分组的数据进行正向排序，并只取前3个。
九、 子查询
mysql> select cust_id
-> from orders
-> where order_num IN (select order_num
-> from orderitems
-> where prod_id = 'TNT2');
#标红的为子查询，先执行子查询，后执行主语句。
mysql> select cust_name,cust_contact
-> from customers
-> where cust_id in (select cust_id
-> from orders
-> where order_num in (select order_num
-> from orderitems
-> where prod_id = 'TNT2'));
#可以嵌套多个
十、 联结
1. 创建联结
1) 定义：对有联系的字段进行创建联结查询输出。
2) 命令：
mysql> select vend_name, prod_name, prod_price
-> from vendors, products
-> where vendors.vend_id = products.vend_id
-> order by vend_name, prod_name;
#不可以缺少where，如果缺少where会让两个表的数据同时输出，就不是我们想要看到的结果。
#如果没有联结关系的表返回的结果为笛卡儿积，检索出的行的束目将是第一个表中的行数乘以第二个表中的行数
2. 内部联结（inner join…on）
1) 定义：等值联结，基于两个表的相等测试。
2) 命令：
mysql> select vend_name, prod_name, prod_price
-> from vendors inner join products
-> on vendors.vend_id = products.vend_id;
#这是联结条件使用特定的on语句来执行
3. 联结多个表
1) 定义：sql对一条select语句中可以连接的表的数目没有限制，创建联结的基本规则也相同。
2) 命令：
mysql> select prod_name, vend_name, prod_price, quantity
-> from orderitems, products, vendors
-> where products.vend_id = vendors.vend_id
-> and orderitems.prod_id = products.prod_id
-> and order_num = 20005;
#首先通过from列出所有的表，然后通过where定义表与表之间的关系。
#这种处理时非常浪费资源的，因此应该仔细，不要联结不必要的表，联结的越多，性能下降的越厉害。
4. 自联结
1) 定义：自联结可以替换相同表中检索数据的子查询语句，处理联结比处理子查询快得多。
2) 命令：
1. 自联结
mysql> select p1.prod_id, p1.prod_name
-> from products AS p1, products AS p2
-> where p1.vend_id = p2.vend_id
-> and p2.prod_id = 'DTNTR';
2. 子查询
mysql> select prod_id, prod_name
-> from products
-> where vend_id = (select vend_id
-> from products
-> where prod_id = 'DTNTR');
#结果一样但是查询速度不同。
5. 自然联结
1) 定义：自然联结排除多次出现，使每个列只返回一次，我们使用的每
一次联结都是自然联结，很少会使用非自然联结 。
6. 外部联结（left outer join，right outer join）
1) 定义： 选择那些行中没有检索内容的行，也进行输出。这种类型的联结称为外部联结。
2) 命令：
mysql> select customers.cust_id, orders.order_num
-> from customers left outer join orders
-> on customers.cust_id = orders.cust_id;
#输出左边，customers的所有内容，包括没有达到条件的，会显示空值。
3) 输出结果：
+---------+-----------+
| cust_id | order_num |
+---------+-----------+
| 10001 | 20005 |
| 10001 | 20009 |
| 10002 | NULL |
| 10003 | 20006 |
| 10004 | 20007 |
| 10005 | 20008 |
+---------+-----------+
7. 使用带聚合函数的联结
1) 定义：聚合函数与联结一起使用，可以使其不只从单个表中统计数据。
2) 命令：
mysql> select customers.cust_name,
-> customers.cust_id,
-> count(orders.order_num) AS num_ord
-> from customers inner join orders
-> on customers.cust_id = orders.cust_id
-> group by customers.cust_id;
#表中使用count统计函数，统计了通过分组后的结果。
十一、 创建组合查询（union）
1. 使用union
1) 定义：union用于连接多个where称为并或者复合查询，从多个表中检索数据会简单并且高效，如果是自联结，建议使用
2) 命令：
mysql> select vend_id, prod_id, prod_price
-> from products
-> where prod_price <=5
-> union --进行连接上下
-> select vend_id, prod_id, prod_price
-> from products
-> where vend_id in (1001,1002);
#这样自联结使用多重筛选and、or会简单而且高效，如果是多表查询的话就要使用union比较简单高效。
3) 输出结果：
+---------+---------+------------+
| vend_id | prod_id | prod_price |
+---------+---------+------------+
| 1003 | FC | 2.50 |
| 1002 | FU1 | 3.42 |
| 1003 | SLING | 4.49 |
| 1003 | TNT1 | 2.50 |
| 1001 | ANV01 | 5.99 |
| 1001 | ANV02 | 9.99 |
| 1001 | ANV03 | 14.99 |
| 1002 | OL1 | 8.99 |
+---------+---------+------------+
2. 包含或取消重复的行（union all）
1) 定义：union默认会合并重复的行，而在后面加上all则会取消默认，显示所有行，不会合并重复的行
2) 命令：
mysql> select vend_id, prod_id, prod_price
-> from products
-> where prod_price <=5
-> union all
-> select vend_id, prod_id, prod_price
-> from products
-> where vend_id in (1001,1002);
#在union后加上all会显示所有，不会使用默认而隐藏相同的行
3) 输出结果：
+---------+---------+------------+
| vend_id | prod_id | prod_price |
+---------+---------+------------+
| 1003 | FC | 2.50 |
| 1002 | FU1 | 3.42 |
| 1003 | SLING | 4.49 |
| 1003 | TNT1 | 2.50 |
| 1001 | ANV01 | 5.99 |
| 1001 | ANV02 | 9.99 |
| 1001 | ANV03 | 14.99 |
| 1002 | FU1 | 3.42 |
| 1002 | OL1 | 8.99 |
+---------+---------+------------+
3. 对union使用排序（order by）
1) 定义：将排序功能使用到最后，虽然看起来是应用到最后一条select语句，其实是应用到整个结果上
2) 命令：
mysql> select vend_id, prod_id, prod_price
-> from products
-> where prod_price <=5
-> union all
-> select vend_id, prod_id, prod_price
-> from products
-> where vend_id in (1001,1002)
-> order by vend_id;
#在union命令中不能使用多个order by语句
十二、 全文本搜索
概念：只有MyISAM支持全文本搜索，InnoDB不支持全文本搜索，
1. like和正则表达式的限制
1) 性能：通配符和正则表达式很少使用索引，一直是遍历查询，因此，由于被搜索行不断增减，这些搜索可能会非常耗时。
2) 明确控制：使用通配符和正则表达式匹配，必须明确的控制匹配什么和不匹配什么。
3) 智能化的结果：虽然基于通配符和正则表达式的搜索提供了非常灵活的搜索，但是它们都不能提供一种智能化选择结果的方法，只能选择一行，不会返回没有关键字的下一行或者多行。
2. 全文本搜索的优点
1) 上面提到的这些限制都可以通过全文本搜索来解决，全文本搜索不需要查看每一行，不需要处理和分析每个词，创建指定列的时候指定一个词的索引，搜索可以针对这些词进行。
3. 创建全文本搜索支持（fulltext）
1) 定义：
a) 在创建全文本搜索支持的时候需要在表格里定义一个索引。
b) 在创建新表时，应该首先将所有数据导入进去，再将索引添加进去。
2) 命令：
mysql> create table hehe
-> (
-> note_id int not null auto_increment,
-> prod_id char(10) not null,
-> note_date datetime not null,
-> note_text text null,
-> primary key (note_id),
-> fulltext(note_text) --使用fulltext定义索引
-> )engine=myisam; --定义引擎为myisam，只有它可以使用全文本搜索
4. 进行全文本搜索（Match指定列，Against指定词）
1) 定义：Match指定列，Against指定关键词，如果在列中查找到关键词，行中有关键词的，则会返回整行。
2) 命令：
mysql> select note_text
-> from productnotes
-> where match(note_text) against('rabbit');
#match指定列，against指定关键词，返回找到关键词的整段。
5. 全文本搜索结果排序原理分析
1) 定义：在搜索语句中使用select对索引进行查询，而不是where，关键词靠后的要比关键词靠前的等级高，等级高的在等级低的后面。
6. 扩展查询（with query expansion）
1) 定义：对普通查询进行扩展，只要根据关键词查询出的内容都会根据句中的词进行扩展，查询到其他语句，
2) 命令：
mysql> select note_text
-> from productnotes
-> where match(note_text) against('anvils' with query expansion);
7. 布尔文本搜索（in boolean mode）
1) 定义：通过布尔文本搜索可以达到以下细节
a) 要匹配的词
b) 要排斥的词（包含该词则不返回该行，即时它含有指定的词也是如此）
c) 排列提示（指定某些词比较重要，重要的等级更高）
d) 表达式分组
e) 没有定义fulltext索引也可以使用，但这种方法会随着数据量增加而降低
2) 命令：
mysql> select note_text
-> from productnotes
-> where match(note_text) against('heavy' in boolean mode);
#返回note_text列中带有heavy字样的行。
mysql> select note_text
-> from productnotes
-> where match(note_text) against('heavy -rope*' in boolean mode);
#返回note_text列中带有heavy字样的行，但是包括除去以repe开头的词的行。
mysql> select note_text
-> from productnotes
-> Where match(note_text) against('+safe +(<"rabbit bait")' in boolean mode);
#返回note_text列中必须带有safe词和rabbit bait短句的行，并降低这个短句的等级。
3) 注释：
a) + 包含，且必须存在
b) - 排除，词必须不出现
c) > 包含，且增加等级值
d) < 包含，且减少等级值
e) () 把词组成表达式
f) ~ 取消一个词的排序值
g) * 词尾的通配符
h) “” 定义一个短句，匹配整个短句，以包含或者排除这个短句。例:“rabbit bait”---这个标识为一个短句
8. 全文本搜索的说明
1) 索引全文数据时，短词被默认忽略，3个及一下的短词
2) MySQL有一个内建的专用词(stopword)列表，这些词在索引中被忽略，可以覆盖，查看官方文档
3) MySQL定义了一条规则，如果有一个词出现在50%的行中则将它作为一个非用词忽略，不在布尔文本搜索中应用
4) 如果表中的行数少于3行，则全文本搜索不反悔结果(因为表中的词或者不出现，或者出现在50%)
5) 忽略词的单引号，don’t = don’t
6) 不具有词分隔符的语言，会返回全文
7) 只有MyISAM数据库引擎支持全文本搜索
十三、 插入数据（insert）
1. 插入完整的行
1) 定义：
a) 第一种方法：insert into 表名
values(数据1,数据2,数据3);
#这种方法虽然简单，但是却很不安全，因为这种是依赖表中的次序排列，如果表结构变动后则添加数据会出错
b) 第二种方法：insert into 表名(列1,列2,列3)
values(数据1,数据2,数据3);
#这种方法虽然不怎么便捷但是却很安全，因为数据会对应着表中自定义序列的列，即使表结构变化也可以根据列名进行添加数据
2) 注意事项：
a) 提高整体性能：因为数据库经常被多个客户进行访问，所以对处理请求的次序管理是mysql的任务。
b) insert工作会占用并且降低数据库的性能，并且会耽误数据检索的工作，该怎么解决？
降低优先级，使用命令：insert low_priority into，进行添加数据，使用low_priority关键词进行对insert降低优先级
2. 插入多行
1) 定义：insert可以插入多行
2) 命令：
insert into 表名(列1,列2,列3)
values(数据1,数据2,数据3);
insert into 表名(列1,列2,列3)
values(数据4,数据5,数据6)
#如果添加的列名次序相同，也可以这样添加
insert into 表名(列1,列2,列3)
values(数据1,数据2,数据3),
values(数据4,数据5,数据6);
3. 插入检索出来的数据（insert select）
1) 定义：将检索出的内容插入到表中，检索出的内容会按照提供的列名进行插入，不会注意列名是否一致。
2) 命令：
mysql> insert into custnew
-> (
-> cust_id,
-> cust_name,
-> cust_address,
-> cust_city,
-> cust_state,
-> cust_zip,
-> cust_country,
-> cust_contact,
-> cust_email
-> )
-> select cust_id,
-> cust_name,
-> cust_address,
-> cust_city,
-> cust_state,
-> cust_zip,
-> cust_country,
-> cust_contact,
-> cust_email
-> from customers;
#将查询customers内的内容插入到custnew这个表中。
十四、 更新和删除数据
1. 更新数据（update，update ignore）
1) 定义：有两种方法定义更新数据，一种是更新所有行，另一种是更新特定行
2) 命令:
mysql> update custnew
-> set cust_email = '[email protected]',
-> cust_name = 'The chendi'
-> where cust_id = 10005;
#更新cust_id等于10005的那一行，将cust_email更新为'[email protected]'，将cust_name更新为The chendi
3) 注意事项：
a) update更新多行时发现错误会停止，并且会恢复之前更新的内容，如果不想让其发现错误也继续执行
b) 就需要加上关键词ignore——（update ignore 表名）
c) 不加where则是更新定义一列的数据，所以where是必须的
2. 删除数据（delete，truncate table）
1) 定义：从一个表中删除数据，有两种方法，删除特定的行，删除所有行
2) 命令：
mysql> delete from custnew
-> where cust_id = 10006;
#在custnew这张表中，过滤出cust_id等于10006的这一行的数据，并删除。
#不加where则是删除整张表的数据
3) 注意事项：
如果想快速的删除一张表，可以使用truncate table，truncate table是将原来的表删除重新创建一个表，而不是逐行删除数据。
用法：mysql> truncate table custnew;
#删除custnew这张表的内容
十五、 创建表
1. 重命名表（rename…to…）
1) 定义：重命名表名
2) 命令：
mysql> rename table dang_an to dangan;
#将dang_an这个表的名字改为dangan
2. 删除表（drop）
1) 定义：删除一个表，且不能恢复
2) 命令：
drop table customers2;
#将customers2删除
十六、 索引
1. 为什么要使用索引？
1) 数据库为了加快查询速度，进行对数据的排序整理，定义查询规则
2) 查询速度变快，查询耗费时间资源变少
3) 索引的类型：
a) 主键索引：当创建表时，系统会自动建立主键索引
b) 唯一性索引：指定字段为唯一性约束时，系统会自动建立唯一性索引
c) 聚合索引：建立索引时，按照数据的存储顺序进行索引，普通的排序
d) 非聚合索引：建立索引时，排序按照冒泡排序的规则进行排序
i. 冒泡排序：对数字先比较第一位，大的放到后面小的在前面，再比较第二位，依次比较进行排序
e) 负责索引：将每个字段进行索引，当查询条件中指定了满足所有复合索引的字段时，才会调用复合索引
2. 创建普通索引（create index）
1) 定义：普通索引只是起到一个索引字段的功能
2) 命令：create index 索引名 on 表名(字段名)
create index name on emp(id)
3. 查看索引（show index from）
1) 定义：查看表中已经建立的索引字段
2) 命令：show index from 表名
show index from emp;
4. 创建唯一性索引（create unique index）
1) 定义：定义的列必须要有唯一性才可以正常进行执行索引功能
2) 命令：create unique index 索引名 on 表名(字段名);
create unique index sex on emp(name);
5. 创建复合索引(组合索引)
1) 定义：使用复合索引时，必须要满足复合索引定义的多个条件，不然是不会触发复合索引的
2) 命令：create index 索引名 on 表名(字段名1,字段名2,……)
create index id_name on emp(id,name);
6. 删除索引（drop index）
1) 定义：删除索引后索引将不存在
2) 命令：drop index 索引名 on 表名;
drop index id on emp;
十七、 视图
1. 为什么要使用视图
1) 重用sql语句
2) 简化复杂的sql操作，编辑查询后不需要知道它的基本查询细节，直接调用就可以
3) 使用表的组成部分，而不是表
4) 保护数据，可以给予用户表的特定部分的访问权限，而不是整个表的访问权限
5) 更改数据格式和表示哦，视图可返回与底层的表示和格式不同的数据
6) 使用大量视图时性能会下降的很厉害
2. 视图的规则和限制
1) 和表一样，视图必须唯一命名
2) 对于可以创建的视图没有数量限制
3) 创建视图要有足够的访问权限，一般是由数据库管理员授予
4) 视图可以嵌套
5) 视图不能索引，也不能有关联的触发器和默认值
6) 视图可以跟表一起使用
7) 可以使用order by，但是从该视图中select的语句也含有order by的话将会被覆盖
3. 视图命令体系
1) 使用create view来创建视图
2) 使用 show create view viewname; 来查看视图的语句
3) 使用drop删除视图，语法为drop view viewname;
4) 更新视图可以先drop然后再create，也可以直接create or replace view;
4. 创建视图（create view）
1) 定义：创建一个视图，将查询语句包含到视图内
2) 命令：
mysql> create view viewname AS
-> select cust_name, cust_contact, prod_id
-> from customers, orders, orderitems
-> where customers.cust_id = orders.cust_id
-> and orderitems.order_num = orders.order_num;
#创建一个名字是viewname的视图，然后将下面的语句输入到视图内，这个语句是返回任意产品的所有客户列表
mysql> select *
-> from viewname
-> where prod_id = 'TNT2';
#调用viewname的视图，然后定义条件为prod_id等于TNT2时才会输出
5. 用试图重新格式化检索出的数据
1) 定义：定义一个视图，将视图内包含需要格式化的数据
2) 命令：
mysql> create view viewname AS
-> select concat(rtrim(vend_name),'(',rtrim(vend_country),')')
-> AS vend_title
-> from vendors
-> order by vend_name;
#定义一个viewname的视图，使用rtrim将空格去除，在使用concat将字符格式化，进行输出
十八、 存储过程
1. 为什么要使用存储过程
优点：
1) 通过把处理封装在容易使用的单元中，简化复杂的操作
2) 简化对变动的管理
3) 提高性能，使用存储过程比使用单独的mysql语句要快
4) 安全性高，通过存储过程的限制对基础数据的访问减少了数据讹误
缺点：
1) 编写的sql语句复杂，需要高技术，高经验
2) 没有权限，DBA允许用户使用存储过程，但不允许他们创建存储过程
2. 执行存储过程（call）
1) 定义：mysql称存储过程的执行为调用
2) 命令：
mysql> call callname(@low,
-> @high,
-> @avg);
#执行名为callname的存储过程，计算返回最低，最高和平均
3. 创建存储过程（create procedure）
1) 定义：使用create procedure创建存储过程
2) 命令：
mysql> delimiter //
mysql> create procedure ping_jun()
-> begin
-> select avg(prod_price) as pingjun
-> from products;
-> end //
#delimiter默认数据库的结束符标记为;，这条关键字是将该结束符更改为//但是当命令转入到数据库引擎时还是会转换为;。
#create procedure创建一个名字为ping_jun的存储过程，如果存储过程需要参数则在()表示出来，如果没有参数也必须要有()
#begin和end用来限定存储过程体，该存储过程体为标红的部分
4. 删除存储过程（drop procedure）
1) 定义：存储过程创建后会一直保存在服务器中以供使用，当需要删除存储过程
2) 命令：
mysql> drop procedure ping_jun;
#删除名字叫ping_jun的存储过程
mysql> drop procedure if exists ping_jun;
#删除名字为ping_jun的存储过程
#与上面不同的是，这种方法即使该存储过程不存在也会删除，并且不会报错
5. 变量的概念（out，into）
1) 定义：
a) OUT指出相应的参数用来从存储过程传出一个值，返回给调用者
b) IN传递给存储过程
c) 内存中一个特定的位置，用来临时存储数据
2) 命令：
a) 定义变量
mysql> delimiter //
mysql> create procedure cing(
-> out p1 decimal (8,2),
-> out p2 decimal (8,2),
-> out p3 decimal (8,2)
-> )
-> begin
-> select min(prod_price)
-> into p1
-> from products;
-> select max(prod_price)
-> into p2
-> from products;
-> select avg(prod_price)
-> into p3
-> from products;
-> end //
#使用delimiter更改结束符为//，定义变量p1,p2,p3，数据类型为decimal(8,2)代表保留8位数字，小数位保留两位
#使用into将数据传给存储过程，使用out将存储过程产生的数据发送给调用者
b) 为次存储过程进行定义变量名
定义：此存储过程要求三个参数，因此必须要传递三个参数，定义变量名
定义的变量名，必须与变量数量一致
mysql> call cing(@pricelow,
-> @pricehigh,
-> @priceavg)//
6. 使用变量，接收参数并返回参数
1) 定义：使用into和out接收调用者的参数，进行计算后返回给调用者参数
2) 命令：
mysql> create procedure jie_fan(
-> in number int,
-> out ototal decimal(8,2)
-> )
-> begin
-> select sum(item_price*quantity)
-> from orderitems
-> where order_num = number
-> into ototal;
-> end//
#定义了两个变量，将number变量定义为in：是将调用者传递的参数传递给存储过程，然后内部进行计算后再传递给out变量
mysql> call jie_fan(20005,@ototal);
#定义变量名，并将要查询的order_num发送给存储过程，进行查询后，赋给ototal这个变量名
mysql> select @ototal;
#调用变量名
7. 变量的作用域
1) 内部通过declare定义的变量，是内部的变量，只要存储过程的语句执行到end结束后就会释放空间，不会存在
2) 外部通过call传递的变量参数（变量名）是外部变量，可以在外部使用并调用
8. 流程控制语句与存储过程的结合
条件判断（if、case）
1) 定义：if语句与存储过程嵌套
1) 命令：
mysql> delimiter // --将结束符替换为delimiter
mysql> create procedure proc2 --创建存储过程，名称为proc2
-> (
-> in p1 int --定义in传到存储过程的变量p1并且数据类型为int
-> )
-> begin
-> declare var int; --使用declare定义局部变量，var数据类型为int
-> set var=p1+1; --var变量加1
-> if var=1 then insert into t values(11); --如果var等于1则执行后面的向t表中添加数据11
-> end if; --并且结束循环
-> if var=2 then insert into t values(22); --如果var等于2则执行后面的向t表中添加数据22
-> else insert into t values(33); --上面的添加11满足后继续判断，等于2或者不等于2，不等于2添加数字33
-> end if; --结束循环
-> end; --结束存储过程
-> //
2) 定义：case语句与存储过程嵌套
1) 命令：
mysql> delimiter //
mysql> create procedure proc3
-> (
-> in p1 int
-> )
-> begin
-> declare var int;
-> set var=p1+1;
-> case var --定义case的判断目标为var
-> when 1 then insert into t values(17); --var等于1的时候添加数值17
-> when 2 then insert into t values(18); --var等于2的时候添加数值18
-> else insert into t values(19); --var不等于2也不等于1的时候添加数值19
-> end case; --结束case循环
-> end; --结束存储过程
-> //
循环判断
--while与repeat不同的一点是，while是先判断，后执行内部语句，而repeat是先执行内部语句，后判断
1) 定义：while语句与存储过程的嵌套
1) 命令：
mysql> delimiter //
mysql> create procedure proc4()
-> begin
-> declare var int;
-> set var=0; --定义var的值为0
-> while var<6 do --while判断var是否小于6，如果小于6则执行
-> insert into t values(var); --while内部语句，添加var的值
-> set var=var+1; --添加var的值，使其不是称为一个死循环
-> end while; --结束while循环
-> end; --结束存储过程
-> //
2) 定义：repeat语句与存储过程的嵌套
1) 命令：
mysql> delimiter //
mysql> create procedure proc5()
-> begin
-> declare v int;
-> set v=0;
-> repeat --循环关键字
-> insert into t values(v); --repeat循环内语句
-> set v=v+1; --对参照进行加1
-> until v>5 --对数据进行判断
-> end repeat; --结束repeat语句
-> end; --结束存储过程
-> //
3) loop语句与存储过程的嵌套
1) 命令：
mysql> delimiter //
mysql> create procedure proc6()
-> begin
-> declare v int;
-> set v=0;
-> LOOP_lable:loop --为loop语句定义一个循环标签
-> insert into t values(v); --loop内部语句
-> set v=v+1; --为变量v加1
-> if v>5 then --if判断，如果v大于5则执行
-> leave LOOP_lable; --跳出loop循环
-> end if; --结束if语句
-> end loop; --结束loop循环
-> end;
-> //
4) iterate语句与存储过程嵌套
1) 命令:
mysql> delimiter //
mysql> create procedure proc7()
-> begin
-> declare v int default 0;
-> LOOP_lable:loop --定义loop的循环标签
-> set v=v+1; --循环添加v+1
-> if v<10 then iterate LOOP_lable; --v小于10执行iterate执行到loop开始，重新循环
-> elseif v>20 then leave LOOP_lable; --如果大于20则跳出loop循环
-> else select 'v is between 10 and 20'; --如果是在10到20之间，则返回一条提示显示在10到20之间
-> end if; --结束if循环
-> end LOOP LOOP_lable; --结束loop和loop标签的循环体
-> end; --结束存储过程
-> //
9. 查看存储过程的详细信息
1) 定义：查看存储过程的详细信息，包括创建的存储过程有哪些？包含的sql命令条目等
2) 命令：
mysql> show create procedure proc7;
#查看proc7这个存储过程内的命令，以及创建人，等。。。
mysql> show procedure status like 'proc%';
#使用show procedure status查看所有的存储过程，而使用like是限制其过程的输出结果，只输出proc开头的存储过程
十九、 游标
1. 为什么要使用游标？
1) 游标是一个存储在mysql服务器上的数据库查询，是被select语句检索出来的结果集
2) 在存储了游标后，用户可以在应用程序根据需要滚动或浏览其中的数据
3) 主要用于交互式，其中用户需要滚动屏幕上的数据，并对数据进行浏览或做出更改
4) mysql游标只能用于存储过程
2. 创建游标
1) 定义：使用declare创建游标，并命名，并定义相应的select语句，根据需要带where或者其他子句。
2) 命令：
mysql> create procedure cunchu()
-> begin
-> declare c_id int; --创建局部变量，存储需要输出的数据
-> declare c_name varchar(11); --创建局部变量，存储需要输出的数据
-> declare yb cursor for select id,name from dang_an; --定义cursor(游标)类型for定义sql语句
->
-> open yb; --开启游标yb
->
-> fetch yb into c_id, c_name; --fetch提取游标信息，一行一行的提取
-> select c_id, c_name; --输出提取的游标信息
->
-> close yb; --关闭游标yb
->
-> end; --结束存储过程
-> //
3. 游标与循环的嵌套
1) 定义：使用游标时会使行一行一行的输出，而需要知道行数
2) 用循环嵌套的方法就是让数据库自己知道该什么时候停下来
3) 命令：
mysql> create procedure cunchu()
-> begin
-> declare p_id int;
-> declare p_name varchar(11);
-> declare has_data boolean default 1; --创建循环判断值，最好为布尔值（boolean）
->
-> declare yb cursor for select id, name from dang_an; --定义游标的输出目标，以及名字
-> declare exit handler for not found set has_data=0;
--exit(退出)handler是自定义名字，not found是找不到数据时将has_data赋值为0
->
-> open yb; --开启游标
->
-> while has_data=1 do --开启循环，循环条件为has_data等于1时才会执行
-> fetch yb into p_id, p_name; --提取信息
-> select p_id, p_name; --输出信息
->
-> end while; --结束循环
-> close yb; --结束游标必须在结束循环后面
-> end;
-> //
二十、 触发器
1. 触发器的基础知识
1) 触发器是干什么的
a) 让某条语句在某些事件发生时，自动执行，就要使用触发器
b) 需要在某个表发生更改时自动处理
2) 创建触发器的信息
a) 唯一的触发器名字
b) 触发器关联的表
c) 触发器应该响应的活动
i. delete（删除） [NEW代表将要或者已经新增的数据]
ii. insert（添加） [OLD表示修改之前的数据，NEW代表将要或者已经新增的数据]
iii. update（更新） [OLD表示将要或者已经删除的数据]
d) 每张表最多支持6个触发器
2. 删除触发器（drop trigger）
1) 定义：触发器（trigger）不允许修改，只能删除后重新创建
2) 命令：
drop trigger 触发器名;
3. 创建触发器
1) 格式：
create trigger trigger_name --创建触发器的名称
before/after insert/delete/update
--定义触发器的执行方式before是触发之前，after是触发之后
--定义触发器的执行条件insert是添加数据的时候，delete是删除数据的时候，update是更新数据的时候
on table_name --定义一个表的名字
[for each row] --mysql不支持语句级触发器，所以只能执行行级触发器
trigger_stmt; --定义触发器执行的语句主体，begin开始，end结束
2) insert触发器命令：
delimiter // --定义结束符为//
create trigger emp_insert_trigger --定义触发器名称为emp_insert_trigger
after insert --定义执行方式为after触发之后，触发方式为insert
on emp --定义针对表的名字
for each row --执行行级触发器
begin
insert into emp_logs(id,operation,operate_time,operate_id,operate_params)
values(null,'insert',now(),new.id,concat('插入后(id:',new.id,',name:',new.name,',sex:',new.sex,',csrq:',new.csrq,')'));
#触发之后的sql语句，new代表新添加后的数据，NEW.进行调用数据
end;
//
3) update触发器格式
create trigger emp_update_trigger
after update --将这个定义为语句执行后，使用update方式
on emp --定义表名
for each row --定义行级触发器
begin
insert into emp_logs(id,operation,operate_time,operate_id,operate_params) --定义列名
values(null,'insert',now(),new.id, --定义数据
concat('修改前(id:',old.id,',name:',old.name,',sex:',old.sex,',csrq:',old.csrq,')', --修改前的使用old进行记录
'修改后(id:',new.id,',name:',new.name,',sex:',new.sex,',csrq:',new.csrq,')')); --修改后的使用new进行记录
end;
//
4) delete触发器命令
create trigger emp_delete_trigger
after delete --将这个定义为语句执行后，使用delete方式
on emp --定义表名
for each row --定义行级触发器
begin
insert into emp_logs(id,operation,operate_time,operate_id,operate_params) --定义列名
values(null,'insert',now(),old.id,concat('删除前(id:',old.id,',name:',old.name,',sex:',old.sex,',csrq:',old.csrq,')')); --定义数据
--因为数据已经删除，所以要用old来获取数据
end;
//
5) 实验结果：
+----+------+-----------+---------------------+------------+----------------------------------------------------------------------------+
| id | name | operation | operate_time | operate_id | operate_params |
+----+------+-----------+---------------------+------------+----------------------------------------------------------------------------+
| 1 | NULL | insert | 2020-03-25 20:39:08 | 4 | 插入后(id:4,name:丁月,sex:女,csrq:20) |
| 2 | NULL | insert | 2020-03-25 21:28:08 | 1 | 修改前(id:1,name:陈迪,sex:女,csrq:20)修改后(id:1,name:陈迪,sex:男,csrq:20) |
| 4 | NULL | insert | 2020-03-25 21:42:23 | 2 | 删除前(id:2,name:郭凤丽,sex:女,csrq:38) |
+----+------+-----------+---------------------+------------+----------------------------------------------------------------------------+
3 rows in set (0.00 sec)
二十一、 事务处理
1. 事务的作用
1) 防止数据库发生错误，而阻止了添加数据这个过程的完成，添加到表中的数据为不完整数据
2) 这样可以将该过程定义为一个事务，这样可以保证一组操作不会中途停止，会作为整体执行，或者完全不执行
3) 将一个事务（整组sql语句）发送给数据库，如果发生错误就回退到某个已知且安全的位置
2. 事务的关键词
1) 事务(transaction)：指一组sql语句
2) 回退(rollback)：指撤销指定sql语句的过程
3) 提交(commit)：指将未存储的sql语句的结果写入到数据库
4) 保留点(savepoint)：指事务出里中设置的临时占位符，可以对它发布回退
3. 开启事务(start transaction)
1) 使用该关键词标识事务的开始
4. 回退语句(rollback)
1) 定义：撤销指定sql语句，rollback只能在一个事务处理内使用，在执行一条start transaction之后
2) 命令：
select * from emp; --emp表中有内容
start transaction; --开启事务处理
delect from emp; --删除emp表中的内容
select * from emp; --emp表中内容被清空
rollback; --对事务进行回退处理
select * from emp; --emp表中的内容再次回归
5. 提交语句(commit)
1) 定义：将未保存sql语句执行结果保存到数据库中，一般的sql语句都是提交和保存都是自动进行的，而事务不能自动保存，需要管理员手动明确的表示提交
2) 命令：
start transaction; --开启事务
delete from orderitems where order_num=20010; --删除
delete from orders where order_num=20010; --删除
commit; --保存事务做出的结果
6. 使用保留点(savepoint)
1) 定义：保留点越多越好，可以创建占位符，让事务处理在合适的地方放置占位符，需要回退可以回退到某个占位符
2) 命令：
start transaction; --开启事务
delete from emp where id=3; --删除id为3的那一行
savepoint delete1; --定义恢复点的名称
delete from emp where id=4; --删除id为4的那一行
rollback to delete1; --恢复到恢复点为delete的那一点
#保留点保留的是定义保留点后的一条sql语句，而不是前一条sql语句
释放保留点：
release savepoint;
7. 更改系统默认的提交行为(autocommit)
1) 定义：默认的sql语句都是自动进行提交更改的，有时我们不需要系统自动进行提交的时候
2) 命令：
set autocommit=0;
#定义为0就是标识为假了，系统不再自动提交更改，直到autocommit等于1为真
二十二、 不同语言使用不同的字符集
1. 字符集和校对顺序
1) 字符集：为字母和符号的集合
2) 编码：为某个字符集成员的内部表示
3) 校对：为规定字符如何比较的指令
二十三、 安全管理
1. 访问控制
1) 即提供用户所需的访问权，且仅提供他们所需的访问权，这就是所谓的访问控制
2) 管理访问控制需要创建和管理用户账号
2. 查看用户
1) 定义：查看系统已经存在的用户，mysql库中会有一个user表，包含所有用户账号
2) 命令：
use mysql;
select user from user;
3. 创建用户（create user）
1) 定义：创建一个新用户账号，使用create user，也可以使用insert插入到用户表中（危险，因为用户表对系统极为重要）
2) 命令：
create user ben identified by ‘mima’; --创建一个用户名为ben密码为mima的用户
create user ben identified by password ‘mima’; --创建密码为散列(hash)算法
4. 删除用户（drop user，revoke）
1) 定义：在mysql 5之后删除用户时会删除他的权限，但是mysql 5之前需要使用revoke删除权限后再删除用户
2) 命令：
drop user bforta; --删除名字叫做bforta的用户
5. 设置访问权限
1) 查看用户的访问权限（grants）
命令：show grants for ben;
#查看ben的权限
结果：
+---------------------------------+
| Grants for ben@% |
+---------------------------------+
| GRANT USAGE ON *.* TO `ben`@`%` |
+---------------------------------+
#usage on *.*这表示用户没有任何权限
2) 授予权限（grant）
命令：grant select on orders.* to ben;
#授予ben这个用户对orders使用select的权限
#结果：用户ben对orders这张表有只读访问权限
验证：
mysql> show grants for ben;
+-----------------------------------------+
| Grants for ben@% |
+-----------------------------------------+
| GRANT USAGE ON *.* TO `ben`@`%` |
| GRANT SELECT ON `orders`.* TO `ben`@`%` |
+-----------------------------------------+
3) 删除权限（revoke）
命令：revoke select on orders.* from ben;
#删除ben这个用户对orders的只读权限
验证：
mysql> show grants for ben;
+---------------------------------+
| Grants for ben@% |
+---------------------------------+
| GRANT USAGE ON *.* TO `ben`@`%` |
+---------------------------------+
1 row in set (0.00 sec)
4) 权限的定义层次
整个服务器 crant all，revoke all
整个数据库 on database.*
特定的表 on database.table
特定的列
特定的存储过程
6. 更改用户口令（set password）
1) 命令：
set password for ben = password(‘hehehe’);
#更新用户ben的密码，更新为hehehe
二十四、 数据库维护（后两章，增加经验后看）
1. 备份数据方法
1) 命令行mysqldump转储
2) 命令行mysqlhotcopy热拷贝
3) backup table或select into outfile转储
二十五、 锁
1. 表锁
1) 创建表锁
a) 定义：定义当前会话的权限，只许本会话查看或者写入
b) 允许看
lock tables [表名] read;
例:
lock tables test read;
在其他会话查询该表时：
mysql> select * from test;
^C -- query aborted
ERROR 1317 (70100): Query execution was interrupted
c) 允许写
lock tables [表名] write;
例:
lock tables test write;
在其他会话写入该表时：
mysql> update test set num=10 where id=2;
^C -- query aborted
ERROR 1317 (70100): Query execution was interrupted
2) 删除表锁
a) 定义：取消当前会话的特权
b) unlock tables;
