一 檢視

檢視是一個虛擬表（非真實存在），是跑到記憶體中的表，真實表是硬碟上的表。使用檢視我們可以把查詢過程中的臨時表摘出來，儲存下來，用檢視去實現，這樣以後再想操作該臨時表的資料時就無需重寫複雜的sql了，直接去檢視中查詢即可，但檢視有明顯地效率問題，並且檢視是存放在資料庫中的，如果我們程式中使用的sql過分依賴資料庫中的檢視，即強耦合，那就意味著擴充套件sql極為不便，因此並不推薦使用。

1.建立檢視
#語法：CREATE VIEW 檢視名稱 AS  SQL語句
create view teacher_view as select tid from teacher where tname='
 
李平老師';
  
#1. 使用檢視以後就無需每次都重寫子查詢的sql，開發的時候是方便了很多，但是這麼效率並不高，不如寫子查詢的效率高

#2.修改檢視中的資料，也會把原表資料修改。

2.修改檢視

語法：ALTER VIEW 檢視名稱 AS SQL語句

alter view teacher_view as select * from course where cid>3;

3.刪除檢視

語法：DROP VIEW 檢視名稱
DROP VIEW teacher_view

二 觸發器

在進行增刪改( 不包括查詢 )操作的時候，觸發的某個操作，稱為觸發器。

1.建立觸發器

# 插入前
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表示即將刪除的資料行。

　　2.使用觸發器

　　　　觸發器無法由使用者直接呼叫，而由對錶的【增/刪/改】操作被動引發的。

　　3.刪除觸發器

drop trigger tri_after_insert_cmd;

三 事務

　　　　事務用於將某些操作的多個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元
update 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 ;

四 儲存過程

一 介紹

　　　　儲存過程包含了一系列可執行的sql語句，儲存過程存放於MySQL中，通過呼叫它的名字可以執行其內部的一堆sql。儲存過程，讓我們的應用程式不需要再寫sql語句了，所有的sql語句，全部放到mysql裡面，被mysql封裝成儲存過程，它是一個功能，這個功能對應著一大堆的sql語句，這些語句裡面可以包括我們前面學的檢視啊、觸發器啊、事務啊、等等的內容，也就是說儲存過程其實是什麼？是一堆sql的集合體，可以直接用mysql裡面提供的一堆功能。儲存過程它的好處是我專案邏輯中需要的各種查詢都可以讓DBA或者你自己封裝到儲存過程裡面，以後使用的時候直接呼叫儲存過程名就可以了，在開發應用的時候就簡單了，就不要應用程式設計師進行sql語句的開發了。

開發模式：

第一種      應用程式設計師-->只需要開發應用程式的邏輯 。   sql開發人員-->編寫儲存過程

第二種     應用程式設計師-->開發應用+寫原生sql ， 資料庫人員負責維護資料庫的正常執行　　

第三種：應用程式除了開發應用程式的邏輯，不需要編寫原生sql，只需要使用別人寫好的框架，基於框架來處理資料，框架提供的功能是ORM：物件關係對映，和物件有關係，就是在應用程式裡面，只需要定義一堆的類，每個類對應資料庫裡面的一張表，這個類一例項化，也就是一個類物件對應表裡面的一條記錄，得到物件以後，這個物件除了有資料之外，還有處理該條資訊的方法，增刪改查都有了，全都封裝成了物件的一個一個的方法了，意味著你以後再想進行查詢，就沒必要寫原生sql了，直接基於面向物件的思想來處理類與物件就行了，但是這種方式本質上還是使用了原生sql，只不過對於應用程式設計師來說，你不用直接寫sql了，別人寫好的ORM框架就幫你處理這件事兒了，幫你把你呼叫的那些介面方法和你傳入的引數等等幫你轉換為了原生sql，然後再往mysql裡面提交。所以這種方式和第二種方式有些類似，但是比第二種方式要好(前提是第二種方式應用程式設計師的sql水平比較low的情況下，一般會比較low)：

這種方式的優點：應用程式設計師不需要再寫原生的sql了，這意味著開發效率比第二種要高，同時還兼顧了第二種方式擴充套件性高的好處，因為本質上還是原生sql

缺點是：執行效率還不如第二種方式高，因為你現在再想執行需要做什麼事 情，首先你想，你程式裡面用的是別人寫好的ORM框架或者模組，你的sql要想執行，你需要做什麼事兒，你的ORM框架需要把類或者類物件先翻譯成原生的sql，再沿著網路發到mysql服務端，中間對了一個轉換的過程，所以執行效率其實連方式二都比不上。

　　　　　　　

使用儲存過程的優點：

#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())

 

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代表第二個引數，即返回值  #格式 @_儲存過程名稱_0,@_儲存過程名稱_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;

 

六 流程控制

　　一 條件語句

　　　　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

本文來源：https://www.cnblogs.com/clschao/articles/10034539.html