MySQL這個軟體想將數據處理的所有事情，能夠在mysql這個層面上全部都做了，也就是說它想要完成一件事，以後想開發的人，例如想寫python程式的人，你就專門的寫你自己的python程式，以後凡是關於數據的增刪改查，全部都在MySQL裡面完成，也就是說它想實現一個數據處理與應用程式的一個完全的解耦和狀態，比如說，如果我是個應用程式設計師，我想要查詢數據，我不需要自己寫sql語句，只需要調用mysql封裝好的一些功能，直接調用這個功能就可以了，之前我們使用sql來進行數據的增刪改查，其實sql也可以算作一個開發語言，有專門招資料庫開發的崗位，也就是說mysql想做這麼一個事兒，以後啊，專門有人寫應用程式的開發，專門有人來寫sql，來開發sql部分，在資料庫層面根據應用層的程式設計師的要求，把sql語句全部寫好，各種複雜的需求全部幫你封裝好，封裝成一個一個的功能，應用程式開發程式設計師在根據自己的需求來使用這些功能，直接調用就可以了，這是mysql想要完成的事情，但是咱們以後做開發，一般不會這麼搞，一般招聘需求裡面都會有一項是要會sql，淺顯的說是因為花最少的錢，做最多的事兒，但是往深了說是因為公司裡面一般不會用這些內置的功能去sql的工作，至於為什麼，咱們學完mysql之後再說吧~~~
一 視圖
視圖是一個虛擬表（非真實存在），是跑到記憶體中的表，真實表是硬碟上的表，怎麼就得到了虛擬表，就是你查詢的結果，只不過之前我們查詢出來的虛擬表，從記憶體中取出來顯示在螢幕上，記憶體中就沒有了這些表的數據，但是下次我要是想用這個虛擬表呢，沒辦法，只能重新查一次，每次都要重新查。其本質是【根據SQL語句獲取動態的數據集，並為其命名】，用戶使用時只需使用【名稱】即可獲取結果集，可以將該結果集當做表來使用。如果我們想查詢一些有關聯的表，比如我們前面的老師學生班級什麼的表，我可能需要幾個表聯合查詢的結果，但是這幾張表在硬碟上是單獨存的，所以我們需要通過查詢的手段，將這些表在記憶體中拼成一個虛擬表，然後是不是我們再基於虛擬表在進行進一步的查詢，然後我們如果以後想重新再查一下這些關係數據，還需要對硬碟上這些表進行再次的重新載入到內容，聯合成虛擬表，然後再篩選等等的操作，意味著咱們每次都在寫重複的sql語句，那有沒有好的方法啊，其實很簡單，我們把重複用的這些sql邏輯封裝起來，然後下次使用的時候直接調用這個封裝好的操作就可以了，這個封裝起來的操作就類似我們下面要說的視圖
為什麼要用視圖：使用視圖我們可以把查詢過程中的臨時表摘出來，保存下來，用視圖去實現，這樣以後再想操作該臨時表的數據時就無需重寫複雜的sql了，直接去視圖中查找即可，但視圖有明顯地效率問題，並且視圖是存放在資料庫中的，如果我們程式中使用的sql過分依賴資料庫中的視圖，即強耦合，那就意味著擴展sql極為不便，因此並不推薦使用
臨時表應用舉例：
#兩張有關係的表 mysql> select * from course; +-----+--------+------------+ | cid | cname | teacher_id | +-----+--------+------------+ | 1 | 生物 | 1 | | 2 | 物理 | 2 | | 3 | 體育 | 3 | | 4 | 美術 | 2 | +-----+--------+------------+ 4 rows in set (0.00 sec) mysql> select * from teacher; +-----+-----------------+ | tid | tname | +-----+-----------------+ | 1 | 張磊老師 | | 2 | 李平老師 | | 3 | 劉海燕老師 | | 4 | 朱雲海老師 | | 5 | 李傑老師 | +-----+-----------------+ 5 rows in set (0.00 sec) #查詢李平老師教授的課程名 mysql> select cname from course where teacher_id = (select tid from teacher where tname='李平老師'); #子查詢的方式
+--------+ | cname | +--------+ | 物理 | | 美術 | +--------+ 2 rows in set (0.00 sec) #子查詢出臨時表，作為teacher_id等判斷依據 select tid from teacher where tname='李平老師'
一 創建視圖
#語法：CREATE VIEW 視圖名稱 AS SQL語句 create view teacher_view as select tid from teacher where tname='李平老師';
mysql> show tables;
+—————+
| Tables_in_crm |
+—————+
| class |
| course |
| score |
| student |
| teacher |
| teacher_view | #看這裡
+—————+
mysql> desc teacher_view; #有表結構
+——-+———+——+—–+———+——-+
| Field | Type | Null | Key | Default | Extra |
+——-+———+——+—–+———+——-+
| tid | int(11) | NO | | 0 | |
+——-+———+——+—–+———+——-+
1 row in set (0.04 sec)
mysql> select * from teacher_view; #有表數據
+—–+
| tid |
+—–+
| 2 |
+—–+
1 row in set (0.00 sec)
注意：但是在硬碟上你找到自己的mysql安裝目錄裡面的data文件夾裡面的對應的那個庫的文件夾，這個文件夾裡面存著咱們的表資訊，打開之後你會發現，這個視圖表，只有表結構的teacher_view.frm文件，沒有那個.idb存放數據的文件
其實他並沒有真實的數據，也沒有必要再存一份數據，因為它的數據來源於其他兩個表，所以他本質在後台對應的就是一個sql語句而已，所以記住了，視圖只有表結構，沒有表數據
視圖的好處是以後我們如果再需要查詢或者使用上面的虛擬表，就可以直接使用這個視圖了，sql的程式碼量也會省很多。但是弊端也很致命，看下面注意的內容。
#於是查詢李平老師教授的課程名的sql可以改寫為 mysql> select cname from course where teacher_id = (select tid from teacher_view); +--------+ | cname | +--------+ | 物理 | | 美術 | +--------+ 2 rows in set (0.00 sec) #！！！注意注意注意： #1. 使用視圖以後就無需每次都重寫子查詢的sql，開發的時候是方便了很多，但是這麼效率並不高，還不如我們寫子查詢的效率高 #2. 而且有一個致命的問題：視圖是存放到資料庫里的，如果我們程式中的sql過分依賴於資料庫中存放的視圖，那麼意味著，一旦sql需要修改且涉及到視圖的部分，則必須去資料庫中進行修改，然後再到自己的應用程式裡面將那個sql語句改一改，需要很多的修改工作，並而對視圖的更改通常在一般中型及以上公司中資料庫有專門的DBA負責，你要想完成修改，必須付出大量的溝通成本DBA可能才會幫你完成修改，極其地不方便
這麼多的弊端，為什麼mysql還要提供這個東西呢，有一點是因為mysql想把所有數據處理的工作全部接手過來，但其實還有其他的原因，等我們講完存儲過程在和大家說吧。
#3 並且注意：視圖一般都是用於查詢，盡量不要修改(插入、刪除等)視圖中的數據，雖然有時候可以修改成功，但是盡量不要這樣做，因為這個視圖可能是多個表聯合起來生成的一個結果，如果你修改它，可能會造成很多表裡面的數據都跟著被修改了
二 使用視圖
#修改視圖，原始表也跟著改 mysql> select * from course; +-----+--------+------------+ | cid | cname | teacher_id | +-----+--------+------------+ | 1 | 生物 | 1 | | 2 | 物理 | 2 | | 3 | 體育 | 3 | | 4 | 美術 | 2 | +-----+--------+------------+ 4 rows in set (0.00 sec) mysql> create view course_view as select * from course; #創建表course的視圖 Query OK, 0 rows affected (0.52 sec) mysql> select * from course_view; +-----+--------+------------+ | cid | cname | teacher_id | +-----+--------+------------+ | 1 | 生物 | 1 | | 2 | 物理 | 2 | | 3 | 體育 | 3 | | 4 | 美術 | 2 | +-----+--------+------------+ 4 rows in set (0.00 sec) mysql> update course_view set cname='xxx'; #更新視圖中的數據 Query OK, 4 rows affected (0.04 sec) Rows matched: 4 Changed: 4 Warnings: 0 mysql> insert into course_view values(5,'yyy',2); #往視圖中插入數據 Query OK, 1 row affected (0.03 sec) mysql> select * from course; #發現原始表的記錄也跟著修改了 +-----+-------+------------+ | cid | cname | teacher_id | +-----+-------+------------+ | 1 | xxx | 1 | | 2 | xxx | 2 | | 3 | xxx | 3 | | 4 | xxx | 2 | | 5 | yyy | 2 | +-----+-------+------------+ 5 rows in set (0.00 sec)
我們不應該修改視圖中的記錄，而且在涉及多個表的情況下是根本無法修改視圖中的記錄的，如下圖
三 修改視圖
語法：ALTER VIEW 視圖名稱 AS SQL語句，這基本就和刪掉視圖重新創建一個視圖的過程是一樣的，修改視圖沒什麼好講的，這裡就簡單提一下，就不講啦~~，還不如我們直接刪掉，再重新創建呢 mysql> alter view teacher_view as select * from course where cid>3; Query OK, 0 rows affected (0.04 sec) mysql> select * from teacher_view; +-----+-------+------------+ | cid | cname | teacher_id | +-----+-------+------------+ | 4 | xxx | 2 | | 5 | yyy | 2 | +-----+-------+------------+ 2 rows in set (0.00 sec)
四 刪除視圖
語法：DROP VIEW 視圖名稱
DROP VIEW teacher_view
二 觸發器
使用觸發器可以訂製用戶對某一張表的數據進行【增、刪、改】操作時前後的行為，注意：沒有查詢，在進行增刪改操作的時候，觸發的某個操作，稱為觸發器，也就是增刪改的行為觸發另外的一種行為，觸發的行為無非就是sql語句的事情，及自動運行另外一段sql語句。來看一下觸發器怎麼來創建：
一 創建觸發器
# 插入前 CREATE TRIGGER tri_before_insert_tb1 BEFORE INSERT ON tb1 FOR EACH ROW BEGIN #begin和end裡面寫觸發器要做的sql事情，注意裡面的程式碼縮進，並且給觸發器起名字的時候，名字的格式最好這樣寫，有表示意義，一看名字就知道要做什麼，是給哪個表設置的觸發器 ... END # 插入後 CREATE TRIGGER tri_after_insert_tb1 AFTER INSERT ON tb1 FOR EACH ROW BEGIN ... END # 刪除前 CREATE TRIGGER tri_before_delete_tb1 BEFORE DELETE ON tb1 FOR EACH ROW BEGIN ... END # 刪除後 CREATE TRIGGER tri_after_delete_tb1 AFTER DELETE ON tb1 FOR EACH ROW BEGIN ... END # 更新前 CREATE TRIGGER tri_before_update_tb1 BEFORE UPDATE ON tb1 FOR EACH ROW BEGIN ... END # 更新後 CREATE TRIGGER tri_after_update_tb1 AFTER UPDATE ON tb1 FOR EACH ROW BEGIN ... END
插入後觸發觸發器：
#準備表 CREATE TABLE cmd ( #這是一張指令資訊表，你在系統裡面執行的任何的系統命令都在表裡面寫一條記錄 id INT PRIMARY KEY auto_increment, #id USER CHAR (32), #用戶 priv CHAR (10), #許可權 cmd CHAR (64), #指令 sub_time datetime, #提交時間 success enum ('yes', 'no') #是否執行成功，0代表執行失敗 ); CREATE TABLE errlog ( #指令執行錯誤的資訊統計表，專門提取上面cmd表的錯誤記錄 id INT PRIMARY KEY auto_increment, #id err_cmd CHAR (64), #錯誤指令 err_time datetime #錯誤命令的提交時間 ); #現在的需求是：不管正確或者錯誤的cmd，都需要往cmd表裡面插入，然後，如果是錯誤的記錄，還需要往errlog表裡面插入一條記錄
#若果沒有觸發器，我們會怎麼實現，我們完全可以通過咱們的應用程式來做，根據cmd表裡面的success這個欄位是哪個值（yes成功，no表示失敗），在給cmd插入記錄的時候，判斷一下這個值是yes或者no，來判斷一下成功或者失敗，如果失敗了，直接給errlog來插入一條記錄
#但是mysql說，你的應用程式可以省事兒了，你只需要往cmd表裡面插入數據就行了，沒必要你自己來判斷了，可以使用觸發器來實現，可以判斷你插入的這條記錄的success這個欄位對應的值，然後自動來觸發觸發器，進行errlog表的數據插入
#創建觸發器 delimiter // （或者寫$$，其他符號也行，但是不要寫mysql不能認識的，知道一下就行了），delimiter 是告訴mysql，遇到這句話的時候，就將sql語句的結束符分號改成delimiter後面的// CREATE TRIGGER tri_after_insert_cmd AFTER INSERT ON cmd FOR EACH ROW #在你cmd表插入一條記錄之後觸發的。 BEGIN #每次給cmd插入一條記錄的時候，都會被mysql封裝成一個對象，叫做NEW，裡面的欄位都是這個NEW的屬性 IF NEW.success = 'no' THEN #mysql裡面是可以寫這種判斷的，等值判斷只有一個等號，然後寫then INSERT INTO errlog(err_cmd, err_time) VALUES(NEW.cmd, NEW.sub_time) ; #必須加分號，並且注意，我們必須用delimiter來包裹，不然，mysql一看到分號，就認為你的sql結束了，所以會報錯 END IF ; #然後寫end if，必須加分號 END// #只有遇到//這個完成的sql才算結束 delimiter ; #然後將mysql的結束符改回為分號 #往表cmd中插入記錄，觸發觸發器，根據IF的條件決定是否插入錯誤日誌 INSERT INTO cmd ( USER, priv, cmd, sub_time, success ) VALUES ('chao','0755','ls -l /etc',NOW(),'yes'), ('chao','0755','cat /etc/passwd',NOW(),'no'), ('chao','0755','useradd xxx',NOW(),'no'), ('chao','0755','ps aux',NOW(),'yes'); #查詢錯誤日誌，發現有兩條 mysql> select * from errlog; +----+-----------------+---------------------+ | id | err_cmd | err_time | +----+-----------------+---------------------+ | 1 | cat /etc/passwd | 2017-09-14 22:18:48 | | 2 | useradd xxx | 2017-09-14 22:18:48 | +----+-----------------+---------------------+ 2 rows in set (0.00 sec)
特別的：NEW表示即將插入的數據行，OLD表示即將刪除的數據行。
二 使用觸發器
觸發器無法由用戶直接調用，而由對錶的【增/刪/改】操作被動引發的。
三 刪除觸發器
drop trigger tri_after_insert_cmd;
三 事務
事務用於將某些操作的多個SQL作為原子性操作，也就是這些sql語句要麼同時成功，要麼都不成功，事務的其他特性在我第一篇部落格關於事務的介紹裡面有，這裡就不多做介紹啦，一旦有某一個出現錯誤，即可回滾到原來的狀態，從而保證資料庫數據完整性。
簡單來說：我給一個姑娘轉賬，姑娘那兒收到了200，你的賬戶上扣了200，這兩個操作是不是兩個sql語句，這兩個sql語句是你的應用程式發給mysql服務端的，並且這兩個sql語句都要一起執行，不然數據就錯了，你想想是不是。並且如果你通過應用程式發送這兩條sql的時候，由於網路問題，你只發送了一個sql過來，那只有一個賬戶改了數據，另外一個沒改，那數據是不是就出錯了啊。這就是事務要完成的事情。
create table user( id int primary key auto_increment, name char(32), balance int ); insert into user(name,balance) values ('wsb',1000), ('chao',1000), ('ysb',1000); #原子操作 start transaction; update user set balance=900 where name='wsb'; #買支付100元 update user set balance=1010 where name='chao'; #中介拿走10元 update user set balance=1090 where name='ysb'; #賣家拿到90元 commit; #只要不進行commit操作，就沒有保存下來，沒有刷到硬碟上 #出現異常，回滾到初始狀態 start transaction; update user set balance=900 where name='wsb'; #買支付100元 update user set balance=1010 where name='chao'; #中介拿走10元 uppdate user set balance=1090 where name='ysb'; #賣家拿到90元,出現異常沒有拿到 rollback; #如果上面三個sql語句出現了異常，就直接rollback，數據就直接回到原來的狀態了。但是執行了commit之後，rollback這個操作就沒法回滾了
#我們要做的是檢測這幾個sql語句是否異常，沒有異常直接commit，有異常就rollback，但是現在單純的只是開啟了事務，但是還沒有說如何檢測異常，我們先來一個存儲過程來捕獲異常，等我們學了存儲過程，再細說存儲過程。 commit;
#通過存儲過程來捕獲異常：(shit！，寫存儲過程的是，注意每一行都不要縮進！！！按照下面的縮進來寫，居然讓我翻車了！！！我記住你了~~~)，我的程式碼直接黏貼就能用。
delimiter //
create PROCEDURE p5()
BEGIN
DECLARE exit handler for sqlexception
BEGIN
rollback;
END;
START TRANSACTION;
update user set balance=900 where name=’wsb’; #買支付100元
update user set balance=1010 where name=’chao’; #中介拿走10元
#update user2 set balance=1090 where name=’ysb’; #賣家拿到90元
update user set balance=1090 where name=’ysb’; #賣家拿到90元
COMMIT;
END //
delimiter ;
mysql> select * from user; +----+------+---------+ | id | name | balance | +----+------+---------+ | 1 | wsb | 1000 | | 2 | chao | 1000 | | 3 | ysb | 1000 | +----+------+---------+ 3 rows in set (0.00 sec)
四 存儲過程
一 介紹
存儲過程包含了一系列可執行的sql語句，存儲過程存放於MySQL中，通過調用它的名字可以執行其內部的一堆sql。到目前為止，我們上面學的視圖、觸發器、事務等為我們簡化了應用程式級別寫sql語句的複雜程度，讓我們在應用程式裡面寫sql更簡單方便了，但是我們在應用程式上還是需要自己寫sql的，而我們下面要學的存儲過程，它是想讓我們的應用程式不需要再寫sql語句了，所有的sql語句，全部放到mysql裡面，被mysql封裝成存儲過程，說白了它就是一個功能，這個功能對應著一大堆的sql語句，這些語句裡面可以包括我們前面學的視圖啊、觸發器啊、事務啊、等等的內容，也就是說存儲過程其實是什麼？是一堆sql的集合體，可以直接用mysql裡面提供的一堆功能，有了存儲過程以後，它的好處是我項目邏輯中需要的各種查詢都可以讓DBA或者你自己封裝到存儲過程裡面，以後使用的時候直接調用存儲過程名就可以了，在開發應用的時候就簡單了，就不要應用程式設計師進行sql語句的開發了，但是你想如果你真的這麼做了，確實很有好處，簡單很多，應用程式的開發和資料庫sql語句的開發，完全的解耦了，這樣，專門的人做專門的事情，專門招一個應用開發的人開發應用程式，招一個開發型DBA，會sql的開發，他把sql寫完之後，封裝成一個個的存儲過程，給應用程式設計師用就行了，對不對，這個DBA就不單純的是管理資料庫系統了，還需要會寫sql語句，那這樣你的應用程式開發的效率就高了，運行效率也提高了，你開發應用程式的時候如果寫了一堆的sql語句，這些語句是不是要通過網路傳輸，傳輸到mysql服務端來執行，然後將結果返回給你的應用程式，那麼在傳輸的時候，你說好多的sql語句和簡單的一個存儲過程的名字，哪個傳輸的速度快，哪個發送給服務端的速度快，當然是單純的一個存儲過程的名字更快。
所以擺在你面前有兩種開發模式：
第一種是招一個會開發應用程式的並且這個人還要會sql開發，這樣的人既寫應用程式，還寫sql語句，這種情況你可以招兩個人，一個是前面說的，還有一個是資料庫管理人員，單純只會管理資料庫的而不會sql開發的人，這樣好招人，工資也不高。（應用程式設計師–>只需要開發應用程式的邏輯 。 sql開發人員–>編寫存儲過程）
第二種：招一個應用程式開發的，只需要會應用程式級別的開發，再招一個會sql開發的DBA。（應用程式設計師–>開發應用+寫原生sql 。 資料庫人員負責維護資料庫的正常運行）
我們比較一下這兩種的開發模式：第二種：解耦和，開發效率高，運行效率也高，所以以後最好採用第一種開發模式，哈哈，是不是神反轉，原因是什麼呢，錢只是一個方面，主要還是因為以後如果你想擴展，那就很不方便了，為什麼呢，因為通常sql開發人員，不如你的應用程式設計師更懂你的業務邏輯，一旦你要擴展一個功能，還需要跨部門溝通，導致這種工作方式受限的不只是技術層面了，這種方式在技術層面肯定是效率高的，但是要考慮人為因素，還有成本方面的考慮，所以通常咱們以後做開發，不要想著會有人給你寫sql，需要你自己寫的很熟練。這樣，你一個部門就能搞定這兩件事情。
第二種方式其實也比較麻煩，你開發程式設計師自己需要寫sql，並且寫出來的sql還存在效率問題，那麼有沒有一種方式可以不讓開發程式設計師自己再寫sql了，搞一個封裝程度更高的東西讓你來調用，有沒有這種方式呢？有，就是第三種方式
第三種：應用程式除了開發應用程式的邏輯，不需要編寫原生sql，只需要使用別人寫好的框架，基於框架來處理數據，框架提供的功能是ORM：對象關係映射，和對象有關係，就是在應用程式裡面，只需要定義一堆的類，每個類對應資料庫裡面的一張表，這個類一實例化，也就是一個類對象對應表裡面的一條記錄，得到對象以後，這個對象除了有數據之外，還有處理該條資訊的方法，增刪改查都有了，全都封裝成了對象的一個一個的方法了，意味著你以後再想進行查詢，就沒必要寫原生sql了，直接基於面向對象的思想來處理類與對象就行了，但是這種方式本質上還是使用了原生sql，只不過對於應用程式設計師來說，你不用直接寫sql了，別人寫好的ORM框架就幫你處理這件事兒了，幫你把你調用的那些介面方法和你傳入的參數等等幫你轉換為了原生sql，然後再往mysql裡面提交。所以這種方式和第二種方式有些類似，但是比第二種方式要好(前提是第二種方式應用程式設計師的sql水平比較low的情況下，一般會比較low)：
這種方式的優點：應用程式設計師不需要再寫原生的sql了，這意味著開發效率比第二種要高，同時還兼顧了第二種方式擴展性高的好處，因為本質上還是原生sql
缺點是：執行效率還不如第二種方式高，因為你現在再想運行需要做什麼事 情，首先你想，你程式裡面用的是別人寫好的ORM框架或者模組，你的sql要想執行，你需要做什麼事兒，你的ORM框架需要把類或者類對象先翻譯成原生的sql，再沿著網路發到mysql服務端，中間對了一個轉換的過程，所以執行效率其實連方式二都比不上。
總結：其實單單從技術層面上看，第一種方式肯定是最好的，開發和執行效率是最高的，擴展性單純技術層面來看也比較高，所以單單從技術層面來考慮，這種方式肯定是優選的。但是就目前的現狀而言，多數還是需要你應用程式設計師既做應用邏輯的開發，還要會原生sql的開發，所以應該儘可能的不讓mysql來做了，所有關於數據的增刪改查都交給應用程式級別來做，在應用程式中寫原生的sql，這也是第二種方式和第三種方式的一個共性，所有事情基本都交給應用程式級別來做，mysql級別基本不做sql的開發，這樣擴展性也好一些，因為所有的事情都交給你應用程式的開發部門來做了，自己部門內部進行擴展還是擴展性不錯的，所以咱們一般從後面兩種方式來選擇，那麼後面兩種選哪一種呢？第二種執行效率比第三種高，因為比第三種少了一步類對象轉換為sql的過程。第三種開發效率高，不要應用程式設計師再寫原生的sql了。所以具體選哪一種，看你們自己公司的情況，需要快速開發，就找第三種，如果自己程式設計師的sql寫的很溜(又快又優)，那麼找第二種，一般大公司採用的第一種多一些，部門分工非常的明確，等你們大家學到Django框架，你們就會接觸ORM啦~~~學完MySQL之後，我們在學框架之前，帶大家咱們自己開發一個簡單的ORM框架，能夠在你自己的應用程式中使用的ORM，寫這個ORM框架很重要，對你以後的框架和項目的學習很有指導意義，說哆啦，我們繼續說存儲過程：
使用存儲過程的優點：
#1. 用於替代程式寫的SQL語句，實現程式與sql解耦 #2. 基於網路傳輸，傳別名的數據量小，而直接傳sql數據量大
使用存儲過程的缺點：
#1. 程式設計師擴展功能不方便
上面一大堆話的總結：程式與資料庫結合使用的三種方式
#方式一： MySQL：存儲過程 程式：調用存儲過程 #方式二： MySQL： 程式：純SQL語句 #方式三： MySQL: 程式：類和對象，即ORM（本質還是純SQL語句）
二 創建簡單存儲過程（無參）
delimiter // create procedure p1() BEGIN select * from blog; INSERT into blog(name,sub_time) values("xxx",now()); END // delimiter ; #在mysql中調用 call p1(); #類似於MySQL的函數，但不是函數昂，別搞混了，MySQL的函數(count()\max()\min()等等)都是放在sql語句裡面用的，不能單獨的使用，存儲過程是可以直接調用的 call 名字+括弧; #MySQL的視圖啊觸發器啊if判斷啊等等都能在存儲過程裡面寫，這是一大堆的sql的集合體，都可以綜合到這裡面 #在python中基於pymysql調用 cursor.callproc('p1') print(cursor.fetchall())
另外：存儲過程是可以傳參數的，看下面的內容
三 創建存儲過程（有參）
對於存儲過程，可以接收參數，其參數有三類： #in 僅用於傳入參數用 #out 僅用於返回值用 #inout 既可以傳入又可以當作返回值
in:傳入參數：
delimiter // create procedure p2( in n1 int, #n1參數是需要傳入的，也就是接收外部數據的，並且這個數據必須是int類型 in n2 int ) BEGIN select * from blog where id > n1; #直接應用變數 END // delimiter ;
#調用存儲過程的兩種方式：或者說是兩個地方吧 #在mysql中調用 call p2(3,2) #在python中基於pymysql調用 cursor.callproc('p2',(3,2)) print(cursor.fetchall())
#通過存儲過程的傳參來看，也能體現出我們學習的Python的靈活性，傳參不需要指定類型，也不需要聲明這個參數是傳入的還是返回出來的，參數既可以傳入，這個參數也可以直接通過return返回。
out：返回值：
#查看存儲過程的一些資訊：show create procedure p3; #查看視圖啊、觸發器啊都這麼看，還可以用\G，show create procedure p3\G;\G的意思是你直接查看錶結構可能橫向上顯示不完，\G是讓表給你豎向顯示，一row是一行的欄位
delimiter // create procedure p3( in n1 int, out res int ) BEGIN select * from blog where id > n1; set res = 1; #我在這裡設置一個res=1，如果上面的所有sql語句全部正常執行了，那麼這一句肯定也就執行了，那麼此時res=1，如果我最開始傳入的時候，給res的值設置的是0，
#那麼你想，最後我接收到的返回值如果是0，那麼說明你中間肯定有一些sql語句執行失敗了
#注意寫法：out的那個參數，可以用set來設置，set設置之後表示這個res可以作為返回值，並且不需要像python一樣寫一個return，你直接set之後的值，就是這個存儲過程的返回值 END // delimiter ; #在mysql中調用 set @res=0; #這是MySQL中定義變數名的固定寫法(set @變數名=值)，可以自己規定好，0代表假（執行失敗），1代表真（執行成功），如果這個被改為1了，說明存儲過程中的sql語句執行成功了 call p3(3,@res);#注意：不要這樣寫：call p3（3，1），這樣out的參數值你寫死了，沒法確定後面這個1是不是成功了，也就是說隨後這個out的值可能改成0了，也就是失敗了，但是這樣你就判斷不了了，你後面查看的這個res就成1了，所以這個參數應該是一個變數名昂，定義變數名就是上一句,如果你直接傳一個常量數字，會報錯的，寫法不對。 select @res; #看一下這個結果，就知道這些sql語句是不是執行成功了，大家明白了嗎~~~ #在python中基於pymysql調用，在python中只需要知道存儲過程的名字就行了 cursor.callproc('p3',(3,0)) #0相當於set @res=0，為什麼這裡這個out參數可以寫常數0啊，因為你用的pymysql,人家會幫你搞定，pymysql其實會幫你寫成這樣：第一個參數變數名：@_p3_0=3，第二個：@_p3_1=0，也就是pymysql會自動幫你對應上一個變數名，pymysql只是想讓你寫的時候更方便
#沿著網路將存儲過程名和參數發給了mysql服務端，比咱們發一堆的sql語句肯定要快對了，mysql幫你調用存儲過程 print(cursor.fetchall()) #查詢select的查詢結果 cursor.execute('select @_p3_0,@_p3_1;') #@_p3_0代表第一個參數，@_p3_1代表第二個參數，即返回值 print(cursor.fetchall())
#別忘了關掉：
cursor.close()
conn.close()
#注意昂：存儲過程在哪個庫裡面建的，就只能在哪個庫裡面用
inout：既可傳入又可以返回值:
delimiter // create procedure p4( inout n1 int ) BEGIN select * from blog where id > n1; set n1 = 1; END // delimiter ;
#在mysql中調用 set @x=3; call p4(@x); select @x; #在python中基於pymysql調用 cursor.callproc('p4',(3,)) print(cursor.fetchall()) #查詢select的查詢結果 cursor.execute('select @_p4_0;') print(cursor.fetchall())
存儲過程結合事務來寫：
delimiter // create procedure p4( out status int ) BEGIN 1. 聲明如果出現異常則執行{ set status = 1; rollback; } 開始事務 -- 由秦兵賬戶減去100 -- 方少偉賬戶加90 -- 張根賬戶加10 commit; 結束 set status = 2; END // delimiter ; #實現 delimiter // create PROCEDURE p5( OUT p_return_code tinyint ) BEGIN DECLARE exit handler for sqlexception #聲明如果一旦出現異常則執行下面的這個begin和end裡面的操作 BEGIN -- ERROR #--是什麼啊，忘了吧，是注釋的意思，就告訴你後面是對錯誤的處理 set p_return_code = 1; #將out返回值改為1了，這是你自己規定的，1表示出錯了 rollback; #回滾事務 END; DECLARE exit handler for sqlwarning #聲明了出現警告資訊之後你的操作行為 BEGIN -- WARNING set p_return_code = 2; rollback; END; START TRANSACTION; #其實咱們這個存儲過程裡面就是執行這個事務，並且一直檢測著這個事務，一旦出錯或者出現警告，就rollback DELETE from tb1; #事務裡面的任何一條sql執行失敗或者執行出現警告，都會執行上面我們聲明的那些對應的操作，如果沒有任何的異常，就會自動執行下面的commit，並執行後面成功的sql insert into blog(name,sub_time) values('yyy',now()); #拿我的程式碼進行測試的時候，別忘了改成你自己庫里的表，還有表裡面對應的欄位名要有的，自己測試的時候，可以自己寫一個錯誤的sql來試試看 COMMIT; -- SUCCESS set p_return_code = 0; #0代表執行成功 END // delimiter ; #在mysql中調用存儲過程 set @res=123; call p5(@res); select @res; #在python中基於pymysql調用存儲過程 cursor.callproc('p5',(123,)) #注意後面這個參數是個元祖，別忘了逗號，按照我們上面規定的，上面有三個值0，1，2：0成功、1失敗、2警告也是失敗。所以我們傳給這個out參數的值只要不是這三個值就行了，這裡給的是100 print(cursor.fetchall()) #查詢select的查詢結果 cursor.execute('select @_p5_0;') print(cursor.fetchall())
#執行成功以後，查看一下結果就能看到執行後的值了
四 執行存儲過程
在MySQL中執行存儲過程：
-- 無參數 call proc_name() -- 有參數，全in call proc_name(1,2) -- 有參數，有in，out，inout set @t1=0; set @t2=3; call proc_name(1,2,@t1,@t2) 執行存儲過程
在python中基於pymysql來執行存儲過程：
#!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) # 執行存儲過程 cursor.callproc('p1', args=(1, 22, 3, 4)) # 獲取執行完存儲的參數 cursor.execute("select @_p1_0,@_p1_1,@_p1_2,@_p1_3") result = cursor.fetchall() #conn.commit() cursor.close() conn.close() print(result)
五 刪除存儲過程
drop procedure proc_name;
五 函數
MySQL中提供了許多內置函數，但是注意，這些函數只能在sql語句中使用，不能單獨調用昂，例如：其實下面的有些函數我們都已經用過了，其他的如果你們用到了，咱們再過來查吧，好不？
一、數學函數 ROUND(x,y) 返回參數x的四捨五入的有y位小數的值 RAND() 返回０到１內的隨機值,可以通過提供一個參數(種子)使RAND()隨機數生成器生成一個指定的值。 二、聚合函數(常用於GROUP BY從句的SELECT查詢中) AVG(col)返回指定列的平均值 COUNT(col)返回指定列中非NULL值的個數 MIN(col)返回指定列的最小值 MAX(col)返回指定列的最大值 SUM(col)返回指定列的所有值之和 GROUP_CONCAT(col) 返回由屬於一組的列值連接組合而成的結果 三、字元串函數 CHAR_LENGTH(str) 返回值為字元串str 的長度，長度的單位為字元。一個多位元組字元算作一個單字元。 CONCAT(str1,str2,...) 字元串拼接 如有任何一個參數為NULL ，則返回值為 NULL。 CONCAT_WS(separator,str1,str2,...) 字元串拼接（自定義連接符） CONCAT_WS()不會忽略任何空字元串。 (然而會忽略所有的 NULL）。 CONV(N,from_base,to_base) 進位轉換 例如： SELECT CONV('a',16,2); 表示將 a 由16進位轉換為2進位字元串表示 FORMAT(X,D) 將數字X 的格式寫為'#,###,###.##',以四捨五入的方式保留小數點後 D 位， 並將結果以字元串的形式返回。若 D 為 0, 則返回結果不帶有小數點，或不含小數部分。 例如： SELECT FORMAT(12332.1,4); 結果為： '12,332.1000' INSERT(str,pos,len,newstr) 在str的指定位置插入字元串 pos：要替換位置其實位置 len：替換的長度 newstr：新字元串 特別的： 如果pos超過原字元串長度，則返回原字元串 如果len超過原字元串長度，則由新字元串完全替換 INSTR(str,substr) 返回字元串 str 中子字元串的第一個出現位置。 LEFT(str,len) 返回字元串str 從開始的len位置的子序列字元。 LOWER(str) 變小寫 UPPER(str) 變大寫 REVERSE(str) 返回字元串 str ，順序和字元順序相反。 SUBSTRING(str,pos) , SUBSTRING(str FROM pos) SUBSTRING(str,pos,len) , SUBSTRING(str FROM pos FOR len) 不帶有len 參數的格式從字元串str返回一個子字元串，起始於位置 pos。帶有len參數的格式從字元串str返回一個長度同len字元相同的子字元串，起始於位置 pos。 使用 FROM的格式為標準 SQL 語法。也可能對pos使用一個負值。假若這樣，則子字元串的位置起始於字元串結尾的pos 字元，而不是字元串的開頭位置。在以下格式的函數中可以對pos 使用一個負值。 mysql> SELECT SUBSTRING('Quadratically',5); -> 'ratically' mysql> SELECT SUBSTRING('foobarbar' FROM 4); -> 'barbar' mysql> SELECT SUBSTRING('Quadratically',5,6); -> 'ratica' mysql> SELECT SUBSTRING('Sakila', -3); -> 'ila' mysql> SELECT SUBSTRING('Sakila', -5, 3); -> 'aki' mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2); -> 'ki' 四、日期和時間函數 CURDATE()或CURRENT_DATE() 返回當前的日期 CURTIME()或CURRENT_TIME() 返回當前的時間 DAYOFWEEK(date) 返回date所代表的一星期中的第幾天(1~7) DAYOFMONTH(date) 返回date是一個月的第幾天(1~31) DAYOFYEAR(date) 返回date是一年的第幾天(1~366) DAYNAME(date) 返回date的星期名，如：SELECT DAYNAME(CURRENT_DATE); FROM_UNIXTIME(ts,fmt) 根據指定的fmt格式，格式化UNIX時間戳ts HOUR(time) 返回time的小時值(0~23) MINUTE(time) 返回time的分鐘值(0~59) MONTH(date) 返回date的月份值(1~12) MONTHNAME(date) 返回date的月份名，如：SELECT MONTHNAME(CURRENT_DATE); NOW() 返回當前的日期和時間 QUARTER(date) 返回date在一年中的季度(1~4)，如SELECT QUARTER(CURRENT_DATE); WEEK(date) 返回日期date為一年中第幾周(0~53) YEAR(date) 返回日期date的年份(1000~9999) 重點: DATE_FORMAT(date,format) 根據format字元串格式化date值 mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y'); -> 'Sunday October 2009' mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s'); -> '22:23:00' mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00', -> '%D %y %a %d %m %b %j'); -> '4th 00 Thu 04 10 Oct 277' mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', -> '%H %k %I %r %T %S %w'); -> '22 22 10 10:23:00 PM 22:23:00 00 6' mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V'); -> '1998 52' mysql> SELECT DATE_FORMAT('2006-06-00', '%d'); -> '00' 五、加密函數 MD5() 計算字元串str的MD5校驗和 PASSWORD(str) 返回字元串str的加密版本，這個加密過程是不可逆轉的，和UNIX密碼加密過程使用不同的演算法。 六、控制流函數 CASE WHEN[test1] THEN [result1]...ELSE [default] END 如果testN是真，則返回resultN，否則返回default CASE [test] WHEN[val1] THEN [result]...ELSE [default]END 如果test和valN相等，則返回resultN，否則返回default IF(test,t,f) 如果test是真，返回t；否則返回f IFNULL(arg1,arg2) 如果arg1不是空，返回arg1，否則返回arg2 NULLIF(arg1,arg2) 如果arg1=arg2返回NULL；否則返回arg1 七、控制流函數小練習 #7.1、準備表，將下面這些內容保存為一個.txt文件或者.sql，然後通過navicat的運行sql文件的功能導入到資料庫中，還記得嗎？ /* Navicat MySQL Data Transfer Source Server : localhost_3306 Source Server Version : 50720 Source Host : localhost:3306 Source Database : student Target Server Type : MYSQL Target Server Version : 50720 File Encoding : 65001 Date: 2018-01-02 12:05:30 */ SET FOREIGN_KEY_CHECKS=0; -- ---------------------------- -- Table structure for course -- ---------------------------- DROP TABLE IF EXISTS `course`; CREATE TABLE `course` ( `c_id` int(11) NOT NULL, `c_name` varchar(255) DEFAULT NULL, `t_id` int(11) DEFAULT NULL, PRIMARY KEY (`c_id`), KEY `t_id` (`t_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- ---------------------------- -- Records of course -- ---------------------------- INSERT INTO `course` VALUES ('1', 'python', '1'); INSERT INTO `course` VALUES ('2', 'java', '2'); INSERT INTO `course` VALUES ('3', 'linux', '3'); INSERT INTO `course` VALUES ('4', 'web', '2'); -- ---------------------------- -- Table structure for score -- ---------------------------- DROP TABLE IF EXISTS `score`; CREATE TABLE `score` ( `id` int(11) NOT NULL AUTO_INCREMENT, `s_id` int(10) DEFAULT NULL, `c_id` int(11) DEFAULT NULL, `num` double DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8; -- ---------------------------- -- Records of score -- ---------------------------- INSERT INTO `score` VALUES ('1', '1', '1', '79'); INSERT INTO `score` VALUES ('2', '1', '2', '78'); INSERT INTO `score` VALUES ('3', '1', '3', '35'); INSERT INTO `score` VALUES ('4', '2', '2', '32'); INSERT INTO `score` VALUES ('5', '3', '1', '66'); INSERT INTO `score` VALUES ('6', '4', '2', '77'); INSERT INTO `score` VALUES ('7', '4', '1', '68'); INSERT INTO `score` VALUES ('8', '5', '1', '66'); INSERT INTO `score` VALUES ('9', '2', '1', '69'); INSERT INTO `score` VALUES ('10', '4', '4', '75'); INSERT INTO `score` VALUES ('11', '5', '4', '66.7'); -- ---------------------------- -- Table structure for student -- ---------------------------- DROP TABLE IF EXISTS `student`; CREATE TABLE `student` ( `s_id` varchar(20) NOT NULL, `s_name` varchar(255) DEFAULT NULL, `s_age` int(10) DEFAULT NULL, `s_sex` char(1) DEFAULT NULL, PRIMARY KEY (`s_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- ---------------------------- -- Records of student -- ---------------------------- INSERT INTO `student` VALUES ('1', '魯班', '12', '男'); INSERT INTO `student` VALUES ('2', '貂蟬', '20', '女'); INSERT INTO `student` VALUES ('3', '劉備', '35', '男'); INSERT INTO `student` VALUES ('4', '關羽', '34', '男'); INSERT INTO `student` VALUES ('5', '張飛', '33', '女'); -- ---------------------------- -- Table structure for teacher -- ---------------------------- DROP TABLE IF EXISTS `teacher`; CREATE TABLE `teacher` ( `t_id` int(10) NOT NULL, `t_name` varchar(50) DEFAULT NULL, PRIMARY KEY (`t_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- ---------------------------- -- Records of teacher -- ---------------------------- INSERT INTO `teacher` VALUES ('1', '大王'); INSERT INTO `teacher` VALUES ('2', 'alex'); INSERT INTO `teacher` VALUES ('3', 'chao'); INSERT INTO `teacher` VALUES ('4', 'peiqi'); #7.2、統計各科各分數段人數.顯示格式:課程ID,課程名稱,[100-85],[85-70],[70-60],[ <60] select score.c_id, course.c_name, sum(CASE WHEN num BETWEEN 85 and 100 THEN 1 ELSE 0 END) as '[100-85]', sum(CASE WHEN num BETWEEN 70 and 85 THEN 1 ELSE 0 END) as '[85-70]', sum(CASE WHEN num BETWEEN 60 and 70 THEN 1 ELSE 0 END) as '[70-60]', sum(CASE WHEN num < 60 THEN 1 ELSE 0 END) as '[ <60]' from score,course where score.c_id=course.c_id GROUP BY score.c_id;
需要掌握的函數：date_format ：這個我們要講一講，將來你可能會用的到的，我們前面沒有講過的一個東西。
#1 基本使用 mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y'); -> 'Sunday October 2009' mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s'); -> '22:23:00' mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00', -> '%D %y %a %d %m %b %j'); -> '4th 00 Thu 04 10 Oct 277' mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', -> '%H %k %I %r %T %S %w'); -> '22 22 10 10:23:00 PM 22:23:00 00 6' mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V'); -> '1998 52' mysql> SELECT DATE_FORMAT('2006-06-00', '%d'); -> '00' #2 準備表和記錄 CREATE TABLE blog ( id INT PRIMARY KEY auto_increment, NAME CHAR (32), sub_time datetime ); INSERT INTO blog (NAME, sub_time) VALUES ('第1篇','2015-03-01 11:31:21'), ('第2篇','2015-03-11 16:31:21'), ('第3篇','2016-07-01 10:21:31'), ('第4篇','2016-07-22 09:23:21'), ('第5篇','2016-07-23 10:11:11'), ('第6篇','2016-07-25 11:21:31'), ('第7篇','2017-03-01 15:33:21'), ('第8篇','2017-03-01 17:32:21'), ('第9篇','2017-03-01 18:31:21'); #3. 提取sub_time欄位的值，按照格式後的結果即"年月"來分組，統計一下每年每月的部落格數量，怎麼寫呢，按照sub_time分組，但是我們的sub_time是年月日加時間，我想看每年每月，直接按照sub_time來分組是不行的，每篇部落格的發表時間基本都是不同的，所以我們需要通過這個date_format來搞了 SELECT DATE_FORMAT(sub_time,'%Y-%m'),COUNT(1) FROM blog GROUP BY DATE_FORMAT(sub_time,'%Y-%m'); #結果 +-------------------------------+----------+ | DATE_FORMAT(sub_time,'%Y-%m') | COUNT(1) | +-------------------------------+----------+ | 2015-03 | 2 | | 2016-07 | 4 | | 2017-03 | 3 | +-------------------------------+----------+ 3 rows in set (0.00 sec)
一 自定義函數（自己簡單看看吧）
#！！！注意！！！ #函數中不要寫sql語句（否則會報錯），函數僅僅只是一個功能，是一個在sql中被應用的功能 #若要想在begin...end...中寫sql，請用存儲過程
delimiter // create function f1( i1 int, i2 int) returns int BEGIN declare num int; set num = i1 + i2; return(num); END // delimiter ;
delimiter // create function f5( i int ) returns int begin declare res int default 0; if i = 10 then set res=100; elseif i = 20 then set res=200; elseif i = 30 then set res=300; else set res=400; end if; return res; end // delimiter ;
二 刪除函數
drop function func_name;
三 執行函數
# 獲取返回值 select UPPER('chao') into @res; SELECT @res; # 在查詢中使用 select f1(11,nid) ,name from tb2;
關於查看存儲過程，函數，視圖，觸發器的語法：
查詢資料庫中的存儲過程和函數 select name from mysql.proc where db = 'xx' and type = 'PROCEDURE' //查看xx庫裡面的存儲過程 select name from mysql.proc where db = 'xx' and type = 'FUNCTION' //函數 show procedure status; //存儲過程 show function status; //函數 查看存儲過程或函數的創建程式碼 show create procedure proc_name; show create function func_name; 查看視圖 SELECT * from information_schema.VIEWS //視圖 SELECT * from information_schema.TABLES //表 查看觸發器 SHOW TRIGGERS [FROM db_name] [LIKE expr] SELECT * FROM triggers T WHERE trigger_name=」mytrigger」 \G；其中triggers T就是triggers as T的意思，起別名
六 流程式控制制
一 條件語句
if條件語句：
delimiter // CREATE PROCEDURE proc_if () BEGIN declare i int default 0; if i = 1 THEN SELECT 1; ELSEIF i = 2 THEN SELECT 2; ELSE SELECT 7; END IF; END // delimiter ;
二 循環語句
while循環：#後面講索引的時候，咱們會用到while循環，注意語法
delimiter // CREATE PROCEDURE proc_while () BEGIN DECLARE num INT ; SET num = 0 ; WHILE num < 10 DO SELECT num ; SET num = num + 1 ; END WHILE ; END // delimiter ;
到這裡你會發現，其實sql也是一個開發語言，基本數據類型啊函數啊流程式控制制啊(if、while等)它都有。下面這兩個我們簡單看一下用法就行啦~~~
repeat循環：
delimiter // CREATE PROCEDURE proc_repeat () BEGIN DECLARE i INT ; SET i = 0 ; repeat select i; set i = i + 1; until i >= 5 end repeat; END // delimiter ;
loop：
BEGIN declare i int default 0; loop_label: loop set i=i+1; if i<8 then iterate loop_label; end if; if i>=10 then leave loop_label; end if; select i; end loop loop_label; END
咱們本篇部落格的重點是事務和存儲過程，這是你將來和mysql打交道的時候會常用的內容。其他的內容是你了解知道的內容。那麼MySQL的內容就還剩下索引及慢sql優化的問題了，我們下一篇部落格再講吧~~~
