一：視圖

視圖是一個虛擬表（非真實存在），其本質是【根據SQL語句獲取動態的數據集，並為其命名】，用戶使用時只需使用【名稱】即可獲取結果集，可以將該結果集當做表來使用。

使用視圖我們可以把查詢過程中的臨時表摘出來，用視圖去實現，這樣以後再想操作該臨時表的數據時就無需重寫復雜的sql了，直接去視圖中查找即可，但視圖有明顯地效率問題，並且視圖是存放在數據庫中的，如果我們程序中使用的sql過分依賴數據庫中的視圖，即強耦合，那就意味著擴展sql極為不便，因此並不推薦使用

1.1 創建視圖

　　#語法：CREATE VIEW 視圖名稱 AS SQL語句

#！！！註意註意註意：
#1. 使用視圖以後就無需每次都重寫子查詢的sql，但是這麽效率並不高，還不如我們寫子查詢的效率高

#2. 而且有一個致命的問題：視圖是存放到數據庫裏的，如果我們程序中的sql過分依賴於數據庫中存放的視圖，那麽意味著，一旦sql需要修改且涉及到視圖的部分，則必須去數據庫中進行修改，而通常在
公司中數據庫有專門的DBA負責，你要想完成修改，必須付出大量的溝通成本DBA可能才會幫你完成修改，極其地不方便
 

1.2 修改視圖，原始表也跟著改

我們不應該修改視圖中的記錄，而且在涉及多個表的情況下是根本無法修改視圖中的記錄的

1.3 修改視圖

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

1.4 刪除視圖

語法：DROP VIEW 視圖名稱

二、觸發器

使用觸發器可以定制用戶對表進行【增、刪、改】操作時前後的行為，註意：沒有查詢
2.1 創建觸發器

# 插入前
CREATE TRIGGER tri_before_insert_tb1 BEFORE INSERT ON tb1 FOR EACH ROW
BEGIN
    ...
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,
    USER CHAR (32),
    priv CHAR (10),
    cmd CHAR (64),
    sub_time datetime, #提交時間
    success enum (‘yes‘, ‘no‘) #0代表執行失敗
);

CREATE TABLE errlog (
    id INT PRIMARY KEY auto_increment,
    err_cmd CHAR (64),
    err_time datetime
);

#創建觸發器
delimiter //
CREATE TRIGGER tri_after_insert_cmd AFTER INSERT ON cmd FOR EACH ROW
BEGIN
    IF NEW.success = ‘no‘ THEN #等值判斷只有一個等號
            INSERT INTO errlog(err_cmd, err_time) VALUES(NEW.cmd, NEW.sub_time) ; #必須加分號
      END IF ; #必須加分號
END//
delimiter ;


#往表cmd中插入記錄，觸發觸發器，根據IF的條件決定是否插入錯誤日誌
INSERT INTO cmd (
    USER,
    priv,
    cmd,
    sub_time,
    success
)
VALUES
    (‘egon‘,‘0755‘,‘ls -l /etc‘,NOW(),‘yes‘),
    (‘egon‘,‘0755‘,‘cat /etc/passwd‘,NOW(),‘no‘),
    (‘egon‘,‘0755‘,‘useradd xxx‘,NOW(),‘no‘),
    (‘egon‘,‘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 |
+----+-----------------+---------------------+
rows in set (0.00 sec)

插入後觸發觸發器

特別的：NEW表示即將插入的數據行，OLD表示即將刪除的數據行。

2.2 使用觸發器

觸發器無法由用戶直接調用，而知由於對表的【增/刪/改】操作被動引發的。

2.3 刪除觸發器

drop trigger tri_after_insert_cmd;

三 事務

事務用於將某些操作的多個SQL作為原子性操作，一旦有某一個出現錯誤，即可回滾到原來的狀態，從而保證數據庫數據完整性。

create table user(
id int primary key auto_increment,
name char(32),
balance int
);

insert into user(name,balance)
values
(‘wsb‘,1000),
(‘egon‘,1000),
(‘ysb‘,1000);

#原子操作
start transaction;
update user set balance=900 where name=‘wsb‘; #買支付100元
update user set balance=1010 where name=‘egon‘; #中介拿走10元
update user set balance=1090 where name=‘ysb‘; #賣家拿到90元
commit;

#出現異常，回滾到初始狀態
start transaction;
update user set balance=900 where name=‘wsb‘; #買支付100元
update user set balance=1010 where name=‘egon‘; #中介拿走10元
uppdate user set balance=1090 where name=‘ysb‘; #賣家拿到90元,出現異常沒有拿到
rollback;
commit;
mysql> select * from user;
+----+------+---------+
| id | name | balance |
+----+------+---------+
|  1 | wsb  |    1000 |
|  2 | esb |    1000 |
|  3 | ysb  |    1000 |
+----+------+---------+
3 rows in set (0.00 sec)

四 存儲過程

一 介紹

存儲過程包含了一系列可執行的sql語句，存儲過程存放於MySQL中，通過調用它的名字可以執行其內部的一堆sql

使用存儲過程的優點：

#1. 用於替代程序寫的SQL語句，實現程序與sql解耦

#2. 基於網絡傳輸，傳別名的數據量小，而直接傳sql數據量大

使用存儲過程的缺點：

#1. 執行效率低

#2. 程序員擴展功能不方便

補充：程序與數據庫結合使用的三種方式

#方式一：

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

#在python中基於pymysql調用
cursor.callproc(‘p1‘) 
print(cursor.fetchall())

三 創建存儲過程（有參）

對於存儲過程，可以接收參數，其參數有三類：

#in          僅用於傳入參數用
#out        僅用於返回值用
#inout     既可以傳入又可以當作返回值

in：傳入函數

delimiter //
create procedure p2(
    in 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：返回值 

delimiter //
create procedure p3(
    in n1 int,
    out res int
)
BEGIN
    select * from blog where id > n1;
    set res = 1;
END //
delimiter ;

#在mysql中調用
set @res=0; #0代表假（執行失敗），1代表真（執行成功）
call p3(3,@res);
select @res;

#在python中基於pymysql調用
cursor.callproc(‘p3‘,(3,0)) #0相當於set @res=0
print(cursor.fetchall()) #查詢select的查詢結果

cursor.execute(‘select @_p3_0,@_p3_1;‘) #@p3_0代表第一個參數，@p3_1代表第二個參數，即返回值
print(cursor.fetchall())

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 
        -- ERROR 
        set p_return_code = 1; 
        rollback; 
    END; 

    DECLARE exit handler for sqlwarning 
    BEGIN 
        -- WARNING 
        set p_return_code = 2; 
        rollback; 
    END; 

    START TRANSACTION; 
        DELETE from tb1; #執行失敗
        insert into blog(name,sub_time) values(‘yyy‘,now());
    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,))
print(cursor.fetchall()) #查詢select的查詢結果

cursor.execute(‘select @_p5_0;‘)
print(cursor.fetchall())

四 執行存儲過程

#使用存儲過程的優點
#1 程序與數據實現解耦
#2 減少網絡傳輸的數據量

#===============================================
#創建無參存儲過程
delimiter //
create procedure p1()
begin
    select * from test;
    insert into test(username,dep_id) values(‘wsb‘,2);
end //
delimiter ;

#調用存儲過程
call p1(); #在mysql中調用
cursor.callproc(‘p1‘) #在python中通過pymysql模塊調用



#===============================================
#創建有參存儲過程之in的使用
delimiter //
create procedure p2(
    in m int,
    in n int,
)
begin
    select * from test where id between m and n;
end //
delimiter ;

#調用存儲過程
call p2(3,7); #在mysql中調用
cursor.callproc(‘p2‘,args=(3,7)) #在python中通過pymysql模塊調用

#===============================================
#創建有參存儲過程之out的使用
delimiter //
create procedure p3(
    in m int,
    in n int,
    out res int
)
begin
    select * from test where id between m and n;
    set res=1;
end //
delimiter ;

#調用存儲過程
#在mysql中
set @x=11111111111
call p3(3,7,@x); #在mysql中調用, 查看結果：select @x;

#在python中
res=cursor.callproc(‘p3‘,args=(3,7,123)) #@_p3_0=3,@_p3_1=7,@_p3_2=123
print(cursor.fetchall()) #只是拿到存儲過程中select的查詢結果
cursor.execute(‘select @_p3_0,@_p3_1,@_p3_2‘)
print(cursor.fetchall()) #可以拿到的是返回值



#===============================================
#創建有參存儲過程之inout的使用

delimiter //
create procedure p4(
    inout m int
)
begin
    select * from test where id > m;
    set m=1;
end //
delimiter ;

#在mysql中
set @x=2;
call p4(@x);
select @x;



delimiter //
create procedure p5(
    inout m int
)
begin
    select * from test11111111 where id > m;
    set m=1;
end //
delimiter ;

set @x=2;
call p5(@x);
select @x;

#====================捕捉異常+事務===========================
delimiter //
create PROCEDURE p6(
    OUT p_return_code tinyint
)
BEGIN
    DECLARE exit handler for sqlexception
    BEGIN
        -- ERROR
        set p_return_code = 1;
        rollback;
    END;

    DECLARE exit handler for sqlwarning
    BEGIN
        -- WARNING
        set p_return_code = 2;
        rollback;
    END;

    START TRANSACTION;
        insert into test(username,dep_id) values(‘egon‘,1);
        DELETE from tb1111111; #執行失敗
    COMMIT;

    -- SUCCESS
    set p_return_code = 0; #0代表執行成功

END //
delimiter ;


#用python模擬
try:
    START TRANSACTION;
        DELETE from tb1; #執行失敗
        insert into blog(name,sub_time) values(‘yyy‘,now());
    COMMIT;
    set p_return_code = 0; #0代表執行成功
except sqlexception:
    set p_return_code = 1;
    rollback;
except sqlwaring:
    set p_return_code = 2;
    rollback;




mysql> show procedure status like ‘p1%‘; #查看某一類存儲過程

五 函數

部分內置函數

CHAR_LENGTH(str)
        返回值為字符串str 的長度，長度的單位為字符。一個多字節字符算作一個單字符。
        對於一個包含五個二字節字符集, LENGTH()返回值為 10, 而CHAR_LENGTH()的返回值為5。

    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)
        變大寫

    LTRIM(str)
        返回字符串 str ，其引導空格字符被刪除。
    RTRIM(str)
        返回字符串 str ，結尾空格字符被刪去。
    SUBSTRING(str,pos,len)
        獲取字符串子序列

    LOCATE(substr,str,pos)
        獲取子序列索引位置

    REPEAT(str,count)
        返回一個由重復的字符串str 組成的字符串，字符串str的數目等於count 。
        若 count <= 0,則返回一個空字符串。
        若str 或 count 為 NULL，則返回 NULL 。
    REPLACE(str,from_str,to_str)
        返回字符串str 以及所有被字符串to_str替代的字符串from_str 。
    REVERSE(str)
        返回字符串 str ，順序和字符順序相反。
    RIGHT(str,len)
        從字符串str 開始，返回從後邊開始len個字符組成的子序列

    SPACE(N)
        返回一個由N空格組成的字符串。

    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‘

    TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM(remstr FROM] str)
        返回字符串 str ， 其中所有remstr 前綴和/或後綴都已被刪除。若分類符BOTH、LEADIN或TRAILING中沒有一個是給定的,則假設為BOTH 。 remstr 為可選項，在未指定情況下，可刪除空格。

        mysql> SELECT TRIM(‘  bar   ‘);
                -> ‘bar‘

        mysql> SELECT TRIM(LEADING ‘x‘ FROM ‘xxxbarxxx‘);
                -> ‘barxxx‘

        mysql> SELECT TRIM(BOTH ‘x‘ FROM ‘xxxbarxxx‘);
                -> ‘bar‘

        mysql> SELECT TRIM(TRAILING ‘xyz‘ FROM ‘barxxyz‘);
                -> ‘barx‘
必須掌握的函數

#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字段的值，按照格式後的結果即"年月"來分組
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 |
+-------------------------------+----------+
rows in set (0.00 sec)

六 流程控制

#函數中不要寫sql語句，它僅僅只是一個功能，是一個在sql中被應用的功能
#若要想在begin...end...中寫sql，請用存儲過程
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 ;






#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 ;

mysql--補充（視圖，觸發器，事務，存儲過程，函數）