MySQL
数据库是所有软件体系中最核心的存在 DBA
1、MySQl
1.1 数据库是什么
数据库(DB,DataBase)
概念: 数据仓库,软件,安装在操作系统之上! SQL,可以存储500万以下的数据
作用:存储数据,管理数据
1.2数据库分类
关系型数据库:
- MySQL,Oracle,SqlServer,DB2,SQLlite
- 通过表和表之间,行和列之间的关系进行数据的存储
非关系型数据库:
- Redis,MongDB
- 存储对象,通过对象的自身的属性来决定
DBMS(数据库管理系统)
- 数据库的管理软件,科学有效的管理我们的数据,维护和获取数据
- MySQL数据库管理系统!
1.3 连接数据库
命令行(管理员cmd面板)面板
mysql -uroot -p123456 --连接数据库
update mysql.uesr set authentication_string=password('123456') where user='root' and Host = 'localhost'; -- 修改用户密码
flush privileges; --刷新权限
-----------------------------------------------
-- 所有的语句都使用;
show databases; --查看所有的数据库
mysql> use school --切换数据库 use 数据库名
Database changed --返回命令
show tables; --查看数据库中所有的表
describe student; --显示数据库中所有的信息
create database wesos; -- 创建一个数据库
exit; --退出连接
-- 单行注释(SQL的本来的注释)
/* */ (SQL的多行注释)
数据库xxx语言 CRUD增删改查!
- 数据库定义语言 DDL
- 数据库操作语言 DML
- 数据库查询语言 DQL
- 数据库控制语言 DCL
2、操作数据库
操作数据库>操作数据库中的表>操作数据库中表的数据
mysql不区分字母大小写
2.1、操作数据库
- 创建数据库
CREATE DATABASE [IF NOT EXISTS] 数据库名
- 删除数据库
DROP DATABASE [IF EXISTS] 数据库名
- 使用数据库
USER 数据库名
如果表明或者字段名是一个特殊字符,则格式如下
USER `数据库名`
- 查看数据库
SHOW DATABASES --查看所有的数据库
SHOW 数据库名
2.2 数据库的列类型
数值
名称 | 类型 | 说明 |
---|---|---|
tinyint | 十分小的数据 | 1个字节 |
smallint | 较小的数据 | 2个字节 |
mediumint | 中等大小的数据 | 3个字节 |
int(常用) | 标准整数 | 4个字节 |
bigint | 较大的数据 | 8个字节 |
float | 浮点数 | 4个字节 |
double | 双精度浮点数 | 8个字节 |
decimal | 字符串形式的浮点数 | 金融计算时使用 |
字符串
char | 字符串固定大小 | 0-255 |
---|---|---|
varchar(常用) | 可变字符串 | 0-65535 |
tinytext | 微型文本 | 2^8-1 |
text | 文本串 | 2^16-1 |
时间日期
- date YYYY-MM-DD 日期格式
- time HH:mm:ss 时间格式
- datetime(常用) YYYY-MM-DD HH:mm:ss
- timestamp 时间戳,1970.1.1到现在的毫秒数!
- year 表示年份
null
- 没有值(未知)
- 不要使用NULL进行运算!
2.3 数据库的字段属性(重点)
Unsigned
- 无符号的整数
- 声明了该列中不能有负数
zerofill
- 不足的位数,使用0来填充
自增
- 通常理解为自增,自动在上一条记录的基础上+1
- 通常用来设计唯一的主键,必须时整数
- 可以自定义设计主键自增的起始值和步长
非空
- 假设设置为 not null ,如果不给它赋值,就会报错!
- NULL , 不过不填写值,默认就是null!
默认
- 设置默认的值
- 若性别列默认为男,则不填写均为男
2.4 创建数据库表
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v5hDRN7n-1618334983488)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20210330232905952.png)]
格式
CREATE TABLE [IF NOT EXISTS] `表名`(
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
.......
`字段名` 列类型 [属性] [索引] [注释],
)[表类型][字符集设置][注释]
常用命令
SHOW CREATE DATABASE school -- 查看创建数据库的语句
SHOW CREATE TABLE student -- 查看student数据表的定义语句
DESC student -- 显示表的结构
2.5 数据表的类型
--关于数据库引擎
/*
INNODB 默认使用
MYISAM 早些年使用的
*/
MYISAM | INNODB事务 | |
---|---|---|
事务支持 | 不支持 | 支持 |
数据行锁定 | 不支持 | 支持 |
外键约束 | 不支持 | 支持 |
全文索引 | 支持 | 不支持 |
表空间的大小 | 较小 | 较大 |
常规使用操作:
- MYISAM 节约空间,速度较快
- INNODB 安全性高,事务处理,多表多用户操作
在物理空间存在的位置
所有的数据库文件都存在 data 目录下,一个文件夹对一个数据库,本质还是文件的存储!
MySQL引擎在物理文件上的区别
- INNODB在数据库表中只有一个*.frm文件,以及上级目录下的ibdata1文件
- MYISAM对应的文件
-
- *.frm 表结构的定义文件
- *.MYD 数据文件(data)
- *.MYI 索引文件(index)
设置数据库表的字符集编码
CHARSET=utf8
不设置的话,会试mysql默认的字符集编码Latin1,不支持中文
2.6 修改、删除表
-- 修改表明:ALTER TABLE 旧表名 RENAME AS 新表名
ALTER TABLE teacher RENAME AS teacher1
-- 增加表的字段:ALTER TABLE 表名 ADD 字段名 列属性
ALTER TABLE teacher1 ADD age INT(11)
-- 修改表的字段(重命名,修改约束)
-- ALTER TABLE 表名 MODIFY 字段名 列属性[]
ALTER TABLE teacher1 MODITY age VARCHAR(11) -- 修改约束
-- ALTER TABLE 表名 CHANGE 旧名字 新名字 列属性[]
ALTER TABLE teacher1 CHANGE age age1 INT(1) -- 字段重命名
-- 删除表的字段:ALTER TABLE 表名 DROP 字段名
ALTER TABLE teacher DROP age1
-- 删除表:DROP TABLE IF EXISTS 表名(判断表存不存在)
DROP TABLE IF EXISTS teacher1
所有的创建和删除操作尽量加上判断,以免报错
注意事项:
- 字段名和表名,用``包裹!!!
- 注释 – , /**/
- sql关键字大小写不敏感,建议写小写
- 所有的符号全部用英文
3、MySQL数据管理
3.1 外键(了解即可)
方式一、在创建表的时候,增加约束(复杂)
CREATE TABLE `grade`(
`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
CREATE TABLE IF NOT EXISTS `student` (
`id` INT(50) 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 '性别',
`gradeid` INT(10) NOT NULL COMMENT '学生的年级',
`brithday` DATETIME DEFAULT NULL COMMENT '出生日期',
`address` VARCHAR (50) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`),
KEY `FK_gradeid` (`gradeid`),
CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
删除有外键关系的表的时候,必须要先删除引用别人的表(从表),再删除被引用的表(主表)
方法二创建表成功后,创建外键约束
CREATE TABLE `grade`(
`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
CREATE TABLE IF NOT EXISTS `student` (
`id` INT(50) 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 '性别',
`gradeid` INT(10) NOT NULL COMMENT '学生的年级',
`brithday` DATETIME DEFAULT NULL COMMENT '出生日期',
`address` VARCHAR (50) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
-- ALTER TABLE 从表 ADD CONSTRAINT 约束名 FOREIGN KEY(作为外键的列) REFERENCES 主表(字段)
以上的操作均为物理外键,即数据库级别的外键,不建议使用(避免数据库过多)
最佳实现
- 数据库就是单纯的表,只用来存放数据,只有数据和字段
- 若想使用多张表,通过程序去实现
3.2 DML语言(重点)
数据库的意义:数据存储,数据管理
3.2.1 添加(insert)
-- 插入语句(添加)
-- insert into 表名([字段名1,字段名2,字段名3,])values('值1'),('值'),('值'),....)
INSERT INTO `grade`(`gradename`) VALUES('大四')
-- 写插入语句,一定要数据和字段名一一对应
-- 插入多个字段
INSERT INTO `grade`(`gradename`) VALUES ('大二'),('大一')
INSERT INTO `student`(`name`) VALUES ('张三')
INSERT INTO `student`(`name`,`pwd`,`sex`) VALUES ('李四','aaaaaa','男')
INSERT INTO `student`(`name`,`pwd`,`sex`)
VALUES ('王五','aaaaaa','男'),('郑志磊','aaaaaa','男')
-- 字段名可以省略,但是后面的值必须要一一对应
INSERT INTO `student`
VALUES (5,'zxk','zxkamq','男',1,'2002-11-17','湖南','zxk@c.cn')
语法:insert into 表名([字段名1,字段名2,字段名3,])values(‘值1’),(‘值’),(‘值’),…)
注意事项:
- 字段和字段之间使用英文逗号隔开
- 字段可以省略,但是后面的值必须要一一对应,所有行项目都要有对应的数据
- 可以同时插入多条数据,每条数据用()包裹,多条数据之间用 , 隔开;同一数据中所对应不同字段的数据用**’ '**包裹,多个数据中用 , 隔开
2.3.2 修改(update)
-- 修改数据
-- 语法:UPDATE 表名 SET 字段名1 = value1,字段名2 = value2,... WHERE [条件]
-- 指定条件:id=1的学员
UPDATE `student` SET `name`='狂神' WHERE id=1;
-- 不指定条件的情况下,会改动表中所有的指定字段的内容
UPDATE `student` SET `name`= 'hhh'
-- 修改多个属性,用,隔开
UPDATE `student` SET `name`= '狂神',`email`='1234585' WHERE id = 1;
-- 可以通过多个条件定位数据
UPDATE `student` SET `name`= 'doinb' WHERE `name`='hhh' AND pwd='zxkamq'
条件:where 子句(操作符结果返回布尔值)
操作符 | 含义 | 范围 | 结果 |
---|---|---|---|
= | 等于 | 5=6 | false |
<>或!= | 不等于 | 5<>6 | true |
> | 大于 | 5>6 | false |
< | 小于 | 5<6 | true |
<= | 小于或等于 | 5<=6 | true |
>= | 大于或等于 | 5>=6 | false |
BEETWEEN | 在某个范围内,闭区间 | [2,5] | |
AND | 和 | 1>2 AND 5>2 | false |
OR | 或 | 1>2 OR 5>2 | true |
语法:UPDATE 表名 SET 字段名1 = value1,字段名2 = value2,… WHERE [条件]
注意事项:
- 字段名带上``
- 若不带指定条件,则会改动表中指定列的所有数据
- value,可以是一个具体得值,也可以是一个变量
- 多个设置的属性之间,使用英文逗号隔开
UPDATE `student` SET `brithday`= CURRENT_TIME WHERE `name`='狂神' AND`sex`='女'
2.3.3 删除(delete)
-- 删除数据
DELETE FROM `student` -- 这将会删除所有数据(一般不用此语法方式清空数据库)
-- TRUNCATE命令:完全清空一个数据库表,且表的结构和索引不会改变!
TRUNCATE `student`
-- 删除指定数据
DELETE FROM `student` WHERE id= 1;
delete和TRUNCATE的区别
- 相同点:都能删除数据,都不会改变数据结构
- 不同点:
-
- TRUNCATE 不会影响事务
- TRUNCATE 不会影响自增(即TRUNCATE删除数据库表后,自增列数值与删除前相同)
delete删除数据库表后,重启数据库,不同引擎对应的现象
- INNODB 自增列会从1重新开始
- MYISAM 继续从删除钱的子增量开始
4、DQL查询数据(select)(最重要的知识点!!)
4.1 DQL
(Data Query LANGUAGE:数据查询语句)
- 所有的查询操作都用它
- 简单和复杂的查询都能做
- 数据库中最核心的语言,使用频率最高的语言
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_cunet | row_countOFFSET OFFSET}]; -- 指定查询的记录从哪条至哪条
注意:[]代表可写的,{}代表必写的
语句之间的顺序不可调换
4.2 指定查询字段
查询 select
-- 查询一个表全部的数据 select 字段 from 表名
SELECT * FROM student
SELECT * FROM result
-- 查询指定字段
SELECT `studentno`,`studentname` FROM student
-- 别名,给结果起名字 用AS 可以给字段起别名,也可以给表起别名(便于阅读)
SELECT `studentno` AS 学号,`studentname` AS 学生姓名 FROM student AS s
-- 函数
SELECT CONCAT('姓名:',studentname) AS 新名字 FROM student
语法:SELECT 字段,… FROM 表名
有时候,为了使列名便于浏览,可对列名或者表名进行别名操作 列名 AS 别名
去重 distinct
作用:去除SELECT查询出来的结果中重复的数据,只显示一条
SELECT * FROM result -- 查询全部的考试成绩
SELECT `studentno` FROM result -- 查询有哪些同学参加了考试
SELECT DISTINCT `studentno` FROM result
数据库的列(表达式)
SELECT VERSION() -- 查询系统版本
SELECT 100*3-1 AS 计算结果 -- 用来计算
SELECT @@auto_increment_increment -- 查询自增的步长
-- 学员考试成绩 + 1分查看
SELECT `studentno`,`studentresult`+1 AS '提分后' FROM result
数据库中的表达式:文本值,列,Null,函数,计算表达式,系统变量…
格式:select 表达式 from 表名
4.3 where 条件子句
作用:检索数据中符合条件的值
搜索条件有一个或者多个表达式组成,结果返回布尔值
逻辑运算符
运算符 | 语法 | 描述 |
---|---|---|
and && | a and b a&&b | 逻辑与,两个都为真,结果为真 |
or || | a or b a||b | 逻辑或,其中一个为真,则结果为真 |
Not ! | not a !a | 逻辑非,真为假,假为真 |
在sql中使用逻辑符尽量使用英文字母
-- ===================== where ===========================
SELECT studentno,`studentresult` FROM result
-- 查询考试成绩在 95-100分之间
SELECT studentno,`studentresult` FROM result
WHERE studentresult>=95 AND studentresult <=100
-- 模糊区间
SELECT studentno,`studentresult` FROM result
WHERE studentresult BETWEEN 95 AND 100
-- 除了学号为1000号学生之外的同学的成绩
SELECT studentno,`studentresult` FROM result
WHERE studentno != 1000;
SELECT studentno,`studentresult` FROM result
WHERE NOT studentno = 1000;
模糊查询:比较运算符
运算符 | 语法 | 描述 |
---|---|---|
IS NULL | a is null | 如果操作符为NULL,结果为真 |
IS NOT NULL | a is not null | 如果操作符不为NULL,结果为真 |
BETWEEN | a between b and c | 若a在b和c之间,则结果为真 |
Like | a like b | SQL匹配,如果a匹配b,则结果为真 |
in | a in(a1,a2,a3…) | 假设a为a1,a2…中的某一个值,结果为真 |
-- ================= 模糊查询 ===================
-- 查询姓张的同学
-- 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 '%伟%'
-- ===================== in (具体的数据) ===================
-- 查询 1001,1002,1003号学员
SELECT `studentno`,`studentname` FROM `student`
WHERE studentno IN (1001,1002,1003);
-- 查询在北京的学生
SELECT `studentno`,`studentname` FROM `student`
WHERE `address` IN ('北京朝阳','河南洛阳');
-- ==================== null not null ======================
-- 查询地址为空的学生 null ''
SELECT `studentno`,`studentname` FROM `student`
WHERE address='' OR address IS NULL
-- 查询有出生日期的同学 不为空
SELECT `studentno`,`studentname` FROM `student`
WHERE `borndate` IS NOT NULL
4.4 联表查询
JOIN对比
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i11r3U56-1618334983490)(https://gimg2.baidu.com/image_search/src=http%3A%2F%2Foscimg.oschina.net%2Foscnet%2Fae3dc7b419e1692526088bf7e55a04166e7.png&refer=http%3A%2F%2Foscimg.oschina.net&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1619782533&t=08390bcefa4b9791378bb06f8a83114e)]
操作 | 描述 |
---|---|
INNER JOIN | 如果两个表中至少有一个匹配,则返回所需要的行 |
LEFT JOIN | 即使右边中没有匹配,也会返回左表中所有的值(以左表为基准) |
RIGHT JOIN | 即使左表中没有匹配,也会返回右表中所有的值(以右表为基准) |
-- ============== 联表查询 =====================
-- 查询参加了考试的同学(学号,姓名,科目编号,分数)
SELECT * FROM student
SELECT * FROM result
/* 思路
1. 分析需求,分析查询的字段来自哪些表(连接查询)
2. 确定使用哪种连接查询(7中)
确定交叉点(即两个表中哪个数据是相同的)
判断的条件 : 学生表中的 studentno = 成绩表 student
*/
-- join(要连接的表) on(判断条件) 连接查询
-- where 等值查询
SELECT s.studentno,studentname,subjectno,studentresult
FROM student AS s
INNER JOIN result AS r
WHERE s.studentno = r.studentno
-- Right Join
SELECT s.studentno,studentname,subjectno,studentresult
FROM student s
RIGHT 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
-- 查询缺考的同学
SELECT s.studentno,studentname,subjectno,studentresult
FROM student s
LEFT JOIN result r
ON s.studentno = r.studentno
WHERE studentresult IS NULL
-- 思考:(查询参加考试的同学信息:学号、学生姓名、科目名、分数)
/* 思路
1. 分析需求,分析查询的字段来自哪些表:student、result、subject(连接查询)
2. 确定使用哪种连接查询(7中)
确定交叉点(即两个表中哪个数据是相同的)
判断的条件 : 学生表中的 studentno = 成绩表 student
*/
SELECT s.studentno,studentname,subjectname,studentresult
FROM student s
RIGHT JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
-- 先明确要查询的数据 SELECT 字段名
-- SELECT后接字段名时,若不同表有重名,需加注标识 s.studentno
-- 找到这些数据所在的表 FROM 表名 JOIN 要连接的表 ON 交叉条件
-- 若需在多张表中查询,从两种表开始慢慢查询(分别找交叉条件
自连接(作了解就可)
自己的表和自己的表连接,核心:一张表拆分为两种一样的表即可
父类
categoryid | categoruname |
---|---|
2 | 信息技术 |
3 | 软件开发 |
5 | 美术设计 |
子类
pid | categoryid | categoruname |
---|---|---|
3 | 4 | 数据库 |
2 | 8 | 办公信息 |
3 | 6 | web开发 |
5 | 7 | ps技术 |
操作:查询父类对应的子类关系
父类 | 子类 |
---|---|
信息技术 | 办公信息 |
软件开发 | web开发 |
软件开发 | 数据库 |
美术设计 | ps技术 |
-- ====================== 自连接 ================================
CREATE TABLE `category`(
`categoryid` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主题id',
`pid` INT(10) NOT NULL COMMENT '父id',
`categoryname` VARCHAR(50) NOT NULL COMMENT '主题名字',
PRIMARY KEY (`categoryid`)
) ENGINE=INNODB AUTO_INCREMENT=9 DEFAULT CHARSET =utf8
INSERT INTO `category` (`categoryid`, `pid`, `categoryname`)
VALUES ('2', '1', '信息技术'),
('3', '1', '软件开发'),
('5', '1', '美术设计'),
('4', '3', '数据库'),
('8', '2', '办公信息'),
('7', '5', 'ps技术'),
('6','3','web开发');
-- 查询父子信息:把一张表看为两个一模一样的表
SELECT a.`categoryname` AS '父栏目',b.`categoryname` AS '子栏目'
FROM `category` AS a,`category` AS b
WHERE a.`categoryid`=b.`pid`
4.5 分页(limit)和排序(order by)
排序 (ORDER BY) ASC:升序 ; DESC:降序
-- 排序: 升序 ASC ,降序 DESC
-- 语法:ORDER BY 通过哪个字段排序,排序方法
-- 查询的结果根据 成绩降序 排序
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
INNER JOIN result r
ON s.studentno = r.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
WHERE subjectname = '高等数学-1'
ORDER BY studentresult ASC
分页 (LIMIT)
-- 分页:缓解数据库压力,给客户更好的体验
-- 语法:limit 起始数据位置-1,数据数量大小
-- LIMIT 0,5 代表从第1个数据到第5个数据
-- LIMIT 1,4 代表从第2个数据到第4和数据
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
INNER JOIN result r
ON s.studentno = r.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
-- WHERE subjectname = '高等数学-1'
ORDER BY studentresult ASC
LIMIT 1,5
-- 一组数据,分页,每页只显示五条数据
-- 第一页 LIMIT 0,5
-- 第二页 LIMIT 5,5
-- 第三页 LIMIT 10,5
-- 第N页 LIMIT (N-1)*5,5
-- 当一组数据分页且每页显示x条数据时
-- 格式:LIMIT (N-1)*x,x
-- 在网页端显示
-- 【pagesize:页面大小】
-- 【(n-1)*pagesize 每页的起始值】
-- 【n:当前页】
-- 【总页数=数据总数/页面大小】
-- 查询 高等数学-1 课程成绩排名前二的学生,并且分数要大于85分的学生信息(学号,姓名,课程名称,课程成绩)
SELECT s.`studentno` AS '学号',`studentname` AS '姓名',`subjectname` AS '科目',`studentresult` AS '成绩'
FROM `student` s
INNER JOIN `result` r
ON s.`studentno` = r.`studentno`
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
WHERE `subjectname` = '高等数学-1' AND `studentresult` >= 85
ORDER BY studentresult DESC
LIMIT 0,2
4.7 子查询(了解即可)
要使where子语句中的值是被计算出来的
本质:在where中嵌套子查询语句
-- 1、查询 高等数学-1 的所有考试结果(学号,科目编号,成绩) ,降序排列
-- 方式一:使用联表查询
SELECT `studentno` AS '学号',r.`subjectno` AS '科目编号',`studentresult` AS '成绩'
FROM `result` r
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
WHERE `subjectname` = '高等数学-1'
ORDER BY studentresult DESC
-- 方式二:使用子查询()(由里及外)
SELECT `studentno` AS '学号',`subjectno` AS '科目编号',`studentresult` AS '成绩'
FROM `result` r
WHERE `subjectno` = (
SELECT subjectno FROM `subject`
WHERE subjectname = '高等数学-1'
)
ORDER BY studentresult DESC
-- 高等数学-1 分数不小于80分的学生学号和姓名
SELECT s.`studentno` AS '学号',`studentname` AS '姓名'
FROM `student` s
INNER JOIN `result` r
ON r.studentno = s.studentno
WHERE `studentresult`>= 80 AND `subjectno` =(
SELECT subjectno FROM `subject`
WHERE `subjectname` = '高等数学-1'
)
-- 再嵌套
SELECT studentno,studentname
FROM student WHERE studentno IN(
SELECT studentno FROM result WHERE studentresult>80 AND subjectno =(
SELECT subjectno FROM `subject` WHERE subjectname = '高等数学-1')
)
4.8 分组和过滤
分组:GROUP BY
过滤:HAVING(分组过后再根据条件筛选出符合要求的组)
-- 查询不同科目的平均分,最高分,最低分
-- 核心:根据数据的不同分组
SELECT ANY_VALUE(subjectname) AS 科目,AVG(studentresult)AS 平均分,MAX(studentresult) AS 最高分,MIN(studentresult) AS 最低分
FROM result r
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
GROUP BY r.subjectno -- 通过字段来分组
HAVING 平均分>80 -- 筛选出平均分高于80分的科目
5、MySQL函数
官网:https://dev.mysql.com/doc/refman/5.7/en/sql-function-reference.html
5.1 常用函数
-- ===================== MySQL常用函数 ============================
-- 数学运算
SELECT ABS(-8) -- 绝对值
SELECT CEILING(9.3) -- 向上取整
SELECT FLOOR(9.9) -- 向下取整
SELECT RAND() -- 返回一个0-1之间的随机数
SELECT SIGN(9) -- 判断一个数的符号 0返回0,负数返回-1,正数返回1
-- 字符串函数
SELECT CHAR_LENGTH('超爱mq呀') -- 返回字符串长度
SELECT CONCAT('I','love','you') -- 拼接字符串
SELECT INSERT('偷窃不是犯法的',3,1,'是') -- 替换字符串,3表示替换位置,1代表替换字符个数
SELECT LOWER('ZXKAHMQ') -- 大写字母转小写字母
SELECT UPPER('zxkahmq') -- 小写字母转大写字母
SELECT INSTR('zxkahmqhaha','h') -- 返回第一次出现h的索引
SELECT REPLACE('前方是星辰大海','星辰大海','浩瀚星海') -- 替换指定字符串
SELECT SUBSTR('前方是星辰大海',4,4) -- 返回指定位置指定长度的子字符串 第一个4表示指定位置,第二个4表示子字符串长度
SELECT REVERSE('前方是星辰大海') -- 将字符串反转
-- 时间和日期函数
SELECT CURRENT_DATE() -- 获取当前日期
SELECT CURDATE() -- 获取当前日期
SELECT NOW() -- 获取当前时间
SELECT LOCALTIME() -- 获取本地时间
SELECT SYSDATE() -- 系统时间
5.2 聚合函数(常用)
函数名称 | 描述 |
---|---|
COUNT() | 计数 |
SUM() | 求和 |
AVG() | 平均值 |
MAX() | 最大值 |
MIN() | 最小值 |
… | … |
-- 均可统计一个表中某个字段下的数据总数
SELECT COUNT(studentname) FROM student; -- COUNT(字段名) 会忽略NULL值
-- 下面两个本质是计算数据的行数
SELECT COUNT(*) FROM student; -- 不会忽略NULL值
SELECT COUNT(1) FROM student; -- 不会忽略NULL值
SELECT SUM(`studentresult`) AS 总和 FROM result
SELECT AVG(`studentresult`) AS 平均分 FROM result
SELECT MAX(`studentresult`) AS 最高分 FROM result
SELECT MIN(`studentresult`) AS 最低分 FROM result
5.3 数据库级别的MD5加密(拓展)
MD5(信息摘要算法):
主要增强算法复杂度和不可逆性
-- ============== MD5 加密 =====================
CREATE TABLE `teatMD5`(
`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 teatmd5 VALUES(1,'zhangsan','123456'),(2,'lisi','123456'),(3,'wangwu','123456')
-- 加密某个用户密码
UPDATE teatmd5 SET pwd=MD5(pwd) WHERE id=1
-- 加密全部用户密码
UPDATE teatmd5 SET pwd=MD5(pwd)
-- 插入密码的时候加密
INSERT INTO teatmd5 VALUES(4,'xiaoming',MD5('123456'))
-- 如何校验:将用户传进来的密码进行MD5加密,然后对比加密后的值
SELECT * FROM teatmd5 WHERE `name`= 'xiaoming' AND pwd=MD5('123456')
6、事务
什么是事务:
要么都成功,要么都失败
——————
1、SQL执行 A给B转账
2、SQL执行 B收到A的钱
eg:A有1000块,B有200块,A给B转200块,若转张成功,A剩下800,B有400;
——————
核心:将一组SQL放在一个批次中去执行
事务原则:ACID原则 (原子性,一致性,隔离性,持久性)
原子性:
A给B转账过程中包含两个步骤
A:1000-200=800
B:200+200=400
原子性表示,两个步骤一起成功一起失败,不能其中只发生一个步骤
一致性(Atomicity):
针对一个事务操作前后的状态一致
转账前A:1000,B:200
转账后A:800,B:400
一致性表示事务完成后符合逻辑运算(即不管如何转账,总钱数为1200)
持久性(Consistency):
表示事务结束后的数据不随着外界原因导致数据丢失,事务一旦提交便不可逆,被持久化到数据库中
若在A转账之前(事务未提交)服务器断电,那么重启数据库后,状态应该为A:1000,B:200
若在A转账之后(事务已提交)服务器断电,那么重启数据库后,状态应该为A:800,B:400
隔离性(Isolation):
针对多个用户同时操作,主要是排除其他事务对本次事务的影响
eg:A给B转钱的同时C给B转钱,两者之间互不影响
隔离失败:事务的隔离级别
脏读:一个事务读取了另外一个事务未提交的数据
即在A给B转账之前,此时B为200,C读取了该数据给B转100,此时在C事务中B为300;当A给B转账200后,A事务中B为400,读出数据有误
不可重复读:
在一个事务内读取表的某一行数据,多次读取结果不同
即A给B转帐前,读取B的值为200
A给B转账后,读取值为400
虚读(幻读):
在一个事务中读取了别的事务插入的数据,导致前后读取不一致
执行事务的原理
-- ========================== 事务 ==================================
-- MySQL是默认开启事务自动提交的
SET autocommit=0 -- 关闭自动提交
SET autocommit=1 -- 开启自动提交
-- 手动处理事务
SET autocommit=0 -- 关闭自动提交
-- 事务开启
START TRANSACTION -- 标记一个事务的开始,之后的sql都在同一个事务内
INSERT xx
INSERT xx
-- 提交:持久化(提交成功)
COMMIT
-- 回滚:回到原来的样子(提交失败)
ROLLBACK
-- 事务结束
SET autocommit = 1 -- 开启自动提交
SAVEPOINT 保存点名 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT -- 回滚到保存点
RELEASE SAVEPOINT -- 撤销保存点
模拟场景
-- 转账
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci -- 创建一个新数据库
USE shop -- 切换数据库
CREATE TABLE `account`(
`id` INT(3) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) NOT NULL,
`money` DECIMAL(9,2) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE = INNODB DEFAULT CHARSET=utf8
INSERT INTO `account`(`name`,`money`)
VALUES ('A',2000.00),('B',10000.00)
-- 模拟转账:事务
SET autocommit = 0; -- 关闭系统自动提交
START TRANSACTION -- 开启一个事务
UPDATE `account` SET money=money -500 WHERE `name` = 'A' -- A减500
UPDATE `account` SET money=money +500 WHERE `name` = 'B' -- B加500
COMMIT; -- 提交事务
ROLLBACK; -- 回滚
SET autocommit=1; -- 恢复默认值
7、索引
MySQL官方对索引的定义为:索引 (index)是帮助MySQL高效获取数据的数据结构。提取句子主干,就可以得到索引的本质:索引是数据结构
7.1 索引分类
- 主键索引(PRIMARY KEY)
-
- 唯一的标识,不可重复,只能有一个主键
- 唯一索引(UNIQUE KEY)
-
- 避免重复的列出现,唯一索引可以重复,多个列可以标识为唯一索引
- 常规索引(KEY/INDEX)
-
- 默认索引,可通过index,key关键字来设置
- 全文索引(FullText)
-
- 在特定的数据库引擎下才有,MyISAM
- 快速定位数据
-- 索引的使用
-- 1、在创建表的时候给字段增加索引
-- 2、创建完毕后,增加索引
-- 显示所有的索引信息
SHOW INDEX FROM student
-- 增加一个索引
ALTER TABLE school.`student` ADD FULLTEXT INDEX `studentname`(`studentname`);
-- EXPLAIN 分析sql执行的状况
EXPLAIN SELECT * FROM student; -- 非全文索引
EXPLAIN SELECT * FROM stuent WHERE MATCH(studentname) AGAINST('刘');
7.2 索引测试
SELECT * FROM app_user WHERE `name` = '用户999999';
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户9999';
SELECT * FROM student
-- id 表名 字段名
-- CREATE 索引类型 索引名 ON 表名(字段名)
CREATE INDEX id_app_user_name ON app_user(`NAME`)
SELECT * FROM app_user WHERE `name` = '用户9999';
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户9999';
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G1iCTqlt-1618334983491)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20210401185648988.png)]
索引在小数据时作用不大,但是在数据量较大时,可极大提高查询速率
7.3 索引原则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用来查询的字段上!
索引的数据类型
Hash类型的索引
INNODB默认的类型为Btree
8、权限管理和备份
8.1 用户管理
SQL yog 创建新用户可视化管理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vOrf1q1J-1618334983492)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20210401191918453.png)]
SQL 命令操作
用户表:mysql.user
本质:对用户表进行增删改查
-- 创建用户 格式:CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER xiaokang IDENTIFIED BY '123456'
-- 修改密码(修改当前用户密码)
SET PASSWORD = PASSWORD('123456')
-- 修改密码(修改指定用户密码)
SET PASSWORD FOR xiaokang = PASSWORD('123456')
-- 给用户重命名 格式:RENAME USER 原名 TO 新名字
RENAME USER xiaokang TO Zxiaokang
-- 用户授权 格式:GRANT 赋予权限范围(自定) ON 库,表 TO 用户
-- ALL PRIVILEGES 赋予全部权限,但不包括grant(授权)权限,即不能给别人授权
GRANT ALL PRIVILEGES ON *.* TO Zxiaokang
-- 查看权限
SHOW GRANTS FOR Zxiaokang -- 查看指定用户的权限
-- 撤销用户权限 格式:格式:REVOKE 赋予权限范围(自定) ON 库,表 FROM 用户
REVOKE ALL PRIVILEGES ON *.* FROM Zxiaokang
-- 删除用户
DROP USER Zxiaokang
8.2 MySQL备份
备份的原因:
- 保证重要的数据不丢失
- 数据转移
MySQL数据库备份的方式
-
直接拷贝物理文件(data文件包)
-
在SQLyog 的可视化工具中手动导出
-
- 在想要导出的表或者库中,右键选择备份或导出
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C192uMdN-1618334983493)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20210401201944288.png)]
-
使用**命令行(管理员cmd面板)**导出 mysqldump
-
# 导出格式:mysqldump -h主机 -u用户名 -p密码 数据库名 [表名1 表名2 表名3...] >物理磁盘位置:/文件名 mysqldump -hlocalhost -uroot -p123456 school student >D:/a.sql # 导入格式:mysql -u用户名 -p密码 库名 [表名] <备份文件 第二种: # 登录账户 mysql -uroot -p123456 # 切换到指定的数据库 use school; # source 备份文件
9、规范数据库设计
9.1 设计数据库的原因
当数据库比较复杂时,就需要设计数据库
- 糟糕的数据库
-
- 会导致数据冗余,浪费空间
- 数据库插入和删除都会麻烦、异常[屏蔽使用物理外键]
- 程序的性能差
- 良好的数据库
-
- 可以节省内存
- 保证数据库的完整性
- 方便开发系统
关于数据库的设计
- 分析需求:分析业务和需要处理的数据库的需求
- 概要设计:设计关系图E-R图
设计数据库的步骤:(eg:个人博客)
- 收集信息,分析需求
-
- 用户表(用户登录注销,用户的个人信息,写博客,创建分类)
- 分类表(文章分类,创建者)
- 文章表(文章的信息)
- 友链表(友链信息)
- 自定义表(系统信息,某个关键字,或者一些主字段)
- 标识实体(把需求落地到字段)
- 标识实体之间的关系
9.2 三大范式
为什么需要数据规范化?
- 避免信息重复
- 更新异常
- 插入异常
-
- 无法显示正常信息
- 删除异常
-
- 丢失有效信息
三大范式
第一范式(1NF)
原子性:保证每一列不可再分
第二范式(2NF)
前提:满足第一范式
每张表只描述一件事情
第三范式(3NF)
前提:满足第一范式和第二范式
确保数据表中的每一列数据都和主键直接相关,而不能间接相关
规范性和性能的问题
- 考虑商业化的需求和目标(成本,用户体验),数据库的性能更加重要
- 在规范性能的问题的时候,需要适当的考虑一下规范性
- 故意给某些表增加冗余字段(从多表查询变为单表查询)
10、JDBC(重点)
10.1 数据库驱动
程序通过数据库驱动,和数据库产生联系(导包)
10.2 JDBC
JAVA操作数据库的规范
10.3 第一个JDBC程序
创建测试数据库
CREATE DATABASE `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `jdbcStudy`;
CREATE TABLE `users`(
`id` INT PRIMARY KEY,
`NAME` VARCHAR(40),
`PASSWORD` VARCHAR(40),
`email` VARCHAR(60),
birthday DATE
);
INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)
VALUES(1,'zhangsan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')
- 在idea中创建一个新项目
- 新建一个目录,导入数据库驱动
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UlgUe2Jz-1618334983494)(C:\Users\86188\AppData\Roaming\Typora\typora-user-images\image-20210402213704328.png)]
在项目中添加目录后,在目录中导入数据库驱动,还需执行如图操作才算导入成功
- 编写测试代码
package com.jdbc.demo;
import java.sql.*;
//我的第一个JDBC程序
public class JdbcFirstDemo {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver"); //固定写法
//2.用户信息和url
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=true";
String username = "root";
String password = "123456";
/*useUnicode=true --支持中文编码
characterEncoding=utf8 --设定中文字符集为utf8
useSSL=true --使用安全的连接*/
//3.连接成功 Connection 代表数据库
Connection connection = DriverManager.getConnection(url, username, password);
//4.创建执行sql的对象
Statement statement = connection.createStatement();
//5.执行sql的对象去执行sql,可能存在结果,返加结果
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql); //返回一个结果集,结果集中封装了所有查询出来的结果
while(resultSet.next()){
System.out.println("id=" + resultSet.getObject("id"));
System.out.println("name=" + resultSet.getObject("NAME"));
System.out.println("pwd=" + resultSet.getObject("PASSWORD"));
System.out.println("email=" + resultSet.getObject("email"));
System.out.println("birth=" + resultSet.getObject("birthday"));
System.out.println("----------------------------------------------------");
}
//6.释放连接
resultSet.close();
statement.close();
connection.close();
}
}
步骤总结:
1、加载驱动
2、连接数据库 DriverManager
3、获得执行sql的对象 Statement
4、返回获得的结果集
5、释放连接
DriveManager
Class.forName("com.mysql.jdbc.Driver"); //固定写法,加载驱动
Connection connection = DriverManager.getConnection(url, username, password);
//connection 代表数据库,可执行数据库自动提交,事务提交与滚回等操作
connection.rollback();
connection.commit();
connection.setAutoCommit();
URL
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=true";
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
//musql的默认端口为3306
//oralce默认端口为1521
//jdbc:oralce:thin:@localhost:1521:sid
Statement 执行SQL的对象 PrepareStatement 执行SQL的对象
String sql = "SELECT * FROM users"; //编写SQL
statement.executeQuery(); //查询操作返回 ResultSet
statement.execute(); //执行任何SQL
statement.executeUpdate(); // 更新、插入、删除,返回一个受影响的函数
ResultSet查询的结果集:封装了所有的查询结果
获得指定的数据类型
resultSet.getObject(); //在不知道列类型的情况下使用
//若知道列的类型则使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
......
遍历
resultSet.beforeFirst(); //移动到最前面
resultSet.beforeLast(); //移动到最后面
resultSet.next(); //移动到下一个数据
resultSet.previous(); //移动到前一行
resultSet.absolute(); //移动到指定行
释放资源
//6.释放连接
resultSet.close();
statement.close();
connection.close();
10.4 Statement对象
JDBC中的Statement对象用于向数据库发送SQL语句,想完成对数据库的增删改查,只需要通过这个对象向数据库发送增删改查语句即可
Statement对象的execute.Update方法,用于向数据库发送增、删、改的sql语句,executeUpdate执行完后,会返回一个整数用来告知这次sql语句影响了几行数据
Statement.executeQuery方法用于向数据库发送查询语句,executeQuery方法返回代表查询结果的ResultSet对象
提取工具类
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/数据库名?useUnicode=true&characterEncoding=utf8&&useSSL=true
username=root
password=12345
CRUD操作-create
使用executeUpdate(String sql)方法完成数据添加操作
Statement st = com.createStatement();
String sql = "insert into user(...) values(...)";
int num = st.executeUpdate(sql);
if(num>0){
System.out.println("插入成功!")
}
CRUD操作-delete
使用executeUpdate(String sql)方法完成数据删除操作
Statement st = com.createStatement();
String sql = "delete from user where id=1";
int num = st.executeUpdate(sql);
if(num>0){
System.out.println("删除成功!")
}
CRUD操作-update
使用executeUpdate(String sql)方法完成数据修改操作
Statement st = com.createStatement();
String sql = "update user set name='' where name=''";
int num = st.executeUpdate(sql);
if(num>0){
System.out.println("修改成功!")
}
CRUD操作-read
使用executeQuery(String sql)方法完成数据查询操作
Statement st = com.createStatement();
String sql = "select * from user where id = 1";
ResultSet rs = st.executeUpdate(sql);
while(rs.next()){
//根据获取列的数据类型,分别调用rs的相应方法映射到java对象中
}
代码实现
1、提取工具类
package lesson.utils;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
private static String driver =null;
private static String url =null;
private static String username =null;
private static String password =null;
static{
try {
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
Properties properties = new Properties();
properties.load(in);
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
//1.驱动只用加载一次
Class.forName(driver);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url,username,password);
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) {
if (rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (st!=null){
try {
st.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
2、编写增删改的方法 executeUpdate
增
package lesson;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestInsert {
public static void main(String[] args) {
Connection coon = null;
Statement st = null;
ResultSet rs = null;
try {
coon = JdbcUtils.getConnection();//获取数据库连接
st = coon.createStatement();//创建sql的执行对象
String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (4,'xiaokang','123456','2982203644@qq.com','2002-11-17');";
int i = st.executeUpdate(sql);
if (i>0){
System.out.println("插入成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(coon,st,rs);
}
}
}
删
package lesson;
import lesson.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 coon = null;
Statement st = null;
ResultSet rs = null;
try {
coon = JdbcUtils.getConnection();//获取数据库连接
st = coon.createStatement();//创建sql的执行对象
String sql = "DELETE FROM users WHERE id = 4";
int i = st.executeUpdate(sql);
if (i>0){
System.out.println("删除成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(coon,st,rs);
}
}
}
改
package lesson;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestUpdate {
public static void main(String[] args) {
Connection coon = null;
Statement st = null;
ResultSet rs = null;
try {
coon = JdbcUtils.getConnection();//获取数据库连接
st = coon.createStatement();//创建sql的执行对象
String sql = "UPDATE users SET `NAME`='xiaokang' WHERE id = 1";
int i = st.executeUpdate(sql);
if (i>0){
System.out.println("更新成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(coon,st,rs);
}
}
}
3、编写查的方法 executeQuery
查
package lesson;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestSelect {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
//SQL
String sql = "select * from users where id = 1";
rs = st.executeQuery(sql);
while(rs.next()){
System.out.println(rs.getString("NAME"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
SQL注入问题
sql存在漏洞,会被攻击导致数据泄露
10.5 PreparedStatement对象
PreparedStatement比Statement效率更高,且可以防止SQL注入
增
package lesson01;
import lesson.utils.JdbcUtils;
import java.util.Date;
import java.sql.*;
public class TestInsert {
public static void main(String[] args) {
Connection conn = null ;
PreparedStatement st = null;
try {
conn = JdbcUtils.getConnection();
//与Statement的区别
//使用? 占位符代替参数
String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
st = conn.prepareStatement(sql); //要加入参数,预编译SQL,然后不执行
//手动给参数赋值
st.setInt(1,4); //id
st.setString(2,"xiaokang");
st.setString(3,"123456");
st.setString(4,"2982023644@qq.com");
//注意点:sql.Date 数据库用的 java.sql.Date()
// util.Date jaca使用的 new Date().getTime() 获得时间戳
st.setDate(5,new java.sql.Date(new Date().getTime()));
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("插入成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,null);
}
}
}
删
package lesson01;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
public class TestUpdate {
public static void main(String[] args) {
Connection conn = null ;
PreparedStatement st = null;
try {
conn = JdbcUtils.getConnection();
//与Statement的区别
//使用? 占位符代替参数
String sql = "delete from users where id = ?";
st = conn.prepareStatement(sql); //要加入参数,预编译SQL,然后不执行
//手动给参数赋值
st.setInt(1,4);
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("删除成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,null);
}
}
}
改
package lesson01;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class TestDelete {
public static void main(String[] args) {
Connection conn = null ;
PreparedStatement st = null;
try {
conn = JdbcUtils.getConnection();
//与Statement的区别
//使用? 占位符代替参数
String sql = "update users set `NAME`=? where id = ?";
st = conn.prepareStatement(sql); //要加入参数,预编译SQL,然后不执行
//手动给参数赋值
st.setString(1,"haha");
st.setInt(2,1);
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("更新成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,null);
}
}
}
查
package lesson01;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestSelect {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null ;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
//编写SQL
String sql = "select * from users where id = ?";
//预编译
st = conn.prepareStatement(sql);
//传递参数
st.setInt(1,1);
//执行
rs = st.executeQuery();
if (rs.next()){
System.out.println(rs.getString("NAME"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
10.6 使用IDEA连接数据库
连接成功后,可以选择数据库
在IDEA中修改表格内容时,一定要提交!!!
在IDEA中来进行SQL编码
10.7 JDBC操作事务
package lesson2;
import lesson.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collections;
public class TestTransaction {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
//关闭数据库的自动提交功能,自动会开启事务
conn.setAutoCommit(false);
String sql1 = "update account set money = money -100 where id = 1";
st = conn.prepareStatement(sql1);
st.executeUpdate();
// int x = 1/0;//报错就会回滚
String sql2 = "update account set money = money +100 where id = 2";
st = conn.prepareStatement(sql2);
st.executeUpdate();
//业务完毕,提交业务
conn.commit();
System.out.println("操作成功");
} catch (SQLException throwables) {
try {
conn.rollback();//如果失败则回滚,系统默认也会回滚
} catch (SQLException e) {
e.printStackTrace();
}
throwables.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
10.8 数据库连接池
编写连接池,实现一个接口 DataSource
开源数据源实现(拿来即用)
DBCP,C3P0,Druid
使用数据库连接池,在项目开发中就不需要再编写连接数据库的代码!!!P
无论使用什么数据源,本质都一样,DataSource接口不会变,方法就不会变
DBCP
需要导用的jar包:commons-dbcp-1.4.jar,commons-pool-1.6.jar
public class JdbcUitls_DBCP {
private static DataSource dataSource = null ;
static{
try {
InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
Properties properties = new Properties();
properties.load(in);
//创建数据源 工厂模式来创建对象
dataSource = BasicDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();//从数据源中获取连接
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) {
if (rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (st!=null){
try {
st.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
使用
public class TestDBCP {
public static void main(String[] args) {
Connection conn = null ;
PreparedStatement st = null;
try {
conn = JdbcUitls_DBCP.getConnection();
//与Statement的区别
//使用? 占位符代替参数
String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
st = conn.prepareStatement(sql); //要加入参数,预编译SQL,然后不执行
//手动给参数赋值
st.setInt(1,5); //id
st.setString(2,"xiaokang");
st.setString(3,"123456");
st.setString(4,"2982023644@qq.com");
//注意点:sql.Date 数据库用的 java.sql.Date()
// util.Date jaca使用的 new Date().getTime() 获得时间戳
st.setDate(5,new java.sql.Date(new java.util.Date().getTime()));
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("插入成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUitls_DBCP.release(conn,st,null);
}
}
}
CP30
properties.load(in);
//创建数据源 工厂模式来创建对象
dataSource = BasicDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();//从数据源中获取连接
}
//释放资源
public static void release(Connection conn, Statement st, ResultSet rs) {
if (rs!=null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (st!=null){
try {
st.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (conn!=null){
try {
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
使用
```java
public class TestDBCP {
public static void main(String[] args) {
Connection conn = null ;
PreparedStatement st = null;
try {
conn = JdbcUitls_DBCP.getConnection();
//与Statement的区别
//使用? 占位符代替参数
String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
st = conn.prepareStatement(sql); //要加入参数,预编译SQL,然后不执行
//手动给参数赋值
st.setInt(1,5); //id
st.setString(2,"xiaokang");
st.setString(3,"123456");
st.setString(4,"2982023644@qq.com");
//注意点:sql.Date 数据库用的 java.sql.Date()
// util.Date jaca使用的 new Date().getTime() 获得时间戳
st.setDate(5,new java.sql.Date(new java.util.Date().getTime()));
//执行
int i = st.executeUpdate();
if(i>0){
System.out.println("插入成功!");
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
JdbcUitls_DBCP.release(conn,st,null);
}
}
}
CP30
需要导用的jar包:c3p0-oracle-thin-extras-0.9.5.5.jar,mchange-commons-java-0.2.19.jar