文章目录
五、数据表的关联关系
5.1、关联关系介绍
Mysql是一个关系型数据库，不仅可以存储数据，还可以维护数据与数据之间的关系- -通过在数据表中添加字段建立外键约束
数据与数据之间的关联关系分为：
- 一对一关联
- 一对多关联
- 多对一关联
- 多对多关联
5.1.1、一对一关联
在 MySQL 数据库中，一对一关联（One-to-One Relationship）是指两个表之间的关联关系，其中一个表的每一行只能与另一个表的一行进行关联
一对一关联通常通过在两个表之间共享主键或外键来实现。主键是一个唯一标识符，用于唯一标识一个表中的每一行。外键是一个指向另一个表中主键的字段，用于建立两个表之间的关联
实例：
假设有两个表：users（用户）和 profiles（用户资料）。每个用户只能拥有一个用户资料，并且每个用户资料也只能属于一个用户。这是一个典型的一对一关联
首先创建 users 表，定义主键 user_id，用于唯一标识每个用户：
CREATE TABLE users (
user_id INT PRIMARY KEY,
username VARCHAR(50),
email VARCHAR(50)
);
然后创建 profiles 表，使用外键 user_id 与 users 表的主键建立关联：
CREATE TABLE profiles (
profile_id INT PRIMARY KEY,
user_id INT UNIQUE,
full_name VARCHAR(100),
address VARCHAR(100),
FOREIGN KEY (user_id) REFERENCES users(user_id)
);
在上面的示例中，user_id 字段在 users 表中定义为主键，并在 profiles 表中定义为外键。通过将 user_id 字段定义为 UNIQUE，我们确保每个用户资料只能与一个用户关联
最后可以插入数据并进行查询
-- 插入用户数据
INSERT INTO users (user_id, username, email) VALUES (1, 'John', 'john@example.com');
-- 插入用户资料数据
INSERT INTO profiles (profile_id, user_id, full_name, address) VALUES (1, 1, 'John Doe', '123 Main St');
-- 查询用户及其对应的用户资料
SELECT users.username, profiles.full_name, profiles.address
FROM users
JOIN profiles ON users.user_id = profiles.user_id;
需要注意的是，一对一关联在实际应用中并不是最常见的关联类型，因为在许多情况下，可以将相关数据直接合并到一个表中。但在某些情况下，一对一关联仍然是有用的，例如将大型表拆分为多个关联的表，以提高查询性能或满足数据规范性要求
5.1.2 一对多关联
MySQL中的一对多关联是指一个表的记录与另一个表的多个记录相关联。这种关联关系在数据库设计中非常常见，可以通过使用外键来实现
实例：
假设有两个表：订单（orders）和订单项（order_items）。一个订单可以有多个订单项，而一个订单项只能属于一个订单。这是典型的一对多关联
首先创建订单表，定义一个主键order_id用于唯一标识每个订单：
CREATE TABLE orders (
order_id INT PRIMARY KEY,
customer_id INT,
order_date DATE,
total_amount DECIMAL(10,2),
FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
在上面的语句中，customer_id字段被定义为外键，参考了另一个表customers中的主键。这样可以将每个订单与特定的客户关联起来
我们创建订单项表，使用外键order_id与orders表的主键建立关联：
CREATE TABLE order_items (
item_id INT PRIMARY KEY,
order_id INT,
product_id INT,
quantity INT,
price DECIMAL(10,2),
FOREIGN KEY (order_id) REFERENCES orders(order_id)
);
在上面的语句中，order_id字段被定义为外键，参考了orders表中的主键。这样可以将每个订单项与特定的订单关联起来
最后可以插入数据并进行查询：
-- 插入订单数据
INSERT INTO orders (order_id, customer_id, order_date, total_amount)
VALUES (1, 1, '2024-04-13', 100.00);
-- 插入订单项数据
INSERT INTO order_items (item_id, order_id, product_id, quantity, price)
VALUES (1, 1, 1, 2, 50.00),
(2, 1, 2, 1, 30.00);
-- 查询订单及其对应的订单项
SELECT orders.order_id, orders.order_date, order_items.product_id, order_items.quantity
FROM orders
JOIN order_items ON orders.order_id = order_items.order_id;
需要注意的是，一对多关联是数据库设计中常见的关系类型，它允许我们在不同的表之间建立关联，以更好地组织和管理数据
5.1.3 多对多关联
MySQL中的多对多关联是指两个表之间存在多对多的关系，即一个表的记录可以与另一个表的多个记录相关联，反之亦然。为了实现多对多关联，通常需要借助一个中间表来跟踪两个表之间的关系
假设有两个表：学生（students）和课程（courses）。一个学生可以选择多门课程，而一门课程也可以有多个学生选择。这是典型的多对多关联
实例：
为了建立多对多关联，我们需要创建一个中间表来存储学生和课程之间的关系。这个中间表通常包含两个外键，分别引用学生表和课程表的主键
CREATE TABLE students (
student_id INT PRIMARY KEY,
student_name VARCHAR(50)
);
CREATE TABLE courses (
course_id INT PRIMARY KEY,
course_name VARCHAR(50)
);
CREATE TABLE student_courses (
student_id INT,
course_id INT,
PRIMARY KEY (student_id, course_id),
FOREIGN KEY (student_id) REFERENCES students(student_id),
FOREIGN KEY (course_id) REFERENCES courses(course_id)
);
在上面的语句中，student_courses表是中间表，它包含了student_id和course_id两个字段作为外键，分别引用了students表和courses表的主键。同时，我们还将这两个字段定义为联合主键，以确保每个学生和课程的组合是唯一的
最后可以插入数据并进行查询
-- 插入学生数据
INSERT INTO students (student_id, student_name)
VALUES (1, 'Alice'),
(2, 'Bob');
-- 插入课程数据
INSERT INTO courses (course_id, course_name)
VALUES (1, 'Math'),
(2, 'Science');
-- 插入学生选课数据
INSERT INTO student_courses (student_id, course_id)
VALUES (1, 1), -- Alice选择了Math课程
(1, 2), -- Alice选择了Science课程
(2, 2); -- Bob选择了Science课程
-- 查询学生及其选择的课程
SELECT students.student_name, courses.course_name
FROM students
JOIN student_courses ON students.student_id = student_courses.student_id
JOIN courses ON student_courses.course_id = courses.course_id;
需要注意的是，多对多关联是一种常见的关系类型，用于解决复杂的数据关系。通过使用中间表来跟踪关联关系，我们可以灵活地管理和查询多对多关联的数据
5.1.4 多对一关联
MySQL中的多对一关联是指多个记录关联到另一个表的单个记录。这种关联关系在数据库设计中也是常见的，通常使用外键来实现
假设有两个表：部门（departments）和员工（employees）。多个员工可以属于同一个部门，而一个员工只能属于一个部门。这就是典型的多对一关联
实例：
首先创建部门表，定义一个主键department_id用于唯一标识每个部门：
CREATE TABLE departments (
department_id INT PRIMARY KEY,
department_name VARCHAR(50)
);
然后创建员工表，使用外键department_id与departments表的主键建立关联：
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
employee_name VARCHAR(50),
department_id INT,
FOREIGN KEY (department_id) REFERENCES departments(department_id)
);
在上面的语句中，department_id字段被定义为外键，参考了departments表的主键。这样可以将每个员工与所属的部门关联起来
最后可以插入数据并进行查询
-- 插入部门数据
INSERT INTO departments (department_id, department_name)
VALUES (1, '销售部'),
(2, '人力资源部');
-- 插入员工数据
INSERT INTO employees (employee_id, employee_name, department_id)
VALUES (1, '张三', 1), -- 张三属于销售部
(2, '李四', 1), -- 李四也属于销售部
(3, '王五', 2); -- 王五属于人力资源部
-- 查询部门及其对应的员工
SELECT departments.department_name, employees.employee_name
FROM departments
JOIN employees ON departments.department_id = employees.department_id;
多对一关联可以帮助我们组织和管理数据，为员工和部门之间建立关系。通过使用外键来关联表，我们可以轻松地进行数据查询和关联操作
5.1.5 外键约束
外键约束是指将一个列添加外键约束与另一张表的主键唯一列进行关联之后，这个外键约束的列添加的数据必须要在关联的主键字段中存在
实例：
创建学生表与班级表，在学生表中添加外键与班级表的主键进行关联
创建原则：先创建不包含外键的表也就是班级表
创建班级表：
create table classes(
class_id int primary key auto_increment,
class_name varchar(40) not null unique,
class_remark varchar(200)
);
上述语句中创建了班级表（classes），并创建了三个列：班级id（class_id）、班级名称（class_name）、班级备注（class_remark），且class_id为主键
创建学生表，并在学生表中添加外键与班级表的主键进行关联：
方法一：在创建表的时候，定义cid字段，并添加外键约束
由于cid列要与classes表的class_id进行关联，因此cid字段类型和长度要与class_id一致
create table students(
stu_num char(8) primary key,
stu_name varchar(20) not null,
stu_gender char(2) not null,
stu_age int not null,
cid int unique,
# 如需一对一关系，那么就需要添加unique约束
constraint FK_STUDENTS_CLASSES foreign key(cid) references classes(class_id)
);
# constraint：关键字
# FK_STUDENTS_CLASSES：约束名称
# foreign key(cid)：外键约束 + 关键字段
# references classes(class_id)：关联的表的具体字段
方法二：先创建表，再添加外键约束
create table students1(
stu_num char(8) primary key,
stu_name varchar(20) not null,
stu_gender char(2) not null,
stu_age int not null,
cid int
);
#添加cid外键约束
alter table students1 add constraint FK_STUDENTS1_CLASSES foreign key(cid) references classes(class_id);
创建班级表数据
insert into classes(class_name,class_remark) values('python2024','2024年python班级');
insert into classes(class_name,class_remark) values('linux2023','2023年linux班级');
insert into classes(class_name,class_remark) values('java2022','2022年java班级');
insert into classes(class_name,class_remark) values('html2021','2021年html班级');
insert into classes(class_name,class_remark) values('c++2020','2020年c++班级');
insert into classes(class_name,class_remark) values('c++2019','2019年c++班级');
insert into classes(class_name,class_remark) values('windows2018','2018年windows班级');
insert into classes(class_name,class_remark) values('android2017','2017年android班级');
insert into classes(class_name,class_remark) values('javascript2016','2016年javascript班级');
insert into classes(class_name,class_remark) values('python2015','2015年python班级');
因为主键自增，所以这里不用添加class_id的数据
创建学生表数据
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20240101','王一','女',20,10);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20230101','王二','女',20,9);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20220101','王三','女',20,8);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20210101','王四','女',20,7);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20200101','王五','女',20,6);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20190101','王六','女',20,5);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20180101','王七','女',20,4);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20170101','王八','女',20,3);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20160101','王九','女',20,2);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('20150101','王十','女',20,1);
删除外键
alter table students drop foreign key FK_STUDENTS_CLASSES;
5.1.6 外键约束 - 级联
外键约束级联是一种数据库设计机制，用于在删除或更新主表中的记录时，自动对相关联的从表中的记录进行相应的操作以保证数据一致性
详细介绍：
保持数据一致性：外键约束的主要目的是保证数据的完整性和一致性。当两个表之间存在外键关系时，任何尝试破坏这种关系的操作（如插入、更新或删除）都将受到限制或级联影响。
级联操作的种类：级联可以指在主表（父表）上执行删除或更新操作时，同时在从表（子表）上自动执行相同的操作。例如，如果一个订单记录被删除，那么所有与该订单相关的订单详情记录也会被删除。
一对多关系：在一对多的关系中，一个父表记录可能对应多个子表记录。使用级联约束，可以确保当父表中的记录被删除时，所有关联的子表记录也会被删除，从而避免留下孤立的子表记录。
定义外键约束：在创建表时，可以使用FOREIGN KEY关键字来定义外键约束，并指定级联操作的类型。这通常在数据库的创建语句中完成。
数据库支持：不是所有的数据库系统都支持外键约束的级联操作。但是，像MySQL这样的现代关系型数据库通常都支持这一功能，并且提供了丰富的选项来配置级联行为。
数据操作的影响：在使用级联外键约束时，需要谨慎考虑数据操作的后果。因为一旦对主表进行了删除或更新操作，所有相关的从表数据也将受到影响。
六、连接查询
在Mysql中可以使用join实现多表的联合查询 – 连接查询，join按照其功能不同分为inner join内连接、left join左连接、right join右连接
6.1、环境准备
创建新的数据库
mysql> create database db_list;
Query OK, 1 row affected (0.02 sec)
mysql> use db_list;
Database changed
mysql>
创建班级信息和学生信息表
mysql> create table classes(
-> class_id int primary key auto_increment,
-> class_name varchar(40) not null unique,
-> class_remark varchar(200)
-> );
Query OK, 0 rows affected (0.04 sec)
mysql> create table students(
-> stu_num char(8) primary key,
-> stu_name varchar(20) not null,
-> stu_gender char(2) not null,
-> stu_age int not null,
-> cid int,
-> constraint FK_STUDENTS_CLASSES foreign key(cid) references classes(class_id) ON UPDATE CASCADE ON DELETE CASCADE
-> );
Query OK, 0 rows affected (0.04 sec)
添加班级信息
mysql> insert into classes(class_name,class_remark) values('java001','001');
Query OK, 1 row affected (0.02 sec)
mysql> insert into classes(class_name,class_remark) values('java002','002');
Query OK, 1 row affected (0.01 sec)
mysql> insert into classes(class_name,class_remark) values('python001','001');
Query OK, 1 row affected (0.01 sec)
mysql> insert into classes(class_name,class_remark) values('python002','002');
Query OK, 1 row affected (0.00 sec)
添加学生信息
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('001','张','男',20,1);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('002','李','女',18,1);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('003','王','女',18,1);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('004','刘','男',20,2);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('005','孙','女',18,2);
insert into students(stu_num,stu_name,stu_gender,stu_age,cid) values('006','谢','女',18,2);
insert into students(stu_num,stu_name,stu_gender,stu_age) values('007','朱','男',20);
insert into students(stu_num,stu_name,stu_gender,stu_age) values('008','黄','女',18);
insert into students(stu_num,stu_name,stu_gender,stu_age) values('009','冷','女',18);
6.2、内连接
6.2.1、笛卡尔积
笛卡尔积（A集合&B集合）：使用A中的每个记录依次关联B中每个记录，笛卡尔积的总数=A总数*B总数
如果直接执行select … from tableName1 inner join tableName2;会获取两种数据表中的数据集合的笛卡尔积（依次使用tableName1表中的每一条记录去匹配tableName2的每条数据）
mysql> select * from students inner join classes;
+---------+----------+------------+---------+------+----------+------------+--------------+
| stu_num | stu_name | stu_gender | stu_age | cid | class_id | class_name | class_remark |
+---------+----------+------------+---------+------+----------+------------+--------------+
| 001 | 张 | 男 | 20 | 1 | 4 | python002 | 002 |
| 001 | 张 | 男 | 20 | 1 | 3 | python001 | 001 |
| 001 | 张 | 男 | 20 | 1 | 2 | java002 | 002 |
| 001 | 张 | 男 | 20 | 1 | 1 | java001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 4 | python002 | 002 |
| 002 | 李 | 女 | 18 | 1 | 3 | python001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 2 | java002 | 002 |
| 002 | 李 | 女 | 18 | 1 | 1 | java001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 4 | python002 | 002 |
| 003 | 王 | 女 | 18 | 1 | 3 | python001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 2 | java002 | 002 |
| 003 | 王 | 女 | 18 | 1 | 1 | java001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 4 | python002 | 002 |
| 004 | 刘 | 男 | 20 | 2 | 3 | python001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 2 | java002 | 002 |
| 004 | 刘 | 男 | 20 | 2 | 1 | java001 | 001 |
| 005 | 孙 | 女 | 18 | 2 | 4 | python002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 3 | python001 | 001 |
| 005 | 孙 | 女 | 18 | 2 | 2 | java002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 1 | java001 | 001 |
| 006 | 谢 | 女 | 18 | 2 | 4 | python002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 3 | python001 | 001 |
| 006 | 谢 | 女 | 18 | 2 | 2 | java002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 1 | java001 | 001 |
| 007 | 朱 | 男 | 20 | NULL | 4 | python002 | 002 |
| 007 | 朱 | 男 | 20 | NULL | 3 | python001 | 001 |
| 007 | 朱 | 男 | 20 | NULL | 2 | java002 | 002 |
| 007 | 朱 | 男 | 20 | NULL | 1 | java001 | 001 |
| 008 | 黄 | 女 | 18 | NULL | 4 | python002 | 002 |
| 008 | 黄 | 女 | 18 | NULL | 3 | python001 | 001 |
| 008 | 黄 | 女 | 18 | NULL | 2 | java002 | 002 |
| 008 | 黄 | 女 | 18 | NULL | 1 | java001 | 001 |
| 009 | 冷 | 女 | 18 | NULL | 4 | python002 | 002 |
| 009 | 冷 | 女 | 18 | NULL | 3 | python001 | 001 |
| 009 | 冷 | 女 | 18 | NULL | 2 | java002 | 002 |
| 009 | 冷 | 女 | 18 | NULL | 1 | java001 | 001 |
+---------+----------+------------+---------+------+----------+------------+--------------+
36 rows in set (0.00 sec)
6.2.2、内连接条件
使用on设置两张表连接查询的匹配条件
使用on设置连接查询条件，先判断连接条件是否成立，如果成立两张表的数据进行组合生成一条结果记录
mysql> select * from students inner join classes on students.cid = classes.class_id;
+---------+----------+------------+---------+------+----------+------------+--------------+
| stu_num | stu_name | stu_gender | stu_age | cid | class_id | class_name | class_remark |
+---------+----------+------------+---------+------+----------+------------+--------------+
| 001 | 张 | 男 | 20 | 1 | 1 | java001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 1 | java001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 1 | java001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 2 | java002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 2 | java002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 2 | java002 | 002 |
+---------+----------+------------+---------+------+----------+------------+--------------+
6 rows in set (0.00 sec)
使用where设置过滤条件，先生成笛卡尔积再从笛卡尔积中过滤数据（效率很低）
mysql> select * from students inner join classes where students.cid = classes.class_id;
+---------+----------+------------+---------+------+----------+------------+--------------+
| stu_num | stu_name | stu_gender | stu_age | cid | class_id | class_name | class_remark |
+---------+----------+------------+---------+------+----------+------------+--------------+
| 001 | 张 | 男 | 20 | 1 | 1 | java001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 1 | java001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 1 | java001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 2 | java002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 2 | java002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 2 | java002 | 002 |
+---------+----------+------------+---------+------+----------+------------+--------------+
6 rows in set (0.00 sec)
6.3、左连接 LEFT JOIN
显示左表中的所有数据，如果在右表中存在于左表记录满足匹配条件的数据，则进行匹配；如果右表中不存在匹配数据，则显示未Null
mysql> select * from students LEFT JOIN classes ON students.cid = classes.class_id;
+---------+----------+------------+---------+------+----------+------------+--------------+
| stu_num | stu_name | stu_gender | stu_age | cid | class_id | class_name | class_remark |
+---------+----------+------------+---------+------+----------+------------+--------------+
| 001 | 张 | 男 | 20 | 1 | 1 | java001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 1 | java001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 1 | java001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 2 | java002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 2 | java002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 2 | java002 | 002 |
| 007 | 朱 | 男 | 20 | NULL | NULL | NULL | NULL |
| 008 | 黄 | 女 | 18 | NULL | NULL | NULL | NULL |
| 009 | 冷 | 女 | 18 | NULL | NULL | NULL | NULL |
+---------+----------+------------+---------+------+----------+------------+--------------+
9 rows in set (0.00 sec)
6.4、右连接 RIGHT JOIN
mysql> select * from students RIGHT JOIN classes ON students.cid = classes.class_id;
+---------+----------+------------+---------+------+----------+------------+--------------+
| stu_num | stu_name | stu_gender | stu_age | cid | class_id | class_name | class_remark |
+---------+----------+------------+---------+------+----------+------------+--------------+
| 001 | 张 | 男 | 20 | 1 | 1 | java001 | 001 |
| 002 | 李 | 女 | 18 | 1 | 1 | java001 | 001 |
| 003 | 王 | 女 | 18 | 1 | 1 | java001 | 001 |
| 004 | 刘 | 男 | 20 | 2 | 2 | java002 | 002 |
| 005 | 孙 | 女 | 18 | 2 | 2 | java002 | 002 |
| 006 | 谢 | 女 | 18 | 2 | 2 | java002 | 002 |
| NULL | NULL | NULL | NULL | NULL | 3 | python001 | 001 |
| NULL | NULL | NULL | NULL | NULL | 4 | python002 | 002 |
+---------+----------+------------+---------+------+----------+------------+--------------+
8 rows in set (0.00 sec)
6.5、数据表别名
先将两表中的name列字段名都改为name
mysql> alter table students rename column stu_name to name;
Query OK, 0 rows affected (0.03 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> alter table classes rename column class_name to name;
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
如果在连接查询的多张表中存在相同的名字的字段，可以使用表名.字段名来进行区分
mysql> select students.name,classes.name
-> from students
-> inner join classes
-> on students.cid = classes.class_id;
+------+---------+
| name | name |
+------+---------+
| 张 | java001 |
| 李 | java001 |
| 王 | java001 |
| 刘 | java002 |
| 孙 | java002 |
| 谢 | java002 |
+------+---------+
6 rows in set (0.00 sec)
如果表名太长则不便SQL语句的编写，可以使用别名查询
mysql> select s.name,c.name
-> from students s
-> inner join classes c
-> on s.cid = c.class_id;
+------+---------+
| name | name |
+------+---------+
| 张 | java001 |
| 李 | java001 |
| 王 | java001 |
| 刘 | java002 |
| 孙 | java002 |
| 谢 | java002 |
+------+---------+
6 rows in set (0.00 sec)
6.6、子查询/嵌套查询
子查询：先进行一次查询，在第一次查询的基础上再进行一次查询
6.6.1、子查询返回单个值 - 单行单列
mysql> select class_id from classes where name='java001';
+----------+
| class_id |
+----------+
| 1 |
+----------+
1 row in set (0.01 sec)
mysql> select * from students where cid = 1;
+---------+------+------------+---------+------+
| stu_num | name | stu_gender | stu_age | cid |
+---------+------+------------+---------+------+
| 001 | 张 | 男 | 20 | 1 |
| 002 | 李 | 女 | 18 | 1 |
| 003 | 王 | 女 | 18 | 1 |
+---------+------+------------+---------+------+
3 rows in set (0.00 sec)
6.6.2、子查询返回多个值 - 多行单列
mysql> select class_id from classes where name LIKE 'java%';
+----------+
| class_id |
+----------+
| 1 |
| 2 |
+----------+
2 rows in set (0.01 sec)
mysql> select * from students where cid = 1
-> UNION
-> select * from students where cid = 2;
+---------+------+------------+---------+------+
| stu_num | name | stu_gender | stu_age | cid |
+---------+------+------------+---------+------+
| 001 | 张 | 男 | 20 | 1 |
| 002 | 李 | 女 | 18 | 1 |
| 003 | 王 | 女 | 18 | 1 |
| 004 | 刘 | 男 | 20 | 2 |
| 005 | 孙 | 女 | 18 | 2 |
| 006 | 谢 | 女 | 18 | 2 |
+---------+------+------------+---------+------+
6 rows in set (0.01 sec)
mysql> select * from students where cid in (select class_id from classes where name like 'java%');
+---------+------+------------+---------+------+
| stu_num | name | stu_gender | stu_age | cid |
+---------+------+------------+---------+------+
| 001 | 张 | 男 | 20 | 1 |
| 002 | 李 | 女 | 18 | 1 |
| 003 | 王 | 女 | 18 | 1 |
| 004 | 刘 | 男 | 20 | 2 |
| 005 | 孙 | 女 | 18 | 2 |
| 006 | 谢 | 女 | 18 | 2 |
+---------+------+------------+---------+------+
6 rows in set (0.01 sec)
6.6.3、子查询返回多个值 - 多行多列
mysql> select * from students where cid = 1 and stu_gender = '男';
+---------+------+------------+---------+------+
| stu_num | name | stu_gender | stu_age | cid |
+---------+------+------------+---------+------+
| 001 | 张 | 男 | 20 | 1 |
+---------+------+------------+---------+------+
1 row in set (0.00 sec)
mysql> select * from (select * from students where cid = 1) t where stu_gender = '男';
+---------+------+------------+---------+------+
| stu_num | name | stu_gender | stu_age | cid |
+---------+------+------------+---------+------+
| 001 | 张 | 男 | 20 | 1 |
+---------+------+------------+---------+------+
1 row in set (0.00 sec)
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
