文章目录
数据库基本操作命令
命名规则
- 字段名必须以字母开头
- 长度不能超过30个字符（不同数据库，不同版本会有不同）
- 不能使用SQL的保留字
- 只能使用如下字符a-z、A-Z、0-9、$等
- Mysql习惯全小写
- 多个单词用下划线隔开
库的操作
| 命令 | 描述 |
|---|---|
| show databases; | 查询所有数据库 |
| create database 库名; | 创建数据库 |
| use 库名; | 使用库 |
| drop database 库名; | 删除数据库 |
表的操作
| 命令 | 描述 |
|---|---|
| show tables; | 查询所有表 |
| create table 表名(字段名1 字段类型1(长度),字段名2 字段类型2(长度),…); | 创建表 |
| drop table 表名; | 删除表 |
| alter table 表名 add column 字段名 字段类型(长度) | 修改表 |
| desc 表名; | 查看表结构 |
- 创建表时多个字段需要 " , " 逗号隔开，但是最后一个字段不需要
表里的记录操作
| 命令 | 描述 |
|---|---|
| select 字段名1,字段名2,字段名3… from 表名; / select * from 表名; | 根据字段名查询 / 查询表里的所有数据 |
| insert into 表名 values(字段1的值,字段2的值,…) / insert into 表名(字段名) values(字段值),(字段值) | 添加表中数据 / 给指定的字段添加数据 |
| update 表名 set 字段名=新值 where 字段名=字段值 | 修改表中数据，整个字段都会改变，后面有条件查询 |
| delete from 表名; | 删除表中数据 |
| set names gbk; | 解决中文乱码 |
| insert into 表名 (字段名1,字段名2,…) values(字段1的值,字段2的值,…),(字段1的值,字段2的值,…) |
主键与自增
- PRIMARY KEY AUTO_INCREMENT
导入表结构
1、选择数据库
2、导入sql，source xxx.sql
DQL（数据查询）
创建表和字段时添加备注（comment）
create table test(id int comment 'id号',name varchar(255) comment '名字')comment='测试表';
查询创建表信息
show create table test;
11、简单查询
任何一个SQL语句以 " ; " 结尾
SQL语句不区分大小写，但是表中存储的数据在Orcale中分大小，MySQL不区分，Oracle比较严谨，MySQL比较松散
字段可以参与数学运算
使用 as 其别名，且as关键字可以省略，别名中有中文，使用单引号括起来
sql语句中字符串一定要使用单引号括起来
查询多个字段用 “ ，” 隔开
查询全部字段使用 " * "，在实际开发中不建议使用 " * "，这样效率比较低。
12、条件查询
select
字段,字段…
from
表名
where
条件;
执行顺序：from，where，select
between…and…：是闭区间 [1100 - 3000]
between…and…：使用时必须左小右大
between…and…：可以使用在数字方面，还可以使用在字符串方面，但是字符方面是左闭右开 [A - C)
在数据库中NULL不是一个值，代表什么也没有，为空。
空不是一个值，不能用等号衡量。
必须使用 is null 或者 is not null
and优先级大于or，可以使用" () "括号解决优先级问题
in后面的值不是区间，是一个具体的值
模糊查询中，如果想查询带有" _ "的内容，可以使用转移字符 " \ “，” \ _"这样就可以了
13、排序（升序、降序）
order by 字段 asc/desc
默认是升序
asc升序
desc降序
多个字段同时排序使用" , " 分割
越靠前的字段越能起到主导作用，只有当前面的字段无法完成排序的时候，才会启用后面的字段。(当前面字段相等，后面字段才会执行)
可以在 order by 字段号，可以根据字段号排序(字段号是查询时使用的字段)，但是不建议在Java程序中使用，平常练习时可以使用。
select
字段
from
表面
where
条件
order by
…
执行顺序：from、where、select、order by
注意：order by最后执行的
14、分组函数
count 计数
sum 求和
avg 平均值
max 最大值
min 最小值
注意：所有的分组函数都是对 某一组 数据进行操作的
分组函数一共5个。
分组函数还有另一个名字，多行处理函数
多行处理函数特点：输入多行，最终输出的结果是一行
分组函数自动忽略NULL
所有分组函数都是自动忽略NULL，所有不需要再where条件中加上过滤条件is not null
select sum(comm) from emp; sum函数自动忽略NULL
SQL语句当中有一个语法规则，分组函数不可以直接使用再where子句当中？
原因：因为group by是在where执行之后才会执行。
执行顺序：where、group by、分组函数（不进行分组group by，不可以使用分组函数），所以where子句中不能使用分组函数。
count( * ) 和 count(某字段) 的区别？
count( * )：不是统计某个字段中数据的个数，而是统计总记录条数，和某个字段无关
count(某字段)：表示统计某个字段不为NULL的数据总数量
分组函数可以组合起来用，使用" , "隔开
分组函数会忽略NULL，但是数学表达式不会忽略NUL，凡是带有NULL的数学表达式结果必为NULL。
15、单行处理函数
输入一行，输出一行
注意：在数据库中，只要数学表达式当中有NULL出现，结果都会是NULL，数学表达式中不会忽略NULL。
解决：ifnull() 空处理函数，属于单行处理函数
ifnull(可能为NULL的数据, 被当做什么处理)
16、group by 和 having
group by：按照某个字段或某些字段进行分组。
having：是对分组之后的数据进行再次过滤。
注意：group by 和 having是搭档，想使用 having 必须要使用 group by
执行顺序：from，group by、select(分组函数)
注意：分组函数一般都会和group by联合使用，任何一个分组函数都是在group by语句执行结束之后才会执行。
当一条sql语句没有group by的话，整张表的数据会自成一组，实际上里面会有一个缺省的group by。
当一条语句中有group by的话，只允许select之后出现参加分组的字段和参数分组的函数写在这，其它的不可以，虽然在MySQL中可以执行，但是毫无意义，在Oracle中执行会报错。
多字段分组查询
把多个字段看成一个字段即可。
select
deptno,job,max(sal)
from
emp
group by
deptno,job;
where过滤高于having过滤
建议能够使用where就尽量使用
17、总结一个完整的DQL语句
select 5 查询字段
…
from 1 查询表
…
where 2 条件过滤
…
group by 3 分组
…
having 4 条件过滤
…
order by 6 排序
…
1、去除重复记录
distinct 去重
select distinct job from emp;
select distinct deptno,job from emp;
distinct 只能出现在所有字段的最前面，多个字段会联合起来去重
统计工作岗位的数量？
select count(distinct job) from emp;
2、连接查询
概述：
实际开发中，大部分不是单表查询数据，一般都是多张表联合查询。
因为一张表中字段过多会出现大量的数据重复，导致数据冗余。
3、分类：
内连接：AB两张表平等关系，没有主副之分
等值连接
非等值连接
自连接
外连接：AB两张表有主表和副表之分，主要查主表，左连接可以写成右连接，右连接可以写出左连接
左外连接（左连接）
右外连接（右连接）
全连接：几乎不用。既有左连接又右连接，把两张表的数据全部查出来。
4、笛卡尔积现象（笛卡尔乘积现象）：
关于表的别名：
执行效率高
可读性好
14 x 4 = 56条
select e.ename,d.dname from emp e,dept d;
避免笛卡尔积现象：匹配次数还是56次（匹配次数不会减少），只不过显示的是有效记录。
找出每一个员工的部门名称，要求显示员工名和部门名。
select e.ename,d.dname from emp e,dept d where e.deptno=d.deptno; # SQL92，以后不用
5、内连接之等值连接
最大特点是：条件是等量关系。
找出每一个员工的部门名称，要求显示员工名和部门名。
SQL92：（不用）
select
e.ename,d.dname
from
emp e,dept d
where
e.deptno=d.deptno; # SQL92，以后不用
SQL99：（常用）
select
e.ename,d.dname
from
emp e
join
dept d
on
e.deptno=d.deptno;
inner：表示内连接，inner可以省略，带着inner目的是可读性好些
select
e.ename,d.dname
from
emp e
inner join
dept d
on
e.deptno=d.deptno;
…
A
join
B
on
连接条件
where
…
结构更清晰一些，表的连接条件和后来的where条件分离了
6、内连接之非等值连接
最大的特点是：连接条件中的关系是非等量关系
找出每个员工的工资等级，要求显示员工名、工资、工资等级。
select
e.ename,e.sal,s.grade
from
emp e
join
salgrade s
on
e.sal between s.losal and s.hisal;
7、自连接
最大的特点是：一张表看做两张表，自己连接自己。
表的自连接可以是等量或不等量。
empno：员工编号
ename：员工名和领导名
mgr：领导编号
select empno,ename,mgr from emp;
emp a 员工表
±------±-------±-----+
| empno | ename | mgr |
±------±-------±-----+
| 7369 | SMITH | 7902 |
| 7499 | ALLEN | 7698 |
| 7521 | WARD | 7698 |
| 7566 | JONES | 7839 |
| 7654 | MARTIN | 7698 |
| 7698 | BLAKE | 7839 |
| 7782 | CLARK | 7839 |
| 7788 | SCOTT | 7566 |
| 7839 | KING | NULL |
| 7844 | TURNER | 7698 |
| 7876 | ADAMS | 7788 |
| 7900 | JAMES | 7698 |
| 7902 | FORD | 7566 |
| 7934 | MILLER | 7782 |
±------±-------±-----+
select empno,ename from emp;
emp b 领导表
±------±-------±
| empno | ename |
±------±-------+
| 7566 | JONES |
| 7698 | BLAKE |
| 7782 | CLARK |
| 7788 | SCOTT |
| 7839 | KING |
| 7902 | FORD |
±------±-------+
找出每个员工的上级领导，要求显示员工名和对应的领导名。
select
a.ename as '员工名',b.ename as '领导名'
from
emp a
inner join
emp b
on
a.mgr = b.empno;
8、外连接（常用）
内连接和外连接的区别？
内连接：
假设A和B表进行连接，使用内连接的话，凡是A表和表能够匹配上的记录查询出来，这就是内连接。
AB两张表没有主副之分，两张表是平等的。
外连接：
假设A和B表进行连接，使用外连接的话，AB两张表中有一张表是主表，一张表是副表，主要查询主表中的数据，捎带着查询副表，当副表中的数据没有和主表中的数据匹配上，副表自动模拟出NULL与之匹配。
外连接分类：
左外连接（左连接）：表示左边的这张表是主表。
右外连接（右连接）：表示右边的这张表是主表。
左连接有右连接的写法，右连接也会有对应的左连接的写法。
找出每个员工的上级领导？（所有员工必须全部查询出来）
左外连接（a表是主表，b表是副表）
外连接outer可以省略，区分内外连接方法是通过 left 和 right 是外连接
select
a.ename as '员工名',b.ename as '领导名'
from
emp a
left outer join
emp b
on
a.mgr = b.empno;
右外连接（a表为主表，b表为副表）
select
a.ename as '员工名',b.ename as '领导名'
from
emp b
right outer join
emp a
on
a.mgr = b.empno;
外连接使用较多
外连接最重要的特点是：主表的数据无条件的全部查询出来。
找出哪个部门没有员工。
select
d.*
from
emp e
right join
dept d
on
e.deptno=d.deptno
where
e.empno is null;
9、三张表连接查询
找出每一个员工的部门名称以及工资等级。
emp e 员工表
mysql> select empno,ename,sal,deptno from emp;
+-------+--------+---------+--------+
| empno | ename | sal | deptno |
+-------+--------+---------+--------+
| 7369 | SMITH | 800.00 | 20 |
| 7499 | ALLEN | 1600.00 | 30 |
| 7521 | WARD | 1250.00 | 30 |
| 7566 | JONES | 2975.00 | 20 |
| 7654 | MARTIN | 1250.00 | 30 |
| 7698 | BLAKE | 2850.00 | 30 |
| 7782 | CLARK | 2450.00 | 10 |
| 7788 | SCOTT | 3000.00 | 20 |
| 7839 | KING | 5000.00 | 10 |
| 7844 | TURNER | 1500.00 | 30 |
| 7876 | ADAMS | 1100.00 | 20 |
| 7900 | JAMES | 950.00 | 30 |
| 7902 | FORD | 3000.00 | 20 |
| 7934 | MILLER | 1300.00 | 10 |
+-------+--------+---------+--------+
14 rows in set (0.00 sec)
dept d 部门表
mysql> select * from dept;
+--------+------------+----------+
| DEPTNO | DNAME | LOC |
+--------+------------+----------+
| 10 | ACCOUNTING | NEW YORK |
| 20 | RESEARCH | DALLAS |
| 30 | SALES | CHICAGO |
| 40 | OPERATIONS | BOSTON |
+--------+------------+----------+
4 rows in set (0.00 sec)
salgrade s 工资等级
mysql> select * from salgrade;
+-------+-------+-------+
| GRADE | LOSAL | HISAL |
+-------+-------+-------+
| 1 | 700 | 1200 |
| 2 | 1201 | 1400 |
| 3 | 1401 | 2000 |
| 4 | 2001 | 3000 |
| 5 | 3001 | 9999 |
+-------+-------+-------+
5 rows in set (0.00 sec)
A
join
B
join
C
on
表示：A表和B表先进行表连接，连接之后(连接之后的结果)A表继续和C表进行连接。
select
e.ename,d.dname,s.grade
from
emp e
join
dept d
on
e.deptno=d.deptno
join
salgrade s
on
e.sal between s.losal and s.hisal;
+--------+------------+-------+
| ename | dname | grade |
+--------+------------+-------+
| SMITH | RESEARCH | 1 |
| ALLEN | SALES | 3 |
| WARD | SALES | 2 |
| JONES | RESEARCH | 4 |
| MARTIN | SALES | 2 |
| BLAKE | SALES | 4 |
| CLARK | ACCOUNTING | 4 |
| SCOTT | RESEARCH | 4 |
| KING | ACCOUNTING | 5 |
| TURNER | SALES | 3 |
| ADAMS | RESEARCH | 1 |
| JAMES | SALES | 1 |
| FORD | RESEARCH | 4 |
| MILLER | ACCOUNTING | 2 |
+--------+------------+-------+
14 rows in set (0.00 sec)
找出每一个员工的部门名称、工资等级、以及上级领导。
#e为主表，e1为副表
select
e.ename '员工',d.dname,s.grade,e1.ename '领导'
from
emp e
join
dept d
on
e.deptno=d.deptno
join
salgrade s
on
e.sal between s.losal and s.hisal
left join
emp e1
on
e.mgr=e1.empno;
+--------+------------+-------+-------+
| 员工 | dname | grade | 领导 |
+--------+------------+-------+-------+
| SMITH | RESEARCH | 1 | FORD |
| ALLEN | SALES | 3 | BLAKE |
| WARD | SALES | 2 | BLAKE |
| JONES | RESEARCH | 4 | KING |
| MARTIN | SALES | 2 | BLAKE |
| BLAKE | SALES | 4 | KING |
| CLARK | ACCOUNTING | 4 | KING |
| SCOTT | RESEARCH | 4 | JONES |
| KING | ACCOUNTING | 5 | NULL |
| TURNER | SALES | 3 | BLAKE |
| ADAMS | RESEARCH | 1 | SCOTT |
| JAMES | SALES | 1 | BLAKE |
| FORD | RESEARCH | 4 | JONES |
| MILLER | ACCOUNTING | 2 | CLARK |
+--------+------------+-------+-------+
14 rows in set (0.00 sec)
3、子查询
1、什么是子查询？子查询会出现在哪里？
select语句当中嵌套select语句，被嵌套的select语句是子查询。
出现在哪里：
select
…(select)
from
…(select)
wehre
…(select)
2、where子句中使用子查询
找出高于平均薪资的员工信息。
第一步：；找出平均薪资。
select avg(sal) from emp;
+-------------+
| avg(sal) |
+-------------+
| 2073.214286 |
+-------------+
1 row in set (0.00 sec)
第二步：where过滤
select * from emp where sal>2073.214286;
+-------+-------+-----------+------+------------+---------+------+--------+
| EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
+-------+-------+-----------+------+------------+---------+------+--------+
| 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
| 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
| 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
| 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
| 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
| 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
+-------+-------+-----------+------+------------+---------+------+--------+
6 rows in set (0.00 sec)
第三步：合并
select * from emp where sal>(select avg(sal) from emp);
+-------+-------+-----------+------+------------+---------+------+--------+
| EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
+-------+-------+-----------+------+------------+---------+------+--------+
| 7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | NULL | 20 |
| 7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | NULL | 30 |
| 7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | NULL | 10 |
| 7788 | SCOTT | ANALYST | 7566 | 1987-04-19 | 3000.00 | NULL | 20 |
| 7839 | KING | PRESIDENT | NULL | 1981-11-17 | 5000.00 | NULL | 10 |
| 7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | NULL | 20 |
+-------+-------+-----------+------+------------+---------+------+--------+
6 rows in set (0.00 sec)
3、from后面嵌套子查询
找出每个部门平均薪水的薪资等级。
第一步：找出每个部门平均薪水（按照部门编号分组，求sal的平均值）
select deptno,avg(sal) as avgsal from emp group by deptno;
+--------+-------------+
| deptno | avgsal |
+--------+-------------+
| 20 | 2175.000000 |
| 30 | 1566.666667 |
| 10 | 2916.666667 |
+--------+-------------+
3 rows in set (0.00 sec)
第二步：将以上的查询结果当做临时表t，让t表和salgrade s表连接，条件是：t.avgsal between s.losal and s.hisal
select
t.*,s.grade
from
(select deptno,avg(sal) as avgsal from emp group by deptno) t
join
salgrade s
on
t.avgsal between s.losal and s.hisal;
+--------+-------------+-------+
| deptno | avgsal | grade |
+--------+-------------+-------+
| 20 | 2175.000000 | 4 |
| 30 | 1566.666667 | 3 |
| 10 | 2916.666667 | 4 |
+--------+-------------+-------+
3 rows in set (0.00 sec)
找出每个部门平均的薪水等级。
第一步：找出每个员工的薪水等级。
emp e 员工表
mysql> select ename,sal from emp;
+--------+---------+
| ename | sal |
+--------+---------+
| SMITH | 800.00 |
| ALLEN | 1600.00 |
| WARD | 1250.00 |
| JONES | 2975.00 |
| MARTIN | 1250.00 |
| BLAKE | 2850.00 |
| CLARK | 2450.00 |
| SCOTT | 3000.00 |
| KING | 5000.00 |
| TURNER | 1500.00 |
| ADAMS | 1100.00 |
| JAMES | 950.00 |
| FORD | 3000.00 |
| MILLER | 1300.00 |
+--------+---------+
14 rows in set (0.00 sec)
salgrade s 等级表
mysql> select * from salgrade;
+-------+-------+-------+
| GRADE | LOSAL | HISAL |
+-------+-------+-------+
| 1 | 700 | 1200 |
| 2 | 1201 | 1400 |
| 3 | 1401 | 2000 |
| 4 | 2001 | 3000 |
| 5 | 3001 | 9999 |
+-------+-------+-------+
5 rows in set (0.00 sec)
mysql> select e.ename,e.sal,e.deptno,s.grade from emp e join salgrade s on e.sal between s.losal and s.hisal;
+--------+---------+--------+-------+
| ename | sal | deptno | grade |
+--------+---------+--------+-------+
| SMITH | 800.00 | 20 | 1 |
| ALLEN | 1600.00 | 30 | 3 |
| WARD | 1250.00 | 30 | 2 |
| JONES | 2975.00 | 20 | 4 |
| MARTIN | 1250.00 | 30 | 2 |
| BLAKE | 2850.00 | 30 | 4 |
| CLARK | 2450.00 | 10 | 4 |
| SCOTT | 3000.00 | 20 | 4 |
| KING | 5000.00 | 10 | 5 |
| TURNER | 1500.00 | 30 | 3 |
| ADAMS | 1100.00 | 20 | 1 |
| JAMES | 950.00 | 30 | 1 |
| FORD | 3000.00 | 20 | 4 |
| MILLER | 1300.00 | 10 | 2 |
+--------+---------+--------+-------+
14 rows in set (0.00 sec)
第二步：基于以上结果，继续按照deptno分组，求grade平均值。
select
e.deptno,avg(s.grade)
from
emp e
join
salgrade s
on
e.sal between s.losal and s.hisal
group by
e.deptno;
+--------+--------------+
| deptno | avg(s.grade) |
+--------+--------------+
| 20 | 2.8000 |
| 30 | 2.5000 |
| 10 | 3.6667 |
+--------+--------------+
3 rows in set (0.00 sec)
4、select后面嵌套子查询
找出每个员工所在的部门名称，要求显示员工名和部门名。
以下的结果一样
select
e.ename,d.dname
from
emp e
join
dept d
on
e.deptno=d.deptno;
select
e.ename,(select d.dname from dept d where e.deptno = d.deptno) as dname
from
emp e;
+--------+------------+
| ename | dname |
+--------+------------+
| SMITH | RESEARCH |
| ALLEN | SALES |
| WARD | SALES |
| JONES | RESEARCH |
| MARTIN | SALES |
| BLAKE | SALES |
| CLARK | ACCOUNTING |
| SCOTT | RESEARCH |
| KING | ACCOUNTING |
| TURNER | SALES |
| ADAMS | RESEARCH |
| JAMES | SALES |
| FORD | RESEARCH |
| MILLER | ACCOUNTING |
+--------+------------+
14 rows in set (0.00 sec)
4、union（可以将查询结果集相加）
找出工资岗位是SALESMAN和MANAGER的员工？
第一种：or
select ename,job from emp where job='MANAGER' or job='SALESMAN';
第二种：in
select ename,job from emp where job in('MANAGER','SALESMAN');
+--------+----------+
| ename | job |
+--------+----------+
| ALLEN | SALESMAN |
| WARD | SALESMAN |
| JONES | MANAGER |
| MARTIN | SALESMAN |
| BLAKE | MANAGER |
| CLARK | MANAGER |
| TURNER | SALESMAN |
+--------+----------+
7 rows in set (0.00 sec)
第三种：union
select ename,job from emp where job = 'MANAGER' union select ename,job from emp where job = 'SALESMAN';
+--------+----------+
| ename | job |
+--------+----------+
| JONES | MANAGER |
| BLAKE | MANAGER |
| CLARK | MANAGER |
| ALLEN | SALESMAN |
| WARD | SALESMAN |
| MARTIN | SALESMAN |
| TURNER | SALESMAN |
+--------+----------+
7 rows in set (0.01 sec)
union：两张不相干的表中的数据拼接在一起显示。
union：使用时select后的字段数量必须一样。
5、limit 分页查询
limit是mysql特有的，其它数据库没有，不通过。（Oracle中有一个相同的机制，叫做 rownum）
limit取结果集中的部分数据，这是它的作用。
语法机制：
limit startIndex, length
startIndex表示起始位置，从0开始，0表示第一条数据
length表示取几个，直接写一个数字的话，前面默认就是0
取出工资前5名的员工（思路：降序取前5个）
select ename,sal from emp order by sal desc;
# 取前5个 limit 0,5
select ename,sal from emp order by sal desc limit 0,5;
+-------+---------+
| ename | sal |
+-------+---------+
| KING | 5000.00 |
| FORD | 3000.00 |
| SCOTT | 3000.00 |
| JONES | 2975.00 |
| BLAKE | 2850.00 |
+-------+---------+
5 rows in set (0.00 sec)
# 取前5个，limit 5，直接写一个数字的话，前面默认就是0
select ename,sal from emp order by sal desc limit 5;
+-------+---------+
| ename | sal |
+-------+---------+
| KING | 5000.00 |
| FORD | 3000.00 |
| SCOTT | 3000.00 |
| JONES | 2975.00 |
| BLAKE | 2850.00 |
+-------+---------+
5 rows in set (0.00 sec)
limist是sql语句最后执行的一个环节
select 5
...
from 1
...
where 2
...
group by 3
...
having 4
...
order by 6
...
limit 7
...
找出工资排名在第4到第9名的员工？
select ename,sal from emp order by sal desc limit 3,6;
+--------+---------+
| ename | sal |
+--------+---------+
| JONES | 2975.00 |
| BLAKE | 2850.00 |
| CLARK | 2450.00 |
| ALLEN | 1600.00 |
| TURNER | 1500.00 |
| MILLER | 1300.00 |
+--------+---------+
6 rows in set (0.00 sec)
6、通用的标准分页sql？
每页显示3条记录：
第1页：0，3 （0，1，2）
第2页：3，3 （3，4，5）
第3页：6，3 （6，7，8）
第4页：9，3 （9，10，11）
第5页：12，3 （12，13，14）
每页显示pageSize条记录：
第pageNo页：(pageNo - 1) * pageSize, pageSize
pageNo：显示第几页
pageSize：是每页显示多少条记录
java代码{
int pageNo = 2; // 页码2
int pageSize = 10; // 每页显示10条
limit (pageNo - 1) * pageSize, pageSize
limit (2 - 1) * 10, pageSize
limit 10,10
}
6、创建表
语法格式：
create table 表名(
字段名1 数据类型,
字段名2 数据类型,
字段名3 数据类型,
......
);
关于MySQL当中字段的数据类型，常见的数据类型
int 整数型（Java中的int）
bigint 长整型（Java中的long）
float 浮点型（Java中的float double）
char 定长字符串（String）
varchar 可变长字符串（StringBuffer StringBuilder）255
date 日期类型（Java中的java.sql.Date类型）
blob 二进制大对象（存储图片、视频等媒体信息）（Java中的Object）
clob 字符大对象（存储较大文本，比如，可以存储4G的字符串）（Java中的Object）
char和varchar怎么选择？
在实际的开发中，当某个字段中的数据长度不发生改变的时候，是定长从的，例如：性别、生日等都是采用char。
当一个字段的数据长度不确定，例如：简介、姓名等都是采用varchar。
blob和clob类型的使用？
需要使用IO流
媒体类型一般不会直接把它放进数据库中，而是把媒体类型的数据通过路径放置在数据库中，这样通常采用char或varchar类型。
电影表：t_movie
id(int) name(varchar) playtime(date/char) haibao(blob) history(clob)
1 蜘蛛侠
2
3
表名在数据库当中一般建议：t_或者tbl_开始
创建学生表：
学生信息包括：
学号、姓名、性别、班级编号、生日
学号：bigint
姓名：varchar
性别：char
班级编号：varchar
生日：char
create table t_student(
no bigint,
name varchar(255),
sex char(1),
classno varchar(255),
birth char(10)
);
7、insert 语句插入数据
语法格式：
要求：字段的数量和值的数量相同，并且数据类型要对应相同。
insert into 表名(字段名1,字段名2,字段名3,...) values(值1,值2,值3,...);
insert into t_student(no,name,sex,classno,birth) values(1,'zhangsan','1','gaosan1ban','1950-10-12');
可以改变字段顺序，但是前后要对应
insert into t_student(name,sex,classno,birth,no) values('lisi','1','gaosan1ban','1950-10-12',2);
可以写一个字段，剩下的所有字段自动插入NULL
insert into t_student(name) values('wangwu');
drop table if exists t_student; # 当这个表存在的话删除
default默认值
create table t_student(
no bigint,
name varchar(255),
sex char(1) default 1,
classno varchar(255),
birth char(10)
);
insert into t_student(name) values('zhangsan');
select * from t_student;
+------+----------+------+---------+-------+
| no | name | sex | classno | birth |
+------+----------+------+---------+-------+
| NULL | zhangsan | 1 | NULL | NULL |
+------+----------+------+---------+-------+
注意：当一条insert语句执行成功之后，表格当中必然会多一行记录。
即使多的这一行记录当中某些字段是NULL，后期也没有办法执行。
insert语句插入数据了，只能使用update进行更新。
字段可以省略不写，但是后面的values对数量和顺序都有要求。
insert into t_student values(1,'jack','0','gaosan2ban','1986-10-23');
插入多条记录
insert into t_student
(no,name,sex,classno,birth)
values
(3,'rose','1','gaosi2ban','1952-12-14'),
(4,'laotie','1','gaosi2ban','1952-12-19');
8、表的复制
语法：
create table 表面 as select语句;
将查询结果当做表创建出来。
create table emp1 as select * from emp;
create table emp2 as select empno,ename from emp;
9、将查询结果插入到一张表中
插入字段有要求，必须字段数量对应。
insert into dept1 select * from dept;
10、修改数据：update
语法格式：
update 表名 set 字段名1=值1,字段名2=值2... where 条件;
注意：没有条件整张表数据全部更新。
将部门10的LOC修改为SHANGHAI，将部门名称修改为RENSHIBU
update dept1 set loc='SHANGHAI',dname='RENSHIBU' where deptno=10;
更新所有记录
update dept1 set loc='x', dname='y';
11、删除数据
语法格式：
delete from 表名 where 条件；
注意：没有条件全部删除。
删除10部门数据？
delete from dept1 where deptno=10;
删除所有记录？
delete from dept1;
怎么删除大表？（重点）
truncate table emp1; # 表被截断，不可回滚，永久丢失。
12、表结构的修改
直接使用工具即可，正常情况下，表一旦设计好之后，表结构很少就行修改。
修改表结构的语句不会出现在Java代码当中，只有insert delete update select这些都是表中的数据操作。
增删改查有一个术语：CRUD操作
create（增)
Retriave（检索）
Update（修改）
Delete（删除）
13、约束(Constraint)
什么是约束？常见的约束有哪些？
在创建表的时候，可以给表的字段添加相应的约束，添加约束的目的是为了保证表中数据的合法性、有效性、完整性。
常见的约束有哪些呢？
非空约束（not null）：约束的字段不能为NULL
唯一约束（unique）：约束的字段不能重复
主键约束（primary key）：约束的字段既不能为NULL，也不能重复（简称 PK）
外键约束（foreign key）：…（简称 FK）
检查约束（check）：注意Orcle数据库有check约束，但是MySQL没有，目前mySQL不支持该约束。
14、非空约束 not null
drop table if exists t_user;
create table t_user(
id int,
username varchar(255) not null,
password varchar(255)
);
insert into t_user(id,username,password) values(1,'lisi','123');
1、唯一性约束（unique）
唯一约束修饰的字段具有唯一性，不能重复。但可以为NULL。
列级约束
表级约束
案例：给某一列添加unique
drop table if exists t_user;
create table t_user(
id int,
username varchar(255) unique # 列级约束，可以使用表级约束来添加一个字段，效果一样
);
insert into t_user values(1,'zhangsan');
insert into t_user values(2,'zhangsan'); # ERROR 1062 (23000): Duplicate entry 'zhangsan' for key 'username'（字段重复报错 ）
insert into t_user(id) values(2);
insert into t_user(id) values(3);
insert into t_user(id) values(4);
案例：给两个列或者多个列添加unique
drop table if exists t_user;
create table t_user(
id int,
usercode varchar(255),
username varchar(255),
unique(usercode,username) # 多个字段联合起来添加约束，不能重复，就添加了一个约束（表级约束）
);
insert into t_user values(1,'111','zs');
insert into t_user values(2,'111','ls');
insert into t_user values(3,'222','zs');
insert into t_user values(3,'111','zs'); # ERROR 1062 (23000): Duplicate entry '111-zs' for key 'usercode'
select * from t_user;
drop table if exists t_user;
create table t_user(
id int,
usercode varchar(255) unique,
username varchar(255) unique
);
insert into t_user values(1,'111','zs');
insert into t_user values(2,'111','ls'); # ERROR 1062 (23000): Duplicate entry '111' for key 'usercode'
select * from t_user;
注意：not null约束只有列级约束， 没有表级约束。
2、主键约束
怎么给一张表添加主键约束？
drop table if exists t_user;
create table t_user(
id int primary key, // 列级约束
username varchar(255),
email varchar(255)
);
insert into t_user(id,username,email) values(1,'zs','[email protected]');
insert into t_user(id,username,email) values(2,'ls','[email protected]');
insert into t_user(id,username,email) values(3,'ww','[email protected]');
select * from t_user;
insert into t_user(id,username,email) values(1,'jack','[email protected]'); # ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'
insert into t_user(username,email) values('jack','[email protected]'); # ERROR 1364 (HY000): Field 'id' doesn't have a default value
总结：id是主键，因为添加了主键约束，主键字段中的数据不能为NULL，也不能重复。
主键的特点：不能为NULL，也不能重复(具有唯一性)。
主键相关的术语：
主键约束：primary key
主键字段：id字段添加primary key之后，id叫做主键字段
主键值：id字段中的每一个值都是主键值
主键有什么作用：
表的设计三范式中有要求，第一范式就要求任何一张表都应该有主键。
主键的作用：主键值是这行记录在这张表当中的唯一标识。（就像一个人的身份证号码一样）
主键的分类：
根据主键字段的字段数量来划分：
单一主键（推荐，常用）
复合主键（多个字段联合起来添加一个主键约束）（复合主键不建议使用，因为复合主键违背三范式）
根据主键性质来划分：
自然主键：主键值最好就是一个和业务没有任何关系的自然数。（推荐，常用）
业务主键：主键值和系统的业务挂钩，例如：拿着银行卡的卡号做主键，拿着身份证号码作为主键。（不建议使用）
最好不要拿着和业务挂钩的字段作为主键。因为以后的业务一旦发发生改变的时候，主键值可能也需要随着发生变化，但有的时候没有办法变化，因为变化可能会导致主键值重复。
一张表的主键约束只能有1个。（必须记住）
使用表级约束方式定义主键：
drop table if exists t_user;
create table t_user(
id int,
username varchar(255),
primary key(id)
);
insert into t_user(id,username) values(1,'zs');
insert into t_user(id,username) values(2,'ls');
insert into t_user(id,username) values(3,'ww');
insert into t_user(id,username) values(4,'cs');
select * from t_user;
insert into t_user(id,username) values(4,'cs'); # ERROR 1062 (23000): Duplicate entry '4' for key 'PRIMARY'
mysql提供主键值自增：（auto_increment）(重点)
drop table if exists t_user;
create table t_user(
id int primary key auto_increment, # id字段自动维护一个自增的数据，从1开始，以1递增。
username varchar(255)
);
insert into t_user(username) values('a');
insert into t_user(username) values('b');
insert into t_user(username) values('c');
insert into t_user(username) values('e');
insert into t_user(username) values('e');
insert into t_user(username) values('f');
select * from t_user;
提示：Oracle当中也提供了一个自增机制，叫做：序列（sequence）对象。
3、外键约束
相关术语：
外键约束：foreign key，外键约束上的值不能顺便写，必须来自某一张表里某个字段的值，被引用的字段必须具有唯一性。
外键字段：添加有外键约束的字段
外键值：外键字段中的每一个值
业务背景：
请设计数据库表，用来维护学生和班级的信息？
第一种方案：一张表存储所有数据
no(pk) name classno classname
1 zs1 101 北京大兴区经济技术开发区亦庄二中高三1班
2 zs2 101 北京大兴区经济技术开发区亦庄二中高三1班
3 zs3 102 北京大兴区经济技术开发区亦庄二中高三2班
4 zs4 102 北京大兴区经济技术开发区亦庄二中高三2班
5 zs5 102 北京大兴区经济技术开发区亦庄二中高三2班
缺点：冗余（不推荐）
第二种方案：两张表（班级表和学生表）
t_class 班级表
cno(pk) cname
101 北京大兴区经济技术开发区亦庄二中高三1班
102 北京大兴区经济技术开发区亦庄二中高三2班
t_student 学生表
sno(pk) sname classno(该字段添加外键约束fk)
1 zs1 101
2 zs2 101
3 zs3 102
4 zs4 102
5 zs5 102
将以上表的建表语句写出来：
t_student中的classno字段引用t_class表中的cno字段，此时t_student表叫做子表。t_class表叫做父表。
顺序要求：（添加父表先，删除子表先）
删除数据的时候，先删除子表，在删除父表。
添加数据的时候，先添加父表，在添加子表。
创建表的时候，先创建父表，再创建子表。
删除表的时候，先删除子表，再删除父表。
drop table if exists t_student;
drop table if exists t_class;
create table t_class(
cno int,
cname varchar(255),
primary key(cno)
);
create table t_student(
sno int,
sname varchar(255),
classno int,
foreign key(classno) references t_class(cno)
);
insert into t_class values(101,'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
insert into t_class values(102,'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy');
insert into t_student values(1,'zs1',101);
insert into t_student values(2,'zs2',101);
insert into t_student values(3,'zs3',102);
insert into t_student values(4,'zs4',102);
insert into t_student values(5,'zs5',102);
insert into t_student values(6,'zs6',102);
select * from t_class;
select * from t_student;
insert into t_student values(7,'lisi',103); # ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`staff`.`t_student`, CONSTRAINT `t_student_ibfk_1` FOREIGN KEY (`classno`) REFERENCES `t_class` (`cno`))
外键可以为NULL。
被引用的字段不一定是主键，但至少具有unique(唯一性)约束，一般情况引用的是主键。
存储引擎（了解）
1、完整的建表语句这样写的
CREATE TABLE `t_x` (
`id` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
注意：在MySQL当中，凡是标识符是可以使用飘号括起来的。最好别用，不通用。
建表的时候可以指定存储引擎，也可以指定字符集。
mysql默认使用的存储引擎是InnoDB方式。
默认采用的字符集是UTF-8。
2、什么是存储引擎你？
存储引擎这个名字只有在mysql中存在。（Orcale中有对应的机制，但是不叫做存储引擎，Oracle中没有特殊的名字，就是表的存储方式）
存储引擎就是表的存储方式。
mysql支持很多存储引擎，每一个存储引擎都对应了一种不同的存储方式。
每一个存储引擎都有自己的优缺点，需要在合适的时机选择合适的存储引擎。
3、查看当前MySQL支持的存储引擎？
show engines \G
mysql8支持的存储引擎有9个
4、常见的存储引擎
MyISAM存储引擎
Engine: MyISAM
Support: YES
Comment: MyISAM storage engine
Transactions: NO
XA: NO
Savepoints: NO
MyISAM这种存储引擎不支持事务。
MyISAM是mysql最常用的存储 引擎，但是这种引擎不是默认的。
MyISAM采用三个文件组织一张表：
xxx.frm（存储格式的文件）
xxx.MYD（存储表中数据的文件）
xxx.MYI（存储表中索引的文件）
优点：可被压缩，节省存储空间。并且可以转换为只读表，提高检索效率。
缺点：不支持事务。
InnoDB存储引擎（默认存储引擎，常用）
Engine: InnoDB
Support: DEFAULT
Comment: Supports transactions, row-level locking, and foreign keys
Transactions: YES
XA: YES
Savepoints: YES
优点：支持事务、行级锁、外键等。这种存储引擎数据的安全得到保障。
表的结构存储在xxx.frm文件中
数据存储在tablespace这样的表空间中（逻辑概念），无法被压缩，无法转换成自读。
这种InnoDB存储引擎在MySQL数据库奔溃之后提供自动恢复机制。
InnoDB支持级联删除和级联更新。
MEMORY存储引擎
Engine: MEMORY
Support: YES
Comment: Hash based, stored in memory, useful for temporary tables
Transactions: NO
XA: NO
Savepoints: NO
缺点：不支持事务。断电后数据会丢失。因为所有数据和索引都是存储在内存当中的。
优点：查询速度最快。
视图（了解）
视图：站在不同的角度去看数据。（同一张表的数据，通过不同的角度去看待）
创建与删除视图：
create view myview as select empno,ename from emp;
drop view myview
注意：只有DQL语句才能以视图对象的方式创建出来。
对视图进行增删改查，会影响到原表数据。（通过视图影响原表数据的，不是直接操作的原表）
可以对视图进行CRUD操作。
面向视图操作：
select * from myview;
+-------+--------+
| empno | ename |
+-------+--------+
| 7369 | SMITH |
| 7499 | ALLEN |
| 7521 | WARD |
| 7566 | JONES |
| 7654 | MARTIN |
| 7698 | BLAKE |
| 7782 | CLARK |
| 7788 | SCOTT |
| 7839 | KING |
| 7844 | TURNER |
| 7876 | ADAMS |
| 7900 | JAMES |
| 7902 | FORD |
| 7934 | MILLER |
+-------+--------+
create table emp_bak as select * from emp;
create view myview1 as select empno,ename,sal from emp_bak;
update myview1 set ename='hehe',sal=1 where empno=7369; # 通过视图修改原表数据
delete from myview1 where empno=7369; # 通过视图删除原表数据
视图作用：视图可以隐藏表的实现细节，保密级别较高的系统，数据库只对外提供相关的视图，Java程序员只对视图对象进行CRUD。
数据库数据的导入导出（DBA命令）
导出整个数据库：在dos命令窗口中执行
mysqldump 数据库>D:\数据库.sql -uroot -p密码
导出指定库下的指定表：在dos命令窗口中执行
mysqldump 数据库 表名>D:\数据库.sql -uroot -p密码
导入数据：
create database 数据库;
use 数据库;
source D:\数据库.sql
事务（Transaction）
1、 什么是事务？
一个事务是一个完整的业务逻辑单元，不可再分。
比如：银行账户转账，从A账户向B账户转账10000，需要执行两条update语句。
update t_act set balance=balance-1000 where actno='act-001';
update t_act set balance=balance+1000 where actno='act-002';
以上两条DML语句必须同时成功，或者同时失败，不允许出现一条成功，一条失败。
要想保证以上的两条DML语句同时成功或者同时失败，那么就需要使用数据库的 ”事务机制“ 。
2、和事务相关的语句只有：DML语句。（insert delete update）
因为它们这三个语句都是和数据库表当中的 ”数据“ 相关的。
事务的存在是为了保证数据的完整性，安全性。
3、假设所有的业务都能使用1条DML语句搞定，还需要事务机制吗？
不需要事务。
但实际情况不是这样的，通常一个事儿（事务【业务】）需要多条DML语句共同联合完成。
4、事务的特性？
事务包括四大特性：ACID
A：原子性：事务是最小的工作单元，不可再分。
C：一致性：事务必须保证多条DML语句同时成功或者同时失败。
I： 隔离性：事务A与事务B之间具有隔离。
D：持久性：最终数据必须持久化到硬盘文件中，事务才算成功的结束。
5、关于事务之间的隔离性
事务隔离性存在隔离级别，理论上隔离级别包括4个：
第一级别：读未提交（read uncommitted）
对方事务还没有提交，我们当前事务可以读取到对方未提交的数据。
读未提交存在脏读（Dirty Read）现象：表示读到了脏的数据。
第二级别：读已提交（read committed）
对方事务提交之后的数据我方可以读取到。
这种隔离级别解决了：脏读现象没有了。
读已提交存在的问题是：不可重复读。
第三级别：可重复读（repeatable read）
这种隔离级别解决了：不可重复读问题。
这种隔离级别存在的问题是：读取到的数据是幻象。
第四级别：序列化读/串行化读（serializable）
解决了所有问题。
效率低。需要事务排队。
Oracle数据库默认的隔离级别是：读已提交。
MySQL数据库默认的隔离级别是：可重复读。
6、演示事务
mysql事务默认情况下是自动提交的。
（什么是自动提交？只要执行任意一条DML语句则提交一次。）怎么关闭自动提交？start transaction;
如果要保存点，会回滚到保存点。
建表：
drop table if exists t_user;
create table t_user(
id int primary key auto_increment,
username varchar(255)
);
演示：mysql中的事务是自动提交的，只要执行一条DML，则提交一次。
mysql> insert into t_user(username) values('zs');
Query OK, 1 row affected (0.01 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
演示：使用start transaction关闭自动提交事务。
回滚
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t_user(username) values('lisi');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('wangwu');
Query OK, 1 row affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 2 | lisi |
| 3 | wangwu |
+----+----------+
3 rows in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
+----+----------+
1 row in set (0.00 sec)
提交
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t_user(username) values('wangwu');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('reos');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t_user(username) values('jack');
Query OK, 1 row affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from t_user;
+----+----------+
| id | username |
+----+----------+
| 1 | zs |
| 4 | wangwu |
| 5 | reos |
| 6 | jack |
+----+----------+
4 rows in set (0.00 sec)
索引
1、什么是索引？有什么用？
索引就相当于一本书的目录，通过目录可以快速的找到对应的资源。
在数据库方面，查询一张表的时候有两张检索方式：
第一种方式：全表扫描
第二种方式：根据索引检索（效率很高）
索引为什么可以提高检索效率呢？
其实最根本的原理是缩小了扫描的范围。
索引虽然可以提高检索效率，但是不能随意的添加索引，因为索引也是数据库中的对象，也需要数据库不断的维护。是有维护成本的。比如，表中的数据经常被修改这个就不适合添加索引，因为数据一旦修改，索引需要重新排序，进行维护。
添加索引是给某一个字段，或者说某些字段添加索引。
select ename,sal from emp where ename='SMITH';
当ename字段上没有添加索引的时候，以上sql语句会进行全表扫描，扫描ename字段中所有的值。
当ename字段上添加索引的时候，以上sql语句会根据索引扫描，快速定位。
2、怎么创建索引对象？怎么删除索引对象？
创建索引对象：
create index 索引名称 on 表名(字段名);
删除索引对象：
drop index 索引名称 on 表名；
3、什么时候考虑给字段添加索引？（满足什么条件）
- 数据量庞大（根据客户的需求，根据线上的环境）
- 该字段很少的DML的操作 （因为字段进行修改操作，索引也需要维护）
- 该字段经常出现在where子句中（经常根据哪个字段查询）
4、注意：主键和具有unique约束的字段会自动添加索引。
根据主键查询效率较高。尽量根据主键检索。
5、查看sql语句的执行计划（explain）
只有MySQL有
mysql> explain select ename,sal from emp where sal = 5000;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| 1 | SIMPLE | emp | NULL | ALL | NULL | NULL | NULL | NULL | 14 | 10.00 | Using where |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
给薪资sal字段添加索引：
create index emp_sal_index on emp(sal);
mysql> explain select ename,sal from emp where sal = 5000;
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
| 1 | SIMPLE | emp | NULL | ref | emp_sal_index | emp_sal_index | 9 | const | 1 | 100.00 | NULL |
+----+-------------+-------+------------+------+---------------+---------------+---------+-------+------+----------+-------+
6、索引底层采用的数据结构是：B + Tree
7、索引的实现原理？
通过B Tree 缩小扫描范围，底层索引进行了排序，分区，索引会携带数据在表中的 “物理地址”，
最终通过索引检索到数据之后，获取到关联的物理地址，通过物理地址定位表中的数据，效率是最高的。
select ename from emp where ename='SMITH';
通过索引转换为：
select ename from emp where 物理地址=0x3;
8、索引的分类？
单一索引：给单个字段添加索引
复合索引：给多个字段联合起来添加1个索引
主键索引：主键上会自动添加索引
唯一索引：有unique约束的字段上会自动添加索引
9、索引什么时候失效？
模糊查询的时候，第一个通配符使用的是 % ，这个时候索引是失效的。
select ename from emp where ename like '%A%';
数据库的三大设计规范（重点内容，面试经常问）
1、什么是设计范式？
设计表的依据，按照这个三范式设计的表不会出现数据冗余。
2、三范式都是哪些？
第一范式：任何一张表都应该有主键，并且每一个字段原子性不可再分。
第二范式：建立在第一范式的基础之上，所有非主键字段完全依赖主键，不能产生部分依赖。
多对多，三张表，关系表两个外键。
t_student学生表
sno(pk) sname
1 张三
2 李四
3 王五
t_teacher讲师表
tno tname
1 王老师
2 张老师
3 李老师
t_student_teacher_relation 学生讲师关系表
id(pk) sno(fk) tno(fk)
1 1 3
2 1 1
3 2 2
4 2 3
5 3 1
6 3 3
第三范式：建立在第二范式的基础之上，所有非主键字段直接依赖主键，不能产生传递依赖。
一对多，两张表，多的表加外键。
班级t_class
cno(pk) cname
1 a
2 b
3 c
4 d
学生t_student
sno(pk) sname classnoo(fk)
101 张1 1
102 张2 1
103 张3 2
104 张4 2
105 张5 2
提醒（面试的时候可以说）：在实际的开发中，以满足客户的需求为主，有的时候会拿冗余换执行速度。
3、一对一怎么设计？
一对一设计有两张方案：主键共享
t_user_login 用户登录表
id(pk) username password
1 zs 123
2 ls 456
t_user_detail 用户详细信息表
id(pk) realname tel
1 张三 111111111
2 李四 111132321
一对一设计有两张方案：外键唯一
t_user_login 用户登录表
id(pk) username password
1 zs 123
2 ls 456
t_user_detail 用户详细信息表
id(pk) realname tel userid(fk+unique)
1 张三 111111111 2
2 李四 111132321 1
SQL的执行顺序
(1) FROM [left_table] 选择表
(2) ON <join_condition> 链接条件
(3) <join_type> JOIN <right_table> 链接
(4) WHERE <where_condition> 条件过滤
(5) GROUP BY <group_by_list> 分组
(6) AGG_FUNC(column or expression),... 聚合/分组
(7) HAVING <having_condition> 分组过滤
(8) SELECT (9) DISTINCT column,... 选择字段、去重
(9) ORDER BY <order_by_list> 排序
(10) LIMIT count OFFSET count; 分页
常见函数
Mysql数据库提供了丰富的函数，类似于Java里的方法。
lower() 函数
该字段全部转换成小写
LOWER(Str 字段名称)
select lower(ename) from emp;
upper() 函数
该字段全部转换成大写
UPPER(Str 字段名称)
length() 函数
查询字段长度，一个字母算一个字符，一个汉字算三个字符
LENGTH(Str 字段名称)
concat() 函数
拼接字符串
CONCAT(Str 字段名称,Str 拼接的内容,Str 拼接的内容…)
substr() 函数
截取字符串
SUBSTR(字段名称,开始截取的位置,截取的总长度)
**注意：**索引从1开始
replace() 函数
替换
REPLACE(Str 字段名称,from_str 要替换内容,to_str 新的内容)
ifnull() 函数
判断是否为null，如果是null就替换成0或1等
IFNULL(expr1 字段名称, expr2 要替换的新内容)
**注意：**做运算时数据库中出现NULL，不参与运算，永远为NULL
round() 函数
小数，四舍五入
ROUND(字段名称)
ceil() 函数
小数，向上取整，有小数的小数去掉整数加一
CEIL(字段名称)
floor() 函数
小数，向下取整，有小数的把小数去掉
FLOOR(字段名称)
now() 函数
查询现在的时间，年月日时分秒
NOW()
curdate() 函数
年月日
CORDATE()
curtime() 函数
时分秒
CORTIME()
year() 函数
年
YEAR(date 日期) / YEAR(date 字符串写个日期)
month() 函数
月
MONTH(date 日期) / MONTH(date 字符串写个日期数据)
day() 函数
日
DAY(date 日期) / DAY(date 字符串写个日期数据)
hour() 函数
时
HOUR(date 日期) / HOUR(date 字符串写个日期数据)
minute() 函数
分
MINUTE(date 日期) / MINUTE(date 字符串写个日期数据)
second() 函数
秒
SECOND(date 日期) / SECOND(date 字符串写个日期数据)
timestampdiff()函数
计算两个日期的时间差，可以是年、月、日、时、分、秒、星期、星期
timestampdiff(间隔类型，前一个日期，后一个日期)
转义字符
‘ 作为SQL语句符号，内容中出现单撇就会乱套，进行转义即可
方法一：使用 一个 \ 转义变成普通字符
方法二：外面使用 " "
select
ename,
lower(ename),
upper(ename),
length(ename),
concat(ename,'hello',100),
substr(ename,2),
substr(ename,1,3),
replace(ename,'S','666'),
ifnull(comm,0),
round(sal),
ceil(sal),
floor(sal),
now(),
curdate(),
curtime(),
year('1999-02-12'),month(now()),day(now()),hour(now()),minute(curtime()),second('12:22:1')
from
emp;
SQL优化
1、插入数据优化
2、主键优化
主键乱序插入可能出现页分裂现象。
3、order by优化
4、group by优化
5、limit优化
6、count优化
7、update优化
尽量根据主键 / 索引字段进行数据更新
总结
- 尽量使用字段名代替*
- 做表设计时，字段的类型最好是varchar代替char
- 字段里的值，最好用数字代替字符串
- 尽量把过滤条件精细，能用and不用or
- 索引的设计，最多5个索引，不能太多
- 模糊查询，尽量要确定开始元素，让索引生效
- 数据库对数字没有严格要求，name=123索引失效，name='123’索引生效
- 无用的索引最好即时删除
not int 在使用的时候，后面小括号中记得排除NULL