后端开发学习记录（二）——MySQL的学习
2022/6/29 2:22:45
本文主要是介绍后端开发学习记录（二）——MySQL的学习，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
MySQL
一、什么是数据库
- 数据库：（DB，DataBase）
- 概念：数据仓库，安装在操作系统之上（windows，linux，mac...）之上
- 作用：储存数据，管理数据
二、数据库的分类
关系型数据库：MySQL，Oracle，Sql Server，DB2，SQLlite
非关系型数据库：对象存储，通过对象的自身属性来决定
NoSQL（not only）不仅仅是SQL
DBMS（数据库管理系统）
- 数据库的管理软件，科学有效的管理，维护和获取数据
- MySQL 是数据库的管理系统
- MySQL的定义：
- MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。
- MySQL是一种关系型数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
- MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择 MySQL 作为网站数据库。
- MySQL官网：https://www.mysql.com/
- MySQL超详细教学：https://www.bilibili.com/video/BV1NJ411J79W?p=3&spm_id_from=pageDriver
★数据库的操作
一、数据库的连接
打开cmd控制命令，以管理员的身份运行，输入：
mysql -uroot -p
123456 -- 连接数据库
update user set password=password('123456')where user='root'; 修改密码
flush privileges; 刷新数据库
show databases; 显示所有数据库
use dbname；打开某个数据库
show tables; 显示数据库mysql中所有的表
describe user; 显示表mysql数据库中user表的列信息
create database name; 创建数据库
use databasename; 选择数据库
exit; 退出Mysql
? 命令关键词 : 寻求帮助
-- 表示注释（SQL本来的注释）
/*SQL的多行注释*/
二、操作数据库
操作数据库->操作数据库中的表->操作数据库中表的数据
1. 操作数据库
Ⅰ.创建数据库
CREATE DATABASE [IF NOT EXISTS] westos []代表可选的！！！
Ⅱ.删除数据库
DROP DATABASE [IF EXISTS] westos
Ⅲ.使用数据库
USE school
Ⅳ.查看数据库
SHOW DATABASE
2. 操作数据库中的表
3. 操作数据库中表的数据
三、数据库的列类型
数值
- tinyint 十分小的数据 1个字节
- smallint 较小的数据 2个字节
- int 标准的整数 4个字节
- bigint 较大的数据 8个字节
- float 浮点数 4个字节
- double 浮点数 8个字节
- decimal 字符串形式的浮点数，金融计算的时候用
字符串
- char 字符串固定的大小 0~255
- varchar 可变字符串 0~65525 常用的变量 String
- tinytext 微型文本 2^8-1
- text 文本串 2^16-1 保存大型文本
时间日期
- date YYYY-MM-DD，日期格式
- time HH；mm；ss，时间格式
- year 年份表示
- datatime YYYY-MM-DD HH；mm；ss 最常用的时间格式
- timestamp 时间戳 1971.1.1到现在的毫秒数
null
- 没有值
- 注意，不能用null进行计算，结果仍为null
四、数据库的字段属性
UnSigned
-
无符号的整数
-
声明该数据列不允许负数 .
ZEROFILL
-
0填充的
-
不足位数的用0来填充 , 如int(3), 5则为005
Auto_InCrement（自增）
-
自动增长的 , 每添加一条数据 , 自动在上一个记录数上加 1(默认)
-
通常用于设置主键（index） , 且为整数类型
-
可定义起始值和步长
-
当前表设置步长(AUTO_INCREMENT=100) : 只影响当前表
-
SET @@auto_increment_increment=5 ; 影响所有使用自增的表(全局)
NULL 和 NOT NULL
- 默认为NULL , 即没有插入该列的数值
- 如果设置为NOT NULL , 则该列必须有值
DEFAULT - 默认的
- 用于设置默认值
- 例如,性别字段,默认为"男" , 否则为 "女" ; 若无指定该列的值 , 则默认值为"男"的值
InnoDB与charset是建立一个表的基本操作
ENGINE=InnoDB不是默认就是这个引擎吗？
——是的，如果不写也是ok,就会走默认的，在这里写上是因为可以很清楚的看到这个建表语句用了哪些，而且在创建表的时候，写上也是一个很好的习惯
utf8不是已经在my.ini里设置过了?
——这个虽然在my.ini设置过了，但设置的是mysql的的语言编码，而这里创建的时候不设置，就会出现乱码问题，二者的作用域是不一样的，在创建表单的时候，这个charset会作用到这个表上，他代表mysql建立数据库数据表时设定字符集为utf-8
每一个表都必须存在以下5个字段！
- id主键
- version 乐观锁
- is_delete 伪删除
- gmt_create 创建时间
- gmt_update 修改时间
五、创建数据库的表
CREATE TABLE IF NOT EXISTS `student` ( `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号', `name` VARCHAR(30) 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
- 格式
CREATE TABLE [IF NOT EXISTS] `表名`( '字段名' 列类型 [属性] [索引] [注释], '字段名' 列类型 [属性] [索引] [注释], ... '字段名' 列类型 [属性] [索引] [注释] )[表类型][字符集设置][注释]
- 常用命令
-- 查看数据库的定义 SHOW CREATE DATABASE school; -- 查看student数据表的定义语句 SHOW CREATE TABLE student; -- 显示表结构 DESC student; -- 显示表的结构
3.数据表的类型
| 名称 | MYISAM | INNODB |
|---|---|---|
| 事务处理 | 不支持 | 支持 |
| 数据行锁定 | 不支持 | 支持 |
| 外键约束 | 不支持 | 支持 |
| 全文索引 | 支持 | 不支持 |
| 表空间大小 | 较小 | 较大，约2倍 |
- 适用场合 :
-
适用 MyISAM : 节约空间及相应速度
-
适用 InnoDB : 安全性 , 事务处理及多用户操作数据表
- 在物理空间存在的位置
** 在所有的数据库文件都存在data目录下 **
MySQL引擎在物理文件上的区别
- InnoDB在数据库表中只有一个*.frm文件，以及上级目录下的ibdata1文件
MYISAM对应文件 - *.frm 表结构的定义文件
- *MYD 数据文件（data）
- *MYI 索引文件
设置数据库表的字符集编码
CHARSET = utf8;
不设置的话，会是mysql默认的字符集编码~（不支持中文！！！）
我们可为数据库,数据表,数据列设定不同的字符集，设定方法 :
- 创建时通过命令来设置 , 如 : CREATE TABLE 表名()CHARSET = utf8;
- 如无设定 , 则根据MySQL数据库配置文件 my.ini 中的参数设定
六、修改删除表
修改( ALTER TABLE )
修改表名 :ALTER TABLE （旧表名） RENAME AS （新表名）
ALTER TABLE teacher RENAME AS teacher1
添加字段 : ALTER TABLE （表名） ADD（字段名） 列属性[属性]
ALTER TABLE teacher ADD age INT(11)
修改字段 :ALTER TABLE （表名） MODIFY （字段名）列类型[属性] (修改约束)
ALTER TABLE teacher1 MODIFY age varchar(11)
ALTER TABLE （表名） CHANGE （旧字段名）（ 新字段名） 列属性[属性]
ALTER TABLE teacher1 CHANGE age agel INT(1)
删除字段 : ALTER TABLE 表名 DROP 字段名
ALTER TABLE teacher1 DROP age1
删除
语法：DROP TABLE [IF EXISTS] 表名
DROP TABLE IF EXISTS teacher1
-
IF EXISTS为可选 , 判断是否存在该数据表
-
如删除不存在的数据表会抛出错误
★MySQL数据管理
一、外键
-
外键的概念：如果公共关键字在一个关系中是主关键字，那么这个公共关键字被称为另一个关系的外键。由此可见，外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的表被称为主表，具有此外键的表被称为主表的从表。
在实际操作中，将一个表的值放入第二个表来表示关联，所使用的值是第一个表的主键值(在必要时可包括复合主键值)。此时，第二个表中保存这些值的属性称为外键(foreign key)。
-
外键作用：
保持数据一致性，完整性，主要目的是控制存储在外键表中的数据,约束。使两张表形成关联，外键只能引用外表中的列的值或使用空值。 -
创建表时指定的外键约束
删除有外键关系的表的时候，必须先删除引用别人的表，再删除主表
-- 创建外键的方式一 : 创建子表同时创建外键 -- 年级表 (id\年级名称) CREATE TABLE `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(30) 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`), KEY `FK_gradeid` (`gradeid`), CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`) ) ENGINE=INNODB DEFAULT CHARSET=utf8
-- 创建外键方式二 : 创建子表完毕后,修改子表添加外键 ALTER TABLE `student` ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`);
二、DML语言
数据库意义 ： 数据存储、数据管理
管理数据库数据方法：
-
通过SQLyog等管理工具管理数据库数据
-
通过DML语句管理数据库数据
DML语言 ：数据操作语言
-
用于操作数据库对象中所包含的数据
-
包括 :
1. INSERT (添加数据语句)
INSERT命令
语法：
INSERT INTO 表名[(字段1,字段2,字段3,...)] VALUES('值1','值2','值3')
-- 使用语句如何增加语句?
-- 语法 : INSERT INTO 表名[(字段1,字段2,字段3,...)] VALUES(('值1'),('值2'),('值3')......)
INSERT INTO `grade`(`gradename`) VALUES ('大一');
-- 主键自增,那能否省略呢?
INSERT INTO `grade` VALUES ('大二');
-- 查询:INSERT INTO grade VALUE ('大二')错误代码：1136
Column count doesn`t match value count at row 1
-- 结论:'字段1,字段2...'该部分可省略 , 但添加的值务必与表结构,数据列,顺序相对应,且数量一致.
-- 一次插入多条数据
INSERT INTO `grade`(`gradename`) VALUES ('大三'),('大四');
注意 :
- 字段或值之间用英文逗号隔开 .
- ' 字段1,字段2...' 该部分可省略 , 但添加的值务必与表结构,数据列,顺序相对应,且数量一致
- 可同时插入多条数据 , values 后用英文逗号隔开
2. UPDATE (更新数据语句)
UPDATE命令
语法：
UPDATE `表名` SET `column_name`=value [,column_name2=value2,...] [WHERE `condition`];
UPDATE `a` SET `id`='远辉' WHERE id = 1;
注意 :
-
column_name 为要更改的数据列
-
value 为修改后的数据 , 可以为变量 , 具体指 , 表达式或者嵌套的SELECT结果
UPDATE `student` SET `name` = '长江七号' WHERE `name`= '远辉' AND sex='女'
-
condition 为筛选条件 , 如不指定则修改该表的所有列数据
where条件子句 运算符id 等于某个值，大于某个值，在某个区间内修改
| 运算符 | 含义 | 范围 | 结果 |
|---|---|---|---|
| = | 等于 | 5=6 | false |
| <>或! = | 不等于 | 5！=6 | true |
| > | 大于 | 5>6 | false |
| >= | 大于等于 | 5>=6 | false |
| <= | 小于等于 | 5<=6 | true |
| BETWEEN | 在某个范围之间 | BETWEEN5 AND 10 | |
| AND | 并且 | 5>1 AND 1>2 && | false |
| OR | 或 | 5>1 OR 1>2 || | true |
3. DELETE (删除数据语句)
>DELETE命令 语法：
DELETE FROM 表名 [WHERE condition];
删除数据（避免这样写，会全部删除） DELETE FROM 'student'; 删除指定数据（删除指定数据） DELETE FROM 'student' WHERE id = 1;
注意 :
- condition为筛选条件 , 如不指定则删除该表的所有列数据
TRUNCATE命令
作用：用于完全清空表数据 , 但表结构 , 索引 , 约束等不变
TRUNCATE [TABLE] table_name; -- 清空年级表 TRUNCATE grade
注意 :区别于DELETE命令
- 相同 : 都能删除数据 , 不删除表结构 , 但TRUNCATE速度更快
- 不同 :
使用TRUNCATE TABLE 重新设置AUTO_INCREMENT计数器
使用TRUNCATE TABLE不会对事务有影响 （事务后面会说）
测试
-- 创建一个测试表
CREATE TABLE `test` (
`id` INT(4) NOT NULL AUTO_INCREMENT,
`coll` VARCHAR(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
-- 插入几个测试数据
INSERT INTO `test`(`coll`) VALUES('1'),('2'),('3');
-- 删除表数据(不会影响自增)
DELETE FROM `test`;
-- 结论:如不指定Where则删除该表的所有列数据,自增当前值依然从原来基础上进行,会记录日志.
-- 删除表数据(truncate)
TRUNCATE TABLE `test`;
-- 结论:truncate删除数据,自增当前值会恢复到初始值重新开始;不会记录日志.
-- 同样使用DELETE清空不同引擎的数据库表数据.重启数据库服务后
-- InnoDB : 自增列从初始值重新开始 (因为是存储在内存中,断电即失)
-- MyISAM : 自增列依然从上一个自增数据基础上开始 (存在文件中,不会丢失)
★★★DQL查询数据（重点）
DQL( Data Query Language 数据查询语言 )
-
查询数据库数据 , 如SELECT语句
-
简单的单表查询或多表的复杂查询和嵌套查询
-
是数据库语言中最核心,最重要的语句
-
使用频率最高的语句
测试数据：
CREATE DATABASE IF NOT EXISTS `school01`;
-- 创建一个school数据库
USE `school01`;-- 创建学生表
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`loginpwd` VARCHAR(20) DEFAULT NULL,
`studentname` VARCHAR(20) DEFAULT NULL COMMENT '学生姓名',
`sex` TINYINT(1) DEFAULT NULL COMMENT '性别，0或1',
`gradeid` INT(11) DEFAULT NULL COMMENT '年级编号',
`phone` VARCHAR(50) NOT NULL COMMENT '联系电话，允许为空',
`address` VARCHAR(255) NOT NULL COMMENT '地址，允许为空',
`borndate` DATETIME DEFAULT NULL COMMENT '出生时间',
`email` VARCHAR (50) NOT NULL COMMENT '邮箱账号允许为空',
`identitycard` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',
PRIMARY KEY (`studentno`),
UNIQUE KEY `identitycard`(`identitycard`),
KEY `email` (`email`)
)ENGINE=MYISAM DEFAULT CHARSET=utf8;
-- 创建年级表
DROP TABLE IF EXISTS `grade01`;
CREATE TABLE `grade`(
`gradeid` INT(11) NOT NULL AUTO_INCREMENT COMMENT '年级编号',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
) ENGINE=INNODB AUTO_INCREMENT = 6 DEFAULT CHARSET = utf8;
-- 创建科目表
DROP TABLE IF EXISTS `subject01`;
CREATE TABLE `subject`(
`subjectno`INT(11) NOT NULL AUTO_INCREMENT COMMENT '课程编号',
`subjectname` VARCHAR(50) DEFAULT NULL COMMENT '课程名称',
`classhour` INT(4) DEFAULT NULL COMMENT '学时',
`gradeid` INT(4) DEFAULT NULL COMMENT '年级编号',
PRIMARY KEY (`subjectno`)
)ENGINE = INNODB AUTO_INCREMENT = 19 DEFAULT CHARSET = utf8;
-- 创建成绩表
DROP TABLE IF EXISTS `result01`;
CREATE TABLE `result`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`subjectno` INT(4) NOT NULL COMMENT '课程编号',
`examdate` DATETIME NOT NULL COMMENT '考试日期',
`studentresult` INT (4) NOT NULL COMMENT '考试成绩',
KEY `subjectno` (`subjectno`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;
-- 插入学生数据 其余自行添加 这里只添加了2行
INSERT INTO `student` (`studentno`,`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)
VALUES
(1000,'123456','张伟',0,2,'13800001234','北京朝阳','1980-1-1','text123@qq.com','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','text111@qq.com','123456199001011233');
-- 插入成绩数据 这里仅插入了一组，其余自行添加
INSERT INTO `result`(`studentno`,`subjectno`,`examdate`,`studentresult`)
VALUES
(1000,1,'2013-11-11 16:00:00',85),
(1000,2,'2013-11-12 16:00:00',70),
(1000,3,'2013-11-11 09:00:00',68),
(1000,4,'2013-11-13 16:00:00',98),
(1000,5,'2013-11-14 16:00:00',58);
-- 插入年级数据
INSERT INTO `grade` (`gradeid`,`gradename`) VALUES(1,'大一'),(2,'大二'),(3,'大三'),(4,'大四'),(5,'预科班');
-- 插入科目数据
INSERT INTO `subject`(`subjectno`,`subjectname`,`classhour`,`gradeid`)VALUES
(1,'高等数学-1',110,1),
(2,'高等数学-2',110,2),
(3,'高等数学-3',100,3),
(4,'高等数学-4',130,4),
(5,'C语言-1',110,1),
(6,'C语言-2',110,2),
(7,'C语言-3',100,3),
(8,'C语言-4',130,4),
(9,'Java程序设计-1',110,1),
(10,'Java程序设计-2',110,2),
(11,'Java程序设计-3',100,3),
(12,'Java程序设计-4',130,4),
(13,'数据库结构-1',110,1),
(14,'数据库结构-2',110,2),
(15,'数据库结构-3',100,3),
(16,'数据库结构-4',130,4),
(17,'C#基础',130,1);
Ⅰ.SELECT语法
SELECT [ALL | DISTINCT]
{* | table.* | [table.field1[as alias1][,table.field2[as alias2]][,...]]}
FROM table_name [as table_alias]
[left | right | inner join table_name2] -- 联合查询
[WHERE ...] -- 指定结果需满足的条件
[GROUP BY ...] -- 指定结果按照哪几个字段来分组
[HAVING] -- 过滤分组的记录必须满足的次要条件
[ORDER BY ...] -- 指定查询记录按一个或多个条件排序
[LIMIT {[offset,]row_count | row_countOFFSET offset}];
-- 指定查询的记录从哪条至哪条
-- 注意 : [ ] 括号代表可选的 , { }括号代表必选得
指定查询字段
-- 查询表中所有的数据列结果 , 采用 **" \* "** 符号; 但是效率低，不推荐 . -- 查询所有学生信息 SELECT * FROM student; -- 查询指定列(学号 , 姓名) SELECT studentno,studentname FROM student;
AS 子句作为别名
作用
-
可给数据列取一个新别名
-
可给表取一个新别名
-
可把经计算或总结的结果用另一个新名称来代替
-- 这里是为列取别名(当然as关键词可以省略)
SELECT studentno AS 学号,studentname AS 姓名 FROM student;
-- 使用as也可以为表取别名
SELECT studentno AS 学号,studentname AS 姓名 FROM student AS s;
-- 使用as,为查询结果取一个新名字
-- CONCAT()函数拼接字符串
SELECT CONCAT('姓名:',studentname) AS 新姓名 FROM student;
Ⅱ.去重(DISTINCT)
DISTINCT关键字的使用
SELECT * FROM SUBJECT; -- 查看考试成绩 SELECT `subjectno` FROM SUBJECT; -- 查看哪些同学参加了考试 SELECT DISTINCT `subjectno` FROM SUBJECT; -- 了解:DISTINCT 去除重复项 , (默认是ALL)
SELECT * FROM SUBJECT; -- 查看考试成绩 SELECT `subjectno` FROM SUBJECT; -- 查看哪些同学参加了考试 SELECT DISTINCT `subjectno` FROM SUBJECT; -- 了解:DISTINCT 去除重复项 , (默认是ALL) SELECT VERSION(); -- 查询版本号 SELECT 100*3-1 AS 计算结果; -- 表达式 SELECT @@auto_increment_increment; -- 查询自增步长 -- 学员考试成绩集体提分一分查看 SELECT `subjectno` ,gradeid+1 AS '提分后' FROM SUBJECT;
数据库中的表达式 : 一般由文本值 , 列值 , NULL , 函数和操作符等组成
应用场景 :
-
SELECT语句返回结果列中使用
-
SELECT语句中的ORDER BY , HAVING等子句中使用
-
DML语句中的 where 条件语句中使用表达式
Ⅲ.where条件语句
作用：用于检索数据表中 符合条件 的记录
搜索条件可由一个或多个逻辑表达式组成 , 结果一般为真或假.
逻辑操作符
| 操作符名称 | 语法 | 描述 |
|---|---|---|
| && | a AND b a && b | 一假即假 |
| || | a OR b a || b | 一真即真 |
| ！ | NOT a ！a | 非 |
-- 满足条件的查询(where) SELECT `subjectno`,gradeid FROM SUBJECT; -- 查询考试成绩在1-3之间的 SELECT `subjectno`,gradeid FROM SUBJECT WHERE gradeid>=1 AND gradeid<=3; -- AND也可以写成 && SELECT `subjectno`,gradeid FROM SUBJECT WHERE gradeid>=1 && gradeid<=3; -- 模糊查询(对应的词:精确查询) SELECT `subjectno`,gradeid FROM SUBJECT WHERE gradeid BETWEEN 1 AND 4; -- 除了1号同学,要其他同学的成绩 SELECT `subjectno`,gradeid FROM SUBJECT WHERE `subjectno`!=1; -- 使用NOT SELECT `subjectno`,gradeid FROM SUBJECT WHERE NOT `subjectno`=1;
注：（where与on的区别）
在多表查询时，on和where都表示筛选条件，on先执行，where后执行。
区别：
外连接时，on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。而where条件是在临时表生成好后，再对临时表进行过滤的条件。
where与on之间的区别：
- 1）on后面的是连接（join）条件，代表两个表建立关系所遵循的规则
- 2）where后面的可以看作是筛选条件，是对最终结果集进行过滤所遵循的规则
思考：在连接（join）两个表时可以不可以使用where字句呢？
答案是肯定的，在连接（join）两个表时确实可以使用where字句，但是我们为什么要使用on呢？
因为当两张表的数据量比较大，又需要连接查询时，应该使用FROM table1 JOIN table2 ON xxx的语法，避免使用FROM table1,table2 WHERE xxx的语法，因为后者会在内存中先生成一张数据量比较大的笛卡尔积表，增加了内存的开销。
Ⅳ.模糊查询：比较操作符(between and \ like \ in \ null)
| 操作符名称 | 语法 | 描述 |
|---|---|---|
| IS NULL | a IS NULL | 若操作符为NULL，则结果为真 |
| IS NOT NULL | a IS NOT NULL | 若操作符不为NULL，则结果为真 |
| BETWEEN | a BETWEEN b AND c | 若a范围在b与c之间，则结果为真 |
| LIKE | a LIKE b | SQL模式匹配，若a匹配b，则结果为真 |
| IN | a IN (a1,a2,a3...) | 若a等于a1，a2...中的某一个，则结果为真 |
** 注意： **
-
数值数据类型的记录之间才能进行算术运算 ;
-
相同数据类型的数据之间才能进行比较 ;
-- 模糊查询 between and \ like \ in \ null
-- =============================================
-- LIKE
-- =============================================
-- 查询姓刘的同学的学号及姓名
-- like结合使用的通配符 : % (代表0到任意个字符) _ (一个字符)
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 '%赵%';
-- 查询姓名中含有特殊字符的需要使用转义符号 '\'
-- 自定义转义符关键字: ESCAPE ':'
-- =============================================
-- IN
-- =============================================
-- 查询学号为1000,1001,1002的学生姓名
SELECT studentno,studentname FROM student
WHERE studentno IN (1000,1001);
-- 查询地址在北京,南京,河南洛阳的学生
SELECT studentno,studentname,address FROM student
WHERE address IN ('北京');
-- =============================================
-- NULL 空
-- =============================================
-- 查询出生日期没有填写的同学
-- 不能直接写=NULL , 这是代表错误的 , 用 is null
SELECT studentname FROM student
WHERE BornDate IS NULL;
-- 查询出生日期填写的同学
SELECT studentname FROM student
WHERE BornDate IS NOT NULL;
-- 查询没有写家庭住址的同学(空字符串不等于null)
SELECT studentname FROM student
WHERE Address='' OR Address IS NULL;
Ⅴ.★★联表查询(JOIN)
JOIN 对比
| 操作符名称 | 描述 |
|---|---|
| INNER JOIN | 如果表中至少有一个匹配，则返回行 |
| LEFT JOIN | 即使右表中没有匹配，也从左表中返回所有的行 |
| RIGHT JOIN | 即使左表中没有匹配，也从右表中返回所有的行 |
-- 查询参加了考试的同学信息(学号,学生姓名,科目编号,分数) SELECT * FROM student; SELECT * FROM result; /*思路: (1):分析需求,确定查询的列来源于两个类,student result,连接查询 (2):确定使用哪种连接查询?(内连接) */ SELECT s.studentno,studentname,subjectno,grade FROM student s INNER JOIN grade r ON r.studentno = s.studentno -- 右连接(也可实现) SELECT s.studentno,studentname,subjectno,grade FROM student s RIGHT JOIN grade r ON r.studentno = s.studentno -- 等值连接 SELECT s.studentno,studentname,subjectno,grade FROM student s , grade r WHERE r.studentno = s.studentno -- 左连接 (查询了所有同学,不考试的也会查出来) SELECT s.studentno,studentname,subjectno,grade FROM student s LEFT JOIN grade r ON r.studentno = s.studentno -- 查一下缺考的同学(左连接应用场景) SELECT s.studentno,studentname,subjectno,grade FROM student s LEFT JOIN grade r ON r.studentno = s.studentno WHERE StudentResult IS NULL -- 思考题:查询参加了考试的同学信息(学号,学生姓名,科目名,分数) SELECT s.studentno,studentname,subjectname,grade FROM student s INNER JOIN grade r ON r.studentno = s.studentno INNER JOIN `subject` sub ON sub.subjectno = r.subjectno
- 连接查询
如需要多张数据表的数据进行查询,则可通过连接运算符实现多个查询
- 内连接 inner join
查询两个表中的结果集中的交集
- 外连接 outer join
左外连接 left join
(以左表作为基准,右边表来一一匹配,匹配不上的,返回左表的记录,右表以NULL填充)
右外连接 right join
(以右表作为基准,左边表来一一匹配,匹配不上的,返回右表的记录,左表以NULL填充)
Ⅵ.★★自连接
自连接的定义：
自连接
数据表与自身进行连接
需求:从一个包含栏目ID , 栏目名称和父栏目ID的表中
查询父栏目名称和其他子栏目名称
| categoryid | categoryname |
|---|---|
| 2 | 信息技术 |
| 3 | 软件开发 |
| 5 | 美术设计 |
子类
| pid | categoryid | categoryname |
|---|---|---|
| 3 | 4 | 数据库 |
| 2 | 8 | 办公信息 |
| 3 | 1 | web开发 |
| 5 | 7 | ps技术 |
操作：查询父类对应的子类关系
| 父类 | 子类 |
|---|---|
| 信息技术 | 办公信息 |
| 软件开发 | 数据库 |
| 软件开发 | web开发 |
| 美术设计 | ps技术 |
-- 编写SQL语句,将栏目的父子关系呈现出来 (父栏目名称,子栏目名称) -- 核心思想:把一张表看成两张一模一样的表,然后将这两张表连接查询(自连接) SELECT a.categoryName AS '父栏目',b.categoryName AS '子栏目' FROM category AS a,category AS b WHERE a.`categoryid`=b.`pid` -- 查询学员及所属的年级(学号,学生姓名,年级名) SELECT studentno AS 学号,studentname AS 学生姓名,gradename AS 年级名称 FROM student s INNER JOIN grade g ON s.`GradeId` = g.`GradeID` -- 查询科目及所属的年级(科目名称,年级名称) SELECT subjectname AS 科目名称,gradename AS 年级名称 FROM SUBJECT sub INNER JOIN grade g ON sub.gradeid = g.gradeid -- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩) SELECT s.`studentno`,`studentname`,`subjectname`,`gradeid` FROM student s INNER JOIN `gradeid` s ON s.studentno = s.studentno INNER JOIN `subject` sub ON s.subjectno = sub.subjectno WHERE subjectname='数据库结构-1'
Ⅶ.分页和排序( ORDER BY && LIMIT )
排序：
语法 : ORDER BY
ORDER BY 语句用于根据指定的列对结果集进行排序。
ORDER BY 语句默认按照ASC升序对记录进行排序。
如果您希望按照降序对记录进行排序，可以使用 DESC 关键字。
-- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩)
-- 按成绩降序排序
SELECT s.studentno,studentname,subjectname,StudentResult FROM student s INNER JOIN result r ON r.studentno = s.studentno INNER JOIN `subject` sub ON r.subjectno = sub.subjectno WHERE subjectname='数据库结构-1' ORDER BY StudentResult DESC
分页：
语法 : SELECT * FROM table LIMIT [offset,] rows | rows OFFSET offset
好处 : (用户体验,网络传输,缓解查询压力)
推导:
第一页 : limit 0,5（1~5）[limit 起始值， 页面的大小]
第二页 : limit 5,5
第三页 : limit 10,5
......
第N页 : limit (pageNo-1) * pageSzie, pageSzie
[pageNo:页码,pageSize:单页面显示条数]
[pageSize：页面大小，（n-1）* pageSize起始值，n 当前页]
-- 每页显示5条数据 SELECT s.studentno,studentname,subjectname,StudentResult FROM student s INNER JOIN result r ON r.studentno = s.studentno INNER JOIN `subject` sub ON r.subjectno = sub.subjectno WHERE subjectname='数据库结构-1' ORDER BY StudentResult DESC , studentno LIMIT 0,5 -- 查询 JAVA第一学年 课程成绩前10名并且分数大于80的学生信息(学号,姓名,课程名,分数) SELECT s.studentno,studentname,subjectname,StudentResult FROM student s INNER JOIN result r ON r.studentno = s.studentno INNER JOIN `subject` sub ON r.subjectno = sub.subjectno WHERE subjectname='JAVA第一学年' ORDER BY StudentResult DESC LIMIT 0,10
练习：
-- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩) -- 按成绩降序排序 SELECT s.`studentno`,`studentname`,`subjectname`,`StudentResult` FROM `student` s INNER JOIN `result` r ON r.studentno = s.studentno INNER JOIN `subject` sub ON r.`subjectno` = sub.`subjectno` WHERE subjectname='数据库结构-1' ORDER BY StudentResult DESC
Ⅷ.子查询和嵌套查询(where (select*from))
定义：
-
在查询语句中的WHERE条件子句中,又嵌套了另一个查询语句
-
嵌套查询可由多个子查询组成,求解的方式是由里及外;
-
子查询返回的结果一般都是集合,故而建议使用IN关键字;
eg：
where (select*from)
-- ====================子查询======================
-- 查询 数据库结构-1 的所有考试结果(学号,科目编号,成绩),并且成绩降序排列
-- 方法一:使用连接查询
SELECT studentno,r.subjectno,StudentResult
FROM result r
INNER JOIN `subject` sub
ON r.`SubjectNo`=sub.`SubjectNo`
WHERE subjectname = '数据库结构-1'
ORDER BY studentresult DESC;
-- 方法二:使用子查询(执行顺序:由里及外)
SELECT studentno,subjectno,StudentResult
FROM result
WHERE subjectno=(
SELECT subjectno FROM `subject`
WHERE subjectname = '数据库结构-1'
)
ORDER BY studentresult DESC;
-- 查询课程为 高等数学-2 且分数不小于80分的学生的学号和姓名
-- 方法一:使用连接查询（个人感觉连接查询好，写的步骤清晰）
SELECT s.studentno,studentname
FROM student s
INNER JOIN result r
ON s.`StudentNo` = r.`StudentNo`
INNER JOIN `subject` sub
ON sub.`SubjectNo` = r.`SubjectNo`
WHERE subjectname = '高等数学-2' AND StudentResult>=80
-- 方法二:使用连接查询+子查询
-- 分数不小于80分的学生的学号和姓名
SELECT DISTINCT r.studentno,studentname
FROM student s
INNER JOIN result r
ON s.`StudentNo`=r.`StudentNo`
WHERE StudentResult>=80
-- 在上面SQL基础上,添加需求:课程为 高等数学-2
SELECT r.studentno,studentname
FROM student s
INNER JOIN result r
ON s.`StudentNo`=r.`StudentNo`
WHERE StudentResult>=80 AND subjectno=(
SELECT subjectno FROM `subject`
WHERE subjectname = '高等数学-2'
)
-- 方法三:使用子查询
-- 分步写简单sql语句,然后将其嵌套起来
SELECT studentno,studentname FROM student WHERE studentno IN(
SELECT studentno FROM result WHERE StudentResult>=80 AND subjectno=(
SELECT subjectno FROM `subject` WHERE subjectname = '高等数学-2'
)
)
Ⅺ.分组和过滤(group by/having)
SELECT subjectname,AVG(studentresult) AS 平均分,MAX(StudentResult) AS 最高分,MIN(StudentResult) AS 最低分 FROM result AS r INNER JOIN `subject` AS s ON r.subjectno = s.subjectno GROUP BY r.subjectno HAVING 平均分>80; /* where写在group by前面. 要是放在分组后面的筛选 要使用HAVING.. 因为having是从前面筛选的字段再筛选，而where是从数据表中的>字段直接进行的筛选的 */
4.MYSQL常用函数（不会的去官网查）
- 数据函数
SELECT ABS(-8); /*绝对值*/ SELECT CEILING(9.4); /*向上取整*/ SELECT FLOOR(9.4); /*向下取整*/ SELECT RAND(); /*随机数,返回一个0-1之间的随机数*/ SELECT SIGN(0); /*符号函数: 负数返回-1,正数返回1,0返回0*/
-
字符串函数
SELECT CHAR_LENGTH('坚持就能成功'); /*返回字符串包含的字符数*/ SELECT CONCAT('我','爱','程序'); /*合并字符串,参数可以有多个*/ SELECT INSERT('我爱编程helloworld',1,2,'超级热爱'); /*替换字符串,从某个位置开始替换某个长度*/ SELECT LOWER('KuangShen'); /*小写*/ SELECT UPPER('KuangShen'); /*大写*/ SELECT LEFT('hello,world',5); /*从左边截取*/ SELECT RIGHT('hello,world',5); /*从右边截取*/ SELECT REPLACE('狂神说坚持就能成功','坚持','努力'); /*替换字符串*/ SELECT SUBSTR('狂神说坚持就能成功',4,6); /*截取字符串,开始和长度*/ SELECT REVERSE('狂神说坚持就能成功'); /*反转 -- 查询姓周的同学,改成邹 SELECT REPLACE(studentname,'周','邹') AS 新名字 FROM student WHERE studentname LIKE '周%'; -
日期和时间函数
SELECT CURRENT_DATE(); /*获取当前日期*/ SELECT CURDATE(); /*获取当前日期*/ SELECT NOW(); /*获取当前日期和时间*/ SELECT LOCALTIME(); /*获取当前日期和时间*/ SELECT SYSDATE(); /*获取当前日期和时间*/ -- 获取年月日,时分秒 SELECT YEAR(NOW()); SELECT MONTH(NOW()); SELECT DAY(NOW()); SELECT HOUR(NOW()); SELECT MINUTE(NOW()); SELECT SECOND(NOW());
-
系统信息函数
SELECT VERSION(); /*版本*/ SELECT USER(); /*用户*/
5.MYSQL聚合函数
| 函数名称 | 描述 |
|---|---|
| COUNT() | 返回满足select条件的记录总和数，如select count()不建议使用，效率低 |
| SUM() | 返回数字字段或表达式列作统计，返回一列的总和。 |
| AVG() | 通常为数值字段或表达列作统计，返回一列的平均值 |
| MAX() | 可以为数值字段，字符字段或表达式列作统计，返回最大的值。 |
| MIN() | 可以为数值字段，字符字段或表达式列作统计，返回最小的值。 |
-- =============================聚合函数============================== /*COUNT(指定列)*/ SELECT COUNT(studentname) FROM student; SELECT COUNT(*) FROM student; SELECT COUNT(1) FROM student; /*推荐*/
从含义上讲，count(1) 与 count(*) 都表示对全部数据行的查询。
- count(字段) 会统计该字段在表中出现的次数，忽略字段为null 的情况。即不统计字段为null 的记录。
- count(*) 包括了所有的列，相当于行数，在统计结果的时候，包含字段为null 的记录；
- count(1) 用1代表代码行，在统计结果的时候，包含字段为null 的记录 。
- 很多人认为count(1)执行的效率会比count()高，原因是count()会存在全表扫描，而count(1)可以针对一个字段进行查询。其实不然，count(1)和count(*)都会对全表进行扫描，统计所有记录的条数，包括那些为null的记录，因此，它们的效率可以说是相差无几。而count(字段)则与前两者不同，它会统计该字段不为null的记录条数。
下面它们之间的一些对比：
1）在表没有主键时，count(1)比count()快
2）有主键时，主键作为计算条件，count(主键)效率最高；
3）若表格只有一个字段，则count()效率较高。
6.MD5 加密
什么是MD5？
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的[密码散列函数]，可以产生出一个128位（16[字节]的散列值（hash value），用于确保信息传输完整一致。
新建一个表：
CREATE TABLE `testmd5` ( `id` INT(4) NOT NULL, `name` VARCHAR(20) NOT NULL, `pwd` VARCHAR(50) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8
插入数据：
-- 明文密码 INSERT INTO testmd5 VALUES(1,'zhangsan','123456'),(2,'lisi','1234567'),(3,'wanger','12345678')
如果我们要对pwd这一列数据进行加密，语法是：
-- 加密全部 UPDATE testmd5 SET pwd=MD5(pwd)
如果单独对某个用户(如 1 )的密码加密：
-- 加密 UPDATE testmd5 SET pwd=MD5(pwd) WHERE id = 1
插入新的数据自动加密：
INSERT INTO testmd5 VALUES(4,'kuangshen3',md5('123456'));
查询登录用户信息（md5对比使用，查看用户输入加密后的密码进行比对）：
-- 查验密码
SELECT * FROM testmd5 WHERE `name`='lisi' AND pwd=MD5('1234567');
7.select小结
-- ================ 内置函数 ================
-- 数值函数
ABS(x) -- 绝对值 ABS(-10.9) = 10
FORMAT(x, d) -- 格式化千分位数值 FORMAT(1234567.456, 2) = 1,234,567.46
CEILING(x) -- 向上取整 CEILING(10.1) = 11
FLOOR(x) -- 向下取整 FLOOR (10.1) = 10
ROUND(x) -- 四舍五入去整
MOD(m, n) -- m%n m MOD n 求余 10%3=1
PI() -- 获得圆周率
POM(m, n) -- m^n
SQRT(x) -- 算术平方根
RAND() -- 随机数
TRUNCATE(x, d) -- 截取d位小数
-- 时间日期函数
now(), current_timestamp(); -- 当前日期时间
current_date(); -- 当前日期
current_time(); -- 当前时间
date('yyyy-mm-dd hh:ii:ss'); -- 获取日期部分
time('yyyy-mm-dd hh:ii:ss'); -- 获取时间部分
date_format('yyyy-mm-dd hh:ii:ss', '%d %y %a %d %m %b %j'); -- 格式化时间
unix_timestamp(); -- 获得unix时间戳
from_unixtime(); -- 从时间戳获得时间
-- 字符串函数
length(string) -- string长度，字节
char_length(string) -- string的字符个数
substring(str, position [,length]) -- 从str的position开始,取length个字符
replace(str ,search_str ,replace_str) -- 在str中用replace_str替换search_str
instr(string ,substring) -- 返回substring首次在string中出现的位置
concat(string [,...]) -- 连接字串
charset(str) -- 返回字串字符集
lcase(string) -- 转换成小写
left(string, length) -- 从string2中的左边起取length个字符
load_file(file_name) -- 从文件读取内容
locate(substring, string [,start_position]) -- 同instr,但可指定开始位置
lpad(string, length, pad) -- 重复用pad加在string开头,直到字串长度为length
ltrim(string) -- 去除前端空格
repeat(string, count) -- 重复count次
rpad(string, length, pad) --在str后用pad补充,直到长度为length
rtrim(string) -- 去除后端空格
strcmp(string1 ,string2) -- 逐字符比较两字串大小
-- 聚合函数
COUNT()
SUM();
MAX();
MIN();
AVG();
GROUP_CONCAT()
-- 其他常用函数
MD5();
DEFAULT();
★MySQL事务和索引
一、事物的定义：
- 事务就是将一组SQL语句放在同一批次内去执行
- 如果一个SQL语句出错,则该批次内的所有SQL都将被取消执行
- MySQL事务处理只支持InnoDB和BDB数据表类型
要么都成功执行，要么都失败执行
二、事物的原则
ACID原则（四大原则）
原子性(Atomic)
- 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性(Consist)
- 一个事务可以封装状态改变（除非它是一个只读的）。事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。也就是说：如果事务是并发多个，系统也必须如同串行事务一样操作。其主要特征是保护性和不变性(Preserving an Invariant)，以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性。 事务前后数据的完整性必须保持一致。
隔离性(Isolated)
- 隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性(Durable)
- 在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
三、事务的隔离级别
- 脏读
- 不可重复读
- 虚读（幻读）
-- ====================事物======================= -- 使用set语句来改变自动提交模式 SET autocommit = 0; /*关闭*/ SET autocommit = 1; /*开启(默认的)*/ -- 注意: --- 1.MySQL中默认是自动提交 --- 2.使用事务时应先关闭自动提交 -- 框架 SET autocommit = 0; -- 先关闭自动提交 -- 开始一个事务,标记事务的起始点，从此之后的sql都在同一个事物内 START TRANSACTION -- 提交一个事务给数据库 COMMIT -- 将事务回滚,数据回到本次事务的初始状态 ROLLBACK -- 开启MySQL数据库的自动提交 SET autocommit =1; -- 保存点 SAVEPOINT 保存点名称 -- 设置一个事务保存点 ROLLBACK TO SAVEPOINT 保存点名称 -- 回滚到保存点 RELEASE SAVEPOINT 保存点名称 -- 删除保存点
模拟场景：（事物一旦执行便会不可逆）
-- 转账模拟实战
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
CREATE TABLE `account01`(
`id` INT (3) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO account01(`name`,`money`)
VALUES ('A',2000.00),('B',10000.00)
-- 模拟转账
SET autocommit = 0;-- 关闭自动提交
START TRANSACTION -- 开始一个事务,标记事务的起始点，从此之后的sql都在同一个事物内
UPDATE account01 SET money = money-500 WHERE `name`='A'-- A少500
UPDATE account01 SET money = money+500 WHERE `name`='B'-- B多500
-- 提交一个事务给数据库
COMMIT
-- 将事务回滚,数据回到本次事务的初始状态
ROLLBACK
-- 开启MySQL数据库的自动提交
SET autocommit =1;
四、索引
1. 索引的定义：
官方介绍索引是帮助MySQL高效获取数据的数据结构。更通俗的说，数据库索引好比是一本书前面的目录，能加快数据库的查询速度。
2. 索引的优势和劣势：
优势：
-
可以提高数据检索的效率，降低数据库的IO成本，类似于书的目录。
-
通过索引列对数据进行排序，降低数据排序的成本，降低了CPU的消耗。
-
被索引的列会自动进行排序，包括【单列索引】和【组合索引】，只是组合索引的排序要复杂一些。
如果按照索引列的顺序进行排序，对应order by语句来说，效率就会提高很多。
劣势：
-
索引会占据磁盘空间
-
索引虽然会提高查询效率，但是会降低更新表的效率。比如每次对表进行增删改操作，MySQL不仅要保存数据，还有保存或者更新对应的索引文件。
3.索引的分类
- 主键索引(Primary Key)
- 唯一的标识，逐渐不能重复，只能有一个列作为主键
- 唯一索引 (Unique)
- 避免重复的列出现，唯一索引可以重复，多个列都可以标识，唯一索引可以有多个
- 常规索引 (Index)
- 默认的，index，key关键字
- 全文索引 (FullText)
- 在特定的数据库引擎下才有，MyISAM
- 快速定位数据
-- ==============索引的使用=============
-- 1.在建表的时候给字段增加索引
-- 2.创建完毕后，增加索引
-- 显示所有索引的信息
SHOW INDEX FROM student
-- 增加一个全文索引
ALTER TABLE school01.`student` ADD FULLTEXT INDEX `studentname`(`studentname`);
-- EXPLAIN 分析sql执行的状况
EXPLAIN SELECT * FROM student;-- 非全文索引
EXPLAIN SELECT * FROM student WHERE MATCH (studentname) AGAINST('张');
-- 增加一个全文索引 ALTER TABLE school01.`student` ADD FULLTEXT INDEX `studentname`(`studentname`);
执行如下代码的结果：EXPLAIN SELECT * FROM student WHERE MATCH (studentname) AGAINST('张');
4. 测试索引
-- 添加索引 -- id_表名_字段名 -- CREATE INDEX 索引名 CREATE INDEX id_app_user_name ON app_user(`name`);
创建索引之后再执行以下代码：
可以减少查询时间，本质：索引创建了一个B树，重新排列了所给的数据
5.索引的使用原则
- 索引不是越多越好
- 不要对进程变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用来查询的字段上
索引背后的参考文献：CodingLabs - MySQL索引背后的数据结构及算法原理
6.索引的数据结构
- 我们可以在创建上述索引的时候，为其指定索引类型，分两类
-
hash类型的索引：查询单条快，范围查询慢
-
btree类型的索引：b+树，层数越多，数据量指数级增长（我们就用它，因为innodb默认支持它）
- 不同的存储引擎支持的索引类型也不一样
InnoDB 支持事务，支持行级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
MyISAM 不支持事务，支持表级别锁定，支持 B-tree、Full-text 等索引，不支持 Hash 索引；
Memory 不支持事务，支持表级别锁定，支持 B-tree、Hash 等索引，不支持 Full-text 索引；
NDB 支持事务，支持行级别锁定，支持 Hash 索引，不支持 B-tree、Full-text 等索引；
Archive 不支持事务，支持表级别锁定，不支持 B-tree、Hash、Full-text 等索引；
★MySQL权限管理
一、用户管理
SQL可视化管理
注意选择的用户是什么就怎么登录
二、基本命令
用户信息表：mysql.user
本质：对mysql中的这张表进行增删改查
用户信息表：mysql.user
-- 刷新权限
FLUSH PRIVILEGES
-- 增加用户 CREATE USER yuanhui IDENTIFIED BY'123456'
CREATE USER 用户名 IDENTIFIED BY [PASSWORD] 密码(字符串)
- 必须拥有mysql数据库的全局CREATE USER权限，或拥有INSERT权限。
- 只能创建用户，不能赋予权限。
- 用户名，注意引号：如 'user_name'@'192.168.1.1'
- 密码也需引号，纯数字密码也要加引号
- 要在纯文本中指定密码，需忽略PASSWORD关键词。要把密码指定为由PASSWORD()函数返回的混编值，需包含关键字PASSWORD
-- ================权限================
-- 创建用户
CREATE USER yuanhui IDENTIFIED BY'123456'
-- 修改密码（修改当前用户名的密码）
SET PASSWORD = PASSWORD('123456')
-- 修改密码（修改指定用户名的密码）
SET PASSWORD FOR yuanhui = PASSWORD('123456')
-- 重命名用户
RENAME USER yuanhui TO yuanhui2
-- 用户授权 ALL PRIVILEGES 全部的权限，库，表
-- ALL PRIVILEGES 除了给别人授权，其他的都可以
GRANT ALL PRIVILEGES ON *.* TO yuanhui2
-- 查询权限
SHOW GRANTS FOR yuanhui2 -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost
-- 撤销权限 REVOKE
REVOKE ALL PRIVILEGES ON *.* FROM yuanhui2
-- 删除用户
DROP USER yuanhui2
三、权限的解释
-- 权限列表
ALL [PRIVILEGES] -- 设置除GRANT OPTION之外的所有简单权限
ALTER -- 允许使用ALTER TABLE
ALTER ROUTINE -- 更改或取消已存储的子程序
CREATE -- 允许使用CREATE TABLE
CREATE ROUTINE -- 创建已存储的子程序
CREATE TEMPORARY TABLES -- 允许使用CREATE TEMPORARY TABLE
CREATE USER -- 允许使用CREATE USER, DROP USER, RENAME USER和REVOKE ALL PRIVILEGES。
CREATE VIEW -- 允许使用CREATE VIEW
DELETE -- 允许使用DELETE
DROP -- 允许使用DROP TABLE
EXECUTE -- 允许用户运行已存储的子程序
FILE -- 允许使用SELECT...INTO OUTFILE和LOAD DATA INFILE
INDEX -- 允许使用CREATE INDEX和DROP INDEX
INSERT -- 允许使用INSERT
LOCK TABLES -- 允许对您拥有SELECT权限的表使用LOCK TABLES
PROCESS -- 允许使用SHOW FULL PROCESSLIST
REFERENCES -- 未被实施
RELOAD -- 允许使用FLUSH
REPLICATION CLIENT -- 允许用户询问从属服务器或主服务器的地址
REPLICATION SLAVE -- 用于复制型从属服务器（从主服务器中读取二进制日志事件）
SELECT -- 允许使用SELECT
SHOW DATABASES -- 显示所有数据库
SHOW VIEW -- 允许使用SHOW CREATE VIEW
SHUTDOWN -- 允许使用mysqladmin shutdown
SUPER -- 允许使用CHANGE MASTER, KILL, PURGE MASTER LOGS和SET GLOBAL语句，mysqladmin debug命令；允许您连接（一次），即使已达到max_connections。
UPDATE -- 允许使用UPDATE
USAGE -- “无权限”的同义词
GRANT OPTION -- 允许授予权限
/* 表维护 */
-- 分析和存储表的关键字分布
ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE 表名 ...
-- 检查一个或多个表是否有错误
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
option = {QUICK | FAST | MEDIUM | EXTENDED | CHANGED}
-- 整理数据文件的碎片
OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
★MySQL备份
一、数组的备份
数据库备份必要性
- 保证重要数据不丢失
- 数据转移
二、数据库的备份方法
MySQL数据库备份方法
-
mysqldump备份工具
-
数据库管理工具,如SQLyog
- 在想要导出的表中右键选择备份
-
-
直接拷贝数据库文件和相关配置文件
三、mysqldump客户端
- 转储数据库
- 搜集数据库进行备份
- 将数据转移到另一个SQL服务器,不一定是MySQL服务器
-- 导出 1. 导出一张表 -- mysqldump -uroot -p123456 school student >D:/a.sql mysqldump -u用户名 -p密码 库名 表名 > 文件名(文件的位置D:/a.sql) 2. 导出多张表 -- mysqldump -uroot -p123456 school student result >D:/a.sql mysqldump -u用户名 -p密码 库名 表1 表2 表3 > 文件名(D:/a.sql) 3. 导出所有表 -- mysqldump -uroot -p123456 school >D:/a.sql mysqldump -u用户名 -p密码 库名 > 文件名(D:/a.sql) 4. 导出一个库 -- mysqldump -uroot -p123456 -B school >D:/a.sql mysqldump -u用户名 -p密码 -B 库名 > 文件名(D:/a.sql) 可以-w携带备份条件 -- 导入 1. 在登录mysql的情况下：-- source D:/a.sql source 备份文件 2. 在不登录的情况下 mysql -u用户名 -p密码 库名 < 备份文件
★MySQL规范化数据库设计
一、为什么需要数据库设计
当数据库比较复杂时我们需要设计数据库
糟糕的数据库设计 :
- 数据冗余,存储空间浪费
- 数据更新和插入的异常
- 程序性能差
良好的数据库设计 :
-
节省数据的存储空间
-
能够保证数据的完整性
-
方便进行数据库应用系统的开发
软件项目开发周期中数据库设计 :
-
需求分析阶段: 分析客户的业务和数据处理需求
-
概要设计阶段:设计数据库的E-R模型图 , 确认需求信息的正确和完整.
设计数据库步骤
-
收集信息
-
与该系统有关人员进行交流 , 座谈 , 充分了解用户需求 , 理解数据库需要完成的任务.
-
标识实体[Entity]
-
标识数据库要管理的关键对象或实体,实体一般是名词
-
标识每个实体需要存储的详细信息[Attribute]
-
标识实体之间的关系[Relationship]
本质上是：把html中不同的分块（不同的导航栏box）都用数据库可视化储存
二、三大范式
问题 : 为什么需要数据规范化?
不合规范的表设计会导致的问题：
-
信息重复
-
更新异常
-
插入异常
- 无法正确表示信息
-
删除异常
- 丢失有效信息
-
第一范式 (1st NF)
第一范式的目标是确保每列的原子性,如果每列都是不可再分的最小数据单元,则满足第一范式
上图不满足第一范式的要求，下图则满足
-
第二范式(2nd NF)
第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。
第二范式要求每个表只描述一件事情，不相干的事情不要写入表内
-
第三范式(3rd NF)
如果一个关系满足第二范式,并且除了主键以外的其他列都不传递依赖于主键列,则满足第三范式.
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。
eg：比如Student表（学号，姓名，年龄，性别，所在院校，院校地址，院校电话）这样一个表结构，就存在 上述关系。 学号--> 所在院校 --> (院校地址，院校电话)。我们应该拆开来，如下：
（学号，姓名，年龄，性别，所在院校）--（所在院校，院校地址，院校电话）
-
规范化和性能的关系
为满足某种商业目标 , 数据库性能比规范化数据库更重要
在数据规范化的同时 , 要综合考虑数据库的性能
通过在给定的表中添加额外的字段,以大量减少需要从中搜索信息所需的时间
通过在给定的表中插入计算列,以方便查询
★JDBC
一、数据库的驱动
程序会根据 数据库 驱动，和数据库打交道
二、JDBC
-
什么是JDBC？
### JDBC（JavaDataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。原来我们操作数据库是在控制台使用SQL语句来操作数据库，JDBC是用Java语言向数据库发送SQL语句。
-
三、第一个JDBC项目
-- ================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')
- 创建一个普通项目
- 导入数据库驱动
导入数据的步骤
-
加载驱动
-
连接到数据库DriverManager
-
获得执行sql的对象 Statement
-
获得返回的结果集
-
释放连接
package com.Ji.lesson01; import java.sql.*; public class JDBCFirstDemo { public static void main(String[] args) throws ClassNotFoundException, SQLException { //1. 加载驱动 Class.forName("com.mysql.jdbc.Driver"); //2. 用户信息和url // useUnicode=true&characterEncoding=utf8&useSSL=ture 第一个：支持中文编码；第二个：字符集位优先；第三个：SSL使用安全的连接 String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false"; String username = "root"; String password = "123456"; //3. 连接成功，数据库对象 Connection connection= DriverManager.getConnection(url,username,password); //4. 执行SQL对象 Statement执行sql的对象 Statement statement = connection.createStatement(); //5. 执行SQL的对象去执行SQL String sql = "SELECT * FROM users"; ResultSet resultSet = statement.executeQuery(sql);//返回结果集 while (resultSet.next()){ System.out.println("id=" + resultSet.getObject("id")); System.out.println("name=" + resultSet.getObject("NAME")); System.out.println("pwd=" + resultSet.getObject("PASSWORD")); System.out.println("email=" + resultSet.getObject("email")); System.out.println("birth=" + resultSet.getObject("birthday")); } //6. 释放连接 resultSet.close(); statement.close(); connection.close(); } }结果：
四、JDBC对象的解释
DriverManager
Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动
Connection connection= DriverManager.getConnection(url,username,password);
//connection
//数据库设置自动提交
//事务提交
//事物回滚
URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false"; //mysql -- 3306 //jdbc:mysql: //协议：//主机地址：端口号/数据库名？参数1&参数2&参数3
Statement执行SQL的对象，PrepareStatement执行SQL的对象
String sql = "SELECT * FROM users";//编写SQL statement.executeQuery()//查询操作返回 ResultSet statement.execute()//执行到任何SQL statement.executeUpdate()//更新，插入，删除，返回一个受影响的参数
ResultSet查询的结果集
获得指定的数据类型 resultSet.getObject();//在不知道列类型的情况下使用 //如果已知列的类型就使用指定的类型 resultSet.getString(); resultSet.getInt(); resultSet.getFloat(); resultSet.getDate(); resultSet.getObject(); ......
遍历，指针
resultSet.beforeFirst();//移动到最前面 resultSet.afterLast();//移动到最后面 resultSet.next();//移动到下一个数据 resultSet.previous();//移动到前一行 resultSet.absolute(row)//移动到指定行
释放资源
resultSet.close(); statement.close(); connection.close();
五、statement对象
JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sq|语句， executeUpdate执行完后， 将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。
Statement.executeQuery方法用于向数据库发生查询语句，executeQuery方法返回代表查询结果的ResultSet对象。
CRUD操作-create
Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("插入成功");
}
CRUD操作-delete
使用executeUpdate(sql);方法完成数据的删除操作
Statement statement = connection.createStatement();
String sql = "delete from user where id =1";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("删除成功");
}
CURD操作-update
使用executeUpdate(sql);方法完成数据的修改操作
Statement statement = connection.createStatement();
String sql = "update user set name ='' where name = "";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("修改成功");
}
CURD操作-read
Statement statement = connection.createStatement();
String sql = "select * from user where id =1";
ResultSet rs= statement.executeQuery(sql);
if(rs.next()){
System.out.println("");
}
代码实现（增）：
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;
public class TestInser {
public static void main(String[] args) throws Exception {
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
"VALUES(4,'yuanhui','123456','233223@qq.com','2020-01-01')";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("插入成功");
}
JdbcUtils.release(conn,st,rs);
} catch (SQLException e) {
e.printStackTrace();
}
finally{
JdbcUtils.release(conn,st,rs);
}
}
}
代码实现（删）：[改变上面的代码即可]
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;
public class TextDelet {
public static void main(String[] args) throws Exception {
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "DELETE FROM users WHERE id = 4";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("删除成功");
}
JdbcUtils.release(conn,st,rs);
} catch (SQLException e) {
e.printStackTrace();
}
finally{
JdbcUtils.release(conn,st,rs);
}
}
}
代码实现（更新）：
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;
public class TextUpdate {
public static void main(String[] args) throws Exception {
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "UPDATE USERS SET `NAME` = 'YUANHUI',`email`= '123456@qq.com' WHERE id = 2";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("更新成功");
}
JdbcUtils.release(conn,st,rs);
} catch (SQLException e) {
e.printStackTrace();
}
finally{
JdbcUtils.release(conn,st,rs);
}
}
}
代码实现（查询）：
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;
public class TextQuery {
public static void main(String[] args) throws Exception {
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = JdbcUtils.getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = " select * from users where id = 2 ";
rs = st.executeQuery(sql);//查询完毕，打印结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
JdbcUtils.release(conn,st,rs);
} catch (SQLException e) {
e.printStackTrace();
}
finally{
JdbcUtils.release(conn,st,rs);
}
}
}
六、SQL注入的问题
sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.Ji.lesson01.lesson2.utils.JdbcUtils.getConnection;
public class SQL注入 {
public static void main(String[] args) {
//SQL注入
login("' or '1=1","123456");
}
public static void login(String name,String password){
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "select * from users where `NAME`='"+ name +"' AND `PASSWORD`='"+ password +"'" ;
rs=st.executeQuery(sql);//查询完毕返回结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(conn,st,rs);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
七、PreparedStatement对象
PreparedStatement 可以防止SQL注入 ，效率更高。
- 新增
- 删除
- 查询
新增：
package com.Ji.lesson01.lesson2.utils;
import com.Ji.lesson01.lesson2.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PreparedStatement {
public static void main(String[] args) {
Connection connection= null;
java.sql.PreparedStatement pstm=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用问好占位符代替参数
String sql = "insert into users(id,`NAME`) values(?,?)";
pstm = connection.prepareStatement(sql);//预编译sql，先写sql然后不执行
//手动赋值
pstm.setInt(1,8);
pstm.setString(2,"SANJIN");
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("插入成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(connection,pstm,null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
防止SQL注入本质，传递字符 带有“ ”，转义字符会被转义
删除：
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PreparedStatement {
public static void main(String[] args) {
Connection connection= null;
java.sql.PreparedStatement st=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用问好占位符代替参数
String sql = "delete from users where id = ?;";
st = connection.prepareStatement(sql);//预编译sql，先写sql然后不执行
//手动赋值
st.setInt(1,4);
//执行
int i = st.executeUpdate();
if (i>0){
System.out.println("删除成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(connection,st,null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
查询：
package com.Ji.lesson01.lesson2.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PreparedStatement1 {
public static void main(String[] args) {
Connection connection= null;
java.sql.PreparedStatement st=null;
ResultSet rs = null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用问好占位符代替参数
String sql = "select * from users where id = ? ;";
st = connection.prepareStatement(sql);//预编译sql，先写sql然后不执行
//手动赋值
st = connection.prepareStatement(sql);
st.setInt(1,8);
//执行
rs = st.executeQuery();
if (rs.next()){
System.out.println(rs.getString("NAME"));
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(connection,st,null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
★使用IDEA连接数据库
** 注：
- 社区版的idea和正式版的不一样
- database在社区版的时候是DB browser
- 注意回看视频区分**
连接成功后，可以选择数据库
双击数据库
更新数据
★JDBC事物
要么都成功，要么都失败
ACID原则
原子性：要么全部完成，要么都不完成
一致性：结果总数不变
隔离性：多个进程互不干扰
持久性：一旦提交不可逆，持久化到数据库了
隔离性的问题：
脏读： 一个事务读取了另一个没有提交的事务
不可重复读：在同一个事务内，重复读取表中的数据，表发生了改变
虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致
- 开启事务
conn.setAutoCommit(false); - 一组业务执行完毕，提交事务
- 可以在catch语句中显示的定义回滚，但是默认失败会回滚
★数据库连接池
数据库连接–执行完毕–释放
连接–释放 十分浪费资源
池化技术： 准备一些预先的资源，过来就连接预先准备好的
常用连接数 100
最少连接数：100
最大连接数 ： 120 业务最高承载上限
排队等待，
等待超时：100ms
编写连接池，实现一个接口 DateSource
开源数据源实现(拿来即用)
DBCP
C3P0
Druid: 阿里巴巴
使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了
结论
无论使用什么数据源，本质是不变的，DateSource接口不会变，方法就不会变
这篇关于后端开发学习记录（二）——MySQL的学习的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-04部署MySQL集群项目实战：新手入门教程
- 2024-11-04如何部署MySQL集群资料：新手入门指南
- 2024-11-02MySQL集群项目实战：新手入门指南
- 2024-11-02初学者指南：部署MySQL集群资料
- 2024-11-01部署MySQL集群教程：新手入门指南
- 2024-11-01如何部署MySQL集群：新手入门教程
- 2024-11-01部署MySQL集群学习：新手入门教程
- 2024-11-01部署MySQL集群入门：新手必读指南
- 2024-10-23BinLog入门：新手必读的MySQL二进制日志指南
- 2024-10-23Binlog入门：MySQL数据库的日志管理指南
