当前位置： 首页 > article >正文

MySQL数据库#6

article 2024/11/15 13:48:52

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没有任何约束功能只会帮你加速查询


http://www.kler.cn/a/107319.html

相关文章：

  • 【力扣热题100】[Java版] 刷题笔记-169. 多数元素
  • C++STL容器——map和set
  • 如何在python中模拟重载初始化函数？
  • 淘宝代购系统；海外代购系统；代购程序，代购系统源码PHP前端源码
  • 简单叙述 Spring Boot 启动过程
  • 【安全通信】告别信息泄露：搭建你的开源视频聊天系统briefing
  • Redis 主从复制和哨兵监控，实现Redis高可用配置
  • 革新技术，释放创意 ：Luminar NeoforMac/win超强AI图像编辑器
  • 浅谈UI自动化测试
  • KDChart3.0编译过程-使用QT5.15及QT6.x编译
  • 深度学习——图像分类（CIFAR-10）
  • Centos系统使用yum安装Java jdk
  • OpenCV学习（一）——图像读取
  • Mysql 数据库
  • 数据分析和互联网医院小程序：提高医疗决策的准确性和效率
  • 网络协议--TCP：传输控制协议
  • 「网络编程」数据链路层协议_ 以太网协议学习
  • LeetCode 1465. 切割后面积最大的蛋糕
  • Elasticsearch7.8.1集群安装手册
  • vscode 保存 “index.tsx“失败: 权限不足。选择 “以超级用户身份重试“ 以超级用户身份重试。
  • Java NIO 高并发开发
  • 列表自动向上滚动
  • 【Android内存优化】内存泄露优化之强引用变弱引用完全详解
  • ElasticSearch快速入门实战
  • ConcurrentHashMap 的 size()方法是线程安全的吗？为什么
  • 程序生活 - 减肥小记