mysql

zoukankan html css js c++ java

mysql
ubuntu mysql 安装：https://www.cnblogs.com/williamjie/p/11126486.html

忘记密码 https://blog.csdn.net/qq_38737992/article/details/

navicat 乱码问题：https://blog.csdn.net/u010071211/article/details/80776046

Can't connect to MySQL server on xxx (10061):https://blog.csdn.net/weixin_36374032/article/details/84341740

navicat 操作:破解进入家目录删除 .navicat文件夹

查看用户信息：SELECT DISTINCT CONCAT('User: ''',user,'''@''',host,''';') AS query FROM mysql.user;

删除用户：drop user " "@" ";

查看数据库位置：show variables like 'datadir';
#进入mysql客户端 $mysql mysql> select user(); #查看当前用户 mysql> exit # 也可以用q quit退出 # 默认用户登陆之后并没有实际操作的权限 # 需要使用管理员root用户登陆 $ mysql -uroot -p # mysql5.6默认是没有密码的 #遇到password直接按回车键 mysql> set password = password('root'); # 给当前数据库设置密码 # 创建账号 mysql> create user 'eva'@'192.168.10.%' IDENTIFIED BY '123';# 指示网段 mysql> create user 'eva'@'192.168.10.5' # 指示某机器可以连接 mysql> create user 'eva'@'%' #指示所有机器都可以连接 mysql> show grants for 'eva'@'192.168.10.5';查看某个用户的权限 # 远程登陆 $ mysql -uroot -p123 -h 192.168.10.3 # 给账号授权 mysql> grant all on *.* to 'eva'@'%'; mysql> flush privileges; # 刷新使授权立即生效 # 创建账号并授权 mysql> grant all on *.* to 'eva'@'%' identified by '123'

账号创建
navicat 新建数据库：字符集：utf-8 排序规则：utf8_general_ci

数据库存储的是图片的名字,信息，价格，和在服务器中的位置
1. 操作文件夹（库）增：create database db1 charset utf8; 查：show databases; 改：alter database db1 charset latin1; 删除: drop database db1; 2. 操作文件（表）先切换到文件夹下：use db1 增：create table t1(id int,name char); 查：show tables; 改：alter table t1 modify name char(3); alter table t1 change name name1 char(2); 删：drop table t1; 3. 操作文件中的内容（记录）增：insert into t1 values(1,'egon1'),(2,'egon2'),(3,'egon3'); 查：select * from t1; 改：update t1 set name='sb' where id=2; 删：delete from t1 where id=1; 清空表： delete from t1; #如果有自增id，新增的数据，仍然是以删除前的最后一样作为起始。 truncate table t1;数据量大，删除速度比上一条快，且直接从零开始， *auto_increment 表示：自增 *primary key 表示：约束（不能重复且不能为空）；加速查找

库操作
查询表的结构：
```
describe staff_info;
show create table stuff_info/G;
show create database sb1;
```
#在创建完表后，修改自增字段的起始值 mysql> create table student( -> id int primary key auto_increment, -> name varchar(20), -> sex enum('male','female') default 'male' -> ); mysql> alter table student auto_increment=3; mysql> show create table student; ....... ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 mysql> insert into student(name) values('egon'); Query OK, 1 row affected (0.01 sec) mysql> select * from student; +----+------+------+ | id | name | sex | +----+------+------+ | 3 | egon | male | +----+------+------+ row in set (0.00 sec) mysql> show create table student; ....... ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 #也可以创建表时指定auto_increment的初始值，注意初始值的设置为表选项，应该放到括号外 create table student( id int primary key auto_increment, name varchar(20), sex enum('male','female') default 'male' )auto_increment=3; #设置步长 sqlserver：自增步长基于表级别 create table t1（ id int。。。）engine=innodb,auto_increment=2 步长=2 default charset=utf8 mysql自增的步长： show session variables like 'auto_inc%'; #基于会话级别 set session auth_increment_increment=2 #修改会话级别的步长 #基于全局级别的 set global auth_increment_increment=2 #修改全局级别的步长（所有会话都生效） #！！！注意了注意了注意了！！！ If the value of auto_increment_offset is greater than that of auto_increment_increment, the value of auto_increment_offset is ignored. 翻译：如果auto_increment_offset的值大于auto_increment_increment的值，则auto_increment_offset的值会被忽略，这相当于第一步步子就迈大了，扯着了蛋比如：设置auto_increment_offset=3，auto_increment_increment=2 mysql> set global auto_increment_increment=5; Query OK, 0 rows affected (0.00 sec) mysql> set global auto_increment_offset=3; Query OK, 0 rows affected (0.00 sec) mysql> show variables like 'auto_incre%'; #需要退出重新登录 +--------------------------+-------+ | Variable_name | Value | +--------------------------+-------+ | auto_increment_increment | 1 | | auto_increment_offset | 1 | +--------------------------+-------+ create table student( id int primary key auto_increment, name varchar(20), sex enum('male','female') default 'male' ); mysql> insert into student(name) values('egon1'),('egon2'),('egon3'); mysql> select * from student; +----+-------+------+ | id | name | sex | +----+-------+------+ | 3 | egon1 | male | | 8 | egon2 | male | | 13 | egon3 | male | +----+-------+------+ 步长:auto_increment_increment,起始偏移量:auto_increment_offset
FOREIKEY

多表：

假设我们要描述所有公司的员工，需要描述的属性有这些：工号姓名部门

公司有3个部门，但是有1个亿的员工，那意味着部门这个字段需要重复存储，部门名字越长，越浪费

解决方法：我们完全可以定义一个部门表然后让员工信息表关联该表，如何关联，即foreign key
mysql> create table departments (dep_id int(4),dep_name varchar(11)); Query OK, 0 rows affected (0.02 sec) mysql> desc departments; +----------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+-------------+------+-----+---------+-------+ | dep_id | int(4) | YES | | NULL | | | dep_name | varchar(11) | YES | | NULL | | +----------+-------------+------+-----+---------+-------+ 2 rows in set (0.00 sec) # 创建外键不成功 mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id)); ERROR 1215 (HY000): Cannot add foreign key # 设置dep_id非空，仍然不能成功创建外键 mysql> alter table departments modify dep_id int(4) not null; Query OK, 0 rows affected (0.02 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql> desc departments; +----------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+-------------+------+-----+---------+-------+ | dep_id | int(4) | NO | | NULL | | | dep_name | varchar(11) | YES | | NULL | | +----------+-------------+------+-----+---------+-------+ 2 rows in set (0.00 sec) mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id)); ERROR 1215 (HY000): Cannot add foreign key constraint # 当设置字段为unique唯一字段时，设置该字段为外键成功 mysql> alter table departments modify dep_id int(4) unique; Query OK, 0 rows affected (0.01 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql> desc departments; +----------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+-------------+------+-----+---------+-------+ | dep_id | int(4) | YES | UNI | NULL | | | dep_name | varchar(11) | YES | | NULL | | +----------+-------------+------+-----+---------+-------+ 2 rows in set (0.01 sec) mysql> create table staff_info (s_id int,name varchar(20),dep_id int,foreign key(dep_id) references departments(dep_id)); Query OK, 0 rows affected (0.02 sec)
#表类型必须是innodb存储引擎，且被关联的字段，即references指定的另外一个表的字段，必须保证唯一 create table department( id int primary key, name varchar(20) not null )engine=innodb; #dpt_id外键，关联父表（department主键id），同步更新，同步删除 create table employee( id int primary key, name varchar(20) not null, dpt_id int, foreign key(dpt_id) references department(id) on delete cascade # 级连删除 on update cascade # 级连更新 )engine=innodb; #先往父表department中插入记录 insert into department values (1,'教质部'), (2,'技术部'), (3,'人力资源部'); #再往子表employee中插入记录 insert into employee values (1,'yuan',1), (2,'nezha',2), (3,'egon',2), (4,'alex',2), (5,'wusir',3), (6,'李沁洋',3), (7,'皮卡丘',3), (8,'程咬金',3), (9,'程咬银',3) ; #删父表department，子表employee中对应的记录跟着删 mysql> delete from department where id=2; Query OK, 1 row affected (0.00 sec) mysql> select * from employee; +----+-----------+--------+ | id | name | dpt_id | +----+-----------+--------+ | 1 | yuan | 1 | | 5 | wusir | 3 | | 6 | 李沁洋 | 3 | | 7 | 皮卡丘 | 3 | | 8 | 程咬金 | 3 | | 9 | 程咬银 | 3 | +----+-----------+--------+ 6 rows in set (0.00 sec) #更新父表department，子表employee中对应的记录跟着改 mysql> update department set id=2 where id=3; Query OK, 1 row affected (0.01 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> select * from employee; +----+-----------+--------+ | id | name | dpt_id | +----+-----------+--------+ | 1 | yuan | 1 | | 5 | wusir | 2 | | 6 | 李沁洋 | 2 | | 7 | 皮卡丘 | 2 | | 8 | 程咬金 | 2 | | 9 | 程咬银 | 2 | +----+-----------+--------+ 6 rows in set (0.00 sec) 复制代码
. cascade方式在父表上update/delete记录时，同步update/delete掉子表的匹配记录 . set null方式在父表上update/delete记录时，将子表上匹配记录的列设为null 要注意子表的外键列不能为not null . No action方式如果子表中有匹配的记录,则不允许对父表对应候选键进行update/delete操作 . Restrict方式同no action, 都是立即检查外键约束 . Set default方式父表有变更时,子表将外键列设置成一个默认的值但Innodb不能识别
1. as关键字

在使用SQL语句显示结果的时候，往往在屏幕显示的字段名并不具备良好的可读性，此时可以使用 as 给字段起一个别名。
1. 使用 as 给字段起别名
  
  select id as 序号, name as 名字, gender as 性别 from students;
2. 可以通过 as 给表起别名
  
  -- 如果是单表查询可以省略表名 select id, name, gender from students; -- 表名.字段名 select students.id,students.name,students.gender from students; -- 可以通过 as 给表起别名 select s.id,s.name,s.gender from students as s;
  
  说明:
  
  在这里给表起别名看起来并没有什么意义,然而并不是这样的，我们在后期学习自连接的时候，必须要对表起别名。
2. distinct关键字

distinct可以去除重复数据行。
```
select distinct 列1,... from 表名;

例： 查询班级中学生的性别
select name, gender from students;

-- 看到了很多重复数据 想要对其中重复数据行进行去重操作可以使用 distinct
select distinct name, gender from students;
```
3. 小结
- as 关键字可以给表中字段或者表名起别名
- distinct 关键字可以去除重复数据行。
1. where条件查询的介绍

使用where条件查询可以对表中的数据进行筛选，条件成立的记录会出现在结果集中。

where语句支持的运算符:
1. 比较运算符
2. 逻辑运算符
3. 模糊查询
4. 范围查询
5. 空判断
where条件查询语法格式如下:
```
select * from 表名 where 条件;
例：
select * from students where id = 1;
```
2. 比较运算符查询
1. 等于: =
2. 大于: >
3. 大于等于: >=
4. 小于: <
5. 小于等于: <=
6. 不等于: != 或 <>
例1：查询编号大于3的学生:
```
select * from students where id > 3;
```
例2：查询编号不大于4的学生:
```
select * from students where id <= 4;
```
例3：查询姓名不是“黄蓉”的学生:
```
select * from students where name != '黄蓉';
```
例4：查询没被删除的学生:
```
select * from students where is_delete=0;
```
3. 逻辑运算符查询
1. and
2. or
3. not
例1：查询编号大于3的女同学:
```
select * from students where id > 3 and gender=0;
```
例2：查询编号小于4或没被删除的学生:
```
select * from students where id < 4 or is_delete=0;
```
例3：查询年龄不在10岁到15岁之间的学生:
```
select * from students where not (age >= 10 and age <= 15);
```
说明:
- 多个条件判断想要作为一个整体，可以结合‘()’。
4. 模糊查询
1. like是模糊查询关键字
2. %表示任意多个任意字符
3. _表示一个任意字符
例1：查询姓黄的学生:
```
select * from students where name like '黄%';
```
例2：查询姓黄并且“名”是一个字的学生:
```
select * from students where name like '黄_';
```
例3：查询姓黄或叫靖的学生:
```
select * from students where name like '黄%' or name like '%靖';
```
5. 范围查询
1. between .. and .. 表示在一个连续的范围内查询
2. in 表示在一个非连续的范围内查询
例1：查询编号为3至8的学生:
```
select * from students where id between 3 and 8;
```
例2：查询编号不是3至8的男生:
```
select * from students where (not id between 3 and 8) and gender='男';
```
6. 空判断查询
1. 判断为空使用: is null
2. 判断非空使用: is not null
例1：查询没有填写身高的学生:
```
select * from students where height is null;
```
注意:
1. 不能使用 where height = null 判断为空
2. 不能使用 where height != null 判断非空
3. null 不等于 '' 空字符串
7. 小结
- 常见的比较运算符有 >,<,>=,<=,!=
- 逻辑运算符and表示多个条件同时成立则为真，or表示多个条件有一个成立则为真，not表示对条件取反
- like和%结合使用表示任意多个任意字符，like和_结合使用表示一个任意字符
- between-and限制连续性范围 in限制非连续性范围
- 判断为空使用: is null
- 判断非空使用: is not null
1. 排序查询语法

排序查询语法：
```
select * from 表名 order by 列1 asc|desc [,列2 asc|desc,...]
```
语法说明:
1. 先按照列1进行排序，如果列1的值相同时，则按照列2 排序，以此类推
2. asc从小到大排列，即升序
3. desc从大到小排序，即降序
4. 默认按照列值从小到大排列（即asc关键字）
例1：查询未删除男生信息，按学号降序:
```
select * from students where gender=1 and is_delete=0 order by id desc;
```
例2：显示所有的学生信息，先按照年龄从大-->小排序，当年龄相同时按照身高从高-->矮排序:
```
select * from students  order by age desc,height desc;
```
2. 小结
1. 排序使用 order by 关键字
2. asc 表示升序
3. desc 表示降序
分页查询

学习目标
- 能够使用 limit 关键字实现分页查询
1. 分页查询的介绍

当我们在京东购物，浏览商品列表的时候，由于数据特别多，一页显示不完，一页一页的进行显示，这就是分页查询

2. 分页查询的语法
```
select * from 表名 limit start,count
```
说明:
1. limit是分页查询关键字
2. start表示开始行索引，默认是0
3. count表示查询条数
例1：查询前3行男生信息:
```
select * from students where gender=1 limit 0,3;
简写
select * from students where gender=1 limit 3;
```
3. 分页查询案例

已知每页显示m条数据，求第n页显示的数据

提示: 关键是求每页的开始行索引

查询学生表，获取第n页数据的SQL语句:
```
select * from students limit (n-1)*m,m
```
4. 小结
- 使用 limit 关键字可以限制数据显示数量，通过 limit 关键可以完成分页查询
- limit 关键字后面的第一个参数是开始行索引(默认是0，不写就是0)，第二个参数是查询条数
聚合函数

学习目标
- 能够写出查询总行数的SQL语句
1. 聚合函数的介绍

聚合函数又叫组函数，通常是对表中的数据进行统计和计算，一般结合分组(group by)来使用，用于统计和计算分组数据。

常用的聚合函数:
1. count(col): 表示求指定列的总行数
2. max(col): 表示求指定列的最大值
3. min(col): 表示求指定列的最小值
4. sum(col): 表示求指定列的和
5. avg(col): 表示求指定列的平均值
2. 求总行数
```
-- 返回非NULL数据的总行数.
select count(height) from students; 
-- 返回总行数，包含null值记录;
select count(*) from students;
```
3. 求最大值
```
-- 查询女生的编号最大值
select max(id) from students where gender = 2;
```
4. 求最小值
```
-- 查询未删除的学生最小编号
select min(id) from students where is_delete = 0;
```
5. 求和
```
-- 查询男生的总身高
select sum(height) from students where gender = 1;
-- 平均身高
select sum(height) / count(*) from students where gender = 1;
```
6. 求平均值
```
-- 求男生的平均身高, 聚合函数不统计null值，平均身高有误
select avg(height) from students where gender = 1;
-- 求男生的平均身高, 包含身高是null的
select avg(ifnull(height,0)) from students where gender = 1;
```
说明
- ifnull函数: 表示判断指定字段的值是否为null，如果为空使用自己提供的值。
7. 聚合函数的特点
- 聚合函数默认忽略字段为null的记录要想列值为null的记录也参与计算，必须使用ifnull函数对null值做替换。
8. 小结
- count(col): 表示求指定列的总行数
- max(col): 表示求指定列的最大值
- min(col): 表示求指定列的最小值
- sum(col): 表示求指定列的和
- avg(col): 表示求指定列的平均值
分组查询

学习目标
- 能够写出分组查询的SQL语句
1. 分组查询介绍

分组查询就是将查询结果按照指定字段进行分组，字段中数据相等的分为一组。

分组查询基本的语法格式如下：

GROUP BY 列名 [HAVING 条件表达式] [WITH ROLLUP]

说明:
- 列名: 是指按照指定字段的值进行分组。
- HAVING 条件表达式: 用来过滤分组后的数据。
- WITH ROLLUP：在所有记录的最后加上一条记录，显示select查询时聚合函数的统计和计算结果
2. group by的使用

group by可用于单个字段分组，也可用于多个字段分组
```
-- 根据gender字段来分组
select gender from students group by gender;
-- 根据name和gender字段进行分组
select name, gender from students group by name, gender;
```
group by 用法解析 group by语法可以根据给定数据列的每个成员对查询结果进行分组统计，最终得到一个分组汇总表。 SELECT子句中的列名必须为分组列或列函数。列函数对于GROUP BY子句定义的每个组各返回一个结果。某个员工信息表结构和数据如下： id name dept salary edlevel hiredate 1 张三开发部 2000 3 2009-10-11 2 李四开发部 2500 3 2009-10-01 3 王五设计部 2600 5 2010-10-02 4 王六设计部 2300 4 2010-10-03 5 马七设计部 2100 4 2010-10-06 6 赵八销售部 3000 5 2010-10-05 7 钱九销售部 3100 7 2010-10-07 8 孙十销售部 3500 7 2010-10-06 例如，我想列出每个部门最高薪水的结果，sql语句如下： SELECT DEPT, MAX(SALARY) AS MAXIMUM FROM STAFF GROUP BY DEPT 查询结果如下： DEPT MAXIMUM 开发部 2500 设计部 2600 销售部 3500
3. group by + group_concat()的使用

group_concat(字段名): 统计每个分组指定字段的信息集合，每个信息之间使用逗号进行分割
```
-- 根据gender字段进行分组， 查询gender字段和分组的name字段信息
select gender,group_concat(name) from students group by gender;
```
4. group by + 聚合函数的使用
```
-- 统计不同性别的人的平均年龄
select gender,avg(age) from students group by gender;
-- 统计不同性别的人的个数
select gender,count(*) from students group by gender;
```
5. group by + having的使用

having作用和where类似都是过滤数据的，但having是过滤分组数据的，只能用于group by
```
-- 根据gender字段进行分组，统计分组条数大于2的
select gender,count(*) from students group by gender having count(*)>2;
```
6. group by + with rollup的使用

with rollup的作用是：在最后记录后面新增一行，显示select查询时聚合函数的统计和计算结果
```
-- 根据gender字段进行分组，汇总总人数
select gender,count(*) from students group by gender with rollup;
-- 根据gender字段进行分组，汇总所有人的年龄
select gender,group_concat(age) from students group by gender with rollup;
```
7. 小结
- group by 根据指定的一个或者多个字段对数据进行分组
- group_concat(字段名)函数是统计每个分组指定字段的信息集合
- 聚合函数在和 group by 结合使用时, 聚合函数统计和计算的是每个分组的数据
- having 是对分组数据进行条件过滤
- with rollup在最后记录后面新增一行，显示select查询时聚合函数的统计和计算结果
同步插入数据：insert into goods (name) select cate_name from goods group by cate_name; (注意没有values)

连接查询-内连接

学习目标
- 能够写出内连接查询的SQL语句
1. 连接查询的介绍

连接查询可以实现多个表的查询，当查询的字段数据来自不同的表就可以使用连接查询来完成。

连接查询可以分为:
1. 内连接查询
2. 左连接查询
3. 右连接查询
4. 自连接查询
2. 内连接查询

查询两个表中符合条件的共有记录

内连接查询效果图:

内连接查询语法格式:
```
select 字段 from 表1 inner join 表2 on 表1.字段1 = 表2.字段2
```
说明:
- inner join 就是内连接查询关键字
- on 就是连接查询条件
例1：使用内连接查询学生表与班级表:
```
select * from students as s inner join classes as c on s.cls_id = c.id;
```
3. 小结
- 内连接使用inner join .. on .., on 表示两个表的连接查询条件
- 内连接根据连接查询条件取出两个表的 “交集”
连接查询-左连接

学习目标
- 能够写出左连接查询的SQL语句
1. 左连接查询

以左表为主根据条件查询右表数据，如果根据条件查询右表数据不存在使用null值填充

左连接查询效果图:

左连接查询语法格式:
```
select 字段 from 表1 left join 表2 on 表1.字段1 = 表2.字段2
```
说明:
- left join 就是左连接查询关键字
- on 就是连接查询条件
- 表1 是左表
- 表2 是右表
例1：使用左连接查询学生表与班级表:
```
select * from students as s left join classes as c on s.cls_id = c.id;
```
2. 小结
- 左连接使用left join .. on .., on 表示两个表的连接查询条件
- 左连接以左表为主根据条件查询右表数据，右表数据不存在使用null值填充。
连接查询-右连接

学习目标
- 能够写出右连接查询的SQL语句
1. 右连接查询

以右表为主根据条件查询左表数据，如果根据条件查询左表数据不存在使用null值填充

右连接查询效果图:

右连接查询语法格式:
```
select 字段 from 表1 right join 表2 on 表1.字段1 = 表2.字段2
```
说明:
- right join 就是右连接查询关键字
- on 就是连接查询条件
- 表1 是左表
- 表2 是右表
例1：使用右连接查询学生表与班级表:
```
select * from students as s right join classes as c on s.cls_id = c.id;
```
2. 小结
- 右连接使用right join .. on .., on 表示两个表的连接查询条件
- 右连接以右表为主根据条件查询左表数据，左表数据不存在使用null值填充。
连接查询-自连接

学习目标
- 能够写出自连接查询的SQL语句
1. 自连接查询

左表和右表是同一个表，根据连接查询条件查询两个表中的数据。

区域表效果图

例1：查询省的名称为“山西省”的所有城市

创建areas表:
```
create table areas(
    id varchar(30) not null primary key, 
    title varchar(30), 
    pid varchar(30)
);
```
执行sql文件给areas表导入数据:
```
source areas.sql;
```
说明:
- source 表示执行的sql文件
自连接查询的用法:
```
select c.id, c.title, c.pid, p.title from areas as c inner join areas as p on c.pid = p.id where p.title = '山西省';
```
说明:
- 自连接查询必须对表起别名
小结
- 自连接查询就是把一张表模拟成左右两张表，然后进行连表查询。
- 自连接就是一种特殊的连接方式，连接的表还是本身这张表
子查询

学习目标
- 能够写出子查询的SQL语句
1. 子查询的介绍

在一个 select 语句中,嵌入了另外一个 select 语句, 那么被嵌入的 select 语句称之为子查询语句，外部那个select语句则称为主查询.

主查询和子查询的关系:
1. 子查询是嵌入到主查询中
2. 子查询是辅助主查询的,要么充当条件,要么充当数据源
3. 子查询是可以独立存在的语句,是一条完整的 select 语句
2. 子查询的使用

例1. 查询大于平均年龄的学生:
```
select * from students where age > (select avg(age) from students);
```
例2. 查询学生在班的所有班级名字:
```
select name from classes where id in (select cls_id from students where cls_id is not null);
```
例3. 查找年龄最大,身高最高的学生:
```
select * from students where (age, height) =  (select max(age), max(height) from students);
```
3. 小结
- 子查询是一个完整的SQL语句，子查询被嵌入到一对小括号里面
数据库设计之三范式

学习目标
- 能够知道一个表结构的设计是否符合三范式的要求
1. 数据库设计之三范式的介绍

范式: 对设计数据库提出的一些规范，目前有迹可寻的共有8种范式，一般遵守3范式即可。
- 第一范式（1NF）: 强调的是列的原子性，即列不能够再分成其他几列。
- 第二范式（2NF）: 满足 1NF，另外包含两部分内容，一是表必须有一个主键；二是非主键字段必须完全依赖于主键，而不能只依赖于主键的一部分。
- 第三范式（3NF）: 满足 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。
2. 第一范式的介绍

如图所示的表结构:

说明:
- 这种表结构设计就没有达到 1NF，要符合 1NF 我们只需把列拆分，即：把 contact 字段拆分成 name 、tel、addr 等字段。
3. 第二范式的介绍

如图所示的表结构:

说明:
- 这种表结构设计就没有达到 2NF，因为 Discount（折扣），Quantity（数量）完全依赖于主键（OrderID），而 UnitPrice单价，ProductName产品名称只依赖于 ProductID, 所以 OrderDetail 表不符合 2NF。
- 我们可以把【OrderDetail】表拆分为【OrderDetail】（OrderID，ProductID，Discount，Quantity）和【Product】（ProductID，UnitPrice，ProductName）这样就符合第二范式了。
4. 第三范式的介绍

如图所示的表结构:

说明:
- 这种表结构设计就没有达到 3NF，因为 OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity 等非主键列都完全依赖于主键（OrderID），所以符合 2NF。不过问题是 CustomerName，CustomerAddr，CustomerCity 直接依赖的是 CustomerID（非主键列），而不是直接依赖于主键，它是通过传递才依赖于主键，所以不符合 3NF。
- 我们可以把【Order】表拆分为【Order】（OrderID，OrderDate，CustomerID）和【Customer】（CustomerID，CustomerName，CustomerAddr，CustomerCity）从而达到 3NF。
5. E-R模型的介绍

E-R模型即实体-关系模型，E-R模型就是描述数据库存储数据的结构模型。

E-R模型的使用场景:
1. 对于大型公司开发项目，我们需要根据产品经理的设计，我们先使用建模工具, 如:power designer，db desinger等这些软件来画出实体-关系模型(E-R模型)
2. 然后根据三范式设计数据库表结构
E-R模型的效果图:

说明:
- 实体: 用矩形表示，并标注实体名称
- 属性: 用椭圆表示，并标注属性名称，
- 关系: 用菱形表示，并标注关系名称
  
  一对一
  
  一对多
  
  多对多
一对一的关系:

说明:
- 关系也是一种数据，需要通过一个字段存储在表中
- 1对1关系，在表A或表B中创建一个字段，存储另一个表的主键值
一对多的关系:

说明:
- 1对多关系，在多的一方表(学生表)中创建一个字段，存储班级表的主键值
多对多的关系:

说明:
- 多对多关系，新建一张表C，这个表只有两个字段，一个用于存储A的主键值，一个用于存储B的主键值
5. 小结
- 范式就是设计数据库的一些通用规范。
  
  1NF强调字段是最小单元，不可再分
  
  2NF强调在1NF基础上必须要有主键和非主键字段必须完全依赖于主键，也就是说不能部分依赖
  
  3MF强调在2NF基础上非主键字段必须直接依赖于主键，也就是说不能传递依赖(间接依赖)。
- E-R模型由实体、属性、实体之间的关系构成，主要用来描述数据库中表结构。
- 开发流程是先画出E-R模型，然后根据三范式设计数据库中的表结构
外键SQL语句的编写

学习目标
- 能够写出删除外键约束的SQL语句
1. 外键约束作用

外键约束:对外键字段的值进行更新和插入时会和引用表中字段的数据进行验证，数据如果不合法则更新和插入会失败，保证数据的有效性

2. 对于已经存在的字段添加外键约束
```
-- 为cls_id字段添加外键约束
alter table students add foreign key(cls_id) references classes(id);
```
3. 在创建数据表时设置外键约束
```
-- 创建学校表
create table school(
    id int not null primary key auto_increment, 
    name varchar(10)
);

-- 创建老师表
create table teacher(
    id int not null primary key auto_increment, 
    name varchar(10), 
    s_id int not null, 
    foreign key(s_id) references school(id)
);
```
4. 删除外键约束
```
-- 需要先获取外键约束名称,该名称系统会自动生成,可以通过查看表创建语句来获取名称
show create table teacher;

-- 获取名称之后就可以根据名称来删除外键约束
alter table teacher drop foreign key 外键名;
```
5. 小结
- 添加外键约束: alter table 从表 add foreign key(外键字段) references 主表(主键字段);
- 删除外键约束: alter table 表名 drop foreign key 外键名;
演练-分组和聚合函数的组合使用

学习目标
- 能够写出分组和聚合函数组合使用的SQL语句
1. 数据准备
```
-- 创建 "京东" 数据库
create database jing_dong charset=utf8;

-- 使用 "京东" 数据库
use jing_dong;

-- 创建一个商品goods数据表
create table goods(
    id int unsigned primary key auto_increment not null,
    name varchar(150) not null,
    cate_name varchar(40) not null,
    brand_name varchar(40) not null,
    price decimal(10,3) not null default 0,
    is_show bit not null default 1,
    is_saleoff bit not null default 0
);

-- 向goods表中插入数据

insert into goods values(0,'r510vc 15.6英寸笔记本','笔记本','华硕','3399',default,default); 
insert into goods values(0,'y400n 14.0英寸笔记本电脑','笔记本','联想','4999',default,default);
insert into goods values(0,'g150th 15.6英寸游戏本','游戏本','雷神','8499',default,default); 
insert into goods values(0,'x550cc 15.6英寸笔记本','笔记本','华硕','2799',default,default); 
insert into goods values(0,'x240 超极本','超级本','联想','4880',default,default); 
insert into goods values(0,'u330p 13.3英寸超极本','超级本','联想','4299',default,default); 
insert into goods values(0,'svp13226scb 触控超极本','超级本','索尼','7999',default,default); 
insert into goods values(0,'ipad mini 7.9英寸平板电脑','平板电脑','苹果','1998',default,default);
insert into goods values(0,'ipad air 9.7英寸平板电脑','平板电脑','苹果','3388',default,default); 
insert into goods values(0,'ipad mini 配备 retina 显示屏','平板电脑','苹果','2788',default,default); 
insert into goods values(0,'ideacentre c340 20英寸一体电脑 ','台式机','联想','3499',default,default); 
insert into goods values(0,'vostro 3800-r1206 台式电脑','台式机','戴尔','2899',default,default); 
insert into goods values(0,'imac me086ch/a 21.5英寸一体电脑','台式机','苹果','9188',default,default); 
insert into goods values(0,'at7-7414lp 台式电脑 linux ）','台式机','宏碁','3699',default,default); 
insert into goods values(0,'z220sff f4f06pa工作站','服务器/工作站','惠普','4288',default,default); 
insert into goods values(0,'poweredge ii服务器','服务器/工作站','戴尔','5388',default,default); 
insert into goods values(0,'mac pro专业级台式电脑','服务器/工作站','苹果','28888',default,default); 
insert into goods values(0,'hmz-t3w 头戴显示设备','笔记本配件','索尼','6999',default,default); 
insert into goods values(0,'商务双肩背包','笔记本配件','索尼','99',default,default); 
insert into goods values(0,'x3250 m4机架式服务器','服务器/工作站','ibm','6888',default,default); 
insert into goods values(0,'商务双肩背包','笔记本配件','索尼','99',default,default);
```
表结构说明:
- id 表示主键自增
- name 表示商品名称
- cate_name 表示分类名称
- brand_name 表示品牌名称
- price 表示价格
- is_show 表示是否显示
- is_saleoff 表示是否售完
2. SQL语句演练
1. 查询类型cate_name为 '超极本' 的商品名称、价格
  
  select name,price from goods where cate_name = '超级本';
2. 显示商品的分类
  
  select cate_name from goods group by cate_name;
3. 求所有电脑产品的平均价格,并且保留两位小数
  
  select round(avg(price),2) as avg_price from goods;
4. 显示每种商品的平均价格
  
  select cate_name,avg(price) from goods group by cate_name;
5. 查询每种类型的商品中最贵、最便宜、平均价、数量
  
  select cate_name,max(price),min(price),avg(price),count(*) from goods group by cate_name;
6. 查询所有价格大于平均价格的商品，并且按价格降序排序
  
  select id,name,price from goods where price > (select round(avg(price),2) as avg_price from goods) order by price desc;
将查询结果插入到其它表中

学习目标
- 能够写出将查询结果插入到其它表中的SQL语句
1. 思考

目前只有一个goods表，我们想要增加一个商品分类信息，比如：移动设备这个分类信息，只通过goods表无法完成商品分类的添加，那么如何实现添加商品分类信息的操作?

答案:
1. 创建一个商品分类表，把goods表中的商品分类信息添加到该表中。
2. 将goods表中的分类名称更改成商品分类表中对应的分类id
2. 创建商品分类表
```
-- 创建商品分类表
create table good_cates(
    id int not null primary key auto_increment, 
    name varchar(50) not null
);
```
3. 把goods表中的商品分类添加到商品分类表
```
-- 查询goods表中商品的分类信息
select cate_name from goods group by cate_name;

-- 将查询结果插入到good_cates表中
insert into good_cates(name) select cate_name from goods group by cate_name;

-- 添加移动设备分类信息
insert into good_cates(name) values('移动设备');
```
说明:
- insert into .. select .. 表示: 把查询结果插入到指定表中，也就是表复制。
4. 小结
- 想要完成表复制可以使用: insert into .. select .. SQL语句
使用连接更新表中某个字段数据

学习目标
- 能够知道使用连接更新表中某个字段数据的SQL语句
1. 更新goods表中的商品分类信息

上一节课我们已经创建了一个商品分类表(good_cates)，并完成了商品分类信息的插入，现在需要更新goods表中的商品分类信息，把商品分类名称改成商量分类id。

接下来我们实现第二步操作:
- 将goods表中的分类名称更改成商品分类表中对应的分类id
```
-- 查看goods表中的商品分类名称对应的商品分类id
select * from goods inner join good_cates on goods.cate_name = good_cates.name;

-- 把该语句中from 后的语句理解为一张虚表  
update goods g inner join good_cates gc on g.cate_name=gc.name set g.cate_name=gc.id;
```
2. 小结
- 连接更新表中数据使用: update .. join .. 语句
创建表并给某个字段添加数据

学习目标
- 能够写出创建表并给某个字段添加数据的SQL语句
1. 思考

上一节课我们完成了商品分类表(good_cates)的创建和商品分类信息的添加以及把商品表(goods)中的商品分类名称改成了对应的商品分类id，假如我们想要添加一个品牌，比如：双飞燕这个品牌信息，只通过goods表无法完成品牌信息的添加，那么如何实现添加品牌信息的操作?

答案:
1. 创建一个品牌表，把goods表中的品牌信息添加到该表中。
2. 将goods表中的品牌名称更改成品牌表中对应的品牌id
2. 创建品牌表
```
-- 查询品牌信息 
select brand_name from goods group by brand_name;

-- 通过create table ...select来创建数据表并且同时插入数据
-- 创建商品分类表，注意: 需要对brand_name 用as起别名，否则name字段就没有值
create table good_brands (     
id int unsigned primary key auto_increment,     
name varchar(40) not null) select brand_name as name from goods group by brand_name;
```
说明:
- create table .. select 列名 .. 表示创建表并插入数据
3. 更新goods表中的品牌信息
```
-- 将goods表中的品牌名称更改成品牌表中对应的品牌id
update goods as g inner join good_brands gb on g.brand_name = gb.name set g.brand_name = gb.id;
```
4. 小结
- 创建表并给字段插入数据使用: create table .. select 语句
修改goods表结构
- 能够写出修改表结构的SQL语句
修改goods表结构

目前我们已经把good表中的商品分类和品牌信息已经更改成了商品分类id和品牌id，接下来需要把 cate_name 和 brand_name 字段分别改成 cate_id和 brand_id 字段，类型都改成int类型
```
-- 查看表结构
desc goods;
-- 通过alter table语句修改表结构
alter table goods change cate_name cate_id int not null, change brand_name brand_id int not null;
```
说明:
- alert table 可以同时修改多个字段信息
小结
- 修改表结构可以使用: alter table 语句，多个修改字段之间使用逗号分隔
PyMySQL的使用

学习目标
- 能够使用PyMySQL完成数据库的增删改查
1. 思考

如何实现将100000条数据插入到MySQL数据库?

答案:

如果使用之前学习的MySQL客户端来完成这个操作，那么这个工作量无疑是巨大的，我们可以通过使用程序代码的方式去连接MySQL数据库，然后对MySQL数据库进行增删改查的方式，实现10000条数据的插入，像这样使用代码的方式操作数据库就称为数据库编程。

2. Python程序操作MySQL数据库

安装pymysql第三方包:
```
sudo pip3 install pymysql
```
说明:
- 安装命令使用 sudo pip3 install 第三方包名
- 卸载命令使用 sudo pip3 uninstall 第三方包
- 大家现在使用的虚拟机已经安装了这个第三方包，可以使用： pip3 show pymysql 命令查看第三方包的信息
- pip3 list 查看使用pip命令安装的第三方包列表
pymysql的使用:
1. 导入 pymysql 包
  
  import pymysql
2. 创建连接对象
  
  调用pymysql模块中的connect()函数来创建连接对象,代码如下:
  
  conn=connect(参数列表) * 参数host：连接的mysql主机，如果本机是'localhost' * 参数port：连接的mysql主机的端口，默认是3306 * 参数user：连接的用户名 * 参数password：连接的密码 * 参数database：数据库的名称 * 参数charset：通信采用的编码方式，推荐使用utf8
  
  连接对象操作说明:
  
  关闭连接 conn.close()
  
  提交数据 conn.commit()
  
  撤销数据 conn.rollback()
3. 获取游标对象
  
  获取游标对象的目标就是要执行sql语句，完成对数据库的增、删、改、查操作。代码如下:
  
  # 调用连接对象的cursor()方法获取游标对象 cur =conn.cursor()
  
  游标操作说明:
  
  使用游标执行SQL语句: execute(operation [parameters ]) 执行SQL语句，返回受影响的行数，主要用于执行insert、update、delete、select等语句
  
  获取查询结果集中的一条数据:cur.fetchone()返回一个元组, 如 (1,'张三')
  
  获取查询结果集中的所有数据: cur.fetchall()返回一个元组,如((1,'张三'),(2,'李四'))
  
  关闭游标: cur.close(),表示和数据库操作完成
4. pymysql完成数据的查询操作
  
  import pymysql # 创建连接对象 conn = pymysql.connect(host='localhost', port=3306, user='root', password='mysql',database='python', charset='utf8') # 获取游标对象 cursor = conn.cursor() # 查询 SQL 语句 sql = "select * from students;" # 执行 SQL 语句返回值就是 SQL 语句在执行过程中影响的行数 row_count = cursor.execute(sql) print("SQL 语句执行影响的行数%d" % row_count) # 取出结果集中一行数据,　例如:(1, '张三') # print(cursor.fetchone()) # 取出结果集中的所有数据, 例如:((1, '张三'), (2, '李四'), (3, '王五')) for line in cursor.fetchall(): print(line) # 关闭游标 cursor.close() # 关闭连接 conn.close()
5. pymysql完成对数据的增删改
  
  import pymysql # 创建连接对象 conn = pymysql.connect(host='localhost', port=3306, user='root', password='mysql',database='python', charset='utf8') # 获取游标对象 cursor = conn.cursor() try: # 添加 SQL 语句 # sql = "insert into students(name) values('刘璐'), ('王美丽');" # 删除 SQ L语句 # sql = "delete from students where id = 5;" # 修改 SQL 语句 sql = "update students set name = '王铁蛋' where id = 6;" # 执行 SQL 语句 row_count = cursor.execute(sql) print("SQL 语句执行影响的行数%d" % row_count) # 提交数据到数据库 conn.commit() except Exception as e: # 回滚数据，即撤销刚刚的SQL语句操作 conn.rollback() # 关闭游标 cursor.close() # 关闭连接 conn.close()
  
  说明:
  
  conn.commit() 表示将修改操作提交到数据库
  
  conn.rollback() 表示回滚数据
6. 防止SQL注入
  
  什么是SQL注入?
  
  用户提交带有恶意的数据与SQL语句进行字符串方式的拼接，从而影响了SQL语句的语义，最终产生数据泄露的现象。
  
  如何防止SQL注入?
  
  SQL语句参数化
  
  SQL语言中的参数使用%s来占位，此处不是python中的字符串格式化操作
  
  将SQL语句中%s占位所需要的参数存在一个列表中，把参数列表传递给execute方法中第二个参数
  
  防止SQL注入的示例代码:
  
  from pymysql import connect def main(): find_name = input("请输入物品名称：") # 创建Connection连接 conn = connect(host='localhost',port=3306,user='root',password='mysql',database='jing_dong',charset='utf8') # 获得Cursor对象 cs1 = conn.cursor() # 非安全的方式 # 输入 ' or 1 = 1 or ' (单引号也要输入) # sql = "select * from goods where name='%s'" % find_name # print("""sql===>%s<====""" % sql) # # 执行select语句，并返回受影响的行数：查询所有数据 # count = cs1.execute(sql) # 安全的方式 # 构造参数列表 params = [find_name] # 执行select语句，并返回受影响的行数：查询所有数据 count = cs1.execute("select * from goods where name=%s", params) # 注意： # 如果要是有多个参数，需要进行参数化 # 那么params = [数值1, 数值2....]，此时sql语句中有多个%s即可 # %s 不需要带引号 # 打印受影响的行数 print(count) # 获取查询的结果 # result = cs1.fetchone() result = cs1.fetchall() # 打印查询的结果 print(result) # 关闭Cursor对象 cs1.close() # 关闭Connection对象 conn.close() if __name__ == '__main__': main()
  
  说明:
  
  execute方法中的 %s 占位不需要带引号
3. 小结
1. 导包
  
  import pymysql
2. 创建连接对象
  
  pymysql.connect(参数列表)
3. 获取游标对象
  
  cursor =conn.cursor()
4. 执行SQL语句
  
  row_count = cursor.execute(sql)
5. 获取查询结果集
  
  result = cursor.fetchall()
6. 将修改操作提交到数据库
  
  conn.commit()
7. 回滚数据
  
  conn.rollback()
8. 关闭游标
  
  cursor.close()
9. 关闭连接
  
  conn.close()
事务

学习目标
- 能够知道事务的四大特性
1. 事务的介绍

事务就是用户定义的一系列执行SQL语句的操作, 这些操作要么完全地执行，要么完全地都不执行，它是一个不可分割的工作执行单元。

事务的使用场景:

在日常生活中，有时我们需要进行银行转账，这个银行转账操作背后就是需要执行多个SQL语句，假如这些SQL执行到一半突然停电了，那么就会导致这个功能只完成了一半，这种情况是不允许出现，要想解决这个问题就需要通过事务来完成。

2. 事务的四大特性
- 原子性(Atomicity)
- 一致性(Consistency)
- 隔离性(Isolation)
- 持久性(Durability)
原子性:

一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作，这就是事务的原子性

一致性:

数据库总是从一个一致性的状态转换到另一个一致性的状态。（在前面的例子中，一致性确保了，即使在转账过程中系统崩溃，支票账户中也不会损失200美元，因为事务最终没有提交，所以事务中所做的修改也不会保存到数据库中。）

隔离性:

通常来说，一个事务所做的修改操作在提交事务之前，对于其他事务来说是不可见的。（在前面的例子中，当执行完第三条语句、第四条语句还未开始时，此时有另外的一个账户汇总程序开始运行，则其看到支票帐户的余额并没有被减去200美元。）

持久性:

一旦事务提交，则其所做的修改会永久保存到数据库。

说明:

事务能够保证数据的完整性和一致性，让用户的操作更加安全。

3. 事务的使用

在使用事务之前，先要确保表的存储引擎是 InnoDB 类型, 只有这个类型才可以使用事务，MySQL数据库中表的存储引擎默认是 InnoDB 类型。

表的存储引擎说明:

表的存储引擎就是提供存储数据一种机制，不同表的存储引擎提供不同的存储机制。

汽车引擎效果图:

说明:
- 不同的汽车引擎，提供的汽车动力也是不同的。
查看MySQL数据库支持的表的存储引擎:
```
-- 查看MySQL数据库支持的表的存储引擎
show engines;
```
说明:
- 常用的表的存储引擎是 InnoDB 和 MyISAM
- InnoDB 是支持事务的
- MyISAM 不支持事务，优势是访问速度快，对事务没有要求或者以select、insert为主的都可以使用该存储引擎来创建表
查看goods表的创表语句:
```
-- 选择数据库
use jing_dong;
-- 查看goods表
show create table goods;

mysql root@(none):jing_dong> show create table goods;
+-------+--------------------------------------------------------+
| Table | Create Table                                           |
+-------+--------------------------------------------------------+
| goods | CREATE TABLE `goods` (                                 |
|       |   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,       |
|       |   `name` varchar(150) NOT NULL,                        |
|       |   `cate_id` int(10) unsigned NOT NULL,                 |
|       |   `brand_id` int(10) unsigned NOT NULL,                |
|       |   `price` decimal(10,3) NOT NULL DEFAULT '0.000',      |
|       |   `is_show` bit(1) NOT NULL DEFAULT b'1',              |
|       |   `is_saleoff` bit(1) NOT NULL DEFAULT b'0',           |
|       |   PRIMARY KEY (`id`)                                   |
|       | ) ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8 |
+-------+--------------------------------------------------------+
```
说明:
- 通过创表语句可以得知，goods表的存储引擎是InnoDB。
- 修改表的存储引擎使用: alter table 表名 engine = 引擎类型;
  
  比如: alter table students engine = 'MyISAM';
开启事务:
```
begin;
或者
start transaction;
```
说明:
- 开启事务后执行修改命令，变更数据会保存到MySQL服务端的缓存文件中，而不维护到物理表中
- MySQL数据库默认采用自动提交(autocommit)模式，如果没有显示的开启一个事务,那么每条sql语句都会被当作一个事务执行提交的操作
- 当设置autocommit=0就是取消了自动提交事务模式，直到显示的执行commit和rollback表示该事务结束。
  
  set autocommit = 0 表示取消自动提交事务模式，需要手动执行commit完成事务的提交
  
  set autocommit = 0; insert into students(name) values('刘三峰'); -- 需要执行手动提交，数据才会真正添加到表中, 验证的话需要重新打开一个连接窗口查看表的数据信息，因为是临时关闭自动提交模式 commit -- 重新打开一个终端窗口，连接MySQL数据库服务端 mysql -uroot -p -- 然后查询数据,如果上个窗口执行了commit，这个窗口才能看到数据 select * from students;
  
  提交事务:
  
  将本地缓存文件中的数据提交到物理表中，完成数据的更新。
  
  commit;
  
  回滚事务:
  
  放弃本地缓存文件中的缓存数据, 表示回到开始事务前的状态
  
  rollback;
  
  事务演练的SQL语句:
  
  begin; insert into students(name) values('李白'); -- 查询数据，此时有新增的数据, 注意: 如果这里后续没有执行提交事务操作，那么数据是没有真正的更新到物理表中 select * from students; -- 只有这里提交事务，才把数据真正插入到物理表中 commit; -- 新打开一个终端，重新连接MySQL数据库，查询students表,这时没有显示新增的数据，说明之前的事务没有提交，这就是事务的隔离性 -- 一个事务所做的修改操作在提交事务之前，对于其他事务来说是不可见的 select * from students;
4. 小结
1. 事务的特性:
  
  原子性: 强调事务中的多个操作时一个整体
  
  一致性: 强调数据库中不会保存不一致状态
  
  隔离性: 强调数据库中事务之间相互不可见
  
  持久性: 强调数据库能永久保存数据，一旦提交就不可撤销
2. MySQL数据库默认采用自动提交(autocommit)模式, 也就是说修改数据(insert、update、delete)的操作会自动的触发事务,完成事务的提交或者回滚
3. 开启事务使用 begin 或者 start transaction;
4. 回滚事务使用 rollback;
5. pymysql 里面的 conn.commit() 操作就是提交事务
6. pymysql 里面的 conn.rollback() 操作就是回滚事务
索引

学习目标
- 能够写出创建索引的SQL语句
1. 索引的介绍

索引在MySQL中也叫做“键”，它是一个特殊的文件，它保存着数据表里所有记录的位置信息，更通俗的来说，数据库索引好比是一本书前面的目录，能加快数据库的查询速度。

应用场景:

当数据库中数据量很大时，查找数据会变得很慢，我们就可以通过索引来提高数据库的查询效率。

2. 索引的使用

查看表中已有索引:
```
show index from 表名;
```
说明:
- 主键列会自动创建索引
索引的创建:
```
-- 创建索引的语法格式
-- alter table 表名 add index 索引名[可选](列名, ..)
-- 给name字段添加索引
alter table classes add index my_name (name);
```
说明:
- 索引名不指定，默认使用字段名
索引的删除:
```
-- 删除索引的语法格式
-- alter table 表名 drop index 索引名
-- 如果不知道索引名，可以查看创表sql语句
show create table classes;
alter table classes drop index my_name;
```
3. 案例-验证索引查询性能

创建测试表testindex:
```
create table test_index(title varchar(10));
```
向表中插入十万条数据:
```
from pymysql import connect

def main():
    # 创建Connection连接
    conn = connect(host='localhost',port=3306,database='python',user='root',password='mysql',charset='utf8')
    # 获得Cursor对象
    cursor = conn.cursor()
    # 插入10万次数据
    for i in range(100000):
        cursor.execute("insert into test_index values('ha-%d')" % i)
    # 提交数据
    conn.commit()

if __name__ == "__main__":
    main()
```
验证索引性能操作：
```
-- 开启运行时间监测：
set profiling=1;
-- 查找第1万条数据ha-99999
select * from test_index where title='ha-99999';
-- 查看执行的时间：
show profiles;
-- 给title字段创建索引：
alter table test_index add index (title);
-- 再次执行查询语句
select * from test_index where title='ha-99999';
-- 再次查看执行的时间
show profiles;
```
4. 联合索引

联合索引又叫复合索引，即一个索引覆盖表中两个或者多个字段，一般用在多个字段一起查询的时候。
```
-- 创建teacher表
create table teacher
(
    id int not null primary key auto_increment,
    name varchar(10),
    age int
);

-- 创建联合索引
alter table teacher add index (name,age);
```
联合索引的好处:
- 减少磁盘空间开销，因为每创建一个索引，其实就是创建了一个索引文件，那么会增加磁盘空间的开销。
5. 联合索引的最左原则

在使用联合索引的时候，我们要遵守一个最左原则,即index(name,age)支持 name 、name 和 age 组合查询,而不支持单独 age 查询，因为没有用到创建的联合索引。

最左原则示例:
```
-- 下面的查询使用到了联合索引
select * from stu where name='张三' -- 这里使用了联合索引的name部分
select * from stu where name='李四' and age=10 -- 这里完整的使用联合索引，包括 name 和 age 部分 
-- 下面的查询没有使用到联合索引
select * from stu where age=10 -- 因为联合索引里面没有这个组合，只有 name | name age 这两种组合
```
说明:
- 在使用联合索引的查询数据时候一定要保证联合索引的最左侧字段出现在查询条件里面，否则联合索引失效
6. MySQL中索引的优点和缺点和使用原则
- 优点：
  
  加快数据的查询速度
- 缺点：
  
  创建索引会耗费时间和占用磁盘空间，并且随着数据量的增加所耗费的时间也会增加
- 使用原则：
  
  通过优缺点对比，不是索引越多越好，而是需要自己合理的使用。
  
  对经常更新的表就避免对其进行过多索引的创建，对经常用于查询的字段应该创建索引，
  
  数据量小的表最好不要使用索引，因为由于数据较少，可能查询全部数据花费的时间比遍历索引的时间还要短，索引就可能不会产生优化效果。
  
  在一字段上相同值比较多不要建立索引，比如在学生表的"性别"字段上只有男，女两个不同值。相反的，在一个字段上不同值较多可是建立索引。
7. 小结
- 索引是加快数据库的查询速度的一种手段
- 创建索引使用: alter table 表名 add index 索引名[可选] (字段名, xxx);
- 删除索引使用: alter table 表名 drop index 索引名;
MySQL主从同步配置
注意：本文是在乌班图和Windows10环境下配置，Centos与乌班图略有不同，就是Centos的MySQL配置文件路径为/etc/my.cnf,其他操作一致

1. 主从同步的定义

主从同步使得数据可以从一个数据库服务器复制到其他服务器上，在复制数据时，一个服务器充当主服务器（master），其余的服务器充当从服务器（slave）。因为复制是异步进行的，所以从服务器不需要一直连接着主服务器，从服务器甚至可以通过拨号断断续续地连接主服务器。通过配置文件，可以指定复制所有的数据库，某个数据库，甚至是某个数据库上的某个表。

使用主从同步的好处：

通过增加从服务器来提高数据库的性能，在主服务器上执行写入和更新，在从服务器上向外提供读功能，可以动态地调整从服务器的数量，从而调整整个数据库的性能。

提高数据安全，因为数据已复制到从服务器，从服务器可以终止复制进程，所以，可以在从服务器上备份而不破坏主服务器相应数据

在主服务器上生成实时数据，而在从服务器上分析这些数据，从而提高主服务器的性能

2. 主从同步的机制

Mysql服务器之间的主从同步是基于二进制日志机制，主服务器使用二进制日志来记录数据库的变动情况，从服务器通过读取和执行该日志文件来保持和主服务器的数据一致。

在使用二进制日志时，主服务器的所有操作都会被记录下来，然后从服务器会接收到该日志的一个副本。从服务器可以指定执行该日志中的哪一类事件（譬如只插入数据或者只更新数据），默认会执行日志中的所有语句。

每一个从服务器会记录关于二进制日志的信息：文件名和已经处理过的语句，这样意味着不同的从服务器可以分别执行同一个二进制日志的不同部分，并且从服务器可以随时连接或者中断和服务器的连接。

主服务器和每一个从服务器都必须配置一个唯一的ID号（在my.cnf文件的[mysqld]模块下有一个server-id配置项），另外，每一个从服务器还需要通过CHANGE MASTER TO语句来配置它要连接的主服务器的ip地址，日志文件名称和该日志里面的位置（这些信息存储在主服务器的数据库里）

3. 配置主从同步的基本步骤

有很多种配置主从同步的方法，可以总结为如下的步骤：

在主服务器上，必须开启二进制日志机制和配置一个独立的ID

在每一个从服务器上，配置一个唯一的ID，创建一个用来专门复制主服务器数据的账号

在开始复制进程前，在主服务器上记录二进制文件的位置信息

如果在开始复制之前，数据库中已经有数据，就必须先创建一个数据快照（可以使用mysqldump导出数据库，或者直接复制数据文件）

配置从服务器要连接的主服务器的IP地址和登陆授权，二进制日志文件名和位置

4. 详细配置主从同步的方法

主和从的身份可以自己指定，我们将虚拟机Ubuntu中MySQL作为主服务器，将Windows中的MySQL作为从服务器。在主从设置前，要保证Ubuntu与Windows间的网络连通。

4.1 备份主服务器原有数据到从服务器

mysqldump -uroot -p --all-databases --lock-all-tables > ~/master_db.sql

说明：

-u ：用户名

-p ：示密码

--all-databases ：导出所有数据库

--lock-all-tables ：执行操作时锁住所有表，防止操作时有数据修改

~/master_db.sql :导出的备份数据（sql文件）位置，可自己指定

4.1.2 在从服务器Windows上进行数据还原

将master_db.sql从乌班图上复制到windows上的任意盘符的根下（方便还原），执行命令还原数据库

4.2.1 编辑设置mysqld的配置文件，设置log_bin和server-id

log_bin可以直接配置成mysql-bin.log

根据需求还可以配置如下字段

log_slave_updates=1

binlog-do-db=db_name # 需要同步的数据库

binlog-ignore-db=mysql # 被忽略的数据库

binlog_format=ROW

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

4.2.2 重启mysql服务

sudo service mysql restart

4.2.3 登入主服务器Ubuntu中的mysql，创建用于从服务器同步数据使用的帐号

GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' identified by 'slave'; FLUSH PRIVILEGES;

4.2.4 获取主服务器的二进制日志信息

SHOW MASTER STATUS;

File为使用的日志文件名字，Position为使用的文件位置，这两个参数须记下，配置从服务器时会用到

4.3 配置从服务器slave（Windows中的MySQL）

4.3.1找到Windows中MySQL的配置文件

4.3.2 编辑my.ini文件，将server-id修改为2，并保存退出。

同样，根据需求可以配置如下字段

log-bin=mysql-bin

replicate-do-db=db_name #需要同步的数据库名

4.2.3 打开windows服务管理

可以在开始菜单中输入services.msc找到并运行

4.3.4 在打开的服务管理中找到MySQL57，并重启该服务

5. 进入windows的mysql，设置连接到master主服务器

change master to master_host='192.168.204.129', master_user='slave', master_password='slave',master_log_file='mysql-bin.000001', master_log_pos=590;

注：

master_host：主服务器Ubuntu的ip地址

master_log_file: 前面查询到的主服务器日志文件名

master_log_pos: 前面查询到的主服务器日志文件位置

6. 开启同步，查看同步状态

7. 测试主从同步

在Ubuntu的MySQL中（主服务器）创建一个数据库

在Windows的MySQL中（从服务器）查看新建的数据库是否存在
查看全文

相关阅读:
前端之css网页布局等相关内容-54
前端之css属性设置等相关内容-53
前端之css选择器等相关内容-52
前端之HTML标签等相关内容-51
前端之HTML基础等相关内容-50
数据库之mysql索引增删改查等相关内容-48
累了就拥抱下自己
 平静地生活
 良心远大于失败
 独处

原文地址：https://www.cnblogs.com/qj696/p/12290605.html

Can't connect to MySQL server on xxx (10061):https://blog.csdn.net/weixin_36374032/article/details/84341740

FOREIKEY

1. as关键字

2. distinct关键字

3. 小结

1. where条件查询的介绍

2. 比较运算符查询

3. 逻辑运算符查询

4. 模糊查询

5. 范围查询

6. 空判断查询

7. 小结

1. 排序查询语法

2. 小结

分页查询

1. 分页查询的介绍

2. 分页查询的语法

3. 分页查询案例

4. 小结

聚合函数

1. 聚合函数的介绍

2. 求总行数

3. 求最大值

4. 求最小值

5. 求和

6. 求平均值

7. 聚合函数的特点

8. 小结

分组查询

1. 分组查询介绍

2. group by的使用

3. group by + group_concat()的使用

4. group by + 聚合函数的使用

5. group by + having的使用

6. group by + with rollup的使用

7. 小结

连接查询-内连接

1. 连接查询的介绍

2. 内连接查询

3. 小结

连接查询-左连接

1. 左连接查询

2. 小结

连接查询-右连接

1. 右连接查询

2. 小结

连接查询-自连接

1. 自连接查询

小结

子查询

1. 子查询的介绍

2. 子查询的使用

3. 小结

数据库设计之三范式

1. 数据库设计之三范式的介绍

2. 第一范式的介绍

3. 第二范式的介绍

4. 第三范式的介绍

5. E-R模型的介绍

5. 小结

外键SQL语句的编写

1. 外键约束作用

2. 对于已经存在的字段添加外键约束

3. 在创建数据表时设置外键约束

4. 删除外键约束

5. 小结

演练-分组和聚合函数的组合使用

1. 数据准备

2. SQL语句演练

将查询结果插入到其它表中

1. 思考

2. 创建商品分类表

3. 把goods表中的商品分类添加到商品分类表

4. 小结

使用连接更新表中某个字段数据

1. 更新goods表中的商品分类信息

2. 小结

创建表并给某个字段添加数据

1. 思考