这只是mysql的入门。里面的很多东西需要去深入学习，这里可以认为是一个总纲，应付面试的，至于职业和学习，还需努把力把里面的东西吃透，还有之外的扩展。
1、学习数据库
为什么学习数据库
1、岗位技能需求
2、现在的世界,得数据者得天下
3、存储数据的方法
4、程序,网站中,大量数据如何长久保存?
5、数据库是几乎软件体系中最核心的一个存在。
什么是数据库
数据库 ( DataBase , 简称DB )
概念 : 长期存放在计算机内,有组织,可共享的大量数据的集合,是一个数据 “仓库”
作用 : 保存,并能安全管理数据(如:增删改查等),减少冗余…
数据库总览 :
-
关系型数据库 ( SQL )
-
- MySQL , Oracle , SQL Server , SQLite , DB2 , …
- 关系型数据库通过外键关联来建立表与表之间的关系
-
非关系型数据库 ( NOSQL )
-
- Redis , MongoDB , …
- 非关系型数据库通常指数据以对象的形式存储在数据库中，而对象之间的关系通过每个对象自身的属性来决定
什么是DBMS
数据库管理系统 ( DataBase Management System )
数据库管理软件 , 科学组织和存储数据 , 高效地获取和维护数据
为什么要说这个呢?
因为我们要学习的MySQL应该算是一个数据库管理系统.
MySQL简介
概念 : 是现在流行的开源的,免费的 关系型数据库
历史 : 由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下产品。
特点 :
- 免费 , 开源数据库
- 小巧 , 功能齐全
- 使用便捷
- 可运行于Windows或Linux操作系统
- 可适用于中小型甚至大型网站应用
官网 : https://www.mysql.com/
安装MySQL
这里建议大家使用压缩版,安装快,方便.不复杂.
软件下载
mysql5.7 64位下载地址:
https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.19-winx64.zip
电脑是64位的就下载使用64位版本的！
安装步骤
1、下载后得到zip压缩包.
2、解压到自己想要安装到的目录，本人解压到的是D:\Environment\mysql-5.7.19
3、添加环境变量：我的电脑->属性->高级->环境变量
选择PATH,在其后面添加: 你的mysql 安装文件下面的bin文件夹
4、编辑 my.ini 文件 ,注意替换路径位置
[mysqld]
basedir=D:\Program Files\mysql-5.7\
datadir=D:\Program Files\mysql-5.7\data\
port=3306
skip-grant-tables
5、启动管理员模式下的CMD，并将路径切换至mysql下的bin目录，然后输入mysqld –install (安装mysql)
6、再输入 mysqld --initialize-insecure --user=mysql 初始化数据文件
7、然后再次启动mysql 然后用命令 mysql –u root –p 进入mysql管理界面（密码可为空）
8、进入界面后更改root密码
update mysql.user set authentication_string=password('123456') where user='root' and Host = 'localhost';
9、刷新权限
flush privileges;
10、修改 my.ini文件删除最后一句skip-grant-tables
11、重启mysql即可正常使用
net stop mysql
net start mysql
12、连接上测试出现以下结果就安装好了
一步步去做 , 理论上是没有任何问题的 .
如果您以前装过,现在需要重装,一定要将环境清理干净 .
好了,到这里大家都装好了,因为刚接触,所以我们先不学习命令.
这里给大家推荐一个工具 : SQLyog .
即便有了可视化工具,可是基本的DOS命名大家还是要记住!
SQLyog
可手动操作,管理MySQL数据库的软件工具
特点 : 简洁 , 易用 , 图形化
使用SQLyog管理工具自己完成以下操作 :
-
连接本地MySQL数据库
-
新建MySchool数据库
-
- 字段
- GradeID : int(11) , Primary Key (pk)
- GradeName : varchar(50)
- 数据库名称MySchool
- 新建数据库表(grade)
在历史记录中可以看到相对应的数据库操作的语句 .
连接数据库
打开MySQL命令窗口
- 在DOS命令行窗口进入 安装目录\mysql\bin
- 可设置环境变量，设置了环境变量，可以在任意目录打开！
连接数据库语句 : mysql -h 服务器主机地址 -u 用户名 -p 用户密码
注意 : -p后面不能加空格,否则会被当做密码的内容,导致登录失败 !
几个基本的数据库操作命令 :
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
? 命令关键词 : 寻求帮助
-- 表示注释
1.1、 操作数据库
--所有的sql最好以分号结尾
net start mysql --启动mysql服务
net stop mysql --停止mysql服务
mysql -uroot -p123456 -- 连接数据库,sql的注释是--
--修改mysql数据库下的user表中的root用户的密码
update mysql.user set authentication_string=password('123456') where user='root' and Host = 'localhost'; -- 修改用户密码
flush privileges; -- 刷新权限
show databases; --查看所有数据库
use school; -- 切换数据库 格式：use 数据库名，出现Database change表示切换成功
show tables； -- 查看数据库中所有的表
describe 表名; --显示数据库中所有表的信息 = desc 表名
create database school; -- 创建一个数据库叫school
exit; -- 退出mysql连接
-- 单行注释
/*
多行注释
*/
数据库XXX语言CRUD操作
DDL 数据库定义语言
DML 数据库操作语言
DQL 数据库查询语言
DCL 数据库控制语言
2、操作数据库（了解）
操作数据库>操作数据库中的表>操作数据库中表的数据
mysql中的关键字是不区分大小写的
2.1、操作数据库
[]表示可以加也可以不加，看你使用
mysql中如果你的表名或者字段名是一个特殊词，关键字，最好加上tab上面的引号，``
-
创建数据库
CREATE DATABASE [IF NOT EXISTS] mydatabase;--如果这个数据库不存在的话就创建一个数据库mydatabase。 -
删除数据库
DROP DATABASE [IF EXISTS] mydatabase;--如果mydatabase这个数据库存在的话就删除这个数据库。
- 使用数据库
USE mydatabase;--使用数据库，USE + 库名
- 查看数据库
SHOW DATABASES;--查看mysql连接中的所有数据库
2.2、数据库的列类型
使用null计算，结果就是null，没啥意义。
2.3、数据库的字段属性（重点）
对于存储长度的一个常见错误：https://blog.csdn.net/github_26672553/article/details/82942313但是varchar是有关系的。
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
-
默认的
-
用于设置默认值
-
例如,性别字段,默认为"男" , 否则为 “女” ; 若无指定该列的值 , 则默认值为"男"的值
2.4、创建数据表
-- 目标 : 创建一个student数据库
-- 创建学生表(列,字段),使用sql语言创建
-- 学号int 登录密码varchar(20) 姓名,性别varchar(2),出生日期(datatime),家庭住址,email
-- 创建表之前 , 一定要先选择数据库，你得确定是在哪个数据库下面创建
--注意，使用英文()，表的名称和字段尽量在语言中使用``括起来
--AUTO_INCREMENT是自增
--字符串使用单引号括起来
--所有的语句后面加上英文的逗号，最后一个不加
--PRIMARY KEY是主键，一般一个表只有一个唯一主键，一般放在最后有标识性
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`)--设置id为主键
) ENGINE=InnoDB DEFAULT CHARSET=utf8
-- 查看数据库的定义语句的语句
SHOW CREATE DATABASE school;
-- 查看数据表的定义的语句
SHOW CREATE TABLE student;
-- 显示表结构
DESC student; -- 设置严格检查模式(不能容错了)SET sql_mode='STRICT_TRANS_TABLES';
--创建表的语言语法
CREATE TABLE [IF NOT EXISTS] `表名`(
'字段名' 列类型 [属性][索引][注释],
'字段名' 列类型 [属性][索引][注释],
......
'字段名' 列类型 [属性][索引][注释]
)[表类型][字符集设置][注释]
--ENGINE=InnoDB 是设置数据库引擎
--DEFAULT CHARSET=utf8设置数据库默认编码
-- 查看mysql所支持的引擎类型 (表类型)
SHOW ENGINES;
2.5、数据表的类型
MySQL的数据表的类型，也就是引擎 : MyISAM , InnoDB , HEAP , BOB , CSV等…
INNODB是默认使用的数据路引擎，MyISAM 是早些年使用的
常见的 MyISAM 与 InnoDB 类型：
常规使用操作：
- MYISAM 节约空间，因为占空间小所以速度较快也是可以理解
- INNODB 安全性高，支持事务的处理，因为外键的概念也是支持多表多用户操作
在物理空间中存在的位置
所有的数据库文件都存在mysql安装目录下的data目录下，每一个数据库是一个文件夹，里面的数据表是一个个文件，其本质就还是文件的存储！
MySql引擎在物理文件上的区别
- InnoDB在数据库表中只有一个*.frm，存的表结构文件，以及其上级目录下的ibdata1存在数据
- MYISAM 对应的文件
- *.frm 表结构的定义文件
- *.MYD 数据文件（data）
- *.MYI 索引文件（index）
设置数据库表的字符集编码
我们可为数据库,数据表,数据列设定不同的字符集，设定方法 :
CHARSET=utf8
- 创建时通过命令来设置 , 如 : CREATE TABLE 表名()CHARSET = utf8;
- 如无设定 , 则mysql会根据MySQL数据库配置文件 my.ini 中的参数设定（character-set-server=utf8），这种会导致通用性变低，我的电脑设置了，导出的sql不一定在那些没设置的人的电脑上能用。
- 如果都没设置,MYSQL的默认编码就是Latin1，这是拉丁文编码，不支持中文
2.6、修改删除表
修改表
修改表：
修改表名 : ALTER TABLE 旧表名 RENAME AS 新表名
--重命名数据表名
alter table student rename as studentnew;
添加字段 : ALTER TABLE 表名 ADD 字段名 列属性[属性]
--增加数据表的字段
alter table studentnew add age int(27);
修改字段 :包括重命名和修改约束
修改字段属性 : ALTER TABLE 表名 MODIFY 字段名 列类型[属性]
--修改字段约束，把int27改为varchar255
alter table studentnew MODIFY age varchar(255);
重命名字段 : ALTER TABLE 表名 CHANGE 旧字段名 新字段名 列属性[属性]
--重命名表字段名,修改age为age1 varchar（32）
alter table studentnew change age age1 varchar(32);
删除字段 : ALTER TABLE 表名 DROP 字段名
--删除表字段 age1
alter table studentnew drop age1;
删除表
--删除数据表
drop TABLE if EXISTS studentnew;
所有的创建和删除操作尽量加上判断，避免出错。
以上所有的操作全部使用英文。sql对于关键字大小写不敏感，但是建议最好还是小写，毕竟英语本来就不好，写个大写更不认识了。
创建表的时候最好在字段，表名上加上``。
3、MySQL数据管理
3.1、外键（不是很重要）
物理外键，数据表级别的
现在都不玩物理外键了，删改麻烦。删除有外键关系的表的时候，必须先删除引用人的表才能删。
以前有那种数据库级别的外键，创建表的时候加约束，很麻烦。而且因为这个外键的存在，你删除一个关联的时候会要求你把外键约束的一起删除或修改，但是这个在开发中还得处理，所以就不用了。现在用的都是逻辑外键，就是知道关联就行了逻辑上，实际在数据库表上没设置。
逻辑外键
其实就是表之间不存在关系了，但是我们在代码实现的时候知道有就可以，然后实现可以。
3.2、DML语言（及其重要）
数据库意义：数据存储，数据管理
DML语言：数据库操作语言
- insert
- update
- delete
3.3、添加
INSERT命令
语法：
INSERT INTO 表名[(字段1,字段2,字段3,...)] VALUES('值1','值2','值3')
注意 :
- 字段或值之间用英文逗号隔开 .
- ’ 字段1,字段2…’ 该部分可省略 , 但添加的值务必与表结构,数据列,顺序相对应,且数量一致
- 可同时插入多条数据 , values 后用英文逗号隔开 .
-- 使用语句如何增加语句?
-- 语法 : 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 ('大三'),('大四');
3.4、修改
update命令
语法：
UPDATE 表名 SET column_name=value [,column_name2=value2,...] [WHERE condition];
注意 :
- column_name 为要更改的数据列
- value 为修改后的数据 , 可以为变量 , 具体指 , 表达式或者嵌套的SELECT结果
- condition 为筛选条件 , 如不指定则修改该表的所有列数据
where条件子句
可以简单的理解为 : 有条件地从表中筛选数据
测试：
-- 修改年级信息
UPDATE grade SET gradename = '高中' WHERE gradeid = 1;
3.5、删除
DELETE命令
语法：
DELETE FROM 表名 [WHERE condition];
注意：condition为筛选条件 , 如不指定则删除该表的所有列数据,删库跑路。
-- 删除最后一个数据
DELETE FROM grade WHERE gradeid = 5
TRUNCATE命令
作用：用于完全清空表数据 , 但表结构 , 索引 , 约束等不变 ;
语法：
TRUNCATE [TABLE] table_name;
-- 清空年级表
TRUNCATE grade
注意：区别于DELETE命令
-
相同 : 都能删除数据 , 不删除表结构 , 但TRUNCATE速度更快
-
不同 :
-
- 使用TRUNCATE TABLE 重新设置AUTO_INCREMENT计数器，删完之后自增列归0
- 使用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 : 自增列依然从上一个自增数据基础上开始 (因为存在文件中,相当于磁盘外存中，不会丢失)
4、DQL查询数据
DQL( Data Query Language 数据查询语言 )
- 查询数据库数据 , 如SELECT语句
- 简单的单表查询或多表的复杂查询和嵌套查询
- 是数据库语言中最核心,最重要的语句
- 使用频率最高的语句
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}];
-- 指定查询的记录从哪条至哪条
注意 : [ ] 括号代表可选的 , { }括号代表必选得
4.1、指定查询字段
-- 查询表中所有的数据列结果 , 采用 **" \* "** 符号; 但是效率低，不推荐 .
-- 查询所有学生信息
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关键字的使用
作用 : 去掉SELECT查询返回的记录结果中重复的记录 ( 返回所有列的值都相同 ) , 只返回一条
-- # 查看哪些同学参加了考试(学号) 去除重复项
SELECT * FROM result; -- 查看考试成绩
SELECT studentno FROM result; -- 查看哪些同学参加了考试
SELECT DISTINCT studentno FROM result; -- 了解:DISTINCT 去除重复项 , (默认是ALL)
对于这个去重的用法，下面我有一些总结：
在表中，可能会包含重复值。这并不成问题，不过，有时您也许希望仅仅列出不同（distinct）的值。关键词 distinct用于返回唯一不同的值。
表A：
表B:
1.作用于单列
select distinct name from A
执行后结果如下：
2.作用于多列
示例2.1
select distinct name, id from A
执行后结果如下：
实际上是根据name和id两个字段来去重的，这种方式Access和SQL Server同时支持。
示例2.2
select distinct xing, ming from B
返回如下结果：
返回的结果为两行，这说明distinct并非是对xing和ming两列“字符串拼接”后再去重的，而是分别作用于了xing和ming列。
3.COUNT统计
select count(distinct name) from A; --表中name去重后的数目， SQL Server支持，而Access不支持
``
count是不能统计多个字段的，下面的SQL在SQL Server和Access中都无法运行。
select count(distinct name, id) from A;
若想使用，请使用嵌套查询，如下：
select count(*) from (select distinct xing, name from B) AS M;
4.distinct必须放在开头
select id, distinct name from A; --会提示错误，因为distinct必须放在开头
5.其他
distinct语句中select显示的字段只能是distinct指定的字段，其他字段是不可能出现的。例如，假如表A有“备注”列，如果想获取distinc name，以及对应的“备注”字段，想直接通过distinct是不可能实现的。但可以通过其他方法实现[关于SQL Server将一列的多行内容拼接成一行的问题讨论](http://www.cnblogs.com/rainman/archive/2013/05/03/3058413.html)
> 使用表达式的列
数据库中的表达式 : 一般由文本值 , 列值 , NULL , 函数和操作符等组成
应用场景 :
- SELECT语句返回结果列中使用
- SELECT语句中的ORDER BY , HAVING等子句中使用
- DML语句中的 where 条件语句中使用表达式
```sql
-- selcet查询中可以使用表达式
SELECT @@auto_increment_increment; -- 查询自增步长
SELECT VERSION(); -- 查询版本号
SELECT 100*3-1 AS 计算结果; -- 表达式
-- 学员考试成绩集体提分一分查看
SELECT studentno,StudentResult+1 AS '提分后' FROM result;
- 避免SQL返回结果中包含 ’ . ’ , ’ * ’ 和括号等干扰开发语言程序.
4.2、where条件语句
作用：用于检索数据表中 符合条件 的记录
搜索条件可由一个或多个逻辑表达式组成 , 结果一般为真或假.
逻辑操作符
测试
-- 满足条件的查询(where)
SELECT Studentno,StudentResult FROM result;
-- 查询考试成绩在95-100之间的
SELECT Studentno,StudentResult
FROM result
WHERE StudentResult>=95 AND StudentResult<=100;
-- AND也可以写成 &&
SELECT Studentno,StudentResult
FROM result
WHERE StudentResult>=95 && StudentResult<=100;
-- 模糊查询(对应的词:精确查询)
SELECT Studentno,StudentResult
FROM result
WHERE StudentResult BETWEEN 95 AND 100;
-- 除了1000号同学,要其他同学的成绩
SELECT studentno,studentresult
FROM result
WHERE studentno!=1000;
-- 使用NOT
SELECT studentno,studentresult
FROM result
WHERE NOT studentno=1000;
模糊查询 ：比较操作符
注意：
- 数值数据类型的记录之间才能进行算术运算 ;
- 相同数据类型的数据之间才能进行比较 ;
测试：
-- 模糊查询 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,1002);
-- 查询地址在北京,南京,河南洛阳的学生
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;
4.3、连接查询
JOIN 对比
这里开始学习到了mysql的关联表查询的内容，首先明确一个概念叫笛卡尔积：
所谓笛卡尔积,通俗点说就是指包含两个集合中任意取出两个元素构成的组合的集合。通俗的说就是两张表，做一次笛卡尔积操作，就是把两个表的各个行都进行一对多组合一次，这叫完全笛卡尔乘积。
而多表查询的目的就是在确定好使用哪些表之后，将多个表先通过笛卡尔积变成一个表，然后通过on或where去掉不符合要求的数据（根据两个表的关系去掉），最后的结果是一个虚拟表，此时还可以加上where对这个虚拟表做最后的筛选条件。
左连接：left join
其实际上是以左表为主，挨个去匹配右表中的数据，只要符合条件就返回，然后左表中没在右表中找到符合条件的数据就列出来，右表那边返回null
简而言之就是：左表和右边能匹配的列出，左表找不到匹配的和null匹配。最终左表是全部查出，右表符合条件的查出
右连接:right join
其实际上是以右表为主，挨个去匹配左表中的数据，只要符合条件就返回，然后右表中没在左表中找到符合条件的数据就列出来，左表那边返回null
简而言之就是：右表和左边能匹配的列出，右表找不到匹配的和null匹配。最终右表是全部查出，左表符合条件的查出
内连接:inner join
如果在查询中，使用inner jion这个操作，其实际上是只返回符合后面的筛选条件的数据，也就是最终返回的是左表中和右表中都符合的数据，不符合的就不会查到
/*
多表联查的思路：
1、分析需求，分析查询的字段来自于哪些表（确定关联查询的对象）
2、确定使用哪种连接查询？共七种可以选择。
3、确定交叉点（就是关联外键）
4、确定筛选条件
多表联查的思想就是每次关联出来的是一个虚拟表，数据库中并不存在该表。
然后使用这个虚拟表再去和下一个表去关联，再来一次这个关联查询。所以
不要追求一次写出，一步一步来，一个一个关联。
*/
/*
本次需求：查询参加了考试的同学（学号，姓名，科目编号，分数）
首先我们发现，这几个目标字段不是在一张学生表或者成绩表就能取得，
它是分布在了学生和成绩两张表
1、确定查询表为学生表和成绩表
2、因为要显示的是参加了考试的学生的成绩和信息，那就不用把所有的
学生都列出来，只需要查询参加了考试的学生，所以应该是：
2.1、以成绩表为主表，使用左连接；
2.2、以学生表为主表，使用内连接；
2.3、以成绩表为主表，使用内连接；
2.4、以学生表为主表，使用右连接。
以上四种都能实现；
*/
/*
连接查询
如需要多张数据表的数据进行查询,则可通过连接运算符实现多个查询
内连接 inner join
查询两个表中的结果集中的交集
外连接 outer join
左外连接 left join
(以左表作为基准,右边表来一一匹配,匹配不上的,返回左表的记录,右表以NULL填充)
右外连接 right join
(以右表作为基准,左边表来一一匹配,匹配不上的,返回右表的记录,左表以NULL填充)
等值连接和非等值连接
自连接
*/
--我们来分析一下上面那四种为啥可行这个过程：
/**
我们想查出所有参加考试了的学生：
先查出笛卡尔积：
2.1、以成绩表为主表，使用左连接；
2.2、以学生表为主表，使用内连接；
2.3、以成绩表为主表，使用内连接；
2.4、以学生表为主表，使用右连接。
*/
--以成绩表为主表，使用左连接；
SELECT s.studentno,studentname,subjectno,studentresult FROM result r LEFT JOIN student s ON s.studentno=r.studentno;
--以学生表为主表，使用内连接；
SELECT s.studentno,studentname,subjectno,studentresult FROM student s INNER JOIN result r ON s.studentno=r.studentno;
--以成绩表为主表，使用内连接；
SELECT s.studentno,studentname,subjectno,studentresult FROM result r INNER JOIN student s ON s.studentno=r.studentno;
--以学生表为主表，使用右连接。有成绩的一定是参加了考试的，所以把成绩的部分全列出来，再对应去学生表里找到该成绩的学生信息，也是一样
SELECT s.studentno,studentname,subjectno,studentresult FROM student s RIGHT JOIN result r ON s.studentno=r.studentno;
测试
/*
连接查询
如需要多张数据表的数据进行查询,则可通过连接运算符实现多个查询
内连接 inner join
查询两个表中的结果集中的交集
外连接 outer join
左外连接 left join
(以左表作为基准,右边表来一一匹配,匹配不上的,返回左表的记录,右表以NULL填充)
右外连接 right join
(以右表作为基准,左边表来一一匹配,匹配不上的,返回右表的记录,左表以NULL填充)
等值连接和非等值连接
自连接
*/
-- 查询参加了考试的同学信息(学号,学生姓名,科目编号,分数)
SELECT * FROM student;
SELECT * FROM result;
/*思路:
(1):分析需求,确定查询的列来源于两个类,student result,连接查询
(2):确定使用哪种连接查询?(内连接)
*/
SELECT s.studentno,studentname,subjectno,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
-- 右连接(也可实现)
SELECT s.studentno,studentname,subjectno,StudentResult
FROM student s
RIGHT JOIN result r
ON r.studentno = s.studentno
-- 等值连接
SELECT s.studentno,studentname,subjectno,StudentResult
FROM student s , result r
WHERE r.studentno = s.studentno
-- 左连接 (查询了所有同学,不考试的也会查出来)
SELECT s.studentno,studentname,subjectno,StudentResult
FROM student s
LEFT JOIN result r
ON r.studentno = s.studentno
-- 查一下缺考的同学(左连接应用场景)
SELECT s.studentno,studentname,subjectno,StudentResult
FROM student s
LEFT JOIN result r
ON r.studentno = s.studentno
WHERE StudentResult IS NULL
-- 思考题:查询参加了考试的同学信息(学号,学生姓名,科目名,分数)
SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno--先连接出这个虚拟表为A
INNER JOIN `subject` sub
ON sub.subjectno = r.subjectno--再和虚拟表A去做操作连接
--所以要是多表联查，不要一次写完，一张表联完，以此为基础再去联下一张，一步一步来。
where和on的区别之处：
参考这一篇文章，说的很清晰：https://blog.csdn.net/xc008/article/details/2872310
自连接
/*
自连接
数据表与自身进行连接，核心就是一张表拆为两张一样的表即可。
需求:从一个包含栏目ID , 栏目名称和父栏目ID的表中
查询父栏目名称和其他子栏目名称
*/
关于自连接，这个和case when一样是我内心挥之不去的阴影。我在这里总结一下，虽说这个东西不重要，但是它有个特定的使用场景，它常用于一张表里有存在层级关系的情况。
我们以一个课程专业表为例子来看一下：
categoryid:课程id pid：课程的上级id categoryname:课程名字
| categoryid | pid | categoryname |
|---|---|---|
| 2 | 1 | 信息技术 |
| 3 | 1 | 软件开发 |
| 4 | 3 | 数据库 |
| 5 | 1 | 美术设计 |
| 6 | 3 | web开发 |
| 7 | 5 | ps技术 |
| 8 | 2 | 办公信息 |
上面这张表就存在一个等级关系，此时我们发现这个表里有两种数据，就是子类和父类，我们的需求是显示出父类下面的子类：如下
| 父类 | 子类 |
|---|---|
| 信息技术 | 办公信息 |
| 软件开发 | 数据库 |
| 软件开发 | web开发 |
。。。
但是一张表里面，你不管怎么查你也做不到能显示成这样，所以我们可以这样理解，其实这是两张表：
父类表：（上级为1的都是父类，根节点）
| categoryid | pid | categoryname |
|---|---|---|
| 2 | 1 | 信息技术 |
| 3 | 1 | 软件开发 |
| 5 | 1 | 美术设计 |
子类表：
| categoryid | pid | categoryname |
|---|---|---|
| 4 | 3 | 数据库 |
| 6 | 3 | web开发 |
| 7 | 5 | ps技术 |
| 8 | 2 | 办公信息 |
这样我们就把一个表分为父类和子类两个表，再显示父类下的子类就是一次等值查询了：
--把一个表看成两个，a当成父类表，b是子类表，从a里取父信息，从b里取子信息
SELECT a.categoryname AS '父课',b.categoryname AS '子课' FROM category a,category b WHERE a.categoryid = b.pid;
4.4、排序和分页
测试
/*============== 排序 ================
语法 : 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
4.5、子查询
/*============== 子查询 ================
什么是子查询?
在查询语句中的WHERE条件子句中,又嵌套了另一个查询语句
嵌套查询可由多个子查询组成,求解的方式是由里及外;
子查询返回的结果一般都是集合,故而建议使用IN关键字;
*/
--写的时候，先把子的写出来，然后两个sql一拼就好了，不用一次写出，所有的非单表查询都要一步一步写出来，不管是什么时候都不能浪
-- 查询 数据库结构-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 studentnoIN(
SELECT studentno FROM result WHERE StudentResult>=80 ANDsubjectno=(
SELECT subjectno FROM `subject` WHERE subjectname = '高等数学-2'
)
)
5、MySQL函数
5.1、常用函数
数据函数
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.2、聚合函数
| 函数名称 | 描述 |
|---|---|
| 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的不是主键的时候，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;
我还是总结一下我的关于count的面试题：都是基于innodb引擎而言的：
首先要弄清楚 count() 的语义。count() 是一个聚合函数，对于返回的结果集，一行行地判断， 如果 count 函数的参数不是 NULL，累计值就加 1，否则不加。最后返回累计值。
所以，count(*)、count(1)和count(主键 id) 都表示返回满足条件的结果集的总行数；而 count(字段），则表示返回满足条件的数据行里面，参数“字段”不为 NULL 的总个数。
count(可空字段)
扫描全表，读到server层，判断字段可空，拿出该字段所有值，判断每一个值是否为空，不为空则累加
count(非空字段)与count(主键 id)
扫描全表，读到server层，判断字段不可空，按行累加。
count(1)
扫描全表，但不取值，server层收到的每一行都是1，判断不可能是null，按值累加。
注意：count(1)执行速度比count(主键 id)快的原因：从引擎返回 id 会涉及到解析数据行，以及拷贝字段值的操作。
count(*)
MySQL 执行count(*)在优化器做了专门优化。因为count(*)返回的行一定不是空。扫描全表，但是不取值，按行累加。
看到这里，你会说优化器就不能自己判断一下吗，主键 id 肯定是非空的，为什么不能按照 count(*) 来处理，多么简单的优化。当然 MySQL 专门针对这个语句进行优化也不是不可以。但是这种需要专门优化的情况太多了，而且 MySQL 已经优化过 count(*) 了，你直接使用这种语句就可以了。
性能对比结论
count(可空字段)，扫全表，mysql会去判断是不是空，最慢
count(非空字段)，扫全表，mysql会直接取，少了判断，次之
count(主键 id) ：扫全表，扫主键 ，会取到id的值，不判断，再次之 count(1) ≈ count(*) ：
count(可空字段) < count(非空字段) = count(主键 id) < count(1) ≈ count(*)
https://www.cnblogs.com/hider/p/11726690.html
再理解：
对于 count(主键 id) 来说，InnoDB 引擎会遍历整张表，把每一行的 id 值都取出来，返回给 server 层。server 层拿到 id 后，判断是不可能为空的，就按行累加。
对于 count(1) 来说，InnoDB 引擎遍历整张表，但不取值。server 层对于返回的每一行，放一个数字“1”进去，判断是不可能为空的，按行累加。
单看这两个用法的差别的话，你能对比出来，count(1) 执行得要比 count(主键 id) 快。因为从引擎返回 id 会涉及到解析数据行，以及拷贝字段值的操作。
对于 count(字段) 来说：如果这个“字段”是定义为 not null 的话，一行行地从记录里面读出这个字段，判断不能为 null，按行累加；
如果这个“字段”定义允许为 null，那么执行的时候，判断到有可能是 null，还要把值取出来再判断一下，不是 null 才累加。也就是前面的第一条原则，server 层要什么字段，InnoDB 就返回什么字段。
但是 count(*) 是例外，并不会把全部字段取出来，而是专门做了优化，不取值。count(*) 肯定不是 null，按行累加。
看到这里，你一定会说，优化器就不能自己判断一下吗，主键 id 肯定非空啊，为什么不能按照 count(*) 来处理，多么简单的优化啊。
当然，MySQL 专门针对这个语句进行优化，也不是不可以。但是这种需要专门优化的情况太多了，而且 MySQL 已经优化过 count(*) 了，你直接使用这种用法就可以了。
所以结论是：按照效率排序的话，count(字段)<count(主键 id)<count(1)≈count(*)，所以我建议你，尽量使用 count(*)。
题目：
-- 查询不同课程的平均分,最高分,最低分
-- 前提:根据不同的课程进行分组
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前面.执行的，也就是说where的时候还没group呢，你还没分组呢，也就筛 不出来了
要是放在分组后面的筛选
要使用HAVING..，对分组后的数据筛选
因为having是从前面筛选的字段再筛选，而where是从数据表中的>字段直接进行的筛选的
*/
--这是执行顺序：
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}];
-- 指定查询的记录从哪条至哪条
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=utf8
插入一些数据
INSERT INTO testmd5 VALUES(1,'kuangshen','123456'),(2,'qinjiang','456789')
如果我们要对pwd这一列数据进行加密，语法是：
update testmd5 set pwd = md5(pwd);
如果单独对某个用户(如kuangshen)的密码加密：
INSERT INTO testmd5 VALUES(3,'kuangshen2','123456')
update testmd5 set pwd = md5(pwd) where name = 'kuangshen2';
插入新的数据自动加密
INSERT INTO testmd5 VALUES(4,'kuangshen3',md5('123456'));
查询登录用户信息（md5对比使用，查看用户输入加密后的密码进行比对）
SELECT * FROM testmd5 WHERE `name`='kuangshen' ANDpwd=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、事务
6.1、什么是事务
原则：要么都成功，要么都失败。
什么是事务
- 事务就是将一组SQL语句放在同一批次内去执行
- 如果一个SQL语句出错,则该批次内的所有SQL都将被取消执行
- MySQL事务处理只支持InnoDB和BDB数据表类型，最新版本，myIsam也支持了
事务的ACID原则 百度 ACID
原子性(Atomic)
- 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。
一致性(Consist)
- 事务前后的数据完整性要一致，你转账前，两个人是1000，转完了还得是1000，不能变这个。
隔离性(Isolated)
- 事务的隔离性是指多个用户并发访问数据库的时候，数据库为每一个用户开启的事务不能被其他事务的操作数据所干扰，事务之间要有相互隔离。
- 但是一旦被干扰就会产生以下几个经典问题，隔离所导致问题：
- 脏读：指一个事务读取了另外一个事务未提交的数据。
- 不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同，这个不一定错，可能某些场合不对
- 虚读（幻读）:是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。一般是多了一行。
持久性(Durable)
- 在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
- 事务如果没有提交就挂了，那就恢复到原状，提交了就写入数据库，一旦提交不可逆
https://www.cnblogs.com/wyaokai/p/10921323.html
基本语法
-- 使用set语句来改变自动提交模式
SET autocommit = 0; /*关闭*/
SET autocommit = 1; /*开启*/
-- 注意:
--- 1.MySQL中默认是自动提交，默认开启事务
--- 2.使用事务时应先关闭自动提交
-- 开始一个事务,标记事务的起始点
START TRANSACTION
-- 提交一个事务给数据库
COMMIT
-- 将事务回滚,数据回到本次事务的初始状态
ROLLBACK
-- 还原MySQL数据库的自动提交，再次设置为自动提交，不然以后每次都得自己提交
SET autocommit =1;
-- 保存点
SAVEPOINT 保存点名称 -- 设置一个事务保存点
ROLLBACK TO SAVEPOINT 保存点名称 -- 回滚到保存点
RELEASE SAVEPOINT 保存点名称 -- 删除保存点
测试
/*
课堂测试题目
A在线买一款价格为500元商品,网上银行转账.
A的银行卡余额为2000,然后给商家B支付500.
商家B一开始的银行卡余额为10000
创建数据库shop和创建表account并插入2条数据
*/
CREATE DATABASE `shop`CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `shop`;
CREATE TABLE `account` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(32) NOT NULL,
`cash` DECIMAL(9,2) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO account (`name`,`cash`)
VALUES('A',2000.00),('B',10000.00)
-- 转账实现
SET autocommit = 0; -- 关闭自动提交，设置为手动
START TRANSACTION; -- 开始一个事务,标记事务的起始点
UPDATE account SET cash=cash-500 WHERE `name`='A';
UPDATE account SET cash=cash+500 WHERE `name`='B';
COMMIT; -- 提交事务，数据被持久化
# rollback;
SET autocommit = 1; -- 恢复自动提交
7、索引
索引的作用
- 提高查询速度
- 确保数据的唯一性
- 可以加速表和表之间的连接 , 实现表与表之间的参照完整性
- 使用分组和排序子句进行数据检索时 , 可以显著减少分组和排序的时间
- 全文检索字段进行搜索优化.
分类
- 主键索引 (Primary Key)
- 唯一索引 (Unique)
- 常规索引 (Index)
- 全文索引 (FullText)
主键索引
主键 : 某一个属性组能唯一标识一条记录
特点 :
- 最常见的索引类型
- 确保数据记录的唯一性
- 确定特定数据记录在数据库中的位置
唯一索引
作用 : 避免同一个表中某数据列中的值重复
与主键索引的区别
- 主键索引只能有一个，只能对主键是主键索引
- 唯一索引可能有多个，其他列都能成为唯一索引，就是你把它设为unique，然后这一列数据就不能重复了，这就成为了唯一索引
CREATE TABLE `Grade`(
`GradeID` INT(11) AUTO_INCREMENT PRIMARYKEY,
`GradeName` VARCHAR(32) NOT NULL UNIQUE
-- 或 UNIQUE KEY `GradeID` (`GradeID`)
)
常规索引
作用 : 快速定位特定数据
注意 :
- index 和 key 关键字都可以设置常规索引
- 应加在查询找条件的字段
- 不宜添加太多常规索引,影响数据的插入,删除和修改操作
CREATE TABLE `result`(
-- 省略一些代码
INDEX/KEY `ind` (`studentNo`,`subjectNo`) -- 创建表时添加
)
-- 创建后添加
ALTER TABLE `result` ADD INDEX `ind`(`studentNo`,`subjectNo`);
全文索引
百度搜索：全文索引
作用 : 快速定位特定数据
注意 :
- 只能用于MyISAM类型的数据表
- 只能用于CHAR , VARCHAR , TEXT数据列类型
- 适合大型数据集
/*
#方法一：创建表时
CREATE TABLE 表名 (
字段名1 数据类型 [完整性约束条件…],
字段名2 数据类型 [完整性约束条件…],
[UNIQUE | FULLTEXT | SPATIAL ] INDEX | KEY
[索引名] (字段名[(长度)] [ASC |DESC])
);
#方法二：CREATE在已存在的表上创建索引
CREATE [UNIQUE | FULLTEXT | SPATIAL ] INDEX 索引名
ON 表名 (字段名[(长度)] [ASC |DESC]) ;
#方法三：ALTER TABLE在已存在的表上创建索引
ALTER TABLE 表名 ADD [UNIQUE | FULLTEXT | SPATIAL ] INDEX
索引名 (字段名[(长度)] [ASC |DESC]) ;
#删除索引：DROP INDEX 索引名 ON 表名字;
#删除主键索引: ALTER TABLE 表名 DROP PRIMARY KEY;
#显示索引信息: SHOW INDEX FROM student;
*/
/*增加全文索引*/
ALTER TABLE `school`.`student` ADD FULLTEXT INDEX `studentname` (`StudentName`);
/*EXPLAIN : 分析SQL语句执行性能*/
EXPLAIN SELECT * FROM student WHERE studentno='1000';
/*使用全文索引*/
-- 全文搜索通过 MATCH() 函数完成。
-- 搜索字符串作为 against() 的参数被给定。搜索以忽略字母大小写的方式执行。对于表中的每个记录行，MATCH() 返回一个相关性值。即，在搜索字符串与记录行在 MATCH() 列表中指定的列的文本之间的相似性尺度。
EXPLAIN SELECT *FROM student WHERE MATCH(studentname) AGAINST('love');
/*
开始之前，先说一下全文索引的版本、存储引擎、数据类型的支持情况
MySQL 5.6 以前的版本，只有 MyISAM 存储引擎支持全文索引；
MySQL 5.6 及以后的版本，MyISAM 和 InnoDB 存储引擎均支持全文索引;
只有字段的数据类型为 char、varchar、text 及其系列才可以建全文索引。
测试或使用全文索引时，要先看一下自己的 MySQL 版本、存储引擎和数据类型是否支持全文索引。
*/
拓展：测试索引
建表app_user：
CREATE TABLE `app_user` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(50) DEFAULT '' COMMENT '用户昵称',
`email` varchar(50) NOT NULL COMMENT '用户邮箱',
`phone` varchar(20) DEFAULT '' COMMENT '手机号',
`gender` tinyint(4) unsigned DEFAULT '0' COMMENT '性别（0:男；1：女）',
`password` varchar(100) NOT NULL COMMENT '密码',
`age` tinyint(4) DEFAULT '0' COMMENT '年龄',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP,
`update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ONUPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='app用户表'
批量插入数据：100w
DROP FUNCTION IF EXISTS mock_data;
DELIMITER $$
CREATE FUNCTION mock_data()
RETURNS INT
BEGIN
DECLARE num INT DEFAULT 1000000;
DECLARE i INT DEFAULT 0;
WHILE i < num DO
INSERT INTO app_user(`name`, `email`, `phone`, `gender`, `password`, `age`)
VALUES(CONCAT('用户', i), '24736743@qq.com', CONCAT('18', FLOOR(RAND()*(999999999-100000000)+100000000)),FLOOR(RAND()*2),UUID(), FLOOR(RAND()*100));
SET i = i + 1;
END WHILE;
RETURN i;
END;
SELECT mock_data();
索引效率测试
无索引
SELECT * FROM app_user WHERE name = '用户9999'; -- 查看耗时
SELECT * FROM app_user WHERE name = '用户9999';
SELECT * FROM app_user WHERE name = '用户9999';
--耗时很长
mysql> EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: app_user
partitions: NULL
type: ALL
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 992759--查到了992759行数据才找到
filtered: 10.00
Extra: Using where
1 row in set, 1 warning (0.00 sec)
创建索引：id_表名__字段名一般这样命名
CREATE INDEX idx_app_user_name ON app_user(name);
测试普通索引
mysql> EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: app_user
partitions: NULL
type: ref
possible_keys: idx_app_user_name
key: idx_app_user_name
key_len: 203
ref: const
rows: 1--查找了一条直接定位，这个基于底层的树
filtered: 100.00
Extra: NULL
1 row in set, 1 warning (0.00 sec)
mysql> SELECT * FROM app_user WHERE name = '用户9999';
1 row in set (0.01 sec)
mysql> SELECT * FROM app_user WHERE name = '用户9999';
1 row in set (0.01 sec)
mysql> SELECT * FROM app_user WHERE name = '用户9999';
1 row in set (0.01 sec)
索引准则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表建议不要加索引
- 索引一般应加在查找条件的字段
索引的数据结构
-- 我们可以在创建上述索引的时候，为其指定索引类型，分两类
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等索引；
--索引的底层原理建议看这个，写的非常好。
http://blog.codinglabs.org/articles/theory-of-mysql-index.html
8、权限管理和备份
8.1、用户管理
使用SQLyog 创建用户，并授予权限演示
基本命令
/* 用户和权限管理 */ ------------------
用户信息表：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] ...
8.2、 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密码 库名 < 备份文件
9、 规范化数据库设计
9.1、 为什么需要数据库设计
当数据库比较复杂时我们需要设计数据库
糟糕的数据库设计 :
- 数据冗余,存储空间浪费
- 数据更新和插入的异常
- 程序性能差
良好的数据库设计 :
- 节省数据的存储空间
- 能够保证数据的完整性
- 方便进行数据库应用系统的开发
软件项目开发周期中数据库设计 :
- 需求分析阶段: 分析客户的业务和数据处理需求
- 概要设计阶段:设计数据库的E-R模型图 , 确认需求信息的正确和完整.
设计数据库步骤
-
收集信息
-
- 与该系统有关人员进行交流 , 座谈 , 充分了解用户需求 , 理解数据库需要完成的任务.
-
标识实体[Entity]
-
- 标识数据库要管理的关键对象或实体,实体一般是名词
-
标识每个实体需要存储的详细信息[Attribute]
-
标识实体之间的关系[Relationship]
9.2、 三大范式
问题 : 为什么需要数据规范化?
不合规范的表设计会导致的问题：
-
信息重复
-
更新异常
-
插入异常
-
- 无法正确表示信息
-
删除异常
-
- 丢失有效信息
三大范式
第一范式 (1st NF)
第一范式的目标是确保每列的原子性,如果每列都是不可再分的最小数据单元,则满足第一范式
第二范式(2nd NF)
第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。
第二范式要求每个表只描述一件事情
第三范式(3rd NF)
如果一个关系满足第二范式,并且除了主键以外的其他列都不传递依赖于主键列,则满足第三范式.
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。
规范化和性能的关系
为满足某种商业目标 , 数据库性能比规范化数据库更重要
在数据规范化的同时 , 要综合考虑数据库的性能
通过在给定的表中添加额外的字段,以大量减少需要从中搜索信息所需的时间
通过在给定的表中插入计算列,以方便查询
10、JDBC(重点)
10.1、数据库驱动
驱动是一个小块代码，或者是一个小的应用，有了这个东西，计算机就能和其他东西通信，能实现一些功能。
驱动有：声卡驱动，显卡驱动，数据库驱动
我们的程序是通过一个数据库驱动的包去实现和数据库打交道。
但是还不够，比如说，我们有各种各样的数据库，我列出的就三种了，那难道我们要有各种各样的驱动吗。所以后来为了方便管理，方便开发，出现了JDBC的这个东西，它实现了一堆接口，包括各种数据库类型的，在中间加了这么一层，就完成了编程应用和数据库的沟通。
10.2、JDBC
SUN公司为了简化开发人员对数据库的统一操作，提供一个java操作数据库的规范，就是jdbc，这些规范的具体实现由厂商完成，我们只负责编程即可。
10.3、第一个JDBC程序
package com.lwq.leson01;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JdbcFirstDemo {
public static void main(String[] args) throws Exception{
//加载mysql数据库驱动,固定写法，相当于你打开nivacat链接那一下，其实所有的操作都和使用工具一样，只不过是用java实现的
Class.forName("com.mysql.jdbc.Driver");
//用户信息和连接URL useUnicode=true是设置支持中文 characterEncoding=utf8是处理乱码 useSSL=false安全连接
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
String username = "root";
String password = "123456";
//获取数据库连接，就相当于在nivicat上打开对应的那个数据库
Connection connection = DriverManager.getConnection(url, username, password);
//拼写sql
String sql = "SELECT * FROM users";
//在这个打开的数据库上创建执行sql的对象，就相当于打开查询那个窗口
Statement statement = connection.createStatement();
//执行对应sql,得到查询的结果集，结果集中要是有数据就输出
ResultSet resultSet = statement.executeQuery(sql);
/**
* resultSet是一个链表集合
* get可以指定类型比如getString,只要你确定类型就可以，不确定可以用getObject
* get里面的是对应数据库的，其实就相当于此时从结果表里取，所以要一一对应数据库字段，大小写也对应
*/
while(resultSet.next()){
System.out.println("id:" + resultSet.getObject("id"));
System.out.println("name:" + resultSet.getObject("NAME"));
System.out.println("password:" + resultSet.getObject("PASSWORD"));
System.out.println("email:" + resultSet.getObject("email"));
System.out.println("birthday:" + resultSet.getObject("birthday"));
}
//释放资源，先声明的后释放，避免你还在用就释放了
resultSet.close();
statement.close();
connection.close();
}
}
步骤总结
- 加载驱动
- 获得连接
- 取得执行sql的对象statement
- 执行sql，得到结果集
- 关闭连接
10.4、JDBC中的对象解释
DriverManager
对于Class.forName(“com.mysql.jdbc.Driver”);这句话我们在代码里就出现了一次，其余地方都没用到，因为它就是一个激活驱动的操作，别的地方没用。
这个东西其实以前最开始是这样的
//用这个驱动管理，注册一个这个驱动类com.mysql.jdbc.Driver
//但是现在不建议这样做，而是用Class.forName("com.mysql.jdbc.Driver")取代这种做法，为什么呢
DriverManager.registerDriver(new Driver());
//我们跟进Driver这个类的源码看到这个类其实里面就一个静态代码块，静态代码块在对象创建的时候执行
tatic {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
//所以现在用反射加载一次就注册了，以前那种new了一次，注册又一次，浪费了
URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
//mysql默认端口号为3306
//连接格式：协议://主机地址:端口号/数据库名?参数1&参数2&参数3
//和http上面那个地址很像
//oracle默认端口号为1521
//jdbc:oracle:thin:@localhost:1521:sid
Connection
//Connection代表的是数据库，所有你在数据库里能实现的现在在这里java都能实现
//数据库设置自动提交
//事务提交
//事务回滚
connection.setAutoCommit();
connection.commit();
connection.rollback();
Statement 和 PreparedStatement 是执行sql的对象
//编写sql
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);//专门执行查询操作，返回一个结果集
int i = statement.executeUpdate(sql);//执行新增，修改，删除都用这个，返回受影响的行数
boolean execute = statement.execute(sql);//可执行左右sql，内置判断sql类型，所以操作效率一般，返回boolean
int[] ints = statement.executeBatch();//批量执行多个sql。返回数组，每个sql受影响的行
ResultSet 查询的结果集:封装了所有的查询结果
获得指定的数据类型;
resultSet.getObject("id");//不知道字段类型的时候用这个
//知道确定类型用这个最优
resultSet.getString();
resultSet.getInt();
resultSet.getDate();
遍历：我们看到next就知道这是个指针那种，它在遍历你搜到的数据表的每一行，然后取出数据。
resultSet.beforeFirst();//移动到第一行
resultSet.afterLast();//移动到最后一行
resultSet.next();//移动到下一行
resultSet.previous();//移动到前一行
resultSet.absolute(int row);//移动到指定行
//这里所指的行就是你查出来的结果表，一行一行的
释放资源:避免浪费资源
//释放资源，先声明的后释放，避免你还在用就释放了
resultSet.close();
statement.close();
connection.close();
10.5、statement对象
maven项目的资源文件，最好放在资源文件夹下才会被编译
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=123456
package com.lwq.lesson02;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcUtil {
private static String url = null;//这个也得是静态，才能在静态代码块里拿到，涉及到声明周期的东西
private static String username = null;
private static String password = null;
private static String driver = null;
static {
System.out.println("项目启动，类加载时候执行=============================");
try {
//读取配置文件中的信息
InputStream is = JdbcUtil.class.getClassLoader().getResourceAsStream("db.properties");
Properties prop = new Properties();
prop.load(is);
driver = prop.getProperty("driver");
url = prop.getProperty("url");
username = prop.getProperty("username");
password = prop.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 relese(ResultSet rs, Connection conn, Statement st){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(st != null){
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.lwq.lesson02;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertTest {
public static void main(String[] args){
Connection connection = null;
Statement statement = null;
try {
connection = JdbcUtil.getConnection();
statement = connection.createStatement();
String sql = "INSERT INTO users (`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (4,'lwq','123456','2018305346@qq.com','1980-12-04')";
int num = statement.executeUpdate(sql);
if(num > 0){
System.out.println("插入数据成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtil.relese(null,connection,statement);
}
}
}
10.6、SQL注入问题
一句话，就是sql存在漏洞被攻击，就是被人拼进去一个字符串，让sql没有输入正确参数直接就输出数据了，被别人的得到了这个数据就很危险
参考这个：https://www.cnblogs.com/liuzeyu12a/p/10046228.html
其实就是Statement这个执行sql的对象不安全。
10.7、PreparedStatement
可以防止sql注入而且效率更好：
其防止sql注入的本质就是把传递进来的参数当成字符串，假设其中存在转义字符就直接转义，
参考这个：https://www.cnblogs.com/roostinghawk/p/9703806.html
10.8、使用idea连接数据库
没看，感觉没啥意义。
10.9、事务
要么都成功要么都失败
ACID原则
原子性：要么都完成，要么都不完成
一致性：操作前后总数不变
隔离性：多个进程互相不干扰
持久性：一旦提交就持久到数据库了，不可逆
隔离性比较特殊，因为隔离性会产生一些问题;
- 脏读：一个事务读到了另一个没有提交的事务的数据
- 不可重复读：在一个事务内，重复读取表中数据，数据变化导致不知道用哪次的数据
- 虚读(幻读):在一个事务内，读取到了别人插入的数据，导致前后读出来的数据数不一致，就像幻觉一样。
代码实现
//关闭数据库的自动提交，java中此时会自动开启事务
connection.setAutoCommit(false);
//提交事务
connection.commit();
/**
如果出现执行错误，在catch语句中可以手动设置事务回滚
connection.rollback();
当然java中是默认回滚的，可以不手动声明。
*/
详细的代码自己去实现一下，这里就不逐一敲了，其实也没啥了。
10.10、数据库连接池
数据库连接–执行完毕–释放
连接到释放是十分浪费系统资源的
池化技术：准备一些预先的资源，过来就连接预先准备好的，除非服务关了，不然池子里一直有
常用连接数：10
最小连接数：10（常用是10，最小就得是10）
最大连接数：15，业务最高承载上限（最大肯定比10大，大多少看情况）
用完了后面的就要排队等待：
等待要设置等待时间：100ms，超过这个时间就连接超时报错，其实没bug就是连接池不够用了。
以上的数字就是可以自己设置的，这里写的只是让你明白什么意思。
编写连接池，其实就是实现一个接口DataSource,下面的这些数据源也是实现的这个接口，替我们封装好了。
开源数据源实现，拿来即用
DBCP
C3P0
Druid:阿里巴巴的
使用这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了。我们先看一下DBCP和C3P0
DBCP
需要的jar包：
commons-dbcp-1.4 commons-pool-1.6
实现的配置文件，可以去百度
#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=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_COMMITTED
C3P0
需要用到的jar包：
c3p0-0.9.5.5、mchange-commons-java-0.2.19
无论使用什么数据源，本质一样，其实就是实现一个接口DataSource，接口不变其中的方法就不变。这就是接口开发的约束，你各种实现类，最后调的还是一个，这就是接口的扩展性，你各种加东西，最后改的也很少，你像这里我们变了两种数据源，加上原生的三种，但是那个getconnctio方法一直没变，需要慢慢体会
配置文件xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<!--
c3p0的缺省（默认）配置
如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）-->
<default-config>
<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="acquiredIncrement">5</property>
<property name="initialPoolSize">10</property>
<property name="minPoolSize">5</property>
<property name="maxPoolSize">20</property>
</default-config>
代码实现：
DBCP代码实现
配置文件
#连接设置
#这里的一些名字就和我之前随便写的不一样了，这里人家默认这个源码里肯定也读这个，别乱改
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=false
username=root
password=123456
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最大空闲连接 -->
maxIdle=20
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
maxWait=60000
#注意："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_COMMITTED
工具类：
package com.lwq.lesson03;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcDbcpUtil {
private static DataSource dataSource = null;
static {
System.out.println("项目启动，类加载时候执行=============================");
try {
//读取配置文件中的信息
InputStream is = JdbcDbcpUtil.class.getClassLoader().getResourceAsStream("dbcp-config.properties");
Properties prop = new Properties();
prop.load(is);
//读取dbcp的工厂类创建数据源
dataSource = BasicDataSourceFactory.createDataSource(prop);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取数据库连接
public static Connection getConnection()throws SQLException {
//获取连接从数据源池里拿
return dataSource.getConnection();
}
//释放连接
public static void relese(ResultSet rs, Connection conn, Statement st){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(st != null){
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
测试类：
package com.lwq.lesson03;
import com.lwq.lesson02.JdbcUtil;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertTest {
public static void main(String[] args){
Connection connection = null;
Statement statement = null;
try {
connection = JdbcDbcpUtil.getConnection();
statement = connection.createStatement();
String sql = "INSERT INTO users (`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (4,'lwq','123456','2018305346@qq.com','1980-12-04')";
int num = statement.executeUpdate(sql);
if(num > 0){
System.out.println("插入数据成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
//这里的释放只是当前线程不用了，还回数据源池里了，还在呢
JdbcDbcpUtil.relese(null,connection,statement);
}
}
}
C3P0代码实现
配置文件：xml
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<!--
c3p0的缺省（默认）配置
如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）-->
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="acquiredIncrement">5</property>
<property name="initialPoolSize">10</property>
<property name="minPoolSize">5</property>
<property name="maxPoolSize">20</property>
</default-config>
<!-- c3p0的配置文件里可以配置多套数据源，默认是上面那个，我这里再配置一个我自己的mysql，版本的，你爱怎么配怎么配
读取的时候，指定好就可以了，也可以再配一个其他的数据库，比如oracle-->
<named-config name="LWQMySQL">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="acquiredIncrement">5</property>
<property name="initialPoolSize">10</property>
<property name="minPoolSize">5</property>
<property name="maxPoolSize">20</property>
</named-config>
</c3p0-config>
工具类:
package com.lwq.lesson4;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.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;
public class JdbcC3P0Util {
//private static DataSource dataSource = null;还是可以这样写，这两个类其实是抽象类和实现类的区别，父子关系，只不过这里我写成实现类了，多态
//最终都是继承实现了DataSource，这是数据源的统一特点，其实你也可以手写一个数据源，继承实现DataSource即可
private static ComboPooledDataSource dataSource = null;
static {
System.out.println("项目启动，类加载时候执行=============================");
try {
//读取配置文件中的信息，时代变了，不需要读，因为xml文件就不需要读，你写mybatis也没见你读
//更加简化了,跟源码进去看构造就知道可以传个配置名字
dataSource = new ComboPooledDataSource("LWQMySQL");
//还有一种是代码版本的配置，这个ComboPooledDataSource内部有很多属性，可以set进去，不用读配置文件，
//和线程池很像，但是这种就效率不太好，所以不推荐
/*dataSource = new ComboPooledDataSource();
dataSource.setDriverClass();
dataSource.setJdbcUrl();
dataSource.setPassword();
dataSource.setUser();
dataSource.setMaxPoolSize(10);*/
} catch (Exception e) {
e.printStackTrace();
}
}
//获取数据库连接
public static Connection getConnection()throws SQLException {
//获取连接从数据源池里拿
return dataSource.getConnection();
}
//释放连接
public static void relese(ResultSet rs, Connection conn, Statement st){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(st != null){
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
测试类：
package com.lwq.lesson4;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertTest {
public static void main(String[] args){
Connection connection = null;
Statement statement = null;
try {
connection = JdbcC3P0Util.getConnection();//现在其实就是第三方的东西了，不是自己写的了
statement = connection.createStatement();
String sql = "INSERT INTO users (`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (4,'lwq','123456','2018305346@qq.com','1980-12-04')";
int num = statement.executeUpdate(sql);
if(num > 0){
System.out.println("插入数据成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
//这里的释放只是当前线程不用了，还回数据源池里了，还在呢
JdbcC3P0Util.relese(null,connection,statement);
}
}
}
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcC3P0Util {
//private static DataSource dataSource = null;还是可以这样写，这两个类其实是抽象类和实现类的区别，父子关系，只不过这里我写成实现类了，多态
//最终都是继承实现了DataSource，这是数据源的统一特点，其实你也可以手写一个数据源，继承实现DataSource即可
private static ComboPooledDataSource dataSource = null;
static {
System.out.println(“项目启动，类加载时候执行=============================”);
try {
//读取配置文件中的信息，时代变了，不需要读，因为xml文件就不需要读，你写mybatis也没见你读
//更加简化了,跟源码进去看构造就知道可以传个配置名字
dataSource = new ComboPooledDataSource(“LWQMySQL”);
//还有一种是代码版本的配置，这个ComboPooledDataSource内部有很多属性，可以set进去，不用读配置文件，
//和线程池很像，但是这种就效率不太好，所以不推荐
/*dataSource = new ComboPooledDataSource();
dataSource.setDriverClass();
dataSource.setJdbcUrl();
dataSource.setPassword();
dataSource.setUser();
dataSource.setMaxPoolSize(10);*/
} catch (Exception e) {
e.printStackTrace();
}
}
//获取数据库连接
public static Connection getConnection()throws SQLException {
//获取连接从数据源池里拿
return dataSource.getConnection();
}
//释放连接
public static void relese(ResultSet rs, Connection conn, Statement st){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(st != null){
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
测试类：
~~~java
package com.lwq.lesson4;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertTest {
public static void main(String[] args){
Connection connection = null;
Statement statement = null;
try {
connection = JdbcC3P0Util.getConnection();//现在其实就是第三方的东西了，不是自己写的了
statement = connection.createStatement();
String sql = "INSERT INTO users (`id`,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (4,'lwq','123456','2018305346@qq.com','1980-12-04')";
int num = statement.executeUpdate(sql);
if(num > 0){
System.out.println("插入数据成功");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
//这里的释放只是当前线程不用了，还回数据源池里了，还在呢
JdbcC3P0Util.relese(null,connection,statement);
}
}
}
扫一扫
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
