一、 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;