??吐血總結《Mysql從入門到入魔》，圖文并茂（建議收藏）??-有解無憂

文章目錄

- 1. 資料庫操作
- - 1.1顯示資料庫
  - 1.2 創建資料庫
  - 1.3 使用資料庫
  - 1.4 查看當前資料庫
  - 1.5 洗掉資料庫
- 2. 表操作
- - 2.1 創建表
  - 2.2 更新表
  - - 2.2.1 添加列
    - 2.2.2 洗掉列
  - 2.3 查看表結構
  - 2.4 查看表詳細資訊
  - 2.5 重命名表
  - 2.6 洗掉表
- 3. 查詢
- - 3.1 查詢多列
  - 3.2 檢索唯一值
  - 3.3 限制輸出
  - 3.4 注釋
- 4. ORDER BY 排序
- - 4.1 單列排序
  - 4.2 多列排序
  - 4.3 指定排序方向
- 5. WHERE 過濾資料
- - 5.1 WHERE 子句運算子
  - 5.2 范圍值檢查
  - 5.3 空值檢查
- 6. 高級資料過濾
- - 6.1 WHERE 組合過濾
  - 6.2 IN 運算子
  - 6.3 NOT 運算子
- 7. 通配符過濾
- - 7.1 % 通配符
  - 7.2 _ 通配符
- 8. 創建計算欄位
- - 8.1 拼接欄位
  - 8.2 執行算數計算
- 9. 函式
- - 9.1 常用文本處理函式
  - 9.2 日期和時間處理函式
  - 9.3 數值處理函式
- 10. 資料聚集
- - 10.1 聚集函式
  - - 10.1.1 AVG() 函式
    - 10.1.2 COUNT() 函式
    - 10.1.3 MAX() & MIN() 函式
    - 10.1.4 SUM() 函式
  - 10.2 組合聚集函式
- 11. 資料分組
- - 11.1 資料分組
  - 11.2 過濾分組
- 12. 子查詢
- - 12.1 利用子查詢進行過濾
  - 12.2 作為計算欄位使用子查詢
- 13. 表聯結
- - 13.1 自聯結
  - 13.2 等值聯結
  - 13.3 行內結
  - 13.4 自然聯結
  - 13.5 外聯結
  - - 13.5.1 左外聯結
    - 13.5.2 右外聯結
  - 13.6 四種聯結對比圖
- 14. 插入資料
- - 14.1 插入完整行
  - 14.2 插入部分行
  - 14.3 從一個表復制到另一個表
- 15.更新資料
- - 15.1 更新單行單列
  - 15.2 更新單行多列
  - 15.3 更新所有行
  - 15.4 洗掉列中的值
- 16. 洗掉資料
- - 16.1 洗掉單行
  - 16.2 洗掉所有行
- 17.存盤程序
- - 17.1 為什么使用存盤程序
  - 17.2 創建存盤程序
  - 17.3 存盤程序體
  - 17.4 存盤程序引數
  - - 17.4.1 IN輸入引數
    - 17.4.2 OUT輸入引數
    - 17.4.3 INOUT輸入輸出引數
  - 17.5 洗掉存盤程序
- 18.管理事務處理
- - 18.1 事務處理
  - 18.2 控制事務處理
  - 18.3 事務隔離級別
  - - 18.3.1 臟讀
    - 18.3.2 不可重復讀
    - 18.3.3 幻讀
- 19. 游標
- - 19.1 使用游標
  - 19.2 創建游標
  - 19.3 使用游標資料
  - 19.4 游標的優缺點
- 20. 約束
- - 20.1 約束
  - 20.2 主鍵
  - 20.3 外鍵
  - 20.4 唯一約束
  - 20.5 檢查約束
- 21. 索引
- - 21.1 普通索引
  - 21.2 唯一索引
  - 21.3 全域索引
  - 21.4 多列索引

1. 資料庫操作

1.1顯示資料庫

mysql> SHOW DATABASES;

1.2 創建資料庫

CREATE DATABASE 資料庫名 CHARSET='編碼格式'

mysql> CREATE DATABASE create_test CHARSET = 'utf8';

1.3 使用資料庫

mysql> USE create_test;

1.4 查看當前資料庫

使用 SELECT DATABASE() 查看當前使用的資料庫，

mysql> SELECT DATABASE();
+-------------+
| DATABASE()  |
+-------------+
| create_test |
+-------------+

1.5 洗掉資料庫

mysql> DROP DATABASE create_test;

2. 表操作

2.1 創建表

格式：

CREATE TABLE  [IF NOT EXISTS] `表名` (
	`欄位名` 列型別 [屬性] [索引] [注釋]，
	`欄位名` 列型別 [屬性] [索引] [注釋]，
	.......
	`欄位名` 列型別 [屬性] [索引] [注釋]
) [表型別] [字符集設定] [注釋]

使用下面的陳述句創建示例中的 one_piece 表，

mysql> CREATE TABLE one_piece
    -> (
    ->     id CHAR(10) NOT NULL COMMENT '海賊團id',
    ->     pirates CHAR(10) NOT NULL COMMENT '海賊團名稱',
    ->     name CHAR(10) NOT NULL COMMENT '海賊名',
    ->     age INT(11) NOT NULL COMMENT '海賊年齡',
    ->     post VARCHAR(10) NULL COMMENT '海賊團職位'
    -> );

注意：創建表時，指定的表名必須不存在，否則會出錯，

2.2 更新表

2.2.1 添加列

在剛才創建的 one_piece 表中添加一列 bounty (賞金)，

mysql> ALTER TABLE one_piece
    -> ADD bounty INT(15);

2.2.2 洗掉列

洗掉 bounty 列，

mysql> ALTER TABLE one_piece
    -> DROP COLUMN bounty;

2.3 查看表結構

mysql> DESC one_piece;
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| id      | char(10)    | NO   |     | NULL    |       |
| pirates | char(10)    | NO   |     | NULL    |       |
| name    | char(10)    | NO   |     | NULL    |       |
| age     | int(11)     | YES  |     | NULL    |       |
| post    | varchar(10) | YES  |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+

2.4 查看表詳細資訊

\G 后面不能加“ ; ”，

mysql> SHOW TABLE STATUS LIKE 'one_piece' \G
*************************** 1. row ***************************
           Name: one_piece
         Engine: InnoDB
        Version: 10
     Row_format: Dynamic
           Rows: 0
 Avg_row_length: 0
    Data_length: 16384
Max_data_length: 0
   Index_length: 0
      Data_free: 0
 Auto_increment: NULL
    Create_time: 2021-09-03 17:53:58
    Update_time: NULL
     Check_time: NULL
      Collation: utf8mb4_0900_ai_ci
       Checksum: NULL
 Create_options:
        Comment:
1 row in set (0.39 sec)

2.5 重命名表

兩種方法：

ALTER TABLE 表名 RENAME [TO | AS] 新表名;
RENAME TABLE 表名 TO 新表名;

用方法一將 Products 表更名為 new_Products ，再用方法二改回來，

-- 方法一
mysql> ALTER TABLE one_piece RENAME TO new_one_piece;
-- 方法二
mysql> RENAME TABLE new_one_piece TO one_piece;

2.6 洗掉表

DROP TABLE 表名

mysql> DROP TABLE one_piece;

注意：在該表與其他表有關聯時，Mysql 會阻止該表的洗掉，

3. 查詢

3.1 查詢多列

同時輸出 name, age 列，

mysql> SELECT name, age
    -> FROM one_piece;

3.2 檢索唯一值

使用 DISTINCT 關鍵字，查詢欄位 age 的唯一值，

mysql> SELECT DISTINCT age
    -> FROM one_piece;

3.3 限制輸出

在 Mysql 中使用 LIMIT 關鍵字限制輸出的資料，LIMIT 有兩種常見用法：

SELECT * FROM table  LIMIT [offset], rows    -- LIMIT 單獨使用
SELECT * FROM table  LIMIT rows OFFSET [offset]    -- 配合 OFFSET 使用

offset：行開始的行的索引，0表示從第1行開始顯示（包括第1行），以此類推，

rows：資料顯示的條數，

示例：

SELECT * FROM one_piece LIMIT 5;    -- 檢索前5條資料
--相當于
SELECT * from one_piece LIMIT 0,5;    -- 從第0行開始檢索5條資料
--相當于
SELECT * FROM one_piece LIMIT 5 OFFSET 0;    -- 從第0行開始檢索5條資料，注意這里的LIMIT的5指代的是數量

注：如果表中資料不足，即LIMIT設定的數過大，則只會檢索到最后一行，

3.4 注釋

三種注釋方式

-- 單行注釋
# 單行注釋
/* 多行注釋 */

4. ORDER BY 排序

4.1 單列排序

使用 ORDER BY 子句， ORDER BY 子句取一個或多個列的名字，據此對輸出進行排序（默認升序），

mysql> SELECT name, age
    -> FROM one_piece
    -> ORDER BY age;

**注意：**在指定一條 ORDER BY 子句時，應該保證它是 SELECT 陳述句中最后一條子句，

4.2 多列排序

mysql> SELECT A, B
    -> FROM test
    -> ORDER BY A, B;

在按多列排序時，僅在多個行具有相同的 A 值時才按 B 進行排序，如果 A 列中所有的值都是 唯一的，則不會按 B 排序，
在這里插入圖片描述

4.3 指定排序方向

ORDER 默認升序（從A到Z）排序，指定 DESC 關鍵字進行降序（從Z到 A）排序，

mysql> SELECT age
    -> FROM one_piece
    -> ORDER BY age DESC;

多列指定排序方向時，要使用逗號分隔，

mysql> SELECT name, age
    -> FROM one_piece
    -> ORDER BY name DESC, age;

5. WHERE 過濾資料

5.1 WHERE 子句運算子

操作符	說明	運算子	說明
=	等于	>	大于
<>、!=	不等于	>=	大于等于
<	小于	!>	不大于
<=	小于等于	BETWEEN	在兩值之間(包含邊界)
!<	不小于	IS NULL	是NULL值

5.2 范圍值檢查

使用 WHERE 關鍵字和 BETWEEN AND 進行范圍值檢查（前閉后閉），

mysql> SELECT age
    -> FROM one_piece
    -> WHERE A BETWEEN 5 AND 10;

查詢欄位 age 中 >=5 并且 <= 10 的資料，

5.3 空值檢查

使用 WHERE 關鍵字和 IS NULL 進行范圍值檢查，如果沒有 NULL 值就不回傳資料，

mysql> SELECT name
    -> FROM one_piece
    -> WHERE name IS NULL;

6. 高級資料過濾

6.1 WHERE 組合過濾

使用 AND 、OR 運算子給 WHERE 子句添加附加條件， AND 的優先級比 OR 要高，優先級高低 () 、 AND 、 OR，在使用的程序中要注意各個優先級的影響，

mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE(name = '索隆' OR name = '路飛')
    -> AND age >= 18;

6.2 IN 運算子

IN 運算子用來指定條件范圍，范圍中的每個條件都可以進行匹配，(與 OR 的功能相同，但速度比 IN 慢)

mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name IN ('索隆', '路飛')

6.3 NOT 運算子

WHERE 子句中的 NOT 運算子有且只有一個功能，那就是否定其后所跟的任何條件，

mysql> SELECT name
    -> FROM one_piece
    -> WHERE name NOT IN ('索隆', '路飛')

7. 通配符過濾

通配符搜索只能用于文本欄位（字串），非文本資料型別欄位不能使用通配符搜索，

在使用通配符過濾之前要先了解 LIKE ， LIKE 運算子用于在 WHERE 子句中搜索列中的指定模式或取值，

7.1 % 通配符

% 表示任何字符出現任意次數，例如，為了找出所有以 路 開始的 name，

mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name LIKE '路';

7.2 _ 通配符

通配符 _ 的用途與 % 一樣也是匹配任意字符，但它只匹配單個字符，而不是多個字符，

mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name LIKE '烏_普';

8. 創建計算欄位

8.1 拼接欄位

下面將 name ， sex 兩列進行合并，并通過 AS 關鍵字進行給新列賦予別名，

mysql> SELECT Concat(name, '(', sex, ')') AS new_column
    -> FROM one_piece;

8.2 執行算數計算

通過 quantity （數量）、 price （價格）來計算 total_price （總價）

mysql> SELECT quantity, price,
    -> quantity * price AS total_price
    -> FROM test

9. 函式

9.1 常用文本處理函式

函式	說明
LEFT(str, length)	回傳指定長度的字串的左邊部分
RIGHT(str, length)	回傳指定長度的字串右邊部分
LTRIM(str)	去掉字串左邊的空格
RTRIM(str)	去掉字串右邊的空格
LOWER(str)	將字串轉換為小寫
UPPER(str)	將字串轉換為大寫
LENGTH(str)	回傳字串的長度

使用 LENGTH(str) 獲取字串的長度，

mysql> SELECT name, LENGTH(name) AS length
    -> FROM one_piece;

9.2 日期和時間處理函式

查詢在 2000年出生的人員資訊，

mysql> SELECT *
    -> FROM test
    -> WHERE YEAR(brithday)=2000;

9.3 數值處理函式

函式	說明
ABS()	回傳一個數的絕對值
COS()	回傳一個角度的余弦
SIN()	回傳一個角度的正弦
TAN()	回傳一個角度的正切
PI()	回傳圓周率
EXP()	回傳一個數的指數值
SQRT()	回傳一個數的平方根

以 ABS() 函式為例

sql> SELECT ABS(-1);
+---------+
| ABS(-1) |
+---------+
|       1 |
+---------+

10. 資料聚集

10.1 聚集函式

函式	說明
AVG()	回傳某列的平均值
COUNT()	回傳某列的行數
MAX()	回傳某列的最大值
MIN()	回傳某列的最小值
SUM()	回傳某列值之和

10.1.1 AVG() 函式

查詢平均 age ，

mysql> SELECT AVG(age) AS avg_age
    -> FROM one_piece

10.1.2 COUNT() 函式

兩種使用方式：

COUNT(*) 對表中行的數目進行計數，包括空值，

mysql> SELECT COUNT(*) AS num_person
    -> FROM one_piece;

COUNT(column) 對特定列中非 NULL 行進行計數，

mysql> SELECT COUNT(name) AS num_name
    -> FROM one_piece;

10.1.3 MAX() & MIN() 函式

當 column 列為數值列， MAX(column) / MIN(column) 回傳 column 列中的最大值 / 最小值，

當 column 列為文本資料， MAX(column) / MIN(column) 回傳 column 列資料排序后的最后一行 / 最前面的行，

10.1.4 SUM() 函式

SUM() 用來回傳指定列值的和（總計）（忽略列值為 NULL 的行），

mysql> SELECT SUM(price * quantity) AS total_price
    -> FROM test

10.2 組合聚集函式

計算 one_piece 表中資料的條數，年齡的最小值、最大值和平均值，

mysql> SELECT COUNT(*) AS num_person,
    -> MIN(age) AS age_min,
    -> MAX(age) AS age_max,
    -> AVG(age) AS age_avg
    -> FROM one_piece;

11. 資料分組

11.1 資料分組

使用分組將資料分為多個邏輯組，對每個組進行聚集計算，
例：統計各個海賊團( pirates )的人數，

mysql> SELECT pirates, COUNT(*) AS num_person
    -> FROM one_piece
    -> GROUP BY pirates;

group by 注意事項:

GROUP BY 可以嵌套使用，
GROUP BY 子句中列出的每一列都必須是檢索列或有效的運算式（但不能是聚集函式），如果在 SELECT 中使用運算式，則必須在 GROUP BY 子句中指定相同的運算式，不能使用別名，
除聚集計算陳述句外，SELECT 陳述句中的每一列都必須在 GROUP BY 子句中給出，
如果分組列中包含具有 NULL 值的行，則 NULL 將作為一個分組回傳，如果列中有多行 NULL 值，它們將分為一組，
GROUP BY 子句必須出現在 WHERE 子句之后，ORDER BY 子句之前，

11.2 過濾分組

使用 HAVING 子句在資料分組后進行過濾，

查詢海賊團人數在500人以上的海賊團名稱及人數，

mysql> SELECT pirates, COUNT(*) AS num_person
    -> FROM one_piece
    -> GROUP BY pirates
    -> HAVING COUNT(*) >= 500;

WHERE 與 HAVING 的主要區別：

WHERE 在資料分組前進行過濾，HAVING 在資料分組后進行過濾，

SELECT子句順序：

子句	說明	是否必須使用
SELECT	要回傳的列或運算式	是
FROM	從中檢索資料的表	僅在從表選擇資料時使用
WHERE	行級過濾	否
GROUP BY	分組說明	僅在按組計算聚集時使用
HAVING	組級過濾	否
ORDER BY	輸出排序順序	否

12. 子查詢

12.1 利用子查詢進行過濾

現在查詢草帽海賊團的排名資訊，

mysql> SELECT rank
    -> FROM rank_info
    -> WHERE id IN (SELECT id
    ->                     FROM one_piece
    ->                     WHERE pirates = '草帽海賊團');

注意：

在 SELECT 陳述句中，子查詢總是從內向外處理，
作為子查詢的 SELECT 陳述句只能查詢單個列，檢索多個列會報錯，

12.2 作為計算欄位使用子查詢

查詢海賊團排名和任務資訊，首先從 one_piece 表中根據 id 檢索出排名資訊，再統計每個冒險團的人數，

mysql> SELECT rank,
    -> (SELECT COUNT(*)
    ->  FROM one_piece AS oe
    ->  WHERE oe.id = ro.id) AS num_person
    -> FROM rank_info AS ro
    -> ORDER BY rank;

注意：上面的例子中使用的是 oe.id 和 ro.id ，而不是直接使用 id ，因為在兩個表中都有 id 列，在有可能混淆列名時必須使用這種語法，

13. 表聯結

13.1 自聯結

假如現在有人不知道喬巴所屬的海賊團, 想要知道喬巴所屬海賊團的所有成員名稱與賞金，
先看一下子查詢的方式：

mysql> SELECT name, bounty
    -> FROM one_piece
    -> WHERE pirates = (SELECT pirates
    ->                    FROM one_piece
    ->                    WHERE name = '喬巴');

接下來使用自聯結的方式：

mysql> SELECT c1.name, c1.bounty
    -> FROM Customers AS c1, Customers AS c2
    -> WHERE c1.pirates = c2.pirates
    ->  AND c2.name = '喬巴';

通常情況下，自聯結的方式比子查詢的方式要快很多，

13.2 等值聯結

聯結是一種機制，用來在一條 SELECT 陳述句中關聯表，因此稱為聯結，使用特殊的語法，可以聯結多個表回傳一組輸出，聯結在運行時關聯表中正確的行，聯結不是物理物體，換句話說，它在實際的資料庫表中并不存在，它只在查詢執行期間存在，

兩表 table1， table2 中資料如下：

table1                      table2
+------+------+------+      +------+------+------+
| A    | B    | C    |      | C    | D    | E    |
+------+------+------+      +------+------+------+
|    1 |    2 |    3 |      |    2 |    3 |    4 |
|    4 |    5 |    6 |      |    6 |    7 |    8 |
+------+------+------+      +------+------+------+

現在通過表聯結，獲取兩個表中的資料，

mysql> SELECT *
    -> FROM table1 AS t1, table2 AS t2
    -> WHERE t1.C = t2.C;
+------+------+------+------+------+------+
| A    | B    | C    | C    | D    | E    |
+------+------+------+------+------+------+
|    4 |    5 |    6 |    6 |    7 |    8 |
+------+------+------+------+------+------+

注意：上例中WHERE 中限制了聯結條件，如果沒有條件的話，回傳的結果就是兩表的笛卡爾積，回傳 6 × 9 共 54條資料

13.3 行內結

上面的聯結準確來說是等值聯結，也可以稱為行內結，它還有另一種語法，回傳的結果以上面相同，

mysql> SELECT *
    -> FROM table1 AS t1 INNER JOIN table2 AS t2
    ->   ON t1.C = t2.C;
+------+------+------+------+------+------+
| A    | B    | C    | C    | D    | E    |
+------+------+------+------+------+------+
|    4 |    5 |    6 |    6 |    7 |    8 |
+------+------+------+------+------+------+

一般行內結可以用如下圖進行表示，取兩個表關聯欄位相同的部分，

13.4 自然聯結

自然連接是一種特殊的等值連接，它在兩個關系表中自動比較相同的屬性列，無須添加連接條件，并且在結果中消除重復的屬性列，

mysql> SELECT *
    -> FROM table1 AS t1 NATURAL JOIN table2 t2;
+------+------+------+------+------+
| C    | A    | B    | D    | E    |
+------+------+------+------+------+
|    6 |    4 |    5 |    7 |    8 |
+------+------+------+------+------+

13.5 外聯結

13.5.1 左外聯結

左外聯結，左表( table1 )的記錄將會全部表示出來，而右表( table2 )只會顯示符合搜索條件的記錄，右表記錄不足的地方均為 NULL ，

mysql> SELECT *
    -> FROM table1 AS t1 LEFT JOIN table2 AS t2
    ->   ON t1.C = t2.C;
+------+------+------+------+------+------+
| A    | B    | C    | C    | D    | E    |
+------+------+------+------+------+------+
|    4 |    5 |    6 |    6 |    7 |    8 |
|    1 |    2 |    3 | NULL | NULL | NULL |
+------+------+------+------+------+------+

13.5.2 右外聯結

右外聯結，右表( table2 )的記錄將會全部表示出來，而右左表( table1 )只會顯示符合搜索條件的記錄，左表記錄不足的地方均為 NULL ，

mysql> SELECT *
    -> FROM table1 AS t1 RIGHT JOIN table2 AS t2
    ->  ON t1.C = t2.C;
+------+------+------+------+------+------+
| A    | B    | C    | C    | D    | E    |
+------+------+------+------+------+------+
|    4 |    5 |    6 |    6 |    7 |    8 |
| NULL | NULL | NULL |    2 |    3 |    4 |
+------+------+------+------+------+------+

13.6 四種聯結對比圖

行內結	自然聯結（去重）
左外聯結	右外聯結

14. 插入資料

14.1 插入完整行

使用 INSERT 插入完整行它要求指定表名和插入到新行中的值，

mysql> INSERT INTO one_piece
    -> VALUES('1',
    ->        '草帽海賊團',
    ->        '路飛',
    ->        'age',
    ->        '團長',
    ->        '1500000000');

注意：

必須每列提供一個值，空值使用NULL
各列必須以它們在表定義中出現的次序填充

14.2 插入部分行

INSERT 推薦的插入方法是明確給出表的列名，這樣還可以省略列，即只給某些列提供值，給其他列不提供值，

省略的列必須滿足以下某個條件：

該列定義為允許 NULL 值（無值或空值），
在表定義中給出默認值（如果不給出值，將使用默認值），

如果表中不允許有 NULL 值或者默認值，這時卻省略了表中的值， DBMS 就會產生錯誤訊息，相應的行不能成功插入，

現在同樣在 one_piece 表中插入一行，

mysql> INSERT INTO one_piece(id,
    ->                       pirates,
    ->                       name)
    -> VALUES('1',
    ->        '草帽海賊團',
    ->        '路飛');

不管使用哪種INSERT 語法，VALUES 的數目都必須正確，如果不提供列名，則必須給每個表列提供一個值；如果提供列名，則必須給列出的每個列一個值，否則，就會產生一條錯誤訊息，相應的行不能成功插入，

14.3 從一個表復制到另一個表

有一種資料插入不使用 INSERT 陳述句，要將一個表的內容復制到一個全新的表（運行中創建的表），

mysql> CREATE TABLE one_pieceCopy AS
    -> SELECT * FROM one_piece;

任何 SELECT 選項和子句都可以使用，包括 WHERE 和 GROUP BY，
可利用聯結從多個表插入資料，
不管從多少個表中檢索資料，資料都只能插入到一個表中，

主要用途：它是試驗新 SQL 陳述句前進行表復制的很好工具，先進行復制，可在復制的資料上測驗 SQL 代碼，而不會影響實際的資料，

15.更新資料

使用 UPDATE 陳述句，更新（修改）表中的資料，

有兩種使用 UPDATE 的方式：

更新表中的特定行
更新表中的所有行

使用時要明確是 更新特定行 還是 更新所有行，

UPDATE 陳述句中可以使用子查詢，使得能用 SELECT 陳述句檢索出的資料更新列資料，

15.1 更新單行單列

將 路飛 的賞金更新為 10000000000

mysql> UPDATE one_piece
    -> SET bounty = 10000000000
    -> WHERE name = '路飛';

15.2 更新單行多列

在更新多個列時，只需要使用一條 SET 命令，每個“列=值”對之間用逗號分隔（最后一列之后不用逗號），

mysql> UPDATE one_piece
    -> SET bounty = 10000000000,
    ->     age = '19'
    -> WHERE name = '路飛';

15.3 更新所有行

不使用 WHERE 限制條件，即更新表中所有行，

mysql> UPDATE one_piece
    -> SET bounty = 10000000000,
    ->     age = '19'

15.4 洗掉列中的值

假如表定義允許 NULL 值，要洗掉某個列的值，可設定它為 NULL，（要注意洗掉列值（保留列結構）和洗掉列（完全洗掉）的區別）

mysql> UPDATE one_piece
    -> SET bounty = NULL
    -> WHERE name = '路飛';

16. 洗掉資料

使用 DELETE 陳述句，洗掉表中的資料，

有兩種使用 DELETE 的方式：

洗掉表中的特定行
洗掉表中的所有行

使用時要明確是 洗掉特定行 還是 洗掉所有行，

16.1 洗掉單行

洗掉 one_piece 表中 name 為 路飛 的行，

mysql> DELETE FROM one_piece
    -> WHERE name = '路飛';

16.2 洗掉所有行

洗掉 Customers 中的所有行，不洗掉表本身，

mysql> DELETE FROM one_piece;

如果想從表中洗掉所有行，推薦使用 TRUNCATE TABLE 陳述句，它完成相同的作業，而速度更快（因為不記錄資料的變動），

但要注意： TRUNCATE 屬于資料定義語言（ DDL ），且 TRUNCATE 命令執行后無法回滾，使用 TRUNCATE 命令之前最好對當前表中的資料做備份，

mysql> TRUNCATE TABLE one_piece;

17.存盤程序

17.1 為什么使用存盤程序

優點：

通過把 “某個處理” 封裝在一個易用的單元中，可以簡化復雜的操作
由于不要求反復建立一系列處理步驟，因而保證了資料的一致性，
簡化對變動的管理，如果表名、列名或業務邏輯（或別的內容）有變化，那么只需要更改存盤程序的代碼，使用它的人員甚至不需要知道這些變化，
因為存盤程序通常以編譯過的形式存盤，所以DBMS處理命令所需的作業量少，提高了性能，

簡單來說，使用存盤程序有三個主要的好處：簡單、安全、高性能，

17.2 創建存盤程序

我們來看一個簡單的存盤程序例子，對草帽海賊團人數進行計數，

mysql> DELIMITER $$
mysql> CREATE PROCEDURE personCount()
    -> BEGIN
    ->     SELECT COUNT(*) AS num_person
    ->     FROM one_piece
    ->     WHERE pirates = '草帽海賊團';
    -> END$$

在定義程序時，使用 DELIMITER $$ 命令將陳述句的結束符號從分號 ; 臨時改為 $$，使得程序體中使用的分號被直接傳遞到服務器，而不會被 Mysql 解釋，

使用 CALL 存盤程序名(引數) 來呼叫存盤程序，

mysql> DELIMITER ;
mysql> CALL personCount();

17.3 存盤程序體

存盤程序體包含了在程序呼叫時必須執行的陳述句，例如：dml、ddl陳述句，if-then-else和while-do陳述句、宣告變數的declare陳述句等，

程序體格式：以begin開始，以end結束(可嵌套)

BEGIN
　　BEGIN
　　　　BEGIN
　　　　　　statements; 
　　　　END
　　END
END

注意：每個嵌套塊及其中的每條陳述句，必須以分號結束，表示程序體結束的 begin-end 塊(又叫做復合陳述句 compound statement )，則不需要分號，

17.4 存盤程序引數

存盤程序可以有0個或多個引數，用于存盤程序的定義，

3種引數型別：

IN (輸入引數)：表示呼叫者向程序傳入值（傳入值可以是字面量或變數）
OUT (輸出引數)：表示程序向呼叫者傳出值(可以回傳多個值)（傳出值只能是變數）
INOUT (輸入輸出引數)：既表示呼叫者向程序傳入值，又表示程序向呼叫者傳出值（值只能是變數）

17.4.1 IN輸入引數

mysql> DELIMITER $$
mysql> CREATE PROCEDURE in_test(IN p_in INT)
    -> BEGIN
    ->     SELECT p_in;    -- 第一次查詢
    ->     SET p_in = 2;   -- 修改p_in的值
    ->     SELECT p_in;    -- 第二次查詢
    -> END$$
    
mysql> DELIMITER ;

mysql> SET @p_in = 1;

mysql> CALL in_test(@p_in);
+------+
| p_in |
+------+
|    1 |
+------+

+------+
| p_in |
+------+
|    2 |
+------+

mysql> SELECT @p_in;
+-------+
| @p_in |
+-------+
|     1 |
+-------+

雖然 p_in 在存盤程序中被修改，但并不影響 @p_in 的值，因為 in_test 只接受輸入引數，并不輸出引數，所以相當于在函式內改變，但并未將這個值輸出給 @p_in ，

17.4.2 OUT輸入引數

mysql> DELIMITER $$
mysql> CREATE PROCEDURE out_test(OUT p_out INT)
    -> BEGIN
    ->     SELECT p_out;    -- 第一次查詢
    ->     SET p_out = 2;   -- 修改p_out的值
    ->     SELECT p_out;    -- 第二次查詢
    -> END$$

mysql> DELIMITER ;

mysql> SET @p_out = 1;

mysql> CALL out_test(@p_out);
+-------+
| p_out |
+-------+
|  NULL |
+-------+

+-------+
| p_out |
+-------+
|     2 |
+-------+

mysql> SELECT @p_out;
+--------+
| @p_out |
+--------+
|      2 |
+--------+

第一個回傳結果為 NULL 是因為 OUT 是向呼叫者輸出引數，不接收輸入的引數，所以第一次查詢時 p_out 還未賦值，所以是 NULL ，最后 @p_out 變數的值變為2是因為呼叫了 out_test 存盤程序，輸出引數，改變了 p_out 變數的值，

17.4.3 INOUT輸入輸出引數

mysql> DELIMITER $$
mysql> CREATE PROCEDURE inout_test(INOUT p_inout INT)
    -> BEGIN
    ->     SELECT p_inout;    -- 第一次查詢
    ->     SET p_inout = 2;   -- 修改p_inout的值
    ->     SELECT p_inout;    -- 第一次查詢
    -> END$$
    
mysql> DELIMITER ;

mysql> SET @p_inout = 1;

mysql> CALL inout_test(@p_inout);
+---------+
| p_inout |
+---------+
|       1 |
+---------+

+---------+
| p_inout |
+---------+
|       2 |
+---------+

mysql> SELECT @p_inout;
+----------+
| @p_inout |
+----------+
|        2 |
+----------+

呼叫 inout_test 存盤程序，既接受了輸入的引數，也輸出引數， @p_inout 的值被改變，

17.5 洗掉存盤程序

使用 DROP PROCEDURE 來洗掉存盤程序，

mysql> DROP PROCEDURE in_test;

18.管理事務處理

18.1 事務處理

事務處理（transaction processing）是一種機制，用來管理必須成批執行的SQL` 操作，保證資料庫不包含不完整的操作結果，利用事務處理，可以保證一組操作不會中途停止，它們要么完全執行，要么完全不執行（除非明確指示），如果沒有錯誤發生，整組陳述句提交給（寫到）資料庫表；如果發生錯誤，則進行回退（撤銷），將資料庫恢復到某個已知且安全的狀態，以此來維護資料庫的完整性，

事務處理術語：

事務（transaction）：指一組 SQL 陳述句；
回退（rollback）：指撤銷指定 SQL 陳述句的程序；
提交（commit）：指將未存盤的 SQL 陳述句結果寫入資料庫表；
保留點（savepoint）：指事務處理中設定的臨時占位符（placeholder），可以對它發布回退（與回退整個事務處理不同），

事務處理用來管理 INSERT、UPDATE 和 DELETE 陳述句，不能回退 SELECT 陳述句（回退 SELECT 陳述句也沒有必要），也不能回退 CREATE 或 DROP 操作，事務處理中可以使用這些陳述句，但進行回退時，這些操作也不撤銷，

一般來說，事務是必須滿足4個條件（ ACID ）：：原子性（Atomicity，或稱不可分割性）、一致性（Consistency）、隔離性（Isolation，又稱獨立性）、持久性（Durability），

原子性： 一個事務（ transaction ）中的所有操作，要么全部完成，要么全部不完成，不會結束在中間某個環節，事務在執行程序中發生錯誤，會被回滾（ Rollback ）到事務開始前的狀態，就像這個事務從來沒有執行過一樣，
一致性： 在事務開始之前和事務結束以后，資料庫的完整性沒有被破壞，這表示寫入的資料必須完全符合所有的預設規則，這包含資料的精確度、串聯性以及后續資料庫可以自發性地完成預定的作業，
隔離性： 資料庫允許多個并發事務同時對其資料進行讀寫和修改的能力，隔離性可以防止多個事務并發執行時由于交叉執行而導致資料的不一致，事務隔離分為不同級別，包括讀未提交（ Read uncommitted ）、讀提交（ read committed ）、可重復讀（ repeatable read ）和串行化（ Serializable），
持久性： 事務處理結束后，對資料的修改就是永久的，即便系統故障也不會丟失，

在 MySQL 命令列的默認設定下，事務都是自動提交的，即執行 SQL 陳述句后就會馬上執行 COMMIT 操作，因此要顯式地開啟一個事務務須使用命令 BEGIN 或 START TRANSACTION，或者執行命令 SET AUTOCOMMIT=0，用來禁止使用當前會話的自動提交，

18.2 控制事務處理

BEGIN / START TRANSACTION ：顯式地開啟一個事務；
COMMIT / COMMIT WORK ：提交事務，使已對資料庫進行的所有修改成為永久性的；
ROLLBACK / ROLLBACK WORK ：回滾會結束用戶的事務，并撤銷正在進行的所有未提交的修改；
SAVEPOINT ：SAVEPOINT 允許在事務中創建一個保存點，一個事務中可以有多個 SAVEPOINT；
RELEASE SAVEPOINT ：洗掉一個事務的保存點，當沒有指定的保存點時，執行該陳述句會拋出一個例外；
ROLLBACK TO ：把事務回滾到標記點；
SET TRANSACTION ：用來設定事務的隔離級別，InnoDB 存盤引擎提供事務的隔離級別有 READ UNCOMMITTED（讀未提交）、READ COMMITTED（讀已提交，專案中常用）、REPEATABLE READ（可重復讀，Mysql 默認隔離級別）和 SERIALIZABLE（串行化），

簡單示例：

mysql> use test;

mysql> CREATE TABLE transaction_test(id int(5)) ENGINE = INNODB;  # 創建資料表
 
mysql> SELECT * FROM transaction_test;
Empty set (0.01 sec)

mysql> BEGIN;  # 開始事務
 
mysql> INSERT INTO runoob_transaction_test VALUE(1);
 
mysql> INSERT INTO runoob_transaction_test VALUE(2);
 
mysql> COMMIT; # 提交事務
 
mysql>  SELECT * FROM transaction_test;
+------+
| id   |
+------+
| 1    |
| 2    |
+------+



mysql> BEGIN;    # 開始事務

mysql> INSERT INTO transaction_test VALUES(3);

mysql> SAVEPOINT first_insert;    # 宣告一個保存點

mysql> INSERT INTO transaction_test VALUES(4);

mysql> SAVEPOINT second_insert;    # 宣告一個保存點

mysql> INSERT INTO transaction_test VALUES(5);

mysql> ROLLBACK TO second_insert;    # 回滾到 second_insert 保存點

mysql> SELECT * FROM transaction_test;    # 因為回滾所以資料沒有插入
+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
|    4 |
+------+

mysql> ROLLBACK TO first_insert;

mysql> SELECT * FROM transaction_test;
+------+
| id   |
+------+
|    1 |
|    2 |
|    3 |
+------+

mysql> COMMIT;    # 執行 COMMIT 或 ROLLBACK 后保存點自動釋放

18.3 事務隔離級別

先看一下如何查看事務隔離級別，

# 查看默認事務隔離級別（session）
select @@transaction_isolation;
# 查看當前會話的隔離級別
select @@session.transaction_isolation;
# 查看全域的事務隔離級別
select @@global.transaction_isolation;

在 Mysql 下事務的隔離級別有四種，由低到高依次為 Read uncommitted 、Read committed 、Repeatable read (默認)、Serializable ，這四個級別中的后三個級別可以逐個解決臟讀、不可重復讀 、幻讀的問題，

18.3.1 臟讀

對于兩個事務T1與T2，T1讀取了已經被T2更新但是還沒有提交的欄位之后，若此時T2回滾，T1讀取的內容就是臨時并且無效的，

示例：

打開兩個Mysql客戶端，分別執行下面操作，查詢當前會話的隔離級別（默認 REPEATABLE READ ），修改當前會話隔離級別為（ READ UNCOMMITTED ），全域事務隔離級別仍然為 REPEATABLE READ ，

mysql> SELECT @@session.transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| REPEATABLE-READ         |
+-------------------------+

mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;    # 修改會話隔離級別

mysql> SELECT @@session.transaction_isolation;    # 當前會話隔離級別已修改
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-UNCOMMITTED                |
+---------------------------------+

mysql> SELECT @@global.transaction_isolation;    # 全域事務隔離級別未修改
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| REPEATABLE-READ                |
+--------------------------------+

之后黑框用來做更新，白框用來查詢，

在這里插入圖片描述

由于黑框的 ④ 回滾，白色背景的客戶端中 ③ 讀取的資料就是臨時并且無效的，即臟讀，

18.3.2 不可重復讀

對于兩個事務T1和T2，T1讀取了一個欄位，然后T2更新了該欄位并提交之后，當T1再次讀取的時候，結果不一致的情況發生，
在這里插入圖片描述

由于黑框的更新操作，白框出現兩次讀取的結果不一致，

18.3.3 幻讀

對于兩個事務T1、T2，T1從表中讀取資料，然后T2進行了INSERT操作并提交，當T1再次讀取的時候，結果不一致的情況發生，
在這里插入圖片描述

由于黑框的插入操作，白框出現兩次讀取的結果不一致，

幾種現象在各隔離級別中出現的可能性：

隔離級別	臟讀（Dirty Read）	不可重復讀（NonRepeatable Read）	幻讀（Phantom Read）
未提交讀（Read uncommitted）	可能	可能	可能
已提交讀（Read committed）	不可能	可能	可能
可重復讀（Repeatable read）	不可能	不可能	可能
可串行化（Serializable ）	不可能	不可能	不可能

19. 游標

SQL 檢索操作回傳結果集，簡單地使用 SELECT 陳述句，沒有辦法得到第一行、下一行或前 10 行，有時，需要在檢索出來的行中前進或后退一行或多行，這就是游標的用途所在，游標（cursor）是一個存盤在 DBMS 服務器上的資料庫查詢，它不是一條 SELECT 陳述句，而是被該陳述句檢索出來的結果集，在存盤了游標之后，應用程式可以根據需要滾動或瀏覽其中的資料，

19.1 使用游標

游標使用的步驟：

在使用游標前，必須宣告（定義）它，這個程序實際上沒有檢索資料，它只是定義要使用的 SELECT 陳述句和游標選項，
一旦宣告，就必須打開游標以供使用，這個程序用前面定義的 SELECT 陳述句把資料實際檢索出來，
對于填有資料的游標，根據需要取出（檢索）各行，
在結束游標使用時，必須關閉游標，可能的話，釋放游標，

宣告游標后，可以根據需要頻繁地 打開或關閉 游標，在游標打開時，可根據需要頻繁地執行取操作，

注意：不像多數DBMS，MySQL游標只能用于存盤程序（和函式），

19.2 創建游標

使用 DECLEAR 來創建游標，DECLARE 命名游標，并定義相應的 SELECT 陳述句，根據需要帶 WHERE 和其他子句，

下面的陳述句定義了名為 ordernumbers 的游標，使用了可以檢索所有訂單的 SELECT 陳述句，

Order表中的資訊：

在這里插入圖片描述

DROP PROCEDURE IF EXISTS processorder;
CREATE PROCEDURE processorder()
BEGIN
	-- 定義游標
	DECLARE ordernumbers CURSOR
	FOR
	SELECT order_num FROM orders;
END;

這個存盤程序中，使用 DECLARE 陳述句用來定義和命名游標，存盤程序處理完成后，游標就消失（因為它局限于存盤程序），

19.3 使用游標資料

使用 OPEN 陳述句來打開游標，CLOSE 陳述句關閉游標，在一個游標被打開后，可以使用 FETCH 陳述句分別訪問它的每一行，FETCH 指定檢索的資料（所需的列），資料存盤的位置（定義的變數），它還向前移動游標中的內部行指標，使下一條 FETCH 陳述句檢索下一行（不重復讀取同一行），

DROP PROCEDURE IF EXISTS processorder;
CREATE PROCEDURE processorder()
BEGIN
    -- 定義區域變數
    DECLARE num INT;
    -- 定義游標
    DECLARE ordernumbers CURSOR
    FOR
    SELECT order_num FROM orders;
    -- 打開游標
    OPEN ordernumbers;
    -- 獲取第一行資料
    FETCH ordernumbers INTO num;
    -- 查詢結果
    SELECT num;
    -- 關閉游標
    CLOSE ordernumbers;
END;
CALL processorder();

在這里插入圖片描述

其中 FETCH 用來檢索當前行的 order_num 列（將自動從第一行開始）到一個名為 num 的區域變數中，并將查詢 num 的結果，由于只檢索到第一行，所以 num 的值為 ‘20005’，

下面，回圈檢索資料，從第一行到最后一行，

DROP PROCEDURE IF EXISTS processorder;
CREATE PROCEDURE processorder()
BEGIN
	-- 定義區域變數
	DECLARE done BOOLEAN DEFAULT false;
	DECLARE num INT;
	-- 定義游標
	DECLARE ordernumbers CURSOR
	FOR
	SELECT order_num FROM orders;
	-- 定義CONTINUE HANDLER
	DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=true;
	-- 打開游標
	OPEN ordernumbers;
	-- 回圈所有行
	REPEAT
		-- 獲取第一行資料
		FETCH ordernumbers INTO num;
	-- 結束回圈
	UNTIL done END REPEAT;
	-- 查詢結果
	SELECT num;
	-- 關閉游標
	CLOSE ordernumbers;
END;
CALL processorder();

在這里插入圖片描述

回圈了結果集的所有行，所以 num 的值是最后一行的資料，

與上一個例子不同之處是，這個例子的 FETCH 是在 REPEAT 內，因此它反復執行直到 done 為真，

DECLARE CONTINUE HANDLER FOR SQLSTATE ‘02000’ SET done=true;

這條陳述句定義了一個 CONTINUE HANDLER，它是在條件出現時被執行的代碼，這里，它指出當 SQLSTATE '02000' 出現時，SET done=true，SQLSTATE '02000'是一個未找到條件，當 REPEAT 由于沒有更多的行供回圈而不能繼續時，出現這個條件，

19.4 游標的優缺點

優點：游標是面向集合與面向行的設計思想之間的一種橋梁，因為游標是針對行操作的，所以對從資料庫中 SELECT 查詢得到的每一行可以進行分開的獨立的相同或不同的操作，是一種分離的思想，可以滿足對某個結果行進行特殊的操作，如基于游標位置的增刪改查能力，

缺點：

速度較慢
會產生死鎖現象
記憶體大

20. 約束

20.1 約束

DBMS 通過在資料庫表上施加約束來實施參考完整性，大多數約束是在表定義中定義的，用 CREATE TABLE 或是 ALTER TABLE 陳述句，

20.2 主鍵

主鍵是一種特殊的約束，用來保證一列（或一組列）中的值是唯一的，而且永不改動，沒有主鍵，要安全地 UPDATE 或 DELETE 特定行而不影響其他行會非常困難，

主鍵的條件：

任意兩行的主鍵值都不相同，
每行都具有一個主鍵值（即列中不允許 NULL 值），

創建表時定義主鍵，

CREATE TABLE teacher
(
	id INT(11) PRIMARY KEY,
	teacher_name VARCHAR(10)
);

使用 ALTER TABLE 添加主鍵，

ALTER TABLE teacher
ADD CONSTRAINT PRIMARY KEY(id);

洗掉主鍵約束，

ALTER TABLE teacher DROP PRIMARY KEY;

20.3 外鍵

外鍵是表中的一列，其值必須列在另一表的主鍵中，外鍵是保證參考完整性的極其重要部分，

下面新建 student 表并添加外鍵 teacher_id 與 teacher 表中的主鍵 id 進行關聯，

在創建表的時定義外鍵，

CREATE TABLE student
(
	stu_id INT(11) PRIMARY KEY,
	teacher_id INT(11) REFERENCES teacher(id),
	stu_name VARCHAR(10)
);

使用 ALTER TABLE 添加外鍵，

ALTER TABLE student
ADD CONSTRAINT teacher_id_id
FOREIGN KEY (teacher_id) REFERENCES teacher(id);

使用外鍵可以有效地防止意外洗掉，比如在上面兩表中如果洗掉 teacher 表中的資訊，如果該 id 在 student 表中也有出現，那么 Mysql 會防止洗掉操作，當然也可以啟用級聯洗掉的特性，那么在洗掉時就會洗掉所有相關資訊，

洗掉外鍵，

ALTER TABLE student DROP FOREIGN KEY teacher_id_id;

20.4 唯一約束

唯一約束用來保證一列（或一組列）中的資料是唯一的，它們類似于主鍵，但存在以下重要區別，

表可包含多個唯一約束，但每個表只允許一個主鍵，
唯一約束列可包含 NULL 值，
與主鍵不一樣，唯一約束不能用來定義外鍵，

在創建表的時定義唯一約束，

CREATE TABLE student
(
	stu_id INT(11) PRIMARY KEY,
	teacher_id INT(11) REFERENCES teacher(id),
	stu_name VARCHAR(10)
);

使用 ALTER TABLE 添加唯一約束，

ALTER TABLE student
ADD CONSTRAINT unique_id UNIQUE(stu_id);

洗掉唯一性約束，

ALTER TABLE student DROP INDEX unique_id;

20.5 檢查約束

檢查約束用來保證一列（或一組列）中的資料滿足一組指定的條件，

常見用途：

檢查最小或最大值，
指定范圍，
只允許特定的值，

下面創建一個檢查約束來限制性別列只能輸入男、女，

在創建表的時定義檢查約束，

CREATE TABLE student
(    
    stu_id INT(11) PRIMARY KEY,
	gender VARCHAR(1) CHECK(gender IN('男', '女'))
);

使用 ALTER TABLE 添加檢查約束，

ALTER TABLE student ADD CONSTRAINT check_gender CHECK(gender in ('男', '女'));

洗掉檢查約束，

ALTER TABLE student DROP CHECK check_gender;

21. 索引

索參考來排序資料以加快搜索和排序操作的速度，主鍵資料總是排序的，因此，按主鍵檢索特定行總是一種快速有效的操作，但是，搜索其他列中的值通常效率不高，這時候我們可以使用索引，在一個或多個列上定義索引，使 DBMS保存其內容的一個排過序的串列，在定義了索引后，DBMS 以使用書的索引類似的方法使用它，DBMS 搜索排過序的索引，找出匹配的位置，然后檢索這些行，

索引特點：

索引提高檢索的性能，但降低了資料增刪改的性能，在執行這些操作時，DBMS 必須動態地更新索引，
索引資料可能要占用大量的存盤空間，
并非所有資料都適合做索引，取值不多的資料（如地區）不如具有更多可能值的資料（如姓名），能夠更加體現索引的價值，
索參考于資料過濾和資料排序，如果你經常以某種特定的順序排序資料，則該資料可能適合做索引，
可以在索引中定義多個列（例如，國家 + 城市），

21.1 普通索引

在創建表的時創建普通索引，

DROP TABLE IF EXISTS student;
CREATE TABLE student
(    
  	id INT(11),
	stu_name VARCHAR(10)
)

直接創建，

CREATE INDEX stu_id ON student(id);

修改表時創建，

ALTER TABLE student ADD INDEX stu_id(id);

洗掉索引，

DROP INDEX stu_id ON student;

21.2 唯一索引

唯一索引列值必須唯一，但允許有空值（注意和主鍵不同），如果是組合索引，則列值的組合必須唯一，事實上，在許多場合，創建唯一索引的目的往往不是提高訪問速度，而是為了避免資料出現重復，

CREATE UNIQUE INDEX stu_id ON student(id);

21.3 全域索引

全文索引只能作用在 CHAR、VARCHAR、TEXT、型別的欄位上，創建全文索引需要使用 FULLTEXT 引數進行約束，

CREATE FULLTEXT INDEX s_name ON student(stu_name);

21.4 多列索引

多列索引，即在資料表的多個欄位上創建索引，

CREATE TABLE student
(    
  id INT(11),
	stu_name VARCHAR(10),
	email VARCHAR(20),
	INDEX info(stu_name, email)
);

在多列索引中，只有查詢條件中使用了這些欄位中的第一個欄位(即上面示例中的 stu_name 欄位)，索引才會被使用（最左前綴’原則），如果沒有用到第一欄位，則索引不起任何作用，

-- 使用索引
SELECT * FROM student WHERE stu_name = '張三';
SELECT * FROM student WHERE stu_name = '李四' AND email = '11111@qq.com';
-- 未使用索引
SELECT * FROM student WHERE email = '11111@qq.com';

這就是本文所有的內容了，如果感徑訓不錯的話，? 點個贊再走吧！！！?

后續會繼續分享各種干貨，如果感興趣的話可以點個關注不迷路哦~，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/297629.html

標籤：其他

上一篇：快速排序思路（挖坑版），代碼實作

下一篇：詳解linux中rsync的妙用