一.索引,分页性能,执行计划,慢日志

(1)索引的种类,创建语句,名词补充(最左前缀匹配,覆盖索引,索引合并,局部索引等):

import sys
#  http://www.cnblogs.com/wupeiqi/articles/5716963.html 武老师索引补充
'''
索引种类:
    单列:
        1.普通索引 : 加速查找
        2.主键索引 : 加速查找 + 不能为空+ 唯一
        3.唯一素银 : 加速查找 + 唯一
    多列:
        4.联合(组合)索引 : 1.联合唯一  2.联合不唯一
            联合主键索引
            联合唯一索引
            联合普通索引(自己取名来的)
'''
#主键索引
#生成普通索引:
    # create index ix_name on userinfo(列名)
    #drop index ix_name on table_name
#生成唯一索引:
    #create unique index index_name on table_name(field)
#生成联合索引:
    # create index ix_name on userinfo(列名,列名...)
    #drop index ix_name on table_name
#局部索引:
    #create index index_name on table_name(列明(16)) 表示列名前16个字符做索引
    #以下几个类型一定要做局部索引:
        #1. Text类型

'''#最左前缀匹配
# create index ix_name_email on userinfo(name,email,lie3,lie4..); 多列还是最左前缀
        #设置普通联合索引,还是会以name为准,只有带上name作为条件,才能查得快,只有email还是慢
'''
#因此组合索引 效率比 索引合并效率高
#但是组合索引,因为有 最左前缀匹配。
# 要依据实际情况去创建索引!!!
'''
两种不是真实的索引,是概念:
    覆盖索引:在索引文件中直接获取数据,(而不用去数据表再获取其他数据)
            覆盖索引:select email from userinfo where email = 'email213'
                      但是如果 select * 则还要去数据表中获取其他列数据

    索引合并:把多个单列索引,合并使用
            select * from userinfo where emai=xxx and id = xxx; (email和id都设置了索引)

    #局部索引: 如果字段前后有重复值,那么重复值就不取,只取该字段不重复部分做索引
'''

#全文索引:生产过程中不借助mysql,用第三方工具,知道就好

'''
总结:
    索引的种类1.主键索引,2.普通索引,3.唯一索引,4.联合索引,5.覆盖索引和索引合并
    索引创建的命令语句
    #特点:1.查找速度快,但是更删改慢(索引不是越多越好!!!)
           2.额外硬盘空间放索引的存储特殊的数据结构:1.哈希索引 2.btree索引
           3.索引要命中,才有效果
    #联合索引:最左前缀匹配
    #索引无法命中的情况
'''

#create table t1( id int auto_increment primary key,
                 # num int,
                 # name char(10),
                 #unique 索引名 (num)  #单列唯一索引
                 #index 索引名 (num)  #创建普通索引
                 #unique 索引名 (num,name) #联合唯一索引: 不能由两行一模一样的 num和name

索引初识

#-- select * from userinfo where name='alex359613';   3.379秒
# select * from userinfo where id = 359613;          #id作为索引 查询只用了 0.063秒

#生成普通索引:
    # create index ix_name on userinfo(列名)
    #drop index ix_name on table_name
#生成唯一索引:
    #create unique index index_name on table_name(field)
#生成联合索引:
    # create index ix_name on userinfo(列名,列名...)
    #drop index ix_name on table_name
#局部索引:
    #create index index_name on table_name(列明(16)) 表示列名前16个字符做索引
    #以下几个类型一定要做局部索引:
        #1. Text类型
'''
无索引:从前到后一次查找
  索引:
        name   创建额外文件(某种格式存储),
        name,email   创建额外文件(某种格式存储),
            当搜索的时候,先来这个文件里找数据在哪个文职,然后去表里定位

'''

# create index ix_name_email on userinfo(name,email);
        #最左前缀匹配
        #设置普通联合索引,还是会以name为准,只有带上name作为条件,才能查得快,只查email还是慢

'''
索引种类
    hash索引:创建了一个索引表,把所有的name都转换为hash值+这行所在的内存地址,然后直接根据地址,去找到数据
              哈希表的值,和数据库表里的值,顺序是不一样的
              缺点:取范围速度没那么快。
                    比如我们找id>3在普通表就很快找了,因为遍历只要到3,但是哈希索引因为是乱序的所以这种情况下反倒没那么快
              优点: 但是哈希索引在寻找单个值的时候,速度是非常快的
    btree索引:二叉树的格式,用二分法查找方法,应用较广(innodb引擎)。

'''
#要想查找速度快
    #建立索引:查询快,增改删变慢
        #1.额外的文件,保存特殊的数据结构,
        #2.创建了索引,导致我们 insert或者update或者delete的时候也要去更新索引,所以插入和更新速度会变慢
        #3.命中索引:创建了要用,才能有价值

hash索引和btree索引

#索引无法命中的情况
#执行计划explain: 但是以后在公司的时候 如果忘记了以下情况,可以去sql里面自己运行语句测试一下

# 不走索引的情况,避免以下情况
'''
- like '%xx'    (生产过程中数据量大会用到第三方工具)
    select * from tb1 where name like '%cn';

        关于like:
            用户量少的时候: 用like和占位符模糊匹配
            用户量巨大的时候:
                第三方工具 sifinks(发音)
                    他会把字段 存在文件里, 比如:title字段
                        镇化,增长率,省份..  对应的id有  1,,4,5,
                        然后获取到对应id后,再到 sql中进行  select * from userinfo where id in (...)

- 使用函数
    select * from tb1 where reverse(name) = 'wupeiqi';
                            所以让自己的字符串条件翻转就好啦
- or
    select * from tb1 where nid = 1 or email = 'seven@live.com';
    特别的:当or条件中有未建立索引的列才失效,以下会走索引
            select * from tb1 where nid = 1 or name = 'seven';
            select * from tb1 where nid = 1 or email = 'seven@live.com' and name = 'alex'

- 类型不一致
    如果列是字符串类型,传入条件是必须用引号引起来,不然...
    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                -- 不使用索引
'''

无法命中索引的几种情况

import os

'''打星号为基础中的基础,要背下来
1.******* 避免使用select *  (联想覆盖索引)

2.*******count(1)或者count(列),代替 count(*)

3.*******创建表的时 char 代替 varchar

4.表的字段顺序固定长度字段优先

5.组合索引代替多个单列索引 (这个要根据实际情况,如果单列查得多,还是用单列好),注意有 最左前缀匹配

6.尽量使用短索引: 局部索引,参见此day39 文件1

7.使用连接(join)来代替子查询(Sub-Queries):mysql里可以先不用在意这个,sql sever中有差别

8.连表时注意条件类型一致

9.*******索引散列值(重复少)不适合建索引,比如:性别这个列
'''

索引注意事项-有3点一定要会

(2).limit分页性能几种方案

import os

'''
    limit 数值越大越慢,比如 limit 300000,10 它会先扫描30万行,然后再取下10行
'''

'''
那要怎么解决这个分页问题呢:
    1.不让看 比如博客园,首页最多只能浏览 200页的内容
    2.索引表中扫描: 用到了覆盖索引,但是速度还是不快
        select * from userinfo where id in (
                select id from userinfo limit 200000,10)
    3.较优解法:
        结合python语句,记录当前页最大或最小id:
            1.页面只有上一页和下一页
            下一页: select * from userinfo where id > 200000 limit 10;
            上一页: select * from userinfo where id < 200000 order by id desc limit 10;
            那比如 197 198 199 200 201 我们网页上是这么显示的
            此时如果我在197 想跳转到200页怎么操作呢?每页10行
                    select * from userinfo where id > 200000 limit 10*(200-197),10;  #大于200000后,从第30行开始,取10行
              或者   select * from userinfo where id in
              (select id from (select * from userinfo where id > [当前页maxid] limit 30) as N order by N.id desc limit 10 );
                                                        #大于200000后,取30行,设置临时表,再从大到小排序,取前十行的id,再表中选择

那如果没有上下页关联,我就是想从第1页跳转到第1万页呢
这在sql中目前实现不了,只能慢慢等待扫描了。  

有个想法是 between and
select * from userinfo where id between 1 and 10;
但是要考虑到 id是否一定是连续的呢, 比如 delete from userinfo where id = 4;
那么 此时1 - 10 就只有9条数据了
!!!***
因此有个重要前提是 【limit的时候,一定要考虑到 id是否是连续的!!】
'''

#武老师博客的分页代码
'''
每页显示10条:
当前 118 120, 125

倒序:
            大      小
            980    970  7 6  6 5  54  43  32

21 19 98
上一页:

    select
        *
    from
        tb1
    where
        nid < (select nid from (select nid from tb1 where nid < 当前页最小值 order by nid desc limit 每页数据 *【页码-当前页】) A order by A.nid asc limit 1)
    order by
        nid desc
    limit 10;

    select
        *
    from
        tb1
    where
        nid < (select nid from (select nid from tb1 where nid < 970  order by nid desc limit 40) A order by A.nid asc limit 1)
    order by
        nid desc
    limit 10;

下一页:

    select
        *
    from
        tb1
    where
        nid < (select nid from (select nid from tb1 where nid > 当前页最大值 order by nid asc limit 每页数据 *【当前页-页码】) A order by A.nid asc limit 1)
    order by
        nid desc
    limit 10;

    select
        *
    from
        tb1
    where
        nid < (select nid from (select nid from tb1 where nid > 980 order by nid asc limit 20) A order by A.nid desc limit 1)
    order by
        nid desc
    limit 10;
'''

limit分页性能几种方案

(3).执行计划介绍:

import os

#执行计划
#预估一条sql语句的执行时间
'''
mysql> explain select * from userinfo \G;
*************************** 1. row ***************************
           id: 1        #注释1
  select_type: SIMPLE  :代指简单查询
        table: userinfo #注释2
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 2837841
     filtered: 100.00
        Extra: NULL
1 row in set, 1 warning (0.00 sec)
'''
#注释1:
#id:1  标识符,代指现在预估哪一条sql,和顺序无关. 这里只有一句所以就1
        #select * from tb where id in (select id from tb2); 这里就有2句sql了
#注释2:
    #ALL : 全表扫描 #但是all不一定慢,比如 select * from tb limit 1;
    #range : where id > 3
    #const : where id = 3  #constant
    #ref : 通过索引查询
    #总结:查询时的访问方式,性能:all < index < range < index_merge < ref_or_null < ref < eq_ref < system/const
            #具体各个值代指什么,见最下方

'''
#那如果查询的字段有 索引,他是怎么预估的呢
mysql> explain select * from userinfo where name='alex465456' \G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: userinfo
   partitions: NULL
         type: ref
possible_keys: ix_name_email
          key: ix_name_email
      key_len: 91
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL
1 row in set, 1 warning (0.00 sec)
'''

explain执行计划介绍

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

type属性详解

(4).慢日志记录:

import os
#DBA工作
#在mysql的服务端进行记录

'''
mysql> show variables like '%quer%';
+----------------------------------------+---------------------------------------------+
| Variable_name                          | Value                                       |
+----------------------------------------+---------------------------------------------+
| binlog_rows_query_log_events           | OFF                                         |
| ft_query_expansion_limit               | 20                                          |
| have_query_cache                       | NO                                          |
| log_queries_not_using_indexes          | OFF        # 语句未使用索引                                  |
| log_throttle_queries_not_using_indexes | 0                                           |
| long_query_time                        | 10.000000  #运行时间大于10秒 则记录                            |
| query_alloc_block_size                 | 8192                                        |
| query_prealloc_size                    | 8192                                        |
| slow_query_log                         | OFF         # 慢查询日志是否开启                                  |
| slow_query_log_file   #慢日志目录       | D:\mysql-8.0.12-winx64\data\Gkx-PC-slow.log |
+----------------------------------------+---------------------------------------------+
10 rows in set, 1 warning (0.00 sec)

注:查看当前配置信息:
       show variables like '%query%'
     修改当前配置:
    set global 变量名 = 值
       set global slow_query_log = ON;
'''

#配置:
    #以上是依据内存进行设置: 设置完马上生效

    #还可以依据配置文件: mysqld
            # mysqld --defaults-file='D:\mysql-8.0.12-winx64\my.ini' #  就是我们最先设置的 my.ini 啦,所以可以告诉它这个ini配置文件的路径,然后我们在ini里写好配置即可
                #比如所在 d:/my.ini  然后在这个 ini文件里 把slow_query_log = ON;
                #想要设置的变量写进去
                # slow_query_log = ON
                # slow_query_log_file = '路径'...
'''
                修改配置文件前,一定要备份
                修改配置文件后,要重启才能生效
'''

慢日志记录

二.视图

视图view

三.触发器

# 定义 : 对某个表进行【增/删/改】操作的前后如果希望触发某个特定的行为时,可以使用触发器,(可以插入多张表也没问题)
# 触发器用于定制用户对表的行进行【增/删/改】前后的行为。
#注意触发器是没有 select 的引发行为的,只有 insert,delete,update
#如果tb1 在一行语句插入多行数据,那么触发器也会对应插入多行数据

# 要创建触发器前,应该先修改分隔符  delimiter
#insert into tb (....)
# -- delimiter //
# -- create trigger t1 BEFORE INSERT on student for EACH ROW
# -- BEGIN
# --     INSERT into teacher(tname) values(NEW.sname);  #因为不修改的话,执行到这里的分号语句就结束了,下面的执行不到
# --     INSERT into teacher(tname) values(NEW.sname);  #NEW.sname 表示你插入tb1 的那条字段的新数据
# --     INSERT into teacher(tname) values(NEW.sname);
# --     INSERT into teacher(tname) values(NEW.sname);
# -- END //
# -- delimiter ;  #修改完记得改回来

# -- insert into student(gender,class_id,sname) values('女',1,'陈涛'),('女',1,'张根');
# -- NEW,代指新数据 (用于 insert)
# -- OLD,代指老数据 (用于 delete / update)

#总结触发器如下:
# # 插入前
# CREATE TRIGGER tri_before_insert_tb1 BEFORE INSERT ON tb1 FOR EACH ROW
# BEGIN
#     INSERT into teacher(tname) values(NEW.sname); (在插入数据之前,要做这个操作)也就是你每往tb1插入一条数据,tb2也会插入数据
# END                                                  #如果tb1 在一行语句插入多行数据,那么触发器也会对应插入多行数据
#
# # 插入后
# 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

trigger触发器

四.函数

#MySQL也有 内置函数 和 自定义函数  :函数是必定有返回值的

# select now()

# 老师博客: http://www.cnblogs.com/wupeiqi/articles/5713323.html
# 官方解释:https://dev.mysql.com/doc/refman/5.7/en/functions.html
#时间格式化
#select DATE_FORMAT(时间字段,'%Y-%m'),count(1) from table_name group by DATE_FORMAT(时间字段,'%Y-%m')
#格式类似 time模块

#自定义函数:
    # delimiter \\
    # create function f1(
    #     i1 int,
    #     i2 int) #传参
    # returns int #返回值数据类型
    # BEGIN
    #     declare num int;  #一定不能写 select
    #     set num = i1 + i2;
    #     return(num);
    # END \\
    # delimiter ;
#删除函数:drop function func_name;
#执行函数: select f1(0,100) ; 输出 100
    # # 获取返回值
    # declare @i VARCHAR(32);
    # select UPPER('alex') into @i;
    # SELECT @i;
    #
    # # 在查询中使用
    # select f1(11,nid) ,name from tb2;

函数介绍

#部分内置函数—字符串相关的
# 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'
#
# 部分内置函数

字符串相关的函数

最常用的:字符串去重,拼接,取子序列,时间的操作

五.存储过程

import time
'''
#存储过程,相比 视图,触发器,函数 更为重要
#存储过程在服务端的mysql(视图,触发器,函数也是),客户端只要知道存储过程的名字就可以了
#定义: 保存在mysql上的一个别名 ---> 一串SQL语句,使用别名就能查到语句
#没有返回值的概念 有三个参数类型 in(传进去要使用的)  out(传进去要拿出来的)  inout(传进去既可以使用也可以拿出来的)
'''
#和视图的区别:
    #视图:别名代指临时表,只能select,动态的显示表,并不建议修改
    #存储过程:存了很多sql语句,比视图多。调用更简单,实现功能更多
            #用来替代sql语句的,让程序员不在写程序语句了
            #直接调用 存储过程 别名,就可以直接使用sql语句了
            #将sql语句和代码进行解耦了,比如网络传输只需要传别名

#程序员写sql,然后交给dba审核
#慢日志:pymysql 可以记录执行较慢的 sql语句。

# 方式一:
#     mysql:存储过程
#     程序:调用存储过程
# 方式二:
    # mysql:啥也不做
    #程序:写SQL语句
#方式三:
    #mysql:啥也不做
    #程序:写类和对象  ---> 转化为 SQL语句

#存储过程初识:
    # 一 不带参数
        # delimiter //
        # create procedure p1()
        # begin
        #     select * from student;
        #     insert into teacher(tname) values('ct');
        # end //
        # delimiter ;
        #执行procedure : call p1();
        #cursor.callproc('p1')

    #二 带参数的:in (传进去使用的) 参数表示有 int out inout
        # delimiter //
        # create procedure p2(
        #           in n1 int,
        #           in n2 int
        #                     )
        # begin
        #     select * from student where sid between n1 and n2;
        #
        # end //
        # delimiter ;
        # 执行procedure : call p1(12,2);
        # cursor.callproc('p2',(12,2))
'''
    #三. 带参数的:out (传进去后要拿出来的)  参数表示有 int out inout
        # delimiter //
        # create procedure p3(
        #           in n1 int,
        #           out n2 int  #n2必须是变量
        #                     )
        # begin
        #    set n2 = 11111;
        #     select * from student where sid > n1;
        #
        # end //
        # delimiter ;
        # 执行procedure :
                    # set @v1 = 1;
                    # call p3(12,@v1); 此时 n2 作为out类型,要传一个变量,然后可以在外部再获取到这个变量
                    # select @v1;
        # cursor.callproc('p2',(12,2)) 首先拿结果集
        # cursor.execute('select @_p3_0,@_p3_1')
        # ret = cursor.fetchone();print(ret)------> ((12,11111))----》((n1的值,n2修改后的值))

        #mysql中有一个session的概念
        # set  @v1 = 0;  #表示创建了一个 session级别的变量 v1 . 【@】类似python中的 global
        # # 执行procedure : call p3(12,@v1);
        #然后再使用 @v1的时候,@v1值就变为了 11111 --> (select @v1;)
'''

# 特性======>
    #1.可传参 in out inout
    #2.MySQL中用call调用,pymysql用  cursor.callproc(procedure,(arg1,arg2..))
    #3.没有返回值,但是可以用 out 伪造一个返回值

'''
为什么有结果集又有out伪造的返回值?
    out 返回值,一般情况下是:用于标识存储过程中的执行结果
            比如返回 1,2,3       1:成功  2:失败  3:一部分成功
            语句1执行 执行完  set n1 =1 表示成功
            语句2执行 执行完  set n2 =2 表示失败.....
'''

procedure存储过程的参数:in out inout

import sys
#1.无参   2.带参数in   3.带参数 in  out

# #接下来第四种: 事务:原子性操作
# 在pymysql中可以进行 try一下,如果报错,则回滚
# ~~~~~~~~~~中文描述
# delimiter //
# create procedure p4(
# out status int
# )
# BEGIN
# 1. 声明如果出现异常则执行{
# set status = 1;
# rollback;
# }
#
# 开始事务
# -- 由秦兵账户减去100
# -- 方少伟账户加90
# -- 张根账户加10
# commit;
# 结束
# set status = 2;
'''
#接下来第四种: 事务:原子性操作
在pymysql中可以进行 try一下,如果报错,则回滚
代码如下:
delimiter \\
create PROCEDURE p4(
    OUT p_return_code tinyint
)
BEGIN
    DECLARE exit handler for sqlexception  #如果出现异常,执行下面begin里的语句
    # https://www.cnblogs.com/datoubaba/archive/2012/06/20/2556428.html
BEGIN
-- ERROR
set p_return_code = 1; #错误返回1
rollback;
END;

START TRANSACTION;   #开始事物
DELETE from tb1;
insert into tb2(name)values('seven');
COMMIT;

-- SUCCESS
set p_return_code = 2; #正确返回2

END\\
delimiter ;
'''
#第四代码:

存储过程—事务

#防 sql注入
#1.pymysql 程序级别去避免
#2.动态的存储过程

#第五:
   #游标:老师没讲

#第六:
# 动态的执行 SQL
'''
6. 动态执行SQL(防SQL注入)

delimiter //
create procedure p7(
in tpl varchar(255),
in arg int
)
begin
1. 预检测某个东西 SQL语句合法性
2. SQL =格式化 tpl + arg
3. 执行SQL语句

set @xo = arg;  #arg 要赋值给一个 session变量
PREPARE xxx FROM 'select * from student where sid > ?';
EXECUTE xxx USING @xo;
DEALLOCATE prepare prod;
end  //
delimter ;
# call p7("select * from tb where id > ?",9)

'''
#真代码如下:
# ===>
#
# delimiter \\
# CREATE PROCEDURE p8 (
# in nid int
# )
# BEGIN
# set @nid = nid;
# PREPARE prod FROM 'select * from student where sid > ?';
# EXECUTE prod USING @nid;
# DEALLOCATE prepare prod;
# END\\
# delimiter ;

存储过程—游标,动态sql(防止sql注入)

import pymysql

conn = pymysql.connect(host='localhost',user='root',password='gkx321',database='sql_homework',charset='utf8')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

cursor.callproc('p3',(12,2)) #n1是12,无所谓n2是多少,不影响
ret = cursor.fetchall()
print(ret)

#out的值要这么获取,固定写法
cursor.execute('select @_p3_0,@_p3_1') #可以只写一个 0获取n1,1获取n2
ret = cursor.fetchall()
print(ret)

'''
为什么格式是这样呢,因为pymysql内部帮我们做了这样子的操作
set @ _p3_0 = 12
set @ _p3_1 = 2
call p3( @ _p3_0,@_p3_1)
select @ _p3_0,@_p3_1
'''

# cursor.execute('select * from teacher')
# ret = cursor.fetchall()
# print(ret)

cursor.close()
conn.close()

pymysql调用存储过程

存储过程总结:    1.无参数    2.有参数 in    3.有参数 in out    为什么有结果集又要有out? ----> 用于标识存储过程中的执行结果    4.事务    5.游标    6.动态执行sql(防sql注入)

数据库相关操作:    1.sql语句:自己写sql全部都能实现        想要利用函数的时候,先找mysql内置函数,找不到再自己写 #函数可能会造成性能低:又索引,函数不会使用索引        -- select xx() from xx;        最常用的:字符串去重,拼接,取子序列                  时间的操作

    2.利用mysql内部提供的功能:视图,触发器,函数,存储过程

MySQL— 索引,视图,触发器,函数,存储过程,执行计划,慢日志,分页性能的更多相关文章

  1. mysql 查询表,视图,触发器,函数,存储过程

    1. mysql查询所有表: SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '数据库名' AND  TAB ...

  2. MySQL 索引 视图 触发器 存储过程 函数

    1.索引 索引相当于图书的目录,可以帮助用户快速的找到需要的内容. 数据库利用各种各样的快速定位技术,能够大大提高查询效率.特别是当数据量非常大,查询涉及多个表时,使用索引往往能使查询速度加快成千上万 ...

  3. python 全栈开发,Day64(视图,触发器,函数,存储过程,事务)

    昨日内容回顾 pymysql:属于python的一个模块 pip3 install pymysql conn = pymysql.connect(...,charset = 'uft8') 创建游标 ...

  4. 【MS SQL】通过执行计划来分析SQL性能

    原文:[MS SQL]通过执行计划来分析SQL性能 如何知道一句SQL语句的执行效率呢,只知道下面3种: 1.通过SQL语句执行时磁盘的活动量(IO)信息来分析:SET STATISTICS IO O ...

  5. Mysql学习---视图/触发器/存储过程/函数/执行计划/sql优化 180101

    视图 视图: 视图是一个虚拟表(非真实存在),动态获取数据,仅仅能做查询操作 本质:[根据SQL语句获取动态的数据集,并为其命名],用户使用时只需使用[名称]即可获取结果集,并可以将其当作表来使用.由 ...

  6. MySQL 视图触发器事务存储过程函数

    事务  致命三问 什么是事务:开启了一个包含多条SQL语句的事务,这些SQL语句要么都执行成功,要么有别想成功:例如A向B转账,二人账户并不属于一家银行,在转账过程中由于网络问题,导致A显示转账 成功 ...

  7. MySQL 5.6 主从复制如何处理——触发器,函数,存储过程,调度事件

      截图来自MySQL5.6的pdf版文档. 说明: 1)基于语句的复制时,trigger会在slave上执行,所以slave上也需要有trigger的定义,不然会导致主从数据不一致的: 2)基于行的 ...

  8. python mysql 视图 触发器 事物 存储过程 用户授权 数据备份还原

    ###################总结########### 视图是一个虚拟表(非真实存在) 是跑在内存中的表,真实表是在硬盘上的表 使用视图我们可以把查询过程中的临时表摘出来,保存下来,用视图去 ...

  9. Python9-MySQL-MySQL存储过程-视图-触发器-函数-day45

    视图:某个查询语句设置别名,日后方便使用 CREATE VIEW v1 as SELECT * FROM student WHERE sid >10 -创建: create view 视图名称 ...

  10. 【MySQL笔记】触发器,存储过程和函数

    一.触发器 触发器(TRIGGER):是由事件来触发某个操作.当数据库系统执行这些事件时,就会激活触发器执行相应的操作.MySQL从5.0.2版本开始支持触发器. 触发事件:INSERT语句.UPDA ...

随机推荐

  1. VS2013 密钥 – 所有版本(Visual Studio Ultimate,Premium,Professional,TFS)

    Visual Studio Ultimate 2013 KEY(密钥):BWG7X-J98B3-W34RT-33B3R-JVYW9 Visual Studio Premium 2013 KEY(密钥) ...

  2. C# 中 SQLite 使用介绍

    关于SQLite SQLite是一款轻型的嵌入式的遵守ACID的关系型数据库管理系统,诞生已有15个年头了.随着移动互联的发展,现在得到了更广泛的使用. 在使用SQLite之前,我们势必要先了解它一些 ...

  3. 帐户当前被锁定,所以用户 sa 登录失败。系统管理员无法将该帐户解锁 解决方法

    ALTER LOGIN sa ENABLE ; GO ALTER LOGIN sa WITH PASSWORD = 'password' unlock, check_policy = off, che ...

  4. HDOJ-三部曲-1002-Radar Installation

    Radar Installation Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 20000/10000K (Java/Other) ...

  5. qqq

    http://blog.sina.com.cn/s/blog_6f0774010100wawd.html http://www.2cto.com/kf/201302/189135.html http: ...

  6. fragment的实现与互相通信

    Android3.0后出来的新控件,主要是为了在平板和手机屏幕的兼容 实现效果: 点击Sd卡,出现SD目录下的所有文件和文件夹,点击外置Sd卡,出现外置Sd卡目录下的文件和文件夹.点击U盘,出现U盘目 ...

  7. Jquery的同步和异步请求

    1 异步请求:    1.1 $.ajax       $.ajax({                url : 'your url',                data:{name:valu ...

  8. 【PowerOJ1738】最小路径覆盖

    Description 给定有向图G=(V,E).设P 是G 的一个简单路(顶点不相交)的集合.如果V 中每个 顶点恰好在P 的一条路上,则称P是G 的一个路径覆盖.P 中路径可以从V 的任何一个顶 ...

  9. PostgreSQL自学笔记:5 数据类型和运算符

    5 数据类型和运算符 5.1 PostgreSQL 数据类型介绍 5.1.1 整数类型 整型类型 字节 取值范围 smallint 2字节 -2^15 ~ 2^15 int integer 4字节 - ...

  10. 前端开发之css

    <!--页面中的组成部分通常随便打开一个网页,有文字,图片,视频,表格,音频,表单(注册信息) css 属性/尺寸/边框/背景 1.css的尺寸属性,就是大小width max-width mi ...