《黑马程序员 MySQL数据库入门到精通，从MySQL安装到MySQL高级、MySQL优化全囊括》——学习笔记基础篇
基础篇
前言
本文仅用作个人笔记使用，整理自《黑马程序员 MySQL数据库入门到精通，从MySQL安装到MySQL高级、MySQL优化全囊括》(https://www.bilibili.com/video/BV1Kr4y1i7ru/)
什么是数据库？
- 数据库：
DataBase简称 ：DB- 是按照数据结构来组织、存储和管理数据的仓库。
- 是保存有组织的数据的一种容器，通常表现为一个或一组文件
- 我们也可以将数据存储在文件中，但是在文件中读写数据速度相对较慢。
- 所以，现在我们使用关系型数据库管理系统（RDBMS）来存储和管理大数据量。所谓的关系型数据库，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。
- 数据库的作用：将一组具有相同特征的数据以表为基础单位通过存储介质进行高效地存储,存储介质:内存、磁盘
- 概念混淆点：数据库及数据库软件是错误的
- 数据库系统：
DataBase System = DBMS + DB - 数据库软件——DBMS，数据库管理系统,过DBMS来创建和管理数据库
- 一般开发人员会针对每一个应用创建一个数据库。为保存应用中实体的数据，一般会在数据库创建多个表，以保存程序中实体用户的数据
数据库类别
-
基于存储介质可以分为关系型数据库与非关系型数据库：
- 关系型数据库是将数据存放于磁盘中，非关系型数据库则存放于内存里
- 在数据访问性能上看非关系型数据库的效率更高；在数据安全性、持久性看，关系型数据库有明显优势。关系型数据库有利于数据的持久化保存与管理
-
关系型数据库产品：
-
大型：Oracle、DB2
-
中型：MySQL、SQL-SERVER等
-
小型：access等
-
-
非关系型数据库产品：
- Memcached
- MongoDB
- Redis（同步技术，数据同步到磁盘）
-
数据库排名：https://db-engines.com/en/ranking
-
定义：关系型数据库是建立在关系模型上的数据库，关系模型是一种建立在关系上的模型，大致上分为：
- 数据结构：数据以二维表形式存储（行和列）
- 操作指令集合：SQL语句
- 完整性约束：对于表内的约束和表与表之间的约束（实体内部、实体之间）
而本文所学习、研究的对象就是RDBMS中的MySQL数据库。
RDBMS 即关系数据库管理系统(Relational Database Management System)的特点：
- 数据以表格的形式出现
- 每行为各种记录名称
- 每列为记录名称所对应的数据域
- 许多的行和列组成一张表单
- 若干的表单组成database，格式统一，便于维护
- 使用SQL语言操作，标准同意，使用方便
**概念：**建立在关系模型基础上，由多张相互连接的二维表组成的数据库。
SQL语言
SQL通用语法
-
SQL语句可以单行或多行书写，
最后以分号结尾。 -
SQL语句可以使用空格/缩进来增强语句的可读性。
-
MySQL数据库的SQL语句不区分大小写，但是为了可读性建议关键字使用大写。
-
注释：
单行注释： --单行注释 或 #单行注释 多行注释： /* 这是多行注释 这是多行注释 这是多行注释 */
SQL分类
| 分类 | 全称 | 说明 |
|---|---|---|
| DDL | Data Definition Language | 数据定义语言，用来定义数据库对象（数据库，表，字段） |
| DML | Data Manipulation Language | 数据操作语言，用来对数据库表中的数据进行增删改 |
| DQL | Data Query Language | 数据查询语言，用来查询数据库中表的记录 |
| DCL | Data Control Language | 数据控制语言，用来创建数据库的用户以及权限的管理 |
DDL-数据定义语言
数据库-查询
查询所有数据库：SHOW DATABASES;
(Wed Aug 10 13:44:49 2022)[root@MySQL][(none)]>show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
4 rows in set (0.00 sec)
查询当前数据库：SELECT DATABASE();
(Wed Aug 10 13:46:52 2022)[root@MySQL][mysql]>select database();
+------------+
| database() |
+------------+
| mysql |
+------------+
1 row in set (0.00 sec)
数据库-创建
创建数据库：CREATE DATABASE [IF NOT EXISTS] 数据库名称 [DEFAULT CHARSET 编码] [COLLATE 排序规则];
#如果当前服务端不存在testdb数据库的话就创建一个名叫testdb的数据库，并指定它的编码为utf8mb4。
(Wed Aug 10 13:50:33 2022)[root@MySQL][(none)]>create database if not exists testdb default charset utf8mb4;
Query OK, 1 row affected (0.00 sec)
(Wed Aug 10 13:53:52 2022)[root@MySQL][(none)]>show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
| testdb |
+--------------------+
5 rows in set (0.00 sec)
在这里多提一嘴，在创建数据库时不建议将编码指定为utf8，因为在MySQL中utf8的存储长度为3字节，而有一些特殊的字符需要占到4字节。
数据库-删除
删除数据库：DROP DATABASE [IF EXISTS] 数据库名称；
#如果存在名称为testdrop的数据库，那么就将其删除。
(Wed Aug 10 14:01:00 2022)[root@MySQL][(none)]>show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
| testdb |
+--------------------+
5 rows in set (0.00 sec)
数据库-切换
切换数据库：USE 数据库名称;
#将当前数据库切换至testdb数据库。
(Wed Aug 10 14:01:02 2022)[root@MySQL][(none)]>use testdb;
Database changed
(Wed Aug 10 14:02:34 2022)[root@MySQL][testdb]> #原先这里的none就变成了testdb
表-数据类型
原文地址：详解MySQL数据类型 - 五月的仓颉 - 博客园 (cnblogs.com)
整型
| 数据类型 | 字节数 | 带符号最小值 | 带符号最大值 | 不带符号最小值 | 不带符号最大值 |
|---|---|---|---|---|---|
| TINYINT | 1 | -128 | 127 | 0 | 255 |
| SMALLINT | 2 | -32768 | 32767 | 0 | 65535 |
| MEDIUMINT | 3 | -8388608 | 8388607 | 0 | 16777215 |
| INT | 4 | -2147483648 | 2147483647 | 0 | 4294967295 |
| BIGINT | 8 | -9223372036854775808 | 9223372036854775807 | 0 | 18446744073709551616 |
即使是带符号的BIGINT，其实也已经是一个天文数字了，什么概念，9223372036854775807我们随便举下例子：
- 以byte为例可以表示8589934592GB–>8388608TB–>8192PB
- 以毫秒为例可以表示292471208年
所以从实际开发的角度，我们一定要为合适的列选取合适的数据类型，即到底用不用得到这种数据类型？举个例子：
- 一个枚举字段明明只有0和1两个枚举值，选用TINYINT就足够了，但在开发场景下却使用了BIGINT，这就造成了资源浪费
- 简单计算一下，假使该数据表中有100W数据，那么总共浪费了700W字节也就是6.7M左右，如果更多的表这么做了，那么浪费的更多
要知道，MySQL本质上是一个存储，以Java为例，可以使用byte类型的地方使用了long类型问题不大，因为绝大多数的对象在程序中都是短命对象，方法执行完毕这块内存区域就被释放了，7个字节实际上不存在浪不浪费一说。但是MySQL作为一个存储，8字节的BIGINT放那儿就放那儿了，占据的空间是实实在在的。
举个例子：
drop table if exists test_tinyint;
create table test_tinyint (
num tinyint
) engine=innodb charset=utf8;
insert into test_tinyint values(-100);
insert into test_tinyint values(255);
执行第7行的代码时候报错"Out of range value for column ‘num’ at row 1"，即很清楚的我们可以看到插入的数字范围越界了，这也同样反映出MySQL中整型默认是带符号的。
把第3行的num字段定义改为"num tinyint unsigned"第7的插入就不会报错了，但是第6行的插入-100又报错了，因为无符号整型是无法表示负数的。
整型（N）形式
在开发中，我们会碰到有些定义整型的写法是int(11)，这种写法从我个人开发的角度看我认为是没有多大用，不过作为一个知识点做一下讲解吧。
int(N)我们只需要记住两点：
- 无论N等于多少，int永远占4个字节
- N表示的是显示宽度，不足的用0补足，超过的无视长度而直接显示整个数字，但这要整型设置了unsigned zerofill才有效
浮点型
整型之后，下面是浮点型，在MySQL中浮点型有两种，分别为float、double，它们用一张表格总结一下：
| 数据类型 | 字节数 | 备注 |
|---|---|---|
| float | 4 | 单精度浮点数 |
| double | 8 | 双精度浮点数 |
从这个结果我们总结一下float(M,D)、double(M、D)的用法规则：
- D表示浮点型数据小数点之后的精度，假如超过D位则四舍五入，即1.233四舍五入为1.23，1.237四舍五入为1.24
- M表示浮点型数据总共的位数，D=2则表示总共支持五位，即小数点前只支持三位数，所以我们并没有看到1000.23、10000.233、100000.233这三条数据的插入，因为插入都报错了
当我们不指定M、D的时候，会按照实际的精度来处理。
定点型
介绍完float、double两种浮点型，我们介绍一下定点型的数据类型decimal类型，有了浮点型为什么我们还需要定点型？
float、double类型存在精度丢失问题，即写入数据库的数据未必是插入数据库的数据，而decimal无论写入数据中的数据是多少，都不会存在精度丢失问题，这就是我们要引入decimal类型的原因，decimal类型常见于银行系统、互联网金融系统等对小数点后的数字比较敏感的系统中。
最后讲一下decimal和float/double的区别：
- float/double在db中存储的是近似值，而decimal则是以字符串形式进行保存的
- decimal(M,D)的规则和float/double相同，但区别在float/double在不指定M、D时默认按照实际精度来处理而decimal在不指定M、D时默认为decimal(10, 0)
日期类型
接着我们看一下MySQL中的日期类型，MySQL支持五种形式的日期类型：date、time、year、datetime、timestamp，用一张表格总结一下这五种日期类型：
| 数据类型 | 字节数 | 格式 | 备注 |
|---|---|---|---|
| date | 3 | yyyy-MM-dd | 存储日期值 |
| time | 3 | HH:mm:ss | 存储时分秒 |
| year | 1 | yyyy | 存储年 |
| datetime | 8 | yyyy-MM-dd HH:mm:ss | 存储日期+时间 |
| timestamp | 4 | yyyy-MM-dd HH:mm:ss | 存储日期+时间，可作时间戳 |
MySQL的时间类型的知识点比较简单，这里重点关注一下datetime与timestamp两种类型的区别：
- 上面列了，datetime占8个字节，timestamp占4个字节
- 由于大小的区别，datetime与timestamp能存储的时间范围也不同，datetime的存储范围为1000-01-01 00:00:00——9999-12-31 23:59:59，timestamp存储的时间范围为19700101080001——20380119111407
- datetime默认值为空，当插入的值为null时，该列的值就是null；timestamp默认值不为空，当插入的值为null的时候，mysql会取当前时间
- datetime存储的时间与时区无关，timestamp存储的时间及显示的时间都依赖于当前时区
char和varchar类型
最后看一下常用到的字符型，说到MySQL字符型，我们最熟悉的应该就是char和varchar了，关于char和varchar的对比，我总结一下：
- char是固定长度字符串，其长度范围为0255且与编码方式无关，无论字符实际长度是多少，都会按照指定长度存储，不够的用空格补足；varchar为可变长度字符串，在utf8编码的数据库中其长度范围为021844
- char实际占用的字节数即存储的字符所占用的字节数，varchar实际占用的字节数为存储的字符+1或+2或+3
- MySQL处理char类型数据时会将结尾的所有空格处理掉而varchar类型数据则不会
varchar型数据占用空间大小及可容纳最大字符串限制探究
接上一部分，我们这部分来探究一下varchar型数据实际占用空间大小是如何计算的以及最大可容纳的字符串为多少，首先要给出一个结论：这部分和具体编码方式有关，且MySQL版本我现在使用的是5.7，当然5.0之后的都是可以的。
先写一段SQL创建表，utf8的编码格式：
drop table if exists test_varchar;
create table test_varchar (
varchar_value varchar(100000)
) engine=innodb charset=utf8;
执行报错：
Column length too big for column 'varchar_value' (max = 21845); use BLOB or TEXT instead
按照提示，我们把大小改为21845，执行依然报错：
Row size too large. The maximum row size for the used table type, not counting BLOBs, is 65535. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs
改为21844就不会有问题，因此在utf8编码下我们可以知道varchar(M)，M最大=21844。那么gbk呢：
drop table if exists test_varchar;
create table test_varchar (
varchar_value varchar(100000)
) engine=innodb charset=gbk;
同样的报错：
Column length too big for column 'varchar_value' (max = 32767); use BLOB or TEXT instead
把大小改为32766，也是和utf8编码格式一样的报错：
Row size too large. The maximum row size for the used table type, not counting BLOBs, is 65535. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs
可见gbk的编码格式下，varchar(M)最大的M=32765，那么为什么会有这样的区别呢，分点详细解释一下：
- MySQL要求一个行的定义长度不能超过65535即64K
- 对于未指定varchar字段not null的表，会有1个字节专门表示该字段是否为null
- varchar(M)，当M范围为0<=M<=255时会专门有一个字节记录varchar型字符串长度，当M>255时会专门有两个字节记录varchar型字符串的长度，把这一点和上一点结合，那么65535个字节实际可用的为65535-3=65532个字节
- 所有英文无论其编码方式，都占用1个字节，但对于gbk编码，一个汉字占两个字节，因此最大M=65532/2=32766；对于utf8编码，一个汉字占3个字节，因此最大M=65532/3=21844，上面的结论都成立
- 举一反三，对于utfmb4编码方式，1个字符最大可能占4个字节，那么varchar(M)，M最大为65532/4=16383，可以自己验证一下
同样的，上面是表中只有varchar型数据的情况，如果表中同时存在int、double、char这些数据，需要把这些数据所占据的空间减去，才能计算varchar(M)型数据M最大等于多少。
varchar、text和blob
最后讲一讲text和blob两种数据类型，它们的设计初衷是为了存储大数据使用的，因为之前说了，MySQL单行最大数据量为64K。
先说一下text，text和varchar是一组既有区别又有联系的数据类型，其联系在于当varchar(M)的M大于某些数值时，varchar会自动转为text：
- M>255时转为tinytext
- M>500时转为text
- M>20000时转为mediumtext
所以过大的内容varchar和text没有区别，同时varchar(M)和text的区别在于：
- 单行64K即65535字节的空间，varchar只能用63352/65533个字节，但是text可以65535个字节全部用起来
- text可以指定text(M)，但是M无论等于多少都没有影响
- text不允许有默认值，varchar允许有默认值
varchar和text两种数据类型，使用建议是能用varchar就用varchar而不用text（存储效率高），varchar(M)的M有长度限制，之前说过，如果大于限制，可以使用mediumtext（16M）或者longtext（4G）。
至于text和blob，简单过一下就是text存储的是字符串而blob存储的是二进制字符串，简单说blob是用于存储例如图片、音视频这种文件的二进制数据的。
表-创建
创建一张表：
CREATE TABLE 表名称(
字段1 类型 [COMMENT 字段1注释],
字段2 类型 [COMMENT 字段2注释],
...
字段n 类型 [COMMENT 字段n注释]
)[COMMENT 表注释];
思考一下，如何创建出下方这张表？
id name age class 1 甲壳虫 22 一班 2 花蝴蝶 27 一班 3 刘六六 66 二班
(Wed Aug 10 14:22:35 2022)[root@MySQL][testdb]>CREATE TABLE table_student(
-> id int COMMENT '编号',
-> name varchar(10) COMMENT '姓名',
-> age int COMMENT '年龄',
-> class varchar(20) COMMENT '班级'
-> ) COMMENT '学生表';
Query OK, 0 rows affected (0.01 sec)
(Wed Aug 10 14:23:22 2022)[root@MySQL][testdb]>SHOW TABLES;
+------------------+
| Tables_in_testdb |
+------------------+
| table_student |
+------------------+
1 row in set (0.00 sec)
表-查询
查询当前数据库下所有表：SHOW TABLES;
(Wed Aug 10 14:18:05 2022)[root@MySQL][mysql]>SHOW TABLES;
+------------------------------------------------------+
| Tables_in_mysql |
+------------------------------------------------------+
| columns_priv |
| component |
| db |
| default_roles |
| engine_cost |
| func |
| general_log |
| global_grants |
| gtid_executed |
| help_category |
| help_keyword |
| help_relation |
| help_topic |
| innodb_index_stats |
| innodb_table_stats |
| password_history |
| plugin |
| procs_priv |
| proxies_priv |
| replication_asynchronous_connection_failover |
| replication_asynchronous_connection_failover_managed |
| role_edges |
| server_cost |
| servers |
| slave_master_info |
| slave_relay_log_info |
| slave_worker_info |
| slow_log |
| tables_priv |
| time_zone |
| time_zone_leap_second |
| time_zone_name |
| time_zone_transition |
| time_zone_transition_type |
| user |
+------------------------------------------------------+
35 rows in set (0.00 sec)
查询某一张表的表结构：DESC 表名称;
(Wed Aug 10 14:32:52 2022)[root@MySQL][testdb]>DESC table_student;
+-------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int | YES | | NULL | |
| name | varchar(10) | YES | | NULL | |
| age | int | YES | | NULL | |
| class | varchar(20) | YES | | NULL | |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.01 sec)
查询指定表的建表语句：SHOW CREATE TABLE 表名称;
(Wed Aug 10 14:33:44 2022)[root@MySQL][testdb]>SHOW CREATE TABLE table_student;
+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Table | Create Table |
+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| table_student | CREATE TABLE `table_student` (
`id` int DEFAULT NULL COMMENT '编号',
`name` varchar(10) DEFAULT NULL COMMENT '姓名',
`age` int DEFAULT NULL COMMENT '年龄',
`class` varchar(20) DEFAULT NULL COMMENT '班级'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='学生表' |
+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.02 sec)
表-修改
添加字段：ALTER TABLE 表名 ADD 字段名 类型(长度) [COMMENT 注释] [约束];
#为emp表新增一个字段“昵称”为nickname,类型为varchar(20)
(Wed Aug 10 16:35:22 2022)[root@MySQL][testdb]>ALTER TABLE Employee_info ADD nickname varchar(20) comment '昵称';
Query OK, 0 rows affected (0.01 sec)
Records: 0 Duplicates: 0 Warnings: 0
(Wed Aug 10 16:35:31 2022)[root@MySQL][testdb]>DESC Employee_info;
+-------------------+------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------------+------------------+------+-----+---------+-------+
| id | int | YES | | NULL | |
| employee_no | varchar(10) | YES | | NULL | |
| employee_name | varchar(10) | YES | | NULL | |
| employee_gender | char(1) | YES | | NULL | |
| employee_age | tinyint unsigned | YES | | NULL | |
| employee_idnum | char(18) | YES | | NULL | |
| employee_hiredate | date | YES | | NULL | |
| nickname | varchar(20) | YES | | NULL | |
+-------------------+------------------+------+-----+---------+-------+
8 rows in set (0.00 sec)
修改数据类型：ALTER TABLE 表名 MODIFY 字段名 新数据类型(长度);
修改字段名和字段类型：ALTER TABLE 表名 CHANGE 旧字段名 新字段名 新数据类型(长度) [COMMENT 注释] [约束];
#将Employee_info表的nickname字段修改为employee_username，类型为varchar(30)。
(Wed Aug 10 16:45:47 2022)[root@MySQL][testdb]>ALTER TABLE Employee_info CHANGE nickname employee_username varchar(30);
Query OK, 0 rows affected (0.00 sec)
Records: 0 Duplicates: 0 Warnings: 0
(Wed Aug 10 16:46:19 2022)[root@MySQL][testdb]>DESC Employee_info;
+-------------------+------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------------+------------------+------+-----+---------+-------+
| id | int | YES | | NULL | |
| employee_no | varchar(10) | YES | | NULL | |
| employee_name | varchar(10) | YES | | NULL | |
| employee_gender | char(1) | YES | | NULL | |
| employee_age | tinyint unsigned | YES | | NULL | |
| employee_idnum | char(18) | YES | | NULL | |
| employee_hiredate | date | YES | | NULL | |
| employee_username | varchar(30) | YES | | NULL | |
+-------------------+------------------+------+-----+---------+-------+
8 rows in set (0.00 sec)
修改表名：ALTER TABLE 表名 RENAME TO 新表名;
#将Employee_info表名修改为Emp_info
(Wed Aug 10 16:50:52 2022)[root@MySQL][testdb]>ALTER TABLE Employee_info RENAME TO Emp_info;
Query OK, 0 rows affected (0.01 sec)
(Wed Aug 10 16:53:09 2022)[root@MySQL][testdb]>SHOW TABLES;
+------------------+
| Tables_in_testdb |
+------------------+
| Emp_info |
| table_student |
+------------------+
2 rows in set (0.00 sec)
表-删除
删除字段：ALTER TABLE 表名 DROP 字段名;
#删除Employee_info表的字段employee_username
(Wed Aug 10 16:46:29 2022)[root@MySQL][testdb]>ALTER TABLE Employee_info DROP employee_username;
Query OK, 0 rows affected (0.01 sec)
Records: 0 Duplicates: 0 Warnings: 0
(Wed Aug 10 16:50:46 2022)[root@MySQL][testdb]>DESC Employee_info;
+-------------------+------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------------+------------------+------+-----+---------+-------+
| id | int | YES | | NULL | |
| employee_no | varchar(10) | YES | | NULL | |
| employee_name | varchar(10) | YES | | NULL | |
| employee_gender | char(1) | YES | | NULL | |
| employee_age | tinyint unsigned | YES | | NULL | |
| employee_idnum | char(18) | YES | | NULL | |
| employee_hiredate | date | YES | | NULL | |
+-------------------+------------------+------+-----+---------+-------+
7 rows in set (0.00 sec)
删除表：DROP TABLE [IF EXISTS] 表名;
#删除table_student表
(Wed Aug 10 16:53:22 2022)[root@MySQL][testdb]>DROP TABLE IF EXISTS table_student;
Query OK, 0 rows affected (0.01 sec)
(Wed Aug 10 16:59:53 2022)[root@MySQL][testdb]>SHOW TABLES;
+------------------+
| Tables_in_testdb |
+------------------+
| Emp_info |
+------------------+
1 row in set (0.00 sec)
删除指定表，并重新创建该表：TRUNCATE TABLE 表名;
(Wed Aug 10 17:00:14 2022)[root@MySQL][testdb]>TRUNCATE TABLE Emp_info;
Query OK, 0 rows affected (0.01 sec)
(Wed Aug 10 17:08:20 2022)[root@MySQL][testdb]>SHOW TABLES;
+------------------+
| Tables_in_testdb |
+------------------+
| Emp_info |
+------------------+
1 row in set (0.00 sec)
小结
- 数据库操作
SHOW DATABASES; #查询所有的数据库
CREATE DATABASE 数据库名; #创建一个新的数据库
USE 数据库名; #切换到该数据库
SELECT DATABASE(); #查询当前所在数据库
DROP DATABASE 数据库名; #删除数据库
- 表操作
SHOW TABLES;
CREATE TABLE 表名(字段 字段类型，字段 字段类型);
DESC 表名;
SHOW CREATE TABLE 表名;
ALTERTABLE 表名 ADD/MODIFY/CHANGE/DROP/RENAME TO...;
DROP TABLE 表名;
DML-数据操作语言
数据-添加
给指定字段添加数据：INSERT INTO 表名(字段1,字段2,...) VALUES(值1,值2,...);
(Thu Aug 11 14:49:37 2022)[root@MySQL][testdb]>INSERT INTO Emp_info(id,employee_no,employee_name,employee_gender,employee_age,employee_idnum,employee_hiredate) VALUES(2,'2','张十五','男',25,'123456789012345687','2021-05-16');
Query OK, 1 row affected (0.01 sec)
(Thu Aug 11 14:58:07 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 2 | 2 | 张十五 | 男 | 25 | 123456789012345687 | 2021-05-16 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
2 rows in set (0.00 sec)
给全部字段添加数据：INSERT INTO 表名 VALUES(值1,值2,...);
(Thu Aug 11 14:49:37 2022)[root@MySQL][testdb]>INSERT INTO Emp_info VALUES(1,'1','刘六六','男',21,'123456789012345678','2022-08-10');
Query OK, 1 row affected (0.01 sec)
(Thu Aug 11 14:49:52 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
1 row in set (0.00 sec)
批量添加数据：INSERT INTO 表名(字段1,字段2,...) VALUES(值1,值2,...),(值1,值2,...);
INSERT INTO 表名 VALUES(字段1,字段2,...),(字段1,字段2,...),(字段1,字段2,...);
(Thu Aug 11 14:58:25 2022)[root@MySQL][testdb]>INSERT INTO Emp_info VALUES(1,'1','刘六六','男',21,'123456789012345678','2022-08-10'),(1,'1','刘六六','男',21,'123456789012345678','2022-08-10'),(1,'1','刘六六','男',21,'123456789012345678','2022-08-10'),(1,'1','刘六六','男',21,'123456789012345678','2022-08-10');
Query OK, 4 rows affected (0.00 sec)
Records: 4 Duplicates: 0 Warnings: 0
(Thu Aug 11 15:00:01 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 2 | 2 | 张十五 | 男 | 25 | 123456789012345687 | 2021-05-16 |
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 刘六六 | 男 | 21 | 123456789012345678 | 2022-08-10 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
6 rows in set (0.01 sec)
注意：
- 插入数据时，指定的字段顺序需要与值的顺序是一一对应的。
- 字符串和日期型数据应该包含在引号中。
- 插入的数据大小，应该在字段的规定范围内。
数据-修改
修改数据：UPDATE 表名 SET 字段1=值1,字段2=值2,...[WHERE 条件];
注意：修改语句的条件可以有，也可以没有，如果没有条件，则会修改整张表的所有数据
#修改id为1的数据，将name修改为王哈哈
(Thu Aug 11 15:18:37 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 2 | 2 | 张十五 | 男 | 25 | 123456789012345687 | 2021-05-16 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
6 rows in set (0.00 sec)
#修改id为2的数据，将name改为小花，gender改为女
(Thu Aug 11 15:29:25 2022)[root@MySQL][testdb]>UPDATE Emp_info SET employee_name='小花',employee_gender='女' WHERE id=2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
(Thu Aug 11 15:29:31 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 2 | 2 | 小花 | 女 | 25 | 123456789012345687 | 2021-05-16 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2022-08-10 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
6 rows in set (0.00 sec)
#修改所有人的入职日期为2021年8月15日
(Thu Aug 11 15:29:34 2022)[root@MySQL][testdb]>UPDATE Emp_info SET employee_hiredate='2021-08-15';
Query OK, 6 rows affected (0.00 sec)
Rows matched: 6 Changed: 6 Warnings: 0
(Thu Aug 11 15:33:41 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2021-08-15 |
| 2 | 2 | 小花 | 女 | 25 | 123456789012345687 | 2021-08-15 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2021-08-15 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2021-08-15 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2021-08-15 |
| 1 | 1 | 王哈哈 | 男 | 21 | 123456789012345678 | 2021-08-15 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
6 rows in set (0.00 sec)
数据-删除
删除数据：DELETE FROM 表名 [WHERE 条件];
#删除gender为男的员工
(Thu Aug 11 15:33:42 2022)[root@MySQL][testdb]>DELETE FROM Emp_info WHERE employee_gender='男';
Query OK, 5 rows affected (0.00 sec)
(Thu Aug 11 15:44:48 2022)[root@MySQL][testdb]>select * from Emp_info;
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| id | employee_no | employee_name | employee_gender | employee_age | employee_idnum | employee_hiredate |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
| 2 | 2 | 小花 | 女 | 25 | 123456789012345687 | 2021-08-15 |
+------+-------------+---------------+-----------------+--------------+--------------------+-------------------+
1 row in set (0.00 sec)
#删除所有员工
(Thu Aug 11 15:44:52 2022)[root@MySQL][testdb]>DELETE FROM Emp_info;
Query OK, 1 row affected (0.01 sec)
(Thu Aug 11 15:46:40 2022)[root@MySQL][testdb]>select * from Emp_info;
Empty set (0.00 sec)
注意：
- DELETE语句的条件可以有也可以没有，如果不加上WHERE的话，是删除整张表的数据。
- DELETE语句不能删除某一个字段的值，但可以使用UPDATE。
小结
- 数据操作
INSERT INTO 表名(字段1,字段2,...) VALUES(值1,值2,...); #对指定字段插入数据
UPDATE 表名 SET 字段1=值1,字段2=值2,...[WHERE 条件]; #更新指定字段的数据
DELETE FROM 表名 [WHERE 条件]; #删除指定（全部）的数据
DQL-数据查询语言
语法：
SELECT
字段1,
字段2,
...
FROM
表1,
表2,
...
WHERE
条件1,
条件2,
...
GROUP BY
分组字段1,
分组字段2,
...
HAVING
分组后条件1,
分组后条件2,
...
ORDER BY
排序字段1,
排序字段2,
...
LIMIT
分页参数
基本查询
- 查询多个字段
SELECT 字段1,字段2, ... FROM 表名; #查询指定的字段
SELECT * FROM 表名; #查询所有字段
- 设置别名
SELECT 字段1 [AS 别名1], 字段2 [AS 别名2], ... FROM 表名;
- 去除重复记录
SELECT DISTINCT 字段1,字段2, ... FROM 表名; #查询指定的字段并去除重复记录
实例：
#查询指定字段 name,workno,age返回
SELECT name,workno,age FROM emp;
#查询所有字段返回
SELECT * FROM emp;
#查询所有员工的工作地址，起别名
SELECT name AS '姓名',workaddress AS '工作地址' FROM emp;
#查询员工的工作地址，不要重复的
SELECT DISTINCT workaddress FROM emp;
条件查询
语法：SELECT 字段1,字段2,... FROM 表名 WHERE 条件...;
实例：
#查询年龄为53岁的员工
SELECT * FROM emp WHERE age = 53;
#查询年龄小于20的员工
SELECT name,age FROM emp WHERE age < 20;
#查询年龄小于等于20的员工
SELECT name,age FROM emp WHERE age <= 20;
#查询身份证号为空的员工
SELECT name,idcard FROM emp WHERE idcard IS NULL;
#查询身份证号不为空的员工
SELECT name,idcard FROM emp WHERE idcard IS NOT NULL;
#查询年龄不等于25的员工
SELECT name,age FROM emp WHERE age <> 25;
#或
SELECT name,age FROM emp WHERE age != 25;
#查询年龄在18-28岁之间的员工
SELECT name,age FROM emp WHERE age BETWEEN 18 AND 28;
#查询性别为女且年龄小于23的员工
SELECT name,age,gender FROM emp WHERE gender='女' AND age < 23;
#查询年龄为18或23或40的员工
SELECT name,age FROM emp WHERE age = 18 or age = 23 or age = 40;
#查询姓名为两个字的员工
SELECT name FROM emp WHERE name LIKE "__";
#查询身份证号最后一位是X的员工
SELECT name,idcard FROM emp WHERE idcard LIKE "%X";
聚合函数
| 函数 | 说明 |
|---|---|
| count | 统计数量 |
| max | 最大值 |
| min | 最小值 |
| avg | 平均数 |
| sum | 求和 |
语法：SELECT 聚合函数(字段) FROM 表名;
实例：
#统计该企业员工数量
SELECT COUNT(*) FROM emp;
#或
SELECT COUNT(字段) FROM emp;
#统计该企业员工的平均年龄
SELECT ROUND(AVG(age),0) FROM emp; #这里的ROUND是四舍五入，其中0是保留几位小数，从0开始。
#统计该企业员工最大年龄
SELECT MAX(age) FROM emp;
#统计该企业员工最小年龄
SELECT MIN(age) FROM emp;
#统计北京市员工年龄之和以及平均值
SELECT workaddress as '工作地址',SUM(age) as '北京地区年龄之和',AVG(age) as '北京地区年龄平均值' FROM emp WHERE workaddress = '北京市';
注意：所有的NULL值不参与聚合函数的计算。
分组查询
语法：SELECT 字段列表 FROM 表名 [WHERE 条件] GROUP BY 字段名 [HAVING 过滤条件]
WHERE和HAVING的区别：
- 执行的顺序不同：WHERE时分组之前进行过滤，不满足WHERE条件的数据不参与分组。而HAVING是对分组之后的结果进行过滤。
- 判断的条件不同：WHERE不能对聚合函数进行判断，但是HAVING可以。
实例：
#根据性别分组，分别统计男性员工和女性员工的数量
SELECT gender,count(*) FROM emp GROUP BY gender;
#根据性别分组，统计男性员工和女性员工的平均年龄
SELECT gender,ROUND(avg(age),0) FROM emp GROUP BY gender;
#查询年龄小于45的员工，并根据工作地址分组，获取员工数量大于等于100的工作地址
SELECT workaddress,COUNT(*) FROM emp WHERE age < 45 GROUP BY workaddress HAVING COUNT(*) >= 100;
注意
- 执行顺序：WHERE -> 聚合函数 -> HAVING。
- 分组之后，查询的字段一般为聚合函数和分组字段。
排序查询
语法：SELECT 字段1, 字段2,... FROM 表名 ORDER BY 字段1 排序方式1, 字段2 排序方式2;
排序方式：
- ASC：升序（默认）
- DESC：降序
注意：如果是多字段排序，当第一个字段值相同时，才会根据第二个字段进行排序。
#根据年龄对员工进行升序排序
SELECT * FROM emp ORDER BY age ASC;
#根据入职时间，对员工进行降序排序
SELECT * FROM emp ORDER BY entrydate DESC;
#根据年龄对员工进行升序排序，年龄相同再根据入职时间降序排序
SELECT * FROM emp ORDER BY age ASC, entrydate DESC;
分页查询
语法：SELECT 字段1, 字段2, ... FROM 表名 LIMIT 起始索引, 查询的记录条数;
注意：
- 起始索引从0开始，起始索引=（查询页码 - 1）* 查询的记录条数。
- 分页查询是数据库的方言，不同的数据库有不同的实现，MySQL中是LIMIT。
- 如果查询的是第一页的数据，则可以忽略起始索引。
实例：
#查询第16页员工数据，每页显示50条数据
SELECT * FROM emp LIMIT 750, 50;
小测试
#查询年龄为20，21，22，23岁的员工信息
SELECT * FROM emp WHERE age BETWEEN 20 AND 23;
#查询性别为男，年龄在30-50岁（含）且名字为三个字的员工
SELECT name,age FROM emp WHERE age BETWEEN 30 AND 50 AND name LIKE '___';
#统计员工表中，年龄小于50的男性员工和女性员工人数。
SELECT gender,COUNT(*) FROM emp WHERE age < 50 GROUP BY gender;
#查询所有年龄小于等于35岁员工的姓名和年龄，并对查询结果根据年龄升序排序，如果年龄相同按入职时间降序排序
SELECT name,age FROM emp WHERE age <= 35 ORDER BY age, entrydate DESC;
#查询性别为男，且年龄在30-50岁（含）以内的前20个员工信息，对结果按年龄升序排序，如果年龄相同按入职时间升序排序
SELECT * FROM emp WHERE age BETWEEN 30 AND 50 ORDER BY age, entrydate LIMIT 20;
执行顺序
编写顺序：SELECT -> FROM -> WHERE -> GROUP BY -> HAVING -> ORDER BY -> LIMIT
执行顺序：FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT
小结
1.DQL语句
SELECT
字段1,
字段2,
...
FROM
表1,
表2,
...
WHERE
条件1,
条件2,
...
GROUP BY
分组字段1,
分组字段2,
...
HAVING
分组后条件1,
分组后条件2,
...
ORDER BY
排序字段1,
排序字段2,
...
LIMIT
分页参数
DCL-数据控制语言
用户-查询用户
#查询所有用户
USE mysql;
SELECT * FROM user;
用户-创建用户
语法：CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
#创建一个新用户名为Mask1密码为MySQL123，只能被本机localhost登录
CREATE USER 'Mask1'@'localhost' IDENTIFIED BY 'MySQL123';
#创建一个新用户名为Mask2密码为MySQL123，且可以被任意主机登录
CREATE USER 'Mask2'@'%' IDENTIFIED BY 'MySQL123';
用户-修改密码
语法：ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';
#修改Mask2用户的密码为MySQL321
ALTER USER 'Mask2'@'%' IDENTIFIED BY 'MYSQL321';
用户-删除用户
语法：DROP USER '用户名'@'主机名';
#删除Mask1用户
DROP USER 'Mask1'@'localhost';
注意：主机名可以用’%'通配。
常用权限：
| 权限 | 说明 |
|---|---|
| ALL,ALL PRIVILEGES | 所有权限 |
| SELECT | 查询数据 |
| INSERT | 插入数据 |
| UPDATE | 修改数据 |
| DELETE | 删除数据 |
| ALTER | 修改表 |
| DROP | 删除数据库/表/视图 |
| CREATE | 创建数据库/表 |
权限-查询权限
语法：SHOW GRANTS FOR '用户名'@'主机名';
#查询Mask2用户的权限
SHOW GRANTS FOR 'Mask2'@'%';
权限-授予权限
语法：GRANT 权限 ON 数据库名.表名 TO '用户名'@'主机名';
#给Mask2用户所有数据库所有表的ALL PRIVILEGES权限
GRANT ALL PRIVILEGES ON *.* TO 'Mask2'@'%';
权限-撤销权限
语法：REVOKE 权限 ON 数据库名.表名 FROM '用户名'@'主机名';
#撤销Mask2用户的所有权限
REVOKE ALL PRIVILEGES ON *.* FROM 'Mask2'@'localhost';
注意：
- 多个权限之间，使用逗号分割。
- 授权时，数据库名和表名可以使用’**'进行通配，代表所有。
小结
#用户管理
CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';
DROP USER '用户名'@'主机名';
#权限控制
SHOW GRANTS FOR '用户名'@'主机名';
GRANT ALL PRIVILEGES ON *.* TO 'Mask2'@'%';
REVOKE ALL PRIVILEGES ON *.* FROM 'Mask2'@'localhost';
函数
函数是指一段可以直接被另一端程序调用的程序或代码。
字符串函数
| 函数 | 说明 |
|---|---|
| CONCAT(S1,S2,…) | 字符串拼接，将S1,S2,…拼接成一个字符串 |
| LOWER(STR) | 将字符串STR全部转为小写R |
| UPPER(STR) | 将字符串STR全部转为大写 |
| LPAD(STR,N,PAD) | 左填充，用字符串PAD对STR左边进行填充，使STR字符串长度达到N |
| RPAD(STR,N,PAD) | 右填充，用字符串PAD对STR右边进行填充，使STR字符串长度达到N |
| TRIM(STR) | 去掉字符串头部和尾部的空格 |
| SUBSTRING(STR,START,LEN) | 返回字符串STR从START位置开始的LEN个长度的字符串 |
实例：
#由于业务需求变更，企业员工工号统一为5位数，不足5位数的全部在前面补0.
UPDATE emp SET workno = LPAD(workno,5,'0');
数值函数
| 函数 | 说明 |
|---|---|
| CEIL(X) | 向上取整 |
| FLOOR(X) | 向下取整 |
| MOD(X,Y) | 返回X/Y的模 |
| RAND() | 返回0-1之间的随机数 |
| ROUND(X,Y) | 求参数X的四舍五入值，并保留Y位小数 |
实例：
#通过函数，生成一个六位数的随机验证码
SELECT LPAD(ROUND(RAND()*1000000,0),6,0);
日期函数
| 函数 | 说明 |
|---|---|
| CURDATE() | 返回当前日期 |
| CURTIME() | 返回当前时间 |
| NOW() | 返回当前日期和时间 |
| YEAR(DATE) | 获取指定DATE的年份 |
| MONTH(DATE) | 获取指定DATE的月份 |
| DAY(DATE) | 获取指定DATE的日期 |
| DATE_ADD(DATE, INTERVAL EXPR TYPE) | 返回一个日期/时间值加上一个时间间隔expr后的时间值 |
| DATEDIFF(DATE1,DATE2) | 返回起始时间DATE1和结束时间DATE2之间的天数 |
实例：
#查询所有员工的入职天数
SELECT name,DATEDIFF(CURDATE(),entrydate) AS entryday FROM EMP ORDER BY entryday DESC;
流程函数
| 函数 | 说明 |
|---|---|
| IF(VALUE,T,F) | 如果VALUE为true,返回t,否则返回f |
| IFNULL(VALUE1,VALUE2) | 如果VALUE1不为空，返回VALUE1,否则返回VALUE2 |
| CASE WHEN [VAL1] THEN [RES1] … ELSE [DEFAULT] END | 如果VAL1为true,返回RES1,…否则返回DEFAULT |
| CASE [EXPR] WHEN [VAL1] THEN [RES1] … ELSE [DEFAULT] END | 如果EXPR的值等于VAL1,返回RES1, … 否则返回DEFAULT |
实例：
#查询员工姓名和工作地址（北京上海->一线城市，其他->二线城市）
SELECT name,CASE WHEN workaddress='北京市' or workaddress='上海市' THEN '一线城市' ELSE '二线城市' END FROM EMP;
create table score(
id int comment 'ID',
name varchar(20) comment '姓名',
math int comment '数学',
english int comment '英语',
chinese int comment '语文'
) comment '学生成绩表';
#统计班级各个学员的成绩，规则如下：
>= 85,显示优秀
>= 60,显示及格
否则显示不及格
小结
- 字符串函数
CONCAT,LOWER,UPPER,LPAD,RPAD,TRIM,SUBSTRING
- 数值函数
CEIL,FLOOR,MOD,RAND,ROUND
- 日期函数
CURDATE,CURTIME,NOW,YEAR,MONTH,DAY,DATE_ADD,DATEDIFF
- 流程函数
IF,IFNULL,CASE[...] WHEN ... THEN ... ELSE... END
约束
概述
-
概念：约束是作用于表中字段上的规则，用于限制存储在表中的数据。
-
目的：保证数据库中数据的正确、有效和完整性。
-
分类：
约束 描述 关键字 非空约束 限制该字段的数据不能为NULL NOT NULL 唯一约束 保证该字段的所有数据都是唯一并不重复的 UNIQUE 主键约束 主键是一行数据的唯一标识，要求非空且唯一 PRIMARY KEY 默认约束 保存数据时，如果未指定该字段的值，则采用默认 DEFAULT 检查约束(8.0.16版本+) 保证字段值满足某一个条件 CHECK 外键约束 用来让两张表的数据之间建立连接，保证数据的一致性和完整性 FOREIGN KEY
注意：约束是作用于表中字段上的，可以在创建表/修改表的时候添加约束
约束演示
需求表：
| 字段名 | 字段含义 | 字段类型 | 约束条件 |
|---|---|---|---|
| id | ID唯一标识 | int | 主键，自动递增 |
| name | 姓名 | varchar(10) | 不为空 |
| age | 年龄 | int | 大于0，小于120 |
| status | 状态 | char(1) | 如果没有值默认为1 |
| gender | 性别 | char(1) | 无 |
create table user(
id int PRIMARY KEY AUTO_INCREMENT comment'主键lID',
name varchar(10) NOT NULL comment'姓名',
age int CHECK(age > 0 && age<120) comment'年龄',
status char(1) DEFAULT 1 comment'状态',
gender char(1) comment'性别'
) comment'用户表';
外键约束
概念：外键用来让两张表之间建立连接，从而保证数据的一致性和完整性。
注意：在数据库层面，未建立外键关联，是无法保证数据的一致性和完整性的。
语法：
#创建表时添加外键
CREATE TABLE 表名(
字段名 数据类型,
字段名 数据类型 [CONSTRAINT] [外键名称] FOREIGN KEY(外键字段名) REFERENCES 主表(主表列名)
);
#创建表后添加外键
ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY(外键字段名) REFERENCES 主表(主表列名);
#删除外键
ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;
实例：
#为emp表的dept_id字段添加外键，关联dept表的id字段。
ALTER TABLE emp ADD CONSTRAINT fk_emp_dept_id FOREIGN KEY(dept_id) REFERENCES dept(id);
#删除名为fk_emp_dept_id的外键
ALTER TABLE emp DROP FOREIGN KEY fk_emp_dept_id;
删除/更新行为
| 行为 | 说明 |
|---|---|
| NO ACTION | 当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则不允许删除/更新。 (与 RESTRICT 一致) 默认行为 |
| RESTRICT | 当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有则不允许删除/更新。 (与 NO ACTION 一致) 默认行为 |
| CASCADE | 当在父表中删除/更新对应记录时，首先检查该记录是否有对应外键，如果有，则也删除/更新外键在子表中的记录。 |
| SET NULL | 当在父表中删除对应记录时，首先检查该记录是否有对应外键，如果有则设置子表中该外键值为null（这就要求该外键允许取null）。 |
| SET DEFAULT | 父表有变更时，子表将外键列设置成一个默认的值 (Innodb不支持) |
小结
- 非空约束：
NOT NULL - 唯一约束：
UNIQUE - 主键约束：
PRIMARY KEY - 默认约束：
DEFAULT - 检查约束：
CHECK - 外键约束：
FOREIGN KEY
多表查询
多表关系
项目开发中，在进行数据库表结构设计时，会根据业务需求及业务模块之间的关系，分析并设计表结构，由于业务之间相互关联，所以各个表结构之间也存在着各种联系，基本上分为三种：
- 一对多(多对一)
- 多对多
- 一对一
一对多(多对一)
- 例如：
部门与员工的关系、班级与学生的关系 - 关系：
一个部门对应多个员工，一个班级对应多个学生 - 实现：
在多的一方建立外键，指向一的一方的主键。学生(外键)->班级(主键)
多对多
- 例如：
学生与课程的关系 - 关系：
一个学生可以选修多门课程，一个课程可以被多个学生选修 - 实现：
建立一张中间表，至少包含两个外键，分别关联两方主键
一对一
- 例如：
用户与个人详情的关系 - 关系：
一对一关系，多用于单表拆分，将一张表的基础字段放在一张表中，其他详细字段放在另一张表中，以提升操作效率 - 实现：
在任意一方添加外键，关联另一方的主键，并且设置外键为唯一(UNIQUE)
多表查询概述
- 概述：从多张表中查询数据
- 笛卡尔积：笛卡尔乘积是指在数学中，两个集合A和B的所有组合情况。(在多表查询时，需要消除无效的笛卡尔积)
- 分类：
- 连接查询
- 内连接：相当于查询A、B交集部分数据
- 外连接：
- 左外连接：查询
左表所有数据，以及两张表交集部分数据 - 右外连接：查询
右表所有数据，以及两张表交集部分数据
- 左外连接：查询
- 自连接：当前表与自身的连接查询，自连接必须使用表别名
- 连接查询
内连接
语法：
#隐式内连接
SELECT 字段列表 FROM 表列表 WHERE 条件...;
#显式内连接
SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件;
内连接查询的是两张表交集的部分
实例：
#查询每一个员工的姓名，以及关联的部门名称（隐式）
SELECT emp.name,dept.name FROM emp,dept WHERE emp.dept_id = dept.id;
#查询每一个员工的姓名，以及关联的部门名称（显示）
SELECT e.name,d.name FROM emp e INNER JOIN dept d ON e.dept_id = d.id;
外连接
语法：
#左外连接
SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件...;
#右外连接
SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件...;
实例：
#查询emp表的所有数据，和对应的部门信息(左外连接)
SELECT * FROM emp e LEFT OUTER JOIN dept d ON e.dept_id = d.id;
#查询dept表的所有数据，和对应的员工信息(右外连接)
SELECT d.*,e.* FROM emp e RIGHT OUTER JOIN dept d ON e.dept_id = d.id;
自连接
语法：
SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件...;
自链接查询，可以是内连接查询，也可以是外连接查询
实例：
#查询员工及其直属领导的名字
SELECT e1.name 员工,e2.name 领导 FROM emp e1 JOIN emp e2 ON e1.managerid = e2.id;
#查询所有员工emp及其领导的名字emp,如果没有领导也要查询出来
SELECT e1.*,e2.name 领导 FROM emp e1 LEFT JOIN emp e2 ON e1.managerid = e2.id;
联合查询
对于UNION查询，就是把多次查询的结果合并起来，形成一个新的查询结果集
语法：
SELECT 字段列表 FROM 表A ...
UNION [ALL]
SELECT 字段列表 FROM 表B ...;
实例：
#将薪资低于5000的员工，和年龄大于50岁的员工都查询出来。
SELECT * FROM emp WHERE salary < 5000 UNION SELECT * FROM emp WHERE age > 50 ORDER BY id ASC;
- 对于联合查询的多张表的列数必须保持一致，字段类型也需要保持一致
- UNION ALL会直接将两个结果集合并，而UNION会进行去重
子查询
概念：SQL语句中嵌套SELECT语句，称为嵌套查询，又称子查询
语法：
SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);
子查询外部的语句可以是INSERT/UPDATE/DELETE/SELECT的任何一个
根据子查询结果不同，分为：
- 标量子查询（结果为单个值）
- 列子查询（结果为一列）
- 行子查询（结果为一行）
- 表子查询（结果为多行多列）
根据子查询位置，分为：WHERE之后、FROM之后、SELECT之后
标量子查询
子查询返回的结果是单个值（数字、字符串、日期等），最简单的形式，这种子查询称为标量子查询。
常用操作符：=、<>、>、>=、<、<=
实例：
#查询销售部的所有员工信息
SELECT * FROM emp WHERE dept_id = (SELECT id FROM dept WHERE name = '销售部');
#查询方东白之后入职的员工信息
SELECT * FROM emp WHERE entrydate > (SELECT entrydate FROM emp WHERE name = '方东白');
列子查询
子查询返回的结果是一列（可以是多行），这种子查询称为列子查询
常用操作符：IN、NOT IN、ANT、SOME、ALL
| 操作符 | 描述 |
|---|---|
| IN | 在指定的集合范围内，多选一 |
| NOT IN | 不在指定的集合范围之内 |
| ANY | 子查询返回列表中，有任意一个满足即可 |
| SOME | 与ANY相同，使用SOME的地方都可以使用ANY |
| ALL | 子查询返回的所有值都必须满足 |
实例：
#查询销售部和市场部的所有员工信息
SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE name = '销售部' OR name = '市场部');
#查询比财务部所有人工资都高的员工信息
SELECT * FROM emp WHERE salary > ALL (SELECT salary FROM emp WHERE dept_id = (SELECT id FROM dept WHERE name = '财务部'));
#查询比研发部其中任意一人工资高的员工信息
SELECT * FROM emp WHERE salary > ANY (SELECT salary FROM emp WHERE dept_id = (SELECT id FROM dept WHERE name = '研发部'));
行子查询
子查询返回的结果是一行（可以是多列），这种子查询称为行子查询。
常用操作符：=、<>、IN、NOT IN
实例：
#查询与张无忌的薪资及直属领导都相同的员工
SELECT * FROM emp WHERE salary = (SELECT salary FROM emp WHERE name = '张无忌') AND managerid = (SELECT managerid FROM emp WHERE name = '张无忌');
#或
SELECT * FROM emp WHERE (salary,managerid) = (SELECT salary,managerid FROM emp WHERE name = '张无忌');
表子查询
子查询返回的结果是多行多列，这种子查询称为表子查询
常用操作符：IN
实例：
#查询与鹿杖客、宋远桥的职位和薪资相同的员工信息
SELECT * FROM emp WHERE job IN (SELECT job FROM emp WHERE name = '鹿杖客' OR name = '宋远桥') AND salary IN (SELECT salary FROM emp WHERE name = '鹿杖客' OR name = '宋远桥');
#查询入职日期是2006-01-01之后的员工信息，及部门信息
SELECT e.*,d.name FROM emp e LEFT JOIN dept d ON e.dept_id = d.id WHERE e.entrydate > '2006-01-01';
多表查询案例
#查询员工的姓名、年龄、职位、部门信息
SELECT e.name,e.age,e.job,d.name FROM emp e LEFT JOIN dept d ON e.dept_id = d.id;
#查询年龄小于30岁的员工姓名、年龄、职位、部门信息
SELECT e.name,e.age,e.job,d.name FROM emp e LEFT JOIN dept d ON e.dept_id = d.id WHERE age < 30;
#查询拥有员工的部门ID、部门名称
SELECT d.* FROM dept d WHERE d.id IN (SELECT e.dept_id FROM emp e);
#查询所有年龄大于40的员工，及其归属的部门名称；如果员工没有分配部门，也需要展示出来
SELECT e.name,d.name FROM emp e LEFT JOIN dept d ON e.dept_id = d.id WHERE e.age > 40;
#查询所有员工的工资等级
SELECT e.name,s.grade FROM emp e,salgrade s WHERE e.salary >s.losal AND e.salary <s.hisal;
#查询研发部所有员工的信息及工资等级
SELECT e.name,s.grade FROM emp e,salgrade s WHERE e.salary >s.losal AND e.salary <s.hisal AND e.dept_id = 1;
#查询研发部员工的平均工资
SELECT AVG(salary) FROM emp WHERE dept_id = 1;
#查询工资比灭绝高的员工信息
SELECT * FROM emp WHERE salary > (SELECT salary FROM emp WHERE name = '灭绝');
#查询比平均工资高的员工信息
SELECT * FROM emp WHERE salary > (SELECT AVG(salary) FROM emp);
#查询比本部门平均工资低的员工信息
SELECT * FROM emp e2 WHERE e2.salary < (SELECT AVG(e1.salary) FROM emp e1 WHERE e1.dept_id = e2.dept_id);
#查询所有的部门信息，并统计部门的员工人数
SELECT d.id,d.name,(SELECT COUNT(*) FROM emp e WHERE e.dept_id = d.id) 人数 FROM dept d;
小结
- 多表关系
- 一对多：在多的一方设置外键，关联一的主键
- 多对多：建立中间表，中间表包含两个外键，关联双方主键
- 一对一：用于表结构查费呢，在其中任何一方设置外键(UNIQUE),关联另一方的主键
- 多表查询
- 内连接
- 隐式内连接
SELECT 字段列表 FROM 表列表 WHERE 条件...; - 显式内连接
SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件;
- 隐式内连接
- 外连接
- 左外连接
SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件...; - 右外连接
SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件...;
- 左外连接
- 自连接
SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件...;
- 子查询
- SELECT * FROM t1 WHERE column1 = (SELECT column1 FROM t2);
- 内连接
事务
事务简介
事务是一组操作的集合，他是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。
MySQL默认事务是自动提交的，也就是当执行一条DML(数据操作语言)时，MySQL会马上隐式的提交事务。
事务操作
#表准备
drop table if exists account;
create table account(
id int primary key AUTO_INCREMENT comment 'ID',
name varchar(10) comment '姓名',
money double(10,2) comment '余额' ) comment '账户表';
insert into account(name, money) VALUES ('张三',2000), ('李四',2000);
#张三给李四转账1000元
#1.查询张三账户余额
SELECT money FROM account WHERE name = '张三';
#2.将张三账户余额减少1000
UPDATE account SET money = money - 1000 WHERE name = '张三';
#3.将李四账户余额增加1000
UPDATE account SET money = money + 1000 WHERE name = '李四';
查看/设置事务提交方式：
SELECT @@AUTOCOMMIT;#1--为开启自动提交; 0--为关闭自动提交;
SET @@AUTOCOMMIT = 0;#关闭自动提交
提交事务：
COMMIT;
回滚事务：
ROLLBACK;
开启事务：
START TRANSACTION 或 BEGIN;
提交事务：
COMMIT;
回滚事务：
ROLLBACK;
事务四大特性（ACID）
- 原子性（Atomicity）：事务是不可分割的最小操作单元，要么全部成功，要么全部失败
- 一致性（Consistency）：事务完成时，必须使所有的数据都保持一致状态
- 隔离性（Isolation）：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行
- 持久性（Durability）：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。
并发事务问题
| 问题 | 说明 |
|---|---|
| 脏读 | 一个事务读到另一个事务还没有提交的数据 |
| 幻读 | 一个事务按照条件查询数据时，没有对应的数据行，但是在插入时，又发现这行数据已经存在了，好像出现了“幻觉” |
| 不可重复读 | 一个事务先后读取同一条记录，但两次读取出来的数据不同，称为不可重复读 |
事务隔离级别
| 隔离级别 | 脏读 | 不可重复读 | 幻读 |
|---|---|---|---|
| Read Uncommitted读未提交 | √ | √ | √ |
| Read Committed读已提交（Orcal默认） | × | √ | √ |
| Repeatable Read可重复读（MySQL默认） | × | × | √ |
| Serializable串行化 | × | × | × |
#查看事务隔离级别
SELECT @@TRANSACTION_ISOLATION;
#设置事务隔离级别
SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}
注意：事务隔离级别越高，数据越安全，性能越低。
小结
-
事务简介
事务是一组操作的集合，他是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。
-
事务操作
-
START TRANSACTION;#开启事务 COMMIT/ROLLBACK;#提交或回滚
-
-
四大特性
- 原子性（Atomicity）
- 一致性（Consistency）
- 隔离性（Isolation）
- 持久性（Durability）
-
并发事务问题
- 脏读
- 幻读
- 不可重复读
-
事务隔离级别
- READ UNCOMMITTED读未提交
- READ COMMITTED读已提交
- REPEATABLE READ可重复读
- SERIALIZABLE串行化
李四’;
查看/设置事务提交方式：
```sql
SELECT @@AUTOCOMMIT;#1--为开启自动提交; 0--为关闭自动提交;
SET @@AUTOCOMMIT = 0;#关闭自动提交
提交事务：
COMMIT;
回滚事务：
ROLLBACK;
开启事务：
START TRANSACTION 或 BEGIN;
提交事务：
COMMIT;
回滚事务：
ROLLBACK;
事务四大特性（ACID）
- 原子性（Atomicity）：事务是不可分割的最小操作单元，要么全部成功，要么全部失败
- 一致性（Consistency）：事务完成时，必须使所有的数据都保持一致状态
- 隔离性（Isolation）：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行
- 持久性（Durability）：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。
并发事务问题
| 问题 | 说明 |
|---|---|
| 脏读 | 一个事务读到另一个事务还没有提交的数据 |
| 幻读 | 一个事务按照条件查询数据时，没有对应的数据行，但是在插入时，又发现这行数据已经存在了，好像出现了“幻觉” |
| 不可重复读 | 一个事务先后读取同一条记录，但两次读取出来的数据不同，称为不可重复读 |
事务隔离级别
| 隔离级别 | 脏读 | 不可重复读 | 幻读 |
|---|---|---|---|
| Read Uncommitted读未提交 | √ | √ | √ |
| Read Committed读已提交（Orcal默认） | × | √ | √ |
| Repeatable Read可重复读（MySQL默认） | × | × | √ |
| Serializable串行化 | × | × | × |
#查看事务隔离级别
SELECT @@TRANSACTION_ISOLATION;
#设置事务隔离级别
SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}
注意：事务隔离级别越高，数据越安全，性能越低。
小结
-
事务简介
事务是一组操作的集合，他是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。
-
事务操作
-
START TRANSACTION;#开启事务 COMMIT/ROLLBACK;#提交或回滚
-
-
四大特性
- 原子性（Atomicity）
- 一致性（Consistency）
- 隔离性（Isolation）
- 持久性（Durability）
-
并发事务问题
- 脏读
- 幻读
- 不可重复读
-
事务隔离级别
- READ UNCOMMITTED读未提交
- READ COMMITTED读已提交
- REPEATABLE READ可重复读
- SERIALIZABLE串行化