MySQL数据库#6

Python操作mysql

在使用Python连接mysql之前我们需要先下载一个第三方的模块 pymysql的模块，导入后再进行操作。

操作步骤：1. 先连接mysql host，port，charset，username password 库，等等。

import pymysql

coon = pymysql.connect(
    host='127.0.0.1',
    port=3306,
    user='root',
    passwd='12345',
    db='db10',
    charset='utf8'，
    autocommit=True
)
"""coon = pymysql.connect(
    host='127.0.0.1', 本地ip
    port=3306,   端口
    user='root', 用户名
    passwd='12345', 密码
    db='db10'
    charset='utf8', 字符编码
    
)"""

2.在Python中书写mysql语句

"""获取游标"""
cur = coon.cursor()

sql = 'select * from student'

#写SQL语句

affect_rows = cur.execute(sql)#代表影响的行数

3.执行SQL语句，拿到结果

fetchmany(3)就是前条数据

fetchall（）所以信息

res = cur.fetchone() #使用fetchone（）代表一个数
print(res) # (1, '男', 1, '理解')

"""mysql> select * from student;
+-----+--------+----------+-------+
| sid | gender | class_id | sname |
+-----+--------+----------+-------+
|   1 | 男     |        1 | 理解  |
|   2 | 女     |        1 | 钢蛋  |
|   3 | 男     |        1 | 张三  |
|   4 | 男     |        1 | 张一  |
|   5 | 女     |        1 | 张二  |

4. 在Python中对数据的进一步处理

在游标这边加上cursor=pymysql.cursors.DictCursor让最终结果输出变为字典类型

cur = coon.cursor(cursor=pymysql.cursors.DictCursor)

sql = 'select * from student'

#写SQL语句

affect_rows = cur.execute(sql)
print(affect_rows)
#
#拿到结果

res = cur.fetchone()
print(res)  # 加上之后变为字典类型 {'sid': 1, 'gender': '男', 'class_id': 1, 'sname': '理解'}

当我们在Python中修改数据后，那么在原来的数据库也会跟着修改
"""获取游标"""
cur = coon.cursor(cursor=pymysql.cursors.DictCursor)

sql = 'insert into teacher(tid, tname) values (6,"ll")'#输出结果为1
#当我们修改之后还要进行二次确认：
coon.commit()

#写SQL语句

affect_rows = cur.execute(sql)
print(affect_rows)
#
添加二次确认 coon.commit()，之后就同步修改成功了

除了查询之外，都需要二次确认。

后续可以直接添加，只需要在开始的地方输入
autocommit=True

基于数据库写一个用户注册和登录功能(注册的数据保存在用户表中，然后根据这个用户名做登录)

1. 使用Navicat 来创建一个用户表：

2. 在python中使用sql语句来登录：

coon = pymysql.connect(
    host='127.0.0.1',
    port=3306,
    user='root',
    passwd='12345',
    db='db10',
    charset='utf8',
    autocommit=True
)

    # 游标
sor = coon.cursor(pymysql.cursors.DictCursor)

# 写sql语句
ip_name = input('username')
ip_pwd = input('password')
sql1 = ''
sql = "select * from  userinfo where username='%s' and password='%s'" % (ip_name, ip_pwd)

add = sor.execute(sql)

res = sor.fetchone()
if res:
    print('登录成功')
else:
    print('登录失败')

视图

什么是视图

MySQL中的视图是一个虚拟表，它根据 SELECT 语句的结果集生成。与物理表一样，视图包含一些列和行，但是这些列和行并不是真实存在的，而是基于 SELECT 语句所定义的查询结果。

为什么要使用视图

使用视图有以下优点：

可以简化复杂的查询，将多个表的数据组合在一起，提供新的查询界面，方便用户操作。
可以隐藏敏感数据，只向用户显示有限的数据。
可以在不修改底层表的结构的情况下，修改和更新数据。

如何使用视图

关键字：select view

select view 表名 as select * from teacher inner join course on teacher.tid = course.teacher_id;

这样就创建成功了

如何删除表

drop view （新建表名）

注意：在硬盘中，视图只有表结构，没有表数据文件，视图通常用于查询，尽量不要去修改。

在开发过程中，会不会去使用视图？

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

触发器

什么是触发器

触发器（Trigger）是一种特殊的存储过程，可以在特定的数据库事件发生时（如插入、更新或删除数据）自动执行。触发器是通过设置一些触发条件来触发的，一旦触发条件满足，就会自动执行触发器所定义的操作。通常用于实现数据的约束性和完整性控制、数据同步、日志记录等功能。触发器可以在数据库中创建、修改和删除。

语法结构：

create trigger 触发器名称 before（之前）/after （之后）insert/update/delete on 表名 for each row
begin

sql语句

end

针对插入

针对插入
create trigger tri_after_insert_t1 after insert on 表名 for each row
begin
sql代码。。。
end

create trigger tri_after_insert_t2 before insert on 表名 for each row
begin
sql代码。。。
end

针对删除

针对删除
create trigger tri_after_delete_t1 after delete on 表名 for each row
begin
sql代码。。。
end

create trigger tri_after_delete_t2 before delete on 表名 for each row
begin
sql代码。。。
end

针对修改

针对修改
create trigger tri_after_update_t1 after update on 表名 for each row
begin
sql代码。。。
end

create trigger tri_after_update_t2 before update on 表名 for each row
begin
sql代码。。。
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 $$ 将mysql默认的结束符由;换成$$

create trigger tri_after_insert_cmd after insert on cmd for each row
begin
if NEW.success = 'no' then # 新记录都会被MySQL封装成NEW对象
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');

查询errlog表记录
select * from errlog;

删除触发器
drop trigger tri_after_insert_cmd;

事物

什么是事物：

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

事物的作用：

保证了数据操作的数据安全性

事物所拥有的四个属性

原子性（atomicity）；一个事物是一个不可分割的工作单位，事物中包含了多个操作，要么都做，要么都不做。

一致性（consistency）：事物必须是数据库中的一个一致性状态变成另一个一致性状态，一致性与原子性相关的

隔离性（isolation）：一个事物的执行不能被其他事物所干扰，即一个事物内部操作级使用的数据，对并发的其他事物是隔开的，并发执行的各个事物之间，不能互相干扰。

持久性（durability）：也被称为永久性（permanence ）一个事物一旦提交，对于数据库的改变就是永久的，接下来的操作或故障不应该对其有所影响。

事物关键字：

start transaction;
commit;
rollback;

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

insert into user(name,balance)
values
('jason',1000),
('egon',1000),
('tank',1000);

修改数据之前先开启事务操作
start transaction;

修改操作
update user set balance=900 where name='jason';         买支付100元
update user set balance=1010 where name='egon';        中介拿走10元
update user set balance=1090 where name='tank';         卖家拿到90元

回滚到上一个状态
rollback;

开启事务之后，只要没有执行commit操作，数据其实都没有真正刷新到硬盘
commit;
开启事务检测操作是否完整，不完整主动回滚到上一个状态，如果完整就应该执行commit操作

站在python代码的角度，应该实现的伪代码逻辑，
try:
   少了开事务...
update user set balance=900 where name='jason';         买支付100元
update user set balance=1010 where name='egon';         中介拿走10元
update user set balance=1090 where name='tank';         卖家拿到90元
except 异常:
rollback;
else:
commit;

存储过程

基本使用：

delimiter $$
create procedure p1()
begin
select * from user;
end $$

delimiter ;

调用
call p1()

创建存储过程

delimiter $$

create procedure p2(
in m int,

in表示这个参数必须只能是传入不能被返回出去

in n int,
out res int

out表示这个参数可以被返回出去
)

begin
select tname from teacher where tid > m and tid < n;
set res=0;

用来标志存储过程是否执行
end $$
delimiter ;

针对res需要先提前定义
set @res=10; 定义
select @res; 查看
call p1(1,5,@res) 调用
select @res 查看

函数

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

+----+--------------------------------------+---------------------+
| id | NAME | sub_time | month
+----+--------------------------------------+---------------------+
| 1 | 第1篇 | 2015-03-01 11:31:21 | 2015-03
| 2 | 第2篇 | 2015-03-11 16:31:21 | 2015-03
| 3 | 第3篇 | 2016-07-01 10:21:31 | 2016-07
| 4 | 第4篇 | 2016-07-22 09:23:21 | 2016-07
| 5 | 第5篇 | 2016-07-23 10:11:11 | 2016-07
| 6 | 第6篇 | 2016-07-25 11:21:31 | 2016-07
| 7 | 第7篇 | 2017-03-01 15:33:21 | 2017-03
| 8 | 第8篇 | 2017-03-01 17:32:21 | 2017-03
| 9 | 第9篇 | 2017-03-01 18:31:21 | 2017-03
+----+--------------------------------------+---------------------+

select count(*) from blog group by month;

select date_format(sub_time,'%Y-%m'),count(id) from blog group by date_format(sub_time,'%Y-%m');

索引

我们知道数据都是存在硬盘上的，查询数据不可避免的使用IO操作

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

索引在MySQL中也叫做“键”，是存储引擎用于快速找到记录的一种数据结构。

primary key

unique key

index key

注意：上面三种key前两种除了有加速查询的效果之外还有额外的约束条件(primary key:非空且唯一，unique key:唯一)，而index key没有任何约束功能只会帮你加速查询