数据库相关概念及MySQL（更新中）

╰半夏微凉° 2023-01-18 14:24 238阅读 0赞

### 文章目录 ###

*  数据库相关概念
 *   *  数据库的存储
     *  数据库的好处
     *  数据库相关概念
     *  SQL
     *  数据完整性
 *  初识MySQL服务端
 *   *  MySQL的优点
     *  MySQL的安装
     *  MySQL服务的启动与停止
     *  MySQL服务的登录和退出
     *  MySQL的常见命令
     *  MySQL的语法规范
 *  客户端
 *  DQL语言的学习
 *   *  1. 基础查询
     *  2.条件查询
     *  3. 排序查询
     *  4. 常见函数
     *   *  单行函数
         *   *  1. 字符函数
             *  2.数学函数
             *  3. 日期函数
             *  4. 其他函数
             *  5. 流程控制函数
         *  分组函数
     *  5. 分组查询
     *  6. 连接查询
     *   *  sql92标准
         *   *  1.等值连接
             *  2.非等值连接
             *  3.自连接
         *  sql99 标准
         *   *  1. 内连接
             *  2. 外连接
             *  3. 交叉连接
             *  4. 独有与全连接
     *  7. 子查询
     *   *  1. where或having后面
         *  2. select后面
         *  3.from后面
         *  4. exists后面（相关子查询）
     *  8. 分页查询
     *  9. 联合查询
     *  10. 查询总结
 *  DML语言的学习
 *   *  插入操作
     *   *  方式一： 经典插入
         *  方式二：字段名插入
         *  两种方式对比
         *  常用的三种插入数据的语句
     *  修改操作
     *  删除操作
     *   *  方式一：delete
         *  方式二：truncate
         *  经典面试题：delete pk truncate【★★★】
 *  DDL语言的学习
 *   *  库的管理
     *  表的管理
     *   *  1.表的创建 ★
         *  2. 表的修改
         *  3. 表的删除
         *  4. 表的复制
     *  常见的数字类型
     *   *  1. 整型
         *  2. 小数
         *  3. 字符型
         *  4. 日期型
     *  常见约束
     *   *  一、创建表时添加约束
         *  二、修改表时添加约束
         *  三、修改表时删除约束
         *  四、标识列
 *  TCL语言的学习
 *   *   *  经典面试题：事务的特性【★★★】
         *  经典面试题：事务的并发问题【★★★】
         *  经典面试题：数据库的事务隔离级别【★★★】
 *  视图的讲解
 *   *  一、创建视图
     *  二、视图的修改
     *  三、删除视图
     *  四、查看视图
     *  五、视图的更新
 *  变量
 *   *  一、系统变量
     *   *  全局变量
         *  会话变量
     *  二、自定义变量
     *   *  用户变量
         *  局部变量
 *  存储过程和函数
 *   *  存储过程
     *   *  一、创建语法
         *  二、调用语法
         *  三、删除存储过程
         *  四、查看存储过程的信息
     *  函数
     *   *  一、创建语法
         *  二、调用语法
         *  三、查看函数
         *  四、删除函数
 *  流程控制结构
 *   *  一、分支结构
     *   *  1.if函数
         *  2.case结构
         *  3.多重if语句
     *  二、循环结构
     *   *  1.while
         *  2.loop
         *  3.repeat
         *  强制索引
     *  例题

仅为自己学习的笔记。

# 数据库相关概念 #

## 数据库的存储 ##

数据库：本质是特殊的文件，由多个表组成，是数据表的集合。描述一类（列）的信息叫做**字段**，描述一个事务（行）的信息叫做**记录**，能够唯一标识一行记录的字段叫做**主键**，表与表之间可以发生关联、有一定关系的数组叫做**关系型数据库**。

1.  将数据放到表中，表再放到库中
2.  一个数据库中可以有多个表，每个表都有一个的名字，用来标识自己。表名具有唯一性。
3.  表具有一些特性，这些特性定义了数据在表中如何存储，类似java中“类”的设计。
4.  表由列组成，我们也称为字段。所有表都是由一个或多个列组成的，每一列类似 java 中的”属性”。
5.  表中的数据是按行存储的，每一行类似于java中的“对象”。

## 数据库的好处 ##

1.  持久化数据到本地
2.  可以实现结构化查询，方便管理

## 数据库相关概念 ##

DB：数据库（database），存储数据的“仓库”，他保存了一系列有组织的数据；  
DBMS：数据库管理系统（Database Management System）,数据库是通过DBMS创建和操作的容器；  
RDBMS：关系型数据库管理系统（Relational Database Management System），通过表来表示关系型。

*  当前主要使用两种类型的数据库︰关系型数据库、非关系型数据库，我们学习的是关系型数据库；
 *  所谓的关系型数据库RDBMS，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。
 *  关系型数据库的主要产品  
    oracle：在以前的大型项目中使用,银行,电信等项目，收费  
    mysql：web时代使用最广泛的关系型数据库  
    sql server：在微软的项目中使用  
    sqlite：轻量级数据库。主要应用在移动平台  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70]

客户端通过SQL语句来连接服务端

## SQL ##

SQL（structure Query Language）是结构化查询语言，是专门和数据库通信的语言，是一种用来操作RDBMS的数据库语言，当前关系型数据库都支持使用SQL语言进行操作,也就是说可以通过SQL操作oracle,sql server,mysql,sqlite等等所有的关系型的数据库；虽然简单，但实际可以进行非常复杂和高级的数据库操作。

*  SQL语句主要分为:
    
     *  **DQL:数据查询语言，用于对数据进行查询，如select**
     *  **DML:数据操作语言，对数据进行增加、修改、删除，如insert、udpate、delete**
     *  TPL:事务处理语言，对事务进行处理，包括begin transaction、commit、rolback
     *  DCL:数据控制语言，进行授权与权限回收，如grant、revoke
     *  **DDL**:数据定义语言，进行数据库、表的管理等，如create、drop
     *  CCL:指针控制语言，通过控制指针完成表的操作，如declare cursor

*  对于web程序员来讲，重点是数据的crud(增删改查)，必须熟练编写DQL、DML，能够编写DDL完成数据库、表的操作，其它语言如TPL、DCL、CCL了解即可
 *  SQL是一门特殊的语言,专门用来操作关系数据库
 *  不区分大小写

## 数据完整性 ##

*  —个数据库就是一个完整的业务单元，可以包含多张表，数据被存储在表中
 *  在表中为了更加准确的存储数据，保证数据的正确有效，可以在创建表的时候，为表添加一些强制性的验证，包括数据字段的类型、约束

**数据类型**

*  可以通过查看帮助文档查阅所有支持的数据类型
 *  使用数据类型的原则是:够用就行，尽量使用取值范围小的，而不用大的，这样可以更多的节省存储空间
 *  常用数据类型如下:
    
     *  整数:int, bit
     *  小数:decimal
     *  字符串: varchar，char
     *  日期时间: date, time, datetime
     *  枚举类型(enum)
 *  特别说明的类型如下:
    
     *  decimal表示浮点数，如decimal(5,2)表示共存5位数，小数占2位
     *  char表示固定长度的字符串，如char(3)，如果填充’ ab’时会补一个空格为`‘ab ’`
     *  varchar表示可变长度的字符串，如varchar(3)，真充’ab"时就会存储’ab’
     *  字符申text表示存储大文本，当字符大于4000时推荐使用
     *  对于图片、音频、视频等文件，不存储在数据库中，而是上传到某个服务器上，然后在表中存储这个文件的保存路径

数据类型(常用)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 1]  
字符串  
![在这里插入图片描述][20210506211045545.png]  
**约束**

*  主键primary key:物理上存储的顺序。
 *  非空not null:此字段不允许填写空值
 *  惟—unique:此字段的值不允许重复
 *  默认default:当不填写此值时会使用默认值，如果填写时以填写为准
 *  外键foreign key:对关系字段进行约束，当为关系字段填写值时，会到关联的表中查询此值是否存在，如果存在则填写成功，如果不存在则填写失败并抛出异常
 *  说明:虽然外健约束可以保证数据的有效性，但是在进行数据的crud (增加、修改、删除、查询)时，都会降低数据库的性能，所以不推荐使用，那么数据的有效性怎么保证呢?答:可以在逻辑层进行控制

# 初识MySQL服务端 #

## MySQL的优点 ##

1.  开源、免费、成本低
2.  性能高、移植性也好
3.  体积小，便于安装

## MySQL的安装 ##

路径不能有中文，属于c/s架构，一般来讲是安装服务端

## MySQL服务的启动与停止 ##

*  此电脑 → \\rightarrow →管理 → \\rightarrow →服务和应用程序 → \\rightarrow →服务 → \\rightarrow →mysql → \\rightarrow → 状态 → \\rightarrow → 右击选择启动/停止，启动类型在右击属性里修改
 *  命令行开启，以管理员身份运行cmd → \\rightarrow →net stop/start 服务名，我的是net start MySQL80

## MySQL服务的登录和退出 ##

*  root用户：进入MySQL自带的客户端，输入密码就启动了，输入`exit`退出，或者`ctr+C`  
    输入密码后闪退可能是因为进程关闭了，要先启动。
 *  命令行登陆，`mysql [-h主机名 -P端口号] -u用户名 -p密码`，远程时输入主机名和端口号，本机可以不写。  
    `mysql -h localhost -P3306 -u root -p`或`mysql -h localhost -P3306 -u root -p密码`，退出`exit`  
    如果出现mysql不是内部命令，可能是没有添加环境变量。在此电脑 → \\rightarrow →属性 → \\rightarrow →高级系统设置 → \\rightarrow →环境变量 → \\rightarrow →PATH 中添加MySQL的环境，一般默认在`C:\Program Files\MySQL\MySQL Server 8.0\bin`  
    ![在这里插入图片描述][20210507153012135.png]  
    h host连主机  
    P port端口号  
    p password密码

## MySQL的常见命令 ##

1.  查看当前所有的数据库 show databases ;  
    ![在这里插入图片描述][20210507150336532.png]
2.  打开指定的库 use 库名
3.  查看当前库的所有表 show tables;  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 2]
4.  查看其它库的所有表 show tables from 库名;  
    ![在这里插入图片描述][20210507150446915.png]
5.  查看当前在哪个库 select database();
6.  创建表  
    create table表名(  
    列名 列类型,  
    列名 列类型,  
    。。。  
    );  
    ![在这里插入图片描述][20210507150646830.png]
7.  查看表结构 desc 表名;  
    ![在这里插入图片描述][20210507151311466.png]
8.  查看有哪些数据  
    select \* from 表名;  
    ![在这里插入图片描述][20210507151453258.png]
9.  插入数据  
    insert into 表名 (id,name) values(1,‘john’);  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 3]
10. 修改  
    update danah set name=‘rose’ where id=2;  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 4]
11. 删除  
    delete from danah where id=1;  
    ![在这里插入图片描述][20210507152714695.png]
12. 查看服务器的版本  
    方式—：登录到mysql服务端  
    select version();  
    ![在这里插入图片描述][20210507152805358.png]  
    方式二∶没有登录到mysql服务端  
    mysql --version  
    或  
    mysql --V

## MySQL的语法规范 ##

1.  不区分大小写，但建议关键字大写，表名、列名小写；
2.  每条命令最好用分号结尾；
3.  每条命令根据需要，可以进行缩进或者换行；
4.  注释  
    单行注释：\#注释文字  
    单行注释：-- 注释文字（–和文字之间有空格）  
    多行注释：/\* 注释文字 \*/

# 客户端 #

客户端可以使用SQLyog、MySQL Workbench或者Navicat,使用方式差不多。  
SQLyog  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 5]  
MySQL Workbench  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 6]  
以下主要针对SQLyog10.0  
修改字体大小：工具 → \\rightarrow →首选项 → \\rightarrow →字体编辑器设置，或者按住CTRL+鼠标滚动；  
语句后面加`;`，后者可能在第二行报错。

# DQL语言的学习 #

DQL(Data Query Language,数据查询语言)用于对数据进行查询，如select。  
首先要了解我们需要分析的数据，处理查询某个信息的时候要知道数据在哪里。  
![在这里插入图片描述][20210508140147985.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][20210508140422673.png]  
![在这里插入图片描述][20210508140523406.png]  
![在这里插入图片描述][20210508140634828.png]

## 1. 基础查询 ##

语法：
    	SELECT 要查询的东西
    	FROM 表名;

特点：  
①通过select查询完的结果 ，是一个虚拟的表格，不是真实存在  
②要查询的东西 可以是常量值、可以是表达式、可以是字段、可以是函数

1.  查询表中单个字段
    
        SELECT last_name FROM employees;
2.  查询表中多个字段
    
        SELECT last_name,salary,email FROM employees;
3.  查询表中所有字段
    
        SELECT `first_name`,`email` FROM employees;
    
    在左侧要选择的字段上双击选择，中间`,`隔开，选中语句，点`F12`格式化，执行：选中要执行的语句点运行 或者`F9`。
    
        SELECT * FROM employees;
    
    用 \* 表示所有字段。
4.  查询常量值
    
        SELECT 100;
         SELECT 'john';
    
    注意：字符型和日期型的常量必须用单引号引起来，数值型不需要
5.  查询表达式
    
        SELECT 100%98;
6.  查询函数  
    SELECT 函数名(实参列表);
    
        SELECT VERSION();
7.  起别名，
    
     *  便于理解
     *  如果要查询的字段有重名，使用别名可以区分开来
    
    方式一：使用as
    
        SELECT 100%98 AS 结果；
         	SELECT `first_name` AS 名,`last_name` AS 姓 FROM employees;
    
    方式二：使用空格
    
        SELECT `first_name` 名,`last_name`  姓 FROM employees;
    
    方式三：如果别名中有关键字，加双引号
    
        SELECT salary AS "out put" FROM employees;
    
    ![在这里插入图片描述][20210508145715655.png]
8.  去重  
    查询员工表中涉及到的所有的部门编号  
    select distinct 字段名 from 表名;
    
        SELECT DISTINCT `department_id` FROM employees;
    
    用`DISTINCT`去重，搭配单个字段。
9.  \+号的作用：  
    仅仅是运算符，两个操作数都为数值型，则做加法运算；其中一方为字符型，试图将字符型数值转换为数值型，如果转换成功，则继续做加法运算；如果转换失败，则将字符型数值转换为0；如果一方为null，则结果为null。
    
    案例：查询员工名和姓连接成一个字段，并显示为姓名。
    
        SELECT CONCAT(`last_name`,`first_name`) AS 姓名 FROM employees;
10. ifnull函数  
    功能：判断某字段或表达式是否为null，如果为null，返回指定值，否则返回原本的值。  
    select ifnull(字段，0) from 表
11. isnull函数  
    功能：判断某字段或表达式是否为null，如果是，返回1，否则返回0.

## 2.条件查询 ##

条件查询：根据条件过滤原始表的数据，查询到想要的数据
    语法：
    select 
    	要查询的字段|表达式|常量值|函数 ③
    from 
    	表  ①
    where 
    	筛选条件 ②;

分类：

一、条件表达式
    	示例：salary>10000
    	条件运算符：
    	> < >= <= = !=  <>不等于
    
    二、逻辑表达式
    示例：salary>10000 && salary<20000
    
    逻辑运算符：
    
    	and（&&）:两个条件如果同时成立，结果为true，否则为false
    	or(||)：两个条件只要有一个成立，结果为true，否则为false
    	not(!)：如果条件成立，则not后为false，否则为true
    
    三、模糊查询
    示例：last_name like 'a%'
    like
    between and 
    in 
    is null

**1. 按条件表达式筛选**

案例1：查询工资>12000的员工信息

SELECT 
    		*
    	FROM
    		employees
    	WHERE
    		salary>12000;

案例2：查询部门编号不等于90号的员工名和部门编号

SELECT 
    	last_name,
    	department_id
    FROM
    	employees
    WHERE
    	department_id<>90;

**2. 按逻辑表达式筛选**

案例1：查询工资在10000到20000之间的员工名、工资以及奖金

SELECT
    	last_name,
    	salary,
    	commission_pct
    FROM
    	employees
    WHERE
    	salary>=10000 AND salary<=20000;

案例2：查询部门编号不是在90到110之间，或者工资高于15000的员工信息

SELECT
    	*
    FROM
    	employees
    WHERE
    	NOT(department_id>=90 AND  department_id<=110) OR salary>15000;

**3. 模糊查询**

*  like  
    特点：一般和通配符搭配使用，可以判断字符型或数值型。  
    通配符：  
    % 任意多个字符,包含0个字符  
    \_ 任意单个字符
    
    案例1：查询员工名中包含字符a的员工信息
    
        SELECT 
        	*
        FROM
        	employees
        WHERE
        	last_name LIKE '%a%';#abc
    
    案例2：查询员工名中第三个字符为n，第五个字符为l的员工名和工资
    
        SELECT
        	last_name,
        	salary
        FROM
        	employees
        WHERE
        	last_name LIKE '__n_l%';
    
    案例3：查询员工名中第二个字符为\_的员工名
    
        SELECT
        	last_name
        FROM
        	employees
        WHERE
        	last_name LIKE '_$_%' ESCAPE '$';
    
    `last_name LIKE '_\_%'`,可以用\\转义符，也可以用任意一个`符号+escape+符号` 表示
 *  between and  
    ①使用between and 可以提高语句的简洁度  
    ②包含临界值  
    ③两个临界值不要调换顺序  
    案例1：查询员工编号在100到120之间的员工信息
    
        SELECT
        	*
        FROM
        	employees
        WHERE
        	employee_id >= 120 AND employee_id<=100;
    
        SELECT
        	*
        FROM
        	employees
        WHERE
        	employee_id BETWEEN 120 AND 100;
 *  in关键字  
    含义：判断某字段的值是否属于in列表中的某一项  
    特点：  
    ①使用in提高语句简洁度  
    ②in列表的值类型必须一致或兼容  
    ③in列表中不支持通配符
    
    案例：查询员工的工种编号是 IT\_PROT、AD\_VP、AD\_PRES中的一个员工名和工种编号
    
        SELECT
        	last_name,
        	job_id
        FROM
        	employees
        WHERE
        	job_id = 'IT_PROT' OR job_id = 'AD_VP' OR JOB_ID ='AD_PRES';
    
        SELECT
        	last_name,
        	job_id
        FROM
        	employees
        WHERE
        	job_id IN( 'IT_PROT' ,'AD_VP','AD_PRES');
 *  is null  
    =或<>不能用于判断null值  
    is null或is not null 可以判断null值
    
    案例1：查询没有奖金的员工名和奖金率
    
        SELECT
        	last_name,
        	commission_pct
        FROM
        	employees
        WHERE
        	commission_pct IS NULL;
    
    案例2：查询有奖金的员工名和奖金率
    
        SELECT
        	last_name,
        	commission_pct
        FROM
        	employees
        WHERE
        	commission_pct IS NOT NULL;
 *  完全等于 <=>  
    案例1：查询没有奖金的员工名和奖金率
    
        SELECT
        	last_name,
        	commission_pct
        FROM
        	employees
        WHERE
        	commission_pct <=>NULL;
    
    案例2：查询工资为12000的员工信息
    
        SELECT
        	last_name,
        	salary
        FROM
        	employees
        
        WHERE 
        	salary <=> 12000;
 *  is null 和 <=>  
    IS NULL:仅仅可以判断NULL值，可读性较高，建议使用  
    <=> :既可以判断NULL值，又可以判断普通的数值，可读性较低

**经典面试题**  
试问：`select * from employees;` 和 `select * from employees where commission_pct like '%%' and last_name like '%%';`结果是否一样？并说明原因。  
不一样。如果判断的字段有null值，结果就不一样，如果没有null值，就一样。

## 3. 排序查询 ##

语法：
    select 查询列表 ③
    from 表名 ①
    【where  筛选条件】②
    order by 排序的字段或表达式; ④

特点

1、asc代表的是升序，可以省略
    desc代表的是降序
    2、order by子句可以支持 单个字段、别名、表达式、函数、多个字段
    3、order by子句在查询语句的最后面，除了limit子句

1.  单个字段排序  
    案例1：查询员工信息，要求工资从高到低排序  
    `SELECT * FROM employees ORDER BY salary DESC;`  
    `SELECT * FROM employees ORDER BY salary;`
2.  添加筛选条件再排序  
    案例2：查询部门编号>=90的员工信息，并按员工编号降序
    
        SELECT *
        FROM employees
        WHERE department_id>=90
        ORDER BY employee_id DESC;
3.  按表达式排序  
    案例3：查询员工信息 按年薪降序
    
        SELECT *,salary*12*(1+IFNULL(commission_pct,0))
        FROM employees
        ORDER BY salary*12*(1+IFNULL(commission_pct,0)) DESC;
4.  按别名排序  
    案例4：查询员工信息 按年薪升序
    
        SELECT *,salary*12*(1+IFNULL(commission_pct,0)) 年薪
        FROM employees
        ORDER BY 年薪 ASC;
5.  按函数排序  
    案例5：查询员工名，并且按名字的长度降序
    
        SELECT LENGTH(last_name),last_name 
        FROM employees
        ORDER BY LENGTH(last_name) DESC;
6.  按多个字段排序  
    案例6：查询员工信息，要求先按工资降序，再按employee\_id升序
    
        SELECT *
        FROM employees
        ORDER BY salary DESC,employee_id ASC;

## 4. 常见函数 ##

概念：类似于java的方法，将一组逻辑语句封装在方法体中，对外暴露方法名
    好处：1、隐藏了实现细节  2、提高代码的重用性
    调用：select 函数名(实参列表) 【from 表】;
    特点：
    	① 叫什么（函数名）
    	② 干什么（函数功能）
    
    分类：
    	1、单行函数
    	如 concat、length、ifnull等
    	2、分组函数
    	功能：做统计使用，又称为统计函数、聚合函数、组函数

### 单行函数 ###

#### 1. 字符函数 ####

1.  lth 获取参数值的**字节**个数  
    `SELECT LENGTH('john');`  
    `SELECT LENGTH('张三丰hahaha');`  
    ![在这里插入图片描述][20210508221905392.png]
2.  concat 拼接字符串  
    `SELECT CONCAT(last_name,'_',first_name) 姓名 FROM employees;`
3.  upper、lower
    
        SELECT UPPER('john');
        SELECT LOWER('joHn');
        #示例：将姓变大写，名变小写，然后拼接
        SELECT CONCAT(UPPER(last_name),'_',LOWER(first_name))  姓名 FROM employees;
    
    ![在这里插入图片描述][20210508222010910.png]
4.  substr、substring  
    注意：索引从1开始
    
        #截取从指定索引处后面所有字符
        SELECT SUBSTR('李莫愁爱上了陆展元',7)  out_put;
        
        #截取从指定索引处指定字符长度的字符
        SELECT SUBSTR('李莫愁爱上了陆展元',1,3) out_put;
        
        #案例：姓名中首字符大写，其他字符小写然后用_拼接，显示出来
        SELECT CONCAT(UPPER(SUBSTR(last_name,1,1)),'_',LOWER(SUBSTR(last_name,2)))  out_put
        FROM employees;
5.  mysql字符串分割
    
        1、left(str,n)//从左开始分割,截取n位
         2、right(str,n)//从右开始分割，截取n位
         3、substring(str,pos)//从哪一位开始
         substring(str,pos,length)//从哪一位开始截取几位
         4、substring_index（str,delim,count）//substring_index（被截取字段，分隔符，关键字出现的次数）
6.  instr 返回子串第一次出现的索引，如果找不到返回0  
    `SELECT INSTR('杨不悔爱上了殷六侠','殷六侠') AS out_put;`
7.  trim 去掉首尾字符  
    `SELECT LENGTH(TRIM(' 张翠山 ')) AS out_put;`  
    `SELECT TRIM('aa' FROM 'aaaaaaaaa张aaaaaaaaaaaa翠山aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa') AS out_put;`  
    ![在这里插入图片描述][20210508221730658.png]
8.  lpad 用指定的字符实现左填充指定长度  
    `SELECT LPAD('殷素素',12,'*') AS out_put;`  
    ![在这里插入图片描述][20210508221616342.png]
9.  rpad 用指定的字符实现右填充指定长度  
    `SELECT RPAD('殷素素',12,'ab') AS out_put;`  
    ![在这里插入图片描述][20210508221656715.png]
10. replace 替换  
    `SELECT REPLACE('周芷若周芷若周芷若周芷若张无忌爱上了周芷若','周芷若','赵敏') AS out_put;`  
    ![在这里插入图片描述][20210508221824131.png]

#### 2.数学函数 ####

1.  round 四舍五入  
    `SELECT ROUND(-1.55);`  
    `SELECT ROUND(1.567,2);`  
    ![在这里插入图片描述][20210508222705481.png]  
    ![在这里插入图片描述][20210508222730298.png]
2.  ceil 向上取整,返回>=该参数的最小整数  
    `SELECT CEIL(-1.02);`  
    ![在这里插入图片描述][2021050822285539.png]
3.  floor 向下取整，返回<=该参数的最大整数  
    SELECT FLOOR(-9.99);  
    ![在这里插入图片描述][2021050822292686.png]
4.  truncate 截断  
    `SELECT TRUNCATE(1.69999,1);`  
    ![在这里插入图片描述][20210508223050886.png]
5.  mod取余  
    mod(a,b) ： a-a/b\*b  
    mod(-10,-3):-10- (-10)/(-3) \*（-3）=-1  
    mod(10,-3):10- 10/(-3) \*（-3）=-1
    
    `SELECT MOD(10,-3);`  
    `SELECT 10%3;`
6.  rand获取随机数  
    ![在这里插入图片描述][20210510141841575.png]
7.  CAST转换数据类型  
    函数语法规则是：Cast(字段名 as 转换的类型 )，其中类型可以为：  
    CHAR\[(N)\] 字符型  
    DATE 日期型  
    DATETIME 日期和时间型  
    DECIMAL float型  
    SIGNED int  
    TIME 时间型

date：2015-11-03 15:31:26  
select cast(date as signed) as date from table1;  
结果：date：20151103153126

#### 3. 日期函数 ####

1.  now 返回当前系统日期+时间  
    `SELECT NOW();`  
    ![在这里插入图片描述][20210508223838553.png]
2.  curdate 返回当前系统日期，不包含时间  
    `SELECT CURDATE();`  
    ![在这里插入图片描述][20210508224005544.png]
3.  curtime 返回当前时间，不包含日期  
    `SELECT CURTIME();`  
    ![在这里插入图片描述][20210508224052835.png]
4.  可以获取指定的部分，年、月、日、小时、分钟、秒  
    `可以获取指定的部分，年、月、日、小时、分钟、秒`  
    ![在这里插入图片描述][2021050822415010.png]  
    `可以获取指定的部分，年、月、日、小时、分钟、秒`  
    ![在这里插入图片描述][202105082242084.png]  
    `SELECT YEAR(hiredate) 年 FROM employees;`  
    `SELECT MONTH(NOW()) 月;`  
    `SELECT MONTHNAME(NOW()) 月;`  
    ![在这里插入图片描述][20210508224329144.png]
5.  str\_to\_date 将字符通过指定的格式转换成日期  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 8]  
    `SELECT STR_TO_DATE('1998-3-2','%Y-%c-%d') AS out_put;`  
    ![在这里插入图片描述][202105082253201.png]  
    查询入职日期为1992–4-3的员工信息  
    `SELECT * FROM employees WHERE hiredate = '1992-4-3';`  
    `SELECT * FROM employees WHERE hiredate = STR_TO_DATE('4-3 1992','%c-%d %Y');`
6.  date\_format 将日期转换成字符  
    `SELECT DATE_FORMAT(NOW(),'%y年%m月%d日') AS out_put;`  
    ![在这里插入图片描述][20210508225708474.png]  
    查询有奖金的员工名和入职日期(xx月/xx日 xx年)
    
        SELECT last_name,DATE_FORMAT(hiredate,'%m月/%d日 %y年') 入职日期
        FROM employees
        WHERE commission_pct IS NOT NULL;
    
    ![在这里插入图片描述][20210508225754918.png]
7.  DATEDIFF 日期差值  
    查询员工表中的最大入职时间和最小入职时间的相差天数 `DATEDIFF`
    
        SELECT MAX(`hiredate`),MIN(`hiredate`),DATEDIFF(MAX(`hiredate`),MIN(`hiredate`))
        FROM `employees`;
8.  interval 加一天  
    mysql里查找某一天的后一天的用法是:DATE\_ADD(yyyy-mm-dd,INTERVAL 1 DAY)，四舍五入的函数为round)
9.  week() 查询当前是第几周  
    10.weekday() 查看当前是周几

#### 4. 其他函数 ####

`SELECT VERSION();`  
`SELECT DATABASE();`  
`SELECT USER();`  
`SELECT PASSWORD('密码')` 返回该字符放入密码形式  
`SELECT MD5('密码')` 返回该字符的md5加密形式  
![在这里插入图片描述][20210508230235554.png]  
pivot函数 [mysql 行转列 列转行\_SQL之行转列Pivot函数][mysql _ _SQL_Pivot]  
![在这里插入图片描述][1c813f1a9de645be9b47732a03f8c8b3.png]  
虽然数据是能够完全给展示了，但好像一眼望去不能得到对我们用处更大的信息，比如说我们想得到每个供应商的每天的总收入，这时我们应该做一些数据形式的转变了，平常的所用的是这样的。  
![在这里插入图片描述][ac50188c2cef42d18a3d38302b9cf98e.png]

得到的结果是这样的：  
![在这里插入图片描述][3a1b56e2df174af2b4eee2ea3d34af21.png]  
如果大家仔细看结果的话，会有这样的发现，这是把VendorID进行了分组，并且对于每组中IncomeDay这一列中的值都变成了新的列名字，然后对IncomeAmount进行求和操作。  
这样写可能是有些麻烦，别着急，我们用Pivot函数进行行转列试下。

![在这里插入图片描述][b6986458dc304b7bab93267fbfe6a936.png]  
来解释下，要想用好Pivot函数，应该理解代码注释中的这几步。  
第一步：肯定是要明白数据源了，这里是DailyIncome  
第二步：要明白要想让哪一列的值做新的列名字  
第三步：要明白对于这新的列要求那些值呢？

例：对于SPIKE这家供应商来说，每天最大的入账金额。

select * from DailyIncome
    pivot (max (IncomeAmount) for IncomeDay in ([MON],[TUE],[WED],[THU],[FRI],[SAT],[SUN])) as MaxIncomePerDay
    where VendorId in ('SPIKE')

#### 5. 流程控制函数 ####

1.  if函数： 实现类似if else 的效果  
    `SELECT IF(10<5,'大','小');`  
    `SELECT last_name,commission_pct,IF(commission_pct IS NULL,'没奖金，呵呵','有奖金，嘻嘻') 备注 FROM employees;`  
    ![在这里插入图片描述][20210508230525391.png]
2.  case函数的使用一： 类似switch case 的效果，判断的是等于的条件
    
    java中
    
        switch(变量或表达式){
         	case 常量1：语句1;break;
         	...
         	default:语句n;break;
    
    mysql中
    
        case 要判断的字段或表达式
         when 常量1 then 要显示的值1或语句1;
         when 常量2 then 要显示的值2或语句2;
         ...
         else 要显示的值n或语句n;
         end as 别名
    
    案例：查询员工的工资，要求：  
    部门号=30，显示的工资为1.1倍  
    部门号=40，显示的工资为1.2倍  
    部门号=50，显示的工资为1.3倍  
    其他部门，显示的工资为原工资
    
        SELECT 
         salary 原始工资,
         department_id,
         CASE
           department_id 
           WHEN 30 
           THEN salary * 1.1 
           WHEN 40 
           THEN salary * 1.2 
           WHEN 50 
           THEN salary * 1.3 
           ELSE salary 
         END AS 新工资 
        FROM
         employees ;
    
    ![在这里插入图片描述][20210508231229147.png]
3.  case 函数的使用二：类似于 多重if，判断的是区间  
    java中：
    
        if(条件1){
         	语句1；
         }else if(条件2){
         	语句2；
         }
         ...
         else{
         	语句n;
         }
    
    mysql中：
    
        case 
         when 条件1 then 要显示的值1或语句1
         when 条件2 then 要显示的值2或语句2
         。。。
         else 要显示的值n或语句n
         end
    
    案例：查询员工的工资的情况  
    如果工资>20000,显示A级别  
    如果工资>15000,显示B级别  
    如果工资>10000，显示C级别  
    否则，显示D级别
    
        SELECT salary,
        CASE 
        WHEN salary>20000 THEN 'A'
        WHEN salary>15000 THEN 'B'
        WHEN salary>10000 THEN 'C'
        ELSE 'D'
        END AS 工资级别
        FROM employees;
    
    ![在这里插入图片描述][20210508231648251.png]

### 分组函数 ###

**功能**：用作统计使用，又称为聚合函数或统计函数或组函数  
**分类**：  
sum 求和、avg 平均值、max 最大值 、min 最小值 、count 计算个数

**特点**：

1.  sum、avg一般用于处理数值型  
    max、min、count可以处理任何类型
2.  以上分组函数都忽略null值
3.  可以和distinct搭配实现去重的运算
4.  count函数的单独介绍  
    一般使用count(\*)用作统计行数
5.  和分组函数一同查询的字段要求是group by后的字段

1、简单的使用

SELECT SUM(salary) FROM employees;
    SELECT AVG(salary) FROM employees;
    SELECT MIN(salary) FROM employees;
    SELECT MAX(salary) FROM employees;
    SELECT COUNT(salary) FROM employees;
    
    SELECT SUM(salary) 和,AVG(salary) 平均,MAX(salary) 最高,MIN(salary) 最低,COUNT(salary) 个数
    FROM employees;
    
    SELECT SUM(salary) 和,ROUND(AVG(salary),2) 平均,MAX(salary) 最高,MIN(salary) 最低,COUNT(salary) 个数
    FROM employees;

2、参数支持哪些类型

SELECT SUM(last_name) ,AVG(last_name) FROM employees;#sum avg不支持字符型
    SELECT SUM(hiredate) ,AVG(hiredate) FROM employees;#没有意义
    
    SELECT MAX(last_name),MIN(last_name) FROM employees;#max min 支持字符型
    
    SELECT MAX(hiredate),MIN(hiredate) FROM employees;#支持日期
    
    SELECT COUNT(commission_pct) FROM employees; #count都支持，统计非空字段个数
    SELECT COUNT(last_name) FROM employees;

3、是否忽略null

SELECT SUM(commission_pct) ,AVG(commission_pct),SUM(commission_pct)/35,SUM(commission_pct)/107 FROM employees;
    
    SELECT MAX(commission_pct) ,MIN(commission_pct) FROM employees;
    
    SELECT COUNT(commission_pct) FROM employees;
    SELECT commission_pct FROM employees;

sum,avg,count,max,min都忽略null。

4、和distinct搭配

SELECT SUM(DISTINCT salary),SUM(salary) FROM employees;
    
    SELECT COUNT(DISTINCT salary),COUNT(salary) FROM employees;

5、count函数的详细介绍

SELECT COUNT(salary) FROM employees;
    
    SELECT COUNT(*) FROM employees;# 用来统计行数,使用最多。
    
    SELECT COUNT(1) FROM employees;# 相当于每一列前面都用1标识，统计有多少个1

效率：  
MYISAM存储引擎下 ，COUNT(\*)的效率高  
INNODB存储引擎下，COUNT(\*)和COUNT(1)的效率差不多，比COUNT(字段)要高一些  
6、和分组函数一同查询的字段有限制  
`SELECT AVG(salary),employee_id FROM employees;`

## 5. 分组查询 ##

**语法：**
    select 查询列表 ⑤
    from 表 ①
    【where 筛选条件】 ②
    group by 分组的字段  ③
    【having 筛选条件】 ④
    【order by 排序的字段】; ⑥ 【最后】
    注意：查询列表必须特殊，要求是分组函数和group by 后出现的字段

**特点：**  
1、和分组函数一同查询的字段必须是group by后出现的字段，也就是说 分组函数做条件肯定是放在having 子句中；  
2、筛选分为两类：分组前筛选和分组后筛选

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center">针对的表</th> 
   <th align="center">位置</th> 
   <th align="center">连接的关键字</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">分组前筛选</td> 
   <td align="center">原始表</td> 
   <td align="center">group by前</td> 
   <td align="center">where</td> 
  </tr> 
  <tr> 
   <td align="center">分组后筛选</td> 
   <td align="center">group by后的结果集</td> 
   <td align="center">group by后</td> 
   <td align="center">having</td> 
  </tr> 
 </tbody> 
</table>

问题1：分组函数做筛选能不能放在where后面
    答：不能
    
    问题2：where——group by——having
    一般来讲，能用分组前筛选的，尽量使用分组前筛选，提高效率

3、分组可以按单个字段也可以按多个字段，多个字段之间用逗号隔开，没有顺序要求，表达式或函数用的较少；  
4、也可以添加排序，排序放在整个分组查询的最后。

1.  简单的分组

#案例1：查询每个工种的员工平均工资
    SELECT AVG(salary),job_id
    FROM employees
    GROUP BY job_id;

#案例2：查询每个位置的部门个数
    
    SELECT COUNT(*),location_id
    FROM departments
    GROUP BY location_id;

1.  可以实现分组前的筛选
    
        select 查询列表 ④
         from 表 ①
         【where 筛选条件】 ②
         group by 分组的字段  ③

#案例1：查询邮箱中包含a字符的 每个部门的最高工资
    
    SELECT MAX(salary),department_id
    FROM employees
    WHERE email LIKE '%a%'
    GROUP BY department_id;

#案例2：查询每个领导手下有奖金的员工的平均工资
    
    SELECT AVG(salary),manager_id
    FROM employees
    WHERE commission_pct IS NOT NULL
    GROUP BY manager_id;

1.  分组后筛选
    
        select  查询列表 ⑤
         from 表 ①
         【where 筛选条件】 ②
         group by 分组的字段  ③
         having  筛选条件 ④

#案例：查询哪个部门的员工个数>5
    
    #①查询每个部门的员工个数
    SELECT COUNT(*),department_id
    FROM employees
    GROUP BY department_id;
    
    #②筛选刚才①结果
    
    SELECT COUNT(*),department_id
    FROM employees
    GROUP BY department_id
    HAVING COUNT(*)>5;

#案例2：每个工种有奖金的员工的最高工资>12000的工种编号和最高工资
    
    SELECT job_id,MAX(salary)
    FROM employees
    WHERE commission_pct IS NOT NULL
    GROUP BY job_id
    HAVING MAX(salary)>12000;

#案例3：领导编号>102的每个领导手下的最低工资大于5000的领导编号和最低工资
    
    SELECT manager_id,MIN(salary)
    FROM employees
    WHERE manager_id>102
    GROUP BY manager_id
    HAVING MIN(salary)>5000;

1.  添加排序

#案例：每个工种有奖金的员工的最高工资>6000的工种编号和最高工资,按最高工资升序
    
    SELECT job_id,MAX(salary) m
    FROM employees
    WHERE commission_pct IS NOT NULL
    GROUP BY job_id
    HAVING m>6000
    ORDER BY m ;

1.  按多个字段分组

#案例：查询每个工种每个部门的最低工资,并按最低工资降序
    
    SELECT MIN(salary),job_id,department_id
    FROM employees
    GROUP BY department_id,job_id
    ORDER BY MIN(salary) DESC;

## 6. 连接查询 ##

含义：又称多表查询，当查询的字段来自于多个表时，就会用到连接查询

笛卡尔乘积现象：表1 有m行，表2有n行，结果=m\*n行

发生原因：没有有效的连接条件  
如何避免：添加有效的连接条件

分类：

按年代分类：
    sql92标准:仅仅支持内连接
    sql99标准【推荐】：支持内连接+外连接（左外和右外）+交叉连接
    
    按功能分类：
    	内连接：
    		等值连接
    		非等值连接
    		自连接
    	外连接：
    		左外连接
    		右外连接
    		全外连接
    	交叉连接

`SELECT * FROM beauty;`  
`SELECT * FROM boys;`  
会发生连接混乱，要加上有效的条件。  
`SELECT NAME,boyName FROM boys,beauty WHERE beauty.boyfriend_id= boys.id;`  
![在这里插入图片描述][20210509182753516.png]

### sql92标准 ###

#### 1.等值连接 ####

语法：

select 查询列表
    from 表1 别名，表2 别名
    where 表1.key=表2.key
    【and 筛选条件】
    【group by 分组字段】
    【having 分组后的筛选】
    【order by 排序字段】

特点：

① 多表等值连接的结果为多表的交集部分
    ②n表连接，至少需要n-1个连接条件
    ③ 多表的顺序没有要求
    ④一般需要为表起别名
    ⑤可以搭配前面介绍的所有子句使用，比如排序、分组、筛选

1.  简单连接

#案例1：查询女神名和对应的男神名
    SELECT NAME,boyName 
    FROM boys,beauty
    WHERE beauty.boyfriend_id= boys.id;

#案例2：查询员工名和对应的部门名
    
    SELECT last_name,department_name
    FROM employees,departments
    WHERE employees.`department_id`=departments.`department_id`;

1.  为表起别名
    
        ①提高语句的简洁度
         ②区分多个重名的字段
        
         注意：如果为表起了别名，则查询的字段就不能使用原来的表名去限定

SELECT e.last_name,e.job_id,j.job_title
    FROM employees  e,jobs j
    WHERE e.`job_id`=j.`job_id`;

1.  两个表的顺序是否可以调换，可以

#查询员工名、工种号、工种名
    
    SELECT e.last_name,e.job_id,j.job_title
    FROM jobs j,employees e
    WHERE e.`job_id`=j.`job_id`;

1.  可以加筛选

#案例：查询有奖金的员工名、部门名
    
    SELECT last_name,department_name,commission_pct
    FROM employees e,departments d
    WHERE e.`department_id`=d.`department_id`
    AND e.`commission_pct` IS NOT NULL;

#案例2：查询城市名中第二个字符为o的部门名和城市名
    
    SELECT department_name,city
    FROM departments d,locations l
    WHERE d.`location_id` = l.`location_id`
    AND city LIKE '_o%';

1.  可以加分组

#案例1：查询每个城市的部门个数
    
    SELECT COUNT(*) 个数,city
    FROM departments d,locations l
    WHERE d.`location_id`=l.`location_id`
    GROUP BY city;

#案例2：查询有奖金的每个部门的部门名和部门的领导编号和该部门的最低工资
    SELECT department_name,d.`manager_id`,MIN(salary)
    FROM departments d,employees e
    WHERE d.`department_id`=e.`department_id`
    AND commission_pct IS NOT NULL
    GROUP BY department_name,d.`manager_id`;

1.  可以加排序

#案例：查询每个工种的工种名和员工的个数，并且按员工个数降序
    
    SELECT job_title,COUNT(*)
    FROM employees e,jobs j
    WHERE e.`job_id`=j.`job_id`
    GROUP BY job_title
    ORDER BY COUNT(*) DESC;

1.  可以实现三表连接

#案例：查询员工名、部门名和所在的城市
    
    SELECT last_name,department_name,city
    FROM employees e,departments d,locations l
    WHERE e.`department_id`=d.`department_id`
    AND d.`location_id`=l.`location_id`
    ORDER BY department_name DESC;

#### 2.非等值连接 ####

#案例1：查询员工的工资和工资级别
    
    SELECT salary,grade_level
    FROM employees e,job_grades g
    WHERE salary BETWEEN g.`lowest_sal` AND g.`highest_sal`

#### 3.自连接 ####

#案例：查询 员工名和上级的名称
    
    SELECT e.employee_id,e.last_name,m.employee_id,m.last_name
    FROM employees e,employees m
    WHERE e.`manager_id`=m.`employee_id`;

### sql99 标准 ###

语法：

select 查询列表
    from 表1 别名 【连接类型】
    join 表2 别名 
    on 连接条件
    【where 筛选条件】
    【group by 分组】
    【having 筛选条件】
    【order by 排序列表】

分类：

内连接（★）：inner
    外连接
    	左外(★):left 【outer】
    	右外(★)：right 【outer】
    	全外：full【outer】
    交叉连接：cross

#### 1. 内连接 ####

语法：

select 查询列表
    from 表1 别名
    inner join 表2 别名
    on 连接条件;

特点：

①添加排序、分组、筛选
    ②inner可以省略
    ③ 筛选条件放在where后面，连接条件放在on后面，提高分离性，便于阅读
    ④inner join连接和sql92语法中的等值连接效果是一样的，都是查询多表的交集

（一）等值连接

1.简单连接

#案例1.查询员工名、部门名
    
    SELECT last_name,department_name
    FROM departments d
    INNER JOIN  employees e
    ON e.`department_id` = d.`department_id`;

1.  添加筛选

#案例：查询名字中包含e的员工名和工种名
    SELECT last_name,job_title
    FROM employees e
    INNER JOIN jobs j
    ON e.`job_id`=  j.`job_id`
    WHERE e.`last_name` LIKE '%e%';

1.  添加分组+筛选

#案例:查询部门个数>3的城市名和部门个数，
    #①查询每个城市的部门个数
    #②在①结果上筛选满足条件的
    SELECT city,COUNT(*) 部门个数
    FROM departments d
    INNER JOIN locations l
    ON d.`location_id`=l.`location_id`
    GROUP BY city
    HAVING COUNT(*)>3;

1.  添加排序

#案例:查询哪个部门的员工个数>3的部门名和员工个数，并按个数降序
    
    SELECT COUNT(*) 个数,department_name
    FROM employees e
    INNER JOIN departments d
    ON e.`department_id`=d.`department_id`
    GROUP BY department_name
    HAVING COUNT(*)>3
    ORDER BY COUNT(*) DESC;

1.  添加三表连接

#案例：查询员工名、部门名、工种名，并按部门名降序
    
    SELECT last_name,department_name,job_title
    FROM employees e
    INNER JOIN departments d ON e.`department_id`=d.`department_id`
    INNER JOIN jobs j ON e.`job_id` = j.`job_id`
    ORDER BY department_name DESC;

（二）非等值连接

#查询员工的工资级别
    
    SELECT salary,grade_level
    FROM employees e
     JOIN job_grades g
     ON e.`salary` BETWEEN g.`lowest_sal` AND g.`highest_sal`;

#查询工资级别的个数>20的个数，并且按工资级别降序
    SELECT COUNT(*),grade_level
    FROM employees e
    JOIN job_grades g
    ON e.`salary` BETWEEN g.`lowest_sal` AND g.`highest_sal`
    GROUP BY grade_level
    HAVING COUNT(*)>20
    ORDER BY grade_level DESC;

（三）自连接

#查询员工的名字、上级的名字
     SELECT e.last_name,m.last_name
     FROM employees e
     JOIN employees m
     ON e.`manager_id`= m.`employee_id`;

#查询姓名中包含字符k的员工的名字、上级的名字
     SELECT e.last_name,m.last_name
     FROM employees e
     JOIN employees m
     ON e.`manager_id`= m.`employee_id`
     WHERE e.`last_name` LIKE '%k%';

#### 2. 外连接 ####

应用场景：用于查询一个表中有，另一个表没有的记录  
特点：

1、外连接的查询结果为主表中的所有记录
    	如果从表中有和它匹配的，则显示匹配的值
    	如果从表中没有和它匹配的，则显示null
    	外连接查询结果=内连接结果+主表中有而从表没有的记录
     2、左外连接，left join左边的是主表
        右外连接，right join右边的是主表
     3、左外和右外交换两个表的顺序，可以实现同样的效果 
     4、全外连接=内连接的结果+表1中有但表2没有的+表2中有但表1没有的

1.  左外连接

#案例：查询男朋友 不在男神表的的女神名
     SELECT b.*,bo.*
     FROM beauty b
     LEFT OUTER JOIN boys bo
     ON b.`boyfriend_id` = bo.`id`
     WHERE bo.`id` IS NULL;

#案例1：查询哪个部门没有员工
     #左外
     SELECT d.*,e.employee_id
     FROM departments d
     LEFT OUTER JOIN employees e
     ON d.`department_id` = e.`department_id`
     WHERE e.`employee_id` IS NULL;

1.  右外连接

# 右外连接
     SELECT b.*,bo.*
     FROM boys bo
     RIGHT OUTER JOIN beauty b
     ON b.`boyfriend_id` = bo.`id`
     WHERE bo.`id` IS NULL;

#右外
     
     SELECT d.*,e.employee_id
     FROM employees e
     RIGHT OUTER JOIN departments d
     ON d.`department_id` = e.`department_id`
     WHERE e.`employee_id` IS NULL;

#### 3. 交叉连接 ####

#交叉连接
     
     SELECT b.*,bo.*
     FROM beauty b
     CROSS JOIN boys bo;

**总结：**  
sql92和 sql99pk  
功能：sql99支持的较多  
可读性：sql99实现连接条件和筛选条件的分离，可读性较高

#### 4. 独有与全连接 ####

`select * from t1 left join t2 on t1.id = t2.id where t2.id is null;`【左表独有】  
`select * from t1 right join t2 on t1.id = t2.id where t1.id is null;`【右表独有】  
【全连接】

select * from t1 left join t2 on t1.id = t2.id
    union 
    select * from t1 right join t2 on t1.id = t2.id;

【并集去交集】

mysql> select * from t1 left join t2 on t1.id = t2.id where t2.id is null
        -> union 
        -> select * from t1 right join t2 on t1.id = t2.id where t1.id is null;

## 7. 子查询 ##

含义：  
出现在其他语句中的select语句，称为子查询或内查询  
外部的查询语句，称为主查询或外查询

分类：

按子查询出现的位置：
    	select后面：
    		仅仅支持标量子查询
    	from后面：
    		支持表子查询
    	where或having后面：★
    		标量子查询（单行） √
    		列子查询  （多行） √
    		
    		行子查询(较少)
    	exists后面（相关子查询）
    		表子查询
    按结果集的行列数不同：
    	标量子查询（结果集只有一行一列）
    	列子查询（结果集只有一列多行）
    	行子查询（结果集有一行多列）
    	表子查询（结果集一般为多行多列）

### 1. where或having后面 ###

1、标量子查询（单行子查询）  
2、列子查询（多行子查询）

3、行子查询（多列多行）

特点：  
①子查询放在小括号内  
②子查询一般放在条件的右侧  
③标量子查询，一般搭配着单行操作符使用`> < >= <= = <>`

列子查询，一般搭配着多行操作符使用  
in、any/some、all

④子查询的执行优先于主查询执行，主查询的条件用到了子查询的结果

1.  标量子查询★

#案例1：谁的工资比 Abel 高?
    
    #①查询Abel的工资
    SELECT salary
    FROM employees
    WHERE last_name = 'Abel'
    
    #②查询员工的信息，满足 salary>①结果
    SELECT *
    FROM employees
    WHERE salary>(
    
    	SELECT salary
    	FROM employees
    	WHERE last_name = 'Abel'
    
    );

#案例2：返回job_id与141号员工相同，salary比143号员工多的员工 姓名，job_id 和工资
    
    #①查询141号员工的job_id
    SELECT job_id
    FROM employees
    WHERE employee_id = 141
    
    #②查询143号员工的salary
    SELECT salary
    FROM employees
    WHERE employee_id = 143
    
    #③查询员工的姓名，job_id 和工资，要求job_id=①并且salary>②
    
    SELECT last_name,job_id,salary
    FROM employees
    WHERE job_id = (
    	SELECT job_id
    	FROM employees
    	WHERE employee_id = 141
    ) AND salary>(
    	SELECT salary
    	FROM employees
    	WHERE employee_id = 143
    
    );

#案例3：返回公司工资最少的员工的last_name,job_id和salary
    
    #①查询公司的 最低工资
    SELECT MIN(salary)
    FROM employees
    
    #②查询last_name,job_id和salary，要求salary=①
    SELECT last_name,job_id,salary
    FROM employees
    WHERE salary=(
    	SELECT MIN(salary)
    	FROM employees
    );

#案例4：查询最低工资大于50号部门最低工资的部门id和其最低工资
    
    #①查询50号部门的最低工资
    SELECT  MIN(salary)
    FROM employees
    WHERE department_id = 50
    
    #②查询每个部门的最低工资
    
    SELECT MIN(salary),department_id
    FROM employees
    GROUP BY department_id
    
    #③ 在②基础上筛选，满足min(salary)>①
    SELECT MIN(salary),department_id
    FROM employees
    GROUP BY department_id
    HAVING MIN(salary)>(
    	SELECT  MIN(salary)
    	FROM employees
    	WHERE department_id = 50
    
    );

1.  列子查询（多行子查询）★

*  返回多行
 *  使用多行操作符
 *  体会any和all，<ALL等价于<min，<any等价于<max，
 *  > ALL等价于>max，>any等价于>min，=ANY 等价于in  
    > ![在这里插入图片描述][20210510211102358.png]

#案例1：返回location_id是1400或1700的部门中的所有员工姓名
    
    #①查询location_id是1400或1700的部门编号
    SELECT DISTINCT department_id
    FROM departments
    WHERE location_id IN(1400,1700)
    
    #②查询员工姓名，要求部门号是①列表中的某一个
    
    SELECT last_name
    FROM employees
    WHERE department_id  IN(
    	SELECT DISTINCT department_id
    	FROM departments
    	WHERE location_id IN(1400,1700)
    
    
    );

#案例2：返回其它工种中比job_id为‘IT_PROG’工种任一工资低的员工的员工号、姓名、job_id 以及salary
    
    #①查询job_id为‘IT_PROG’部门任一工资
    
    SELECT DISTINCT salary
    FROM employees
    WHERE job_id = 'IT_PROG'
    
    #②查询员工号、姓名、job_id 以及salary，salary<(①)的任意一个
    SELECT last_name,employee_id,job_id,salary
    FROM employees
    WHERE salary<ANY(
    	SELECT DISTINCT salary
    	FROM employees
    	WHERE job_id = 'IT_PROG'
    
    ) AND job_id<>'IT_PROG';
    
    #或
    SELECT last_name,employee_id,job_id,salary
    FROM employees
    WHERE salary<(
    	SELECT MAX(salary)
    	FROM employees
    	WHERE job_id = 'IT_PROG'
    
    ) AND job_id<>'IT_PROG';

#案例3：返回其它部门中比job_id为‘IT_PROG’部门所有工资都低的员工   的员工号、姓名、job_id 以及salary
    
    SELECT last_name,employee_id,job_id,salary
    FROM employees
    WHERE salary<ALL(
    	SELECT DISTINCT salary
    	FROM employees
    	WHERE job_id = 'IT_PROG'
    
    ) AND job_id<>'IT_PROG';
    
    #或
    
    SELECT last_name,employee_id,job_id,salary
    FROM employees
    WHERE salary<(
    	SELECT MIN( salary)
    	FROM employees
    	WHERE job_id = 'IT_PROG'
    
    ) AND job_id<>'IT_PROG';

1.  行子查询（结果集一行多列或多行多列）

#案例：查询员工编号最小并且工资最高的员工信息
    
    SELECT * 
    FROM employees
    WHERE (employee_id,salary)=(
    	SELECT MIN(employee_id),MAX(salary)
    	FROM employees
    );
    
    #①查询最小的员工编号
    SELECT MIN(employee_id)
    FROM employees
    
    
    #②查询最高工资
    SELECT MAX(salary)
    FROM employees
    
    
    #③查询员工信息
    SELECT *
    FROM employees
    WHERE employee_id=(
    	SELECT MIN(employee_id)
    	FROM employees
    	
    )AND salary=(
    	SELECT MAX(salary)
    	FROM employees
    
    );

### 2. select后面 ###

**仅仅支持标量子查询**

#案例：查询每个部门的员工个数
    
    SELECT d.*,(
    
    	SELECT COUNT(*)
    	FROM employees e
    	WHERE e.department_id = d.`department_id`
     ) 个数
     FROM departments d;

#案例2：查询员工号=102的部门名
    
    SELECT (
       SELECT department_name,e.department_id
       FROM departments d
       INNER JOIN employees e
       ON d.department_id=e.department_id
       WHERE e.employee_id=102
       
    ) 部门名;

### 3.from后面 ###

**将子查询结果充当一张表，要求必须起别名**

案例：查询每个部门的平均工资的工资等级
    #①查询每个部门的平均工资
    SELECT AVG(salary),department_id
    FROM employees
    GROUP BY department_id
    
    
    SELECT * FROM job_grades;
    
    
    #②连接①的结果集和job_grades表，筛选条件平均工资 between lowest_sal and highest_sal
    
    SELECT  ag_dep.*,g.`grade_level`
    FROM (
    	SELECT AVG(salary) ag,department_id
    	FROM employees
    	GROUP BY department_id
    ) ag_dep
    INNER JOIN job_grades g
    ON ag_dep.ag BETWEEN lowest_sal AND highest_sal;

### 4. exists后面（相关子查询） ###

语法：

exists(完整的查询语句)
    结果：
    1或0

`SELECT EXISTS(SELECT employee_id FROM employees WHERE salary=300000);`

#案例1：查询有员工的部门名
    
    #in
    SELECT department_name
    FROM departments d
    WHERE d.`department_id` IN(
    	SELECT department_id
    	FROM employees
    
    )
    #exists
    
    SELECT department_name
    FROM departments d
    WHERE EXISTS(
    	SELECT *
    	FROM employees e
    	WHERE d.`department_id`=e.`department_id`
    );

#案例2：查询没有女朋友的男神信息
    
    #in
    
    SELECT bo.*
    FROM boys bo
    WHERE bo.id NOT IN(
    	SELECT boyfriend_id
    	FROM beauty
    )
    
    #exists
    SELECT bo.*
    FROM boys bo
    WHERE NOT EXISTS(
    	SELECT boyfriend_id
    	FROM beauty b
    	WHERE bo.`id`=b.`boyfriend_id`
    
    );

## 8. 分页查询 ##

应用场景：当要显示的数据，一页显示不全，需要分页提交sql请求  
语法：

select 查询列表 ⑦
    from 表 ①
    【join type join 表2】 ②
    on 连接条件 ③
    where 筛选条件 ④
    group by 分组字段 ⑤
    having 分组后的筛选 ⑥
    order by 排序的字段】⑧
    limit 【offset,】size; ⑨
    
    offset要显示条目的起始索引（起始索引从0开始）
    size 要显示的条目个数

特点：  
①limit语句放在查询语句的最后  
②公式  
要显示的页数 page，每页的条目数size

select 查询列表
    from 表
    limit (page-1)*size,size;
    
    size=10
    page  
    1	0
    2  	10
    3	20

#案例1：查询前五条员工信息
    
    SELECT * FROM  employees LIMIT 0,5;
    SELECT * FROM  employees LIMIT 5;
    
    #案例2：查询第11条——第25条
    SELECT * FROM  employees LIMIT 10,15;
    
    #案例3：有奖金的员工信息，并且工资较高的前10名显示出来
    SELECT 
        * 
    FROM
        employees 
    WHERE commission_pct IS NOT NULL 
    ORDER BY salary DESC 
    LIMIT 10 ;

## 9. 联合查询 ##

union 联合 合并：将多条查询语句的结果合并成一个结果

语法：
    查询语句1
    union
    查询语句2
    union

…

**应用场景：**  
要查询的结果来自于多个表，且多个表没有直接的连接关系，但查询的信息一致时

特点：★

1、要求多条查询语句的查询列数是一致的！
    2、要求多条查询语句的查询的每一列的类型和顺序最好一致
    3、union关键字默认去重，如果使用union all 可以包含重复项

#引入的案例：查询部门编号>90或邮箱包含a的员工信息
    
    SELECT * FROM employees WHERE email LIKE '%a%' OR department_id>90;;
    
    SELECT * FROM employees  WHERE email LIKE '%a%'
    UNION
    SELECT * FROM employees  WHERE department_id>90;

#案例：查询中国用户中男性的信息以及外国用户中年男性的用户信息
    
    SELECT id,cname FROM t_ca WHERE csex='男'
    UNION ALL
    SELECT t_id,tname FROM t_ua WHERE tGender='male';

## 10. 查询总结 ##

语法：

select 查询列表    ⑦
    from 表1 别名       ①
    连接类型 join 表2   ②
    on 连接条件         ③
    where 筛选          ④
    group by 分组列表   ⑤
    having 筛选         ⑥
    order by排序列表    ⑧
    limit 起始条目索引，条目数;  ⑨

# DML语言的学习 #

DML(Data Manipulation Language,数据操作语言）对数据进行增加、修改、删除，如insert、udpate、delete。  
数据操作语言：

## 插入操作 ##

语法

insert into 表名(列名,...) values(值1,...);

### 方式一： 经典插入 ###

1.  插入的值的类型要与列的类型一致或兼容

INSERT INTO beauty(id,NAME,sex,borndate,phone,photo,boyfriend_id)
    VALUES(13,'唐艺昕','女','1990-4-23','1898888888',NULL,2);

1.  不可以为null的列必须插入值。可以为null的列如何插入值？

#方式一：字段写上，值使用null
    INSERT INTO beauty(id,NAME,sex,borndate,phone,photo,boyfriend_id)
    VALUES(13,'唐艺昕','女','1990-4-23','1898888888',NULL,2);
    
    #方式二：直接不列列名,字段和值都省略
    
    INSERT INTO beauty(id,NAME,sex,phone)
    VALUES(15,'娜扎','女','1388888888');

1.  列的顺序是否可以调换？可以

INSERT INTO beauty(NAME,sex,id,phone)
    VALUES('蒋欣','女',16,'110');

1.  列数和值的个数必须一致

INSERT INTO beauty(NAME,sex,id,phone)
    VALUES('关晓彤','女',17,'110');

1.  可以省略列名，默认所有列，而且列的顺序和表中列的顺序一致

VALUES(18,'张飞','男',NULL,'119',NULL,NULL);

### 方式二：字段名插入 ###

语法：

insert into 表名
    set 列名=值,列名=值,...

INSERT INTO beauty
    SET id=19,NAME='刘涛',phone='999';

### 两种方式对比 ###

1、方式一支持插入多行,方式二不支持

insert into 表名【(字段名,..)】 values(值，..),(值，...),...;

INSERT INTO beauty
    VALUES(23,'唐艺昕1','女','1990-4-23','1898888888',NULL,2),
    (24,'唐艺昕2','女','1990-4-23','1898888888',NULL,2),
    (25,'唐艺昕3','女','1990-4-23','1898888888',NULL,2);

2、方式一支持子查询，方式二不支持

insert into 表名
    查询语句;

INSERT INTO beauty(id,NAME,phone)
    SELECT 26,'宋茜','11809866';
    
    INSERT INTO beauty(id,NAME,phone)
    SELECT id,boyname,'1234567'
    FROM boys WHERE id<3;

### 常用的三种插入数据的语句 ###

1.  insert into表示插入数据，数据库会检查主键，如果出现重复会报错；
2.  replace into表示插入替换数据，若表中有PrimaryKey，或者unique索引，如果数据库已经存在数据，则用新数据替换，如果没有数据效果则和insert into一样；
3.  insert ignore表示，如果中已经存在相同的记录，则忽略当前新数据；

## 修改操作 ##

1.修改单表的记录★

语法：
    update 表名
    set 列=新值,列=新值,...
    where 筛选条件;

#案例1：修改beauty表中姓唐的女神的电话为13899888899
    
    UPDATE beauty SET phone = '13899888899'
    WHERE NAME LIKE '唐%';
    
    #案例2：修改boys表中id好为2的名称为张飞，魅力值 10
    UPDATE boys SET boyname='张飞',usercp=10
    WHERE id=2;

2.修改多表的记录【补充】

语法：

sql92语法：
    update 表1 别名,表2 别名
    set 列=值,...
    where 连接条件
    and 筛选条件;
    
    sql99语法：
    update 表1 别名
    inner|left|right join 表2 别名
    on 连接条件
    set 列=值,...
    where 筛选条件;

#案例 1：修改张无忌的女朋友的手机号为114
    UPDATE boys bo
    INNER JOIN beauty b ON bo.`id`=b.`boyfriend_id`
    SET b.`phone`='119',bo.`userCP`=1000
    WHERE bo.`boyName`='张无忌';

#案例2：修改没有男朋友的女神的男朋友编号都为2号
    
    UPDATE boys bo
    RIGHT JOIN beauty b ON bo.`id`=b.`boyfriend_id`
    SET b.`boyfriend_id`=2
    WHERE bo.`id` IS NULL;

## 删除操作 ##

### 方式一：delete ###

语法：

1、单表的删除【★】

delete from 表名 where 筛选条件 【limit 条目数】

#案例：删除手机号以9结尾的女神信息
    DELETE FROM beauty WHERE phone LIKE '%9';
    SELECT * FROM beauty;

DELETE FROM  beauty WHERE boyfriendid=4 limit 1;

2、多表的删除【补充】

sql92语法：
    delete 表1的别名,表2的别名
    from 表1 别名,表2 别名
    where 连接条件
    and 筛选条件;
    
    sql99语法：
    delete 表1的别名,表2的别名
    from 表1 别名
    inner|left|right join 表2 别名 on 连接条件
    where 筛选条件;

#案例：删除张无忌的女朋友的信息
    
    DELETE b
    FROM beauty b
    INNER JOIN boys bo ON b.`boyfriend_id` = bo.`id`
    WHERE bo.`boyName`='张无忌';

#案例：删除黄晓明的信息以及他女朋友的信息
    DELETE b,bo
    FROM beauty b
    INNER JOIN boys bo ON b.`boyfriend_id`=bo.`id`
    WHERE bo.`boyName`='黄晓明';

### 方式二：truncate ###

语法：truncate table 表名;

#案例：将魅力值>100的男神信息删除
    TRUNCATE TABLE boys ;

### 经典面试题：delete pk truncate【★★★】 ###

1.delete 可以加where 条件，truncate不能加  
2.truncate删除，效率高一丢丢  
3.假如要删除的表中有自增长列，  
如果用delete删除后，再插入数据，自增长列的值从断点开始，  
而truncate删除后，再插入数据，自增长列的值从1开始。表结构被删除。  
4.truncate删除没有返回值，delete删除有返回值  
5.truncate删除不能回滚，delete删除可以回滚.

SELECT * FROM boys;
    
    DELETE FROM boys;
    TRUNCATE TABLE boys;
    INSERT INTO boys (boyname,usercp)
    VALUES('张飞',100),('刘备',100),('关云长',100);

# DDL语言的学习 #

DDL(Data Defination Language,数据定义语言）进行数据库、表的管理等，如create、drop

一、库的管理  
创建、修改、删除  
二、表的管理  
创建、修改、删除

创建： create  
修改： alter  
删除： drop

## 库的管理 ##

1、库的创建

语法：  
`create database [if not exists]库名 [character set 字符集名];`

#案例：创建库Books
    CREATE DATABASE IF NOT EXISTS books ;

2、库的修改

#更改库的字符集
    ALTER DATABASE books CHARACTER SET gbk;

3、库的删除

DROP DATABASE IF EXISTS books;

## 表的管理 ##

### 1.表的创建 ★ ###

语法：

create table 表名(
    	列名 列的类型【(长度) 约束】,
    	列名 列的类型【(长度) 约束】,
    	列名 列的类型【(长度) 约束】,
    	...
    	列名 列的类型【(长度) 约束】）

#案例：创建表Book
    
    CREATE TABLE book(
    	id INT,#编号
    	bName VARCHAR(20),#图书名
    	price DOUBLE,#价格
    	authorId  INT,#作者编号
    	publishDate DATETIME#出版日期
    );

#案例：创建表author
    CREATE TABLE IF NOT EXISTS author(
    	id INT,
    	au_name VARCHAR(20),
    	nation VARCHAR(10)
    
    )
    DESC author;

### 2. 表的修改 ###

alter table 表名 add|drop|modify|change column 列名 【列类型 约束】;
    column 可加可不加

1.添加列
    alter table 表名 add column 列名 类型 【first|after 字段名】;
    2.修改列的类型或约束
    alter table 表名 modify column 列名 新类型 【新约束】;
    3.修改列名
    alter table 表名 change column 旧列名 新列名 类型;
    4 .删除列
    alter table 表名 drop column 列名;
    5.修改表名
    alter table 表名 rename 【to】 新表名;

#①修改列名
    ALTER TABLE book CHANGE COLUMN publishdate pubDate DATETIME;
    
    #②修改列的类型或约束
    ALTER TABLE book MODIFY COLUMN pubdate TIMESTAMP;
    
    #③添加新列
    ALTER TABLE author ADD COLUMN annual DOUBLE; 
    
    #④删除列
    ALTER TABLE book_author DROP COLUMN  annual;
    
    #⑤修改表名
    ALTER TABLE author RENAME TO book_author;

### 3. 表的删除 ###

DROP TABLE IF EXISTS book_author;
    SHOW TABLES;

#通用的写法：
    
    DROP DATABASE IF EXISTS 旧库名;
    CREATE DATABASE 新库名;
    
    DROP TABLE IF EXISTS 旧表名;
    CREATE TABLE  表名();

### 4. 表的复制 ###

#1.仅仅复制表的结构
    CREATE TABLE copy LIKE author;

#2.复制表的结构+数据
    CREATE TABLE copy2 
    SELECT * FROM author;

#3.只复制部分数据
    CREATE TABLE copy3
    SELECT id,au_name
    FROM author 
    WHERE nation='中国';

#4.仅仅复制某些字段
    
    CREATE TABLE copy4 
    SELECT id,au_name
    FROM author
    WHERE 0;

## 常见的数字类型 ##

**原则：所选择的类型越简单越好，能保存数值的型越小越好**

数值型：
    	整型
    	小数：
    		定点数
    		浮点数
    字符型：
    	较短的文本：char、varchar
    	较长的文本：text、blob（较长的二进制数据）
    日期型：

### 1. 整型 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 9]  
特点：

① 都可以设置有符号和无符号，如果不设置无符号还是有符号，默认是有符号，如果想设置无符号，需要添加unsigned关键字
    ② 如果插入的数值超出了整型的范围,会报out of range异常，并且插入临界值
    ③ 如果不设置长度，会有默认的长度
    长度代表了显示的最大宽度，如果不够会用0在左边填充，但必须搭配zerofill使用！

# 如何设置无符号和有符号
    
    DROP TABLE IF EXISTS tab_int;
    CREATE TABLE tab_int(
    	t1 INT(7) ZEROFILL,
    	t2 INT(7) ZEROFILL 
    
    );
    
    DESC tab_int;
    
    
    INSERT INTO tab_int VALUES(-123456);
    INSERT INTO tab_int VALUES(-123456,-123456);
    INSERT INTO tab_int VALUES(214748364894967296);
    
    INSERT INTO tab_int VALUES(123,123);
    SELECT * FROM tab_int;

### 2. 小数 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 10]  
分类：

1.浮点型
    float(M,D) 
    double(M,D)
    2.定点型
    dec(M，D)
    decimal(M,D)

特点：

①
    M：整数部位+小数部位
    D：小数部位
    如果超过范围，则插入临界值
    ②
    M和D都可以省略
    如果是decimal，则M默认为10，D默认为0
    如果是float和double，则会根据插入的数值的精度来决定精度
    float默认M为6，D为3
    ③定点型的精确度较高，如果要求插入数值的精度较高如货币运算等则考虑使用

#测试M和D
    
    DROP TABLE tab_float;
    CREATE TABLE tab_float(
    	f1 FLOAT,
    	f2 DOUBLE,
    	f3 DECIMAL
    );
    
    CREATE TABLE tab_float(
    	f1 FLOAT(5,2),
    	f2 DOUBLE(5,2),
    	f3 DECIMAL(5,2)
    );
    
    SELECT * FROM tab_float;
    DESC tab_float;
    
    INSERT INTO tab_float VALUES(123.4523,123.4523,123.4523);
    INSERT INTO tab_float VALUES(123.456,123.456,123.456);
    INSERT INTO tab_float VALUES(123.4,123.4,123.4);
    INSERT INTO tab_float VALUES(1523.4,1523.4,1523.4);

### 3. 字符型 ###

较短的文本：⭐
    	char
    	varchar
    
    其他：
    	binary和varbinary用于保存较短的二进制
    	enum用于保存枚举
    	set用于保存集合
    
    较长的文本：
    	text
    	blob(较大的二进制)

![在这里插入图片描述][20210512163537769.png]

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th align="center">写法</th> 
   <th align="center">M的意思</th> 
   <th align="center">特点</th> 
   <th align="center">空间的耗费</th> 
   <th align="center">效率</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>char</td> 
   <td align="center">char(M)</td> 
   <td align="center">最大的字符数，可以省略，默认为1</td> 
   <td align="center">固定长度的字符</td> 
   <td align="center">比较耗费</td> 
   <td align="center">高</td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td align="center">varchar(M)</td> 
   <td align="center">最大的字符数，不可以省略</td> 
   <td align="center">可变长度的字符</td> 
   <td align="center">比较节省</td> 
   <td align="center">低</td> 
  </tr> 
 </tbody> 
</table>

CREATE TABLE tab_char(
    a_char CHAR,
    b_char VARCHAR(10)
    )
    
    SELECT * FROM tab_char;
    
    INSERT INTO tab_char VALUES('中国','中国');
    INSERT INTO tab_char(b_char) VALUES('中国');

![在这里插入图片描述][20210512164858299.png]

CREATE TABLE tab_enum(
    	c1 ENUM('a','b','c')
    );
    SELECT * FROM tab_enum;
    
    INSERT INTO tab_enum VALUES('a');
    INSERT INTO tab_enum VALUES('b');
    INSERT INTO tab_enum VALUES('c');
    INSERT INTO tab_enum VALUES('m');
    INSERT INTO tab_enum VALUES('A');

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 11]

CREATE TABLE tab_set(
    	s1 SET('a','b','c','d')
    );
    INSERT INTO tab_set VALUES('a');
    INSERT INTO tab_set VALUES('A,B');
    INSERT INTO tab_set VALUES('a,c,d');
    
    SELECT * FROM tab_set;

### 4. 日期型 ###

分类：

date保存日期
    time 只保存时间
    year只保存年
    
    datetime保存日期+时间
    timestamp保存日期+时间

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 12]  
特点：

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>字节</th> 
   <th>范围</th> 
   <th>时区等的影响</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>datetime</td> 
   <td>8</td> 
   <td>1000——9999</td> 
   <td>不受</td> 
  </tr> 
  <tr> 
   <td>timestamp</td> 
   <td>4</td> 
   <td>1970-2038</td> 
   <td>受</td> 
  </tr> 
 </tbody> 
</table>

datetime 和timestamp的区别：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 13]

CREATE TABLE tab_date(
    	t1 DATETIME,
    	t2 TIMESTAMP
    
    );
    
    INSERT INTO tab_date VALUES(NOW(),NOW());
    
    SELECT * FROM tab_date;
    SHOW VARIABLES LIKE 'time_zone';
    
    SET time_zone='+9:00';

![在这里插入图片描述][20210512172411617.png]

修改时区后：  
![在这里插入图片描述][20210512171709780.png]  
![在这里插入图片描述][20210512172458160.png]

## 常见约束 ##

含义：

一种限制，用于限制表中的数据，为了保证表中的数据的准确和可靠性

分类：六大约束

NOT NULL：非空，用于保证该字段的值不能为空
    	比如姓名、学号等
    DEFAULT:默认，用于保证该字段有默认值
    	比如性别
    PRIMARY KEY:主键，用于保证该字段的值具有唯一性，并且非空
    	比如学号、员工编号等
    UNIQUE:唯一，用于保证该字段的值具有唯一性，可以为空
    	比如座位号
    CHECK:检查约束【mysql中不支持】
    	比如年龄、性别
    FOREIGN KEY:外键，用于限制两个表的关系，用于保证该字段的值必须来自于主表的关联列的值
    【为什么要创建外键约束】
    FOREIGN KEY 约束用于预防破坏表之间连接的行为。 FOREIGN KEY 约束也能防止非法数据插入外键列，因为它必须是它指向的那个表中的值之一。
    	在从表添加外键约束，用于引用主表中某列的值
    	比如学生表的专业编号，员工表的部门编号，员工表的工种编号

添加约束的时机：

1.创建表时
    2.修改表时

约束的添加分类：

列级约束：
    	六大约束语法上都支持，但外键约束没有效果。列的后面。不可以起约束名。
    表级约束：
    	除了非空、默认，其他的都支持。所有列的下面。可以（主键没效果）

主键和唯一的大对比：

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>保证唯一性</th> 
   <th>是否允许为空</th> 
   <th>一个表中可以有多少个</th> 
   <th>是否允许组合</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>主键</td> 
   <td>√</td> 
   <td>×</td> 
   <td>至多有1个</td> 
   <td>√，但不推荐</td> 
  </tr> 
  <tr> 
   <td>唯一</td> 
   <td>√</td> 
   <td>√</td> 
   <td>可以有多个</td> 
   <td>√，但不推荐</td> 
  </tr> 
 </tbody> 
</table>

外键：

1、要求在从表设置外键关系
    2、从表的外键列的类型和主表的关联列的类型要求一致或兼容，名称无要求
    3、主表的关联列必须是一个key（一般是主键或唯一）
    4、插入数据时，先插入主表，再插入从表
    删除数据时，先删除从表，再删除主表

### 一、创建表时添加约束 ###

1.  添加列级约束

语法：

直接在字段名和类型后面追加 约束类型即可。
    只支持：默认、非空、主键、唯一

CREATE TABLE 表名(
    	字段名 字段类型 列级约束,
    	字段名 字段类型,
    	表级约束
    )

# 案例
    CREATE DATABASE students;
    USE students;
    DROP TABLE stuinfo;
    CREATE TABLE stuinfo(
    	id INT PRIMARY KEY,#主键
    	stuName VARCHAR(20) NOT NULL UNIQUE,#非空
    	gender CHAR(1) CHECK(gender='男' OR gender ='女'),#检查
    	seat INT UNIQUE,#唯一
    	age INT DEFAULT  18,#默认约束
    	majorId INT REFERENCES major(id)#外键
    
    );
    
    
    CREATE TABLE major(
    	id INT PRIMARY KEY,
    	majorName VARCHAR(20)
    );
    
    #查看stuinfo中的所有索引，包括主键、外键、唯一
    SHOW INDEX FROM stuinfo;

1.  添加表级约束

语法：

在各个字段的最下面
    【constraint 约束名】 约束类型(字段名)

# 案例
    DROP TABLE IF EXISTS stuinfo;
    CREATE TABLE stuinfo(
    	id INT,
    	stuname VARCHAR(20),
    	gender CHAR(1),
    	seat INT,
    	age INT,
    	majorid INT,
    	
    	CONSTRAINT pk PRIMARY KEY(id),#主键
    	CONSTRAINT uq UNIQUE(seat),#唯一键
    	CONSTRAINT ck CHECK(gender ='男' OR gender  = '女'),#检查
    	CONSTRAINT fk_stuinfo_major FOREIGN KEY(majorid) REFERENCES major(id)#外键
    	
    );
    
    SHOW INDEX FROM stuinfo;

# 1.添加主键
    ALTER TABLE tbl_name ADD PRIMARY KEY (col_list);
    // 该语句添加一个主键，这意味着索引值必须是唯一的，且不能为NULL。
    # 2.添加唯一索引
    ALTER TABLE tbl_name ADD UNIQUE index_name (col_list);
    // 这条语句创建索引的值必须是唯一的。
    # 3. 添加普通索引
    ALTER TABLE tbl_name ADD INDEX index_name (col_list);
    // 添加普通索引，索引值可出现多次。
    # 4. 添加全文索引
    ALTER TABLE tbl_name ADD FULLTEXT index_name (col_list);
    // 该语句指定了索引为 FULLTEXT ，用于全文索引。
    # 5. 删除索引
    DROP INDEX index_name ON tbl_name;
    // 或者
    ALTER TABLE tbl_name DROP INDEX index_name；
    ALTER TABLE tbl_name DROP PRIMARY KEY;

通用的写法：★

CREATE TABLE IF NOT EXISTS stuinfo(
    	id INT PRIMARY KEY,
    	stuname VARCHAR(20),
    	sex CHAR(1),
    	age INT DEFAULT 18,
    	seat INT UNIQUE,
    	majorid INT,
    	CONSTRAINT fk_stuinfo_major FOREIGN KEY(majorid) REFERENCES major(id)
    
    );

### 二、修改表时添加约束 ###

1、添加列级约束
    alter table 表名 modify column 字段名 字段类型 新约束;
    
    2、添加表级约束
    alter table 表名 add 【constraint 约束名】 约束类型(字段名) 【外键的引用】;

DROP TABLE IF EXISTS stuinfo;
    CREATE TABLE stuinfo(
    	id INT,
    	stuname VARCHAR(20),
    	gender CHAR(1),
    	seat INT,
    	age INT,
    	majorid INT
    )
    DESC stuinfo;
    #1.添加非空约束
    ALTER TABLE stuinfo MODIFY COLUMN stuname VARCHAR(20)  NOT NULL;
    #2.添加默认约束
    ALTER TABLE stuinfo MODIFY COLUMN age INT DEFAULT 18;
    #3.添加主键
    #①列级约束
    ALTER TABLE stuinfo MODIFY COLUMN id INT PRIMARY KEY;
    #②表级约束
    ALTER TABLE stuinfo ADD PRIMARY KEY(id);
    
    #4.添加唯一
    #①列级约束
    ALTER TABLE stuinfo MODIFY COLUMN seat INT UNIQUE;
    #②表级约束
    ALTER TABLE stuinfo ADD UNIQUE(seat);
    
    #5.添加外键
    ALTER TABLE stuinfo ADD CONSTRAINT fk_stuinfo_major FOREIGN KEY(majorid) REFERENCES major(id);

### 三、修改表时删除约束 ###

#1.删除非空约束
    ALTER TABLE stuinfo MODIFY COLUMN stuname VARCHAR(20) NULL;
    
    #2.删除默认约束
    ALTER TABLE stuinfo MODIFY COLUMN age INT ;
    
    #3.删除主键
    ALTER TABLE stuinfo DROP PRIMARY KEY;
    或 ALTER TABLE stuinfo MODIFY COLUMN id INT ;
    #4.删除唯一
    ALTER TABLE stuinfo DROP INDEX seat;
    
    #5.删除外键
    ALTER TABLE stuinfo DROP FOREIGN KEY fk_stuinfo_major;
    
    SHOW INDEX FROM stuinfo;

### 四、标识列 ###

又称为自增长列  
含义：可以不用手动的插入值，系统提供默认的序列值

特点：

1、标识列必须和主键搭配吗？不一定，但要求是一个key
    2、一个表可以有几个标识列？至多一个！
    3、标识列的类型只能是数值型
    4、标识列可以通过 SET auto_increment_increment=3;设置步长
    可以通过 手动插入值，设置起始值

一、创建表时设置标识列

DROP TABLE IF EXISTS tab_identity;
    CREATE TABLE tab_identity(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20)
    
    );
    INSERT INTO tab_identity(id,NAME) VALUES(NULL,'john');
    
    INSERT INTO tab_identity VALUES(1,'john');
    INSERT INTO tab_identity VALUES(3,'jon');
    # 设置为null时，会自增长，如给定值，则会使用给定值。可使用给定值设置起始值
    
    INSERT INTO tab_identity(NAME) VALUES('lucy');
    SELECT * FROM tab_identity;
    
    SHOW VARIABLES LIKE '%auto_increment%';
    
    SET auto_increment_increment=3;

![在这里插入图片描述][20210513164504563.png]  
设置步长后：  
![在这里插入图片描述][20210513164732499.png]  
二、创修改表时设置标识列  
`ALTER TABLE tab_identity MODIFY COLUMN id INT PRIMARY KEY AUTO_INCREMENT;`  
三、修改表时删除标识列  
`ALTER TABLE tab_identity MODIFY COLUMN id INT PRIMARY KEY;`

# TCL语言的学习 #

TCL(Transaction Control Language,事务控制语言)  
事务：  
一个或一组sql语句组成一个执行单元，这个执行单元要么全部执行，要么全部不执行。![在这里插入图片描述][2021051317004614.png]

### 经典面试题：事务的特性【★★★】 ###

ACID
    原子性（Atomicity）：一个事务不可再分割，要么都执行要么都不执行
    一致性（consistency）：一个事务执行会使数据从一个一致状态切换到另外一个一致状态
    隔离性（Isolation）：一个事务的执行不受其他事务的干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
    持久性（Durability）：一个事务一旦提交，则会永久的改变数据库的数据.

事务的创建

隐式事务：事务没有明显的开启和结束的标记
    比如insert、update、delete语句
    delete from 表 where id =1;
    
    显式事务：事务具有明显的开启和结束的标记
    前提：必须先设置自动提交功能为禁用
    SHOW VARIABLES LIKE 'autocommit';
    set autocommit=0;

事务创建的步骤：

步骤1：开启事务
    set autocommit=0;
    start transaction;可选的
    
    步骤2：编写事务中的sql语句(select insert update delete)
    语句1;
    语句2;
    ...
    
    步骤3：结束事务
    commit;提交事务
    rollback;回滚事务
    
    savepoint 节点名;设置保存点

### 经典面试题：事务的并发问题【★★★】 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 14]

### 经典面试题：数据库的事务隔离级别【★★★】 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 15]  
事务的隔离级别：

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>脏读</th> 
   <th>不可重复读</th> 
   <th>幻读</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>read uncommitted</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>read committed</td> 
   <td>×</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>repeatable read</td> 
   <td>×</td> 
   <td>×</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>serializable</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
 </tbody> 
</table>

mysql中默认 第三个隔离级别 repeatable read
    oracle中默认第二个隔离级别 read committed
    查看隔离级别
    select @@tx_isolation;
    设置隔离级别
    set session|global transaction isolation level 隔离级别;

1.  演示事务的使用步骤

CREATE TABLE account(
    username VARCHAR(20),
    balance INT
    )
    INSERT INTO account VALUES('张无忌',500);
    INSERT INTO account VALUES('赵敏',1500);
    SELECT * FROM account;
    #开启事务
    SET autocommit=0;
    START TRANSACTION;
    #编写一组事务的语句
    UPDATE account SET balance = 1500 WHERE username='张无忌';
    UPDATE account SET balance = 1000 WHERE username='赵敏';
    
    #结束事务
    ROLLBACK;# 在commit之前可以回滚
    COMMIT;
    
    SELECT * FROM account;

1.  演示事务对于delete和truncate的处理的区别

# drop之后可以回滚
    SET autocommit=0;
    START TRANSACTION;
    DELETE FROM account;
    ROLLBACK;
    
    # truncate之后不能回滚
    SET autocommit=0;
    START TRANSACTION;
    TRUNCATE TABLE account;
    ROLLBACK;

1.  数据库的隔离级别  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 16]  
    默认的隔离级别：  
    ![在这里插入图片描述][20210513211934745.png]  
    将其设置为read uncommitted,  
    ![在这里插入图片描述][20210513212036177.png]  
    修改其中的数据，并不提交：  
    ![在这里插入图片描述][20210513213006257.png]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 17]  
    新开一个命令去查看，修改隔离方式，可以看到读取到的数据是未被提交的。  
    ![在这里插入图片描述][2021051321313849.png]  
    ![在这里插入图片描述][2021051321315841.png]  
    rollback之后查看，结果并未被更改  
    ![在这里插入图片描述][20210513212909941.png]  
    新开一个命令查看，结果也随rollback更改。  
    ![在这里插入图片描述][20210513213258419.png]
2.  演示savepoint的使用

SET autocommit=0;
    START TRANSACTION;
    DELETE FROM account WHERE id=25;
    SAVEPOINT a;#设置保存点
    DELETE FROM account WHERE id=28;
    ROLLBACK TO a;#回滚到保存点
    
    SELECT * FROM account;

# 视图的讲解 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 18]

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>创建语法的关键字</th> 
   <th>是否实际占用物理空间</th> 
   <th>使用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>视图</td> 
   <td>create view</td> 
   <td>只是保存了sql逻辑</td> 
   <td>增删改查，只是一般不能增删改</td> 
  </tr> 
  <tr> 
   <td>表</td> 
   <td>create table</td> 
   <td>保存了数据</td> 
   <td>增删改查</td> 
  </tr> 
 </tbody> 
</table>

作用：

*  重用sql语句
 *  简单复杂化的sql语句，不必知道他的查询细节
 *  保护数据，提高安全性

#案例：查询姓张的学生名和专业名
    # 一般方法
    SELECT stuname,majorname
    FROM stuinfo s
    INNER JOIN major m ON s.`majorid`= m.`id`
    WHERE s.`stuname` LIKE '张%';
    # 视图
    CREATE VIEW v1
    AS
    SELECT stuname,majorname
    FROM stuinfo s
    INNER JOIN major m ON s.`majorid`= m.`id`;
    #使用时直接调用
    SELECT * FROM v1 WHERE stuname LIKE '张%';

也就是将一段固定的sql保存起来，起一个名字叫视图（手动狗头）。

## 一、创建视图 ##

语法：

create view 视图名
    as
    查询语句;

#1.查询姓名中包含a字符的员工名、部门名和工种信息
    #①创建
    CREATE VIEW myv1
    AS
    SELECT last_name,department_name,job_title
    FROM employees e
    JOIN departments d ON e.department_id  = d.department_id
    JOIN jobs j ON j.job_id  = e.job_id;
    
    #②使用
    SELECT * FROM myv1 WHERE last_name LIKE '%a%';

#2.查询各部门的平均工资级别
    
    #①创建视图查看每个部门的平均工资
    CREATE VIEW myv2
    AS
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id;
    
    #②使用
    SELECT myv2.`ag`,g.grade_level
    FROM myv2
    JOIN job_grades g
    ON myv2.`ag` BETWEEN g.`lowest_sal` AND g.`highest_sal`;

#3.查询平均工资最低的部门信息
    SELECT * FROM myv2 ORDER BY ag LIMIT 1;

#4.查询平均工资最低的部门名和工资
    
    CREATE VIEW myv3
    AS
    SELECT * FROM myv2 ORDER BY ag LIMIT 1;
    
    SELECT d.*,m.ag
    FROM myv3 m
    JOIN departments d
    ON m.`department_id`=d.`department_id`;

## 二、视图的修改 ##

方式一：

create or replace view  视图名
    as
    查询语句;

SELECT * FROM myv3 
    
    CREATE OR REPLACE VIEW myv3
    AS
    SELECT AVG(salary),job_id
    FROM employees
    GROUP BY job_id;

方式二：  
语法：

alter view 视图名
    as 
    查询语句;

ALTER VIEW myv3
    AS
    SELECT * FROM employees;

## 三、删除视图 ##

语法：drop view 视图名,视图名,…;  
`DROP VIEW emp_v1,emp_v2,myv3;`

## 四、查看视图 ##

`DESC myv3;`  
`SHOW CREATE VIEW myv3;`

## 五、视图的更新 ##

CREATE OR REPLACE VIEW myv1
    AS
    SELECT last_name,email
    FROM employees;
    
    SELECT * FROM myv1;
    SELECT * FROM employees;

1.  插入

INSERT INTO myv1 VALUES('张飞','zf@qq.com');

在视图中插入会影响原表，原表也会插入

1.  修改

UPDATE myv1 SET last_name = '张无忌' WHERE last_name='张飞';

1.  删除

DELETE FROM myv1 WHERE last_name = '张无忌';

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 19]

1.  具备以下特点的视图不允许更新  
    ①包含以下关键字的sql语句：分组函数、distinct、group by、having、union或者union all

CREATE OR REPLACE VIEW myv1
    AS
    SELECT MAX(salary) m,department_id
    FROM employees
    GROUP BY department_id;
    
    SELECT * FROM myv1;
    #更新
    UPDATE myv1 SET m=9000 WHERE department_id=10;#不可以更新

②常量视图

CREATE OR REPLACE VIEW myv2
    AS
    SELECT 'john' NAME;
    
    SELECT * FROM myv2;
    
    #更新
    UPDATE myv2 SET NAME='lucy';

③Select中包含子查询

CREATE OR REPLACE VIEW myv3
    AS
    SELECT department_id,(SELECT MAX(salary) FROM employees) 最高工资
    FROM departments;
    
    #更新
    SELECT * FROM myv3;
    UPDATE myv3 SET 最高工资=100000;

④join

CREATE OR REPLACE VIEW myv4
    AS
    SELECT last_name,department_name
    FROM employees e
    JOIN departments d
    ON e.department_id  = d.department_id;
    
    #更新
    SELECT * FROM myv4;
    UPDATE myv4 SET last_name  = '张飞' WHERE last_name='Whalen';
    INSERT INTO myv4 VALUES('陈真','xxxx');#可以更新，不可以插入

⑤from一个不能更新的视图

CREATE OR REPLACE VIEW myv5
    AS
    SELECT * FROM myv3;
    
    #更新
    SELECT * FROM myv5;
    UPDATE myv5 SET 最高工资=10000 WHERE department_id=60;

⑥where子句的子查询引用了from子句中的表

CREATE OR REPLACE VIEW myv6
    AS
    SELECT last_name,email,salary
    FROM employees
    WHERE employee_id IN(
    	SELECT  manager_id
    	FROM employees
    	WHERE manager_id IS NOT NULL
    );
    
    #更新
    SELECT * FROM myv6;
    UPDATE myv6 SET salary=10000 WHERE last_name = 'k_ing';

# 变量 #

系统变量：
    	全局变量
    	会话变量
    
    自定义变量：
    	用户变量
    	局部变量

## 一、系统变量 ##

说明：变量由系统定义，不是用户定义，属于服务器层面
    注意：全局变量需要添加global关键字，会话变量需要添加session关键字，如果不写，默认会话级别
    使用步骤：
    1、查看所有系统变量
    show global|【session】variables;
    2、查看满足条件的部分系统变量
    show global|【session】 variables like '%char%';
    3、查看指定的系统变量的值
    select @@global|【session】.系统变量名;
    4、为某个系统变量赋值
    方式一：
    set global|【session】.系统变量名=值;
    方式二：
    set @@global|【session】.系统变量名=值;

### 全局变量 ###

作用域：服务器每次启动都将为所有的全局变量赋初始值，针对于所有会话（连接）有效，但不能跨重启

#①查看所有全局变量
    SHOW GLOBAL VARIABLES;
    #②查看满足条件的部分全局变量
    SHOW GLOBAL VARIABLES LIKE '%char%';
    #③查看指定的全局变量的值
    SELECT @@global.autocommit;
    #④为某个全局变量赋值
    SET @@global.autocommit=0;
    SET GLOBAL autocommit=0;

### 会话变量 ###

作用域：针对于当前会话（连接）有效

#①查看所有会话变量
    SHOW SESSION VARIABLES;
    #②查看满足条件的部分会话变量
    SHOW SESSION VARIABLES LIKE '%char%';
    #③查看指定的会话变量的值
    SELECT @@autocommit;
    SELECT @@session.transaction_isolation;
    #④为某个会话变量赋值
    SET @@session.transaction_isolation='read-uncommitted';
    SET SESSION transaction_isolation='read-committed';

## 二、自定义变量 ##

说明：变量由用户自定义，而不是系统提供的
    使用步骤：
    1、声明
    2、赋值
    3、使用（查看、比较、运算等）

### 用户变量 ###

作用域：针对于当前会话（连接）有效，作用域同于会话变量

#赋值操作符：=或:=
    #①声明并初始化
    SET @变量名=值;
    SET @变量名:=值;
    SELECT @变量名:=值;
    
    #②赋值（更新变量的值）
    #方式一：
    	SET @变量名=值;
    	SET @变量名:=值;
    	SELECT @变量名:=值;
    #方式二：
    	SELECT 字段 INTO @变量名
    	FROM 表;
    #③使用（查看变量的值）
    	SELECT @变量名;

# 案例：声明并初始化
    SET @name='john';
    SET @name=100;
    SET @count=1;
    #复制
    SELECT COUNT(*) INTO @count
    FROM employees;
    #查看
    SELECT @count;

### 局部变量 ###

作用域：仅仅在定义它的begin end块中有效  
应用在 begin end中的第一句话

#①声明
    DECLARE 变量名 类型;
    DECLARE 变量名 类型 【DEFAULT 值】;
    
    #②赋值（更新变量的值）
    #方式一：
    	SET 局部变量名=值;
    	SET 局部变量名:=值;
    	SELECT 局部变量名:=值;
    #方式二：
    	SELECT 字段 INTO 局部变量名
    	FROM 表;
    #③使用（查看变量的值）
    	SELECT 局部变量名;

#案例：声明两个变量，求和并打印
    
    #用户变量
    SET @m=1;
    SET @n=1;
    SET @sum=@m+@n;
    SELECT @sum;
    
    #局部变量，这么样写不可以，必须放在begin end中。
    DECLARE m INT DEFAULT 1;
    DECLARE n INT DEFAULT 1;
    DECLARE SUM INT;
    SET SUM=m+n;
    SELECT SUM;

**用户变量和局部变量的对比**

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>作用域</th> 
   <th>定义位置</th> 
   <th>语法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>用户变量</td> 
   <td>当前会话</td> 
   <td>会话的任何地方</td> 
   <td>加@符号，不用指定类型</td> 
  </tr> 
  <tr> 
   <td>局部变量</td> 
   <td>定义它的BEGIN END中</td> 
   <td>BEGIN END的第一句话</td> 
   <td>一般不用加@,需要指定类型</td> 
  </tr> 
 </tbody> 
</table>

# 存储过程和函数 #

存储过程和函数

存储过程和函数：类似于java中的方法
    好处：
    1、提高代码的重用性
    2、简化操作
    
    #存储过程
    含义：一组预先编译好的SQL语句的集合，理解成批处理语句
    1、提高代码的重用性
    2、简化操作
    3、减少了编译次数并且减少了和数据库服务器的连接次数，提高了效率

## 存储过程 ##

### 一、创建语法 ###

CREATE PROCEDURE 存储过程名(参数列表)
    BEGIN
    	存储过程体（一组合法的SQL语句）
    END

#注意：
    	1、参数列表包含三部分
    	参数模式  参数名  参数类型
    	举例：
    	in stuname varchar(20)
    	
    	参数模式：
    	in：该参数可以作为输入，也就是该参数需要调用方传入值
    	out：该参数可以作为输出，也就是该参数可以作为返回值
    	inout：该参数既可以作为输入又可以作为输出，也就是该参数既需要传入值，又可以返回值
    
    	2、如果存储过程体仅仅只有一句话，begin end可以省略
    	存储过程体中的每条sql语句的结尾要求必须加分号。
    	存储过程的结尾可以使用 delimiter 重新设置
    	语法：
    	delimiter 结束标记
    	案例：
    	delimiter $

### 二、调用语法 ###

CALL 存储过程名(实参列表);  
1.空参列表

#案例：插入到admin表中五条记录
    
    SELECT * FROM admin;
    
    DELIMITER $
    CREATE PROCEDURE myp1()
    BEGIN
    	INSERT INTO admin(username,`password`) 
    	VALUES('john1','0000'),('lily','0000'),('rose','0000'),('jack','0000'),('tom','0000');
    END;
    
    #调用
    CALL myp1();

2.创建带in模式参数的存储过程

#案例1：创建存储过程实现 根据女神名，查询对应的男神信息
    
    CREATE PROCEDURE myp2(IN beautyName VARCHAR(20))
    BEGIN
    	SELECT bo.*
    	FROM boys bo
    	RIGHT JOIN beauty b ON bo.id = b.boyfriend_id
    	WHERE b.name=beautyName;
    	
    END;
    
    #调用
    CALL myp2('柳岩');$

#案例2 ：创建存储过程实现，用户是否登录成功
    
    CREATE PROCEDURE myp4(IN username VARCHAR(20),IN PASSWORD VARCHAR(20))
    BEGIN
    	DECLARE result INT DEFAULT 0;#声明并初始化
    	
    	SELECT COUNT(*) INTO result#赋值
    	FROM admin
    	WHERE admin.username = username
    	AND admin.password = PASSWORD;
    	
    	SELECT IF(result>0,'成功','失败');#使用
    END $
    
    #调用
    CALL myp3('张飞','8888');$

3.创建out 模式参数的存储过程

#案例1：根据输入的女神名，返回对应的男神名
    DELIMITER $
    CREATE PROCEDURE myp6(IN beautyName VARCHAR(20),OUT boyName VARCHAR(20))
    BEGIN
    	SELECT bo.boyname INTO boyname
    	FROM boys bo
    	RIGHT JOIN
    	beauty b ON b.boyfriend_id = bo.id
    	WHERE b.name=beautyName ;
    	
    END $

#案例2：根据输入的女神名，返回对应的男神名和魅力值
    
    CREATE PROCEDURE myp7(IN beautyName VARCHAR(20),OUT boyName VARCHAR(20),OUT usercp INT) 
    BEGIN
    	SELECT boys.boyname ,boys.usercp INTO boyname,usercp
    	FROM boys 
    	RIGHT JOIN
    	beauty b ON b.boyfriend_id = boys.id
    	WHERE b.name=beautyName ;
    	
    END;
    
    #调用
    CALL myp7('小昭',@name,@cp);
    SELECT @name,@cp

4.创建带inout模式参数的存储过程

#案例1：传入a和b两个值，最终a和b都翻倍并返回
    
    CREATE PROCEDURE myp8(INOUT a INT ,INOUT b INT)
    BEGIN
    	SET a=a*2;
    	SET b=b*2;
    END $
    
    #调用
    #调用
    SET @m=10
    SET @n=20
    CALL myp8(@m,@n);
    SELECT @m,@n

### 三、删除存储过程 ###

#语法：drop procedure 存储过程名
    DROP PROCEDURE p1;
    DROP PROCEDURE p2,p3;#×不能多个删除

### 四、查看存储过程的信息 ###

DESC myp2;×
    SHOW CREATE PROCEDURE  myp2;

视图是存储的逻辑上的结果，存储过程是存储的操作方法。视图是一张表，存储过程是一个逻辑处理。

## 函数 ##

#函数
    含义：一组预先编译好的SQL语句的集合，理解成批处理语句
    1、提高代码的重用性
    2、简化操作
    3、减少了编译次数并且减少了和数据库服务器的连接次数，提高了效率
    
    区别：
    存储过程：可以有0个返回，也可以有多个返回，适合做批量插入、批量更新
    函数：有且仅有1 个返回，适合做处理数据后返回一个结果

### 一、创建语法 ###

CREATE FUNCTION 函数名(参数列表) RETURNS 返回类型
    BEGIN
    	函数体
    END

注意：
    1.参数列表 包含两部分：
    参数名 参数类型
    
    2.函数体：肯定会有return语句，如果没有会报错
    如果return语句没有放在函数体的最后也不报错，但不建议
    	return 值;
    3.函数体中仅有一句话，则可以省略begin end
    4.使用 delimiter语句设置结束标记

### 二、调用语法 ###

`SELECT 函数名(参数列表)`  
1.无参有返回

#案例：返回公司的员工个数
    SET GLOBAL log_bin_trust_function_creators=TRUE;
    DELIMITER $
    CREATE FUNCTION myf1() RETURNS INT
    BEGIN
    
    	DECLARE c INT DEFAULT 0;#定义局部变量
    	SELECT COUNT(*) INTO c#赋值
    	FROM employees;
    	RETURN c;
    	
    END;$
    
    SELECT myf1();$

2.有参有返回

#案例1：根据员工名，返回它的工资
    CREATE FUNCTION myf2(empName VARCHAR(20)) RETURNS DOUBLE
    BEGIN
    	SET @sal=0;#定义用户变量 
    	SELECT salary INTO @sal   #赋值
    	FROM employees
    	WHERE last_name = empName;
    	
    	RETURN @sal;
    END $
    
    SELECT myf2('k_ing') $

#案例2：根据部门名，返回该部门的平均工资
    DELIMITER $
    CREATE FUNCTION myf3(deptName VARCHAR(20)) RETURNS DOUBLE
    BEGIN
    	DECLARE sal DOUBLE ;
    	SELECT AVG(salary) INTO sal
    	FROM employees e
    	JOIN departments d ON e.department_id = d.department_id
    	WHERE d.department_name=deptName;
    	RETURN sal;
    END $
    
    SELECT myf3('IT');$

### 三、查看函数 ###

`SHOW CREATE FUNCTION myf3;`

### 四、删除函数 ###

`DROP FUNCTION myf3;`

#案例
    #一、创建函数，实现传入两个float，返回二者之和
    DELIMITER $
    CREATE FUNCTION test_fun1(num1 FLOAT,num2 FLOAT) RETURNS FLOAT
    BEGIN
    	DECLARE SUM FLOAT DEFAULT 0;
    	SET SUM=num1+num2;
    	RETURN SUM;
    END $
    
    SELECT test_fun1(1,2)$

# 流程控制结构 #

顺序、分支、循环
    顺序结构：程序从上到下依次执行
    分支结构：程序从两条或者多条路径中选择一条执行
    循环结构：程序在满足一定条件的基础上，重复执行一段代码

## 一、分支结构 ##

### 1.if函数 ###

功能：实现双分支
    语法：if(条件,值1，值2)
    执行顺序：如果条件成立，则if函数返回值1，否则返回值2
    应用在begin end中或外面

### 2.case结构 ###

语法：
    情况1：类似于switch，一般用于实现等值判断
    	case 变量或表达式
    	when 值1 then 语句1;
    	when 值2 then 语句2;
    	...
    	else 语句n;
    	end case
    
    情况2：类似于java中的多重if语句，一般用于实现区间判断
    	case 
    	when 条件1 then 语句1;
    	when 条件2 then 语句2;
    	...
    	else 语句n;
    	end case
    
    特点：
    ①应用在begin end 中或外面
    可以作为表达式，嵌套在其他语句中使用，可以放在任何地方，begin end中或begin end的外面
    可以作为独立的语句去使用，只能放在begin end 中
    ②如果when中的值满足或条件成立，则执行对应的then后面的语句，并且结束case
    如果不满足，则执行else在的语句或值
    ③else可以省略，如果else省略了，并且所有when都不满足，则返回null

**case结构作为表达式**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 20]

**case语句作为独立的语句**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 21]

#案例1：创建函数，实现传入成绩，如果成绩>90,返回A，如果成绩>80,返回B，如果成绩>60,返回C，否则返回D
    DELIMITER $
    CREATE FUNCTION test_case(score FLOAT) RETURNS CHAR
    BEGIN 
    	DECLARE ch CHAR DEFAULT 'A';
    	
    	CASE 
    	WHEN score>90 THEN SET ch='A';
    	WHEN score>80 THEN SET ch='B';
    	WHEN score>60 THEN SET ch='C';
    	ELSE SET ch='D';
    	END CASE;
    	
    	RETURN ch;
    END $
    
    SELECT test_case(56)$

### 3.多重if语句 ###

功能：类似于多重if,实现多重分支
    
    语法：
    if 条件1 then 语句1;
    elseif 条件2 then 语句2;
    ....
    else 语句n;
    end if;
    
    只能应用在begin end 中

#案例1：创建函数，实现传入成绩，如果成绩>90,返回A，如果成绩>80,返回B，如果成绩>60,返回C，否则返回D
    DELIMITER $
    CREATE FUNCTION test_if(score FLOAT) RETURNS CHAR
    BEGIN
    	DECLARE ch CHAR DEFAULT 'A';
    	IF score>90 THEN SET ch='A';
    	ELSEIF score>80 THEN SET ch='B';
    	ELSEIF score>60 THEN SET ch='C';
    	ELSE SET ch='D';
    	END IF;
    	RETURN ch;
    	
    END; $
    
    SELECT test_if(87)$

## 二、循环结构 ##

分类：
    we、loop、repeat
    
    循环控制：
    iterate类似于 continue，继续，结束本次循环，继续下一次
    leave 类似于  break，跳出，结束当前所在的循环

### 1.while ###

语法：
    【标签:】while 循环条件 do
    	循环体;
    end while【 标签】;
    
    联想：
    while(循环条件){
    	循环体;
    }

### 2.loop ###

语法：
    【标签:】loop
    	循环体;
    end loop 【标签】;
    
    可以用来模拟简单的死循环

### 3.repeat ###

语法：
    【标签：】repeat
    	循环体;
    until 结束循环的条件
    end repeat 【标签】;

#1.没有添加循环控制语句
    #案例：批量插入，根据次数插入到admin表中多条记录
    DROP PROCEDURE pro_while1 $
    DELIMITER $
    CREATE PROCEDURE pro_while1(IN insertCount INT)
    BEGIN
    	DECLARE i INT DEFAULT 1;
    	WHILE i<=insertCount DO
    		INSERT INTO admin(username,`password`) VALUES(CONCAT('Rose',i),'666');
    		SET i=i+1;
    	END WHILE;
    	
    END $
    
    CALL pro_while1(100);
    SELECT * FROM admin;

#2.添加leave语句
    
    #案例：批量插入，根据次数插入到admin表中多条记录，如果次数>20则停止
    TRUNCATE TABLE admin $
    DROP PROCEDURE test_while1 $
    DELIMITER $
    CREATE PROCEDURE test_while1(IN insertCount INT)
    BEGIN
    	DECLARE i INT DEFAULT 1;
    	a:WHILE i<=insertCount DO
    		INSERT INTO admin(username,`password`) VALUES(CONCAT('xiaohua',i),'0000');
    		IF i>=20 THEN LEAVE a;
    		END IF;
    		SET i=i+1;
    	END WHILE a;
    END $
    
    CALL test_while1(100)$
    SELECT * FROM admin;

#3.添加iterate语句
    
    #案例：批量插入，根据次数插入到admin表中多条记录，只插入偶数次
    TRUNCATE TABLE admin $
    DROP PROCEDURE test_while1$
    DELIMITER $
    CREATE PROCEDURE test_while1(IN insertCount INT)
    BEGIN
    	DECLARE i INT DEFAULT 0;
    	a:WHILE i<=insertCount DO
    		SET i=i+1;
    		IF MOD(i,2)!=0 THEN ITERATE a;
    		END IF;
    		
    		INSERT INTO admin(username,`password`) VALUES(CONCAT('xiaohua',i),'0000');
    		
    	END WHILE a;
    END
    
    CALL test_while1(100)
    SELECT * FROM admin;

**循环结构总结**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 22]

### 强制索引 ###

查询优化器是MySQL数据库服务器中的一个组件，它为SQL语句提供最佳的执行计划;  
查询优化器使用可用的统计信息来提出所有候选计划中成本最低的计划;  
例如，查询可能会请求价格在10到80之间的产品。如果统计数据显示80％的产品具有这些价格范围，那么它可能会认为全表扫描效率最高。但是，如果统计数据显示很少有产品具有这些价格范围，那么读取索引后跟表访问可能比全表扫描更快，更有效。  
如果查询优化器忽略索引，您可以使用FORCE INDEX提示来指示它使用索引。  
![在这里插入图片描述][20210717203835106.png]

## 例题 ##

1.  删除表中重复的记录  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 23]

delete from titles_test 
    where id not IN
    (
    select * from 
        (select min(id)
        from titles_test
        group by emp_no) T1
    )

mysql不允许在查询的同时删除原表数据，如果向删除，必须给原始数据表取一个别名再删除，查询出结果，给结果取别名之后再删除

1.  将id=5以及emp\_no=10001的行数据替换成id=5以及emp\_no=10005,其他数据保持不变，使用replace实现，直接使用update会报错。

本题考查的是replace函数，其中包含三个参数，第一个参数为该字段的名称，第二参数为该字段的需要被修改值，第三个参数为该字段修改后的值。

update titles_test
    set emp_no = replace(emp_no,10001,10005)
    where id = 5

REPLACE INTO当遇到primary 或者 unique key 的时候，会首先进行update

REPLACE INTO titles_test
        VALUES(5, 10005 ,'Senior Engineer', '1986-06-26', '9999-01-01')

1.  查找字符出现次数  
    ![在这里插入图片描述][20210717214207578.png]
    
        统计字符串长度：
         char_length('string')/char_length(column_name)
         1、返回值为字符串string或者对应字段长度，长度的单位为字符，一个多字节字符（例如，汉字）算作一个单字符；
         2、不管汉字还是数字或者是字母都算是一个字符；
         3、任何编码下，多字节字符都算是一个字符；
         
         length('string')/length(column_name)
         1、utf8字符集编码下,一个汉字是算三个字符,一个数字或字母算一个字符。
         2、其他编码下,一个汉字算两个字符, 一个数字或字母算一个字符。
         
         字符串替换：REPLACE(s,s1,s2)，将字符串 s2 替代字符串 s 中的字符串 s1

然后原来串的长度 - 替换之后的串的长度 就是 被替换的 逗号的个数

select (length("10,A,B") - length(replace("10,A,B",",","")) )
    as cnt;

1.  将查询结果汇总  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 24]
    
        聚合函数group_concat（X，Y），其中X是要连接的字段，Y是连接时用的符号，可省略，默认为逗号。此函数必须与GROUP BY配合使用。

此题以dept\_no作为分组，将每个分组中不同的emp\_no用逗号连接起来（即可省略Y）。

SELECT dept_no,group_concat(emp_no) employees
    FROM dept_emp GROUP BY dept_no

1.  查询除最大最小值之后的均值  
    ![在这里插入图片描述][20210717221648956.png]

select avg(salary) avg_salary
    from salaries
    where salary not in
    (select max(salary) from salaries where to_date='9999-01-01') and 
    salary not in (select min(salary) from salaries where to_date='9999-01-01')
    and to_date='9999-01-01';

SELECT (SUM(salary) - MAX(salary) - MIN(salary)) / (COUNT(1)-2) avg_salary 
    FROM salaries where to_date = '9999-01-01';

1.  累计和

select emp_no,salary,sum(salary) over (order by emp_no) running_total
    from salaries
    where to_date = '9999-01-01'

1.  构建触发器  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 25]

CREATE trigger audit_log
    after insert on employees_test
    for each ROW
    BEGIN
        insert into audit VALUES(new.id,new.name);
    END

在MySQL中，创建触发器语法如下：

CREATE TRIGGER trigger_name
    trigger_time trigger_event ON tbl_name
    FOR EACH ROW
    trigger_stmt

其中：

trigger_name：标识触发器名称，用户自行指定；
    trigger_time：标识触发时机，取值为 BEFORE 或 AFTER；
    trigger_event：标识触发事件，取值为 INSERT、UPDATE 或 DELETE；
    tbl_name：标识建立触发器的表名，即在哪张表上建立触发器；
    trigger_stmt：触发器程序体，可以是一句SQL语句，或者用 BEGIN 和 END 包含的多条语句，每条语句结束要分号结尾。
    【NEW 与 OLD 详解】
    MySQL 中定义了 NEW 和 OLD，用来表示
    触发器的所在表中，触发了触发器的那一行数据。
    具体地：

在 INSERT 型触发器中，NEW 用来表示将要（BEFORE）或已经（AFTER）插入的新数据；  
在 UPDATE 型触发器中，OLD 用来表示将要或已经被修改的原数据，NEW 用来表示将要或已经修改为的新数据；  
在 DELETE 型触发器中，OLD 用来表示将要或已经被删除的原数据；  
使用方法： NEW.columnName （columnName 为相应数据表某一列名）

1.  新用户次日留存率

select 
    round(count(distinct user_id)*1.0/(select count(distinct user_id) from login),3)
    from login
    where (user_id,date) in
    (select user_id,date_add(min(date),interval 1 day) from login
    group by user_id)

1.  异常的邮件概率  
    ![在这里插入图片描述][58dfc617480549de83c5034fde4cc78a.png]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 26]

select date,round(sum(case type when 'no_completed' then 1 else 0 end)*1.0/count(type),3) as p
    from email
    where send_id in 
        (select id from user where is_blacklist = 0)
        and receive_id in
        (select id from user where is_blacklist = 0)
    group by date
    order by date

1.  查询连续登录7天以上的用户

1、因为每天用户登录次数可能不止一次，所以需要先将用户每天的登录日期去重。

select distinct date(date) as '日期',id from order;

2、再用row\_number() over(partition by \_ order by \_)函数将用户id分组，按照登陆时间进行排序。

select *,row_number() over(partition by id order by 日期) as cnt
    from (select distinct date(date) as '日期',id from order) a;

3、计算登录日期减去第二步骤得到的结果值，用户连续登陆情况下，每次相减的结果都相同。

select *,date(日期)-cnt as 结果
    from (select *,row_number() over(partition by id order by 日期) as cnt
    from (select distinct date(date) as '日期',id from order) a) b

4、按照id和日期分组并求和，筛选大于等于7的即为连续7天登陆的用户。

select id,count(*) from(select *,date(日期)-cnt as 结果
    from (select *,row_number() over(partition by id order by 日期) as cnt
    from (select distinct date(date) as '日期',id from order) a) b) c
    group by id,结果
    having count(*)>=7

注意：在操作前，最好用`use 表`选择要操作的表。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70]: /images/20221021/f9136468ba6b4168a50e26367bdcb02b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 1]: /images/20221021/f42d43ee9fa24890948848dd855461b4.png
[20210506211045545.png]: /images/20221021/10a7b79f988a436384b34a1fa2996f06.png
[20210507153012135.png]: /images/20221021/3567b30991a84673b3fad1ef37bf0b27.png
[20210507150336532.png]: /images/20221021/2fa1422d1aee413ebfa64f15be26b564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 2]: /images/20221021/7e29d80f463143989adf83632c3cd7ef.png
[20210507150446915.png]: /images/20221021/90fb5006a5d1418da549109645e7a97d.png
[20210507150646830.png]: /images/20221021/936031f41f304f5899ed0638fb54257b.png
[20210507151311466.png]: /images/20221021/a193db208d034a3b9f9f410c4edb02d8.png
[20210507151453258.png]: /images/20221021/8bdfac45980a494db01b0b6c23a15935.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 3]: /images/20221021/4a28a0cb745741e58feebb4f191d6bbf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 4]: /images/20221021/7a2e23f981234e09aa7e63e11086f48b.png
[20210507152714695.png]: /images/20221021/f6b27349173145d4a52c8ca4172e418a.png
[20210507152805358.png]: /images/20221021/be3620c8867344d29e924961ee278aad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 5]: /images/20221021/3b24426eb50e479ebed23413d7c51b15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 6]: /images/20221021/e8f62628f79b4cddacaca31db9f56e86.png
[20210508140147985.png]: /images/20221021/b6c854b371a24ff285318bb79cffa650.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 7]: /images/20221021/979e7506fb634aed91987ef66f066d6f.png
[20210508140422673.png]: /images/20221021/df6193414ad244ba95490df64c5f5047.png
[20210508140523406.png]: /images/20221021/235af0de10f44808a1cfd6f7b6c535fd.png
[20210508140634828.png]: /images/20221021/62159dd052204f6a89ab3da5fb8fd7b3.png
[20210508145715655.png]: /images/20221021/8e24341625964365b01de2a281d7712f.png
[20210508221905392.png]: /images/20221021/56dd55ab67c6484589df407ff4a9f047.png
[20210508222010910.png]: /images/20221021/d0c6528cb5df40ccbe2c3d841346e8ef.png
[20210508221730658.png]: /images/20221021/0957e7f20ab34393b13d2c7230143fd7.png
[20210508221616342.png]: /images/20221021/f754b8e071514281a34a6345ee0bf921.png
[20210508221656715.png]: /images/20221021/cac97cd07dd84dd1b304584110db4c32.png
[20210508221824131.png]: /images/20221021/03ed251beaf94ae9b0518d32a39ab10e.png
[20210508222705481.png]: /images/20221021/fd76deb2b21344b0a28f0ba7febfdbc6.png
[20210508222730298.png]: /images/20221021/79af0e9c5e8646029c2e941aa5a5ef2d.png
[2021050822285539.png]: /images/20221021/5b6348db14fa4509b39336d76b42be87.png
[2021050822292686.png]: /images/20221021/4a04dfc4e30d4ea3abffe426efdfb26d.png
[20210508223050886.png]: /images/20221021/fdc33b4d5180499e8e9bab086705270f.png
[20210510141841575.png]: /images/20221021/c96cc21253e44308b63d8808cbae9711.png
[20210508223838553.png]: /images/20221021/de32b705b5c3444dba8cf7697eb198c6.png
[20210508224005544.png]: /images/20221021/3e8c37934e9b4b1ba5109e05783e251d.png
[20210508224052835.png]: /images/20221021/a5ed8dc23c1e48a898161aa4a4d2b430.png
[2021050822415010.png]: /images/20221021/b41242dc6a854a2899b9c05120ac4ec7.png
[202105082242084.png]: /images/20221021/0c366776de6f46199a01974c1ed90e9e.png
[20210508224329144.png]: /images/20221021/ac8555e30a7a45249b4a995cedf92533.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 8]: /images/20221021/ee2f69d47bc247adbf30aab09212e78f.png
[202105082253201.png]: /images/20221021/28b1356252b541508a52c90f8cc6b683.png
[20210508225708474.png]: /images/20221021/d8e6fa36fd2c45d4b13b94834c25bff2.png
[20210508225754918.png]: /images/20221021/5176de14a8644412a30a3af8050ff366.png
[20210508230235554.png]: /images/20221021/169b793675e145d3b1f1a7044ff975ea.png
[mysql _ _SQL_Pivot]: https://blog.csdn.net/weixin_39897758/article/details/110864571
[1c813f1a9de645be9b47732a03f8c8b3.png]: /images/20221021/9b9e435e31ff4947adbba5e6b9959121.png
[ac50188c2cef42d18a3d38302b9cf98e.png]: /images/20221021/e2aa7f1d22fb4eebb416da239eeb330b.png
[3a1b56e2df174af2b4eee2ea3d34af21.png]: /images/20221021/7d2638e57bee44a3b697e9940a4a3edc.png
[b6986458dc304b7bab93267fbfe6a936.png]: /images/20221021/a3120042b0894dbaadf5961751ab42cf.png
[20210508230525391.png]: /images/20221021/7b74ade4b9294a87b9e4bf11534fc426.png
[20210508231229147.png]: /images/20221021/2c04d806624c4f44a113e5322923f967.png
[20210508231648251.png]: /images/20221021/26df626adfdf4f2890a13256e976abe0.png
[20210509182753516.png]: /images/20221021/c08ed612da89497aafd7f312c40f710c.png
[20210510211102358.png]: /images/20221021/1c3aad1f183d4233b41d90e6ed4f8c6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 9]: /images/20221021/b79d4db7408d49a582aac8b0eff6b6d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 10]: /images/20221021/163e3b7364e0491b9c4a74702bcd29dd.png
[20210512163537769.png]: /images/20221021/54545d9be9304f4aa3fd4492459c5ebc.png
[20210512164858299.png]: /images/20221021/84516d042345432b83c09801f14332a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 11]: /images/20221021/e5e6c5faa4cb46d59b4b597cf75f943b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 12]: /images/20221021/be0f7a7f61584be8ad9a4a2e3a684bed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 13]: /images/20221021/5b72cabe94e34c5d9426a34fdcbf3ba0.png
[20210512172411617.png]: /images/20221021/35a951e33f764a549f34bfe2274b46e1.png
[20210512171709780.png]: /images/20221021/d32b1ed726324883ace9a119af065e8b.png
[20210512172458160.png]: /images/20221021/04e3c7b7df8e40e1815722b0c233f96f.png
[20210513164504563.png]: /images/20221021/c2b24edbbc684fc0a15ff3137667bf7e.png
[20210513164732499.png]: /images/20221021/59a27df6e2974ad0868d1a4ed1bba7b6.png
[2021051317004614.png]: /images/20221021/ec93ad2d22de4702a6a278a27b757ec0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 14]: /images/20221021/784ec39a5a204598925f83ac1bfcc165.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 15]: /images/20221021/ec5b219e0d254af09353ffa2338ea04e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 16]: /images/20221021/53bfc31ba9eb4ad59545e1f1f25ce408.png
[20210513211934745.png]: /images/20221021/c439998cb7664135aaae48764268fcd1.png
[20210513212036177.png]: /images/20221021/b75662a5eb6b4eac9bbaa0e8c8aef9ec.png
[20210513213006257.png]: /images/20221021/77f6d6ba1e444964812f9090dc9be37e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 17]: /images/20221021/27c0607246254345b8cc9c2653195d9d.png
[2021051321313849.png]: /images/20221021/aada78016430475abea97a6ff8e0aaac.png
[2021051321315841.png]: /images/20221021/09faf4b0633a40a69b5228952d46cec8.png
[20210513212909941.png]: /images/20221021/be51363fc56e49129b01139343b7b9d3.png
[20210513213258419.png]: /images/20221021/baa51cb28c2e4555a289a5c38a1f6ad1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 18]: /images/20221021/804311f156e74f4999f499de27253a2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 19]: /images/20221021/349605d04e4c45eb81f785ac3572de0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 20]: /images/20221021/09dade0779a940e69d95360644abeb04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 21]: /images/20221021/00d32af4793e40678b7deb1a96441f4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 22]: /images/20221021/00747b728d7149c19c48a0480f0f1346.png
[20210717203835106.png]: /images/20221021/c8321ff01fee4b7e9c0d5b041a6616d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 23]: /images/20221021/b67ddee906ab4ec584c68a854dd1b05e.png
[20210717214207578.png]: /images/20221021/e35bd71f8019411a8ff81523edc3d649.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 24]: /images/20221021/3f334cd4dc724f2fa2c6a3d14a4b753d.png
[20210717221648956.png]: /images/20221021/8b0723c6e1424bb58b32d06aa9eb2d3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 25]: /images/20221021/a7634f375c984c6d87d357b9e3f38c37.png
[58dfc617480549de83c5034fde4cc78a.png]: /images/20221021/58a4c9027ded4c0a8f54eb57565ccda6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MjIzNDQ0_size_16_color_FFFFFF_t_70 26]: /images/20221021/4c3c44d6ebc54f13976f9a4426906025.png