SQL语句全攻略：从基础到进阶的编程之旅
目录
- 一、引言
- 二、SQL 基础语法
-
- 2.1 SQL 语句写法顺序
- 2.2 关联查询
- 2.3 数据处理常用函数和运算符
- 三、数据库和表的基本操作
-
- 3.1 创建数据库
- 3.2 使用数据库
- 3.3 创建表
- 四、基础增删改查操作
-
- 4.1 插入数据（增）
- 4.2 查询数据（查）
- 4.3 更新数据（改）
- 4.4 删除数据（删）
- 五、复杂关系操作
-
- 5.1 一对多关系操作
- 5.2 多对多关系操作
- 六、SQL 优化技巧
-
- 6.1 索引的使用
- 6.2 避免子查询
- 6.3 其他优化建议
- 七、SQL 高级用法
-
- 7.1 窗口函数
- 7.2 公共表达式（CTEs）
- 7.3 聚合函数的高级应用
- 八、总结
一、引言
在信息技术飞速发展的当下，数据已成为各行业至关重要的资产。无论是大型企业的海量业务数据，还是互联网公司的用户信息，都离不开高效的数据管理和处理。而 SQL（Structured Query Language），即结构化查询语言，作为与关系型数据库交互的标准语言，在数据管理和软件开发领域中占据着举足轻重的地位。
在数据管理方面，SQL 是创建、修改、管理和控制数据库中数据与数据结构的核心工具。通过 SQL，我们能够轻松完成数据库和表的创建、修改与删除，以及数据的插入、查询、更新和删除等操作。同时，SQL 还提供了丰富的数据查询工具和命令，支持对数据进行分类、排序、聚合等操作，帮助我们有效地管理和使用数据。比如在一个电商企业中，借助 SQL 可以方便地管理商品信息、订单数据以及用户资料，从而实现精准的库存管理、销售分析以及个性化推荐。
在软件开发领域，数据库是众多应用系统的重要组成部分，而 SQL 作为操作数据库的语言，自然成为了开发人员必须掌握的关键技能。无论是前端开发还是后端开发，都需要与数据库进行交互，以实现数据的存储、读取和更新。例如，在开发一个在线教育平台时，通过 SQL 可以实现用户课程信息的存储、学习进度的跟踪以及学习资料的查询等功能，为平台的稳定运行和用户体验提供有力支持。
掌握 SQL 语句不仅能提升数据处理的效率和准确性，还能为数据分析、数据挖掘以及机器学习等领域打下坚实的基础。无论是数据分析师从海量数据中提取有价值的信息，还是数据科学家进行复杂的数据建模，都离不开 SQL 的支持。此外，在面试中，SQL 的考察也是一道必不可少的关卡，掌握 SQL 能够为你的职业发展增添强大的竞争力。
本文将全面深入地讲解 SQL 语句，从基础语法到高级应用，从简单查询到复杂的多表关联，旨在帮助读者系统地掌握 SQL 这门强大的语言，提升在数据管理和软件开发领域的能力。无论你是初学者，还是有一定经验的开发者，都能从本文中获取到有价值的知识和技巧，开启 SQL 学习的进阶之旅。
二、SQL 基础语法
2.1 SQL 语句写法顺序
SQL 语句中常见的子句有 SELECT、FROM、WHERE、GROUP BY、HAVING、ORDER BY 和 LIMIT ，它们的书写顺序决定了查询的逻辑结构和功能实现。
- SELECT：该子句用于指定要查询的列。可以是具体的列名，如SELECT column1, column2 FROM table_name;，也可以使用通配符*来表示查询所有列，即SELECT * FROM table_name;。此外，还能使用聚合函数，比如计算某列的总和SUM(column_name)、平均值AVG(column_name)等 。
- FROM：用于指定查询数据的来源表，例如FROM employees表示从名为employees的表中获取数据。
- WHERE：用于筛选数据，通过指定条件来过滤表中的记录，只有满足条件的行才会被包含在结果集中。条件表达式可以使用比较运算符（如=、<>、<、>等）、逻辑运算符（如AND、OR、NOT）等。例如WHERE salary > 5000表示筛选出工资大于 5000 的记录。需要注意的是，WHERE 子句针对的是原表，条件中的列名只能是原表的列名，不能使用别名或者聚合函数。
- GROUP BY：用于对查询结果进行分组。可以根据一个或多个列的值将结果集划分为不同的组，通常会与聚合函数一起使用，以便对每个组进行计算。例如GROUP BY department会按照department列对结果进行分组。条件中的列既可以使用原名，也可以使用别名。
- HAVING：用于对分组后的结果进行进一步筛选。与 WHERE 子句类似，但 HAVING 子句是在分组之后进行过滤，所以可以使用聚合函数。例如HAVING AVG(salary) > 6000表示筛选出平均工资大于 6000 的分组。条件中的列同样可以使用原名或别名。
- ORDER BY：用于对查询结果进行排序，可以按照一个或多个列进行升序（ASC）或降序（DESC）排序。例如ORDER BY salary DESC表示按照salary列降序排列结果集。条件中的列可以使用原名或别名，默认是升序排序，如果不指定ASC或DESC，则按照升序排列。
- LIMIT：用于限制查询结果返回的行数。可以指定返回的起始行和行数，如LIMIT 0, 10表示从第 1 行开始（索引从 0 开始），返回 10 行数据；也可以只指定一个参数，如LIMIT 5，表示返回前 5 行数据。
以一个电商数据库为例，假设我们有orders表（包含order_id、customer_id、order_date、total_amount等字段）和customers表（包含customer_id、customer_name、city等字段），要查询每个城市的订单总金额，并按照总金额降序排列，只返回前 5 个城市的数据，SQL 语句如下：
SELECT c.city, SUM(o.total_amount) AS total_amount
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id
GROUP BY c.city
HAVING SUM(o.total_amount) > 10000
ORDER BY total_amount DESC
LIMIT 5;
在这个例子中，首先通过FROM和JOIN指定了数据来源是orders表和customers表，并通过ON条件关联这两个表；然后使用WHERE筛选出符合条件的订单记录；接着用GROUP BY按照城市对订单进行分组；HAVING进一步筛选出总金额大于 10000 的分组；ORDER BY对分组后的结果按照总金额降序排列；最后LIMIT限制只返回前 5 个城市的数据。通过这样的顺序组合这些子句，能够实现复杂的数据查询和分析需求。
2.2 关联查询
关联查询是 SQL 中用于从多个表中获取相关数据的重要技术，通过连接条件将不同表中的数据进行关联，从而生成包含多个表信息的结果集。常见的关联查询类型有内连接、外连接（左、右、全外连接）和自连接。
- 内连接（INNER JOIN）：内连接是最常用的连接类型之一，它返回两个表中在连接条件上匹配的行。只有当两个表中连接列的值相等时，对应的行才会被包含在结果集中。其语法结构为：
SELECT columns
FROM table1
INNER JOIN table2 ON table1.column = table2.column;
假设我们有students表（包含student_id、student_name、class_id等字段）和classes表（包含class_id、class_name等字段），要查询每个学生所属的班级名称，SQL 语句可以这样写：
SELECT s.student_name, c.class_name
FROM students s
INNER JOIN classes c ON s.class_id = c.class_id;
在这个例子中，通过内连接将students表和classes表根据class_id列进行关联，返回了每个学生及其对应的班级名称。内连接适用于需要获取多个表中相互关联的数据，且只关注匹配数据的场景，比如在电商系统中查询订单对应的商品信息，只有订单中包含的商品信息才会被返回。
- 外连接：
- 左外连接（LEFT JOIN）：左外连接会返回左表中的所有行，以及右表中与左表匹配的行。如果右表中没有匹配的行，则在结果集中用NULL值填充右表的列。语法如下：
SELECT columns
FROM table1
LEFT JOIN table2 ON table1.column = table2.column;
例如，要查询所有学生及其可能所属的班级名称（包括没有分配班级的学生），SQL 语句为：
SELECT s.student_name, c.class_name
FROM students s
LEFT JOIN classes c ON s.class_id = c.class_id;
此时，即使某个学生没有对应的班级（即students表中的class_id在classes表中没有匹配值），该学生的记录也会被返回，class_name列显示为NULL。左外连接常用于保留左表的所有数据，并获取与之相关的右表数据，即使右表中没有完全匹配的数据。比如在员工管理系统中，查询所有员工及其可能关联的部门信息，即使某些员工还未分配到具体部门，这些员工的信息也会被完整返回。
- 右外连接（RIGHT JOIN）：右外连接与左外连接相反，它返回右表中的所有行，以及左表中与右表匹配的行。如果左表中没有匹配的行，则在结果集中用NULL值填充左表的列。语法为：
SELECT columns
FROM table1
RIGHT JOIN table2 ON table1.column = table2.column;
假设要查询所有班级及其包含的学生信息（包括没有学生的班级），可以使用右外连接：
SELECT s.student_name, c.class_name
FROM students s
RIGHT JOIN classes c ON s.class_id = c.class_id;
这里，即使某个班级当前没有学生，该班级的记录也会被返回，student_name列显示为NULL。右外连接适用于需要重点关注右表数据，并获取与之相关的左表数据的场景，比如在课程管理系统中，查询所有课程及其可能关联的学生成绩，即使某些课程还没有学生选修，这些课程的信息也会被完整展示。
- 全外连接（FULL JOIN）：全外连接会返回左表和右表中的所有行。如果某个表中没有与另一个表匹配的行，则在结果集中用NULL值填充相应的列。语法为：
SELECT columns
FROM table1
FULL JOIN table2 ON table1.column = table2.column;
例如，要查询所有学生和所有班级的信息，无论学生是否分配到班级，班级是否有学生，都可以使用全外连接：
SELECT s.student_name, c.class_name
FROM students s
FULL JOIN classes c ON s.class_id = c.class_id;
全外连接适用于需要获取两个表的所有数据，并展示它们之间可能的关联关系的场景，即使这种关联关系并不完整。比如在一个综合的学校管理系统中，查询所有学生和所有班级的信息，以便全面了解学生和班级的整体情况，包括那些尚未建立关联的学生和班级。
- 自连接（SELF JOIN）：自连接是指在同一个表上进行的连接操作，通常用于比较或组合表中不同行的数据。在自连接中，需要为表取不同的别名来区分不同的行。语法结构如下：
SELECT t1.column1, t2.column2
FROM table_name t1
JOIN table_name t2 ON t1.some_column = t2.some_column;
假设有一个employees表（包含employee_id、employee_name、manager_id等字段），manager_id表示员工的上级经理的employee_id，要查询每个员工及其对应的经理姓名，可以使用自连接：
SELECT e.employee_name, m.employee_name AS manager_name
FROM employees e
JOIN employees m ON e.manager_id = m.employee_id;
在这个例子中，通过自连接将employees表与自身进行关联，e表示员工，m表示经理，根据manager_id和employee_id的对应关系，查询出每个员工及其经理的姓名。自连接常用于处理层级关系的数据，如员工与经理关系、商品类别层级关系等，通过自身连接来获取同一表中不同行之间的关联信息。
2.3 数据处理常用函数和运算符
在 SQL 中，函数和运算符是进行数据处理和计算的重要工具，能够帮助我们对数据进行各种操作和转换，以满足不同的查询和分析需求。下面介绍一些常用的函数和运算符。
- DISTINCT：DISTINCT不是一个函数，而是一个关键字，用于在查询结果中去除重复的行。当我们希望获取某一列或多列的唯一值时，可以使用它。例如，在students表中有city列，要查询所有不同的城市，SQL 语句为：
SELECT DISTINCT city
FROM students;
这样就能得到city列中所有不重复的城市名称，避免重复数据对分析结果的干扰，在统计城市数量等场景中非常有用。
- IF 函数：IF函数用于条件判断，其语法为IF(condition, value_if_true, value_if_false)。如果condition条件为真，则返回value_if_true，否则返回value_if_false。假设在orders表中有order_amount列表示订单金额，我们要根据订单金额判断订单状态，金额大于 1000 为 “大额订单”，否则为 “普通订单”，SQL 语句如下：
SELECT order_id, order_amount,
IF(order_amount > 1000, '大额订单', '普通订单') AS order_status
FROM orders;
通过IF函数，我们能够根据订单金额动态地生成订单状态，方便对订单数据进行分类和分析，在电商数据分析、客户分级等场景中经常使用。
- IFNULL 函数：IFNULL函数用于判断一个表达式是否为NULL，如果为NULL，则返回指定的值，否则返回表达式本身的值。语法为IFNULL(expr1, expr2)。在employees表中，如果salary列可能存在NULL值，我们希望将其替换为 0，以便进行统计计算，SQL 语句可以写成：
SELECT employee_name, IFNULL(salary, 0) AS salary
FROM employees;
这样，在查询结果中，salary列的NULL值就会被替换为 0，保证了数据的完整性和可用性，在数据清洗、统计分析等场景中是非常实用的函数，能够避免NULL值对计算结果产生影响。
- EXISTS 和 NOT EXISTS：EXISTS和NOT EXISTS是用于子查询的运算符，用于判断子查询是否返回结果。EXISTS运算符检查子查询是否至少返回一行数据，如果是，则EXISTS条件为真；NOT EXISTS则相反，检查子查询是否没有返回任何数据，如果是，则NOT EXISTS条件为真。假设我们有customers表和orders表，要查询有订单的客户，SQL 语句可以使用EXISTS：
SELECT customer_name
FROM customers c
WHERE EXISTS (
SELECT 1
FROM orders o
WHERE o.customer_id = c.customer_id
);
这条语句表示对于customers表中的每一个客户，检查orders表中是否存在与之关联的订单记录，如果存在，则该客户被包含在结果集中。NOT EXISTS则可以用于查询没有订单的客户：
SELECT customer_name
FROM customers c
WHERE NOT EXISTS (
SELECT 1
FROM orders o
WHERE o.customer_id = c.customer_id
);
EXISTS和NOT EXISTS在处理复杂的关联查询和条件筛选时非常有用，能够有效地判断数据之间的存在关系，常用于数据查询、数据校验等场景，帮助我们获取符合特定条件的数据子集。
- CASE WHEN：CASE WHEN语句用于条件判断和数据转换，类似于编程语言中的switch语句。它可以根据不同的条件返回不同的结果。语法有两种形式：
- 简单CASE WHEN：
CASE expression
WHEN value1 THEN result1
WHEN value2 THEN result2
...
ELSE result
END
- 搜索CASE WHEN：
CASE
WHEN condition1 THEN result1
WHEN condition2 THEN result2
...
ELSE result
END
假设在students表中有score列表示学生成绩，我们要根据成绩进行等级划分，90 分及以上为 “A”，80 - 89 分为 “B”，70 - 79 分为 “C”，60 - 69 分为 “D”，60 分以下为 “F”，使用搜索CASE WHEN的 SQL 语句如下：
SELECT student_name, score,
CASE
WHEN score >= 90 THEN 'A'
WHEN score >= 80 AND score < 90 THEN 'B'
WHEN score >= 70 AND score < 80 THEN 'C'
WHEN score >= 60 AND score < 70 THEN 'D'
ELSE 'F'
END AS grade
FROM students;
通过CASE WHEN语句，我们能够灵活地根据不同的条件对数据进行分类和转换，在数据分析、报表生成等场景中广泛应用，为数据的展示和分析提供了更多的灵活性和定制性。
三、数据库和表的基本操作
3.1 创建数据库
在 SQL 中，使用CREATE DATABASE语句来创建数据库，这是构建数据库应用的基础步骤之一。其基本语法如下：
CREATE DATABASE database_name;
其中，database_name是你要创建的数据库的名称，需遵循数据库的命名规则，通常由字母、数字和下划线组成，且不能以数字开头，同时应具有一定的描述性，以便清晰地标识数据库的用途。例如，要创建一个用于存储电商数据的数据库，可使用以下语句：
CREATE DATABASE e_commerce_db;
这样就创建了一个名为e_commerce_db的数据库。然而，在实际操作中，如果尝试创建一个已经存在的数据库，数据库管理系统会抛出错误，这可能会导致程序中断或出现不可预期的结果。为避免这种情况，可以使用IF NOT EXISTS选项 ，它的作用是在创建数据库之前先检查该数据库是否已经存在，如果不存在则创建，若已存在则不会执行创建操作，也不会抛出错误。语法如下：
CREATE DATABASE IF NOT EXISTS database_name;
比如，再次执行创建e_commerce_db数据库的操作时，使用IF NOT EXISTS选项：
CREATE DATABASE IF NOT EXISTS e_commerce_db;
无论e_commerce_db数据库之前是否已经存在，这条语句都能正常执行，不会产生错误，增强了数据库创建操作的稳定性和可靠性，尤其适用于可能会重复执行创建数据库语句的场景，如数据库初始化脚本中。
3.2 使用数据库
在创建数据库之后，若要对该数据库进行各种操作，如创建表、插入数据等，首先需要选择要操作的数据库。在 SQL 中，使用USE语句来指定当前要使用的数据库，语法非常简单：
USE database_name;
例如，要使用前面创建的e_commerce_db数据库，只需执行以下语句：
USE e_commerce_db;
执行这条语句后，后续的 SQL 操作，如创建表、查询数据等，都将在e_commerce_db数据库的上下文中进行。如果不先使用USE语句指定数据库，直接执行相关操作，数据库管理系统可能无法确定操作的目标数据库，从而导致错误。USE语句就像是打开了一个特定数据库的 “大门”，让我们能够在这个数据库中进行各种数据管理和操作，它是与特定数据库进行交互的关键步骤，确保了操作的准确性和针对性。
3.3 创建表
表是数据库中存储数据的基本结构，它由行和列组成，每列都有特定的数据类型和约束条件。在 SQL 中，使用CREATE TABLE语句来创建表，其语法相对复杂，涵盖了多个方面的定义。基本语法如下：
CREATE TABLE table_name (
column1 datatype constraint,
column2 datatype constraint,
...
[, PRIMARY KEY (column1 [, column2,...])]
[, FOREIGN KEY (column) REFERENCES another_table(column)]
);
在这个语法中：
- 列定义：
- column1、column2等是表中的列名，应具有明确的含义，以便清晰地表示该列所存储的数据内容。
- datatype是列的数据类型，常见的数据类型有：
- 数值类型：如INT（整数类型，用于存储整数数值，如员工编号、商品数量等）、DECIMAL(m, n)（定点数类型，m表示总位数，n表示小数位数，常用于存储需要精确表示的数值，如商品价格）。
- 字符串类型：VARCHAR(n)（可变长度字符串，n表示最大长度，适用于存储长度不固定的字符串，如员工姓名、商品描述等）、CHAR(n)（固定长度字符串，无论实际存储的字符串长度是多少，都会占用n个字符的存储空间，常用于存储长度固定的字符串，如邮政编码、身份证号码等）。
- 日期和时间类型：DATE（用于存储日期，格式为YYYY - MM - DD，如订单日期、员工入职日期等）、DATETIME（用于存储日期和时间，格式为YYYY - MM - DD HH:MM:SS，如商品上架时间、系统操作时间等）。
- constraint是列的约束条件，常见的约束有：
- 主键约束（PRIMARY KEY）：用于唯一标识表中的每一行数据，确保列中的值具有唯一性且不能为空。一个表只能有一个主键，可以由单个列组成，也可以由多个列组成复合主键。例如，在students表中，可以将student_id列定义为主键：
CREATE TABLE students (
student_id INT PRIMARY KEY,
student_name VARCHAR(50),
age INT
);
- 唯一约束（UNIQUE）：保证列中的值在表中是唯一的，但可以为空。例如，在employees表中，email列通常需要设置为唯一约束，以确保每个员工的邮箱地址是唯一的：
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
employee_name VARCHAR(50),
email VARCHAR(100) UNIQUE
);
- 非空约束（NOT NULL）：规定列的值不能为空。比如在products表中，product_name列不能为空，因为每个商品都应该有名称：
CREATE TABLE products (
product_id INT PRIMARY KEY,
product_name VARCHAR(50) NOT NULL,
price DECIMAL(10, 2)
);
- 主键定义：除了在列定义时直接指定主键，也可以在表定义的末尾使用PRIMARY KEY关键字来定义主键，当主键由多个列组成时，这种方式更为常用。例如，在orders表中，order_id和product_id共同组成复合主键，用于唯一标识每一笔订单中的商品记录：
CREATE TABLE orders (
order_id INT,
product_id INT,
quantity INT,
PRIMARY KEY (order_id, product_id)
);
- 外键关联：外键用于建立两个表之间的关联关系，确保数据的一致性和完整性。FOREIGN KEY关键字用于定义外键，REFERENCES关键字指定外键关联的主表和列。例如，有departments表（包含department_id、department_name等字段）和employees表，employees表中的department_id是外键，关联departments表中的department_id，表示员工所属的部门：
CREATE TABLE departments (
department_id INT PRIMARY KEY,
department_name VARCHAR(50)
);
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
employee_name VARCHAR(50),
department_id INT,
FOREIGN KEY (department_id) REFERENCES departments(department_id)
);
这样，在向employees表中插入数据时，department_id的值必须是departments表中已存在的department_id值，否则插入操作会失败，从而保证了数据的一致性。如果主表departments中删除了某个部门记录，从表employees中与之关联的员工记录如何处理，可以通过外键的级联操作来定义，如ON DELETE CASCADE表示主表记录删除时，从表相关记录也一并删除；ON DELETE SET NULL表示主表记录删除时，从表相关记录的外键字段设置为NULL。例如：
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
employee_name VARCHAR(50),
department_id INT,
FOREIGN KEY (department_id) REFERENCES departments(department_id)
ON DELETE SET NULL
);
四、基础增删改查操作
4.1 插入数据（增）
在 SQL 中，插入数据是向数据库表中添加新记录的操作，主要通过INSERT INTO语句来实现，它是数据库操作中最基本的功能之一，为数据库提供了新的数据来源。该语句有多种用法，以满足不同的插入需求。
- 插入单条记录：插入单条记录是最常见的插入操作，其基本语法为：
INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);
其中，table_name是要插入数据的表名；column1, column2, …是表中的列名，这些列名指定了要插入数据的位置；value1, value2, …是要插入的值，这些值与前面指定的列名一一对应，并且数据类型要匹配。例如，在employees表中插入一条员工记录，包含员工编号、姓名、年龄和工资信息：
INSERT INTO employees (employee_id, employee_name, age, salary)
VALUES (1001, 'John Doe', 30, 5000);
在这个例子中，employee_id为 1001，employee_name为John Doe，age为 30，salary为 5000，这些值被插入到employees表对应的列中。插入单条记录适用于在数据库中添加单个独立的数据项，比如在用户管理系统中添加一个新用户的信息。
- 插入多条记录：当需要一次性向表中插入多条记录时，可以使用以下语法：
INSERT INTO table_name (column1, column2, ...)
VALUES (value1a, value2a, ...), (value1b, value2b, ...), ...;
通过这种方式，可以在一个INSERT INTO语句中插入多条记录，每个VALUES子句对应一条记录，子句之间用逗号分隔。例如，要向students表中插入多名学生的信息：
INSERT INTO students (student_id, student_name, grade)
VALUES (2001, 'Alice', 'A'), (2002, 'Bob', 'B'), (2003, 'Charlie', 'A');
这样就一次性将三名学生的记录插入到了students表中。插入多条记录能够显著提高数据插入的效率，减少与数据库的交互次数，适用于批量添加数据的场景，如在电商系统中导入一批新商品的信息。
4.2 查询数据（查）
查询数据是 SQL 中最常用的操作之一，通过SELECT语句可以从数据库表中获取所需的数据，它提供了丰富的功能和灵活的语法，能够满足各种复杂的数据查询需求。
- 查询所有列：使用通配符*可以查询表中的所有列，语法非常简单：
SELECT *
FROM table_name;
例如，要查询employees表中的所有员工信息，包括员工编号、姓名、年龄、工资等所有列的数据，可以使用以下语句：
SELECT *
FROM employees;
这条语句会返回employees表中的每一行数据，并且包含表中的所有列，方便快速获取表的整体数据情况，但在实际应用中，如果只需要部分列的数据，使用*可能会导致查询效率降低，因为它会返回所有列的数据，包括一些可能不需要的列。
- 查询特定列：如果只需要查询表中的某些特定列，可以在SELECT关键字后面列出这些列的名称，列名之间用逗号分隔：
SELECT column1, column2, ...
FROM table_name;
例如，要查询employees表中员工的姓名和工资信息，SQL 语句如下：
SELECT employee_name, salary
FROM employees;
这样只会返回employees表中employee_name和salary这两列的数据，相比查询所有列，减少了数据的传输和处理量，提高了查询效率，适用于只关注部分列数据的场景，比如在生成员工工资报表时，只需要员工姓名和工资列。
- 带条件查询：通过WHERE子句可以对查询结果进行条件筛选，只返回满足特定条件的数据。WHERE子句中可以使用各种比较运算符（如=、<>、<、>、<=、>=）、逻辑运算符（如AND、OR、NOT）以及其他条件表达式 。语法如下：
SELECT columns
FROM table_name
WHERE condition;
例如，要查询employees表中工资大于 5000 的员工信息：
SELECT *
FROM employees
WHERE salary > 5000;
如果要查询工资在 5000 到 8000 之间的员工，可以使用BETWEEN关键字：
SELECT *
FROM employees
WHERE salary BETWEEN 5000 AND 8000;
还可以使用LIKE关键字进行模糊查询，比如查询姓名以 “J” 开头的员工：
SELECT *
FROM employees
WHERE employee_name LIKE 'J%';
带条件查询能够从大量数据中精准地筛选出符合要求的数据，在数据分析、业务处理等场景中广泛应用，帮助用户快速获取有价值的信息。
- 排序：使用ORDER BY子句可以对查询结果进行排序，默认是升序（ASC）排序，如果需要降序排序，可以使用DESC关键字。可以按照一个或多个列进行排序。语法如下：
SELECT columns
FROM table_name
ORDER BY column1 [ASC | DESC], column2 [ASC | DESC], ...;
例如，要按照工资降序查询employees表中的员工信息：
SELECT *
FROM employees
ORDER BY salary DESC;
如果要先按照部门进行升序排序，在同一部门内再按照工资降序排序，可以这样写：
SELECT *
FROM employees
ORDER BY department ASC, salary DESC;
排序功能使得查询结果更加有序，方便用户查看和分析数据，在报表生成、排行榜展示等场景中经常使用。
- 聚合查询：聚合函数用于对一组数据进行计算，并返回一个单一的值。常见的聚合函数有COUNT（统计数量）、SUM（求和）、AVG（求平均值）、MAX（求最大值）、MIN（求最小值）等。聚合查询通常与GROUP BY子句一起使用，GROUP BY子句用于将数据按照指定的列进行分组，然后对每个组应用聚合函数。语法如下：
SELECT column1, aggregate_function(column2)
FROM table_name
GROUP BY column1;
例如，要查询每个部门的员工数量：
SELECT department, COUNT(*) AS employee_count
FROM employees
GROUP BY department;
如果要查询每个部门的平均工资，并且只显示平均工资大于 6000 的部门，可以使用HAVING子句对分组后的结果进行筛选：
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 6000;
聚合查询在数据分析和统计中起着重要作用，能够帮助用户快速获取数据的总体特征和分组信息，为决策提供支持。
4.3 更新数据（改）
更新数据是对数据库表中已存在的数据进行修改的操作，通过UPDATE语句来实现。它可以更新单个或多个列的值，并且可以使用WHERE子句指定更新条件，以确保只对满足特定条件的数据进行更新，从而保证数据的准确性和一致性。
- 更新单个列的值：更新单个列的值的语法如下：
UPDATE table_name
SET column1 = new_value1
WHERE condition;
其中，table_name是要更新数据的表名；column1是要更新的列名；new_value1是该列的新值；WHERE子句是可选的，用于指定更新的条件，如果不指定WHERE子句，则会更新表中所有行的该列值。例如，在employees表中，将员工编号为 1001 的员工的工资增加 1000：
UPDATE employees
SET salary = salary + 1000
WHERE employee_id = 1001;
在这个例子中，WHERE子句确保只有employee_id为 1001 的员工的工资会被更新，其他员工不受影响。这种操作适用于对特定记录的单个属性进行修改的场景，比如在员工管理系统中，调整某个员工的薪资。
- 更新多个列的值：当需要同时更新多个列的值时，可以在SET子句中列出多个列及其新值，列之间用逗号分隔，语法如下：
UPDATE table_name
SET column1 = new_value1, column2 = new_value2, ...
WHERE condition;
例如，要将employees表中部门为 “HR” 的所有员工的年龄增加 1 岁，并且将工资提高 5%：
UPDATE employees
SET age = age + 1, salary = salary * 1.05
WHERE department = 'HR';
通过这种方式，可以一次性对多个列进行更新，提高数据更新的效率，适用于需要同时修改多个属性的场景，比如在用户信息管理中，同时更新用户的姓名、地址和联系方式等多个字段。
4.4 删除数据（删）
删除数据是从数据库表中移除不需要的数据记录的操作，使用DELETE FROM语句来完成。可以删除单条或多条记录，同样可以借助WHERE子句指定删除条件，以避免误删数据。
- 删除单条记录：删除单条记录时，通过WHERE子句指定唯一标识该记录的条件，语法如下：
DELETE FROM table_name
WHERE condition;
例如，在students表中删除学生编号为 2005 的学生记录：
DELETE FROM students
WHERE student_id = 2005;
这样就可以准确地删除指定的单条记录，在数据清理、用户注销等场景中经常使用，确保数据库中只保留有用的数据。
- 删除多条记录：当需要删除多条满足特定条件的记录时，同样使用WHERE子句来定义删除条件，语法与删除单条记录相同。例如，要删除orders表中订单日期在 2022 年 1 月 1 日之前的所有订单记录：
DELETE FROM orders
WHERE order_date < '2022-01-01';
通过这种方式，可以批量删除符合条件的多条记录，在数据维护、过期数据清理等场景中非常有用，能够有效减少数据库中的冗余数据，提高数据库的性能和存储空间利用率。如果不使用WHERE子句，DELETE FROM语句将删除表中的所有记录，这在实际操作中需要谨慎使用，以免造成数据丢失 。例如：
DELETE FROM table_name; -- 慎用，会删除表中所有记录
五、复杂关系操作
5.1 一对多关系操作
在数据库设计中，一对多关系是一种常见的数据关系模式，它表示一个表中的一条记录可以与另一个表中的多条记录相关联 。以电商系统中的订单和订单项为例，一个订单可以包含多个订单项，而每个订单项只能属于一个订单，这就是典型的一对多关系。
- 创建表：在 SQL 中，创建一对多关系的表时，通常在多的一方（订单项表）添加一个外键，用于引用一的一方（订单表）的主键，以此建立两个表之间的关联。假设我们要创建orders表（订单表）和order_items表（订单项表），SQL 语句如下：
-- 创建订单表
CREATE TABLE orders (
order_id INT PRIMARY KEY,
customer_name VARCHAR(255),
order_date DATE
);
-- 创建订单项表
CREATE TABLE order_items (
item_id INT PRIMARY KEY,
order_id INT,
product_name VARCHAR(255),
quantity INT,
FOREIGN KEY (order_id) REFERENCES orders(order_id)
);
在这个例子中，orders表的order_id作为主键，唯一标识每个订单。order_items表中的order_id是外键，它引用orders表中的order_id，通过这个外键建立了订单和订单项之间的一对多关系。这样的设计确保了数据的一致性和完整性，当插入订单项时，order_id必须是orders表中已存在的order_id值，否则插入操作会因为外键约束而失败。
- 插入数据：插入数据时，需要先插入一的一方（订单表）的数据，然后再插入多的一方（订单项表）的数据，并且在订单项表中指定正确的order_id值，以建立关联。例如：
-- 插入订单数据
INSERT INTO orders (order_id, customer_name, order_date)
VALUES (1, 'John Doe', '2023-04-01');
-- 插入订单项数据，关联到订单1
INSERT INTO order_items (item_id, order_id, product_name, quantity)
VALUES (101, 1, 'Product A', 2), (102, 1, 'Product B', 3);
这里先插入了一个订单记录，order_id为 1。然后插入了两个订单项记录，它们的order_id都为 1，表明这两个订单项属于订单 1。如果先插入订单项，而对应的订单在orders表中不存在，就会违反外键约束，导致插入失败。
- 查询数据：查询一对多关系的数据时，通常需要使用连接操作（JOIN）将两个表关联起来，以获取完整的订单和订单项信息。例如，要查询订单 1 的所有订单项，SQL 语句可以这样写：
SELECT o.order_id, o.customer_name, oi.item_id, oi.product_name, oi.quantity
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
WHERE o.order_id = 1;
这条语句通过JOIN操作将orders表和order_items表根据order_id进行关联，然后通过WHERE子句筛选出order_id为 1 的订单及其对应的订单项信息。通过连接操作，可以方便地从两个相关的表中获取所需的数据，在数据分析、报表生成等场景中，这种查询方式能够提供全面且有价值的信息。
5.2 多对多关系操作
多对多关系是数据库设计中更为复杂的一种关系模式，它表示两个表中的记录可以相互关联，即一个表中的一条记录可以与另一个表中的多条记录相关联，反之亦然。以教育系统中的学生和课程为例，一个学生可以选修多门课程，一门课程也可以被多个学生选修，这就是典型的多对多关系。在 SQL 中，处理多对多关系通常需要借助中间表来实现。
- 创建表：创建多对多关系的表时，需要创建一个中间表，该中间表至少包含两个外键，分别指向两个主表（学生表和课程表）的主键，通过这些外键来建立两个主表之间的关联。假设我们要创建students表（学生表）、courses表（课程表）和中间表student_courses，SQL 语句如下：
-- 创建学生表
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)
);
在这个例子中，students表的student_id和courses表的course_id分别作为各自表的主键。student_courses表作为中间表，它的主键由student_id和course_id共同组成，这是因为同一个学生可以选修多门课程，同一门课程也可以被多个学生选修，只有两个字段组合才能唯一标识中间表中的每一条记录。同时，student_courses表中的student_id和course_id分别作为外键，引用students表和courses表的主键，从而建立起学生和课程之间的多对多关系 。这种设计确保了数据的一致性和完整性，当插入中间表的数据时，student_id和course_id必须是各自主表中已存在的值，否则插入操作会因为外键约束而失败。
- 插入数据：插入数据时，首先要插入两个主表（学生表和课程表）的数据，然后再向中间表插入数据，以建立学生和课程之间的关联。例如：
-- 插入学生数据
INSERT INTO students (student_id, student_name)
VALUES (1, 'Alice'), (2, 'Bob');
-- 插入课程数据
INSERT INTO courses (course_id, course_name)
VALUES (101, 'Math'), (102, 'Science');
-- 插入中间表数据，建立关联
INSERT INTO student_courses (student_id, course_id)
VALUES (1, 101), (1, 102), (2, 101);
这里先插入了两个学生记录和两门课程记录，然后通过向student_courses表插入数据，建立了学生和课程之间的关联。其中，学生 1 选修了数学和科学课程，学生 2 选修了数学课程。如果在插入中间表数据时，student_id或course_id在对应的主表中不存在，插入操作将无法成功，这保证了数据的准确性和一致性。
- 查询数据：查询多对多关系的数据时，需要通过连接操作将三个表（两个主表和中间表）关联起来，以获取学生和课程之间的完整关联信息。例如，要查询学生 1 选修的所有课程，SQL 语句如下：
SELECT s.student_name, c.course_name
FROM students s
JOIN student_courses sc ON s.student_id = sc.student_id
JOIN courses c ON sc.course_id = c.course_id
WHERE s.student_id = 1;
这条语句通过两次JOIN操作，首先将students表和student_courses表根据student_id进行关联，然后将student_courses表和courses表根据course_id进行关联，最后通过WHERE子句筛选出student_id为 1 的学生及其选修的课程信息。通过这种方式，可以清晰地展示学生和课程之间复杂的多对多关系，在教育系统的选课管理、成绩统计等场景中，这种查询方式能够提供关键的数据支持。
六、SQL 优化技巧
6.1 索引的使用
索引在数据库中就如同书籍的目录，是一种特殊的数据结构，能够极大地提升数据查询的效率 。当数据库执行查询操作时，如果没有索引，它可能需要逐行扫描整个表来查找符合条件的数据，这在数据量较大时会耗费大量的时间和资源。而索引的存在可以让数据库快速定位到所需数据的位置，减少数据扫描的范围，从而显著提高查询速度。以电商数据库中包含大量商品信息的products表为例，假设表中有product_id、product_name、price、category等字段，如果经常需要根据product_name查询商品信息，在product_name字段上创建索引后，查询效率将大幅提升。例如执行查询语句SELECT * FROM products WHERE product_name = ‘智能手表’;，有索引时，数据库可以通过索引快速定位到product_name为 “智能手表” 的记录，而无需扫描整个products表。
在 SQL 中，创建索引的方法有多种。最常见的是使用CREATE INDEX语句，其基本语法为：
CREATE INDEX index_name ON table_name (column_name);
其中，index_name是你为索引指定的名称，应具有描述性，便于识别和管理；table_name是要创建索引的表名；column_name是要在其上创建索引的列名。例如，要在employees表的email列上创建索引，可以使用以下语句：
CREATE INDEX idx_employees_email ON employees (email);
除了普通索引，还可以创建唯一索引（CREATE UNIQUE INDEX），它确保索引列中的值是唯一的，常用于保证数据的唯一性，如用户表中的email或phone_number列；主键索引（CREATE PRIMARY KEY），它是一种特殊的唯一索引，用于唯一标识表中的每一行数据，一个表只能有一个主键索引；组合索引（CREATE INDEX index_name ON table_name (column1, column2, …)），它基于多个列创建索引，适用于经常使用多个列进行查询的场景。
在创建索引时，有一些注意事项需要牢记。首先，虽然索引能显著提升查询性能，但并非索引越多越好。过多的索引会增加数据库的存储开销，因为每个索引都需要占用一定的磁盘空间。同时，在进行数据插入、更新和删除操作时，数据库不仅要更新数据本身，还要更新相关的索引，这会导致这些操作的性能下降。例如，在一个频繁进行数据插入的orders表中，如果创建了过多不必要的索引，插入新订单记录时，数据库需要花费额外的时间来更新这些索引，从而降低插入操作的效率 。其次，要避免在选择性低的列上创建索引。选择性是指索引列中不同值的数量与总行数的比例，选择性越高，索引的效果越好。如果一个列的选择性很低，如性别列，只有 “男” 和 “女” 两个值，在这样的列上创建索引对查询性能的提升作用不大，反而会增加索引的维护成本。此外，对于经常用于WHERE、JOIN和ORDER BY子句的列，通常适合创建索引，但也要根据实际情况进行评估和测试，确保索引的创建真正能提高查询效率。
6.2 避免子查询
子查询是指在一个查询语句中嵌套另一个查询语句，它在实现复杂数据检索和处理任务时非常强大，但在性能方面存在一些潜在问题。当执行子查询时，数据库通常需要为内层查询语句的查询结果建立一个临时表，然后外层查询语句从临时表中查询记录，查询完毕后再撤销这些临时表。这个过程会消耗大量的 CPU 和 IO 资源，尤其是当子查询返回的结果集较大时，对查询性能的影响更为显著。例如，有一个查询要查找在过去 30 天内下过订单的所有客户，使用子查询的方式如下：
SELECT * FROM customers WHERE customer_id IN (SELECT customer_id FROM orders WHERE order_date >= DATEADD(day, -30, GETDATE()));
在这个例子中，内层子查询先从orders表中筛选出过去 30 天内有订单的客户customer_id，并将结果存储在临时表中，外层查询再从customers表中根据临时表中的customer_id获取客户信息。如果orders表数据量很大，创建和处理这个临时表会带来很高的性能开销。
为了提高查询效率，可以使用JOIN操作来替代子查询。连接查询不需要建立临时表，其速度通常比子查询要快，如果查询中使用索引的话，性能会更好。以上述查询为例，使用JOIN替代子查询的方式如下：
SELECT DISTINCT c.* FROM customers c JOIN orders o ON c.customer_id = o.customer_id WHERE o.order_date >= DATEADD(day, -30, GETDATE());
这条语句通过JOIN将customers表和orders表直接连接起来，然后根据订单日期条件筛选出符合要求的客户信息。相比子查询，这种方式减少了临时表的创建和处理，能够更高效地获取结果。在实际应用中，当需要从多个表中获取相关数据时，应优先考虑使用JOIN操作，仔细分析查询需求，选择合适的连接类型（如内连接、左连接、右连接等），以避免因使用子查询而导致的性能问题。
6.3 其他优化建议
在编写 SQL 语句时，还有许多其他优化技巧可以提高查询性能，以下是一些常见的建议：
- 减少通配符使用：在 SQL 查询中，通配符（如%和_）用于模糊匹配数据。然而，过度使用通配符会降低查询性能，因为当使用通配符时，数据库必须扫描整个表来查找相关数据。例如，使用LIKE '%keyword%'这样的查询，由于无法利用索引，数据库需要逐行检查表中的每一条记录，在数据量较大的情况下，查询速度会非常慢。为了优化查询，应尽量减少通配符的使用，仅在必要时使用，并且尽量将通配符放在查询条件的末尾，如LIKE ‘keyword%’，这样可以利用索引提高查询效率。如果可以通过其他方式实现相同的查询目的，如使用全文索引，应优先选择更高效的方法。
- 使用适当的数据类型：在数据库中，为列选择适当的数据类型对查询性能有着重要影响。对于包含数字值的列，使用整数数据类型（如INT、BIGINT等）通常比使用文本数据类型（如VARCHAR）查询速度更快，因为数字类型在比较和计算时更加高效。例如，在存储年龄信息时，使用INT类型而不是VARCHAR类型，可以减少数据处理的时间。同时，选择正确的数据类型还可以确保数据的完整性，避免数据转换错误。对于固定长度的字符串字段，应使用CHAR类型，它的存储空间是固定的，适用于存储长度固定的字符串，如邮政编码、身份证号码等；对于长度可变的字符串字段，使用VARCHAR类型，它的存储空间会根据实际数据的长度调整，不会浪费存储空间 。在选择数据类型时，还应考虑数据的取值范围和精度要求，避免使用过大或过小的数据类型，以充分利用数据库的存储空间和性能。
- 限制返回行数：如果只需要检索少量记录，使用LIMIT（在 MySQL 中）或TOP（在 SQL Server 中）子句来限制返回的行数，可以显著减少需要处理和返回的数据量，从而提高查询性能。例如，要查询orders表中最新的 10 个订单，可以使用以下语句：
-- MySQL
SELECT * FROM orders ORDER BY order_date DESC LIMIT 10;
-- SQL Server
SELECT TOP 10 * FROM orders ORDER BY order_date DESC;
这样可以避免查询返回大量不必要的数据，减少网络传输和数据处理的开销，尤其在处理大数据集时，效果更为明显。在实际应用中，根据业务需求合理设置返回行数的限制，能够提高系统的响应速度和资源利用率。
- 避免 SELECT *：在编写查询语句时，应尽量避免使用SELECT *，因为它会返回表中的所有列，包括可能不需要的列。这不仅会增加数据传输和处理的开销，还可能导致查询性能下降。例如，在employees表中，如果只需要查询员工的姓名和工资信息，使用SELECT *会返回所有列的数据，而实际上可能只需要employee_name和salary这两列。正确的做法是明确指定需要查询的列，如SELECT employee_name, salary FROM employees;，这样可以减少数据的传输量，提高查询效率。在实际应用中，根据具体的业务需求，仔细选择需要查询的列，避免不必要的数据获取，从而优化查询性能。
七、SQL 高级用法
7.1 窗口函数
窗口函数，也被称为分析函数，是 SQL 中功能强大且灵活的工具，它能够在不改变查询结果集行数的情况下，对每一行执行聚合计算或者其他复杂的计算 。与普通聚合函数不同，窗口函数不会将多行数据合并为一行，而是为每一行返回一个计算结果，同时保留原始数据的行结构，这使得我们能够在同一结果集中同时展示原始数据和基于这些数据的计算结果，为数据分析和处理提供了极大的便利。
窗口函数的基本语法结构如下：
<窗口函数> OVER ([PARTITION BY <分区列>] [ORDER BY <排序列>] [ROWS 或 RANGE <窗口框架定义>])
- 窗口函数表达式：可以是各种聚合函数（如SUM、AVG、COUNT、MAX、MIN），也可以是一些专用的窗口函数（如ROW_NUMBER、RANK、DENSE_RANK、LEAD、LAG等）。例如，SUM(salary)表示对salary列进行求和计算。
- PARTITION BY 子句：用于将数据分成不同的分区，窗口函数将在每个分区内独立执行计算。这类似于GROUP BY子句的分组功能，但GROUP BY会将分组后的数据合并为一行，而PARTITION BY只是划分计算的范围，不会改变结果集的行数。例如，PARTITION BY department表示按department列进行分区，这样窗口函数会针对每个部门的数据分别进行计算。
- ORDER BY 子句：定义了数据在每个分区内的排序方式，它决定了窗口函数的计算顺序。例如，ORDER BY salary DESC表示按salary列降序排序，窗口函数在计算时会按照这个顺序依次处理每一行数据。
- ROWS 或 RANGE 窗口框架定义：用于指定窗口的范围，即窗口函数计算时所涉及的行范围。可以是固定的行数（ROWS），也可以是基于值的范围（RANGE）。如果省略此部分，默认是从分区的起始行到当前行。例如，ROWS BETWEEN 1 PRECEDING AND CURRENT ROW表示窗口范围包括当前行及其前一行。
窗口函数在实际应用中有着广泛的场景，以下是一些常见的例子：
- 排名：在employees表中，要根据salary对每个部门的员工进行排名，可以使用RANK函数：
SELECT employee_id, department_id, salary,
RANK() OVER (PARTITION BY department_id ORDER BY salary DESC) AS salary_rank
FROM employees;
在这个查询中，PARTITION BY department_id按部门进行分区，ORDER BY salary DESC按工资降序排列，RANK()函数为每个部门内的员工根据工资进行排名。如果有多个员工工资相同，他们的排名会相同，并且下一个排名会跳过相应的数量。例如，如果有两个员工并列第 2 名，下一个员工的排名将是第 4 名。
- 计算累计值：假设有一个sales表，包含sale_date（销售日期）和sales_amount（销售金额）字段，要计算每天的累计销售金额，可以使用SUM窗口函数：
SELECT sale_date, sales_amount,
SUM(sales_amount) OVER (ORDER BY sale_date) AS running_total
FROM sales;
这里没有使用PARTITION BY子句，表示对整个结果集进行计算。ORDER BY sale_date按销售日期排序，SUM(sales_amount) OVER (…)计算从第一条记录到当前记录的销售金额累计值，随着日期的递增，累计值不断更新。
7.2 公共表达式（CTEs）
公共表表达式（Common Table Expressions，简称 CTEs）是一种在 SQL 查询中定义临时结果集的方法，它可以使复杂的查询更加易读和易于维护 。CTE 就像是一个临时的命名结果集，只在包含它的查询的执行期间有效，它可以被看作是一个 “虚拟表”，这个 “虚拟表” 基于一个查询语句生成，并且可以在后续的查询中像普通表一样被引用。
CTE 的基本语法结构如下：
WITH cte_name AS (
查询语句
)
SELECT * FROM cte_name;
- WITH 关键字：用于引入 CTE 的定义。
- cte_name：为 CTE 指定的名称，在后续的查询中通过这个名称来引用该 CTE。
- 查询语句：用于生成 CTE 的查询，可以是任何有效的 SQL 查询，包括简单的选择查询、连接查询、子查询等。
例如，有一个employees表，包含employee_id、employee_name、department_id和salary字段，要计算每个部门的平均工资，并找出工资高于部门平均工资的员工，可以使用 CTE 来实现：
WITH department_avg_salary AS (
SELECT department_id, AVG(salary) AS avg_salary
FROM employees
GROUP BY department_id
)
SELECT e.employee_id, e.employee_name, e.salary, das.avg_salary
FROM employees e
JOIN department_avg_salary das ON e.department_id = das.department_id
WHERE e.salary > das.avg_salary;
在这个例子中，首先定义了一个名为department_avg_salary的 CTE，它通过查询计算出每个部门的平均工资。然后在主查询中，将employees表与department_avg_salary CTE 进行连接，筛选出工资高于部门平均工资的员工记录。
CTE 在递归查询中也有着重要的应用，特别是在处理树形结构数据时，如组织架构、目录结构等。例如，有一个employees表，包含employee_id、manager_id和employee_name字段，manager_id表示员工的上级经理的employee_id，要查询整个组织架构的层级关系，可以使用递归 CTE：
WITH RECURSIVE EmployeeCTE AS (
-- 初始查询，找到顶层经理（manager_id为NULL）
SELECT employee_id, manager_id, employee_name, 1 AS level
FROM employees
WHERE manager_id IS NULL
UNION ALL
-- 递归查询，将每个员工与其上级经理关联起来
SELECT e.employee_id, e.manager_id, e.employee_name, ecte.level + 1
FROM employees e
INNER JOIN EmployeeCTE ecte ON e.manager_id = ecte.employee_id
)
SELECT employee_id, employee_name, level
FROM EmployeeCTE
ORDER BY level, employee_id;
在这个递归 CTE 中，首先通过初始查询找到顶层经理，然后通过UNION ALL将每个员工与其上级经理关联起来，不断递归，直到所有员工都被包含在结果集中。最终查询结果展示了每个员工的层级关系，level字段表示员工在组织架构中的层级。
7.3 聚合函数的高级应用
聚合函数是 SQL 中用于对一组值进行计算并返回单个结果值的函数，如SUM（求和）、AVG（求平均值）、MIN（求最小值）、MAX（求最大值）和COUNT（计数）等。它们在数据分析和统计中起着关键作用，而将聚合函数与窗口函数、GROUP BY子句结合使用，可以实现更高级的数据处理和分析功能。
当聚合函数与窗口函数结合时，能够在不改变原始数据行结构的情况下，对数据进行灵活的聚合计算。例如，有一个sales表，包含sale_id、product_id、sale_date、sale_amount和region字段，要计算每个地区每种产品的累计销售金额，并按销售日期排序，可以使用如下查询：
SELECT sale_id, product_id, sale_date, sale_amount, region,
SUM(sale_amount) OVER (PARTITION BY region, product_id ORDER BY sale_date) AS running_total
FROM sales;
在这个查询中，SUM(sale_amount)是聚合函数，OVER (PARTITION BY region, product_id ORDER BY sale_date)是窗口函数的定义。PARTITION BY region, product_id按地区和产品进行分区，ORDER BY sale_date按销售日期排序，这样SUM(sale_amount)会在每个分区内，按照销售日期的顺序计算累计销售金额，为每一行返回从分区起始行到当前行的销售金额总和。
聚合函数与GROUP BY子句的结合是实现数据分组统计的基础。例如，要计算每个地区的销售总额、平均销售金额以及产品数量，可以使用以下查询：
SELECT region,
SUM(sale_amount) AS total_sales,
AVG(sale_amount) AS avg_sales,
COUNT(product_id) AS product_count
FROM sales
GROUP BY region;
在这个例子中，GROUP BY region按地区对数据进行分组，然后对每个分组应用聚合函数，SUM(sale_amount)计算每个地区的销售总额，AVG(sale_amount)计算平均销售金额，COUNT(product_id)计算产品数量。
在实际应用中，还经常需要查找每个分组的 Top N 记录。例如，要找出每个地区销售金额排名前三的产品，可以结合窗口函数和GROUP BY子句来实现：
WITH RankedSales AS (
SELECT product_id, region, sale_amount,
RANK() OVER (PARTITION BY region ORDER BY sale_amount DESC) AS sale_rank
FROM sales
)
SELECT product_id, region, sale_amount
FROM RankedSales
WHERE sale_rank <= 3;
在这个查询中，首先通过 CTERankedSales使用RANK窗口函数对每个地区的产品按销售金额进行排名，PARTITION BY region按地区分区，ORDER BY sale_amount DESC按销售金额降序排列。然后在主查询中，从RankedSales中筛选出排名小于等于 3 的记录，即每个地区销售金额排名前三的产品。
八、总结
通过本文，我们全面深入地学习了 SQL 语句，从基础的数据库和表的创建，到复杂的多表关联查询、高级的窗口函数和公共表达式，以及重要的优化技巧。我们了解了 SQL 在数据管理和软件开发领域的核心地位，掌握了数据的增删改查基本操作，学会了处理各种数据关系，如一对多、多对多关系 。同时，我们还学习了如何使用索引、避免子查询等优化方法来提升 SQL 查询性能，以及窗口函数、CTEs 等高级特性在复杂数据分析中的应用。
SQL 是一门不断发展和演进的语言，随着数据量的增长和业务需求的日益复杂，持续学习和实践 SQL 是提升数据处理能力的关键。希望读者在今后的学习和工作中，不断练习和应用所学的 SQL 知识，勇于探索新的功能和技术，将 SQL 灵活运用到实际项目中，通过实践不断积累经验，提升自己的 SQL 技能水平，从而更好地应对各种数据管理和分析的挑战，为业务发展提供有力的数据支持。