MySQL 2021-03-29
SQL
SHOW CREATE DATABASE school -- 查看创建数据库的语句
SHOW CREATE TABLE student1 -- 查看student数据表的定义语句
DESC student1 -- 显示表的结构
1、初识MySQL
JavaEE：企业级Java开发 Web
前端（页面：展示：数据）
后台 （连接点：连接数据库JDBC,连接前端（控制视图跳转，给前端传递数据））
数据库（存数据，Txt,Excel,Word）
只会写代码，学好数据库，基本混饭吃：
操作系统，数据结构与算法！当一个不错的程序猿！
离散数学，数字电路，体系结构，编译原理。+实战经验，优秀程序猿
1.1为什么学数据库
1、岗位需求
2、现在的世界，大数据时代，得数据者得天下
3、被迫需求：存数据
4、数据库是所有软件体系中最核心的存在 DBA
1.2 什么是数据库
数据库：(DB,DataBase)
概念:数据仓库，软件，安装在操作系统之（windows,Linux。mac）上的！SQL,可以存储大量的数据，500万!
作用:存储数据，管理数据 Excel
1.3 数据库分类
关系型数据库：(SQL)
-
MySQL, Oracle, sql Server, DB2, SQLite
-
通过表和表之间，行和列之间的关系进行数据的存储
非关系型数据库：(NoSQL) Not Only SQL
- Redis, MongDB
- 非关系型数据库，对象存储，通过对象自身的属性来决定。
**DBMS(数据库管理系统) **
- 数据库的管理软件，科学有效的管理我们的数据，维护和获取
- MySQL ，数据管理系统！
1.4 MySQL简介
MySQL是一个关系型数据库管理系统
前世： 瑞典MySQL AB 公司
今身： 属于 Oracle 旗下产品
MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。
开源的数据库软件
体积小，速度快，总体拥有成本低，招人成本比较低。
中小型网站，或者大型网站，集群
2、操作数据库
操作数据库》操作数据库中的表》操作数据库中表的数据
MySQL不区分大小写
2.1操作数据库
1.创建数据库
CREATE DATABASE IF NOT EXISTS westos;
2.删除数据库
DROP DATABASE IF EXISTS westos
1
3.使用数据库
-- ``,如果你的表名或者字段名是一个特殊字符，需要带``
USE 'school'
123
4.产看数据库
SHOW DATABASES--查看所有数据库
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 (保存大文本)
时间日期
java.util.Date
- date YYYY-MM-DD，日期
- time HH:mm:ss 时间格式
- datetime YYYY-MM-DD HH:mm:ss 最常用的时间格式
- timestamp 时间戳 1970.1.1到现在的毫秒数
- year 年份表示
null
- 没有值，未知
- 注意，不要使用null进行运算，结果为null
2.3数据库的字段类型（重点）
unsigened:
- 无符号的整数
- 声明该列
zerofill:
- 0填充的
- 10的长度 1 – 0000000001 不足位数用0 填充
自增：
- 通常理解为自增，自动在上一条记录的基础上+1
- 通常用来设计唯一的主键 index,必须是整数类似
- 可以自定义设置主键自增的起始值和步长
非空 NULL not Null
- 假设设置为 not null，如何不给他赋值，就会报错
- NULL 如果不填写，默认为NULL
默认：
- 设置默认的值！
2.4 创建 添加 修改 删除 数据库表
创建数据库
CREATE TABLE IF NOT EXISTS `student1`student1`` (
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` VARCHAR(20) NOT NULL DEFAULT '123' 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
添加
-- 使用语句如何增加语句?
-- 语法 : 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 ('大三'),('大四');
修改
-- 修改表名 : ALTER TABLE 旧名字 RENAME AS 新名字
ALTER TABLE student RENAME AS student2
-- 增加表的字段 : ALTER TABLE 表名 ADD 字段名 列属性
ALTER TABLE student1 ADD age INT(11)
-- 修改表的字段 (重命名, 修改结束!)
-- ALTER TABLE 表名 MODIFY 字段名 列属性[]
ALTER TABLE student1 MODIFY age VARCHAR(11) -- 修改结束
-- ALTER TABLE 表名 CHANGE 旧名字 新名字 列属性
ALTER TABLE student1 CHANGE age age1 INT(1) -- 字段重命名
-- 删除表的字段:
ALTER TABLE student1 DROP age1
删除
-- 删除表(如果存在再删除)
-- DROP TABLE IF EXISTS 表名
DROP TABLE IF EXISTS school
== 所有的创建和删除操作尽量加上判断,一面报错 ==
注意点:
- ``字段名, 使用这个包裹
- 注释 – /* */
- 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
-- 学生表的 gradeid 字段 要去引用年纪表的 gradeid
-- 定义外键 key
-- 给这个外键定义外键添加约数 (执行引用) reference 引用
CREATE TABLE IF NOT EXISTS `student1`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` VARCHAR(20) NOT NULL DEFAULT '123' COMMENT '密码',
`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
`gradeid` INT(10) NOT NULL COMMENT '学生年级',
`address` VARCHAR(100) DEFAULT NULL COMMENT '地址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`),
KEY `FK_gradeid` (`gradeid`),
CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
方法二
-- 学生表的 gradeid 字段 要去引用年纪表的 gradeid
-- 定义外键 key
-- 给这个外键定义外键添加约数 (执行引用) reference 引用
CREATE TABLE IF NOT EXISTS `student1`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`pwd` VARCHAR(20) NOT NULL DEFAULT '123' COMMENT '密码',
`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
`gradeid` INT(10) NOT NULL COMMENT '学生年级',
`address` VARCHAR(100) DEFAULT NULL COMMENT '地址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
-- 创建表的时候没有外键关系
ALTER TABLE `student1`
ADD CONSTRAINT `fk_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);
-- ALTER TABLE 表 ADD CONSTRAINT 约束名 FOREIGN KEY(作为外键的列) REFERENCES 那个表(那个字段)
以上的操作都是物理外键,数据库级别的外键,我们不建议使用!! (避免数据库过多造成困扰,这里了解即可~)
== 最佳实践 ==
- 数据库就是单纯的表,只是用来存数据,只有行(数据)和列(字段)
- 我们想使用多张表的数据,想使用外键 (用程序实现)
3.2 DML语言(记住)
数据库的意义: DML 是对数据库的增删改操作，即添加表中的数据，删除表中的数据，修改表中的数据。
DML语言: 数据库操作语言
- insert（添加）
- update（修改)
- delete（删除）
3.3 添加
insert
-- 插入语句(添加)
-- insert in to 表名([字段名1,字段名2,字段名3]) values('值1'), ('值2'), ('值3')....
INSERT INTO `student` (`name`) VALUES('哥哥1')
-- 由于住键自增我们可以省略(如果不写表的字段,他就会一一匹配)
INSERT INTO `student` VALUES('姐姐')
-- 一般写插入语句,我们一定要数据和字段一一对应!
INSERT INTO `student` (`name`)
VALUES('大明'),('二明')
INSERT INTO `student` (`name`,`pwd`,`sex`)
VALUES('杰哥','www','男'),('花花','999','男')
INSERT INTO `student` VALUES('123','大哥','aaa','男','2001-1-1','桂林','a123')
语法 : insert into 表名([字段名1, 字段名2, 字段名3]) values('值1') , ('值2') , ('值3')...
注意事项:
- 字段和字段之间使用 英文逗号 隔开
- 字段是可以省略的, 但是后面的值必须要一一对应,不能少
- 可以同时插入多条数据,VALUES 后面的值, 需要使用 , 隔开即可
vALUES(),()...
3.4 修改
update 修改谁 (条件) set 原来的值 = 新值
-- 修改学员名字,带了简介
UPDATE `student` SET `name` = '小框' WHERE id = 2
-- 不指定条件的情况下,会改变所有的表的name值, 建议跑路
UPDATE `student` SET `name` = '小白'
-- 语法:
-- UPDATE 表名 set colnum_name= value WHERE[条件]
条件: where 子句 运算符 id 等于某个值, 大于某个值, 在某个区间内修改…
操作符会返回 布尔值
| 操作符 | 含义 | 范围 | 结果 |
|---|---|---|---|
| = | 等于 | 5 = 6 | flase |
| <> 或 != | 不等于 | 5<>5 | true |
| > | 大于 | 5>3 | true |
| < | 小于 | 3<4 | ture |
| <= | 小于等于 | 5<=3 | false |
| >= | 大于等于 | 5>=5 | true |
| BETWEEN…and… | 在某个范围 | 2 and 5 | [2,5] |
| AND | 我和你 && | 5>1 and 1<2 | false |
| OR | 我或你 || | 5>1 or 1<2 | true |
-- 修改id
UPDATE `student` SET `name` = '方法' WHERE `name` = '李白' AND `sex` = '男'
UPDATE `student` SET `name` = '旧居' WHERE id BETWEEN 3 AND 5
-- 修改id和密码 修改多个属性用逗号隔开
UPDATE `student` SET `id` = '花花' , pwd` = '777' WHERE id = 2 < 3 && `sex` = '男'
-- 修改时间 多条件
UPDATE `student` SET `birthday` = CURRENT_TIME WHERE `name` = '旧居' AND `sex` = '女'
语法: `UPDATE 表名 set property_name = value, [ property_name = value,…] where [条件]
注意:
- property_name 是数据库的列, 尽量带上``
- 条件, 筛选啊的条件,如果没有指定,则会修改所有的列
- value, 是一个具体的值, 也可以是一个变量
- 多个设置的属性之间, 使用英文逗号隔开
3.5 删除
delete 命令
语法: `delete from 表名 [where 条件]
-- 删除数据 (避免这样写,会全部删除)
DELETE FROM `student`
-- 删除数据
DELETE FROM `student` WHERE id = 1
delete 的 TRUNCATE 区别
- 相同点: 都能删除数据, 都不会删除表结构
- 不同:
- TRUNCATE 重新设置 自增列 计数器会归零
- TRUNCATE 不会影响事务
-- 测试delete 和 TRUNCATE 区别
CREATE TABLE `test`(
`id` INT(4) NOT NULL AUTO_INCREMENT,
`coll` VARCHAR(20) NOT NULL,
PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `test` (`coll`) VALUES('1'), ('2'), ('3')
DELETE FROM `test` -- 不影响自增
TRUNCATE TABLE `test` -- 自增会归零
了解即可:DELETE ,重启数据库, 现象
- innoDB 自增列会重新开始 (存在内存当中, 断电即失)
- MyISAM 继续从上一个子增量开始 (存在文件中的,不会丢失)
4 DQL查询数据(核心知识 最重要)
4.1DQL
(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}]; -- 指定查询的纪录从哪条到那条
/*
-- 顺序很重要
select 去重 要查询的字段 from 表 (注意: 表和字段可以取别名)
xxx.join 要链接的表 on 等值判断
where (具体的值, 子查询语句)
Group By (通过那个字段来分组)
Having (过滤分组后的信息, 条件和 where 是一样的, 位置不同)
Order By .. (通过哪个字段排序) [升序/降序]
Limit startIndex, pagesize
业务层面:
查询: 跨表, 跨数据库...
*/
注意: [] 括号代表可选的, {}括号代表必选得
创建数据
-- 创建一个school数据库
CREATE DATABASE IF NOT EXISTS `school`;
-- 创建一个school数据库
USE `school`;-- 创建学生表
DROP TABLE IF EXISTS `student`; -- 如果表已经存在就删除
CREATE TABLE `student`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`loginpwd` VARCHAR(20) DEFAULT NULL,
`studentname` VARCHAR(20) DEFAULT NULL COMMENT '学生姓名',
`sex` TINYINT(1) DEFAULT NULL COMMENT '性别，0或1',
`gradeid` INT(11) DEFAULT NULL COMMENT '年级编号',
`phone` VARCHAR(50) NOT NULL COMMENT '联系电话，允许为空',
`address` VARCHAR(255) NOT NULL COMMENT '地址，允许为空',
`borndate` DATETIME DEFAULT NULL COMMENT '出生时间',
`email` VARCHAR (50) NOT NULL COMMENT '邮箱账号允许为空',
`identitycard` VARCHAR(18) DEFAULT NULL COMMENT '身份证号',
PRIMARY KEY (`studentno`),
UNIQUE KEY `identitycard`(`identitycard`),
KEY `email` (`email`)
)ENGINE=MYISAM DEFAULT CHARSET=utf8;
-- 创建年级表
DROP TABLE IF EXISTS `grade`; -- 如果表已经存在就删除
CREATE TABLE `grade`(
`gradeid` INT(11) NOT NULL AUTO_INCREMENT COMMENT '年级编号',
`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
PRIMARY KEY (`gradeid`)
) ENGINE=INNODB AUTO_INCREMENT = 6 DEFAULT CHARSET = utf8;
-- 创建科目表
DROP TABLE IF EXISTS `subject`; -- 如果表已经存在就删除
CREATE TABLE `subject`(
`subjectno`INT(11) NOT NULL AUTO_INCREMENT COMMENT '课程编号',
`subjectname` VARCHAR(50) DEFAULT NULL COMMENT '课程名称',
`classhour` INT(4) DEFAULT NULL COMMENT '学时',
`gradeid` INT(4) DEFAULT NULL COMMENT '年级编号',
PRIMARY KEY (`subjectno`)
)ENGINE = INNODB AUTO_INCREMENT = 19 DEFAULT CHARSET = utf8;
-- 创建成绩表
DROP TABLE IF EXISTS `result`; -- 如果表已经存在就删除
CREATE TABLE `result`(
`studentno` INT(4) NOT NULL COMMENT '学号',
`subjectno` INT(4) NOT NULL COMMENT '课程编号',
`examdate` DATETIME NOT NULL COMMENT '考试日期',
`studentresult` INT (4) NOT NULL COMMENT '考试成绩',
KEY `subjectno` (`subjectno`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;
-- 插入科目数据
INSERT INTO `subject`(`subjectno`,`subjectname`,`classhour`,`gradeid`)VALUES
(1,'高等数学-1',110,1),
(2,'高等数学-2',110,2),
(3,'高等数学-3',100,3),
(4,'高等数学-4',130,4),
(5,'C语言-1',110,1),
(6,'C语言-2',110,2),
(7,'C语言-3',100,3),
(8,'C语言-4',130,4),
(9,'Java程序设计-1',110,1),
(10,'Java程序设计-2',110,2),
(11,'Java程序设计-3',100,3),
(12,'Java程序设计-4',130,4),
(13,'数据库结构-1',110,1),
(14,'数据库结构-2',110,2),
(15,'数据库结构-3',100,3),
(16,'数据库结构-4',130,4),
(17,'C#基础',130,1);`student``subject`
-- 插入学生数据 其余自行添加 这里只添加了2行
`student`
-- 插入成绩数据 这里仅插入了一组，其余自行添加
INSERT INTO `result`(`studentno`,`subjectno`,`examdate`,`studentresult`)
VALUES
(1000,1,'2013-11-11 16:00:00',85),
(1000,2,'2013-11-12 16:00:00',70),
(1000,3,'2013-11-11 09:00:00',68),
(1000,4,'2013-11-13 16:00:00',98),
(1000,5,'2013-11-14 16:00:00',58);
-- 插入年级数据
INSERT INTO `grade` (`gradeid`,`gradename`) VALUES(1,'大一'),(2,'大二'),(3,'大三'),(4,'大四'),(5,'预科班');
4.2 指定查询字段
-- 查询全部学生 SELECF字段 EROM
SELECT * FROM `student`
-- 查询部分学生 查询指定字段
SELECT `studentno`, `studentname` FROM `student`
-- 别名, 给每个结果起一个名字 AS
SELECT `studentno` AS 学号, `studentname` AS 名字 FROM `student` AS s
-- 函数 Concat(a,b)
SELECT CONCAT('姓名:', `studentname`) AS 新名字 FROM `student`
语法:SELECT 字段 ,... FROM 表
有的时候, 列名字不是那么的见名知意.我们需要起别名 AS 字段名 as 别名
去重 distinct
作用: 去除SELECT 查询出来的结果重复的数据, 重复的数据之线是一条
-- 查询一下有哪些同学参加了考试,成绩
SELECT * FROM `result` -- 查询全部考试的成绩
SELECT `studentno` FROM `result` -- 查询有哪些同学参加了考试
SELECT DISTINCT `studentno` FROM result -- 发现重复数据,去重
数据库的列(表达式)
SELECT VERSION() AS '查询系统版本' -- 查询系统版本 (函数)
SELECT 10*12+1 AS '计算结果' -- 用来计算 (表达式)
SELECT @@auto_increment_increment AS '查询自增的步数' -- 查询自增的步数(变量)
-- 学员考试成绩 + 1分查看
SELECT `studentno`, `studentresult`+2 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 | 逻辑非,真为假,假为真 |
== 尽量使用英文字母 ==
-- ================ 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`>= 95 && `studentresult` <= 100
-- 模糊查询(区间)
SELECT `studentno`, `studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 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…其中的某一部分中, 结果为真 |
-- ================== 模糊查询 ====================
-- 查询姓牛的同学
-- like 结合 %(代表0到任意个字符) _ (代表一个字符)
SELECT `studentno`, `studentname` FROM `student`
WHERE `studentname` LIKE '牛%'
-- 查询性张的同学, 名字后面只有一个字de
SELECT `studentno`, `studentname` FROM `student`
WHERE `studentname` LIKE '张_'
-- 查询名字中有大字的同学 %大%
SELECT `studentno`, `studentname` FROM `student`
WHERE `studentname` LIKE '%大%'
-- ============ in ==============
-- 查询 1001, 1003 学号学员
SELECT `studentno`, `studentname` FROM `student`
WHERE `studentno` IN (1001,1003)
SELECT `studentno`, `studentname` FROM `student`
WHERE `studentno` = 1000 || `studentno` = 1003
-- 查询在地址的学生
SELECT `studentno` AS 学号 , `studentname` AS 名字 FROM `student`
WHERE `address` IN ('广东');
-- ====null not null =====
-- 查询地址为空的同学null ''
SELECT `studentno` AS 学号 , `studentname` AS 名字 FROM `student`
WHERE `address`= '' OR `address` IS NULL
-- 查询有出生日期的同学
SELECT `studentno` , `studentname` FROM `student`
WHERE `borndate` IS NOT NULL
-- 查询没有出生日期的同学
SELECT `studentno` , `studentname` FROM `student`
WHERE `borndate` IS NULL
4.4 联表查询
JOIN 对比
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kt0VlyiK-1617024798720)(C:\Users\86135\AppData\Roaming\Typora\typora-user-images\image-20210326213909549.png)]
-- ================ 联表查询 join ===================
-- 查询参加了考试的同学 (学号, 姓名, 科目编号, 分数)
SELECT * FROM `student`
SELECT * FROM `result`
/* 思路
1. 分析需求, 分析查询的字段来自哪些表, (连接查询)
2. 确定使用哪些连接查询? 7种
确定交叉点(这两个表中哪个数据是相同的)
判断条件: 学生表中 studentno = 成绩表 studentno
*/
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 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 ===================
-- 查询参加了考试的同学 (学号, 姓名, 科目编号, 分数)
SELECT * FROM `student` -- * 是所有的意思
SELECT * FROM `result`
/* 思路
1. 分析需求, 分析查询的字段来自哪些表, (连接查询)
2. 确定使用哪些连接查询? 7种
确定交叉点(这两个表中哪个数据是相同的)
判断条件: 学生表中 studentno = 成绩表 studentno
*/
-- join (
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 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, `result`
FROM student AS s
LEFT JOIN result AS r
ON s.studentno = r.studentno
WHERE studentresult IS NULL
-- 思考题(查询了参加考试的同学: 学号, 学生姓名, 科目名, 分数)
SELECT s.studentno AS '学号',studentname AS '姓名' ,subjectname AS '课程名', studentresult AS '成绩'
FROM `student` AS s
LEFT JOIN result AS r
ON s.studentno = r.studentno
INNER JOIN `subject` AS su
ON r.subjectno = su.subjectno
-- 我要查询哪些数据 select...
-- 从哪几个表中查 FROM 表 XXX Join 连接的表 on 交叉条件
-- 假设存在一种多张表查询, 慢慢来, 先查寻两张表然后在慢慢增加
-- From a left join b
-- From a right join b
自连接
自己的表和自己的表连接, 核心: 一张表拆为两张一样的表即可
父类
| categoryid | categoryName |
|---|---|
| 2 | 信息技术 |
| 3 | 软件开发 |
子类
| pid | categoryid | categoryid |
|---|---|---|
| 2 | 8 | 办公信息 |
| 3 | 4 | 数据库 |
| 3 | 6 | Web开发 |
| 5 | 7 | ps技术 |
操作: 查询父类对应的子类关系
| 父类 | 子类 |
|---|---|
| 信息技术 | 办公信息 |
| 软件开发 | 数据库 |
| 软件开发 | Web开发 |
| 美术设计 | ps技术 |
-- 创建表category[种类]
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', '软件开发'),
('4', '3', '数据库'),
('5', '1', '美术设计'),
('6', '3', 'Web开发'),
('7', '5', 'ps技术'),
('8', '2', '办公信息')
-- 查询父子信息: 把一张表看为两个一摸一样的表
SELECT c.categoryName AS '父类', ca.categoryName AS '子类'
FROM category AS c
INNER JOIN category AS ca
ON c.categoryid = ca.pid
-- 效果同上
SELECT c.categoryName AS '父类', ca.categoryName AS '子类'
FROM category AS c, category AS ca
WHERE c.categoryid = ca.pid
-- 查询科目所属年级 (科目名称, 年级名称)
SELECT subjectname AS 科目, gradename AS 年级
FROM `grade` AS g
INNER JOIN `subject` AS s
ON g.gradeid = s.gradeid
-- 查询了参加 数据库结构-1 考试的同学信息: 学号, 学生姓名, 科目名, 分数
SELECT a.studentno AS 学号, studentname AS 姓名, subjectname AS 科目名, studentresult AS 分数
FROM student AS a
INNER JOIN `subject` AS s
ON a.gradeid = s.gradeid
INNER JOIN result AS r
ON a.studentno = r.studentno
WHERE subjectname = 'Java程序设计-2'
4.5 分页和排序
排序
-- ================== 分页 limit 和排序 order by ================
-- 排序: 升序 ASC , 降序 DESC
-- ORDER BY 通过那个字段排序, 怎么排序
-- 查询的结果根据 成绩降序 排序
SELECT a.studentno AS 学号, studentname AS 姓名, subjectname AS 科目名, studentresult AS 分数
FROM student AS a
INNER JOIN `subject` AS s
ON a.gradeid = s.gradeid
INNER JOIN result AS r
ON a.studentno = r.studentno
WHERE subjectname = 'Java程序设计-2'
ORDER BY studentresult ASC
分页
-- 为什么要分页 ?
-- 缓解数据库压力, 给人的体验更好, 瀑布流 如百度查照片
-- 分页, 每页只显示5条数据
-- 语法: limit 起始值, 页面的大小 (数据个数)
-- 网页应用 : 当前, 总的页数, 页面的大小 (数据个数)
-- LIMIT 0, 3 1~3
-- LIMIT 3, 3 3~6
SELECT a.studentno AS 学号, studentname AS 姓名, subjectname AS 科目名, studentresult AS 分数
FROM student AS a
INNER JOIN `subject` AS s
ON a.gradeid = s.gradeid
INNER JOIN result AS r
ON a.studentno = r.studentno
WHERE subjectname = 'Java程序设计-2'
ORDER BY studentresult ASC
LIMIT 0,3
-- 第一页 limit 0, 3 (1-1) * 3
-- 第二页 limit 3, 3 (3-1) * 3
-- 第N页 limit X, 3 (N-1) * 3
-- [pagesize : 页面大小]
-- [(n-) * pagesize : 起始值]
-- [n : 当前页]
-- [数据总数/页面大小 = 页面数]
语法: limit(查询起始下标, pagesize)
4.6 子查询
where (这个值是计算出来的)
本质 : 在where语句中嵌套一个子查询语句
where (select *)
-- ===================== where ==========================
-- 1. 查询高等数学-4 的所有考试结果(学号, 科目编号, 成绩) , 降序排列
-- 方式一: 使用连接查询
SELECT r.`studentno` AS 学号, r.`subjectno` AS 科目编号, `studentresult` AS 成绩
FROM result AS r
INNER JOIN `subject` AS s
ON r.`subjectno` = s.`subjectno`
WHERE s.`subjectname` = '高等数学-4'
ORDER BY studentresult DESC
-- 方式二: 使用子查询()
SELECT `studentno` AS 学号, `subjectno` AS 科目编号, `studentresult` AS 成绩
FROM `result` AS r
WHERE r.subjectno = (
SELECT `gradeid`
FROM `subject`
WHERE subjectname = '高等数学-4'
)
ORDER BY studentresult DESC
-- ===================================================
-- 分数不小于80分的学生的学号和姓名
SELECT s.studentno, studentname
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno` = r.`studentno`
WHERE `studentresult` > 80
-- 1 在上面的基础上在查找一个科目 高等数学-4
SELECT s.studentno, studentname
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 `studentresult` > 80 AND `subjectname` = '高等数学-4'
-- 2 在这个基础上增加一个科目, 高等数学-2
-- 查询 高等数学-2 的编号
SELECT s.studentno, studentname
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno` = r.`studentno`
WHERE `studentresult` > 80 AND `subjectno` = (
SELECT `subjectno`
FROM `subject`
WHERE `subjectname` = '高等数学-2'
)
-- 再改造(有里及外)
SELECT studentno, studentname FROM student WHERE studentno IN (
SELECT studentno FROM result WHERE studentresult>80 AND subjectno = (
SELECT subjectno FROM `subject` WHERE subjectname = '高等数学-2'
)
)
-- 练习: 查询 C语言-1 前5名同学的成绩的信息 (学号, 姓名, 分数)
-- 使用子查询
4.7 分组和过滤
-- 查询不同课程的平均分，最高分，最低分，平均分大于80
-- 核心：根据不同的课程分组
SELECT subjectname,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 --通过什么字段来分组
4.8 select小结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t6seu1Jh-1617024798733)(C:\Users\86135\AppData\Roaming\Typora\typora-user-images\image-20210328102941074.png)]
5. MYSQL函数
网站 :https://dev.mysql.com/doc/refman/5.7/en/func-op-summary-ref.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('即使再小的帆也能远航') -- 字符串长度
SELECT CONCAT('我', '爱', '我家') -- 字符串拼接
SELECT INSERT('我爱编程hellowodr', 1, 2, '非常非常') -- 查询, 从 1某个 位置开始 2替换个数 '替换的字符串'
SELECT LOWER('KuangShen') -- 全转小写字母
SELECT UPPER('KuangShen') -- 全传大写字母
SELECT INSTR('KuangShen', 'h') -- 返回第一次出现的字符串的索引
SELECT REPLACE('狂神说坚持就一定成功', '坚持', '努力') -- 替换出现的 指定字符串
SELECT SUBSTR('狂神说坚持就一定成功', 7, 4) -- 返回指定的字符串 (源字符串, 截取的位置, 截取的长度)
SELECT REVERSE('狂神说坚持就一定成功') -- 反转
-- 查询姓 刘的同学, 改性 为小
SELECT REPLACE(studentname, '刘', '小') 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 SYSTEM_USER() -- 系统
SELECT USER() -- 系统
SELECT VERSION() -- 版本
5.2 聚合函数(常用)
| 函数名称 | 描述 |
|---|---|
| COUNT() | 计数 |
| SUM() | 求和 |
| AVG() | 平均值 |
| MAX() | 最大值 |
| MIN() | 最小值 |
| … | … |
-- =========== 聚合函数 ======================
-- 都能够统计 表中的数据 ( 想查询一个表中有多少个记录, 就使用这个count() )
SELECT COUNT(studentname) FROM student; -- cont(指定列)
SELECT COUNT(*) FROM student; -- count(*), 不会忽略 null 值, 本质 计算行数
SELECT COUNT(1) FROM result; -- count(1) , 不会忽略所有的 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 不可逆, 具体的值的 MD5 是一样的
MD5 破解网站的原理, 背景有一个字典, MD5加密后的值, 机密的前值
-- ============= MD5 加密测试 =================
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, '张三', '123456'), (2, '李四', '123456'),(3, '王五', '123456')
-- 加密
UPDATE testmd5 SET pwd=MD5(pwd) WHERE id=1
UPDATE testmd5 SET pwd=MD5(pwd) -- 加密全部密码
-- 插入的时候加密
INSERT INTO testmd5 VALUES(4, '六六', MD5('123456'))
-- 如何校验: 将用户传递进来的密码, 进行MD5加密, 然后对比加密后的值
SELECT * FROM testmd5 WHERE `name` = '六六' AND pwd=MD5('123456')
6. 事物
6.1 什么是事物
== 要么都成功, 要么都是失败
- SQl 执行 A 给 B 赚钱 A 1000 --> 200 B 200
- SQL执行 B 收到 A 的钱 A 800 -->B 400
将一组SQL放在一个批次中去执行~
事物原则: ACID 原则 原子性, 一致性, 隔离性, 持久性 (脏读, 幻读…)
原子性(Atomic)
- 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。
一致性(Consist)
- 一个事务可以封装状态改变（除非它是一个只读的）。事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。也就是说：如果事务是并发多个，系统也必须如同串行事务一样操作。其主要特征是保护性和不变性(Preserving an Invariant)，以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性。
隔离性(Isolated)
- 隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。
持久性(Durable)
- 在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
隔离所导致的一些问题
脏读:
指一个事务读取了另外一个事物未提交的数据.
不可重复读:
在一个事物读取表中的某一行数据, 多次读取结果不同. (这个不一定是错误的, 只是某些场合不对)
幻读(虚读)
是指在一个事务内读取到了别的食物插入的数据, 导致前后读取不一致.
基本语法
-- 使用set语句来改变自动提交模式
SET autocommit = 0; /*关闭*/
SET autocommit = 1; /*开启*/
-- 注意:
--- 1.MySQL中默认是自动提交
--- 2.使用事务时应先关闭自动提交
-- 开始一个事务,标记事务的起始点
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. 索引
7.1 索引的分类
索引的作用
- 提高查询速度
- 确保数据的唯一性
- 可以加速表和表之间的连接 , 实现表与表之间的参照完整性
- 使用分组和排序子句进行数据检索时 , 可以显著减少分组和排序的时间
- 全文检索字段进行搜索优化.
分类
- 主键索引 (Primary Key)
- 唯一索引 (Unique)
- 常规索引 (Index)
- 全文索引 (FullText)
主键索引
主键 : 某一个属性组能唯一标识一条记录
特点 :
- 最常见的索引类型
- 确保数据记录的唯一性
- 确定特定数据记录在数据库中的位置
唯一索引
作用 : 避免同一个表中某数据列中的值重复
与主键索引的区别
- 主键索引只能有一个
- 唯一索引可能有多个
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 版本、存储引擎和数据类型是否支持全文索引。
7.2 测试索引
拓展：测试索引
建表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 ON UPDATE 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), '[email protected]', 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
filtered: 10.00
Extra: Using where
1 row in set, 1 warning (0.00 sec)
创建索引
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.00 sec)
mysql> SELECT * FROM app_user WHERE name = '用户9999';
1 row in set (0.00 sec)
mysql> SELECT * FROM app_user WHERE name = '用户9999';
1 row in set (0.00 sec)
未使用索引：
使用索引：在大数据情况，使用索引速度优势很明显
7.3 索引准则
索引准则
- 索引不是越多越好
- 不要对经常变动的数据加索引
- 小数据量的表建议不要加索引
- 索引一般应加在查找条件的字段
索引的数据结构
-- 我们可以在创建上述索引的时候，为其指定索引类型，分两类
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 等索引；
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（Java DataBase Connectivity）
链接