文章目录
MySQL
生成链接目录:[TOC]+Enter
1、初识数据库
1.1 为什么需要学习数据库
1、岗位技能需求
2、现在的世界,得数据者得天下
3、存储数据的方法
4、程序,网站中,大量数据如何长久保存?
5、数据库是几乎软件体系中最核心的一个存在。
1.2 什么是数据库
数据库 ( DataBase , 简称DB )
概念 : 长期存放在计算机内,有组织,可共享的大量数据的集合,是一个数据 “仓库”
作用 : 存储数据,管理数据
1.3 数据库的分类
关系型数据库 ( SQL ):
- MySQL , Oracle , SQL Server , SQLite , DB2 , …
- 关系型数据库通过外键关联来建立表与表之间的关系
非关系型数据库 ( NOSQL ):not only
- Redis , MongoDB , …
- 非关系型数据库通常指数据以对象的形式存储在数据库中,而对象之间的关系通过每个对象自身的属性来决定
什么是DBMS:数据库管理系统 ( DataBase Management System ),数据库管理软件 , 科学组织和存储数据 , 高效地获取和维护数据
为什么要说这个呢? 因为我们要学习的MySQL应该算是一个数据库管理系统.
1.4 MySQL简介
概念 : 是现在流行的开源的,免费的 关系型数据库
历史 : 由瑞典MySQL AB 公司开发,目前属于 Oracle 旗下产品。
特点 :
免费 , 开源数据库
小巧 , 功能齐全
使用便捷
可运行于Windows或Linux操作系统
可适用于中小型甚至大型网站应用
官网 : https://www.mysql.com/
1.5 SQLyog
可手动操作,管理MySQL数据库的软件工具
特点 : 简洁 , 易用 , 图形化
2、DDL定义数据(用的少)
操作数据库 > 操作数据库中的表 > 操作数据库中表的数据
2.1、操作数据库(了解)
mysql不区分大小写
1、创建数据库
-- []表示可选
CREATE DATABASE [IF NOT EXISTS] school;
2、删除数据库
-- []表示可选
DROP DATABASE [IF EXISTS] westos;
3、使用数据库
-- 如果表名或字段名是一个特殊的字符,需要加tab键上的反引号``
USE school;
4、查看数据库
-- 查看所有的数据库
SHOW DATABASES;
2.2、数据库的列类型
数值
- tinyint 十分小的数据 1个字节
- smallint 较小的数据 2个字节
- mediumint 中等大小的数据 3个字节
- int 标准的整数 4个字节 常用的int
- bigint 较大的数据 8个字节
- float 单精度浮点型 4个字节
- double 双精度浮点型 8个字节 (都存在精度问题!)
- decimal 字符串形式的浮点数 在金融计算的时候,一般使用decimal
字符串
- char 字符串固定大小 0-255
- varchar 可变字符串 0~65535 常用的变量 String
- tinytext 微型文本 >2^8-1
- text 文本串 >2^16-1 保存大文本
时间日期
java.utils.Date
- date YYYY-MM-DD 日期格式
- time HH:mm:ss 时间格式
- datatime YYYY-MM-DD HH:mm:ss 最常用的时间格式
- timestamp 时间戳 1970.1.1到现在的毫秒数! 也较为常用!
- year 年份表示
null
- 没有值,未知
- 不要使用NULL进行运算,使用结果为NULL
2.3、数据库的字段属性(重点)
unsigned
- 无符号整数
- 声明该列不能为负数
zerofill
- 零填充
- 不足的位数,用0填充。int(3) 5----005
自增
- 通常理解为自增,在上一条记录的基础上加1(默认)
- 通常用来设置唯一的主键–index,必须是整型
- 可以自定义主键的起始值和步长
非空NULL not null
- 假设设置为not null,如果不给它赋值,则会报错
- NULL,如果不填写,默认就是null
默认
- 设置默认的值!
- sex,默认为男,如果不填写该列,则默认值为男!
拓展:听听就好
/*每一个表,都必须存在以下五个字段!表示一个记录存在的意义!
id 主键
`version` 乐观锁
is_delete 伪删除
gmt_create 创建时间
gmt_update 更新时间
*/
2.4、创建数据库表(重点)
-- 目标:创建一个school数据库
-- 创建学生表(列,字段) 使用SQL创建
-- 学号int 登录密码varchar(20) 姓名 性别varchar(2) 出生日期(datatime) 家庭住址 email
-- 注意点:使用英文(),表的 名称 和 字段 尽量使用``括起来
-- AUTO INCREMENT 自增
-- COMMENT 注释
-- 字符串使用 单引号'' 括起来
-- 所有的语句后面加逗号,最后一个不用加
-- PRIMART KEY 主键,一般一个表只有一个唯一的主键!
CREATE TABLE `student`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '登录密码',
`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`)
)ENGINE=INNODB CHARSET=utf8;
格式
CREATE TABLE [IF NOT EXISTS] `表名`(
`字段名` 列类型 [属性] [索引] [注释],
`字段名` 列类型 [属性] [索引] [注释],
......
`字段名` 列类型 [属性] [索引] [注释]
)[表类型][字符集设置][注释]
--[]可选
常用命令
SHOW CREATE DATABASE school; -- 查看创建数据库的语句
-- output:CREATE DATABASE `school` /*!40100 DEFAULT CHARACTER SET utf8 */
SHOW CREATE TABLE student; -- 查看创建student表的语句
/* output:CREATE TABLE `student` (
`id` int(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` varchar(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` varchar(20) NOT NULL DEFAULT '123456' COMMENT '登录密码',
`sex` varchar(2) NOT NULL DEFAULT '女' COMMENT '性别',
`birthday` datetime DEFAULT NULL COMMENT '出生日期',
`address` varchar(100) DEFAULT NULL COMMENT '家庭住址',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
*/
DESC TABLE student; -- 显示表的结构
2.5、数据表的类型
-- 关于数据库的引擎
/*
INNODB 默认使用~
MYISAM 早些年使用
*/
MYISAM | INNODB | |
---|---|---|
事务支持 | 不支持 | 支持 |
数据行锁定 | 不支持 | 支持 |
外键约束 | 不支持 | 支持 |
全文索引 | 支持 | 不支持 |
表空间的大小 | 较小 | 较大,约为MYISAM的两倍 |
常规使用操作:
- MYISAM 节省空间,速度较快
- INNODB 安全性高,支持事务的处理,允许多表多用户操作
在物理空间的位置:
所有的数据库文件在data的目录下,一个文件夹对应一个数据库
本质上还是文件的存储!
MySQL 引擎在物理文件上的区别
- INNODB 在数据库表中只有一个
*.frm
文件(其他两个不属于他的),以及上级目录下的ibdata1
文件
- MYISAM对应的文件
*.frm
表结构的定义文件*.MYD
数据文件(data)*.MYI
索引文件(index)
设置字符集表的字符集编码
CHARSET=utf8
不设置的话,会是mysql默认的字符集编码~(不支持中文!)
MySQL的默认编码是Latin1,不支持中文
也可以在my.ini中配置默认的编码
character-set-server=utf8
2.6、修改删除表
[注] CHANGE
和MODIFY
的区别:CHANGE
用来实现字段的重命名,MODIFY
用来修改字段的类型和约束。
修改
-- 修改表名: ALTER TABLE 旧表名 RENAME AS 新表名
ALTER TABLE teacher RENAME AS teacher1;
-- 增加表的字段: ALTER TABLE 表名 ADD 字段名 列属性
ALTER TABLE teacher1 ADD `age` INT(3);
-- 修改表的字段 (修改约束和重命名)(重点)
-- ALTER TABLE 表名 MODIFY 字段名 列属性[]
ALTER TABLE teacher1 MODIFY `age` VARCHAR(10); -- 修改字段类型和约束
-- ALTER TABLE 表名 CHANGE 旧名字 新名字 列属性[]
ALTER TABLE teacher1 CHANGE `age` `age1` INT(3); -- 重命名字段
-- 删除表的字段:ALTER TABLE 表名 DROP 字段名
ALTER TABLE teacher1 DROP `age1`;
删除
-- 删除表(如果表存在再删除)
DROP TABLE IF EXISTS `teacher1`;
所有的创建和删除尽量加上判断,以免报错~
注意点:
- 所有的字段名尽量使用反引号``包裹;
- 注释使用 --或者/**/;
- sql关键字大小写不敏感,建议都用小写;
- 所有的符号全部都用英文!
3、DML管理数据
3.1、外键(了解即可)
方式一:创建表的时候,增加约束(麻烦,比较复杂)
CREATE TABLE `grade`(
`grade_id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
`grade_name` VARCHAR(20) NOT NULL COMMENT '年级名称',
PRIMARY KEY(`grade_id`)
)ENGINE=INNODB CHARSET=utf8;
-- 学生表的 grade_id字段要去引用年级表的 grade_id
-- 定义外键key: KEY `FK_grade_id` (`grade_id`),
-- 给这个外键添加约束(执行引用) references: CONSTRAINT `FK_grade_id` FOREIGN KEY (`grade_id`) REFERENCES `grade` (`grade_id`)
CREATE TABLE `student`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(20) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '登录密码',
`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
`grade_id` INT(10) NOT NULL COMMENT '学生的年级',
`address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`),
KEY `FK_grade_id` (`grade_id`),
CONSTRAINT `FK_grade_id` FOREIGN KEY (`grade_id`) REFERENCES `grade` (`grade_id`)
)ENGINE=INNODB CHARSET=utf8;
删除有外键关系的表的时候,必须删除引用别人的表(从表),再删除被引用的表(主表)。
方式二:创建表成功后,添加外键约束。
-- 创建表的时候没有外键关系
ALTER TABLE `student`
ADD CONSTRAINT `FK_grade_id` FOREIGN KEY (`grade_id`) REFERENCES `grade` (`grade_id`);
-- ALTER TABLE 表名 ADD CONSTRAINT 约束名 FOREIGN KEY (作为外键的列) REFENCES 哪个表(哪个字段);
以上操作都是物理外键,即数据库级别的外键,不建议使用(要避免数据库过多造成困扰,这里了解即可~)
最佳实现
- 数据库就是单纯的表,只用来存数据,只有行(数据)和列(字段);
- 如果想使用多张表的数据,可以考虑程序去实现。
3.2、DML语言(全部记住,背)
数据库的意义:数据存储和数据管理。
DML语言:数据操作语言。
- insert
- update
- delete
3.3、添加
insert
-- 插入语句(添加)
-- 由于主键自增可以省略(如果不写表的字段,他就会一一匹配)
-- 写插入语句,数据和字段要一一对应
-- insert into 表名([字段1,字段2,字段3,...]) values('值1'),('值2'),('值3');
INSERT INTO `grade` (`grade_name`) VALUES('大二');
-- 插入多条数据
-- insert into 表名([字段,...]) values('值1'),('值2'),('值3');
INSERT INTO `grade`(`grade_name`) VALUES('大一'),('大二'),('大三');
-- 插入多个字段
INSERT INTO `student`(`name`) VALUES('张三');
INSERT INTO `student`(`name`, `pwd`, `sex`) VALUES('张三', 'aaaaa', '男'),('王五', 'sssss', '女');
语法:insert into 表名([字段1,字段2,字段3,…]) values(‘值1’,‘值2’,‘值3’,…)
注意事项:
- 字段与字段之间使用英文逗号隔开
- 字段是可以省略的,但是后面的值要一一对应,不能少
- 可以同时插入多条数据,VALUES后面的值,需要使用逗号隔开——
VALUES(),(),()...;
3.4、修改
update 修改谁 (条件) set原来的值=新值
-- 修改学员的名字,记得带条件!
UPDATE `student` SET `name`='狂神' WHERE id = 1;
-- 不指定条件,则会改动所有的表!
UPDATE `student` SET `name`='长江七号';
-- 修改多个属性,逗号隔开即可
UPDATE `student` SET `name`='狂神', email='100249585@qq.com' WHERE id=1;
语法:UPDATE 表名 SET 列名=value[列名=value,列名=value...] WHERE [条件]
条件:where子句 运算符 id=某个值 >某个值 <某个值,在某个区间进行修改
操作符会返回布尔值
操作符 | 含义 | 范围 | 结果 |
---|---|---|---|
= | 等于 | 5=6 | false |
<>、!= | 不等于 | 5<>6 | true |
> | 大于 | 5>6 | false |
< | 小于 | 5<6 | true |
<= | 小于等于 | 5<=6 | true |
>= | 大于等于 | 5>=6 | false |
BETWEEN…AND… | 在某个范围内 | [2,5] | |
AND | 我和你&& | 5>1 and 1>2 | false |
or | 我或你|| | 5>1 or 1>2 | true |
-- 通过多个条件定位数据,无上限! && ||
UPDATE `student` SET `name`='长江七号' WHERE `name`='狂神99' AND `sex`='女';
语法:UPDATE 表名 SET 列名=value,[列名=value...] WHERE [条件]
注意:
- 列名是数据库的列,尽量带上``
- 条件:筛选的条件,如果没有指定,则会修改所有的列
- value,是一个具体的值,也可以是一个变量(CURRENT_TIME:当前时间)
- 多个设置的属性之间,使用英文逗号隔开
-- 通过多个条件定位数据,无上限! && ||
UPDATE `student` SET `birthday`=SYSDATE(), `name`='长江七号' WHERE `name`='狂神99' AND `sex`='男';
3.5、删除
delete命令
语法:delete from 表名 [where 条件]
-- 删除数据(避免这样写,会全部删除)
DELETE FROM `student`;
-- 删除指定数据
DELETE FROM `student` WHERE `id`=1;
TRUNCATE 命令
作用:完全清空一个数据库表,表的结构和索引约束不会变!
-- 清空 student 表
TRUNCATE `student`;
delete 和 TRUNCATE 的区别
- 相同点:都能删除表的数据,都不会删除表的结构
- 不同点:
- TRUNCATE 会重新设置 自增列,会使得计数器归零
- TRUNCATE 不会影响事务
-- 测试 delete 和 TRANCATE 区别
CREATE TABLE `test`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '序号',
`coll` VARCHAR(20) NOT NULL COMMENT '对应值',
PRIMARY KEY(`id`)
)ENGINE=INNODB CHARSET=utf8;
INSERT INTO `test`(`coll`) VALUES('1'),('2'),('3');
DELETE FROM `test`; -- 不会影响自增
TRUNCATE `test`; -- 自增会归零
了解即可:DELETE删除的问题
,重启数据库的现象
- 如果表是INNODB引擎,自增列会从1开始 (因为INNODB的数据是存储在内存中的,断电即失)
- 如果表是MyISAM引擎,自增列会从上一个自增量开始(因为MyISAM的数据是存储在本地文件中,不会丢失)
4、DQL查询数据(最重点)
4.1、DQL
(Data Query Language:数据库查询语言)
- 所有的查询操作都用它 Select
- 简单的查询,复杂的查询它都能做~
- 数据库中最核心的语言,最重要的语句
- 使用频率最高的语句
select 语法
SELECT [ALL | DISTINCT]
{*|table.*| [table.field1[as alias1][,table.field1[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.2、指定查询字段
-- 查询全部的学生 SELECT 字段 FROM 表
SELECT * FROM `student`;
-- 查询指定字段
SELECT `studentno`, `studentname` FROM `student`;
-- 别名,给结果起一个名字 AS 可以给字段起别名,也可以给表起别名
SELECT `studentno` AS 学号, `studentname` AS 学生姓名 FROM `student`;
-- 函数 concat(a, b) 字符串的拼接
SELECT CONCAT('新名字:', `studentname`) AS 新名字 FROM `student`;
语法:SELECT 字段名1[AS 别名1],字段名2[AS 别名2],.., FROM 表 AS 别名
有时候字段名不是很见名知意,可以对它使用别名
去重 distinct
作用:去除SELECT
语句查询结果中重复的数据,只显示一条。
-- 从成绩表中查询一下哪些同学参加了考试
SELECT * 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 | 逻辑与 |
or || | a or b | 逻辑或 |
Not ! | not a | 逻辑非 |
尽量使用英文字母
。
-- ========================== 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;
模糊查询:本质是比较运算符
运算符 | 语法 | 描述 |
---|---|---|
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, a3,…)中,则结果为真 |
-- ========================== 模糊查询 =========================
-- 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 对比
-- ========================== 联表查询 join =========================
-- 查询参加了考试的同学(学号,姓名,科目编号,分数)
/* 思路
1、分析需求,分析查询的字段来自哪些表。 (连接查询)
2、确定使用哪种连接查询。 (有7种连接查询)
确定交叉点(这两个表中哪个数据是相同的)
判断的条件:学生表中的studentNo = 成绩表 studentNo
*/
-- join (连接的表) on (判断的条件) 连接查询
-- where 等值查询
-- 结果一样,但是本质不一样
-- inner join: 查询交叉部分
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno` = r.`studentno`;
-- right join: 以右表为基准
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
-- left join: 以左表为基准
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
LEFT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
操作 | 描述 |
---|---|
inner join | 如果表中至少有一个匹配,就返回行,两个表都有的字段需要指定具体表的行 |
left join | 会从左表中返回所有的值,即使右表中没有匹配,即以左表为基准 |
right join | 会从右表中返回所有的值,即使左表中没有匹配。即以右表为基准 |
-- ========================== 联表查询 join =========================
-- 查询参加了考试的同学(学号,姓名,科目编号,分数)
/* 思路
1、分析需求,分析查询的字段来自哪些表。 (连接查询)
2、确定使用哪种连接查询。 (有7种连接查询)
确定交叉点(这两个表中哪个数据是相同的)
判断的条件:学生表中的studentNo = 成绩表 studentNo
*/
-- join (连接的表) on (判断的条件) 连接查询
-- where 等值查询
-- inner join: 查询交叉部分
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno` = r.`studentno`;
-- right join: 以右表为基准
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
-- left join: 以左表为基准
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
LEFT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
-- 查询缺考的同学
SELECT s.`studentno`, `studentname`, `subjectno`, `studentresult`
FROM `student` AS s
LEFT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
WHERE `studentresult` IS NULL;
-- 思考题(查询参加考试同学的信息:学号,学生姓名,科目名称,分数)
/* 思路
1、分析需求,分析查询的字段来自哪些表。 sudent、result、subject(连接查询)
2、确定使用哪种连接查询。 (有7种连接查询)
确定交叉点(这两个表中哪个数据是相同的)
判断的条件:学生表中的studentNo = 成绩表 studentNo
*/
SELECT s.`studentno`, `studentname`, `subjectname`, `studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON r.`subjectno`=sub.`subjectno`;
-- 我要查询哪些数据 select ...
-- 从那几个表中查 FROM 表 XXX Join 连接的表 ON 交叉条件
-- 假设存在一种多张表查询,慢慢来,先查询两张表然后慢慢增加
-- FROM a LEFT JOIN b 以左边的表为基准
-- FROM A RIGHT JOIN b 以右边的表为基准
自连接(了解)
自己的表和自己的表的连接。核心:一张表拆为两张一样的表即可
建表如下。
根据pid=1
可得父类如下:
category | categoryName |
---|---|
2 | 信息技术 |
3 | 软件开发 |
5 | 美术设计 |
子类
pid | categoryid | categoryName |
---|---|---|
3 | 4 | 数据库 |
3 | 6 | web开发 |
5 | 7 | ps技术 |
2 | 8 | 办公信息 |
操作:查询表中父类对应子类的关系。
-- 查询父子信息:把一张表看为两个一模一样的表
SELECT a.`categoryName` AS '父栏目', b.`categoryName` AS '子栏目'
FROM `category` AS a, `category` AS b
WHERE a.`categoryid`=b.`pid`;
说白了就是建数据库的人偷懒!导致多余的操作
练习题目:
-- 查询学员所属的年级 (学号,学生的姓名,年级的名称)
SELECT `studentno`, `studentname`, `gradename`
FROM `student` AS s
LEFT JOIN `grade` AS g
ON s.`gradeid`=g.`gradeid`;
-- 查询科目所属的年级 (科目名称,年级名称)
SELECT `subjectname`, `gradename`
FROM `subject` AS sub
INNER JOIN `grade` AS g
ON sub.`gradeid`=g.`gradeid`;
-- 查询了参加 数据库结构-1 考试的同学信息 (学号,学生姓名,科目名,分数)
SELECT s.`studentno`, `studentname`, `subjectname`, `studentresult`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON r.`subjectno`=sub.`subjectno`
WHERE `subjectname` LIKE '数据库结构-1';
-- 查询考试成绩>70的 学生id 学生名字 年级名称 科目名称 考试成绩
SELECT s.`studentno`, `studentname`, `gradename`, `subjectname`, `studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `grade` AS g
ON s.`gradeid`=g.`gradeid`
INNER JOIN `subject` AS sub
ON r.`subjectno`=sub.`subjectno`
WHERE `studentresult`>70;
4.5 分页和排序
排序
-- 排序 升序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 sub.subjectname = 'C语言-2'
order by studentresult asc
--上面的顺序不能改变
分页
-- 为什么要分页
-- 缓解数据库压力,给人的体验更好
-- 分页,每页显示五条数据
-- 语法: limit 起始页,页面的数
-- limit 0,5 1-5
-- limit 1,5 1-5
-- limit 6,5
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 0,5
-- 第一页 limit 0,5
-- 第二页 limit 5,5
-- 第三页 limit 10,5
-- 第N页 limit pagesize*(n-1),pagesize
-- pagesize
-- [pagesize*(n-1),pagesize]
-- n 当前页
-- 【数据总数/页面大小=总页数】
语法 limit(查询起始下标,pagesize)
-- 查询 JAVA第一学年 课程成绩前10名并且分数大于80的学生信息(学号,姓名,课程名,分数)
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 = 'JAVA第一学年' and studentresult >= 80
order by studentresult desc
limit 0,10
4.6 子查询
where (这个值是计算出来的) , 本质:在where语句中嵌套一个子查询语句
/*============== 子查询 ================
什么是子查询?
在查询语句中的WHERE条件子句中,又嵌套了另一个查询语句
嵌套查询可由多个子查询组成,求解的方式是由里及外;
子查询返回的结果一般都是集合,故而建议使用IN关键字;
*/
-- 查询 数据库结构-1 的所有考试结果(学号,科目编号,成绩),并且成绩降序排列
-- 方法一:使用连接查询
SELECT studentno,r.subjectno,StudentResult
FROM result r
INNER JOIN `subject` sub
ON r.`SubjectNo`=sub.`SubjectNo`
WHERE subjectname = '数据库结构-1'
ORDER BY studentresult DESC;
-- 方法二:使用子查询(执行顺序:由里及外)
SELECT studentno,subjectno,StudentResult
FROM result
WHERE subjectno=(
SELECT subjectno FROM `subject`
WHERE subjectname = '数据库结构-1'
)
ORDER BY studentresult DESC;
-- 查询课程为 高等数学-2 且分数不小于80分的学生的学号和姓名
-- 方法一:使用连接查询
SELECT s.studentno,studentname
FROM student s
INNER JOIN result r
ON s.`StudentNo` = r.`StudentNo`
INNER JOIN `subject` sub
ON sub.`SubjectNo` = r.`SubjectNo`
WHERE subjectname = '高等数学-2' AND StudentResult>=80
-- 方法二:使用连接查询+子查询
-- 分数不小于80分的学生的学号和姓名
SELECT r.studentno,studentname FROM student s
INNER JOIN result r ON s.`StudentNo`=r.`StudentNo`
WHERE StudentResult>=80
-- 在上面SQL基础上,添加需求:课程为 高等数学-2
SELECT r.studentno,studentname FROM student s
INNER JOIN result r ON s.`StudentNo`=r.`StudentNo`
WHERE StudentResult>=80 AND subjectno=(
SELECT subjectno FROM `subject`
WHERE subjectname = '高等数学-2'
)
-- 方法三:使用子查询
-- 分步写简单sql语句,然后将其嵌套起来
SELECT studentno,studentname FROM student WHERE studentno IN(
SELECT studentno FROM result WHERE StudentResult>=80 AND subjectno=(
SELECT subjectno FROM `subject` WHERE subjectname = '高等数学-2'
)
)
4.7 分组和过滤
-- 查询不同课程的平均分,最高分,最低分
-- 前提:根据不同的课程进行分组
SELECT subjectname,AVG(studentresult) AS 平均分,MAX(StudentResult) AS 最高分,MIN(StudentResult) AS 最低分
FROM result AS r
INNER JOIN `subject` AS s
ON r.subjectno = s.subjectno
GROUP BY r.subjectno -- 通什么字段分组
HAVING 平均分>80;
/*
where写在group by前面.
要是放在分组后面的筛选
要使用HAVING..
因为having是从前面筛选的字段再筛选,而where是从数据表中的>字段直接进行的筛选的
*/
4.8 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}];
-- 指定查询的记录从哪条至哪条
5. MySQL函数
官网:https://dev.mysql.com/doc/refman/8.0/en/built-in-function-reference.html
5.1 常用函数
-- 数学运算
SELECT ABS(-8) -- 绝对值
SELECT CEILING(9.4) -- 向上取整
SELECT FLOOR(9.4) -- 向下取整
SELECT RAND() -- 返回0-1随机数
SELECT SIGN(-10) -- 判断一个数的符号 0-0 负数返回-1 正数返回1
-- 字符串函数
SELECT CHAR_LENGTH('2323232') -- 返回字符串长度
SELECT CONCAT('我','233') -- 拼接字符串
SELECT INSERT('java',1,2,'cccc') -- 从某个位置开始替换某个长度ccva
SELECT UPPER('abc') -- 大写
SELECT LOWER('ABC') -- 小写
SELECT REPLACE('坚持就能成功','坚持','努力') -- 替换指定的字符串
-- 查询姓 周 的同学 ,改成邹
SELECT REPLACE(studentname,'周','邹') FROM student
WHERE studentname LIKE '周%'
-- 时间跟日期函数(记住)
SELECT CURRENT_DATE() -- 获取当前日期
SELECT CURDATE() -- 获取当前日期
SELECT NOW() -- 获取当前时间
SELECT LOCATIME() -- 本地时间
SELECT SYSDATE() -- 系统时间
-- 返回年月日时分秒
SELECT YEAR(NOW())
SELECT MONTH(NOW())
SELECT DAY(NOW())
SELECT HOUR(NOW())
SELECT MINUTE(NOW())
SELECT SECOND(NOW())
-- 系统
SELECT SYSTEM_USER()
SELECT USER()
SELECT VERSION()
5.2 聚合函数(常用)
函数名称 | 描述 |
---|---|
COUNT() | 计数 |
SUM() | 求和 |
AVG() | 平均值 |
MAX() | 最大值 |
MIN() | 最小值 |
-- 聚合函数
/*COUNT:非空的*/
SELECT COUNT(studentname) FROM student;
SELECT COUNT(*) FROM student;
SELECT COUNT(1) FROM student; /*推荐*/
-- 从含义上讲,count(1) 与 count(*) 都表示对全部数据行的查询。
-- count(字段) 会统计该字段在表中出现的次数,忽略字段为null 的情况。即不统计字段为null 的记录。
-- count(*) 包括了所有的列,相当于行数,在统计结果的时候,包含字段为null 的记录;
-- count(1) 用1代表代码行,在统计结果的时候,包含字段为null 的记录 。
/*
很多人认为count(1)执行的效率会比count(*)高,原因是count(*)会存在全表扫描,
而count(1)可以针对一个字段进行查询。其实不然,count(1)和count(*)都会对全表进行扫描,
统计所有记录的条数,包括那些为null的记录,因此,它们的效率可以说是相差无几。而
count(字段)则与前两者不同,它会统计该字段不为null的记录条数。
下面它们之间的一些对比:
1)在表没有主键时,count(1)比count(*)快
2)有主键时,主键作为计算条件,count(主键)效率最高;
3)若表格只有一个字段,则count(*)效率较高。
*/
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即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' AND pwd=MD5('123456');
5.4 小结
-- ================ 内置函数 ================
-- 数值函数
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数据表类型
事务原则 : ACID原则 :原子性,一致性,隔离性,持久性
- 原子性(Atomicity)
要么都成功,要么都失败,不能只发生一个
- 一致性(Consistency)
事务前后的数据完整性要保持一致
- 持久性(Durability)
事务没有提交,恢复到原状(宕机),事务一旦提交就不可逆转,被持久化到数据库中
- 隔离性(Isolation)
事务产生多并发时,互不干扰脏读:
指一个事务读取了另外一个事务未提交的数据。
- 脏读:
指一个事务读取了另外一个事务未提交的数据。
- 不可重复读:
在一个事务内读取表中的某一行数据,多次读取结果不同。(这个不一定是错误,只是某些场合不对)
- 虚读(幻读)
是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。
(一般是行影响,多了一行)
执行事务
-- mysql 自动开启事务提交
SET autocommit=0 -- 关闭
SET autocommit=1 -- 开启(默认的)
-- 手动处理事务
SET autocommit =0 -- 关闭自动提交
-- 事务开启
START TRANSACTION -- 标记一个事务的开始,从这个之后的SQP都在同一个事务内
INSERT XX
INSERT XX
-- 提交 : 持久化(成功)
COMMIT
-- 回滚: 回到原来的样子(失败)
ROLLBACK
-- 事务结束
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. 索引
MySQL索引的建立对于MySQL的高效运行是很重要的,索引可以大大提高MySQL的检索速度。
索引的作用
- 提高查询速度
- 确保数据的唯一性
- 可以加速表和表之间的连接 , 实现表与表之间的参照完整性
- 使用分组和排序子句进行数据检索时 , 可以显著减少分组和排序的时间
- 全文检索字段进行搜索优化
7.1 索引的分类
在一个表中,主键索引只能有一个,唯一索引可以有多个
- 主键索引 (PRIMARY KEY)
- 唯一的标识,主键不可重复,只能有一个列作为主键
- 唯一索引 (UNIQUE KEY)
- 避免重复的列出现,唯一索引可以重复,多个列都可以标识唯一索引
- 常规索引(KEY/INDEX)
- 默认的,index,key关键字来设置
- 全文索引(FULLTEXT)
- 在特点的数据库引擎下才有,MyISAM
- 快速定位数据
/*
#方法一:创建表时
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 版本、存储引擎和数据类型是否支持全文索引。
*/
7.2 测试索引
CREATE TABLE `app_user` (
`id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) DEFAULT '',
`email` VARCHAR(50) NOT NULL,
`phone` VARCHAR(20) DEFAULT '',
`gender` TINYINT(4) UNSIGNED DEFAULT '0',
`password` VARCHAR(100) NOT NULL DEFAULT '',
`age` TINYINT(4) DEFAULT NULL,
`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
`update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
-- 插入100万数据
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`)
VALUE(CONCAT('用户',i),'534240118@qq.com',FLOOR (CONCAT('18',RAND()*9999999)),FLOOR (RAND()*2),
UUID(),FLOOR (RAND()*100));
SET i = i+1;
END WHILE;
RETURN i;
END;
INSERT INTO app_user(`name`,`email`,`phone`,`gender`,`password`,`age`)
VALUE(CONCAT('用户',i),'534240118@qq.com',FLOOR (CONCAT('18',RAND()*9999999)),FLOOR (RAND()*2),
UUID(),FLOOR (RAND()*100))
SELECT mock_data();
SELECT * FROM app_user WHERE `name`='用户9999' -- 接近半秒
EXPLAIN SELECT * FROM app_user WHERE `name`='用户9999' -- 查询99999条记录
-- 创建索引
-- id _ 表名_字段名
-- create index on 字段
CREATE INDEX id_app_user_name ON app_user(`name`);
EXPLAIN SELECT * FROM app_user WHERE `name`='用户9999' -- 查询一条记录,耗时0.001 s
索引在小数据的时候,用处不大,但是在大数据的时候,区别十分明显
7.3 索引原则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用来查询的字段上
8. 权限管理和备份
8.1 用户管理
用户表:mysql.user
本质:对这张表进行,增删改查
-- 创建用户 CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER sanjin IDENTIFIED BY '123456'
-- 修改密码(修改当前密码)
SET PASSWORD = PASSWORD('111111')
-- 修改密码(修改指定用户密码)
SET PASSWORD FOR sanjin = PASSWORD('111111')
-- 重命名 rename user 原名字 to 新名字
RENAME USER sanjin TO sanjin2
-- 用户授权 ALL PRIVILEGES 全部的权限 库,表
-- ALL PRIVILEGES 除了给别人授权,其他都能干
GRANT ALL PRIVILEGES ON *.* TO sanjin2
-- 查询权限
SHOW GRANTS FOR sanjin2 -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost
-- 撤销权限 REVOKE 哪些权限,在哪个库撤销,给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM sanjin2
-- 删除用户
DROP USER sanjin2
8.2 MySQL备份
为什么备份:
- 保证重要数据不丢失
- 数据转移
MySQL数据库备份的方式
- 直接拷贝物理文件,拷贝data文件夹下的文件
- 数据库管理工具- 在想要导出的表或者库中,右键选择备份和导出
- 使用命令行导出 :mysqldump
-- 导出
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 为什么需要数据库设计
设计数据库步骤
-
收集信息
-
与该系统有关人员进行交流 , 座谈 , 充分了解用户需求 , 理解数据库需要完成的任务.
-
标识实体[Entity]
-
标识数据库要管理的关键对象或实体,实体一般是名词
-
标识每个实体需要存储的详细信息[Attribute]
-
标识实体之间的关系[Relationship]
9.2 三大范式
三大范式:
- 第一范式 (1st NF)
第一范式的目标是确保每列的原子性,如果每列都是不可再分的最小数据单元,则满足第一范式
- 第二范式(2nd NF)
第二范式(2NF)是在第一范式(1NF)的基础上建立起来的,即满足第二范式(2NF)必须先满足第一范式(1NF)。
第二范式要求每个表只描述一件事情
- 第三范式(3rd NF)
如果一个关系满足第二范式,并且除了主键以外的其他列都不传递依赖于主键列,则满足第三范式.
第三范式需要确保数据表中的每一列数据都和主键直接相关,而不能间接相关。
- 规范化和性能的关系
关联查询的表不能超过三张(阿里规定)
为满足某种商业目标 , 数据库性能比规范化数据库更重要
在数据规范化的同时 , 要综合考虑数据库的性能
10. JDBC(重点)
10.1 数据库驱动
我们的程序会通过数据库驱动,和数据库打交道!
10.2 JDBC
SUN 公司为了简化开发人员的(对数据库的统一)操作,提供了一个(Java操作数据库的)规范,JDBC
这些规范的实现由具体的厂商去做
对于开发人员来说,我们只需要掌握JDBC的接口操作即可
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,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')
-
1.创建一个普通项目或maven项目
-
2.导入数据库驱动
-
pom.xml
中配置 -
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency>
-
-
3 测试
package com.princehan.lesson01;
//我的第一个JDBC程序
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 {
//1. 加载驱动
Class.forName("com.mysql.jdbc.Driver");//固定写法
//2. 用户信息和url
//useUnicode=true&characterEncoding=utf8&&useSSL=true
String url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=false";
String name = "root";
String password = "0925";
//3. 连接成功,返回数据库对象 connection代表数据库
Connection connection= DriverManager.getConnection(url,name,password);
//4. 执行SQL的对象 statement 执行SQL的对象
Statement statement = connection.createStatement();
//5. 执行SQL的对象 去执行SQL 可能存在结果,查看返回结果
String sql="SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部查询的结果
while(resultSet.next()){
System.out.println("id+"+resultSet.getObject("id"));
System.out.println("name+"+resultSet.getObject("NAME"));
System.out.println("password+"+resultSet.getObject("PASSWORD"));
System.out.println("email+"+resultSet.getObject("email"));
System.out.println("birthday+"+resultSet.getObject("birthday"));
}
//6. 释放连接
resultSet.close();
statement.close();
connection.close();
}
}
步骤总结:
- 1.加载驱动
- 2.连接数据库 DriverManager
- 3.获取执行SQL的对象 Statement
- 4.获得返回的结果集
- 5.释放连接
DriverManager:
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");//固定写法
Connection connection= DriverManager.getConnection(url,name,password);
//connection代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
connection.rollback();
connection.commit();
connection.setAutoCommit();
URL:
String url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&&useSSL=false";
//mysql 默认3306
//协议://主机地址:端口号/数据库名?参数1&参数2&参数3
//Oracle 1521
//jdbc:oralce:thin:@localhost:1521:sid
Statement 执行SQL的对象 PrepareStatement 执行SQL的对象:
String sql="SELECT * FROM users";//编写Sql
statement.executeQuery();
statement.execute();
statement.executeUpdate();//更新,插入,删除,返回一个受影响的行数
ResultSet 查询的结果集,封装了所有的查询结果:
获得指定的数据类型:
ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部查询的结果
resultSet.getObject();//在不知道列类型下使用
resultSet.getString();//如果知道则指定使用
resultSet.getInt();
遍历,指针
resultSet.next(); //移动到下一个
resultSet.afterLast();//移动到最后
resultSet.beforeFirst();//移动到最前面
resultSet.previous();//移动到前一行
resultSet.absolute(row);//移动到指定行
释放内存:
//6. 释放连接
resultSet.close();
statement.close();
connection.close();//耗资源
10.4 statement对象
-
JDBC中的
statement
对象用于向数据库发送SQL语句,想完成对数据库的增删改查,只需要通过这个对象向数据库发送增删改查语句即可。 -
Statement
对象的executeUpdate
方法,用于向数据库发送增、删、改的sq|语句, -
executeUpdate
执行完后, 将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。 -
Statement.executeQuery
方法用于向数据库发生查询语句,executeQuery
方法返回代表查询结果的ResultSet
对象。
CRUD操作-create:
//使用executeUpdate(String sql)方法完成数据添加操作,示例操作:
Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("插入成功");
}
CRUD操作-delete:
//使用executeUpdate(String sql)方法完成数据删除操作,示例操作:
Statement statement = connection.createStatement();
String sql = "delete from user where id =1";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("删除成功");
}
CURD操作-update:
//使用executeUpdate(String sql)方法完成数据修改操作,示例操作:
Statement statement = connection.createStatement();
String sql = "update user set name ='' where name = ''";
int num = statement.executeUpdate(sql);
if(num>0){
System.out.println("修改成功");
}
CURD操作-read:
//使用executeUpdate(String sql)方法完成数据查询操作,示例操作:
Statement statement = connection.createStatement();
String sql = "select * from user where id =1";
ResultSet rs= statement.executeQuery(sql);
if(rs.next()){
System.out.println("");
}
代码实现
1.提取工具类
package com.princehan.lesson02.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 (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//2.获取连接
public static Connection getConnection() throws Exception{
return DriverManager.getConnection(url, username, password);
}
//3.释放资源
public static void release(Connection conn, Statement st, ResultSet rs) throws SQLException {
if(rs!=null){
rs.close();
}
if (st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
}
2.编写增删改的方法,exectueUpdate
package com.princehan.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import static com.kuang.lesson02.utils.JdbcUtils.*;
public class TestInnsert {
public static void main(String[] args){
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
"VALUES(5,'sanjin','123456','233223@qq.com','2020-01-01')";
int i = st.executeUpdate(sql);
if(i>0){
System.out.println("插入成功");
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.查询 executeQuery
package com.princehan.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.kuang.lesson02.utils.JdbcUtils.*;
public class TestInnsert {
public static void main(String[] args) throws SQLException {
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "select * from users";
rs=st.executeQuery(sql);//查询完毕返回结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.release(conn,st,rs);
}
}
}
SQL注入问题
SQL注入是比较常见的网络攻击方式之一,它不是利用操作系统的BUG来实现攻击,而是针对程序员编写时的疏忽,通过SQL语句,实现无账号登录,甚至篡改数据库。sql存在漏洞,会被攻击导致数据泄露 .SQL会被拼接 or
package com.kuang.lesson02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import static com.kuang.lesson02.utils.JdbcUtils.getConnection;
public class SQL注入 {
public static void main(String[] args) {
//SQL注入
login("' or '1=1","123456");
}
public static void login(String name,String password){
Connection conn =null;
Statement st = null;
ResultSet rs =null;
try {
conn = getConnection();//获取连接
st = conn.createStatement();//获取SQL执行对象
String sql = "select * from users where `NAME`='"+ name +"' AND `PASSWORD`='"+ password +"'" ;
rs=st.executeQuery(sql);//查询完毕返回结果集
while (rs.next()){
System.out.println(rs.getString("NAME"));
}
JdbcUtils.release(conn,st,rs);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(conn,st,rs);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
10.5 PreparedStatement对象
PreparedStatement 可以防止SQL注入 ,效率更高。
- 新增
- 删除
- 查询
package com.princehan.lesson03;
import com.princehan.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Test {
public static void main(String[] args) {
Connection connection= null;
PreparedStatement pstm=null;
try {
connection = JdbcUtils.getConnection();
//区别
//使用问好占位符代替参数
String sql = "insert into users(id,`NAME`) values(?,?)";
pstm = connection.prepareStatement(sql);//预编译sql,先写sql然后不执行
//手动赋值
pstm.setInt(1,8);
pstm.setString(2,"SANJIN");
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("插入成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(connection,pstm,null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
10.6 JDBC操作事务
- 开启事务
conn.setAutoCommit(false)
; - 一组业务执行完毕,提交事务
- 可以在catch语句中显示的定义回滚,但是默认失败会回滚
package com.princehan.lesson04;
import com.princehan.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Action {
public static void main(String[] args) {
Connection conn =null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
//关闭数据库的自动提交功能, 开启事务
conn.setAutoCommit(false);
//自动开启事务
String sql = "update account set money = money-500 where id = 1";
ps =conn.prepareStatement(sql);
ps.executeUpdate();
String sql2 = "update account set money = money-500 where id = 2";
ps=conn.prepareStatement(sql2);
ps.executeUpdate();
//业务完毕,提交事务
conn.commit();
System.out.println("操作成功");
} catch (Exception e) {
try {
//如果失败,则默认回滚
conn.rollback();//如果失败,回滚
} catch (SQLException e) {
e.printStackTrace();
}
e.printStackTrace();
}finally {
try {
JdbcUtils.release(conn,ps,rs);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
(sql);//预编译sql,先写sql然后不执行
//手动赋值
pstm.setInt(1,8);
pstm.setString(2,“SANJIN”);
//执行
int i = pstm.executeUpdate();
if (i>0){
System.out.println("插入成功");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JdbcUtils.release(connection,pstm,null);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}
### 10.6 JDBC操作事务
1. 开启事务`conn.setAutoCommit(false)`;
2. 一组业务执行完毕,提交事务
3. 可以在catch语句中显示的定义回滚,但是默认失败会回滚
```java
package com.princehan.lesson04;
import com.princehan.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Action {
public static void main(String[] args) {
Connection conn =null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
//关闭数据库的自动提交功能, 开启事务
conn.setAutoCommit(false);
//自动开启事务
String sql = "update account set money = money-500 where id = 1";
ps =conn.prepareStatement(sql);
ps.executeUpdate();
String sql2 = "update account set money = money-500 where id = 2";
ps=conn.prepareStatement(sql2);
ps.executeUpdate();
//业务完毕,提交事务
conn.commit();
System.out.println("操作成功");
} catch (Exception e) {
try {
//如果失败,则默认回滚
conn.rollback();//如果失败,回滚
} catch (SQLException e) {
e.printStackTrace();
}
e.printStackTrace();
}finally {
try {
JdbcUtils.release(conn,ps,rs);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}