• day43

    今日内容

    • python操作MySQL(重要)

    • SQL注入问题(安全相关的xss,csrf)

    • 视图(了解)

    • 触发器(了解)

    • 事务(重要)

    • 存储过程(了解)

    • 内置函数(了解，很多)

    • 流程控制(了解)

    • 索引(重点)

    python操作MySQL

    MySQL本身就是一款c/s架构，有服务端、有客户端，自身带了有客户端，mysql.exe
    python这门语言成为了MySQL的客户端（对于一个服务端来说，客户端可以有很多）

    操作步骤：
    1.先连接MySQL
    host、port、username、password、charset、库等
    2.在python中书写SQL语句
    3.开始执行SQL语句，拿到结果
    4.在python中做处理(进一步对数据处理）
    需要使用第三方一个模块：pymysql mysqldb mysqlclient
    pip install pymysql

    import pymysql

    1. 1.先连接MySQL
    2. conn=pymysql.connect(
    3.     host='127.0.0.1,
    4.     port=3306,
    5.     user='root',
    6.     password='1234',
    7.     db='db8',
    8.     charset='utf8',
    9.     autocomit=True # 自动执行二次提交
    10. )
    12. 2.获取游标
    13. cur=conn.cursor(cursor=pymysql.cursors.DictCursor)
    16. 3.写SQL语句
    17. sql='inseert into teacher(tid,tname) values (7,"ly1")
    18.  
    19. 4.开始执行SQL语句
    20. affect_rows=cur.execute(sql) # 16 影响的行数
    21. 需要执行二次确认：除了查询之外都要二次确认提交
    22. print(affect_rows)
    23.  
    24. 5.想获取到结果
    25. #res=cur.fetchone() # 取单个
    26. #res=cur.fetchmany(5) # 取指定个数
    27. res=cur.fetchall() # 取所有 元组类型
    28. print(res)
    29.  
    30. for i in res:
    31.      print(i.get("sid"))

     SQL注入问题

    1. import pymysql
    2.  
    3. conn = pymysql.connect(
    4.     host='127.0.0.1',
    5.     port=3306,
    6.     user='root',
    7.     password='123',
    8.     database='db8',
    9.     charset='utf8',
    10.     autocommit=True
    11. )
    12.  
    13. cur = conn.cursor(cursor=pymysql.cursors.DictCursor)
    14.  
    15. inp_name = input('username>>>:').strip()
    16. inp_pwd = input('password>>>:').strip()
    17.  
    18. sql = 'select * from userinfo where username="%s" and password="%s"' % (inp_name,inp_pwd)
    19.  
    20. affect_rows=cur.execute(sql)
    21.  
    22. res=cur.fetchone()
    23. if res:
    24.     print("登陆成功")
    25. else:
    26.     print("登陆失败")

    SQL注入的原因是由于特殊符号的组合会产生特殊的效果
     实际生活中 尤其是在注册用户名的时候 会非常明显的提示你很多特殊符号不能用 原因也是一样的
    结论：设计到敏感数据部分 不要自己拼接 交给现成的方法拼接即可

    在使用代码进行数据操作的时候，不同操作的时候 不同操作的级别是不一样的
    针对查无所谓 针对增 改 删都需要二次确认
    conn.commit()

    视图

    1.什么是视图

    视图就是通过查询得到一张虚拟表，然后保存下来，下次直接使用即可

    2.为什么要用视图

    如果要频繁使用一张虚拟表，可以不用重复查询 

    3.如何使用视图

     create view teacher2course as

    select * from teacher inner jion course on teacher,tid = course.teacher_id;

    创建好了之后 验证它的存在navicat验证 cmd终端验证

    最后文件验证 得出下面的结论 视图只有表结构数据还是来源于之前的表

    delete from teacher2course where id=1；

     强调

    1.在硬盘中，视图只有表结构文件，没有表数据文件
    2.视图通常是用于查询，尽量不要修改视图中的数据

    思考：开发过程中会不会去使用视图

    不会！视图是mysql的功能，如果你的项目里面大量的使用到了视图，那意味着你后期想要扩张某个功能的时候这个功能恰巧又需要对视图进行修改，意味着你需要先在mysql这边将视图先修改一下，然后再去应用程序中修改对应的sql语句，这就涉及到跨部门沟通的问题，所以通常不会使用视图，而是通过重新修改sql语句来扩展功能

    触发器

    在满足对某张表数据的增、删、改的情况下，自动触发的功能称之为触发器

    为何要用触发器

    触发器专门针对我们对某一张表数据增insert、删delete、改update的行为，这类行为一旦执行就会触发触发器的执行，即自动运行另外一段sql代码

    创建触发器语法
    1. """语法结构
    2. create trigger 触发器的名字 before/after insert/update/delete on 表名 for each row 
    3. begin
    4.   sql语句
    5. end
    6.   """
    7.  
    8. # 针对插入
    9. create trigger tri_after_insert_t1 after insert on 表名 for each row
    10. begin
    11.   sql代码...
    12. end
    13. create trigger tri_after_insert_t2 before insert on 表名 for each row
    14. begin
    15.   sql代码...
    16. end
    17.  
    18. # 针对删除
    19. create trigger tri_after_delete_t1 afer delete on 表名 for each row
    20. begin
    21.   sql代码...
    22. end
    23. create trigger tri_after_delete_t2 afer delete on 表名 for each row
    24. begin
    25.   sql代码...
    26. end
    27.  
    28. # 针对修改
    29. create trigger tri_after_update_t1 after update on 表名 for each row
    30. begin
    31.   sql代码...
    32. end
    33. create trigger tri_after_update_t2 before update on 表名 for each row
    34. begin
    35.   sql代码...
    36. end

    需要注意 在书写sql代码的时候结束符是；而整个触发器的结束也需要分号；
    这就会出现语法冲突 需要我们临时修改结束符号
    delimiter $$
    delimiter ;
    该语法只在当前窗口有效

    案例

    1. mysql> CREATE TABLE cmd (
    2.     ->     id INT PRIMARY KEY auto_increment,
    3.     ->     USER CHAR (32),
    4.     ->     priv CHAR (10),
    5.     ->     cmd CHAR (64),
    6.     ->     sub_time datetime, #提交时间
    7.     ->     success enum ('yes', 'no') #0代表执行失败
    8.     -> );
    9. Query OK, 0 rows affected (0.03 sec)
    10.  
    11. mysql> create table errlog(
    12.     -> id int primary key auto_increment,
    13.     -> err_cmd char(64),
    14.     -> err_time datetime);
    15. Query OK, 0 rows affected (0.02 sec)
    16.  
    17. mysql> create trigger tri_after_insert_cmd after insert on cmd for each row
    18.     -> begin
    19.     ->     if NEW.success = 'no' then  # 新记录都会被MySQL封装成NEW对象
    20.     ->         insert into errlog(err_cmd,err_time) values(NEW.cmd,NEW.sub_time);
    21.     ->     end if;
    22.     -> end $$
    23. Query OK, 0 rows affected (0.01 sec)
    24.  
    25. mysql> delimiter ;
    26. mysql> insert into cmd (
    27.     -> user,
    28.     -> priv,
    29.     -> cmd,
    30.     -> sub_time,
    31.     -> success
    32.     -> )
    33.     -> values
    34.     -> ('egon','0755','ls -l /etc',NOW(),'yes'),
    35.     ->     ('egon','0755','cat /etc/passwd',NOW(),'no'),
    36.     ->     ('egon','0755','useradd xxx',NOW(),'no'),
    37.     ->     ('egon','0755','ps aux',NOW(),'yes');
    38. Query OK, 4 rows affected (0.01 sec)
    39. Records: 4  Duplicates: 0  Warnings: 0
    40.  
    41. 查询errlog表记录
    42. mysql> select * from errlog;
    43. +----+------------------------------------------------------------------+---------------------+
    44. | id | err_cmd                                                          | err_time            |
    45. +----+------------------------------------------------------------------+---------------------+
    46. |  1 | cat /etc/passwd                                                  | 2023-10-26 17:16:39 |
    47. |  2 | useradd xxx                                                      | 2023-10-26 17:16:39 |
    48. +----+------------------------------------------------------------------+---------------------+
    49. 2 rows in set (0.00 sec)
    50.  
    51. 删除触发器
    52. mysql> drop trigger tri_after_insert_cmd;
    53. Query OK, 0 rows affected (0.00 sec)

    事务

    什么是事务

    开启一个事务可以包含一些sql语句，这些sql语句要么同时成功
    要么一个都别想成功，称之为事务的有原子性

    事务的作用

    保证了对数据操作的数据安全性
    举例：用交行的卡操作建行ATM机给工商的账户转钱

    事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
    原子性（atomicity）：一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么不做。
    一致性（consistency）：事务是必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
    隔离新（isolation）：一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务时隔离的，并发执行的各个事务之间不能干扰。
    持久性（durabili）：持久性也称永久性（permanence），指一个事务一旦提交，他对数据库中数据的改变就是永久性的，接下来的其他操作或故障不应该对其有任何影响。

    如何用
    1. mysql> create table user(
    2.     -> id int primary key auto_increment,
    3.     -> name char(32),
    4.     -> balance int
    5.     -> );
    6. Query OK, 0 rows affected (0.03 sec)
    7.  
    8. mysql> insert into user(name,balance)
    9.     -> values
    10.     -> ('jason',1000),
    11.     -> ('egon',1000),
    12.     -> ('tank',1000);
    13. Query OK, 3 rows affected (0.00 sec)
    14. Records: 3  Duplicates: 0  Warnings: 0
    15.  
    16. mysql> select * from user;
    17. +----+----------------------------------+---------+
    18. | id | name                             | balance |
    19. +----+----------------------------------+---------+
    20. |  1 | jason                            |    1000 |
    21. |  2 | egon                             |    1000 |
    22. |  3 | tank                             |    1000 |
    23. +----+----------------------------------+---------+
    24. 3 rows in set (0.00 sec)
    25.  
    26. mysql> start transaction;
    27. Query OK, 0 rows affected (0.00 sec)
    28.  
    29. mysql> update user set balance=900 where name='jsaon';
    30. Query OK, 0 rows affected (0.00 sec)
    31. Rows matched: 0  Changed: 0  Warnings: 0
    32.  
    33. mysql> update user set balance=1010 where name='egon';
    34. Query OK, 1 row affected (0.01 sec)
    35. Rows matched: 1  Changed: 1  Warnings: 0
    36.  
    37. mysql> update user set balance=1090 where name='tank';
    38. Query OK, 1 row affected (0.00 sec)
    39. Rows matched: 1  Changed: 1  Warnings: 0
    40.  
    41. mysql> select * from user;
    42. +----+----------------------------------+---------+
    43. | id | name                             | balance |
    44. +----+----------------------------------+---------+
    45. |  1 | jason                            |    1000 |
    46. |  2 | egon                             |    1010 |
    47. |  3 | tank                             |    1090 |
    48. +----+----------------------------------+---------+
    49. 3 rows in set (0.00 sec)
    50.  
    51. mysql> rollback; # 回滚到上一个状态
    52. Query OK, 0 rows affected (0.00 sec)
    53.  
    54. mysql> commit; # 开启事务之后，只要没有执行commit操作，数据其实都没有真正刷新到硬盘
    55. Query OK, 0 rows affected (0.00 sec)

    站在python代码的角度，应该实现的伪代码逻辑

    1.  
    2. try:
    3. 	# 少了开事务...
    4.     update user set balance=900 where name='jason'; #买支付100元
    5.     update user set balance=1010 where name='egon'; #中介拿走10元
    6.     update user set balance=1090 where name='tank'; #卖家拿到90元
    7. except 异常:
    8.     rollback;
    9. else:
    10.     commit;

    存储过程

    存储过程包含了一系列可执行的sql语句，存储过程存放于MySQL中，通过调用它的名字可以执行其内部的一堆sql，类似于python中的自定义函数

    基本使用
    1. mysql> delimiter $$
    2. mysql> create procedure p1()
    3.     -> begin
    4.     ->     select * from user;
    5.     -> end $$
    6. Query OK, 0 rows affected (0.01 sec)
    7.  
    8. mysql> delimiter ;
    9. mysql> call p1()
    10.     -> ;
    11. +----+----------------------------------+---------+
    12. | id | name                             | balance |
    13. +----+----------------------------------+---------+
    14. |  1 | jason                            |    1000 |
    15. |  2 | egon                             |    1000 |
    16. |  3 | tank                             |    1000 |
    17. +----+----------------------------------+---------+
    18. 3 rows in set (0.00 sec)
    19.  
    20. Query OK, 0 rows affected (0.01 sec)
       三种开发者模型

    第一种

    应用程序：只需要开发应用程序的逻辑

    mysql：编写好存储过程，以供应程序调用

    优点：开发效率，执行效率都高

    缺点：考虑到人为因素、跨部门沟通等问题，会导致扩展性差 

    第二种

    应用程序：除了开发应用程序逻辑，还需要编写原生sql
    优点：比方式1，扩展性高（非技术性）

    缺点：

    1.开发效率，执行效率都不如方式1

    2.编写原生sql太过于复杂，而且需要考虑到sql语句的优化问题

    第三种

    应用程序：开发应用程序的逻辑，不需要编写原生sql，基于别人写好的框架来处理，ORM

    优点：不用再编写纯生sql，这意味着开发效率比方式2高，同时兼容方式2扩展性高的好处

    缺点：执行效率连方式2都比不过

     创建存储过程
    1. mysql> set @res=10;
    2. Query OK, 0 rows affected (0.00 sec)
    3.  
    4. mysql> delimiter $$
    5. mysql> create procedure p2(
    6.     ->     in m int, # in表示这个参数必须只能是传入不能被返回出去
    7.     ->     in n int,
    8.     ->     out res int # out表示这个参数可以被返回出去
    9.     -> )
    10.     -> begin
    11.     ->     select tname from teacher where tid > m and tid < n;
    12.     ->     set res=0; # 用来标志存储过程是否执行
    13.     -> end $$
    14. Query OK, 0 rows affected (0.00 sec)
    15.  
    16. mysql> call p2(1,5,@res);
    17. +-----------------+
    18. | tname           |
    19. +-----------------+
    20. | 李平老师        |
    21. | 刘海燕老师      |
    22. | 朱云海老师      |
    23. +-----------------+
    24. 3 rows in set (0.00 sec)
    25.  
    26. Query OK, 0 rows affected (0.01 sec)
    27.  
    28. # 针对res需要先提前定义
    29. set @res=10;  定义
    30. select @res;  查看
    31. call p1(1,5,@res)  调用
    32. select @res  查看
    如何用存储过程

    大前提：存储过程在哪个库下面创建的只能在对应的库下面才能使用！！！

    1.直接在mysql中调用

    set @res=10 # res的值是用来判断存储过程是否被执行成功的依据，所以需要先定义一个变量@res存储10

    call p1(2,4,10); # 报错

    call p1(2,4,@res);

    查看结果

    select @res；# 执行成功。@res变量值发生了变化

    2、在python中调用

    pymysql连接mysql

    产生的游表cursor.callproc('p1',(2,4,10)) # 内部原理：@_p1_0=2,@_p1_1=4,@_p1_2=10;

    cursor.execute('select @_p1_2;')

    3、存储过程与事务使用举例(了解)

    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;
          update user set balance=900 where id =1;
          update user123 set balance=1010 where id = 2;
          update user set balance=1090 where id =3;
      COMMIT;

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


    END //
    delimiter ;

    函数

    注意与存储过程的区别，mysql内置的函数只能在sql语句中使用！

    1.  
    2. CREATE TABLE blog (
    3.     id INT PRIMARY KEY auto_increment,
    4.     NAME CHAR (32),
    5.     sub_time datetime
    6. );
    7.  
    8. INSERT INTO blog (NAME, sub_time)
    9. VALUES
    10.     ('第1篇','2015-03-01 11:31:21'),
    11.     ('第2篇','2015-03-11 16:31:21'),
    12.     ('第3篇','2016-07-01 10:21:31'),
    13.     ('第4篇','2016-07-22 09:23:21'),
    14.     ('第5篇','2016-07-23 10:11:11'),
    15.     ('第6篇','2016-07-25 11:21:31'),
    16.     ('第7篇','2017-03-01 15:33:21'),
    17.     ('第8篇','2017-03-01 17:32:21'),
    18.     ('第9篇','2017-03-01 18:31:21');
    19.  
    20.  
    21. +----+--------------------------------------+---------------------+
    22. | id | NAME                                 | sub_time            |  month
    23. +----+--------------------------------------+---------------------+
    24. |  1 | 第1篇                                | 2015-03-01 11:31:21 |  2015-03
    25. |  2 | 第2篇                                | 2015-03-11 16:31:21 |  2015-03
    26. |  3 | 第3篇                                | 2016-07-01 10:21:31 |  2016-07
    27. |  4 | 第4篇                                | 2016-07-22 09:23:21 |  2016-07
    28. |  5 | 第5篇                                | 2016-07-23 10:11:11 |  2016-07 
    29. |  6 | 第6篇                                | 2016-07-25 11:21:31 |  2016-07
    30. |  7 | 第7篇                                | 2017-03-01 15:33:21 |  2017-03
    31. |  8 | 第8篇                                | 2017-03-01 17:32:21 |  2017-03
    32. |  9 | 第9篇                                | 2017-03-01 18:31:21 |  2017-03
    33. +----+--------------------------------------+---------------------+
    34.  
    35. select count(*) from blog group by month;
    36.  
    37. select date_format(sub_time,'%Y-%m'),count(id) from blog group by date_format(sub_time,'%Y-%m');
    38. https://blog.csdn.net/GG_Bruse/article/details/131484538

    流程控制

    1. # if条件语句
    2. delimiter //
    3. CREATE PROCEDURE proc_if ()
    4. BEGIN
    5.     
    6.     declare i int default 0;
    7.     if i = 1 THEN
    8.         SELECT 1;
    9.     ELSEIF i = 2 THEN
    10.         SELECT 2;
    11.     ELSE
    12.         SELECT 7;
    13.     END IF;
    14.  
    15. END //
    16. delimiter ;
    17.  
    18. # while循环
    19. delimiter //
    20. CREATE PROCEDURE proc_while ()
    21. BEGIN
    22.  
    23.     DECLARE num INT ;
    24.     SET num = 0 ;
    25.     WHILE num < 10 DO
    26.         SELECT
    27.             num ;
    28.         SET num = num + 1 ;
    29.     END WHILE ;
    30.  
    31. END //
    32. delimiter ;

    索引

    数据都是存在硬盘上的，那查询数据不可避免的需要IO操作

    索引就是一种数据结构，类似于书的目录。意味着以后再查数据应该先找目录再找数据，而不是用翻页的方式查询数据

    索引在MySQL中也叫做’键‘，是存储引擎用于快速找到记录的一种数据结构
    primary key、unique key、index key
    注意：上面三种key前两种除了有加速查询的效果之外还有额外的约束条件(primary key:非空且唯一，unique key:唯一)，而index key没有任何约束功能只会帮你加速查询

    本质都是：通过不断地缩小想要获取数据的范围来筛选出最终想要的结果，同时把随机的事件变成顺序的事件，也就是说，有了这种索引机制，我们可以总是用同一种查找方式来锁定数据。

    索引的影响

    在表中有大量数据的前提下，创建索引速度会很慢(建表的时候，如果明显需要索引，就提前加上
    以后实际添加索引的时候，尽量在空表的时候添加，在创建表的时候就添加索引，此时添加索引是最快的
    如果表中数据已经有了，还需要添加索引，也可以，只不过创建索引的速度会很慢，不建议这样做

    在索引创建完毕后，对表的查询性能会大幅度提升，但是写的性能会降低

    但是，写的性能影响不是很大，因为在实际中，写的频率很少，大部分操作都是查询
    如何添加索引？到底给哪些字段加索引呢?
    '''没有固定答案，具体给哪个字段加索引，要看你实际的查询条件'''
    select * from user where name='' and password='';
    索引的使用其实是需要大量的工作经验，才能正确的判断出
    '''不要一创建表就加索引，在一张表中，最多最多不要超过15个索引，索引越多，性能就会下降'''
    如何数据量比较小，不需要加索引，100w一下一般不用加，mysql针对于1000w一下的数据，性能不会下降太多.

    b+树

    只有叶子结点存放真实数据，根和树枝节点存的仅仅是虚拟数据

    查询次数由树的层级决定，层级越低次数越少

    一个磁盘块儿的大小是一定的，那也就意味着能存的数据量是一定的。如何保证树的层级最低呢？一个磁盘块儿存放占用空间比较小的数据项

    以后加索引的时候，尽量给字段中存的是数字的列加,我们使用主键查询速度很快
    select * from user where name = ''
    select * from user where id = ''  # 主键查询的更快一些

    思考我们应该给我们一张表里面的什么字段字段建立索引能够降低树的层级高度>>> 主键id字段

  • 相关阅读:
    【推送服务】【FAQ】Push Ki常见咨询合集1--权益类问题
    TypeScript基础学习
    引擎入门 | Unity UI简介–第2部分（5）
    Java书签 #获取项目应用中所有Mapper接口并打印URL
    Tomcat（二）
    LCD简介
    camunda如何调用HTTP REST（Service Task）服务节点
    Unity Shader入门精要学习——透明效果
    记一次edu实战
    在预处理中用于预训练网络模型的均值和标准差的几种形式
  • 原文地址：https://blog.csdn.net/qq_67257222/article/details/134055789