MySQL学习【个人笔记/已完结】

学校课程数据库大概都学过啦，不过已经过去两年了，就跟着狂神老师复习复习吧。个人向的笔记，就记录一些重难点与自己不会的知识点，不会特别详细滴~

一、软件安装与初识

1.1 MySQL

安装目录下建一个 my.ini 文件，里面敲入这些，记得修改 basedir 和 datadir 的目录（datadir 目前应该还没有生成，反正就是 basedir 的目录加上\data，后续会自动生成的）：

[mysqld]
--设置3306端口
port=3306
--设置mysql的安装目录
basedir=C:\mysql\mysql-8.0.28
--设置mysql数据库的数据的存放目录
datadir=C:\mysql\mysql-8.0.28\data
--允许最大连接数
max_connections=200
--允许连接失败的次数。这是为了防止有人从该主机试图攻击数据库系统
max_connect_errors=10
--服务端使用的字符集默认为UTF8
character-set-server=utf8
--创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
--默认使用“mysql_native_password”插件认证
default_authentication_plugin=mysql_native_password

[mysql]
--设置mysql客户端默认字符集
default-character-set=utf8
[client]
--设置mysql客户端连接服务端时默认使用的端口
port=3306
default-character-set=utf8

配置环境变量：
PATH 下敲入安装的 bin 目录就好，我的是：

C:\mysql\mysql-8.0.28\bin

然后管理员身份打开命令行进行操作…
我上午搞的，出了些小问题整了很久，所以命令行里敲了什么全忘光了！ 可以b站上找视频的，都很详细的！直接跳过这一 part。

1.2 sqlyog

安装很简单，包很小，选择路径后一路 next。记得找一个注册名和证书密钥就好。

新建时报错（plugin caching_sha2_password could not be loaded），还有一堆乱码。

尝试解决办法：
以管理员的身份启动控制台，进入MySQL：

mysql -uroot -p

输入密码后，再依次输入：

ALTER USER 'root'@'localhost' IDENTIFIED BY '这里写你的密码' PASSWORD EXPIRE NEVER;
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '这里写你的密码';
FLUSH PRIVILEGES;

成功！

1.3 初用 sqlyog

1. 创建 school 数据库
   
   
   每一个 sqlyog 的执行操作，本质就是对应了一个 sql，可以在软件的历史记录中查看。

2. 新建一张表 student

3. 查看表

1.4 连接数据库

	mysql -uroot -p		--连接数据库

回车后输入密码，登陆成功。

show databases;	--查看所有数据库
mysql> use school	--切换数据库

show tables;	--查看数据库中所有表
describe student;	--显示数据库中所有表信息

create database westos;	--创建一个数据库

exit;	--退出

MySQL 的四个语言
DDL：数据库定义语言
DML：数据库操作语言
DQL：数据库查询语言
DCL：数据库控制语言

二、操作数据库

操作数据库 -> 操作数据库中的表 -> 操作数据库中表的数据

2.1 操作数据库

1. 创建数据库

CREATE DATABASE [IF NOT EXISTS] school;		--如果数据库名为关键字，就这样：`school`

2. 删除数据库

DROP DATABASE IF EXISTS hello;

3. 使用数据库

不说了！后续要深入学习这个！

4. 查看数据库

SHOW DATABASES	--查看所有数据库

2.2 数据库的列类型

数值：

• tinyint：1个字节
• smallint：2个字节
• mediumint：3个字节
• int：标准的整数，4个字节
• bigint：8个字节
• float：浮点数，4个字节
• double：浮点数，8个字节
• decimal：字符串形式的浮点数，金融计算的时候使用

字符串：

• char：0~255
• varchar：可变字符串，0~65535
• tinytext：微型文本，2^8 - 1
• text：文本串，2^16 - 1，保存大文本

时间日期：java.util.Data

• data：YYYY-MM-DD，日期格式
• time：HH : mm : ss，时间格式
• datatime：日期 + 时间
• timestamp：时间戳，1970.1.1 到现在的毫秒数
• year：年份表示

2.3 数据库的字段属性

Unsigned：无符号的整数，表示该列不能为负数

zerofill：不足的位数用0填充，int（3），5 -> 005

自增：自动在上一条的基础上 +1（默认），通常来设计唯一的主键。index，必须是整数类型（也可以自定义设计主键自增的起始值和步长，在高级中）

非空： not null，如果不赋值，就会报错。如果不选中，不填写，默认就是 null。

默认：设置默认的值。例如 sex，默认值为男，如果不指定该列的值，就默认填入男。

每个表中必须存在以下五个字段：

未来做项目用的，表示一个记录的存在意义。

id：主键
version：乐观锁
is_delete：伪删除
gmt_create：创建时间
gmt_create：修改时间

2.4 创建数据库表

格式：

CREATE TABLE [IF NOT EXISTS] `表名`(
	`字段名` 列类型 [属性] [索引] [注释] ,
	`字段名` 列类型 [属性] [索引] [注释] ,
	`字段名` 列类型 [属性] [索引] [注释] ,
	`字段名` 列类型 [属性] [索引] [注释] ,
	`字段名` 列类型 [属性] [索引] [注释] 
)[表类型][字符集设置][注释]

创建一个学生表：

CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',	-- 列名 数据类型 非空 自增 注释
	`name` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭地址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

常用命令：

SHOW CREATE DATABASE school	-- 查看创建数据库的语句
SHOW CREATE TABLE student	-- 查看student数据表的定义语句
DESC student	-- 显示表的结构

2.5 数据表的类型

-- 数据库引擎
/*
	INNODB  默认使用
	MYISAM  早些年使用
*/

	MYISAM	INNODB
事物锁定	不支持	支持
数据行锁定	不支持	支持
外键约束	不支持	支持
全文索引	支持	不支持
表空间大小	较小	较大，约为 2 倍

常规使用操作：

• MYISAM 节约空间，速度较快
• INNODB 安全性高，事务的处理，多表多用户操作

所有数据库文件都存在 data 目录下，一个文件夹就对应一个数据库！

2.6 修改表（Alter）、删除表（Drop）

修改：

-- 修改表名：ALTER TABLE 旧表名 RENAME 新表名
ALTER TABLE student RENAME student1

-- 增加表的字段：ALTER TABLE 表名 ADD `字段名` 列属性
ALTER TABLE student1 ADD `age` INT(11)

-- 修改表的字段
-- ALTER TABLE 表名 MODIFY 字段名 属性
ALTER TABLE student1 MODIFY age VARCHAR(10)	-- 修改约束
-- ALTER TABLE 表名 CHANGE 旧字段名 新字段名
ALTER TABLE student1 CHANGE age age1 INT(10)	-- 字段重命名，一般不用于改约束！

-- 删除表的字段
-- ALTER TABLE 表名 DROP 属性名
ALTER TABLE student1 DROP age1

删除：

-- 删除表
-- DROP TABLE IF EXISTS 表名
DROP TABLE IF EXISTS student1

三、MySQL 的数据管理

3.1 外键（了解）

法一：在创建表的时候给主键增加约束。

• 定义外键 key
• 给这个外键添加约束（执行引用）

-- grade表
CREATE TABLE IF NOT EXISTS `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

-- student表
CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',	-- 列名 数据类型 非空 自增 注释
	`name` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭地址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	`gradeid` VARCHAR(10) DEFAULT NULL COMMENT '年级号',
	 PRIMARY KEY (`id`),
	 KEY `FK_gradeid` (`gradeid`),	-- 外键通用约束名
	 CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

删除有外键关系的表的时候，必须先删除引用别人的表（从表），再删除被引用的表（主表）。

此处从表为 student，主表为 grade。所以只能先删除 student 表，再删除 grade 表。

法二：创建表成功后，添加表的约束

CREATE TABLE IF NOT EXISTS `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`)
)ENGINE = INNODB DEFAULT CHARSET=utf8



CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',	-- 列名 数据类型 非空 自增 注释
	`name` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭地址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	`gradeid` INT(10) NOT NULL COMMENT '年级id',
	PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET=utf8

-- 创建表的时候没有外键关系
ALTER TABLE `student` 
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);

以上操作都是物理外键，也就是数据库级别的外键，不建议使用！避免数据库过多造成困扰。

• 数据库就是单纯的表，只用来存数据，只有行（数据）和列（字段）
• 如果我们想使用多张表的数据，用程序去实现！

3.2 DML 语言（背）

数据库意义：数据存储，数据管理

DML 语言：数据操作语言

• insert
• update
• delete

3.3 添加（insert）

语法：

INSERT INTO 表名([字段名1,字段名2,字段名3,...]) 
		   VALUE('值1','值2','值3',...),
		   		('值1','值2','值3',...),
		   		...;

例子，插入学生信息：

-- 插入单个学生信息
INSERT INTO `student` (`name`,`pwd`,`sex`) 
	           VALUES ('张三','111111','男');

-- 插入多个学生信息
INSERT INTO `student`(`name`,`pwd`,`sex`)
	           VALUES('李四','222222','男'),
		    	     ('赵二','666666','女'),
		       	     ('王五','888888','男');

查看表：

3.4 修改（update）

语法：

UPDATE 表名 SET COLNUM = VALUE, 
			    COLNUM = VALUE,
			    COLNUM = VALUE,
			    ...
WHERE 条件;

修改单个属性：

UPDATE `student` SET `name` = '失忆' 
WHERE `id` = 1;

如果不指定条件，会改动所有表！不要用！

UPDATE `student` SET `name` = '失忆';

修改多个属性：

UPDATE `student` SET `name` = '失忆',`pwd` =  '987654',`address` = 'shanghai' 
WHERE `id` = 1;

WHERE 后面跟条件，操作符会返回布尔值。
这里懒得画表格了，直接贴上狂神老师的图！

多个条件定位修改对象，无上限：

UPDATE `student` SET `pwd` = '233333' 
WHERE `sex` = '男' AND `name` = '赵二';

注：

• COLNUM 是数据库的列，尽量带上``，防止关键字
• VALUE 可以是一个具体的值，也可以是一个变量（一般变量就用时间，其他用的不多）
• WHERE 是删选条件，如果没有指定，会修改所有的列
• 多个设置的属性之间，使用英文逗号隔开

3.5 删除（delete）

语法：

DELETE FROM 表名 
WHERE 条件; 

清空数据库表：

法一：

DELETE FROM 表名;

不推荐使用！！！

法二：

TRUNCATE 表名;

作用：完全清空一个数据库表，表的结构和索引约束不会变！

• 相同点：都能删除数据，都不会删除表结构
• 不同点：
  ① TRUNCATE 会重新设置自增列（自增列的计数器归零）
  ② TRUNCATE 不会影响事物

四、DQL 查询数据（重点）

4.1 DQL

DQL：Data Query Language（数据查询语言）

• 所有查询操作都用它 Select
• 简单、复杂的查询它都能做
• 数据库最核心的语言，最重要的语句
• 使用频率最高的语句

4.2 指定查询字段（select）

语法：

SELECT 表达式 FROM 表名;

① 查询全部的学生的全部信息：

SELECT * FROM `student`;

结果如下：

② 查询指定字段

SELECT `studentno`,`studentname` FROM `student`;

结果如下：

③ 给结果起别名

SELECT `studentno` AS '学号',`studentname` AS '学生姓名' FROM `student`;

AS 可以省略

SELECT `studentno` 学号,`studentname` 学生姓名 FROM `student`;

结果如下：

④ 函数 CONCAT(a,b)

SELECT CONCAT('学生姓名：',`studentname`) '换个表头' FROM `student`;

结果如下：

⑤ 去重（DISTINCT）

SELECT DISTINCT `studentno` '学生编号' FROM `result`;

结果如下：

⑥ 用 SELECT 查一些好玩的东西

SELECT VERSION();	-- 查询系统版本（函数）
SELECT 100*3-1 '计算结果';	-- 计算（表达式）
SELECT @@AUTO_INCREMENT_INCREMENT;	-- 查询自增步长（变量）

⑦ 操作数据库的列

SELECT `studentno` '学生学号',`studentresult` +1 '提分后' FROM `result`;

结果如下：

数据库的表达式：文本值、列、null、函数、计算表达式、系统变量…

4.3 where 条件子句

作用：检索数据中符合条件的值
搜索的条件由一个或者多个表达式组成！结果为布尔值。
逻辑运算符（图 from 狂神）：

尽量使用英文字母！

① 简单检索

查询成绩在80到100之间

-- AND
SELECT `studentno`学号,`studentresult` 成绩 FROM `result`
WHERE `studentresult` >= 80 AND `studentresult` <= 100;

-- BETWEEN AND
SELECT `studentno`学号,`studentresult` 成绩 FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100;

结果如下：

查询 subjectno 不为2和3的学号、成绩：

SELECT `studentno` 学号,`subjectno` 科目编号,`studentresult` 成绩 FROM `result`
WHERE `subjectno` != 2 AND `subjectno` != 3;

结果如下：

② 模糊查询

模糊查询：本质就是比较运算符

图 from 狂神：

Like 相关的操作：

-- 查询姓王的同学
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `studentname` LIKE '王%';

-- 查询姓王的同学，姓后只有一个字
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `studentname` LIKE '王_';

-- 查询姓王的同学，姓后有两个字
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `studentname` LIKE '王__';

-- 查询名字中带有强的
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `studentname` LIKE '%强%';

IN 相关的操作：
具体的一个或者多个值，不能用%

-- 单属性
SELECT `studentno` 学号,`studentname` 姓名, `address` 地址 FROM `student`
WHERE `address` IN ('广东深圳');

-- 多个属性值
SELECT `studentno` 学号,`studentname` 姓名, `address` 地址 FROM `student`
WHERE `address` IN ('广东深圳','上海浦东');

IS NULL 和 IS NOT NULL：

-- 查询地址为空的学生
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `address`='' OR `address` IS NULL;

-- 查询生日不为空的学生
SELECT `studentno` 学号,`studentname` 姓名 FROM `student`
WHERE `borndate` IS NOT NULL;

4.4 联表查询

LEFTJION、RIGHTJION、INNERJION（图 from 狂神）：

语法：

SELECT 表名.字段名,字段名,字段名
FROM 表名 自定义名字
INNER/LEFT/RIGHT JOIN 表名 自定义名字
ON 两张表的共同字段

注：此处 ON 可以换成 WHERE，但不推荐！

双联表例子：

查询学号（两张表共有）、姓名（仅student）、学生成绩（仅result）

SELECT s.`studentno`,`studentname`,`studentresult`
FROM `student` s
INNER JOIN `result` r
ON s.`studentno` = r.`studentno`

三联表例子：

查询参加考试的同学信息：学号（student，result）、学生姓名（student）、科目名（subject）、分数（result）

SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s 
INNER JOIN `result` r
ON s.`studentno` = r.`studentno`	-- 先链接student和result，公共字段：studentno	
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`	-- 再链接result和subject，公共字段：subjectno

自连接

自连接就是自己的表和自己的表连接。
核心：一张表取两个名字当成两张表即可。

原表（pid = 1表示根节点）：

拆分理解（图 from 狂神）：

例子：

SELECT a.`categoryname` '父栏目',b.`categoryname` '子栏目'
FROM `category` a,`category` b
WHERE b.`pid` = a.`categoryid`;

结果如下：

4.5 分页和排序

① 排序（用的不多，一般用前端去排序）

语法：

ORDER BY 字段名 ASC/DESC

例子：

SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s 
INNER JOIN `result` r
ON s.`studentno` = r.`studentno`
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
ORDER BY `studentresult` ASC 		-- 升序
-- ORDER BY `studentresult` DESC 		-- 降序 

② 分页

语法：

LIMIT 起始下标,页面大小

例子：

SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s 
INNER JOIN `result` r
ON s.`studentno` = r.`studentno`
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
ORDER BY `studentresult` ASC 		-- 升序
LIMIT 0,5

结果如下：

简单思考题：查询 C语言-1 课程成绩排名前三的学生，且分数要大于70的学生信息，按成绩升序排列（学号，姓名，课程名称，分数）

SELECT sn.`studentno` '学号',`studentname` '学生姓名',`subjectname` '课程名称',`studentresult` '分数'
FROM `student` sn
INNER JOIN `result` r
ON sn.`studentno` = r.`studentno`	-- 链接result和student表
INNER JOIN `subject` sub
ON sub.`subjectno` = r.`subjectno`	-- 再链接上result表
WHERE `subjectname` = 'C语言-1' AND `studentresult` > 70
ORDER BY `studentresult` ASC
LIMIT 0,3;

结果如下：

4.6 子查询

WHERE（这个值是计算出来的）
WHERE ( SELECT * FROM )
本质：在 WHERE 中嵌套一个子查询语句

例：查询高等数学-2的所有考试结果（学号，科目编号，成绩），降序排列

法一：

SELECT `studentno` '学号',r.`subjectno` '科目编号',`studentresult`'成绩'
FROM `result` r
INNER JOIN `subject` sub
ON sub.`subjectno` = r.`subjectno`
WHERE `subjectname` = '高等数学-2'
ORDER BY `studentresult` DESC;

法二（使用嵌套）：

SELECT `studentno` '学号',`subjectno` '科目编号',`studentresult`'成绩'
FROM `result` 
WHERE `subjectno` = (
	SELECT `subjectno` 
	FROM `subject`
	WHERE `subjectname` =  '高等数学-2'
)
ORDER BY `studentresult` DESC

4.7 分组和过滤

例：查询不同课程的平均分、最高分、最低分，平均分大于80

SELECT `subjectname`,AVG(`studentresult`) '平均分',MAX(`studentresult`) '最高分',MIN(`studentresult`) '最低分'
FROM `result` r
INNER JOIN `subject` sub
WHERE r.`subjectno` = sub.`subjectno`
GROUP BY `subjectname`
HAVING 平均分>80;

五、函数

5.1 常用函数

太多了不写了，常用函数不常用。需要的时候去 API 文档查即可。

5.2 聚合函数

count 系列：

SELECT COUNT(`borndate`) FROM `student`;	-- 会忽略所有的null值
SELECT COUNT(*) FROM `student`;		-- 不会忽略null值，本质：计算行数
SELECT COUNT(1) FROM `student`;		-- 不会忽略null值，本质：计算行数，但指定列而非主键，比COUNT(*)快

总和、平均值、最大值、最小值：

SELECT SUM(`studentresult`) '总分' FROM `result`;
SELECT AVG(`studentresult`) '总分' FROM `result`;
SELECT MAX(`studentresult`) '总分' FROM `result`;
SELECT MIN(`studentresult`) '总分' FROM `result`;

5.3 数据库级别的 MD5 摘要（扩展）

什么是 MD5？
主要增强算法复杂度和不可逆性。
MD5 不可逆，具体的值的 MD5 是一样的。

懒得敲代码了， 继续贴图（图 from 狂神）：

5.4 SELECT 小结

老规矩直接贴图（图 from 狂神）：

六、事物

6.1 什么是事物

事物就是一组 SQL 要么都成功，要么都失败！

核心：将一组 SQL 放在一个批次中去执行！

事物原则：ACID
A：Atomicity 原子性：要么都成功，要么都失败。
C：Consistency 一致性：事物前后的数据完整性要保证一致。
I：Isolation 隔离性：多个用户访问数据库时，数据库为每一个用户开启的事物，不能被其他事物的操作所干预。
D：Durability持久性：事物一旦提交则不可逆，被持久化到数据库中。

脏读： 指一个事物读取了另外一个事物未提交的数据。

不可重复读： 在一个事物内读取表中的某一行数据，多次读取结果不同。

虚读（幻读）： 在一个事物内读取到了别的事物插入的数据，导致前后读取不一致。

6.2 执行事务

执行事务的流程（图 from 狂神）：

代码理解：

-- MySQL中是默认开启事物自动提交的
SET autocommit = 0	-- 关闭
SET autocommit = 1	-- 开启，默认是开启的

-- 手动处理事务
SET autocommit = 0	-- 先关闭自动提交

-- 事物开启
START TRANSACTION	-- 标记一个事物的开始，从这之后的sql都在一个事物内

-- 提交：持久化（成功！）
COMMIT

-- 回滚：回到原来的样子（失败！）
ROLLBACK

-- 事物结束
SET autocommit = 1	-- 开启自动提交



-- 了解即可
SAVEPOINT 保存点名	-- 设置一个事物的保存点
ROLLBACK TO SAVEPOINT 保存点名 	-- 回滚到保存点	
RELEASE SAVEPOINT 保存点名	-- 撤销保存点

案例：模拟转账

-- 模拟转账
SET autocommit = 0;	-- 关闭自动提交

START TRANSACTION	-- 开启一个事物
UPDATE `account` SET `money` = `money` - 500 WHERE `name`='A'	-- A转出500
UPDATE `account` SET `money` = `money` + 500 WHERE `name`='B'	-- B转入500

COMMIT;		-- 提交
ROLLBACK;	-- 回滚

SET autocommit = 1;	-- 开启自动提交

初始表：

执行完事物后：

执行回滚后（与初始状态一致）：

若选择提交，则数据被持久化！无法恢复原来的值！

最后一定要恢复自动提交！

七、索引

MySQL 官方对索引的定义为：索引（Index）是帮助 MySQL高效获取数据的数据结构。
索引的本质就是数据结构。

7.1 索引的分类

• 主键索引（PRIMARY KEY）：唯一的表示，主键不可重复，只能有一个列作为主键。
• 唯一索引（UNIQUE KEY）：避免重复的列出现（列中的数据不能相同），一个表中可以有多个唯一索引。
• 常规索引（KEY/INDEX）：默认的
• 全文索引（FULLTEXT）：在特定的数据库引擎下才有

基础语法：

-- 显示所有的索引信息
SHOW INDEX FROM `student`;

-- 增加一个全文索引
ALTER TABLE `student` ADD FULLTEXT INDEX `phone`(`phone`);

-- EXPLAIN 分析sql执行的情况
EXPLAIN SELECT * FROM `student` ;	-- 非全文索引
EXPLAIN SELECT * FROM `student` WHERE MATCH(`phone`) AGAINST('13');

最后一个有亿点点懵，先学下去吧。

7.2 索引原则

• 索引不是越多越好
• 不要对经常变动的数据加索引
• 小数据量的表不需要加索引
• 索引一般加在常用来查询的字段上

Hash 类型的索引
Btree：InnoDB 的默认数据结构

狂神推荐文章：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

八、权限管理和备份

8.1 用户管理

sqlyog 的可视化管理：

sql 命令操作

本质：对用户表（mysql.user）进行增删改查

-- 创建用户  CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER GlassMaple IDENTIFIED BY '123456'

-- 修改密码  ALTER USER 用户名 IDENTIFIED BY '新密码';
ALTER USER GlassMaple IDENTIFIED BY '111111';

-- 重命名  RENAME USER 用户名 TO 新用户名
RENAME USER GlassMaple TO GlassMaple1

-- 授权（除了GRANT权限）  GRANT 权限名 ON 库.表 TO 用户名
GRANT ALL PRIVILEGES ON *.* TO GlassMaple1

-- 权限查询  SHOW GRANTS FOR 用户名
SHOW GRANTS FOR GlassMaple1

-- 撤销权限  REVOKE 权限名 ON 库.表 FROM 用户名
REVOKE ALL PRIVILEGES ON *.* FROM GlassMaple1

-- 删除用户
DROP USER GlassMaple1

8.2 MySQL备份

为什么要备份？

• 保证重要数据不丢失
• 数据转移

MySQL 数据库备份的方式

• 直接拷贝物理文件

• 在 sqlyog 这种可视化工具中手动导出
  

• 使用命令行导出 mysqldump（不写了！反正也记不住，用的时候查就行了）

九、规范数据库设计

9.1 为什么需要设计数据库

当数据库较为复杂时，我们就需要设计了。

糟糕的数据库设计：

• 数据冗余，浪费空间
• 数据库插入和删除都很麻烦，会出现异常（所以要屏蔽使用物理外键）
• 程序性能差

良好的数据库设计：

• 节省内存空间
• 保证数据库的完整性
• 方便我们开发系统

软件开发中，关于数据库的设计

• 分析需求：分析业务和需要处理的数据库需求
• 概要设计：设计实体-联系图（E-R图）

设计数据库的步骤（个人博客）：

• 收集信息，分析需求：用户表、分类表、文章表、评论表、自定义表…
• 标识实体（把需求落实到每个字段）
• 标识实体之间的关系：写博客 user->blog、创建分类 user->catalog、关注user->user、评论user->user->blog

9.2 三大范式

为什么需要数据规范化？

• 信息重复
• 信息异常
• 插入异常：无法正常显示信息
• 删除异常丢失有效的信息

三大范式

第一范式（1NF）：具有原子性，保证每一列不可再分
第二范式（2NF）：满足第一范式的前提下，消除非主属性对主码（也叫主键、主关键字）的部分函数依赖。也就是说，表中的每一列都要与主键有关，而不能只和主键的一部分有关，这主要是针对联合主键而言。
第三范式（3NF）：满足第二范式的前提下，确保数据表中的每一列都和主键直接相关，而不能间接相关。

规范性与性能的问题
关联查询的表不能超过三张

• 考虑商业化的需求和目标（成本、用户体验），数据库的性能更重要！
• 在处理性能的问题的时候，需要适当地考虑规范性！
• 为了提高用户体验，有时会降低性能，故意给表增加一些冗余的字段，从多表查询变为单表查询。
• 或者故意增加一些计算列，从大数据量降低为小数据量的查询；或增加索引。

十、JDBC

10.1 数据库驱动

驱动：声卡、显卡、数据库

图 from 狂神：

我们的程序会通过数据库驱动，和数据库打交道。

10.2 JDBC

SUN 公司为了简化开发人员对数据库的统一操作，提供了一个Java操作数据库的规范——JDBC。
这些规范的实现由具体的厂商去做。
对于开发人员来说，我们只需要掌握 JDBC 接口的操作即可！

图 from 狂神：

需要的包：java.sql、javax.sql，还有一个数据库驱动包：mysql-connector-java-8.0.28.jar

10.3 第一个JDBC程序

创建测试数据库：

CREATE DATABASE `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci;

USE `jdbcStudy`;

CREATE TABLE `users`(
	`id` INT PRIMARY KEY,
	`NAME` VARCHAR(40),
	`PASSWORD` VARCHAR(40),
	`email` VARCHAR(60),
	birthday DATE
);

INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)
	     VALUES('1','zhangsan','123456','zs@sina.com','1980-12-04'),
		   ('2','lisi','123456','lisi@sina.com','1981-12-04'),
		   ('3','wangwu','123456','wangwu@sina.com','1979-12-04');

1. 创建一个普通项目
2. 导入数据库驱动
   新建一个 lib Dictionary，把 jar 包拷贝进来
   
3. 编写测试代码

import java.sql.*;

//我的第一个JDBC程序
public class Main {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");  //MySql8.0以上版本特有写法

        //2.用户信息和url 支持中文编码 编码格式为utf-8 安全连接（8.0以上写true会报错）
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true & characterEncoding=utf8 & useSSL = false";
        String name = "root";
        String password = "123456";

        //3.连接成功，返回数据库对象
        Connection connection = DriverManager.getConnection(url, name, password);

        //4.通过连接定义执行SQL对象
        Statement statement = connection.createStatement();

        //5.通过执行SQL的对象去执行SQL，可能存在结果，要查看
        ResultSet resultSet = statement.executeQuery("SELECT * FROM `users`");

        while (resultSet.next()){
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("NAME"));
            System.out.println("password=" + resultSet.getObject("PASSWORD"));
            System.out.println("email=" + resultSet.getObject("email"));
            System.out.println("birth=" + resultSet.getObject("birthday"));
            System.out.println("========================================");
        }

        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

注：

URL：MySQL 默认端口号3306

	协议://主机地址:端口号/数据库名?参数1 & 参数2 & 参数3

Connection：连接

	connection.rollback();  //回滚
    connection.commit();    //提交
    connection.setAutoCommit();	//自动提交

Statement：执行 SQL 的对象
PrepareStatement：执行 SQL 的对象
两者的区别后续再学习

        statement.executeQuery();   //查询操作，返回ResultSet
        statement.executeUpdate();  //增删改，返回受影响的行数
        statement.execute();    //执行任何SQL

ResultSet：查询的结果集，封装了所有的查询结果

获得指定的数据类型，如果不知道列的类型就使用 getObject()

        resultSet.getObject();
        resultSet.getInt();
        resultSet.getFloat();
        resultSet.getDate();
        resultSet.getString();

遍历（本质就是个链表）：

        resultSet.next();           //移动到下一个数据
        resultSet.beforeFirst();    //移动到最前面
        resultSet.afterLast();      //移动到最后面
        resultSet.previous();       //移动到前一行
        resultSet.absolute(row);    //移动到指定行

释放资源

        resultSet.close();
        statement.close();
        connection.close();		//好资源，用完就关掉！

10.4 Statement 对象

JDBC 的 statement 对象用于向数据库发送 SQL 语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送对应的语句即可。

两个方法：executeUpdate()、executeQuery()

executeUpdate()：增、删、改

        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeUpdate("增删改的SQL语句");
        int num = statement.executeUpdate("SELECT * FROM `users`");
        if (num > 0){
            System.out.println("插入成功");
        }

executeQuery()：查

       Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("查询的SQL语句");
        while (resultSet.next()){
            //根据列的数据类型，分别调用rs的相应方法映射到java对象中
        }

① 提取工具类

src 目录下建一个文件，命名为 db.properties

driver = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true & characterEncoding=utf8 & useSSL=false
username = root
password = 123456

建一个 名为JDBCUtils 的 java 程序：

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;


    static {
        try {
            InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.驱动只用加载一次
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //释放连接资源
    public static void release(Connection connection, Statement st, ResultSet rs){
        if (rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null){
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

② 编写增删改方法：executeUpdate()
增：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestInsert {
    public static void main(String[] args) {

        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();     //获取数据库连接
            statement = connection.createStatement();
            String sql = "INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)VALUES(5,'GlassMaple','123456','123456@qq.com','2000-1-1')";

            int i = statement.executeUpdate(sql);
            if (i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }

    }
}

删：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestDelete {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();     //获取数据库连接
            statement = connection.createStatement();
            String sql = "DELETE FROM `users`WHERE `id`=5";

            int i = statement.executeUpdate(sql);
            if (i>0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }
    }
}

改：

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestUpdate {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();     //获取数据库连接
            statement = connection.createStatement();
            String sql = "UPDATE `users` SET `NAME` = 'zhaoer',`PASSWORD` = '111111',`birthday` = '1985-10-6'";

            int i = statement.executeUpdate(sql);
            if (i>0){
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }
    }
}

③ 编写查询方法：executeQuery()

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestSelect {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select * from users where id = 1";
            resultSet = statement.executeQuery(sql);
            while (resultSet.next()){
                System.out.println(resultSet.getString("NAME"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }
    }
}

SQL 注入问题：SQL 存在漏洞，会被攻击导致数据泄露！SQL 会被拼接 or

正常业务登录：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SQL注入 {
    public static void main(String[] args) {
        login("zhaoer","111111");
    }
    //登录业务
    public static void login(String username,String password){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select * from users where `NAME`='" + username + "' AND `password` ='" + password + "'";
            resultSet = statement.executeQuery(sql);
            while (resultSet.next()){
                System.out.println(resultSet.getString("NAME"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }

    }
}

密码正确，输出结果：

zhaoer

若密码错误，则输出为空。

但稍微修改一下代码，重点是主函数的那句！

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SQL注入 {
    public static void main(String[] args) {
        login(" 'or '1=1"," 'or '1=1");
    }
    //登录业务
    public static void login(String username,String password){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select * from users where `NAME`='" + username + "' AND `password` ='" + password + "'";
            resultSet = statement.executeQuery(sql);
            while (resultSet.next()){
                System.out.println(resultSet.getString("NAME"));
                System.out.println("==============================");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,statement,resultSet);
        }

    }
}

输出结果：

zhangsan
==============================
zhaoer
==============================
wangwu
==============================

重点：

	login(" 'or '1=1"," 'or '1=1");

’ ’ 为拼接字符串，这里是一个空 or 1=1（永真），结果一定为真。所以所有信息都被取了出来。

10.5 PreparedStatement 对象

与 Statement 对象最本质的区别：可以防止 SQL 注入，并且效率更高。

PreparedStatement 防止 SQL 注入的本质：把传递进来的参数当作字符。假设其中存在转义字符，就直接忽略！

增：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.*;

public class TestInsert {

    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)VALUES(?,?,?,?,?)"; //使用？占位符代替参数
            preparedStatement = connection.prepareStatement(sql);  //预编译SQL，先写SQL，但不执行
            //手动给id赋值，其实就是给？赋值
            preparedStatement.setInt(1,4);  //下标从1开始
            preparedStatement.setString(2,"GlassMaple");
            preparedStatement.setString(3,"987654");
            preparedStatement.setString(4,"23333333@qq.com");
            preparedStatement.setDate(5,new java.sql.Date(new java.util.Date().getTime())); //new java.util.Date().getTime()：获得时间戳

            //执行
            int i = preparedStatement.executeUpdate();
            if (i>0)
                System.out.println("插入成功");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

删：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestDelete {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "delete from users where id =?"; //使用？占位符代替参数
            preparedStatement = connection.prepareStatement(sql);  //预编译SQL，先写SQL，但不执行
            //手动给id赋值，其实就是给？赋值
            preparedStatement.setInt(1,4);  //下标从1开始

            //执行
            int i = preparedStatement.executeUpdate();
            if (i>0)
                System.out.println("删除成功");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

改：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestUpdate {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();

            //区别
            String sql = "update users set PASSWORD = ? where id = 2"; //使用？占位符代替参数
            preparedStatement = connection.prepareStatement(sql);  //预编译SQL，先写SQL，但不执行
            //手动给id赋值
            preparedStatement.setString(1,"555555");  //下标从1开始
            //执行
            int i = preparedStatement.executeUpdate();
            if (i>0)
                System.out.println("修改成功");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

查：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestSelect {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement("select * from users where id = ?");
            preparedStatement.setInt(1,1);
            //执行
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()){
                System.out.println(resultSet.getString("NAME"));
                System.out.println(resultSet.getString("password"));
                System.out.println(resultSet.getString("email"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

☆ 修改 10.4 中的业务登录程序：

import com.GlassMaple.lesson02.utils.JDBCUtils;

import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
        login("zhaoer","555555");
    }
    //登录业务
    public static void login(String username,String password){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement("select * from users where `NAME`=? AND `password`=?");
            preparedStatement.setString(1,username);
            preparedStatement.setString(2,password);
            //执行
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()){
                System.out.println(resultSet.getString("NAME"));
                System.out.println(resultSet.getString("email"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

10.6 使用 IDEA 连接数据库

连接成功后，选择数据库：

查看表信息：

修改完信息之后记得点 DB 保存！

编写写 sql 的地方：

10.7 数据库连接池

数据库连接 -> 执行完毕 -> 释放
连接 -> 释放十分浪费系统资源

池化技术：准备一些预先的资源，过来就连接预先准备好的。

通过常用连接数设定最小连接数。
最大连接数：业务最高承载上限，超出的部分等待 -> 等待超时。

编写连接池，只需要实现接口 DataSource

开源数据源：DBCP、C3P0、Druid 等。使用了这些数据库连接池后，我们在项目开发中就不需要编写连接数据库的代码了。

需要用到的 jar 包：commons-dbcp-1.4、commons-pool-1.6

其实就是用库，问题不大！后续的SSM学习中还会遇到的！