MySQL万字总结(含测试代码)

本文大部分笔记来源于：【狂神说Java】MySQL最新教程通俗易懂

1.MySQL

什么是数据库

数据库(DataBase,简称DB)

概念：长期存放在计算机内，有组织，可共享的大量数据的集合，是一个数据“仓库”

作用：保存，并能安全管理数据（如：增删改查等），减少冗余…

数据库总览：

• 关系型数据库（SQL）
  • MySQL,Oracle,SQL Server,SQLite,DB2,…
  • 关系型数据库通过外键关联来建立表与表之间的关系
• 非关系型数据库（NOSQL）
  • Redis，MongDB，…
  • 非关系型数据库通常指数据以对象的形式存储在数据库中，而对象之间的关系通过每个对象自身的属性来决定

数据库管理软件，科学组织和存储数据，高效地获取和维护数据

MySQL应该算是一个数据库管理系统.

概念 : 是现在流行的开源的,免费的 关系型数据库

历史 : 由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下产品。

特点 :

• 免费 , 开源数据库
• 小巧 , 功能齐全
• 使用便捷
• 可运行于Windows或Linux操作系统
• 可适用于中小型甚至大型网站应用

打开MySQL命令窗口

• 在DOS命令行窗口进入 安装目录\mysql\bin
• 可设置环境变量，设置了环境变量，可以在任意目录打开！

连接数据库语句 : mysql -h 服务器主机地址 -u 用户名 -p 用户密码

注意 : -p后面不能加空格,否则会被当做密码的内容,导致登录失败 !

几个基本的数据库操作命令 :

update user set password=password('123456')where user='root';	--修改密码
flush privileges;	--刷新数据库
show databases;		--显示所有数据库
use database_name;		--打开某个数据库
show tables;		--显示mysql中的所有表
desc user;		--显示mysql数据库中user表的字段信息
create database name;		--创建数据库

exit;		--退出mysql
?命令关键词:寻求帮助
--表注释

2.数据库操作

结构化查询语句分类

数据库操作

创建数据库：creat database [if not exists] 数据库名;

删除数据库：drop database [if exists] 数据库名;

查看数据库：show databases;

使用数据库：use 数据库名;

创建数据表

属于DDL的一种，语法：

create table [if not exists] `名字`(
	`字段名1` 数据类型 [属性][索引][注释],
    `字段名2` 数据类型 [属性][索引][注释],
    `字段名3` 数据类型 [属性][索引][注释],
	#...
    `字段名n` 数据类型 [属性][索引][注释],
    primary key(`字段名`)		--设置主键
)[表类型][表字符集][注释]

CREATE TABLE `student` (
  `id` int(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` varchar(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
  `pwd` varchar(10) NOT NULL DEFAULT '123456' COMMENT '密码',
  `gender` varchar(1) NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` datetime DEFAULT NULL COMMENT '出生日期',
  `gradeId` int(4) NOT NULL COMMENT '班级id',
  `address` varchar(100) DEFAULT NULL COMMENT '地址',
  `email` varchar(30) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`),
  KEY `FK_gradeId` (`gradeId`),
  CONSTRAINT `FK_gradeId` FOREIGN KEY (`gradeId`) REFERENCES `grade` (`gradeId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4


-- 查看数据库的定义
SHOW CREATE DATABASE school;
-- 查看数据表的定义
SHOW CREATE TABLE student;
-- 显示表结构
DESC student;  -- 设置严格检查模式(不能容错了)SET

说明：反引号用于区别mysql保留字与普通字符引入的（``）,我们在对字段进行操作的时候，可以不用加(),但是如果被操作字段是数据库中保留的关键字的话，我们就必须要加上(’ ')

数据类型

​

• 理解为 “没有值” 或 “未知值”
• 不要用NULL进行算术运算 , 结果仍为NULL

数据字段属性

UnSigned

• 无符号的
• 声明该数据列不允许负数 .

ZEROFILL

• 0填充的
• 不足位数的用0来填充 , 如int(3),5则为005

Auto_InCrement

• 自动增长的 , 每添加一条数据 , 自动在上一个记录数上加 1(默认)

• 通常用于设置主键 , 且为整数类型

• 可定义起始值和步长

• 当前表设置步长(AUTO_INCREMENT=100) : 只影响当前表

• SET @@auto_increment_increment=5 ; 影响所有使用自增的表(全局)

NULL 和 NOT NULL

• 默认为NULL , 即没有插入该列的数值
• 如果设置为NOT NULL , 则该列必须有值

DEFAULT

• 默认的
• 用于设置默认值
• 例如,性别字段,默认为"男" , 否则为 “女” ; 若无指定该列的值 , 则默认值为"男"的值

数据表的类型

create table `表名`(
	...
)engine=MyISAM(or innodb)
  -- Mysql注释
  -- 1. # 单行注释
  -- 2. /*...*/ 多行注释
-- 查看mysql所支持的引擎类型 (表类型)
SHOW ENGINES;

MySQL的数据表的类型 : MyISAM , InnoDB , HEAP , BOB , CSV等…

常见的 MyISAM 与 InnoDB 类型：

经验 ( 适用场合 ) :

• 适用 MyISAM : 节约空间及相应速度
• 适用 InnoDB : 安全性 , 事务处理及多用户操作数据表

• MySQL数据表以文件方式存放在磁盘中

  • 包括表文件 , 数据文件 , 以及数据库的选项文件

  • 位置 : Mysql安装目录\data\下存放数据表 . 目录名对应数据库名 , 该目录下文件名对应数据表 .

  • 注意 :

    • *. frm – 表结构定义文件
    • * . MYD – 数据文件 ( data )
    • * . MYI – 索引文件 ( index )
    • InnoDB类型数据表只有一个 *.frm文件 , 以及上一级目录的ibdata1文件
    • MyISAM类型数据表对应三个文件 :

我们可为数据库,数据表,数据列设定不同的字符集，设定方法 :

• 创建时通过命令来设置 , 如 : CREATE TABLE 表名()CHARSET = utf8mb4;
• 如无设定 , 则根据MySQL数据库配置文件 my.ini 中的参数设定

修改数据库

alter table 旧表名	rename as 新表名				--修改表名
alter table 表名 add 字段名 [属性]					--为表增加新字段
alter table 表名 modify 字段名[新属性]				--修改字段的属性
alter table 表名 change 旧字段名	新字段名 [属性]	 --修改字段名以及属性
alter table 表名 drop 字段名						 --删除字段

drop table[if exists] 表名
-- IF EXISTS为可选 , 判断是否存在该数据表

-- 如删除不存在的数据表会抛出错误

1. 可用反引号（`）为标识符（库名、表名、字段名、索引、别名）包裹，以避免与关键字重名！中文也可以作为标识符！

2. 每个库目录存在一个保存当前数据库的选项文件db.opt。

3. 注释：
  单行注释 # 注释内容
  多行注释 /* 注释内容 */
  单行注释 -- 注释内容       (标准SQL注释风格，要求双破折号后加一空格符（空格、TAB、换行等）)
   
4. 模式通配符：
  _   任意单个字符
  %   任意多个字符，甚至包括零字符
  单引号需要进行转义 \'
   
5. CMD命令行内的语句结束符可以为 ";", "\G", "\g"，仅影响显示结果。其他地方还是用分号结束。delimiter 可修改当前对话的语句结束符。

6. SQL对大小写不敏感 （关键字）

7. 清除已有语句：\c

3.DML语言

外键

如果公共关键字在一个关系中是主关键字，那么这个公共关键字被称为另一个关系的外键。由此可见，外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的表被称为主表，具有此外键的表被称为主表的从表。

在实际操作中，将一个表的值放入第二个表来表示关联，所使用的值是第一个表的主键值(在必要时可包括复合主键值)。此时，第二个表中保存这些值的属性称为外键(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=utf8mb4;

-- 学生信息表 (学号,姓名,性别,年级,手机,地址,出生日期,邮箱,身份证号)
CREATE TABLE `student` (
`studentno` INT(4) NOT NULL COMMENT '学号',
`studentname` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`sex` TINYINT(1) DEFAULT '1' COMMENT '性别',
`gradeid` INT(10) DEFAULT NULL COMMENT '年级',
`phoneNum` VARCHAR(50) NOT NULL COMMENT '手机',
`address` VARCHAR(255) DEFAULT NULL COMMENT '地址',
`borndate` DATETIME DEFAULT NULL COMMENT '生日',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
`idCard` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',
PRIMARY KEY (`studentno`),
KEY `FK_gradeid` (`gradeid`),
CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;

-- 在navicat中一条语句结束后要打分号

建表之后修改

-- 创建外键方式二 : 创建子表完毕后,修改子表添加外键
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`);

注意 : 删除具有主外键关系的表时 , 要先删子表 , 后删主表

-- 删除外键
ALTER TABLE student DROP FOREIGN KEY FK_gradeid;
-- 发现执行完上面的,索引还在,所以还要删除索引
-- 注:这个索引是建立外键的时候默认生成的
ALTER TABLE student DROP INDEX FK_gradeid;

添加数据

语法：

insert into `表名`[(字段1,字段2,字段3,...)] values('值1','值2','值3')
--单条记录添加
insert into `student`(`name`,`pwd`,`gradeId`) values('小红','12314','123')
--多条中间用逗号隔开
insert into `student`(`name`,`pwd`,`gradeId`)
values('小黑','1412','143'),('小黄','12141','32')

注意 :

• 字段或值之间用英文逗号隔开 .
• ’ 字段1,字段2…’ 该部分可省略 , 但添加的值务必与表结构,数据列,顺序相对应,且数量一致 .
• 可同时插入多条数据 , values 后用英文逗号隔开 .

修改数据

语法：

update `表名` set `name1`='value'[,`name2`='value‘,...] where [condition]

注意：

• name1和name2为要修改值的字段名，如果要修改多个字段的值，则它们之间用逗号隔开
• value为修改后的值，可以为变量，具体值，表达式或者嵌套的select结果
• condition如果不指定则表示修改该表的对应字段的数据

update `student` set `name`='小青' where id='1';
update `student` set `email`='23425235@sina.com' where id<>'2';
update `student` set `gender`='女' where id='1' or id='3' or pwd='1241412';
update `student` set `email`='2423443@qq.com' where id between 2 and 4;
update `student` set `address`='关涧';
update `student` set `name`='小李',`birthday`=CURRENT_TIME where address='关涧' and gradeId='39';

删除数据

语法：

delete from `表名` where[condition]
delete from `student` where id=1
delete from `student`

condition为筛选条件，符合即删除相关项，如果不指定condition，则删除表中的所有数据

作用：用于完全清空表数据 , 但表结构 , 索引 , 约束等不变 ;

语法：

turncate [table] table_name;

truncate `student`

注意：区别于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('row1'),('row2'),('row3');

-- 删除表数据(不带where条件的delete)
DELETE FROM test;
-- 结论:如不指定Where则删除该表的所有列数据,自增当前值依然从原来基础上进行,会记录日志.

-- 删除表数据(truncate)
TRUNCATE TABLE test;
-- 结论:truncate删除数据,自增当前值会恢复到初始值重新开始;不会记录日志.

-- 同样使用DELETE清空不同引擎的数据库表数据.重启数据库服务后
-- InnoDB : 自增列从初始值重新开始 (因为是存储在内存中,断电即失)
-- MyISAM : 自增列依然从上一个自增数据基础上开始 (存在文件中,不会丢失)

使用delete删除表，自动递增在原来的基础上不变，

使用turncate删除表，自动递增会重置：

4.DQL语言

DQL( Data Query Language 数据查询语言 )

• 查询数据库数据 , 如SELECT语句
• 简单的单表查询或多表的复杂查询和嵌套查询
• 是数据库语言中最核心,最重要的语句
• 使用频率最高的语句

select[All | distinct]							-- all表示默认不去重
{字段名1[[as newname],字段名2[as newname],...}
from table_name[as new table_name]
	[left | inner | right  join table_name]		-- 联合查询
	[where...]									-- 指定查询结果需要满足的条件
	[group by ...]								-- 按指定字段进行分组
	[having...]									-- 筛选聚合元素所需要满足的条件
	[order by...]								-- 对指定字段进行排序
    [limit{[offset,count]}]						-- 指定查询的记录从第offset条开始(相对于原始记录)，显示count条

注：[ ]表示可选可不选，{ }表示必选项

指定查询

-- 查询表中所有的数据列结果 , 采用 **" \* "** 符号; 但是效率低，不推荐 .
-- 查询全部学学生
SELECT * FROM student
-- 查询指定字段
SELECT `StudentNo`,`StudentName` FROM student
-- 可以用as给字段、表起别名
SELECT `StudentNo` as 学号,`StudentName` as 姓名 FROM	student	as 学生表
-- as也可以省略
SELECT `StudentNo`学号,`StudentName`姓名 FROM	student	学生表
-- 使用concat函数连接字符串 
SELECT CONCAT('学号:',`StudentNo`,',姓名:',`StudentName`) as 信息 from student

-- select 语法：select `字段名1`[字段名2,...] from 表名

作用 : 去掉SELECT查询返回的记录结果中重复的记录 ( 返回所有列的值都相同 ) , 只返回一条

-- distinct 用于对数据进行去重
select distinct `StudentNo` from result

未去重前：存在多个学号相同的记录

去重后：没有学号相同的记录

数据库中的表达式 : 一般由文本值 , 列值 , NULL , 函数和操作符等组成

应用场景 :

• SELECT语句返回结果列中使用

• SELECT语句中的ORDER BY , HAVING等子句中使用

• DML语句中的 where 条件语句中使用表达式

• -- 查询mysql版本
  select version()
  -- 查询自增步长
  select @@auto_increment_increment
  -- 查询表达式结果
  select 100*3-1 as result
  -- 学员考试成绩+1 查看
  select distinct `StudentNo`,`SubjectNo`,`StudentResult`+1 提分后 from result
  --数据库中的表达式：文本值，字段，Null，函数，计算表达式，系统变量...
  -- select 表达式 from 表 
  

• 避免SQL返回结果中包含 ’ . ’ , ’ * ’ 和括号等干扰开发语言程序.

作用：用于检索数据表中 符合条件 的记录

搜索条件可由一个或多个逻辑表达式组成 , 结果一般为真或假.

• and -> 逻辑与
• or -> 逻辑或
• not -> 逻辑非

select studentno,studentresult from result
where studentresult>=80 and studentresult<=100;	-- 查询成绩在[80,100]区间内的记录

select studentno,studentresult from result
where studentresult between 80 and 90 ;		-- 查询成绩在[80,90]区间内的记录

select studentno,subjectno,studentresult from result 
where not (subjectno>=1 and subjectno<10); 	-- 查询编号不在[1,10]之内的记录

select studentno,studentresult from result 
where studentresult <> 67;				-- 查询成绩不等于67的记录

注意：

• 数值数据类型的记录之间才能进行算术运算 ;
• 相同数据类型的数据之间才能进行比较 ;

-- like 与% 和 _ 结合使用
-- %相当于通配符*(任意多个字符)  _相当于通配符?(任意一个字符)
select studentname,address from student where studentname like '%杨%'	-- 姓名中包含杨字
select studentname,address from student where studentname like '_%杨%'	-- 姓名中间包含杨的
select studentname,address from student where studentname like '李__'	-- 姓李且名字长度为3个字
select studentname,address from student where studentname like '张_'	-- 姓张名字长度2个字

-- in(range) 查询在range范围内的记录
select studentno,studentname from student where studentno in (1007,1005,1003)
select studentname,address from student where address in('北京','重庆')

-- null与not null
-- 在表中将数据修改为null是将null作为字符串进行修改，而不是表示空的含义
-- 即使在表中将数据删除也不表示空的含义
select studentname,address from student where address is not null
select studentname,address from student where address is null

连接查询

-- inner join 返回两个表所匹配的记录 
select s.studentno,studentname,subjectno,studentresult
from student s
inner join result r
on s.studentno=r.studentno

-- left join 不管左表与右表是否有匹配，都会返回左表的全部记录
select s.studentno,studentname,subjectno,studentresult
from student s
left join result r
on s.studentno=r.studentno

-- right join 不管左表与右表是否有匹配项，都会返回右表的全部记录
select s.studentno,studentname,subjectno,studentresult
from student s
right join result r
on s.studentno=r.studentno

-- 思考题:查询参加了考试的同学信息(学号,学生姓名,科目名,分数)
SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON sub.subjectno = r.subjectno

/*
自连接
   数据表与自身进行连接

需求:从一个包含栏目ID , 栏目名称和父栏目ID的表中
    查询父栏目名称和其他子栏目名称
*/

-- 编写SQL语句,将栏目的父子关系呈现出来 (父栏目名称,子栏目名称)
-- 核心思想:把一张表看成两张一模一样的表,然后将这两张表连接查询(自连接)
SELECT a.categoryName AS '父栏目',b.categoryName AS '子栏目'
FROM category AS a,category AS b
WHERE a.`categoryid`=b.`pid`
-- 将父栏目放在左侧，子栏目放在右侧，子栏目的pid字段对应父栏目的category字段

-- 思考题:查询参加了考试的同学信息(学号,学生姓名,科目名,分数)
SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON sub.subjectno = r.subjectno

-- 查询学员及所属的年级(学号,学生姓名,年级名)
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,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
   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
   第二页 : limit 5,5
   第三页 : limit 10,5
   ......
   第N页 : limit (pageNo-1)*pageSzie,pageSzie
   [pageNo:页码,pageSize:单页面显示条数]
   
*/

-- 每页显示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','高等数学-2','高等数学-3','高等数学-4')四门课程中成绩大于等于80分中的前十名的学生信息（学号，姓名，课程名，分数）
select stu.studentno,studentname,subjectname,studentresult
from student stu
inner join result res
on stu.studentno = res.studentno
left join `subject` sub
on res.subjectno = sub.subjectno
where studentresult >= 80 and subjectname in ('高等数学-1','高等数学-2','高等数学-3','高等数学-4')
order by studentresult desc
limit 0,10

子查询

/*============== 子查询 ================
什么是子查询?
   在查询语句中的WHERE条件子句中,又嵌套了另一个查询语句
   嵌套查询可由多个子查询组成,求解的方式是由里及外;
   子查询返回的结果一般都是集合,故而建议使用IN关键字;
*/
-- 查询 数据库结构-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 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'
  )
)

/*

5.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 '周%';
 -- 如果名字中有两个周，替换其中一个使用insert

日期和时间函数

 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();     /*用户*/

聚合函数

 -- 聚合函数
 /*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(*)效率较高。
 */
 
 SELECT SUM(StudentResult) AS 总和 FROM result;
 SELECT AVG(StudentResult) AS 平均分 FROM result;
 SELECT MAX(StudentResult) AS 最高分 FROM result;
 SELECT MIN(StudentResult) AS 最低分 FROM result;
 
 
  -- 查询不同课程的平均分,最高分,最低分
 -- 前提:根据不同的课程进行分组
 
 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是从数据表中的>字段直接进行的筛选的
 */

MD5加密

一、MD5简介

MD5即Message-Digest Algorithm 5（信息-摘要算法5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。

二、实现数据加密

新建一个表 testmd5

 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=utf8mb4

插入一些数据

 INSERT INTO testmd5 VALUES(1,'lisi','123456'),(2,'zhangsan','456789')

如果我们要对pwd这一列数据进行加密，语法是：

 update testmd5 set pwd = md5(pwd);

如果单独对某个用户(如zhangsan)的密码加密：

 INSERT INTO testmd5 VALUES(3,'zhangsan','123456')
 update testmd5 set pwd = md5(pwd) where name = 'zhangsan';

插入新的数据自动加密

 INSERT INTO testmd5 VALUES(4,'wangwu',md5('123456'));

查询登录用户信息（md5对比使用，查看用户输入加密后的密码进行比对）

 SELECT * FROM testmd5 WHERE `name`='wangwu' AND pwd=MD5('123456');

小结

-- ================ 内置函数 ================
 -- 数值函数
 abs(x)            -- 绝对值 abs(-10.9) = 10
 format(x, d)    -- 格式化千分位数值 format(1234567.456, 2) = 1,234,567.46
 ceil(x)            -- 向上取整 ceil(10.1) = 11
 floor(x)        -- 向下取整 floor (10.1) = 10
 round(x)        -- 四舍五入去整
 mod(m, n)        -- m%n m mod n 求余 10%3=1
 pi()            -- 获得圆周率
 pow(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();

6.事务

• 事务就是将一组SQL语句放在同一批次内去执行
• 如果一个SQL语句出错,则该批次内的所有SQL都将被取消执行
• MySQL事务处理只支持InnoDB和BDB数据表类型

事务四大特性

原子性（Atomicity）

​ 事务中的操作要么都发生，要么都不发生

一致性（Consistency）

​ 事务中的数据在操作前和操作之后必须完整性保持一致，不发生改变.

隔离性（Isolation）

​ 在多个用户并发访问数据库的时候，每一个用户所开启的事务不能影响到其它用户开启的事务，其他用户开启的事务也不能影响到自己开启的事务。

持久性（Durability）

​ 一个事物一旦被提交，那么对数据的改动就是永久性的，接下来就算数据库发生鼓掌对其也不能有任何影响。

参考博客链接：https://blog.csdn.net/dengjili/article/details/82468576

-- 使用set来设置事务提交状态（开启/关闭）自动提交事务
set autocommit = 0; -- 关闭自动提交
set autocommit = 1; -- 打开自动提交

-- 注意：
/*
Mysql中默认为自动提交
使用事务之前应当关闭自动提交
*/

start transaction;  -- 开始一个事务，标记事务的起始点

commit; -- 将一个事物提交给数据库
rollback; -- 回滚，数据回到本次事物的初始状态


-- 保存点
savepoint 保存点名称  -- 设置一个事务保存点
rollback to savepoint 保存点名称 -- 回滚到保存点
release savepoint 保存点名称 -- 删除保存点

/*
课堂测试题目

A在线买一款价格为500元商品,网上银行转账.
A的银行卡余额为2000,然后给商家B支付500.
商家B一开始的银行卡余额为10000

创建数据库shop和创建表account并插入2条数据
*/

create table `account`(
	`id` int(10) not null auto_increment,
	`name` varchar(10) not null,
	`money` decimal(9,2) not null,
	primary key(`id`)
)engine=innodb default charset=utf8mb4


insert into `account`(`name`,`money`)
values('A','2000.00'),('B','10000.00')

et autocommit = 0;	-- 关闭自动提交
start transaction;	-- 开启一个事物
update account set money = money - 500 where name = 'A';
update account set money = money + 500 where name = 'B';

commit;				-- 提交事务，提交之后就被持久化了
rollback;			-- 回滚
set autocommit = 1; -- 开启自动提交

事物的隔离级别

读未提交：read uncommitted（最低的隔离级别）

事务A可以读取到事务B未提交的数据。
这种隔离级别存在的问题就是：
脏读现象！(Dirty Read)
这种隔离级别一般都是理论上的，大多数的数据库隔离级别都是二档起步！

脏读：事物A读到了事物B未提交的数据，当事物B回滚数据之后，数据A所读到的数据就失效了

读已提交 ：read commited

事物A读到的是事物B已经提交的数据 -> 解决了脏读问题，出现了不可重复读问题

不可重复读： 事物多次读取的数据不一致

可重复读：repeatable commited

事物A所读取的信息一直是事物B没有开始事物的信息 -->解决了不可重复读问题，出现了幻读问题

幻读：因为事务A读取的信息一直停留在事务B还未开始时候的信息，每一次读取的到的数据都不是真实的，无法读取到事物B修改后的数据。

序列化：serializable（最高的隔离级别）

相当于synchronized的线程同步（事物同步），一个事物没有结束，另外一事物就不能开始。

每一次读取到的数据都是最真实的，但是效率是最低的。

7.索引

参考博客：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

什么是索引？

索引是在数据库表的字段上添加的，是为了提高查询效率存在的一种机制。
一张表的一个字段可以添加一个索引，当然，多个字段联合起来也可以添加索引。
索引相当于一本书的目录，是为了缩小扫描范围而存在的一种机制。

对于一本字典来说，查找某个汉字有两种方式：
**第一种方式：**一页一页挨着找，直到找到为止，这种查找方式属于全字典扫描。
效率比较低。
**第二种方式：**先通过目录（索引）去定位一个大概的位置，然后直接定位到这个
位置，做局域性扫描，缩小扫描的范围，快速的查找。这种查找方式属于通过
索引检索，效率较高。

MySQL在查询方面主要就是两种方式：
第一种方式：全表扫描
第二种方式: 根据索引检索。

提醒1：在任何数据库当中主键上都会自动添加索引对象，id字段上自动有索引，
因为id是PK。另外在mysql当中，一个字段上如果有unique约束的话，也会自动
创建索引对象。

提醒2：在任何数据库当中，任何一张表的任何一条记录在硬盘存储上都有
一个硬盘的物理存储编号。

提醒3：在mysql当中，索引是一个单独的对象，不同的存储引擎以不同的形式
存在，在MyISAM存储引擎中，索引存储在一个.MYI文件中。在InnoDB存储引擎中
索引存储在一个逻辑名称叫做tablespace的当中。在MEMORY存储引擎当中索引
被存储在内存当中。不管索引存储在哪里，索引在mysql当中都是一个树的形式
存在。（自平衡二叉树：B-Tree）

在mysql当中，主键上，以及unique字段上都会自动添加索引的！！！！
什么条件下，我们会考虑给字段添加索引呢？
条件1：数据量庞大（到底有多么庞大算庞大，这个需要测试，因为每一个硬件环境不同）
条件2：该字段经常出现在where的后面，以条件的形式存在，也就是说这个字段总是被扫描。
条件3：该字段很少的DML(insert delete update)操作。（因为DML之后，索引需要重新排序。）

建议不要随意添加索引，因为索引也是需要维护的，太多的话反而会降低系统的性能。
建议通过主键查询，建议通过unique约束的字段进行查询，效率是比较高的。

索引的作用

• 提高查询速度
• 确保数据的唯一性
• 可以加速表和表之间的连接 , 实现表与表之间的参照完整性
• 使用分组和排序子句进行数据检索时 , 可以显著减少分组和排序的时间
• 全文检索字段进行搜索优化.

分类：

• 主键索引 (Primary Key)
• 唯一索引 (Unique)
• 常规索引 (Index)
• 全文索引 (FullText)

主键 : 某一个属性组能唯一标识一条记录

特点 :

• 最常见的索引类型
• 确保数据记录的唯一性
• 确定特定数据记录在数据库中的位置

作用 : 避免同一个表中某数据列中的值重复

与主键索引的区别

• 主键索引只能有一个
• 唯一索引可能有多个

create table `test`(
	`id` int(11) not null auto_increment primary,
	`name` varchar(20) not null union
    -- primary key(`id`),
    -- union key(`name`)
)

作用 : 快速定位特定数据

注意 :

• index 和 key 关键字都可以设置常规索引
• 应加在查询找条件的字段
• 不宜添加太多常规索引,影响数据的插入,删除和修改操作

create table `test`(
	index / key `ind`(`id`,'name')	-- 创建表的时候添加

)

-- 创建后添加
alter table `result` add index `ind`(`id`,`name`)

• 百度搜索：全文索引

  作用 : 快速定位特定数据

  注意 :

  • 只能用于MyISAM类型的数据表
  • 只能用于CHAR , VARCHAR , TEXT数据列类型
  • 适合大型数据集

创建索引：

create index indexname on table_name(field_name)	-- 为xxx表xxx字段创建名为xxx的索引
create index index_emp_ename on emp(ename)		-- 为emp表的ename字段创建名为index_emp_ename的索引

删除索引：

drop index indexname on table_name				-- 删除xxx表中名为xxx的索引
drop index index_emp_ename on emp				-- 删除emp中索引名为index_emp_ename的索引

查看一个sql语句中是否使用了索引

explain select * from emp where ename = 'king';
-- 使用索引

explain select * from emp where sal = 800
-- 未使用索引

索引失效

失效的第1种情况：
select * from emp where ename like ‘%T’;

​ ename上即使添加了索引，也不会走索引，为什么？

原因是因为模糊匹配当中以“%”开头了！尽量避免模糊查询的时候以“%”开始。这是一种优化的手段/策略。

失效的第2种情况：
使用or的时候会失效，如果使用or那么要求or两边的条件字段都要有索引，才会走索引，如果其中一边有一个字段没有索引，那么另一个字段上的索引也会实现。所以这就是为什么不建议使用or的原因。

失效的第3种情况：
在where当中索引列使用了函数
explain select * from emp where lower(ename) = ‘smith’;

索引是各种数据库进行优化的重要手段。优化的时候优先考虑的因素就是索引。

8.用户管理与数据备份

用户管理

/* 用户和权限管理 */ ------------------
用户信息表：mysql.user

-- 刷新权限
FLUSH PRIVILEGES

-- 增加用户 CREATE USER kuangshen IDENTIFIED BY '123456'
CREATE USER 用户名 IDENTIFIED BY [PASSWORD] 密码(字符串)
  - 必须拥有mysql数据库的全局CREATE USER权限，或拥有INSERT权限。
  - 只能创建用户，不能赋予权限。
  - 用户名，注意引号：如 'user_name'@'192.168.1.1'
  - 密码也需引号，纯数字密码也要加引号
  - 要在纯文本中指定密码，需忽略PASSWORD关键词。要把密码指定为由PASSWORD()函数返回的混编值，需包含关键字PASSWORD

-- 重命名用户 RENAME USER kuangshen TO kuangshen2
RENAME USER old_user TO new_user

-- 设置密码
SET PASSWORD = PASSWORD('密码')    -- 为当前用户设置密码
SET PASSWORD FOR 用户名 = PASSWORD('密码')    -- 为指定用户设置密码

-- 删除用户 DROP USER kuangshen2
DROP USER 用户名

-- 分配权限/添加用户
GRANT 权限列表 ON 表名 TO 用户名 [IDENTIFIED BY [PASSWORD] 'password']
  - all privileges 表示所有权限
  - *.* 表示所有库的所有表
  - 库名.表名 表示某库下面的某表

-- 查看权限   SHOW GRANTS FOR root@localhost;
SHOW GRANTS FOR 用户名
   -- 查看当前用户权限
  SHOW GRANTS; 或 SHOW GRANTS FOR CURRENT_USER; 或 SHOW GRANTS FOR CURRENT_USER();

-- 撤消权限
REVOKE 权限列表 ON 表名 FROM 用户名
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 用户名    -- 撤销所有权限

-- 权限列表
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] ...

数据备份

方式：

• 直接拷贝物理文件
• 手动导出
  • 右击想要导出的表->转储为SQL文件->结构和数据(数据)

-- 导出
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密码 库名 < 备份文件

9.三大范式

问题 : 为什么需要数据规范化?

不合规范的表设计会导致的问题：

• 信息重复

• 更新异常

• 插入异常

• 无法正确表示信息

• 删除异常

• 丢失有效信息

第一范式 (1st NF)

第一范式的目标是确保每列的原子性,如果每列都是不可再分的最小数据单元,则满足第一范式

第二范式(2nd NF)

第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。

第二范式要求要确保数据库表中的每一列都和主键相关，而不能只与主键的某一部分相关（主要针对联合主键而言）。

第三范式(3rd NF)

如果一个关系满足第二范式,并且除了主键以外的其他列都不传递依赖于主键列,则满足第三范式.

第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

规范化和性能的关系

为满足某种商业目标 , 数据库性能比规范化数据库更重要

在数据规范化的同时 , 要综合考虑数据库的性能

通过在给定的表中添加额外的字段,以大量减少需要从中搜索信息所需的时间

通过在给定的表中插入计算列,以方便查询

10.JDBC

IDEA与mysql连接

1.下载mysql-connector-java

2.新建一个项目，并在项目中新建一个lib文件夹，将下载好的jar包导入lib文件夹

jar包导入完成后，我们右击jar包，选择Add as Library，数据库的驱动就导入完成了

Java代码：

package com.demo1;

import com.sun.media.sound.SoftTuning;

import java.sql.*;

public class JdbcFirstTest {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //mysql 5.7固定写法
        //mysql8.0固定写法：com.mysql.cj.jdbc.Driver

        //2.用户信息和url
        //useUnicode=true&characterEncoding=utf8&useSSL=true
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
        //如果报错可以尝试将useSSL=true修改为false
        String username = "root";
        String password = "123456";

        //3.连接成功，数据库对象，Connection代表数据库
        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("birthday = " + resultSet.getObject("birthday"));
            System.out.println("=======================");
        }
               
        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

//DriverManager.registerDriver(new com.mysql.jdbc.Driver())
Class.forName("com.mysql.jdbc.Driver"); //mysql 5.7固定写法

 Connection connection = DriverManager.getConnection(url,username,password);
//connection 代表数据库

connection.setAutoCommit(); //设置事务自动提交
connection.commit();//事务提交
connection.rollback();//事务回滚

String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
//mysql -- 3306
//协议://主机地址:端口号/数据库名?参数1&参数2&参数3

statement.executeQuery();	//查询操作返回ResultSet
statement.execute();		//执行SQL
statement.executeUpdate();	//更新、插入、删除都是用该函数，返回一个影响到的行数

resultSet.getObject();		//在不知道类型的情况下使用
resultSet.getArray();		//知道类型使用指定方式
resultSet.getInt();
resultSet.getString();
resultSet.getDouble();

resultSet.next();           //移动到下一项
resultSet.previous();       //移动到前一项
resultSet.absolute(x);      //移动到第x项
resultSet.afterLast();      //移动到最后一项
resultSet.beforeFirst();    //移动到第一项

resultSet.close();
statement.close();
connection.close();		//十分消耗资源

crud代码实现

1.提取工具类

//JdcUtils.java
package com.lesson2.utils;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
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");

            //驱动只用加载一次即可
            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 statement, ResultSet resultSet){
       if(resultSet != null){
           try {
               resultSet.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       if(statement != null){
           try {
               statement.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       if(connection != null){
           try {
               connection.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
    }
}

dp.properties

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

package com.lesson2;

import com.lesson2.utils.JdbcUtils;

import java.net.SocketTimeoutException;
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();           //获取SQL的执行对象
            String sql ="insert into users(`id`,`name`,`password`,`email`,`birthday`)" +
                    "values('4','xiaotian','12314','12431241@qq.com','2000-11-12')";
            int i = statement.executeUpdate(sql);
            if(i > 0){
                System.out.println("插入成功!");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

//TestQuery.java 使用executeQuery(String sql)进行读取
package com.lesson2;

import com.lesson2.utils.JdbcUtils;

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

、
public class TestQuery {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection =  JdbcUtils.getConnection();            //获取数据库连接
            statement = connection.createStatement();           //获取SQL的执行对象
            String sql = "select * from users";
            resultSet = statement.executeQuery(sql);
            while(resultSet.next()){
                System.out.println(resultSet.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

//TestUpdate.java
package com.lesson2;

import com.lesson2.utils.JdbcUtils;

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

public class TestUpadate {

    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection =  JdbcUtils.getConnection();            //获取数据库连接
            statement = connection.createStatement();           //获取SQL的执行对象
            String sql ="update users set `name`='liming',`email`='liming@sina.com' where `id` = '1'";
            int i = statement.executeUpdate(sql);
            if(i > 0){
                System.out.println("更新成功!");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

//TestDelete.java
package com.lesson2;

import com.lesson2.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();           //获取SQL的执行对象
            String sql ="delete from users where id = 4";
            int i = statement.executeUpdate(sql);
            if(i > 0){
                System.out.println("删除成功!");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

注：只有查询用executeQuery方法，增删改都是使用executeUpdate()方法

SQL注入

package com.lesson2;

import com.lesson2.utils.JdbcUtils;

import java.rmi.StubNotFoundException;
import java.sql.*;

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 con = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            con = JdbcUtils.getConnection();
            st = con.createStatement();
			//"select * from users where name = ' ' or '1=1' and password = ' ' or '1=1'"
             String sql = "select * from users where name ='" + username + "' and password='" + password +"'" ;
            rs = st.executeQuery(sql);
            while(rs.next()){
                System.out.println("name:" + rs.getString("name"));
                System.out.println("pwd:" + rs.getString("password"));
                System.out.println("==================================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,rs);
        }
    }
}

Statement对象

Statement可以防止SQL注入，效率更高，更可靠

package com.lesson3;

import com.lesson2.utils.JdbcUtils;

import java.sql.*;
import java.util.Date;

public class TestInsert {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement st = null;
        try {
            con = JdbcUtils.getConnection();
            //preparedStatement要预先编译sql语句，并且使用?当做占位符，在获得PreparedStatement对象后
            //使用set方法进行赋值
            String sql = "insert into users(`id`,`name`,`password`,`email`,`birthday`) value(?,?,?,?,?)";
            st = con.prepareStatement(sql);
            st.setString(1,"4");
            st.setString(2,"xiaoming");
            st.setString(3,"13124124");
            st.setString(4,"124134122@qq.com");
            st.setDate(5,new java.sql.Date(new Date().getTime()));
            int i = st.executeUpdate();
            if(i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,null);
        }
    }
}

package com.lesson3;

import com.lesson2.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;


public class TestDelete {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement st = null;
        try {
            con = JdbcUtils.getConnection();
            String sql = "delete from users where id =?";
            st = con.prepareStatement(sql);
            st.setInt(1,4);
            int i = st.executeUpdate();
            if(i > 0){
                System.out.println("delete success");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,null);
        }
    }
}

package com.lesson3;

import com.lesson2.utils.JdbcUtils;

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

public class TestUpdate {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement st = null;
        try {
            con = JdbcUtils.getConnection();
            String sql = "update  users set name=?,email=? where id = ?";
            st = con.prepareStatement(sql);
            st.setString(1,"jack");
            st.setString(2,"2342424@qq.com");
            st.setInt(3,1);
            int i = st.executeUpdate();
            if(i > 0){
                System.out.println("update success");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,null);
        }
    }
}

package com.lesson3;

import com.lesson2.utils.JdbcUtils;

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

public class TestQuery {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement st = null;
        ResultSet rt = null;
        try {
            con = JdbcUtils.getConnection();
            String sql = "select * from users where id=?";
            st = con.prepareStatement(sql);
            st.setInt(1,1);
            rt = st.executeQuery();
            while(rt.next()){
                System.out.println("name: "+ rt.getString("name"));
                System.out.println("password: "+ rt.getString("password"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,null);
        }
    }
}

package com.lesson3;

import com.lesson2.utils.JdbcUtils;

import java.sql.*;

/**
 * @Descripition
 * @Author Zhouchang
 * @Date 2022/2/26 19:58
 * @Version 1.0
 */
public class SQL注入 {

    public static void main(String[] args) {
//        login(" ' or '1=1"," ' or '1=1");
        login("wangwu","123456");
    }
    public static void login(String username,String password){
        Connection con = null;
        PreparedStatement st = null;
        ResultSet rt = null;
        try {
            con = JdbcUtils.getConnection();
            String sql = "select * from users where name= ? and password = ?" ;
            st = con.prepareStatement(sql);
            st.setString(1,username);
            st.setString(2,password);
            rt = st.executeQuery();
            while(rt.next()){
                System.out.println("name:" + rt.getString("name"));
                System.out.println("pwd:" + rt.getString("password"));
                System.out.println("==================================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(con,st,rt);
        }
    }
}

IDEA 连接数据库

1.点击屏幕右侧的database

2.点击“+” -> “Data Source” -> 选中MySQL

3.输入账号和密码 ，点击apply

4.出现如下界面后点击设置按钮

5.选中Schemas选项，在出现的数据库中进行选择即可

6.双击想查看的表会出现相对应的信息

7.点击带有QL的小图标即可打开console窗口，在此处可以输入SQL语句进行操作

IDEA事务操作

package com.lesson4;

import com.lesson2.utils.JdbcUtils;

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


public class TestTransaction1 {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement st = null;
        try {
            con = JdbcUtils.getConnection();
            //关闭自动提交事务，自动开启事务
            con.setAutoCommit(false);

            String sql1 = "update account set money = money - 100 where name = 'A'";
            st = con.prepareStatement(sql1);
            st.executeUpdate();

            String sql2 = "update account set money = money + 100 where name = 'B'";
            st = con.prepareStatement(sql2);
            st.executeUpdate();

            con.commit();
            System.out.println("成功");
            con.setAutoCommit(true);
        } catch (SQLException e) {
            try {
                con.rollback();         //如果事务提交失败，则回滚
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            JdbcUtils.release(con,st,null);
        }

    }
}

DBCP连接池

commons-dbcp2-2.9.0、commons-logging-1.2、commons-pool2-2.11.1三个jar包导入后

配置properties文件

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

测试代码

package com.lesson5.utils;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @Descripition
 * @Author Zhouchang
 * @Date 2022/2/27 9:54
 * @Version 1.0
 */
public class JdbcUtils_DBCP {
    private static DataSource dataSource = null;
    static{
        try {
            InputStream is = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbconfig.properties");
            Properties properties = new Properties();
            properties.load(is);

            //创建数据源
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    public static void release(Connection con, 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(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}

package com.lesson5;

import com.lesson2.utils.JdbcUtils;
import com.lesson5.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;

public class TestDBCP {
    public static void main(String[] args) {
            Connection con = null;
            PreparedStatement st = null;
            try {
                con = JdbcUtils_DBCP.getConnection();
                String sql = "insert into users(`id`,`name`,`password`,`email`,`birthday`) value(?,?,?,?,?)";
                st = con.prepareStatement(sql);
                st.setString(1,"4");
                st.setString(2,"xiaoming");
                st.setString(3,"13124124");
                st.setString(4,"124134122@qq.com");
                st.setDate(5,new java.sql.Date(new Date().getTime()));
                int i = st.executeUpdate();
                if(i > 0){
                    System.out.println("插入成功");
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                JdbcUtils_DBCP.release(con,st,null);
            }
    }
}

public class JdbcUtils_DBCP {
    private static DataSource dataSource = null;
    static{
        try {
            InputStream is = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbconfig.properties");
            Properties properties = new Properties();
            properties.load(is);

        //创建数据源
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    public static void release(Connection con, 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(con != null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}



package com.lesson5;

import com.lesson2.utils.JdbcUtils;
import com.lesson5.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;

public class TestDBCP {
    public static void main(String[] args) {
            Connection con = null;
            PreparedStatement st = null;
            try {
                con = JdbcUtils_DBCP.getConnection();
                String sql = "insert into users(`id`,`name`,`password`,`email`,`birthday`) value(?,?,?,?,?)";
                st = con.prepareStatement(sql);
                st.setString(1,"4");
                st.setString(2,"xiaoming");
                st.setString(3,"13124124");
                st.setString(4,"124134122@qq.com");
                st.setDate(5,new java.sql.Date(new Date().getTime()));
                int i = st.executeUpdate();
                if(i > 0){
                    System.out.println("插入成功");
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                JdbcUtils_DBCP.release(con,st,null);
            }
    }
}