黑马MySQL数据库学习day03 级联 多表查询 连接和子查询 表约束

 /*
 存在外键的表
     删表限制:
         1.先删除从表，再删除主表。（不能直接删除主表，主表被从表引用，尽管实际可能还没有记录引用）
     建表限制：
         1.必须先建主表，再建从表（没有主表，从表无法建立外键关系）
 */
 DROP TABLE IF EXISTS employee;
 DROP TABLE IF EXISTS department;

 CREATE TABLE department(
     id INT PRIMARY KEY,
     name varchar(50) UNIQUE NOT NULL
 );
 -- 建表时，添加外键
 CREATE TABLE employee(
     id INT PRIMARY KEY,
     name    varchar(50) NOT NULL,
     dep_id    INT,
     -- CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id)
     -- CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id) ON DELETE CASCADE
     -- CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id) ON UPDATE CASCADE
     CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id) ON UPDATE CASCADE ON DELETE CASCADE
 );

 INSERT INTO department(id, name)
 VALUES
 (1, '技术部'),
 (2, '测试部');

 INSERT INTO employee(id, name, dep_id)
 VALUES
 (1, '刘备', 1),
 (2, '孙权', 1),
 (3, '曹操', 2),
 (4, '大乔', 2),
 (5, '小乔', 2);

 SHOW CREATE TABLE employee;

 -- 级联删除，解决记录被引用时，删除记录不方便。
 -- bug点: 删除记录时，引用该记录的记录也被删除
 DELETE FROM department where id = 1;

 -- 只想删除记录，不想删除引用该记录的记录。不应该用级联删除。先置null,清除引用，再删除记录。
 UPDATE employee SET dep_id = NULL WHERE dep_id = 1;
 DELETE FROM department where id = 1;

 -- 级联更新，解决记录被引用时，更新记录不方便。
 -- 更新记录时，引用该记录的记录也被更新
 UPDATE department set id = 3 where id = 2;

级联

 /*
 多表查询：
 连接
         1.内连接
             表中符合连接条件的记录才会出现在结果中。
             方式：
                 SELECT 查询目标 FROM tb_name1, tb_name2,... WHERE 查询条件
                 SELECT 查询目标 FROM tb_name1
                             [INNER] JOIN tb_name2 ON 查询条件
                             [INNER] JOIN tb_name3 ON 查询条件
                             ...

         2.外连接
             悬浮元组：不符合连接条件的记录。
             左外连接
                 查询出左表的全部数据，悬浮元组跟null值连接。
             SELECT 查询目标 FROM tb_name1
                         LEFT JOIN tb_name2 ON 查询条件
                         LEFT JOIN tb_name3 ON 查询条件
                         ...

             右外连接
                 查询出右表的全部数据，悬浮元组跟null值连接。
             SELECT 查询目标 FROM tb_name1
                         RIGHT JOIN tb_name2 ON 查询条件
                         RIGHT JOIN tb_name3 ON 查询条件
                         ...

             全外连接（MySQL不支持）
                 查询出左表和右表的全部数据，左表和右表的悬浮元组跟null值连接。

     注意特殊的数据：
         新成立的部门测试部，没有员工
         新入职的员工小白龙，没有部门
 */
 drop table if exists emp;
 drop table if exists dept;

 create table dept(
     id int primary key auto_increment,
     name varchar(20)
 );
 insert into dept (name) values ('开发部'),('市场部'),('财务部'),('测试部');
 # 创建员工表
 create table emp (
     id int primary key auto_increment,
     name varchar(10),
     gender char(1), -- 性别
     salary double, -- 工资
     join_date date, -- 入职日期
     dept_id int,
     foreign key (dept_id) references dept(id) -- 外键，关联部门表(部门表的主键)
 );
 insert into emp(name,gender,salary,join_date,dept_id) values('孙悟空','男',7200,'2013-02-24',1);
 insert into emp(name,gender,salary,join_date,dept_id) values('猪八戒','男',3600,'2010-12-02',2);
 insert into emp(name,gender,salary,join_date,dept_id) values('唐僧','男',9000,'2008-08-08',2);
 insert into emp(name,gender,salary,join_date,dept_id) values('白骨精','女',5000,'2015-10-07',3);
 insert into emp(name,gender,salary,join_date,dept_id) values('蜘蛛精','女',4500,'2011-03-14',1);
 insert into emp(name,gender,salary,join_date,dept_id) values('小白龙','男',3000,'2019-03-14',null);

 -- 连接查询帮助 help join

 -- 内连接不规范的写法，不容易阅读
 SELECT emp.id, emp.name, emp.gender, dept.name FROM emp , dept WHERE emp.dept_id = dept.id;

 -- 需求：查询员工和部门信息（不包括没有部门的员工）
 -- 内连接，隐式
 SELECT
     t1.id, -- 员工id
     t1.name, -- 员工姓名
     t1.gender, -- 员工性别
     t2.name -- 部门名称
 FROM
     emp AS t1, -- 员工表
     dept AS t2 -- 部门表
 WHERE
     t1.dept_id = t2.id;

 -- 内连接，显式
 SELECT
     t1.id, -- 员工id
     t1.name, -- 员工姓名
     t1.gender, -- 员工性别
     t2.name -- 部门名称
 FROM
     emp AS t1 -- 员工表
     JOIN dept AS t2 -- 部门表
 ON
     t1.dept_id = t2.id;

 -- 需求2：查询所有员工的信息（包括没有部门的员工）
 -- 方案一：左外连接
 SELECT
     t1.id, -- 员工id
     t1.name, -- 员工姓名
     t1.gender, -- 员工性别
     t2.name -- 部门名称
 FROM
     emp AS t1 -- 员工表
 LEFT JOIN
     dept AS t2 -- 部门表
 ON
     t1.dept_id = t2.id;

 -- 方案二：右外连接
 SELECT
     t1.id, -- 员工id
     t1.name, -- 员工姓名
     t1.gender, -- 员工性别
     t2.name -- 部门名称
 FROM
     dept AS t2 -- 部门表
 RIGHT JOIN
     emp AS t1 -- 员工表
 ON
     t1.dept_id = t2.id;

连接

 /*
     子查询：
         1.子查询的结果是单行单列
             即，子查询的结果是一个值，可以参与运算。
         2.子查询的结果是多行单列
             即，子查询的结果是一列，可以使用IN运算符。
         3.子查询的结果是多行多列
             即，子查询的结果是表，可以像实体表一样参与查询

     注意特殊的数据：
         测试部，新建立的部门，没有员工
         小白龙，新入职的员工，没有部门
 */
 drop table if exists emp;
 drop table if exists dept;

 create table dept(
     id int primary key auto_increment,
     name varchar(20)
 );
 insert into dept (name) values ('开发部'),('市场部'),('财务部'),('测试部');
 # 创建员工表
 create table emp (
     id int primary key auto_increment,
     name varchar(10),
     gender char(1), -- 性别
     salary double, -- 工资
     join_date date, -- 入职日期
     dept_id int,
     foreign key (dept_id) references dept(id) -- 外键，关联部门表(部门表的主键)
 );
 insert into emp(name,gender,salary,join_date,dept_id) values('孙悟空','男',7200,'2013-02-24',1);
 insert into emp(name,gender,salary,join_date,dept_id) values('猪八戒','男',3600,'2010-12-02',1);
 insert into emp(name,gender,salary,join_date,dept_id) values('唐僧','男',9000,'2008-08-08',2);
 insert into emp(name,gender,salary,join_date,dept_id) values('白骨精','女',5000,'2015-10-07',3);
 insert into emp(name,gender,salary,join_date,dept_id) values('蜘蛛精','女',4500,'2011-03-14',1);
 insert into emp(name,gender,salary,join_date,dept_id) values('小白龙','男',3000,'2019-03-14',null);

 -- 需求1：查询工资最高的员工的信息（子查询的结果是一个值）
 SELECT
     *
 FROM
     emp
 WHERE -- 先查出最高的工资，再根据最高工资，查询员工信息。
     salary = (
             SELECT
                 MAX(salary)
             FROM
                 emp
             );

 -- 需求2：查询市场部和财务部的员工信息（子查询的结果是一列，使用IN运算符）
 SELECT
     *
 FROM
     emp
 WHERE
     dept_id IN (
                 SELECT
                     id
                 FROM
                     dept
                 WHERE
                     name in('市场部', '财务部')
                 );

 -- 需求3：查询2011年后入职的员工号，姓名，入职日期和其部门名称(查询的结果是一张表，可以像实体表一样参与查询)(注意：没有部门的员工不需要查询)
 -- 子查询解法
 SELECT
     t1.id,
     t1.name,
     t1.join_date,
     t2.name
 FROM
     (
         SELECT
             *
         FROM
             emp
         WHERE
             join_date >= '2011-01-01'
     ) AS t1,
     dept AS t2
 WHERE
     t1.dept_id = t2.id;

 -- 连接解法
 SELECT
     t1.id,
     t1.name,
     t1.join_date,
     t2.name
 FROM
     emp AS t1,
     dept AS t2
 WHERE
     t1.dept_id = t2.id
     AND t1.join_date >= '2011-01-01';

子查询

 /*
     连接练习：
         bug点：
             1.给表起别名后，不能使用原名称
             2.分组对null值也看成一组。
         约定：
             每个员工都有部门和职务。
         特殊数据：
             财务部新成立，没有员工。
 */
 DROP TABLE if EXISTS emp;
 DROP TABLE if EXISTS dept;
 DROP TABLE if EXISTS job;
 DROP TABLE if EXISTS salarygrade;

 -- 部门表
 CREATE TABLE dept (
   id INT PRIMARY KEY PRIMARY KEY, -- 部门id
   dname VARCHAR(50), -- 部门名称
   loc VARCHAR(50) -- 部门所在地
 );

 -- 添加4个部门
 INSERT INTO dept(id,dname,loc) VALUES
 (10,'教研部','北京'),
 (20,'学工部','上海'),
 (30,'销售部','广州'),
 (40,'财务部','深圳');

 -- 职务表，职务名称，职务描述
 CREATE TABLE job (
   id INT PRIMARY KEY,
   jname VARCHAR(20),
   description VARCHAR(50)
 );

 -- 添加4个职务
 INSERT INTO job (id, jname, description) VALUES
 (1, '董事长', '管理整个公司，接单'),
 (2, '经理', '管理部门员工'),
 (3, '销售员', '向客人推销产品'),
 (4, '文员', '使用办公软件');

 -- 员工表
 CREATE TABLE emp (
   id INT PRIMARY KEY, -- 员工id
   ename VARCHAR(50), -- 员工姓名
   job_id INT, -- 职务id
   mgr INT , -- 上级领导
   joindate DATE, -- 入职日期
   salary DECIMAL(7,2), -- 工资
   bonus DECIMAL(7,2), -- 奖金
   dept_id INT, -- 所在部门编号
   CONSTRAINT emp_jobid_ref_job_id_fk FOREIGN KEY (job_id) REFERENCES job (id),
   CONSTRAINT emp_deptid_ref_dept_id_fk FOREIGN KEY (dept_id) REFERENCES dept (id)
 );

 -- 添加员工
 INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES
 (1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
 (1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
 (1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
 (1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
 (1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
 (1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
 (1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
 (1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
 (1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
 (1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
 (1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
 (1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
 (1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
 (1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);

 -- 工资等级表
 CREATE TABLE salarygrade (
   grade INT PRIMARY KEY,   -- 级别
   losalary INT,  -- 最低工资
   hisalary INT -- 最高工资
 );

 -- 添加5个工资等级
 INSERT INTO salarygrade(grade,losalary,hisalary) VALUES
 (1,7000,12000),
 (2,12010,14000),
 (3,14010,20000),
 (4,20010,30000),
 (5,30010,99990);

 -- 需求：(约定所有的员工都有部门和工作)

 -- 1.查询所有员工信息。查询员工编号，员工姓名，工资，职务名称，职务描述
 /*
     分析：
         1.员工编号，员工姓名，工资 emp表，职务名称，职务描述 job表
         2.使用连接，连接条件是 emp.job_id = job.id
 */
 SELECT
     t1.id, -- 员工编号
     t1.ename, -- 员工姓名
     t1.salary, -- 员工工资
     t2.jname, -- 职务名称
     t2.description -- 职务描述
 FROM
     emp AS t1 -- 员工表
     JOIN
         job    AS t2 -- 职务表
     ON
         t1.job_id = t2.id;

 -- 2.查询员工编号，员工姓名，工资，职务名称，职务描述，部门名称，部门位置
 /*
     分析：
         1.员工编号，员工姓名，工资 emp表，职务名称，职务描述 job表，部门名称，部门位置 dept表
         2.使用连接查询，连接条件 emp.job_id = job.id, emp.dept_id = dept.id
 */
 SELECT
     t1.id, -- 员工编号
     t1.ename, -- 员工姓名
     t1.salary, -- 员工工资
     t2.jname, -- 职务名称
     t2.description, -- 职务描述
     t3.dname, -- 部门名称
     t3.loc -- 部门位置
 FROM
     emp AS t1 -- 员工表
     JOIN
         job AS t2 -- 职务表
     ON
         t1.job_id = t2.id
     JOIN
         dept AS t3 -- 部门表
     ON t1.dept_id = t3.id;
 -- 3.查询员工姓名，工资，工资等级
 /*
     分析：
         1.员工姓名，工资 emp表，工资等级 salarygrade表
         2.通过连接，连接条件是工资在区间内。emp.salary >= salarygrade.losalary <= salarygrade.hisalary
         简化 emp.salary BETWEEN salarygrade.losalary AND salarygrade.hisalary
 */
 SELECT
     t1.ename, -- 员工姓名
     t1.salary, -- 工资
     t2.grade -- 工资等级
 FROM
     emp AS t1 -- 员工表
     JOIN
         salarygrade AS t2 -- 薪资等级表
     ON
         t1.salary BETWEEN t2.losalary AND t2.hisalary;
 -- 4.查询员工姓名，工资，职务名称，职务描述，部门名称，部门位置，工资等级
 /*
         分析：
             1.员工姓名，工资 emp表，职务名称，职务描述 job表，部门名称，部门位置 dept表，工资等级 salarygrade表
             2.需要进行连接，连接条件：
                 emp.job_id = job.id, emp.dept_id = dept.id
                 emp.salary BETWEEN salarygrade.losalary AND salarygrade.hisalary
 */
 SELECT
     t1.ename, -- 员工姓名
     t1.salary, -- 工资
     t2.jname, -- 职务名称
     t2.description, -- 职务描述
     t3.dname, -- 部门名称
     t3.loc, -- 部门位置
     t4.grade -- 工资等级
 FROM
     emp AS t1 -- 员工表
     JOIN
         job AS t2 -- 职务表
     ON
         t1.job_id = t2.id
     JOIN
         dept AS t3 -- 部门表
     ON
         t1.dept_id = t3.id
     JOIN
         salarygrade AS t4 -- 薪资等级表
     ON
         t1.salary BETWEEN t4.losalary AND t4.hisalary;

 -- 5.查询出部门编号、部门名称、部门位置、部门人数
 /*
     分析：
         1.查询出部门编号、部门名称、部门位置 dept表、部门人数 emp表
         2.员工表和部门表根据外键连接，左外连接进行连接，再统计部门人数
     特殊数据：
         财务部新成立，没有员工。
 */
 SELECT
     t1.id,
     t1.dname,
     t1.loc,
     count(t2.id) -- 不能写count(*),因为它会统计悬浮元组，悬浮元组表示没有员工，不应该被统计
 FROM
     dept AS t1 -- 部门表
     LEFT JOIN
         emp AS t2 -- 员工表
     ON
         t1.id = t2.dept_id
 GROUP BY
     t1.id; -- 根据部门分组

 /*
     典型错误代码：不能查询出人数为0的部门
 */
 SELECT
     t1.id,
     t1.dname,
     t1.loc,
     count(*)
     -- count(*) count(t1.id) count(t2.id) 都得不到正确结果
 FROM
     dept AS t1,
     emp AS t2
 WHERE
     t1.id = t2.dept_id
 GROUP BY
     t1.id;

 -- 6.查询所有员工的姓名及其直接上级的姓名,没有领导的员工也需要查询
 /*
     分析：
         1.所有员工的姓名及其直接上级的姓名,没有领导的员工也需要查询 emp表
         2.自连接，连接条件 emp.mgr = emp.id，必须使用别名
 */
 SELECT
     t1.ename AS ename, -- 员工姓名
     t2.ename AS manager -- 直接上级
 FROM -- 对员工表进行自连接，左外连接。
     emp AS t1
     LEFT JOIN
         emp AS t2
     ON
         t1.mgr = t2.id;

连接练习

 /*
 约束分类: 4种约束的CRUD
 注意点：
 唯一 主键 外键 都可以约束多列。
 4种约束，建表后，添加约束，如果表中有数据，则可能出bug，导致约束添加失败。

 查询约束：
         查询约束信息：SHOW CREATE TABLE 表名;
         查询约束语法：help create talbe; help alter table

     1.非空
             NOT NULL 非空
         建表时加非空，删除非空，建表后加非空

         建表后添加非空约束：
         bug: 如果表中有数据，并且指定列有null值，则非空约束添加失败。

     2.唯一
             UNIQUE 唯一，可以有多个null值
         建表时加UNIQUE，删除UNIQUE，建表后加UNIQUE

         建表后添加唯一约束：
         bug: 如果表中有数据，并且指定的列有重复数据，则UNIQUE约束添加失败

         注意点：
             UNIQUE约束允许多个null值。

     3.主键
         PRIMARY KEY  唯一非空，一张表只能有一个主键约束
         建表时加PRIMARY KEY，删除PRIMARY KEY，建表后加PRIMARY KEY

         建表后添加主键约束：
         bug: 如果表中有数据，并且指定列含有null值或者重复数据，则添加主键失败。

         注意点：
             1.PRIMARY KEY != UNIQUE + NOT NULL（因为主键只能有一个，而UNIQUE + NOT NULL可以多个）
             2.删除PRIMARY KEY后还会有一个NOT NULL约束

     4.外键
         FOREIGN KEY 外键约束可以设置级联更新和级联删除
         建表时加FOREIGN KEY，删除FOREIGN KEY，建表后加FOREIGN KEY

         建表后添加外键约束：
         bug: 如果从表有数据，并且外键列引用了被引用列没有的值，则添加外键约束失败

         注意点：
             1.添加外键约束，主表必须存在
             2.表数据约束：
                 1.从表不能引用主表中不存在的值
                 2.主表不能删除被从表引用的记录
             3.删表：从表引用主表，不能直接删除主表。

     5.综合：
     唯一 主键 外键 都可以约束多列。
     4种约束，建表后，添加约束，如果表中有数据，则可能出bug，导致约束添加失败。

     6.自动增长
             AUTO_INCREMENT
             1.一张表只能有一个自动增长列，该列必须是数值类型
             2.自增的新值= 表数据最大值 + 1
     7.默认值
             DEFAULT

 */
 DROP TABLE IF EXISTS student;

 -- 建表时添加NOT NULL约束
 CREATE TABLE student(
     name VARCHAR(50) NOT NULL
 );

 -- 删除NOT NULL约束
 ALTER TABLE student MODIFY name VARCHAR(50);

 -- 建表后添加NOT NULL约束
 -- bug: 如果表中有数据，并且指定列有null值，则非空约束添加失败。
 ALTER TABLE student MODIFY name VARCHAR(50) NOT NULL;
 DELETE FROM student WHERE name IS NULL;

 DROP TABLE IF EXISTS student;

 -- 建表时,添加UNIQUE约束
 CREATE TABLE student(
     name VARCHAR(50) UNIQUE
 );

 CREATE TABLE student(
     name VARCHAR(50),
     CONSTRAINT uni_name UNIQUE(name)
 );

 -- 删除UNIQUE约束
 ALTER TABLE student DROP INDEX name;

 -- 建表后,添加UNIQUE约束
 -- bug: 如果表中有数据，并且指定的列有重复数据，则UNIQUE约束添加失败
 ALTER TABLE student MODIFY name VARCHAR(50) UNIQUE;
 ALTER TABLE student ADD CONSTRAINT uni_name UNIQUE(name);

 -- 查看表信息
 SHOW CREATE TABLE student;

 /*
     PRIMARY KEY 主键约束
         唯一非空，一张表只能有一个主键约束
         注意点：
             PRIMARY KEY != UNIQUE + NOT NULL（因为主键只能有一个，而UNIQUE + NOT NULL可以多个）
 */
 DROP TABLE IF EXISTS student;

 -- 建表时,添加PRIMARY KEY约束
 CREATE TABLE student(
     name VARCHAR(50) PRIMARY KEY
 );

 CREATE TABLE student(
     name VARCHAR(50),
     PRIMARY KEY(name)
 );

 -- 删除主键
 ALTER TABLE student DROP PRIMARY KEY; -- 删除后还有一个NOT NULL约束

 -- 创建完表后，添加主键
 -- bug: 如果表中有数据，并且指定列含有null值或者重复数据，则添加主键失败。
 ALTER TABLE student MODIFY name VARCHAR(50) PRIMARY KEY;
 ALTER TABLE student ADD PRIMARY KEY (name); 

 -- 查看表：约束
 SHOW CREATE TABLE student;

 /*
     外键约束：
         注意点：
             1.添加外键约束，主表必须存在
             2.表数据约束：
                 1.从表不能引用主表中不存在的值
                 2.主表不能删除被从表引用的记录
             3.删表：从表引用主表，不能直接删除主表。
 */
 DROP TABLE IF EXISTS employee;
 DROP TABLE IF EXISTS department;

 CREATE TABLE department(
     id INT PRIMARY KEY,
     name varchar(50) UNIQUE NOT NULL
 );
 -- 建表时，添加外键
 CREATE TABLE employee(
     id INT PRIMARY KEY,
     name    varchar(50) NOT NULL,
     dep_id    INT,
     CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id)
 );
 -- 删除外键
 ALTER TABLE employee DROP FOREIGN KEY emp_dep_fk;

 -- 建表后，添加外键
 -- bug: 如果从表有数据，并且外键列引用了被引用列没有的值，则添加外键约束失败
 ALTER TABLE employee ADD CONSTRAINT emp_dep_fk FOREIGN KEY(dep_id) REFERENCES department(id);

 SHOW CREATE TABLE employee;

表约束