Linux环境下MySQL数据库的使用

柔光的暖阳◎ 2023-02-28 01:21 3阅读 0赞

转载来源：[Python-100-Days/Day36-40/36-38.关系型数据库MySQL.md][Python-100-Days_Day36-40_36-38._MySQL.md]

### Linux环境下MySQL数据库的使用： ###

#### MySQL命令行基本操作： ####

*  启动MySQL服务  
    可以使用下面的命令来启动MySQL。
    
        service mysqld start
    
    在CentOS 7中，更推荐使用下面的命令来启动MySQL。
    
        systemctl start mysqld
    
    启动MySQL成功后，可以通过下面的命令来检查网络端口使用情况，MySQL默认使用3306端口。
    
        netstat -ntlp | grep mysql
    
    也可以使用下面的命令查找是否有名为mysqld的进程。
    
        pgrep mysqld
 *  登录MySQL数据库：  
    命令行工具：
    
        mysql -u root -p
    
    > 说明：启动客户端时，`-u`参数用来指定用户名，MySQL默认的超级管理账号为 `root`；`-p`表示要输入密码（用户口令）；如果连接的是其他主机而非本机，可以用`-h`来指定连接主机的主机名或IP地址。
    
    如果是首次安装MySQL，可以使用下面的命令来找到默认的初始密码。
    
        cat /var/log/mysqld.log | grep password
    
    `上面的命令会查看MySQL的日志带有password的行，在显示的结果中 root@localhost:后面的部分就是默认设置的初始密码。`
    
    修改超级管理员（root）的登录密码为123456。
    
        set global validate_password_policy=0;
        set global validate_password_length=6;
        alter user 'root'@'localhost' identified by '123456';
    
    根据你自己的意愿来设置MySQL的root账号的登录密码。
 *  常用命令。

1.  查看MySQL数据库的版本
    
        select version();
2.  查看所有数据库。
    
        show databases;
3.  切换到指定数据库。
    
        use mysql;
4.  查看数据库下所有表。
    
        show tables;
5.  获取帮助。
    
        ? contents;
        ? functions;
        ? numeric functions;
        ? round;
        
        ? data types;
        ? longblob;

#### SQL操作： ####

**基本操作：**  
我们通常可以将SQL分为三类：DDL（数据定义语言）、DML（数据操作语言）和DCL（数据控制语言）。DDL主要用于创建（create）、删除（drop）、修改（alter）数据库中的对象，比如创建、删除和修改二维表；DML主要负责插入数据（insert）、删除数据（delete）、更新数据（update）和查询（select）；DCL通常用于授予权限（grant）和召回权限（revoke）。

> 说明：SQL是不区分大小写的语言，为了书写方便，下面的SQL都使用了小写字母来书写。

1.  DDL（数据定义语言）
    
        -- 如果存在名为school的数据库就删除它
        drop database if exists school;
        
        -- 创建名为school的数据库并设置默认的字符集和排序方式
        create database school default charset utf8;
        
        -- 切换到school数据库上下文环境
        use school;
        
        -- 创建学院表
        create table tb_college
        (
        collid 		int auto_increment comment '编号',
        collname 	varchar(50) not null comment '名称',
        collintro 	varchar(500) default '' comment '介绍',
        primary key (collid)
        );
        
        -- 创建学生表
        create table tb_student
        (
        stuid 		int not null comment '学号',
        stuname 	varchar(20) not null comment '姓名',
        stusex 		boolean default 1 comment '性别',
        stubirth 	date not null comment '出生日期',
        stuaddr 	varchar(255) default '' comment '籍贯',
        collid 		int not null comment '所属学院',
        primary key (stuid),
        foreign key (collid) references tb_college (collid)
        );
        
        -- 创建教师表
        create table tb_teacher
        (
        teaid 		int not null comment '工号',
        teaname 	varchar(20) not null comment '姓名',
        teatitle 	varchar(10) default '助教' comment '职称',
        collid 		int not null comment '所属学院',
        primary key (teaid),
        foreign key (collid) references tb_college (collid)
        );
        
        -- 创建课程表
        create table tb_course
        (
        couid 		int not null comment '编号',
        couname 	varchar(50) not null comment '名称',
        coucredit 	int not null comment '学分',
        teaid 		int not null comment '授课老师',
        primary key (couid),
        foreign key (teaid) references tb_teacher (teaid)
        );
        
        -- 创建选课记录表
        create table tb_record
        (
        recid 		int auto_increment comment '选课记录编号',
        sid 		int not null comment '选课学生',
        cid 		int not null comment '所选课程',
        seldate 	datetime default now() comment '选课时间日期',
        score 		decimal(4,1) comment '考试成绩',
        primary key (recid),
        foreign key (sid) references tb_student (stuid),
        foreign key (cid) references tb_course (couid),
        unique (sid, cid)
        );
    
    创建数据库时，我们通过default charset utf8指定了数据库默认使用的字符集，我们推荐使用该字符集，因为utf8能够支持国际化编码。如果将来数据库中用到的字符可能包括类似于Emoji这样的图片字符，也可以将默认字符集设定为utf8mb4（最大4字节的utf-8编码）。查看MySQL支持的字符集可以执行下面的语句。
    
        show character set;
2.  DML（数据操作语言）
    
        -- 查询所有学生信息
        select * from tb_student;
        
        -- 查询所有课程名称及学分(投影和别名)
        select couname, coucredit from tb_course;
        select couname as 课程名称, coucredit as 学分 from tb_course;
        
        -- 查询所有学生的姓名和性别(条件运算)
        select stuname as 姓名, case stusex when 1 then '男' else '女' end as 性别 from tb_student;
        select stuname as 姓名, if(stusex, '男', '女') as 性别 from tb_student;
        
        -- 查询所有女学生的姓名和出生日期(筛选)
        select stuname, stubirth from tb_student where stusex=0;
        
        -- 查询所有80后学生的姓名、性别和出生日期(筛选)
        select stuname, stusex, stubirth from tb_student where stubirth>='1980-1-1' and stubirth<='1989-12-31';
        select stuname, stusex, stubirth from tb_student where stubirth between '1980-1-1' and '1989-12-31';
        
        -- 查询姓"杨"的学生姓名和性别(模糊)
        select stuname, stusex from tb_student where stuname like '杨%';
        
        -- 查询姓"杨"名字两个字的学生姓名和性别(模糊)
        select stuname, stusex from tb_student where stuname like '杨_';
        
        -- 查询姓"杨"名字三个字的学生姓名和性别(模糊)
        select stuname, stusex from tb_student where stuname like '杨__';
        
        -- 查询名字中有"不"字或"嫣"字的学生的姓名(模糊)
        select stuname, stusex from tb_student where stuname like '%不%' or stuname like '%嫣%';
        
        -- 查询没有录入家庭住址的学生姓名(空值)
        select stuname from tb_student where stuaddr is null;
        
        -- 查询录入了家庭住址的学生姓名(空值)
        select stuname from tb_student where stuaddr is not null;
        
        -- 查询学生选课的所有日期(去重)
        select distinct seldate from tb_record;
        
        -- 查询学生的家庭住址(去重)
        select distinct stuaddr from tb_student where stuaddr is not null;
        
        -- 查询男学生的姓名和生日按年龄从大到小排列(排序)
        select stuname as 姓名, datediff(curdate(), stubirth) div 365 as 年龄 from tb_student where stusex=1 order by 年龄 desc;
        
        -- 查询年龄最大的学生的出生日期(聚合函数)
        select min(stubirth) from tb_student;
        
        -- 查询年龄最小的学生的出生日期(聚合函数)
        select max(stubirth) from tb_student;
        
        -- 查询男女学生的人数(分组和聚合函数)
        select stusex, count(*) from tb_student group by stusex;
        
        -- 查询课程编号为1111的课程的平均成绩(筛选和聚合函数)
        select avg(score) from tb_record where cid=1111;
        
        -- 查询学号为1001的学生所有课程的平均分(筛选和聚合函数)
        select avg(score) from tb_record where sid=1001;
        
        -- 查询每个学生的学号和平均成绩(分组和聚合函数)
        select sid as 学号, avg(score) as 平均分 from tb_record group by sid;
        
        -- 查询平均成绩大于等于90分的学生的学号和平均成绩
        -- 分组以前的筛选使用where子句 / 分组以后的筛选使用having子句
        select sid as 学号, avg(score) as 平均分 from tb_record group by sid having 平均分>=90;
        
        -- 查询年龄最大的学生的姓名(子查询/嵌套的查询)
        select stuname from tb_student where stubirth=( select min(stubirth) from tb_student );
        
        -- 查询年龄最大的学生姓名和年龄(子查询+运算)
        select stuname as 姓名, datediff(curdate(), stubirth) div 365 as 年龄 from tb_student where stubirth=( select min(stubirth) from tb_student );
        
        -- 查询选了两门以上的课程的学生姓名(子查询/分组条件/集合运算)
        select stuname from tb_student where stuid in ( select stuid from tb_record group by stuid having count(stuid)>2 );
        
        -- 查询学生姓名、课程名称以及成绩(连接查询)
        select stuname, couname, score from tb_student t1, tb_course t2, tb_record t3 where stuid=sid and couid=cid and score is not null;
        
        -- 查询学生姓名、课程名称以及成绩按成绩从高到低查询第11-15条记录(内连接+分页)
        select stuname, couname, score from tb_student inner join tb_record on stuid=sid inner join tb_course on couid=cid where score is not null order by score desc limit 5 offset 10;
        
        select stuname, couname, score from tb_student inner join tb_record on stuid=sid inner join tb_course on couid=cid where score is not null order by score desc limit 10, 5;
        
        -- 查询选课学生的姓名和平均成绩(子查询和连接查询)
        select stuname, avgmark from tb_student, ( select sid, avg(score) as avgmark from tb_record group by sid ) temp where stuid=sid;
        
        select stuname, avgmark from tb_student inner join ( select sid, avg(score) as avgmark from tb_record group by sid ) temp on stuid=sid;
        
        -- 查询每个学生的姓名和选课数量(左外连接和子查询)
        select stuname, ifnull(total, 0) from tb_student left outer join ( select sid, count(sid) as total from tb_record group by sid ) temp on stuid=sid;
3.  DCL
    
        -- 创建可以远程登录的root账号并为其指定口令
        create user 'root'@'%' identified by '123456';
        
        -- 为远程登录的root账号授权操作所有数据库所有对象的所有权限并允许其将权限再次赋予其他用户
        grant all privileges on *.* to 'root'@'%' with grant option;
        
        -- 创建名为hellokitty的用户并为其指定口令
        create user 'hellokitty'@'%' identified by '123123';
        
        -- 将对school数据库所有对象的所有操作权限授予hellokitty
        grant all privileges on school.* to 'hellokitty'@'%';
        
        -- 召回hellokitty对school数据库所有对象的insert/delete/update权限
        revoke insert, delete, update on school.* from 'hellokitty'@'%';
    
    > 说明：创建一个可以允许任意主机登录并且具有超级管理员权限的用户在现实中并不是一个明智的决定，因为一旦该账号的口令泄露或者被破解，数据库将会面临灾难级的风险。

#### 索引 ####

使用方法：[Python-100-Days/Day36-40/36-38.关系型数据库MySQL][Python-100-Days_Day36-40_36-38._MySQL]

**索引的设计原则：**

1.  **最适合**索引的列是出现在**WHERE子句**和连接子句中的列。
2.  索引列的基数越大（取值多重复值少），索引的效果就越好。
3.  使用**前缀索引**可以减少索引占用的空间，内存中可以缓存更多的索引。
4.  **索引不是越多越好**，虽然索引加速了读操作（查询），但是写操作（增、删、改）都会变得更慢，因为数据的变化会导致索引的更新，就如同书籍章节的增删需要更新目录一样。
5.  使用InnoDB存储引擎时，表的普通索引都会保存主键的值，所以**主键要尽可能选择较短的数据类型**，这样可以有效的减少索引占用的空间，利用提升索引的缓存效果。

#### 视图 ####

视图是关系型数据库中将一组查询指令构成的结果集组合成可查询的数据表的对象。简单的说，视图就是虚拟的表，但与数据表不同的是，数据表是一种实体结构，而视图是一种虚拟结构，你也可以将视图理解为保存在数据库中被赋予名字的SQL语句。

使用视图可以获得以下好处：

1.  可以将实体数据表隐藏起来，让外部程序无法得知实际的数据结构，让访问者可以使用表的组成部分而不是整个表，降低数据库被攻击的风险。
2.  在大多数的情况下视图是只读的（更新视图的操作通常都有诸多的限制），外部程序无法直接透过视图修改数据。
3.  重用SQL语句，将高度复杂的查询包装在视图表中，直接访问该视图即可取出需要的数据；也可以将视图视为数据表进行连接查询。
4.  视图可以返回与实体数据表不同格式的数据，

创建视图。

create view vw_avg_score 
    as 
        select sid, round(avg(score), 1) as avgscore 
        from tb_record group by sid;
    
    create view vw_student_score 
    as 
        select stuname, avgscore 
        from tb_student, vw_avg_score 
        where stuid=sid;

> **提示**：因为视图不包含数据，所以每次使用视图时，都必须执行查询以获得数据，如果你使用了连接查询、嵌套查询创建了较为复杂的视图，你可能会发现查询性能下降得很厉害。因此，在使用复杂的视图前，应该进行测试以确保其性能能够满足应用的需求。

使用视图。

select stuname, avgscore from vw_student_score order by avgscore desc;

+--------------+----------+
    | stuname      | avgscore |
    +--------------+----------+
    | 杨过         |     95.6 |
    | 任我行       |     53.5 |
    | 王语嫣       |     84.3 |
    | 纪嫣然       |     73.8 |
    | 岳不群       |     78.0 |
    | 东方不败     |     88.0 |
    | 项少龙       |     92.0 |
    +--------------+----------+

既然视图是一张虚拟的表，那么视图的中的数据可以更新吗？视图的可更新性要视具体情况而定，以下类型的视图是不能更新的：

1.  使用了聚合函数（SUM、MIN、MAX、AVG、COUNT等）、DISTINCT、GROUP BY、HAVING、UNION或者UNION ALL的视图。
2.  SELECT中包含了子查询的视图。
3.  FROM子句中包含了一个不能更新的视图的视图。
4.  WHERE子句的子查询引用了FROM子句中的表的视图。

删除视图。

drop view vw_student_score;

> **说明**：如果希望更新视图，可以先用上面的命令删除视图，也可以通过`create or replace view`来更新视图。

视图的规则和限制。

1.  视图可以嵌套，可以利用从其他视图中检索的数据来构造一个新的视图。视图也可以和表一起使用。
2.  创建视图时可以使用`order by`子句，但如果从视图中检索数据时也使用了`order by`，那么该视图中原先的`order by`会被覆盖。
3.  视图无法使用索引，也不会激发触发器（实际开发中因为性能等各方面的考虑，通常不建议使用触发器，所以我们也不对这个概念进行介绍）的执行。

#### 存储过程 ####

存储过程是事先编译好存储在数据库中的一组SQL的集合，调用存储过程可以简化应用程序开发人员的工作，减少与数据库服务器之间的通信，对于提升数据操作的性能也是有帮助的。其实迄今为止，我们使用的SQL语句都是针对一个或多个表的单条语句，但在实际开发中经常会遇到某个操作需要多条SQL语句才能完成的情况。例如，电商网站在受理用户订单时，需要做以下一系列的处理。

1.  通过查询来核对库存中是否有对应的物品以及库存是否充足。
2.  如果库存有物品，需要锁定库存以确保这些物品不再卖给别人， 并且要减少可用的物品数量以反映正确的库存量。
3.  如果库存不足，可能需要进一步与供应商进行交互或者至少产生一条系统提示消息。
4.  不管受理订单是否成功，都需要产生流水记录，而且需要给对应的用户产生一条通知信息。

我们可以通过存储过程将复杂的操作封装起来，这样不仅有助于保证数据的一致性，而且将来如果业务发生了变动，只需要调整和修改存储过程即可。对于调用存储过程的用户来说，存储过程并没有暴露数据表的细节，而且执行存储过程比一条条的执行一组SQL要快得多。

在存储过程中，我们可以定义变量、条件，可以使用分支和循环语句，可以通过游标操作查询结果，还可以使用事件调度器，这些内容我们暂时不在此处进行介绍。`虽然我们说了很多存储过程的好处，但是在实际开发中，如果过度的使用存储过程，将大量复杂的运算放到存储过程中，也会导致占用数据库服务器的CPU资源，造成数据库服务器承受巨大的压力。为此，我们一般会将复杂的运算和处理交给应用服务器，因为很容易部署多台应用服务器来分摊这些压力。`

#### Python数据库编程 ####

我们用如下所示的数据库来演示在Python中如何访问MySQL数据库。

drop database if exists hrs;
    create database hrs default charset utf8;
    
    use hrs;
    
    drop table if exists tb_emp;
    drop table if exists tb_dept;
    
    create table tb_dept
    (
    dno   int not null comment '编号',
    dname varchar(10) not null comment '名称',
    dloc  varchar(20) not null comment '所在地',
    primary key (dno)
    );
    
    insert into tb_dept values 
    	(10, '会计部', '北京'),
    	(20, '研发部', '成都'),
    	(30, '销售部', '重庆'),
    	(40, '运维部', '深圳');
    
    create table tb_emp
    (
    eno   int not null comment '员工编号',
    ename varchar(20) not null comment '员工姓名',
    job   varchar(20) not null comment '员工职位',
    mgr   int comment '主管编号',
    sal   int not null comment '员工月薪',
    comm  int comment '每月补贴',
    dno   int comment '所在部门编号',
    primary key (eno)
    );
    
    alter table tb_emp add constraint fk_emp_dno foreign key (dno) references tb_dept (dno);
    
    insert into tb_emp values 
    	(7800, '张三丰', '总裁', null, 9000, 1200, 20),
    	(2056, '乔峰', '分析师', 7800, 5000, 1500, 20),
    	(3088, '李莫愁', '设计师', 2056, 3500, 800, 20),
    	(3211, '张无忌', '程序员', 2056, 3200, null, 20),
    	(3233, '丘处机', '程序员', 2056, 3400, null, 20),
    	(3251, '张翠山', '程序员', 2056, 4000, null, 20),
    	(5566, '宋远桥', '会计师', 7800, 4000, 1000, 10),
    	(5234, '郭靖', '出纳', 5566, 2000, null, 10),
    	(3344, '黄蓉', '销售主管', 7800, 3000, 800, 30),
    	(1359, '胡一刀', '销售员', 3344, 1800, 200, 30),
    	(4466, '苗人凤', '销售员', 3344, 2500, null, 30),
    	(3244, '欧阳锋', '程序员', 3088, 3200, null, 20),
    	(3577, '杨过', '会计', 5566, 2200, null, 10),
    	(3588, '朱九真', '会计', 5566, 2500, null, 10);

在Python 3中，我们通常使用纯Python的三方库PyMySQL来访问MySQL数据库，它应该是目前Python操作MySQL数据库最好的选择。  
**安装PyMySQL。**

pip install pymysql

**增：添加一个部门。**

import pymysql
    
    
    def main():
        no = int(input('编号: '))
        name = input('名字: ')
        loc = input('所在地: ')
        # 1. 创建数据库连接对象
        con = pymysql.connect(host='localhost', port=3306,
                              database='hrs', charset='utf8',
                              user='yourname', password='yourpass')
        try:
            # 2. 通过连接对象获取游标
            with con.cursor() as cursor:
                # 3. 通过游标执行SQL并获得执行结果
                result = cursor.execute(
                    'insert into tb_dept values (%s, %s, %s)',
                    (no, name, loc)
                )
            if result == 1:
                print('添加成功!')
            # 4. 操作成功提交事务
            con.commit()
        finally:
            # 5. 关闭连接释放资源
            con.close()
    
    
    if __name__ == '__main__':
        main()

**删：删除一个部门。**

import pymysql
    
    
    def main():
        no = int(input('编号: '))
        con = pymysql.connect(host='localhost', port=3306,
                              database='hrs', charset='utf8',
                              user='yourname', password='yourpass',
                              autocommit=True)
        try:
            with con.cursor() as cursor:
                result = cursor.execute(
                    'delete from tb_dept where dno=%s',
                    (no, )
                )
            if result == 1:
                print('删除成功!')
        finally:
            con.close()
    
    
    if __name__ == '__main__':
        main()

> 说明：如果不希望每次SQL操作之后手动提交或回滚事务，可以像上面的代码那样，在创建连接的时候多加一个名为`autocommit`的参数并将它的值设置为`True`，表示每次执行SQL之后自动提交。如果程序中不需要使用事务环境也不希望手动的提交或回滚就可以这么做。

**改：更新一个部门。**

import pymysql
    
    
    def main():
        no = int(input('编号: '))
        name = input('名字: ')
        loc = input('所在地: ')
        con = pymysql.connect(host='localhost', port=3306,
                              database='hrs', charset='utf8',
                              user='yourname', password='yourpass',
                              autocommit=True)
        try:
            with con.cursor() as cursor:
                result = cursor.execute(
                    'update tb_dept set dname=%s, dloc=%s where dno=%s',
                    (name, loc, no)
                )
            if result == 1:
                print('更新成功!')
        finally:
            con.close()
    
    
    if __name__ == '__main__':
        main()

**查：查询所有部门。**

import pymysql
    from pymysql.cursors import DictCursor
    
    
    def main():
        con = pymysql.connect(host='localhost', port=3306,
                              database='hrs', charset='utf8',
                              user='yourname', password='yourpass')
        try:
            with con.cursor(cursor=DictCursor) as cursor:
                cursor.execute('select dno as no, dname as name, dloc as loc from tb_dept')
                results = cursor.fetchall()
                print(results)
                print('编号\t名称\t\t所在地')
                for dept in results:
                    print(dept['no'], end='\t')
                    print(dept['name'], end='\t')
                    print(dept['loc'])
        finally:
            con.close()
    
    
    if __name__ == '__main__':
        main()

**查：分页查询员工信息。**

import pymysql
    from pymysql.cursors import DictCursor
    
    
    class Emp(object):
    
        def __init__(self, no, name, job, sal):
            self.no = no
            self.name = name
            self.job = job
            self.sal = sal
    
        def __str__(self):
            return f'\n编号：{self.no}\n姓名：{self.name}\n职位：{self.job}\n月薪：{self.sal}\n'
    
    
    def main():
        page = int(input('页码: '))
        size = int(input('大小: '))
        con = pymysql.connect(host='localhost', port=3306,
                              database='hrs', charset='utf8',
                              user='yourname', password='yourpass')
        try:
            with con.cursor() as cursor:
                cursor.execute(
                    'select eno as no, ename as name, job, sal from tb_emp limit %s,%s',
                    ((page - 1) * size, size)
                )
                for emp_tuple in cursor.fetchall():
                    emp = Emp(*emp_tuple)
                    print(emp)
        finally:
            con.close()
    
    
    if __name__ == '__main__':
        main()

**limit分页公式：**

*  limit分页公式：  
    curPage是当前第几页；  
    pageSize是一页多少条记录；  
    limit (curPage-1) \* pageSize, pageSize
 *  使用的地方：sql语句中  
    select \* from student limit (curPage-1) \* pageSize, pageSize;  
    `代表从第(curPage-1)*pageSize条记录（但不包括该条记录）开始查询pageSize条记录。`

[Python-100-Days_Day36-40_36-38._MySQL.md]: https://github.com/jackfrued/Python-100-Days/blob/master/Day36-40%2F36-38.%E5%85%B3%E7%B3%BB%E5%9E%8B%E6%95%B0%E6%8D%AE%E5%BA%93MySQL.md
[Python-100-Days_Day36-40_36-38._MySQL]: https://github.com/jackfrued/Python-100-Days/blob/master/Day36-40%2F36-38.%E5%85%B3%E7%B3%BB%E5%9E%8B%E6%95%B0%E6%8D%AE%E5%BA%93MySQL.md#%E7%B4%A2%E5%BC%95