MySQL

一、什么是数据库

1. 数据库：（DB，DataBase）
2. 概念：数据仓库，安装在操作系统之上（windows，linux，mac...）之上
3. 作用：储存数据，管理数据

二、数据库的分类

关系型数据库：MySQL，Oracle，Sql Server，DB2，SQLlite

非关系型数据库：对象存储，通过对象的自身属性来决定

NoSQL（not only）不仅仅是SQL

DBMS（数据库管理系统）

• 数据库的管理软件，科学有效的管理，维护和获取数据
• MySQL 是数据库的管理系统
• MySQL的定义：

1. MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。
2. MySQL是一种关系型数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
3. MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择 MySQL 作为网站数据库。

• MySQL官网：https://www.mysql.com/
• MySQL超详细教学：https://www.bilibili.com/video/BV1NJ411J79W?p=3&spm_id_from=pageDriver

★数据库的操作

一、数据库的连接

打开cmd控制命令，以管理员的身份运行，输入：

mysql -uroot -p 
123456  -- 连接数据库

update user set password=password('123456')where user='root'; 修改密码

flush privileges;  刷新数据库

show databases; 显示所有数据库

use dbname；打开某个数据库

show tables; 显示数据库mysql中所有的表

describe user; 显示表mysql数据库中user表的列信息

create database name; 创建数据库

use databasename; 选择数据库
 
exit; 退出Mysql
? 命令关键词 : 寻求帮助
-- 表示注释（SQL本来的注释）
/*SQL的多行注释*/

二、操作数据库

操作数据库->操作数据库中的表->操作数据库中表的数据

1. 操作数据库

Ⅰ.创建数据库

CREATE DATABASE  [IF NOT EXISTS] westos	[]代表可选的！！！

Ⅱ.删除数据库

DROP DATABASE [IF EXISTS] westos

Ⅲ.使用数据库

USE school

Ⅳ.查看数据库

SHOW DATABASE 

2. 操作数据库中的表

3. 操作数据库中表的数据

三、数据库的列类型

数值

• tinyint 十分小的数据 1个字节
• smallint 较小的数据 2个字节
• int 标准的整数 4个字节
• bigint 较大的数据 8个字节
• float 浮点数 4个字节
• double 浮点数 8个字节
• decimal 字符串形式的浮点数，金融计算的时候用

字符串

• char 字符串固定的大小 0~255
• varchar 可变字符串 0~65525 常用的变量 String
• tinytext 微型文本 2^8-1
• text 文本串 2^16-1 保存大型文本

时间日期

• date YYYY-MM-DD，日期格式
• time HH；mm；ss，时间格式
• year 年份表示
• datatime YYYY-MM-DD HH；mm；ss 最常用的时间格式
• timestamp 时间戳 1971.1.1到现在的毫秒数

null

• 没有值
• 注意，不能用null进行计算，结果仍为null

四、数据库的字段属性

UnSigned

• 无符号的整数

• 声明该数据列不允许负数 .

ZEROFILL

• 0填充的

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

Auto_InCrement（自增）

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

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

• 可定义起始值和步长

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

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

NULL 和 NOT NULL

• 默认为NULL , 即没有插入该列的数值
• 如果设置为NOT NULL , 则该列必须有值
  DEFAULT
• 默认的
• 用于设置默认值
• 例如,性别字段,默认为"男" , 否则为 "女" ; 若无指定该列的值 , 则默认值为"男"的值

InnoDB与charset是建立一个表的基本操作

ENGINE=InnoDB不是默认就是这个引擎吗？
——是的，如果不写也是ok,就会走默认的，在这里写上是因为可以很清楚的看到这个建表语句用了哪些，而且在创建表的时候，写上也是一个很好的习惯

utf8不是已经在my.ini里设置过了?
——这个虽然在my.ini设置过了，但设置的是mysql的的语言编码，而这里创建的时候不设置，就会出现乱码问题，二者的作用域是不一样的，在创建表单的时候，这个charset会作用到这个表上，他代表mysql建立数据库数据表时设定字符集为utf-8

每一个表都必须存在以下5个字段！

1. id主键
2. version 乐观锁
3. is_delete 伪删除
4. gmt_create 创建时间
5. gmt_update 修改时间

五、创建数据库的表

CREATE TABLE IF NOT EXISTS `student` (
  `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
  `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME DEFAULT NULL COMMENT '生日',
  `address` VARCHAR(100) DEFAULT NULL COMMENT '地址',
  `email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

1. 格式

CREATE TABLE [IF NOT EXISTS] `表名`(
'字段名'	列类型		[属性]	[索引]	[注释],
'字段名'	列类型		[属性]	[索引]	[注释],
...
'字段名'	列类型		[属性]	[索引]	[注释]
)[表类型][字符集设置][注释] 

2. 常用命令

-- 查看数据库的定义
SHOW CREATE DATABASE school;
-- 查看student数据表的定义语句
SHOW CREATE TABLE student;
-- 显示表结构
DESC student;  -- 显示表的结构

3.数据表的类型

4. 适用场合 :

• 适用 MyISAM : 节约空间及相应速度

• 适用 InnoDB : 安全性 , 事务处理及多用户操作数据表

5. 在物理空间存在的位置
   ** 在所有的数据库文件都存在data目录下 **
   MySQL引擎在物理文件上的区别

• InnoDB在数据库表中只有一个*.frm文件，以及上级目录下的ibdata1文件
  MYISAM对应文件
• *.frm 表结构的定义文件
• *MYD 数据文件（data）
• *MYI 索引文件

设置数据库表的字符集编码

CHARSET = utf8;

不设置的话，会是mysql默认的字符集编码~（不支持中文！！！）

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

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

六、修改删除表

修改( ALTER TABLE )

修改表名 :ALTER TABLE （旧表名） RENAME AS （新表名）

ALTER TABLE teacher RENAME AS teacher1

添加字段 : ALTER TABLE （表名） ADD（字段名） 列属性[属性]

ALTER TABLE teacher ADD age INT(11)

修改字段 :ALTER TABLE （表名） MODIFY （字段名）列类型[属性] (修改约束)

ALTER TABLE teacher1 MODIFY age varchar(11)

ALTER TABLE （表名） CHANGE （旧字段名）（ 新字段名） 列属性[属性]

ALTER TABLE teacher1 CHANGE age agel INT(1)

删除字段 : ALTER TABLE 表名 DROP 字段名

 ALTER TABLE teacher1  DROP age1

删除
语法：DROP TABLE [IF EXISTS] 表名

DROP TABLE IF EXISTS teacher1

• IF EXISTS为可选 , 判断是否存在该数据表

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

★MySQL数据管理

一、外键

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

   在实际操作中，将一个表的值放入第二个表来表示关联，所使用的值是第一个表的主键值(在必要时可包括复合主键值)。此时，第二个表中保存这些值的属性称为外键(foreign key)。

2. 外键作用：
   保持数据一致性，完整性，主要目的是控制存储在外键表中的数据,约束。使两张表形成关联，外键只能引用外表中的列的值或使用空值。

3. 创建表时指定的外键约束
   删除有外键关系的表的时候，必须先删除引用别人的表，再删除主表

-- 创建外键的方式一 : 创建子表同时创建外键
 
-- 年级表 (id\年级名称)
CREATE TABLE `grade` (
  `gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级ID',
  `gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
  PRIMARY KEY (`gradeid`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

CREATE TABLE IF NOT EXISTS `student` (
  `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
  `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME DEFAULT NULL COMMENT '生日',
  `address` VARCHAR(100) DEFAULT NULL COMMENT '地址',
  `email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`),
  KEY `FK_gradeid` (`gradeid`),
  CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

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

二、DML语言

数据库意义 ： 数据存储、数据管理

管理数据库数据方法：

• 通过SQLyog等管理工具管理数据库数据

• 通过DML语句管理数据库数据

DML语言 ：数据操作语言

• 用于操作数据库对象中所包含的数据

• 包括 :

1. INSERT (添加数据语句)

INSERT命令

语法：

INSERT INTO 表名[(字段1,字段2,字段3,...)] VALUES('值1','值2','值3')

-- 使用语句如何增加语句?
-- 语法 : 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 ('大三'),('大四');

注意 :

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

2. UPDATE (更新数据语句)

UPDATE命令
语法：

UPDATE `表名` SET `column_name`=value [,column_name2=value2,...] [WHERE `condition`];

UPDATE `a` SET `id`='远辉'  WHERE id = 1;

注意 :

• column_name 为要更改的数据列

• value 为修改后的数据 , 可以为变量 , 具体指 , 表达式或者嵌套的SELECT结果

  UPDATE `student` SET `name` = '长江七号' WHERE `name`= '远辉' AND sex='女' 
  

• condition 为筛选条件 , 如不指定则修改该表的所有列数据

where条件子句 运算符id 等于某个值，大于某个值，在某个区间内修改

3. DELETE (删除数据语句)

 >DELETE命令

语法：

DELETE FROM 表名 [WHERE condition];

删除数据（避免这样写，会全部删除）
DELETE FROM 'student';

删除指定数据（删除指定数据）
DELETE FROM 'student'  WHERE  id = 1;

注意 :

• condition为筛选条件 , 如不指定则删除该表的所有列数据

TRUNCATE命令

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

TRUNCATE [TABLE] table_name;
 
-- 清空年级表
TRUNCATE grade

注意 :区别于DELETE命令

• 相同 : 都能删除数据 , 不删除表结构 , 但TRUNCATE速度更快
• 不同 :

使用TRUNCATE TABLE 重新设置AUTO_INCREMENT计数器

使用TRUNCATE TABLE不会对事务有影响 （事务后面会说）

测试

-- 创建一个测试表
CREATE TABLE `test` (
  `id` INT(4) NOT NULL AUTO_INCREMENT,
  `coll` VARCHAR(20) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8



-- 插入几个测试数据
INSERT INTO `test`(`coll`) VALUES('1'),('2'),('3');
 
-- 删除表数据(不会影响自增)
DELETE FROM `test`;
-- 结论:如不指定Where则删除该表的所有列数据,自增当前值依然从原来基础上进行,会记录日志.
 
-- 删除表数据(truncate)
TRUNCATE TABLE `test`;
-- 结论:truncate删除数据,自增当前值会恢复到初始值重新开始;不会记录日志.
 
-- 同样使用DELETE清空不同引擎的数据库表数据.重启数据库服务后
-- InnoDB : 自增列从初始值重新开始 (因为是存储在内存中,断电即失)
-- MyISAM : 自增列依然从上一个自增数据基础上开始 (存在文件中,不会丢失)

★★★DQL查询数据（重点）

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

• 查询数据库数据 , 如SELECT语句

• 简单的单表查询或多表的复杂查询和嵌套查询

• 是数据库语言中最核心,最重要的语句

• 使用频率最高的语句

测试数据：

CREATE DATABASE IF NOT EXISTS `school01`;
-- 创建一个school数据库
USE `school01`;-- 创建学生表
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 `grade01`;
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 `subject01`;
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 `result01`;
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;

-- 插入学生数据 其余自行添加 这里只添加了2行
INSERT INTO `student` (`studentno`,`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)
VALUES
(1000,'123456','张伟',0,2,'13800001234','北京朝阳','1980-1-1','text123@qq.com','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','text111@qq.com','123456199001011233');

-- 插入成绩数据  这里仅插入了一组，其余自行添加
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,'预科班');

-- 插入科目数据
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);

Ⅰ.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 student;
 
-- 查询指定列(学号 , 姓名)
SELECT studentno,studentname FROM student;

AS 子句作为别名

作用

1. 可给数据列取一个新别名

2. 可给表取一个新别名

3. 可把经计算或总结的结果用另一个新名称来代替

-- 这里是为列取别名(当然as关键词可以省略)
SELECT studentno AS 学号,studentname AS 姓名 FROM student;
 
-- 使用as也可以为表取别名
SELECT studentno AS 学号,studentname AS 姓名 FROM student AS s;
 
-- 使用as,为查询结果取一个新名字
-- CONCAT()函数拼接字符串
SELECT CONCAT('姓名:',studentname) AS 新姓名 FROM student;

Ⅱ.去重(DISTINCT)

DISTINCT关键字的使用

SELECT * FROM SUBJECT; -- 查看考试成绩
SELECT `subjectno` FROM SUBJECT; --  查看哪些同学参加了考试
SELECT DISTINCT `subjectno` FROM SUBJECT; -- 了解:DISTINCT 去除重复项 , (默认是ALL)

SELECT * FROM SUBJECT; -- 查看考试成绩
SELECT `subjectno` FROM SUBJECT; --  查看哪些同学参加了考试
SELECT DISTINCT `subjectno` FROM SUBJECT; -- 了解:DISTINCT 去除重复项 , (默认是ALL)


SELECT VERSION(); -- 查询版本号
SELECT 100*3-1 AS 计算结果; -- 表达式
SELECT @@auto_increment_increment; -- 查询自增步长

-- 学员考试成绩集体提分一分查看
SELECT `subjectno` ,gradeid+1 AS '提分后' FROM SUBJECT;

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

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

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

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

Ⅲ.where条件语句

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

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

逻辑操作符

-- 满足条件的查询(where)
SELECT `subjectno`,gradeid FROM SUBJECT;
 
-- 查询考试成绩在1-3之间的
SELECT `subjectno`,gradeid
FROM SUBJECT
WHERE gradeid>=1 AND gradeid<=3;
 
-- AND也可以写成 &&
SELECT `subjectno`,gradeid
FROM SUBJECT
WHERE gradeid>=1 && gradeid<=3;
 
-- 模糊查询(对应的词:精确查询)
SELECT `subjectno`,gradeid
FROM SUBJECT
WHERE gradeid BETWEEN 1 AND 4;
 
-- 除了1号同学,要其他同学的成绩
SELECT `subjectno`,gradeid
FROM SUBJECT
WHERE `subjectno`!=1;
 
-- 使用NOT
SELECT `subjectno`,gradeid
FROM SUBJECT
WHERE NOT `subjectno`=1;

注：（where与on的区别）

在多表查询时，on和where都表示筛选条件，on先执行，where后执行。
区别：
外连接时，on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。而where条件是在临时表生成好后，再对临时表进行过滤的条件。

where与on之间的区别：

• 1）on后面的是连接（join）条件，代表两个表建立关系所遵循的规则
• 2）where后面的可以看作是筛选条件，是对最终结果集进行过滤所遵循的规则

思考：在连接（join）两个表时可以不可以使用where字句呢？

答案是肯定的，在连接（join）两个表时确实可以使用where字句，但是我们为什么要使用on呢？
因为当两张表的数据量比较大，又需要连接查询时，应该使用FROM table1 JOIN table2 ON xxx的语法，避免使用FROM table1,table2 WHERE xxx的语法，因为后者会在内存中先生成一张数据量比较大的笛卡尔积表，增加了内存的开销。

Ⅳ.模糊查询：比较操作符(between and \ like \ in \ null)

** 注意： **

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

• 相同数据类型的数据之间才能进行比较 ;

-- 模糊查询 between and \ like \ in \ null
 
-- =============================================
-- LIKE
-- =============================================
-- 查询姓刘的同学的学号及姓名
-- like结合使用的通配符 : % (代表0到任意个字符)  _ (一个字符)
SELECT `studentno`,`studentname` FROM student
WHERE studentname LIKE '张%';
 
-- 查询姓张的同学,后面只有一个字的
SELECT studentno,studentname FROM student
WHERE studentname LIKE '张_';
 
-- 查询姓张的同学,后面只有两个字的
SELECT studentno,studentname FROM student
WHERE studentname LIKE '张__';

-- 查询姓名中含有 赵 字的
SELECT studentno,studentname FROM student
WHERE studentname LIKE '%赵%';
 
-- 查询姓名中含有特殊字符的需要使用转义符号 '\'
-- 自定义转义符关键字:  ESCAPE ':'
-- =============================================
-- IN
-- =============================================
-- 查询学号为1000,1001,1002的学生姓名
SELECT studentno,studentname FROM student
WHERE studentno IN (1000,1001);
-- 查询地址在北京,南京,河南洛阳的学生
SELECT studentno,studentname,address FROM student
WHERE address IN ('北京');
-- =============================================
-- NULL 空
-- =============================================
-- 查询出生日期没有填写的同学
-- 不能直接写=NULL , 这是代表错误的 , 用 is null
SELECT studentname FROM student
WHERE BornDate IS NULL;
-- 查询出生日期填写的同学
SELECT studentname FROM student
WHERE BornDate IS NOT NULL;
-- 查询没有写家庭住址的同学(空字符串不等于null)
SELECT studentname FROM student
WHERE Address='' OR Address IS NULL;

Ⅴ.★★联表查询(JOIN)

JOIN 对比

-- 查询参加了考试的同学信息(学号,学生姓名,科目编号,分数)
SELECT * FROM student;
SELECT * FROM result;

/*思路:
(1):分析需求,确定查询的列来源于两个类,student  result,连接查询
(2):确定使用哪种连接查询?(内连接)
*/
SELECT s.studentno,studentname,subjectno,grade
FROM student s
INNER JOIN grade r
ON r.studentno = s.studentno

-- 右连接(也可实现)
SELECT s.studentno,studentname,subjectno,grade
FROM student s
RIGHT JOIN grade r
ON r.studentno = s.studentno

-- 等值连接
SELECT s.studentno,studentname,subjectno,grade
FROM student s , grade r
WHERE r.studentno = s.studentno

-- 左连接 (查询了所有同学,不考试的也会查出来)
SELECT s.studentno,studentname,subjectno,grade
FROM student s
LEFT JOIN grade r
ON r.studentno = s.studentno

-- 查一下缺考的同学(左连接应用场景)
SELECT s.studentno,studentname,subjectno,grade
FROM student s
LEFT JOIN grade r
ON r.studentno = s.studentno
WHERE StudentResult IS NULL

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

1. 连接查询

如需要多张数据表的数据进行查询,则可通过连接运算符实现多个查询

2. 内连接 inner join

查询两个表中的结果集中的交集

3. 外连接 outer join
   左外连接 left join
   (以左表作为基准,右边表来一一匹配,匹配不上的,返回左表的记录,右表以NULL填充)
   右外连接 right join
   (以右表作为基准,左边表来一一匹配,匹配不上的,返回右表的记录,左表以NULL填充)

Ⅵ.★★自连接

自连接的定义：
自连接
数据表与自身进行连接
需求:从一个包含栏目ID , 栏目名称和父栏目ID的表中
查询父栏目名称和其他子栏目名称

子类

操作：查询父类对应的子类关系

-- 编写SQL语句,将栏目的父子关系呈现出来 (父栏目名称,子栏目名称)
-- 核心思想:把一张表看成两张一模一样的表,然后将这两张表连接查询(自连接)
SELECT a.categoryName AS '父栏目',b.categoryName AS '子栏目'
FROM category AS a,category AS b
WHERE a.`categoryid`=b.`pid`
  
-- 查询学员及所属的年级(学号,学生姓名,年级名)
SELECT studentno AS 学号,studentname AS 学生姓名,gradename AS 年级名称
FROM student s
INNER JOIN grade g
ON s.`GradeId` = g.`GradeID`
 
-- 查询科目及所属的年级(科目名称,年级名称)
SELECT subjectname AS 科目名称,gradename AS 年级名称
FROM SUBJECT sub
INNER JOIN grade g
ON sub.gradeid = g.gradeid
 
-- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩)
SELECT s.`studentno`,`studentname`,`subjectname`,`gradeid`
FROM student s
INNER JOIN `gradeid` s
ON s.studentno = s.studentno
INNER JOIN `subject` sub 
ON s.subjectno = sub.subjectno
WHERE subjectname='数据库结构-1'

Ⅶ.分页和排序( ORDER BY && LIMIT )

排序：
语法 : ORDER BY
ORDER BY 语句用于根据指定的列对结果集进行排序。
ORDER BY 语句默认按照ASC升序对记录进行排序。
如果您希望按照降序对记录进行排序，可以使用 DESC 关键字。

-- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩)
-- 按成绩降序排序

SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
WHERE subjectname='数据库结构-1'
ORDER BY StudentResult DESC

分页：
语法 : SELECT * FROM table LIMIT [offset,] rows | rows OFFSET offset
好处 : (用户体验,网络传输,缓解查询压力)
推导:
第一页 : limit 0,5（1~5）[limit 起始值， 页面的大小]
第二页 : limit 5,5
第三页 : limit 10,5
......
第N页 : limit (pageNo-1) * pageSzie, pageSzie
[pageNo:页码,pageSize:单页面显示条数]

[pageSize：页面大小，（n-1）* pageSize起始值，n 当前页]

-- 每页显示5条数据
SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
WHERE subjectname='数据库结构-1'
ORDER BY StudentResult DESC , studentno
LIMIT 0,5
 
-- 查询 JAVA第一学年 课程成绩前10名并且分数大于80的学生信息(学号,姓名,课程名,分数)
SELECT s.studentno,studentname,subjectname,StudentResult
FROM student s
INNER JOIN result r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON r.subjectno = sub.subjectno
WHERE subjectname='JAVA第一学年'
ORDER BY StudentResult DESC
LIMIT 0,10

练习：

-- 查询 数据库结构-1 的所有考试结果(学号 学生姓名 科目名称 成绩)
-- 按成绩降序排序
SELECT s.`studentno`,`studentname`,`subjectname`,`StudentResult`
FROM `student` s
INNER JOIN `result` r
ON r.studentno = s.studentno
INNER JOIN `subject` sub
ON r.`subjectno` = sub.`subjectno`
WHERE subjectname='数据库结构-1'
ORDER BY StudentResult DESC

Ⅷ.子查询和嵌套查询(where (select*from))

定义：

1. 在查询语句中的WHERE条件子句中,又嵌套了另一个查询语句

2. 嵌套查询可由多个子查询组成,求解的方式是由里及外;

3. 子查询返回的结果一般都是集合,故而建议使用IN关键字;

eg：

where (select*from)

-- ====================子查询======================

-- 查询 数据库结构-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 DISTINCT 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'
    )
)

Ⅺ.分组和过滤(group by/having)

 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.MYSQL常用函数（不会的去官网查）

• 数据函数

 SELECT ABS(-8);  /*绝对值*/
 
 SELECT CEILING(9.4); /*向上取整*/
 
 SELECT FLOOR(9.4);   /*向下取整*/
 
 SELECT RAND();  /*随机数,返回一个0-1之间的随机数*/
 
 SELECT SIGN(0); /*符号函数: 负数返回-1,正数返回1,0返回0*/

• 字符串函数

   SELECT CHAR_LENGTH('坚持就能成功'); /*返回字符串包含的字符数*/
   
   SELECT CONCAT('我','爱','程序');  /*合并字符串,参数可以有多个*/
   
   SELECT INSERT('我爱编程helloworld',1,2,'超级热爱');  /*替换字符串,从某个位置开始替换某个长度*/
   
   SELECT LOWER('KuangShen'); /*小写*/
   
   SELECT UPPER('KuangShen'); /*大写*/
   
   SELECT LEFT('hello,world',5);   /*从左边截取*/
   
   SELECT RIGHT('hello,world',5);  /*从右边截取*/
   
   SELECT REPLACE('狂神说坚持就能成功','坚持','努力');  /*替换字符串*/
   
   SELECT SUBSTR('狂神说坚持就能成功',4,6); /*截取字符串,开始和长度*/
   
   SELECT REVERSE('狂神说坚持就能成功'); /*反转
   
   -- 查询姓周的同学,改成邹
   SELECT REPLACE(studentname,'周','邹') AS 新名字
   FROM student WHERE studentname LIKE '周%';
  

• 日期和时间函数

   SELECT CURRENT_DATE();   /*获取当前日期*/
   SELECT CURDATE();   /*获取当前日期*/
   SELECT NOW();   /*获取当前日期和时间*/
   SELECT LOCALTIME();   /*获取当前日期和时间*/
   SELECT SYSDATE();   /*获取当前日期和时间*/
   
   -- 获取年月日,时分秒
   SELECT YEAR(NOW());
   SELECT MONTH(NOW());
   SELECT DAY(NOW());
   SELECT HOUR(NOW());
   SELECT MINUTE(NOW());
   SELECT SECOND(NOW());
  

• 系统信息函数

   SELECT VERSION();  /*版本*/
   SELECT USER();     /*用户*/
  

5.MYSQL聚合函数

-- =============================聚合函数==============================
 /*COUNT(指定列)*/
 SELECT COUNT(studentname) FROM student;
 SELECT COUNT(*) FROM student;
 SELECT COUNT(1) FROM student;  /*推荐*/

从含义上讲，count(1) 与 count(*) 都表示对全部数据行的查询。

1. count(字段) 会统计该字段在表中出现的次数，忽略字段为null 的情况。即不统计字段为null 的记录。
2. count(*) 包括了所有的列，相当于行数，在统计结果的时候，包含字段为null 的记录；
3. count(1) 用1代表代码行，在统计结果的时候，包含字段为null 的记录 。

• 很多人认为count(1)执行的效率会比count()高，原因是count()会存在全表扫描，而count(1)可以针对一个字段进行查询。其实不然，count(1)和count(*)都会对全表进行扫描，统计所有记录的条数，包括那些为null的记录，因此，它们的效率可以说是相差无几。而count(字段)则与前两者不同，它会统计该字段不为null的记录条数。

下面它们之间的一些对比：

1）在表没有主键时，count(1)比count()快
2）有主键时，主键作为计算条件，count(主键)效率最高；
3）若表格只有一个字段，则count()效率较高。

6.MD5 加密

什么是MD5？

MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的[密码散列函数]，可以产生出一个128位（16[字节]的散列值（hash value），用于确保信息传输完整一致。

新建一个表：

 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,'zhangsan','123456'),(2,'lisi','1234567'),(3,'wanger','12345678')

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

-- 加密全部
UPDATE testmd5 SET pwd=MD5(pwd) 

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

-- 加密
UPDATE testmd5 SET pwd=MD5(pwd) WHERE id  = 1

插入新的数据自动加密：

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

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

-- 查验密码
 SELECT * FROM testmd5 WHERE `name`='lisi' AND pwd=MD5('1234567');

7.select小结

 -- ================ 内置函数 ================
 -- 数值函数
 ABS(x)            -- 绝对值 ABS(-10.9) = 10
 FORMAT(x, d)    -- 格式化千分位数值 FORMAT(1234567.456, 2) = 1,234,567.46
 CEILING(x)            -- 向上取整 CEILING(10.1) = 11
 FLOOR(x)        -- 向下取整 FLOOR (10.1) = 10
 ROUND(x)        -- 四舍五入去整
 MOD(m, n)        -- m%n m MOD n 求余 10%3=1
 PI()            -- 获得圆周率
 POM(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();

★MySQL事务和索引

一、事物的定义：

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

要么都成功执行，要么都失败执行

二、事物的原则

ACID原则（四大原则）

原子性(Atomic)

• 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

一致性(Consist)

• 一个事务可以封装状态改变（除非它是一个只读的）。事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。也就是说：如果事务是并发多个，系统也必须如同串行事务一样操作。其主要特征是保护性和不变性(Preserving an Invariant)，以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性。 事务前后数据的完整性必须保持一致。

隔离性(Isolated)

• 隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。

持久性(Durable)

• 在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

三、事务的隔离级别

1. 脏读

2. 不可重复读

3. 虚读（幻读）

-- ====================事物=======================
-- 使用set语句来改变自动提交模式
SET autocommit = 0;   /*关闭*/
SET autocommit = 1;   /*开启(默认的)*/
 
-- 注意:
---  1.MySQL中默认是自动提交
---  2.使用事务时应先关闭自动提交


-- 框架
SET autocommit = 0; -- 先关闭自动提交

-- 开始一个事务,标记事务的起始点，从此之后的sql都在同一个事物内
START TRANSACTION  
 
-- 提交一个事务给数据库
COMMIT
 
-- 将事务回滚,数据回到本次事务的初始状态
ROLLBACK
 
-- 开启MySQL数据库的自动提交
SET autocommit =1;
 
-- 保存点
SAVEPOINT 保存点名称 -- 设置一个事务保存点
ROLLBACK TO SAVEPOINT 保存点名称 -- 回滚到保存点
RELEASE SAVEPOINT 保存点名称 -- 删除保存点

模拟场景：（事物一旦执行便会不可逆）

-- 转账模拟实战
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci

CREATE TABLE `account01`(
	`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 account01(`name`,`money`)
VALUES ('A',2000.00),('B',10000.00)

-- 模拟转账
SET autocommit = 0;-- 关闭自动提交

START TRANSACTION  -- 开始一个事务,标记事务的起始点，从此之后的sql都在同一个事物内

UPDATE account01 SET money = money-500 WHERE `name`='A'-- A少500
UPDATE account01 SET money = money+500 WHERE `name`='B'-- B多500

-- 提交一个事务给数据库
COMMIT

-- 将事务回滚,数据回到本次事务的初始状态
ROLLBACK
 
-- 开启MySQL数据库的自动提交
SET autocommit =1;

四、索引

1. 索引的定义：

官方介绍索引是帮助MySQL高效获取数据的数据结构。更通俗的说，数据库索引好比是一本书前面的目录，能加快数据库的查询速度。

2. 索引的优势和劣势：

优势：

• 可以提高数据检索的效率，降低数据库的IO成本，类似于书的目录。

• 通过索引列对数据进行排序，降低数据排序的成本，降低了CPU的消耗。

• 被索引的列会自动进行排序，包括【单列索引】和【组合索引】，只是组合索引的排序要复杂一些。
  如果按照索引列的顺序进行排序，对应order by语句来说，效率就会提高很多。

劣势：

• 索引会占据磁盘空间

• 索引虽然会提高查询效率，但是会降低更新表的效率。比如每次对表进行增删改操作，MySQL不仅要保存数据，还有保存或者更新对应的索引文件。

3.索引的分类

• 主键索引(Primary Key)
  • 唯一的标识，逐渐不能重复，只能有一个列作为主键
• 唯一索引 (Unique)
  • 避免重复的列出现，唯一索引可以重复，多个列都可以标识，唯一索引可以有多个
• 常规索引 (Index)
  • 默认的，index，key关键字
• 全文索引 (FullText)
  • 在特定的数据库引擎下才有，MyISAM
  • 快速定位数据

-- ==============索引的使用=============
-- 1.在建表的时候给字段增加索引
-- 2.创建完毕后，增加索引


-- 显示所有索引的信息
SHOW INDEX FROM student

-- 增加一个全文索引
ALTER TABLE school01.`student`  ADD FULLTEXT INDEX `studentname`(`studentname`);

-- EXPLAIN 分析sql执行的状况
EXPLAIN  SELECT * FROM student;-- 非全文索引
 
EXPLAIN SELECT * FROM student WHERE MATCH (studentname) AGAINST('张');

-- 增加一个全文索引
ALTER TABLE school01.`student`  ADD FULLTEXT INDEX `studentname`(`studentname`);

执行如下代码的结果：EXPLAIN SELECT * FROM student WHERE MATCH (studentname) AGAINST('张');

4. 测试索引

-- 添加索引
-- id_表名_字段名
-- CREATE INDEX　索引名
CREATE INDEX id_app_user_name ON app_user(`name`);

创建索引之后再执行以下代码：

可以减少查询时间，本质：索引创建了一个B树，重新排列了所给的数据

5.索引的使用原则

• 索引不是越多越好
• 不要对进程变动的数据加索引
• 小数据量的表不需要加索引
• 索引一般加在常用来查询的字段上

索引背后的参考文献：CodingLabs - MySQL索引背后的数据结构及算法原理

6.索引的数据结构

• 我们可以在创建上述索引的时候，为其指定索引类型，分两类

1. hash类型的索引：查询单条快，范围查询慢

2. 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 等索引；

★MySQL权限管理

一、用户管理

SQL可视化管理

注意选择的用户是什么就怎么登录

二、基本命令

用户信息表：mysql.user

本质：对mysql中的这张表进行增删改查

用户信息表：mysql.user

-- 刷新权限
FLUSH PRIVILEGES

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

-- ================权限================
-- 创建用户
CREATE USER yuanhui IDENTIFIED BY'123456'

-- 修改密码（修改当前用户名的密码）
SET PASSWORD = PASSWORD('123456')

-- 修改密码（修改指定用户名的密码）
SET PASSWORD FOR yuanhui = PASSWORD('123456')


-- 重命名用户  
RENAME USER yuanhui TO yuanhui2

-- 用户授权  ALL PRIVILEGES 全部的权限，库，表
-- ALL PRIVILEGES  除了给别人授权，其他的都可以
GRANT ALL PRIVILEGES ON *.* TO yuanhui2

-- 查询权限
SHOW GRANTS FOR yuanhui2 -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost

-- 撤销权限 REVOKE
REVOKE ALL PRIVILEGES ON *.* FROM yuanhui2

-- 删除用户
DROP USER yuanhui2

三、权限的解释

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

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

★MySQL规范化数据库设计

一、为什么需要数据库设计

当数据库比较复杂时我们需要设计数据库

糟糕的数据库设计 :

• 数据冗余,存储空间浪费
• 数据更新和插入的异常
• 程序性能差

良好的数据库设计 :

• 节省数据的存储空间

• 能够保证数据的完整性

• 方便进行数据库应用系统的开发

软件项目开发周期中数据库设计 :

• 需求分析阶段: 分析客户的业务和数据处理需求

• 概要设计阶段:设计数据库的E-R模型图 , 确认需求信息的正确和完整.

设计数据库步骤

• 收集信息

• 与该系统有关人员进行交流 , 座谈 , 充分了解用户需求 , 理解数据库需要完成的任务.

• 标识实体[Entity]

• 标识数据库要管理的关键对象或实体,实体一般是名词

• 标识每个实体需要存储的详细信息[Attribute]

• 标识实体之间的关系[Relationship]

本质上是：把html中不同的分块（不同的导航栏box）都用数据库可视化储存

二、三大范式

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

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

• 信息重复

• 更新异常

• 插入异常

  • 无法正确表示信息

• 删除异常

  • 丢失有效信息

• 第一范式 (1st NF)

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

上图不满足第一范式的要求，下图则满足

• 第二范式(2nd NF)

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

  第二范式要求每个表只描述一件事情，不相干的事情不要写入表内

• 第三范式(3rd NF)

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

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

​ eg：比如Student表（学号，姓名，年龄，性别，所在院校，院校地址，院校电话）这样一个表结构，就存在 上述关系。 学号--> 所在院校 --> (院校地址，院校电话)。我们应该拆开来，如下：

​ （学号，姓名，年龄，性别，所在院校）--（所在院校，院校地址，院校电话）

• 规范化和性能的关系

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

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

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

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

★JDBC

一、数据库的驱动

程序会根据 数据库 驱动，和数据库打交道

二、JDBC

1. 什么是JDBC？

   　　### JDBC（JavaDataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。原来我们操作数据库是在控制台使用SQL语句来操作数据库，JDBC是用Java语言向数据库发送SQL语句。

2. 

三、第一个JDBC项目

-- ================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')

1. 创建一个普通项目
2. 导入数据库驱动

导入数据的步骤

1. 加载驱动

2. 连接到数据库DriverManager

3. 获得执行sql的对象 Statement

4. 获得返回的结果集

5. 释放连接

   package com.Ji.lesson01;
   
   import java.sql.*;
   
   public class JDBCFirstDemo {
       public static void main(String[] args) throws ClassNotFoundException, SQLException {
           //1. 加载驱动
           Class.forName("com.mysql.jdbc.Driver");
           //2. 用户信息和url
           // useUnicode=true&characterEncoding=utf8&useSSL=ture 第一个：支持中文编码；第二个：字符集位优先；第三个：SSL使用安全的连接
           String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
           String username = "root";
           String password = "123456";
           //3. 连接成功，数据库对象
           Connection connection= DriverManager.getConnection(url,username,password);
           //4. 执行SQL对象    Statement执行sql的对象
           Statement statement = connection.createStatement();
           //5. 执行SQL的对象去执行SQL
           String sql = "SELECT * FROM users";
           ResultSet resultSet = statement.executeQuery(sql);//返回结果集
           while (resultSet.next()){
               System.out.println("id=" + resultSet.getObject("id"));
               System.out.println("name=" + resultSet.getObject("NAME"));
               System.out.println("pwd=" + resultSet.getObject("PASSWORD"));
               System.out.println("email=" + resultSet.getObject("email"));
               System.out.println("birth=" + resultSet.getObject("birthday"));
   
           }
           //6. 释放连接
           resultSet.close();
           statement.close();
           connection.close();
       }
   }
   

   结果：

   

四、JDBC对象的解释

DriverManager

Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动
Connection connection= DriverManager.getConnection(url,username,password);

//connection
//数据库设置自动提交
//事务提交
//事物回滚

URL

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

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.getObject();
......

遍历，指针

resultSet.beforeFirst();//移动到最前面
resultSet.afterLast();//移动到最后面
resultSet.next();//移动到下一个数据
resultSet.previous();//移动到前一行
resultSet.absolute(row)//移动到指定行

释放资源

resultSet.close();
statement.close();
connection.close();

五、statement对象

JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sq|语句， executeUpdate执行完后， 将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。

Statement.executeQuery方法用于向数据库发生查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

 Statement statement = connection.createStatement();
        String sql = "insert into user(...) values(...)";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("插入成功");
        }

CRUD操作-delete

使用executeUpdate(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(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

Statement statement = connection.createStatement();
        String sql = "select * from  user where id =1";
        ResultSet rs= statement.executeQuery(sql);
        if(rs.next()){
            System.out.println("");
        }

代码实现（增）：

package com.Ji.lesson01.lesson2.utils;

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

import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;

public class TestInser {
    public static void main(String[] args) throws Exception {
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;

        try {
            conn = JdbcUtils.getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(4,'yuanhui','123456','233223@qq.com','2020-01-01')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
            JdbcUtils.release(conn,st,rs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally{
            JdbcUtils.release(conn,st,rs);
        }
    }
}

代码实现（删）：[改变上面的代码即可]

package com.Ji.lesson01.lesson2.utils;

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

import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;

public class TextDelet {
    public static void main(String[] args) throws Exception {
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;

        try {
            conn = JdbcUtils.getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "DELETE FROM users WHERE id = 4";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("删除成功");
            }
            JdbcUtils.release(conn,st,rs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally{
            JdbcUtils.release(conn,st,rs);
        }
    }
}

代码实现（更新）：

package com.Ji.lesson01.lesson2.utils;

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

import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;

public class TextUpdate {
    public static void main(String[] args) throws Exception {
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;

        try {
            conn = JdbcUtils.getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "UPDATE USERS SET `NAME` = 'YUANHUI',`email`= '123456@qq.com' WHERE id = 2";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("更新成功");
            }
            JdbcUtils.release(conn,st,rs);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally{
            JdbcUtils.release(conn,st,rs);
        }
    }

}

代码实现（查询）：

package com.Ji.lesson01.lesson2.utils;

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

import static com.Ji.lesson01.lesson2.utils.JdbcUtils.*;

public class TextQuery {
    public static void main(String[] args) throws Exception {
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;

        try {
            conn = JdbcUtils.getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象

            String sql = " select * from users where id = 2   ";

           rs  = st.executeQuery(sql);//查询完毕，打印结果集

            while (rs.next()){
                System.out.println(rs.getString("NAME"));
            }
            JdbcUtils.release(conn,st,rs);

        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally{
            JdbcUtils.release(conn,st,rs);
        }
    }
}

六、SQL注入的问题

sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接

package com.Ji.lesson01.lesson2.utils;

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

import static com.Ji.lesson01.lesson2.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();
            }
        }
    }
}

七、PreparedStatement对象

PreparedStatement 可以防止SQL注入 ，效率更高。

1. 新增
2. 删除
3. 查询

新增：

package com.Ji.lesson01.lesson2.utils;

import com.Ji.lesson01.lesson2.utils.JdbcUtils;

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

public class PreparedStatement {
    public static void main(String[] args) {
        Connection connection= null;
        java.sql.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();
            }
        }
    }
}

防止SQL注入本质，传递字符 带有“ ”，转义字符会被转义

删除：

package com.Ji.lesson01.lesson2.utils;

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

public class PreparedStatement {
    public static void main(String[] args) {
        Connection connection= null;
        java.sql.PreparedStatement st=null;
        try {
            connection = JdbcUtils.getConnection();
            //区别
            //使用问好占位符代替参数
            String sql = "delete from users where id = ?;";
            st = connection.prepareStatement(sql);//预编译sql，先写sql然后不执行
            //手动赋值
            st.setInt(1,4);
            //执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("删除成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                JdbcUtils.release(connection,st,null);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

查询：

package com.Ji.lesson01.lesson2.utils;

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

public class PreparedStatement1 {
    public static void main(String[] args) {
        Connection connection= null;
        java.sql.PreparedStatement st=null;
        ResultSet rs = null;
        try {
            connection = JdbcUtils.getConnection();
            //区别
            //使用问好占位符代替参数
            String sql = "select * from users where id = ? ;";
            st = connection.prepareStatement(sql);//预编译sql，先写sql然后不执行
            //手动赋值
            st = connection.prepareStatement(sql);

            st.setInt(1,8);
            //执行
           rs  = st.executeQuery();
            if (rs.next()){
                System.out.println(rs.getString("NAME"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                JdbcUtils.release(connection,st,null);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

★使用IDEA连接数据库

** 注：

1. 社区版的idea和正式版的不一样
2. database在社区版的时候是DB browser
3. 注意回看视频区分**

连接成功后，可以选择数据库

双击数据库

更新数据

★JDBC事物

要么都成功，要么都失败

ACID原则

原子性：要么全部完成，要么都不完成

一致性：结果总数不变

隔离性：多个进程互不干扰

持久性：一旦提交不可逆，持久化到数据库了

隔离性的问题：

脏读： 一个事务读取了另一个没有提交的事务

不可重复读：在同一个事务内，重复读取表中的数据，表发生了改变

虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致

1. 开启事务conn.setAutoCommit(false);
2. 一组业务执行完毕，提交事务
3. 可以在catch语句中显示的定义回滚，但是默认失败会回滚

★数据库连接池

数据库连接–执行完毕–释放

连接–释放 十分浪费资源

池化技术： 准备一些预先的资源，过来就连接预先准备好的

常用连接数 100

最少连接数：100

最大连接数 ： 120 业务最高承载上限

排队等待，

等待超时：100ms

编写连接池，实现一个接口 DateSource

开源数据源实现(拿来即用)

DBCP

C3P0

Druid: 阿里巴巴

使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了

结论

无论使用什么数据源，本质是不变的，DateSource接口不会变，方法就不会变