python之路-----MySql操做三

時間 2019-11-30

標籤 python 之路 mysql 欄目 Python 简体版

原文原文鏈接

mysql 概述
　　一.主要內容:
　　　　視圖 create view name (select * from user where id>5);
　　　　觸發器
　　　　函數
　　　　存儲過程
　　　　索引

二.各模塊詳細說明
　　1.視圖
　　加速有臨時表：(select * from user where id>5) as B 須要再100個sql語句中使用，若是按照臨時表的寫法，須要再100個sql語句裏重複寫:(select 　　　* from user where id>5) as B.html

　　這無疑增長了代碼量。這時候能夠將臨時表存爲視圖，供sql語句使用。(某個查詢語句設置別名，往後方便使用)

　　定義：視圖是一個虛擬表（非真實存在），其本質是【根據SQL語句獲取動態的數據集，併爲其命名】，用戶使用時只需使用【名稱】便可獲取結果集，並能夠將其看成表來使用。

　　視圖的命令:
　　新增：python

create view viem_name as sql語句；
e.g:CREATE VIEW user_view AS (SELECT * FROM userinfo WHERE id>1);
修改：
ALTER VIEW view_name as sql語句;

e.g：ALTER VIEW user_view as (SELECT * FROM userinfo WHERE id>2);

刪除：mysql

drop view view name;

　　視圖的特色：
　　　　1.因爲視圖是虛擬表，因此不能對視圖的數據進行增刪改
　　　　2.視圖的內容隨着物理表的變化而變化，如user表新增一個id爲10的數據，則視圖也會同時將該數據加入。

　　2.觸發器
　　當咱們在對每一行數據進行增刪改先後(查詢不會觸發觸發器)，能夠定義一系列其餘動做。如:往user表新增數據時，則在資產表新增對應的用戶信息等。

　　定義：對某個表進行【增/刪/改】操做的先後若是但願觸發某個特定的行爲時，可使用觸發器，觸發器用於定製用戶對錶的行進行【增/刪/改】先後的行爲。git

　　觸發器的命令
　　新增:算法

插入前:
delimiter // --定義結束符爲 // ，結束符可自定義
CREATE TRIGGER trigger_name BEFORE INSERT ON tb_name FOR EACH ROW
BEGIN
sql語句1;
sql語句2；
....
END // ---根據本身定義的結束符結束建立觸發器命令
delimiter ; ---將結束符改回;，避免影響其餘sql語句執行


插入後:
delimiter // --定義結束符爲 // ，結束符可自定義
CREATE TRIGGER trigger_name AFTER INSERT ON tb_name FOR EACH ROW
BEGIN
sql語句1;
sql語句2；
....
END // ---根據本身定義的結束符結束建立觸發器命令
delimiter ; ---將結束符改回;，避免影響其餘sql語句執行

刪除前，刪除後，更改前，更改後只須要將insert改成delete,update便可。命令結構是同樣的。

　　修改：
　　　　觸發器沒法修改，只能刪除重建

　　刪除：
　　　　DROP TRIGGER trigger_name;
　　觸發器的使用：
　　　　觸發器沒法由用戶直接調用，而知因爲對錶的【增/刪/改】操做被動引起的。
sql

1.old new
old表示表中的舊數據，new表示爲用戶新增的數據。咱們可使用new，old來完成一些數據操做。
ps:
new至關於Python中的對象類型，裏面還有多個屬性，調用時，插入值時，須要具體的屬性名稱.
例如插入表 a(id,name,gender) values(1,'test','man'),則 new.id=1，new.name='test',new.gender='man'
old跟new同理

e.g:
new：將a表新插入的數據同時插入b表
delimiter // 
CREATE TRIGGER tr_a_b AFTER INSERT ON a FOR EACH ROW
BEGIN
insert into b(name) values(new.name);
END // 
delimiter ;
old:刪除a表前將刪除的數據插入b表
delimiter //
CREATE TRIGGER tr_a_b_del1 BEFORE DELETE ON a FOR EACH ROW
BEGIN
INSERT INTO b(id,name,gender) VALUES(old.id,old.name,old.gender);
END //
delimiter ;

補充說明：在刪除前觸發器中,咱們將 old改成new，發現命令報錯，說明old表明表中已存在的數據，而new表示用戶新增長的數據。且old，new都是跟
操做表有關，示例中的a表，與b表是無關的。

old,new補充說明

　　3.函數
　　函數分爲內置函數和自定義函數
　　3.1 內置函數數據庫

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'

部份內置函數

部份內置函數

　　官方內置函數網址：服務器

　　　　https://dev.mysql.com/doc/refman/5.7/en/functions.htmlsession

　　中文版內置函數：數據結構

　　　　http://doc.mysql.cn/mysql5/refman-5.1-zh.html-chapter/functions.html#encryption-functions

　　3.2 自定義函數

　　　　建立函數

delimiter //
CREATE FUNCTION func_name(
    a INT,    #聲明變量和變量類型
    b INT
)
RETURNS INT   #設置返回值類型
BEGIN
    DECLARE c INT;   #聲明變量
    set c=a+b;          #賦值運算
    RETURN(c);          #返回值
END //
delimiter ;

　　　　刪除函數

drop function func_name;

　　　　執行函數

# 獲取返回值
declare @i VARCHAR(32);
select UPPER('alex') into @i;  
SELECT @i;


# 在查詢中使用
select f1(11,nid) ,name from tb2;

#直接使用
select f1(1,2);

　　使用pymysql調用mysql函數

cursor=conn.cursor()
cursor.execute('select f1(6,2)')
res=cursor.fetchone()

　　4.存儲過程

　　存儲過程是一個SQL語句集合，當主動去調用存儲過程時，其中內部的SQL語句會按照邏輯執行。

　　4.1.簡單存儲過程

delimiter //
CREATE PROCEDURE p1()
BEGIN
SELECT * FROM userinfo WHERE id<4;
INSERT into b(name,gender) VALUES('test1','112');
END //
delimiter ;

無參數存儲過程

　　4.2.帶參數的存儲過程（in,out,inout）

in 僅用於傳入參數用
out 僅用於返回值用
inout 既能夠傳入又能夠看成返回值

　　建立：

delimiter //
CREATE PROCEDURE p1(
IN nid INT
)
BEGIN
SELECT * FROM userinfo WHERE id<nid;
END //
delimiter ;
使用：
CALL p1(2);

in參數建立

delimiter //
CREATE PROCEDURE p2(
OUT nid int
)
BEGIN
set nid=111111;
END //
delimiter ;
執行：
set @v1=10; --須要先定義變量，再將輸出賦值給變量
call p2(@v1);
SELECT @v1;

out參數建立及執行

　　inout是in和out的結合體，用法同in和out。
補充：

 爲何有結果集又有out僞造的返回值？
    1.存儲過程和函數不同，並無返回值。若是咱們須要使用返回值的時候，能夠定義out來僞造返回值。
    2.用於標識存儲過程的執行結果。咱們能夠在存儲過程的不一樣階段返回不一樣的返回值來標記執行結果。
    用於標識存儲過程的執行結果示例；
delimiter //
create procedure p3(
    in n1 int,
    out n2 int 用於標識存儲過程的執行結果 1表示成功,2表示失敗
)
BEGIN
代碼監測：
    insert into vv(..)
    insert into vv(..)
    insert into vv(..)
    set n2=1;
發生異常：
    set n2=2;
END //
delimiter ;

補充說明

　　4.3.事物

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

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; 

    START TRANSACTION; 
        DELETE from tb1;
        insert into tb2(name)values('seven');
        COMMIT; 

    -- SUCCESS 
    set p_return_code = 2; 

END\\
delimiter ;

示例

　　4.4.遊標(性能比較差,最好在程序級別進行操做)
　　4.4.1 遊標使用原理:
　　　　1.聲明遊標
　　　　2.取操做表的數據
　　　　　　my_cursor select id,num from userinfo;
　　　　3.循環每行數據
　　　　　　for row.id,row.num in my_cursor:
　　　　　　#遊標沒法自動識別是否無數據，須要檢測循環是否有數據，若是無數據，則結束循環

delimiter //
create procedure p6()
begin 
    declare row_id int; -- 自定義變量1 
    declare row_num int; -- 自定義變量2 
    declare done INT DEFAULT FALSE; #設置循環結束標誌爲False
    declare temp int;

    declare my_cursor CURSOR FOR select id,num from A; #聲明遊標,my_cursor類型爲cursor，而且從A表中取數據給遊標my_cursor 
    declare CONTINUE HANDLER FOR NOT FOUND SET done = TRUE; #若是遊標數據取完，則設置done爲True

    open my_cursor; #打開遊標
        xxoo: LOOP #xxoo爲自定義循環名稱
        fetch my_cursor into row_id,row_num; #等於python中的for .. in ..，拿一行數據賦值給row_id,row_num
        if done then #若是數據取完，則結束循環
            leave xxoo;
        END IF;
        set temp = row_id + row_num; 
        insert into B(number) values(temp);
        end loop xxoo;
    close my_cursor;
end //
delimter ;

示例

　　4.5.動態執行(防sql注入)

　　4.5.1 命令格式

　　　delimiter //
　　　　create procedure p7(
　　　　in sql varchar(255),
　　　　in arg int
　　　　)
　　　　begin 
　　　　　　--1. 預檢測某個東西 SQL語句合法性
　　　　　　--2. SQL =格式化 tpl + arg 
　　　　　　--3. 執行SQL語句

　　　　　　set @xo = arg;
　　　　　　PREPARE xxx FROM 'select * from student where sid > ?'; -- ?是佔位符
　　　　　　EXECUTE xxx USING @xo;
　　　　　　DEALLOCATE prepare prod; 
　　　　end //
　　　　delimter ;

delimiter \\
CREATE PROCEDURE p8 (
　　in nid int
)
BEGIN
　　set @nid = nid; --須要先將出入的參數值轉換爲session變量（命令要求，不然會保持錯）
　　PREPARE prod FROM 'select * from student where sid > ?'; --預製語句，prod爲自定義名稱
　　EXECUTE prod USING @nid; --將nid傳入 'select * from student where sid > ?' 的佔位符？處
　　DEALLOCATE prepare prod; --執行sql命令
END \\
delimiter ;

示例

　　4.6.存儲過程執行

　　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)

　　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)

　　4.7.存儲過程刪除

drop PROCEDURE 存儲過程名

　　5.索引

　　索引，是數據庫中專門用於幫助用戶快速查詢數據的一種數據結構。相似於字典中的目錄，查找字典內容時能夠根據目錄查找到數據的存放位置，而後直接獲取便可。

　　5.1 索引的做用：

　　　　1.根據索引類型的不一樣,有不一樣的越蘇

　　　　2.加速查詢速度。（可是會下降行修改，增長，刪除的效率）

　　5.2 索引加速的原理:

　　　　將索引內容以某種存儲格式建立額外的文件,用來加速查詢。

　　　　　　1.hash加速

　　　　　　　經過將索引內容hash後報存在額外的文件裏，查詢時若是爲索引值，則優先在這張表裏查詢。因爲hash報存時，並非按照表內容的順序進行報存,而是隨機順序保存，因此hash方式的索引在範圍查找時效率較低，單值查找時較快。

　　　　　　2.btree

　　　　　　　　mysql默認的索引保存方式，使用了二叉樹原理，二叉樹是按照必定的規律進行排列的,因此範圍查找速度較快。

　　　　5.3 索引的分類：　　　　　

　　　　　　1.主鍵索引：不能爲空+不能重複，加速查找，一個表只能有一個主鍵索引
　　　　　　2.普通索引：沒有約束，加速查找
　　　　　　3.惟一索引：能夠爲空，不能重複，加速查找
　　　　　　4.聯合索引( 專門用於組合搜索，其效率大於索引合併)：
　　　　　　　　聯合惟一索引
　　　　　　　　聯合普通索引
　　　　　　　　聯合主鍵索引

　　　　　　5.全文索引：對文本的內容進行分詞，進行搜索 (通常使用第三方工具來進行索引，不使用全文索引)

　　　　　　名詞補充:

　　　　　　　　索引合併，使用多個單列索引組合搜索
　　　　　　　　覆蓋索引，select的數據列只用從索引中就可以取得，沒必要讀取數據行，換句話說查詢列要被所建的索引覆蓋.

　　　　5.4 有索引和無索引查詢速度比較

　　　　　　使用索引:　　　　　　　　

　　　　　　不使用索引　　　　　　　

　　　　5.5 各索引的建立，修改，刪除

　　　　　　5.5.1 普通索引

　　　　　　　　普通索引只有加速查找的做用，不對數據進行約束。

create table in1(
    nid int not null auto_increment primary key,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text,
    index ix_name (name)    #index 索引名 列名(能夠多列)
)

建立表和普通索引

create index index_name on table_name(column_name)

建立普通索引

DROP INDEX index_name ON talbe_name
ALTER TABLE table_name DROP INDEX index_name
ALTER TABLE table_name DROP PRIMARY KEY

刪除索引

show index from table_name;

mysql> show keys from index_pra;
+-----------+------------+--------------+--------------+-------------+----------
-+-------------+----------+--------+------+------------+---------+--------------
-+
| Table     | Non_unique | Key_name     | Seq_in_index | Column_name | Collation
 | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment
 |
+-----------+------------+--------------+--------------+-------------+----------
-+-------------+----------+--------+------+------------+---------+--------------
-+
| index_pra |          0 | PRIMARY      |            1 | id          | A
 |      676725 |     NULL | NULL   |      | BTREE      |         |
 |
| index_pra |          1 | index_pra_ix |            1 | name        | A
 |      699559 |     NULL | NULL   | YES  | BTREE      |         |
 |
| index_pra |          1 | index_pra_ix |            2 | email       | A
 |      699559 |     NULL | NULL   | YES  | BTREE      |         |
 |
+-----------+------------+--------------+--------------+-------------+----------
-+-------------+----------+--------+------+------------+---------+--------------
-+
3 rows in set (0.00 sec)

查看索引

　　　　　　　　注意：對於建立索引時若是是BLOB 和 TEXT 類型，必須指定length。

create index ix_extra on in1(extra(32));

　　　　　　5.5.2 惟一索引

　　　　　　　　約束:不能重複，能夠爲空。有加速查找做用

 CREATE TABLE employ(
    id int auto_increment PRIMARY KEY,
    name char(20),
    pc_id int,
    UNIQUE uq_hostinfo_employ (pc_id)
);

建立表及惟一約束索引

create unique index 索引名 on 表名(列名)

建立惟一索引

drop unique index 索引名 on 表名;

若是命令報錯，可使用:
drop  index 索引名 on 表名;

刪除惟一索引

　　　　　　5.5.3 主鍵索引

　　　　　　　　約束:不能重複，不能爲空，有加速查找做用

create table in1(
    nid int not null auto_increment primary key,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text,
    index ix_name (name)
)

OR

create table in1(
    nid int not null auto_increment,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text,
    primary key(ni1),
    index ix_name (name)
)

建立表 + 建立主鍵

建立表及主鍵

alter table 表名 add primary key(列名);

建立主鍵

1.當主鍵沒有自增時：
    alter table 表名 drop primary key;
    alter table 表名  modify  列名 int, drop primary key;
2、當主鍵由自增時，須要先刪自增，再刪除主鍵
    Alter table tb change id id int(10);//刪除自增加
    Alter table tb drop primary key;//刪除主建

刪除主鍵

　　　　5.5.4 組合索引

　　　　　　組合索引是將n個列組合成一個索引

　　　　　　其應用場景爲：頻繁的同時使用n列來進行查詢，如：where username = 'root' and passwd = '123456'。

create table in3(
    nid int not null auto_increment primary key,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text
)

建立表

create index ix_name_email on in3(name,email);

建立組合索引

　　　　　　組合索引查詢時,遵循最左前綴匹配原則。

　　　　　　如上建立組合索引以後，查詢：

　　　　　　　　name and email -- 使用索引 #name爲最左邊索引

　　　　　　　　name -- 使用索引

　　　　　　　　email -- 不使用索引

　　　　　　注意：對於同時搜索n個條件時，組合索引的性能好於多個單一索引合併。

　　　　5.6 索引命中

　　　　　　索引能夠加快查詢速度，可是咱們須要避免索引未命中的行爲，致使沒法利用到索引加速。常見的錯誤用法以下：

-like '%xx'
    select * from tb1 where name like '%cn';

- 使用函數
    select * from tb1 where reverse(name) = 'wupeiqi';

- or

    select * from tb1 where nid = 1 or email = 'seven@live.com';   #nid爲索引,email不爲索引

    特別的：當or條件中有未創建索引的列才失效，如下會走索引
            select * from tb1 where nid = 1 or name = 'seven';   #nid和name都是索引
            select * from tb1 where nid = 1 or email = 'seven@live.com' and name = 'alex'；  #and會使用有索引的那列

- 類型不一致
    若是列是字符串類型，傳入條件是必須用引號引發來，主鍵除外
    select * from tb1 where name = 999;

- !=
    select * from tb1 where name != 'alex'
    特別的：若是是主鍵，則仍是會走索引
        select * from tb1 where nid != 123

- >

    select * from tb1 where name > 'alex'
    特別的：若是是主鍵或索引是整數類型，則仍是會走索引
        select * from tb1 where nid > 123
        select * from tb1 where num > 123

- order by
    select email from tb1 order by name desc;
    當根據索引排序時候，選擇的映射若是不是索引，則不走索引
    特別的：若是對主鍵排序，則仍是走索引：
        select * from tb1 order by nid desc;
 
- 組合索引最左前綴
    若是組合索引爲：(name,email)
    name and email       -- 使用索引
    name                 -- 使用索引
    email                -- 不使用索引

　　　　5.7 其餘注意點

- 避免使用select *   --效率低
- count(1)或count(列) 代替 count(*)   --報錯
- 建立表時儘可能時 char 代替 varchar　　　　--char固定長度，檢索速度快
- 表的字段順序固定長度的字段優先
- 組合索引代替多個單列索引（常用多個條件查詢時）　　--組合索引效率更高
- 儘可能使用短索引　　　　　　　　　　　　　　　　　　--如數據後面都同樣,則可使用局部索引   create index index_eg on tb(titile(16));
　　　　　　　　　　　　　　　　　　　　　　　　　　　　指定titile前十六個字符作索引
- 使用鏈接（JOIN）來代替子查詢(Sub-Queries)     --mysql如今版本速度差很少
- 連表時注意條件類型需一致　　　　　　　　　　　　　　--類型不一致也能夠連表
- 索引散列值（重複少）不適合建索引，例：性別不適合

　　　　5.8 分頁

    每頁顯示十條，一共有100萬條數據，如何解決分頁問題:
解決方案：
     1.不讓看很後面的數據
     2.索引表中掃描
       select * from userinfo3 where id in(select id from userinfo3 limit 200000,10)  
       缺點：
              select id from userinfo3 limit 200000,10； 須要從頭掃到截取的位置，數據越後面致使耗時越久，效率低。
      3.正確方案：
       記錄當前頁最大或最小ID
       3.1. 頁面只有上一頁，下一頁
        # max_id
        # min_id
    下一頁：
        select * from userinfo3 where id > max_id limit 10;
    上一頁：
    select * from userinfo3 where id < min_id order by id desc limit 10;
    3.2. 上一頁 192 193  [196]  197  198  199 下一頁
                    
        select * from userinfo3 where id in (select id from (select id from userinfo3 where id > max_id limit 30) as N order by N.id desc limit 10)
     補充:
     1.爲何不用between .. and ..
            由於id不必定是連續的，用between會致使頁面顯示不完整 。

　　5.9 執行計劃

　　　　執行計劃能夠評估下sql的執行時間，用來比較sql語句是否比較優。雖然執行計劃並非百分百能夠對比sql優化程度，可是大部分狀況下都適用。

　　　命令：

explain + 查詢SQL - 用於顯示SQL執行信息參數，根據參考信息能夠進行SQL優化

 查詢順序標識
            如：mysql> explain select * from (select nid,name from tb1 where nid < 10) as B;
            +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
            | id | select_type | table      | type  | possible_keys | key     | key_len | ref  | rows | Extra       |
            +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
            |  1 | PRIMARY     | <derived2> | ALL   | NULL          | NULL    | NULL    | NULL |    9 | NULL        |
            |  2 | DERIVED     | tb1        | range | PRIMARY       | PRIMARY | 8       | NULL |    9 | Using where |
            +----+-------------+------------+-------+---------------+---------+---------+------+------+-------------+
        特別的：若是使用union鏈接氣值可能爲null


    select_type
        查詢類型
            SIMPLE          簡單查詢
            PRIMARY         最外層查詢
            SUBQUERY        映射爲子查詢
            DERIVED         子查詢
            UNION           聯合
            UNION RESULT    使用聯合的結果
            ...
    table
        正在訪問的表名


    type
        查詢時的訪問方式，性能：all < index < range < index_merge < ref_or_null < ref < eq_ref < system/const
            ALL             全表掃描，對於數據表從頭至尾找一遍
                            select * from tb1;
                            特別的：若是有limit限制，則找到以後就不在繼續向下掃描
                                   select * from tb1 where email = 'seven@live.com'
                                   select * from tb1 where email = 'seven@live.com' limit 1;
                                   雖然上述兩個語句都會進行全表掃描，第二句使用了limit，則找到一個後就再也不繼續掃描。

            INDEX           全索引掃描，對索引從頭至尾找一遍
                            select nid from tb1;

            RANGE          對索引列進行範圍查找
                            select *  from tb1 where name < 'alex';
                            PS:
                                between and
                                in
                                >   >=  <   <=  操做
                                注意：!= 和 > 符號


            INDEX_MERGE     合併索引，使用多個單列索引搜索
                            select *  from tb1 where name = 'alex' or nid in (11,22,33);

            REF           根據索引查找一個或多個值。
                            select *  from tb1 where name = 'seven';

            EQ_REF          鏈接時使用primary key 或 unique類型
                            select tb2.nid,tb1.name from tb2 left join tb1 on tb2.nid = tb1.nid;



            CONST      常量
                            表最多有一個匹配行,由於僅有一行,在這行的列值可被優化器剩餘部分認爲是常數,const表很快,由於它們只讀取一次。
                            select nid from tb1 where nid = 2 ;

            SYSTEM          系統(覆蓋索引)
                            表僅有一行(=系統表)。這是const聯接類型的一個特例。
                            select * from (select nid from tb1 where nid = 1) as A;
    possible_keys
        可能使用的索引

    key
        真實使用的

    key_len
        MySQL中使用索引字節長度

    rows
        mysql估計爲了找到所需的行而要讀取的行數 ------ 只是預估值

    extra
        該列包含MySQL解決查詢的詳細信息
        「Using index」
            此值表示mysql將使用覆蓋索引，以免訪問表。不要把覆蓋索引和index訪問類型弄混了。
        「Using where」
            這意味着mysql服務器將在存儲引擎檢索行後再進行過濾，許多where條件裏涉及索引中的列，當（而且若是）它讀取索引時，就能被存儲引擎檢驗，所以不是全部帶where子句的查詢都會顯示「Using where」。有時「Using where」的出現就是一個暗示：查詢可受益於不一樣的索引。
        「Using temporary」
            這意味着mysql在對查詢結果排序時會使用一個臨時表。
        「Using filesort」
            這意味着mysql會對結果使用一個外部索引排序，而不是按索引次序從表裏讀取行。mysql有兩種文件排序算法，這兩種排序方式均可以在內存或者磁盤上完成，explain不會告訴你mysql將使用哪種文件排序，也不會告訴你排序會在內存裏仍是磁盤上完成。
        「Range checked for each record(index map: N)」
            這個意味着沒有好用的索引，新的索引將在聯接的每一行上從新估算，N是顯示在possible_keys列中索引的位圖，而且是冗餘的。

詳細介紹

　　5.10 慢日誌

　　　　DBA能夠開啓慢日誌,看哪些sql語句查詢比較慢，是否命中索引

查看慢日誌配置：
show variables like '%query%'；

+------------------------------+-----------------------------------------+
| Variable_name                | Value                                   |
+------------------------------+-----------------------------------------+
| slow_query_log               | ON                                      |
| slow_query_log_file          | E:\mysql-5.7.17-winx64\data\my_slow.log |
+------------------------------+-----------------------------------------+

參數說明:
     slow_query_log      是否開啓慢日誌
    slow_query_log_file      慢日誌保存文件路徑

查看慢日誌設置閾值
show variables like '%queries%';

+----------------------------------------+-------+
| Variable_name                          | Value |
+----------------------------------------+-------+
| long_query_time                        | 0.200000 |
| log_queries_not_using_indexes          | ON    |
| log_throttle_queries_not_using_indexes | 2   |
+----------------------------------------+-------+

參數說明:
    long_query_time  查詢時間超時該閾值則記錄，單位爲 s
    log_queries_not_using_indexes   是否記錄沒有使用索引的sql
    log_throttle_queries_not_using_indexes  用來表示每分鐘容許記錄到slow log的且未使用索引的SQL語句次數。該值默認爲0，表示沒有限制

查看慢日誌相關配置

　　session級別修改配置參數

set global 變量名 = 值

　　修改配置文件

    mysqld --defaults-file='E:\wupeiqi\mysql-5.7.16-winx64\mysql-5.7.16-winx64\my-default.ini'
                
my.conf內容：
    slow_query_log = ON
    slow_query_log_file = D:/....
    ...                
注意：修改配置文件以後，須要重啓服務

修改配置文件

　　查看慢日誌

　　mysqldumpslow -s at -a /usr/local/var/mysql/MacBook-Pro-3-slow.log

"""
--verbose    版本
--debug      調試
--help       幫助
 
-v           版本
-d           調試模式
-s ORDER     排序方式
             what to sort by (al, at, ar, c, l, r, t), 'at' is default
              al: average lock time
              ar: average rows sent
              at: average query time
               c: count
               l: lock time
               r: rows sent
               t: query time
-r           反轉順序，默認文件倒序拍。reverse the sort order (largest last instead of first)
-t NUM       顯示前N條just show the top n queries
-a           不要將SQL中數字轉換成N，字符串轉換成S。don't abstract all numbers to N and strings to 'S'
-n NUM       abstract numbers with at least n digits within names
-g PATTERN   正則匹配；grep: only consider stmts that include this string
-h HOSTNAME  mysql機器名或者IP；hostname of db server for *-slow.log filename (can be wildcard),
             default is '*', i.e. match all
-i NAME      name of server instance (if using mysql.server startup script)
-l           總時間中不減去鎖定時間；don't subtract lock time from total time
"""

　　6.其餘補充

　　1.條件語句　　

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 ;

IF語句

　　2.循環語句

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 ;

while循環

while循環

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 ;

repeat

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

loop

　　3.動態執行sql語句

delimiter \\
DROP PROCEDURE IF EXISTS proc_sql \\
CREATE PROCEDURE proc_sql ()
BEGIN
    declare p1 int;
    set p1 = 11;
    set @p1 = p1;

    PREPARE prod FROM 'select * from tb2 where nid > ?';
    EXECUTE prod USING @p1;
    DEALLOCATE prepare prod; 

END\\
delimiter ;

動態執行SQL

動態執行sql