MySQL之視圖、觸發器、事務、存儲過程、函數
MySQL這個軟件想將數據處理的全部事情，可以在mysql這個層面上所有都作了，也就是說它想要完成一件事，之後想開發的人，例如想寫python程序的人，你就專門的寫你本身的python程序，之後凡是關於數據的增刪改查，所有都在MySQL裏面完成，也就是說它想實現一個數據處理與應用程序的一個徹底的解耦和狀態，好比說，若是我是個應用程序員，我想要查詢數據，我不須要本身寫sql語句，只須要調用mysql封裝好的一些功能，直接調用這個功能就能夠了，以前咱們使用sql來進行數據的增刪改查，其實sql也能夠算做一個開發語言，有專門招數據庫開發的崗位，也就是說mysql想作這麼一個事兒，之後啊，專門有人寫應用程序的開發，專門有人來寫sql，來開發sql部分，在數據庫層面根據應用層的程序員的要求，把sql語句所有寫好，各類複雜的需求所有幫你封裝好，封裝成一個一個的功能，應用程序開發程序員在根據本身的需求來使用這些功能，直接調用就能夠了，這是mysql想要完成的事情，可是我們之後作開發，通常不會這麼搞，通常招聘需求裏面都會有一項是要會sql，淺顯的說是由於花最少的錢，作最多的事兒，可是往深了說是由於公司裏面通常不會用這些內置的功能去sql的工做，至於爲何，我們學完mysql以後再說吧~~~java
一 視圖
視圖是一個虛擬表（非真實存在），是跑到內存中的表，真實表是硬盤上的表，怎麼就獲得了虛擬表，就是你查詢的結果，只不過以前咱們查詢出來的虛擬表，從內存中取出來顯示在屏幕上，內存中就沒有了這些表的數據，可是下次我要是想用這個虛擬表呢，沒辦法，只能從新查一次，每次都要從新查。其本質是【根據SQL語句獲取動態的數據集，併爲其命名】，用戶使用時只需使用【名稱】便可獲取結果集，能夠將該結果集當作表來使用。若是咱們想查詢一些有關聯的表，好比咱們前面的老師學生班級什麼的表，我可能須要幾個表聯合查詢的結果，可是這幾張表在硬盤上是單獨存的，因此咱們須要經過查詢的手段，將這些表在內存中拼成一個虛擬表，而後是否是咱們再基於虛擬表在進行進一步的查詢，而後咱們若是之後想從新再查一下這些關係數據，還須要對硬盤上這些表進行再次的從新加載到內容，聯合成虛擬表，而後再篩選等等的操做，意味着我們每次都在寫重複的sql語句，那有沒有好的方法啊，其實很簡單，咱們把重複用的這些sql邏輯封裝起來，而後下次使用的時候直接調用這個封裝好的操做就能夠了，這個封裝起來的操做就相似咱們下面要說的視圖python
爲何要用視圖：使用視圖咱們能夠把查詢過程當中的臨時表摘出來，保存下來，用視圖去實現，這樣之後再想操做該臨時表的數據時就無需重寫複雜的sql了，直接去視圖中查找便可，但視圖有明顯地效率問題，而且視圖是存放在數據庫中的，若是咱們程序中使用的sql過度依賴數據庫中的視圖，即強耦合，那就意味着擴展sql極爲不便，所以並不推薦使用mysql
臨時表應用舉例：linux
#兩張有關係的表 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 而且注意：視圖通常都是用於查詢，儘可能不要修改(插入、刪除等)視圖中的數據，雖然有時候能夠修改爲功，可是儘可能不要這樣作，
由於這個視圖多是多個表聯合起來生成的一個結果，若是你修改它，可能會形成不少表裏面的數據都跟着被修改了
二 使用視圖web
#修改視圖，原始表也跟着改 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)
咱們不該該修改視圖中的記錄，並且在涉及多個表的狀況下是根本沒法修改視圖中的記錄的，以下圖算法
三 修改視圖sql
語法：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語句中使用，不能單獨調用昂，例如：其實下面的有些函數咱們都已經用過了，其餘的若是大家用到了，我們再過來查吧，好不？
1、數學函數
ROUND(x,y)
返回參數x的四捨五入的有y位小數的值
RAND()
返回０到１內的隨機值,能夠經過提供一個參數(種子)使RAND()隨機數生成器生成一個指定的值。
2、聚合函數(經常使用於GROUP BY從句的SELECT查詢中)
AVG(col)返回指定列的平均值
COUNT(col)返回指定列中非NULL值的個數
MIN(col)返回指定列的最小值
MAX(col)返回指定列的最大值
SUM(col)返回指定列的全部值之和
GROUP_CONCAT(col) 返回由屬於一組的列值鏈接組合而成的結果
3、字符串函數
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'
4、日期和時間函數
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'
5、加密函數
MD5()
計算字符串str的MD5校驗和
PASSWORD(str)
返回字符串str的加密版本，這個加密過程是不可逆轉的，和UNIX密碼加密過程使用不一樣的算法。
6、控制流函數
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、控制流函數小練習
#7.一、準備表，將下面這些內容保存爲一個.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.二、統計各科各分數段人數.顯示格式:課程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打交道的時候會經常使用的內容。其餘的內容是你瞭解知道的內容。
相關文章
- 1. MySQL視圖、觸發器、事務、存儲過程、函數 視圖、觸發器、事務、存儲過程、函數
- 2. MySQL之視圖、觸發器、事務、存儲過程、函數
- 3. MySQL（視圖、觸發器、事務、存儲過程、函數 ）
- 4. MySQL 的視圖、觸發器、事務、存儲過程、函數
- 5. mysql七：視圖、觸發器、事務、存儲過程、函數
- 6. mysql事務、觸發器、視圖、存儲過程、函數
- 7. Mysql視圖、觸發器、事務、儲存過程、函數
- 8. Mysql之視圖,觸發器,事物,存儲過程,函數
- 9. MySQL之試圖、觸發器、事務、存儲過程、函數
- 10. MySQL之視圖、觸發器、事務、存儲過程、函數 流程控制
- 更多相關文章...
- • MySQL存儲過程簡介 - MySQL教程
- • MySQL刪除存儲過程（DROP PROCEDURE） - MySQL教程
- • 三篇文章瞭解 TiDB 技術內幕——說存儲
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 字節跳動21屆秋招運營兩輪面試經驗分享
- 2. Java 3 年，25K 多嗎？
- 3. mysql安裝部署
- 4. web前端開發中父鏈和子鏈方式實現通信
- 5. 3.1.6 spark體系之分佈式計算-scala編程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在線
- 8. 在線畫圖
- 9. devtools熱部署
- 10. 編譯和鏈接
歡迎關注本站公眾號,獲取更多信息
相關文章