SQL语句

一、SQL 是什么？

SQL（Structured Query Language）结构化查询语言，用于与关系型数据库交互（如 MySQL、PostgreSQL、Oracle、SQL Server 等）。

主要功能包括：

• 查询数据（SELECT）
• 插入数据（INSERT）
• 更新数据（UPDATE）
• 删除数据（DELETE）
• 建表、建库（CREATE）
• 权限与索引管理

二、SQL 基础语法结构

1
2
3
4
5
6
7

SELECT [字段名或表达式]
FROM [表名]
WHERE [条件]
GROUP BY [分组字段]
HAVING [分组后的过滤条件]
ORDER BY [排序字段]
LIMIT [数量限制];

三、表连接（JOIN）

JOIN 是 SQL 的核心，用来从多个表中获取相关数据。

假设我们有两张表：

表：users

表：orders

1. 内连接（INNER JOIN）

内连接（INNER JOIN）—— 取匹配的记录，只有两张表 匹配的记录 才会显示。

graph LR
    subgraph users["users 表"]
    U1["Alice (id=1)"]
    U2["Bob (id=2)"]
    U3["Charlie (id=3)"]
    U4["Diana (id=4)"]
    end

    subgraph orders["orders 表"]
    O1["order#1 (user_id=1, 100)"]
    O2["order#2 (user_id=1, 200)"]
    O3["order#3 (user_id=2, 300)"]
    O4["order#4 (user_id=3, 50)"]
    O5["order#5 (user_id=3, 70)"]
    end

    %% 匹配关系
    U1 --- O1
    U1 --- O2
    U2 --- O3
    U3 --- O4
    U3 --- O5

对应 SQL

1
2
3

SELECT users.name, orders.amount
FROM users
INNER JOIN orders ON users.id = orders.user_id;

查询结果

2. 左连接（LEFT JOIN）

左连接（LEFT JOIN）—— 保留左表全部，左表（users）全部保留；右表（orders）如果没有匹配，则显示 NULL。

graph LR
    subgraph users["users 表（左表）"]
    U1["Alice (id=1)"]
    U2["Bob (id=2)"]
    U3["Charlie (id=3)"]
    U4["Diana (id=4)"]
    end

    subgraph orders["orders 表（右表）"]
    O1["order#1 (user_id=1, 100)"]
    O2["order#2 (user_id=1, 200)"]
    O3["order#3 (user_id=2, 300)"]
    O4["order#4 (user_id=3, 50)"]
    O5["order#5 (user_id=3, 70)"]
    end

    %% 匹配关系
    U1 --- O1
    U1 --- O2
    U2 --- O3
    U3 --- O4
    U3 --- O5
    U4 -.-> NULL["(无匹配，右表为 NULL)"]

对应 SQL

1
2
3

SELECT users.name, orders.amount
FROM users
LEFT JOIN orders ON users.id = orders.user_id;

查询结果

3. 右连接（RIGHT JOIN）

右连接（RIGHT JOIN）—— 保留右表全部，与 LEFT JOIN 相反，保留右表全部记录。

graph LR
    subgraph users["users 表（左表）"]
    U1["Alice (id=1)"]
    U2["Bob (id=2)"]
    U3["Charlie (id=3)"]
    U4["Diana (id=4)"]
    end

    subgraph orders["orders 表（右表）"]
    O1["order#1 (user_id=1, 100)"]
    O2["order#2 (user_id=1, 200)"]
    O3["order#3 (user_id=2, 300)"]
    O4["order#4 (user_id=3, 50)"]
    O5["order#5 (user_id=3, 70)"]
    end

    %% 匹配关系
    U1 --- O1
    U1 --- O2
    U2 --- O3
    U3 --- O4
    U3 --- O5
    %% Diana 没订单，不参与连接

对应 SQL

1
2
3

SELECT users.name, orders.amount
FROM users
RIGHT JOIN orders ON users.id = orders.user_id;

查询结果

4. 全连接（FULL JOIN）

全连接（FULL JOIN）—— 两边都保留（MySQL 不支持，可用 UNION 模拟）

graph LR
    subgraph users["users 表（左表）"]
    U1["Alice (id=1)"]
    U2["Bob (id=2)"]
    U3["Charlie (id=3)"]
    U4["Diana (id=4)"]
    end

    subgraph orders["orders 表（右表）"]
    O1["order#1 (user_id=1, 100)"]
    O2["order#2 (user_id=1, 200)"]
    O3["order#3 (user_id=2, 300)"]
    O4["order#4 (user_id=3, 50)"]
    O5["order#5 (user_id=3, 70)"]
    end

    %% 匹配关系
    U1 --- O1
    U1 --- O2
    U2 --- O3
    U3 --- O4
    U3 --- O5
    U4 -.-> NULL右["(无匹配，右表为 NULL)"]

对应 SQL（MySQL 模拟实现）

1
2
3
4
5
6
7

SELECT users.name, orders.amount
FROM users
LEFT JOIN orders ON users.id = orders.user_id
UNION
SELECT users.name, orders.amount
FROM users
RIGHT JOIN orders ON users.id = orders.user_id;

查询结果

5. 交叉连接（CROSS JOIN）

交叉连接（CROSS JOIN）—— 笛卡尔积（两表全组合），CROSS JOIN 不需要任何连接条件，它会把左表的每一行与右表的每一行 两两组合，一般不常用，会生成所有组合（性能差）。

graph LR
    subgraph users["users 表（左表）"]
    U1["Alice (id=1)"]
    U2["Bob (id=2)"]
    U3["Charlie (id=3)"]
    U4["Diana (id=4)"]
    end

    subgraph orders["orders 表（右表）"]
    O1["order#1 (100)"]
    O2["order#2 (200)"]
    O3["order#3 (300)"]
    O4["order#4 (50)"]
    O5["order#5 (70)"]
    end

    %% 每个用户都和所有订单组合（笛卡尔积）
    U1 --- O1
    U1 --- O2
    U1 --- O3
    U1 --- O4
    U1 --- O5

    U2 --- O1
    U2 --- O2
    U2 --- O3
    U2 --- O4
    U2 --- O5

    U3 --- O1
    U3 --- O2
    U3 --- O3
    U3 --- O4
    U3 --- O5

    U4 --- O1
    U4 --- O2
    U4 --- O3
    U4 --- O4
    U4 --- O5

对应 SQL

1
2
3

SELECT users.name, orders.amount
FROM users
CROSS JOIN orders;

查询结果（部分示例）

四、分组与聚合

1. GROUP BY + 聚合函数

聚合函数用来对数据集计算汇总结果：

示例：每个用户的订单总额是多少？

1
2
3
4

SELECT users.name, SUM(orders.amount) AS total_amount
FROM users
JOIN orders ON users.id = orders.user_id
GROUP BY users.name;

执行逻辑图

graph TD
    A["users 表"] --> B["JOIN orders ON users.id = orders.user_id"]
    B --> C["分组 GROUP BY users.name"]
    C --> D["聚合 SUM(orders.amount)"]
    D --> E["输出 name, total_amount"]

思路拆解

1. JOIN：先把 users 与 orders 关联；
2. GROUP BY：按 users.name 分组；
3. SUM：对每个分组的 amount 求和；
4. SELECT：只输出每个用户的名字和总金额。

查询结果

Diana 没有订单，因此没有出现在结果中（因为 INNER JOIN）。

2. 使用 HAVING 过滤聚合结果

示例：只显示订单总额大于 1000 的用户（这时必须用 HAVING，因为 WHERE 不能过滤聚合结果）。

1
2
3
4
5

SELECT users.name, SUM(orders.amount) AS total_amount
FROM users
JOIN orders ON users.id = orders.user_id
GROUP BY users.name
HAVING SUM(orders.amount) > 1000;

HAVING 执行逻辑图

graph TD
    A["JOIN users + orders"] --> B["GROUP BY users.name"]
    B --> C["计算 SUM(orders.amount)"]
    C --> D["HAVING SUM(orders.amount) > 1000"]
    D --> E["输出结果"]

查询结果

3. WHERE 与 HAVING 的区别

4. GROUP BY 与 HAVING 区别

五、常见子查询与嵌套查询

1. 子查询

子查询：指一个查询语句嵌套在另一个查询语句内部。 它通常出现在：

• WHERE 子句中
• FROM 子句中
• SELECT 子句中

子查询返回的结果，可以是一条记录、一个值、一个表，或一个布尔判断。

示例：查询下过大额订单的用户

1
2
3
4
5
6
7

SELECT name
FROM users
WHERE id IN (
    SELECT user_id
    FROM orders
    WHERE amount > 500
);

2. 子查询的常见形式

子查询的常见形式（5种）

3. 常见关键字与区别

IN、EXISTS、ANY、ALL

1. IN 示例

查询有下单记录的用户：

1
2
3

SELECT name
FROM users
WHERE id IN (SELECT user_id FROM orders);

查询结果：

（因为 Diana 没订单）

2. EXISTS 示例

与上面功能相同，但用 EXISTS：

1
2
3
4
5
6
7

SELECT name
FROM users u
WHERE EXISTS (
    SELECT 1
    FROM orders o
    WHERE o.user_id = u.id
);

结果相同，但执行逻辑不同：

这段 SQL 想干嘛？查询所有有下过订单的用户。

也就是说：

• 从 users 表取出每个用户；
• 判断：这个用户的 id 是否出现在 orders.user_id 中；
• 如果是 → 返回该用户；
• 如果不是 → 不返回。

EXISTS 是一个逻辑判断（布尔测试）， 它不看子查询返回的值，而只关心：

子查询是否返回至少一行数据？

• 如果子查询返回了 ≥1 行 → EXISTS 结果为 TRUE
• 如果子查询返回 0 行 → EXISTS 结果为 FALSE

为什么是 SELECT 1？

因为 EXISTS 只关心“有没有行”，根本不看列内容。 所以写成 SELECT 1、SELECT *、SELECT o.id 都可以，效果完全一样。

只不过：

• SELECT 1 是最简洁、最推荐的写法（标准写法）
• SELECT * 虽然也行，但数据库会多做点解析工作（不推荐）

逻辑执行过程

查询结果：

与 IN 的对比

可视化理解

graph TD
    U["users 表 u"] -->|逐行| Q["子查询 SELECT 1 FROM orders o WHERE o.user_id = u.id"]
    Q -->|存在匹配记录？| E{"EXISTS 结果？"}
    E -->|TRUE| R["返回该用户"]
    E -->|FALSE| X["跳过"]

3. > ANY

查询至少有一笔订单金额大于 Alice 的任意一笔订单金额（即大于最小订单）的用户：

1
2
3
4
5
6
7

SELECT name
FROM users
WHERE id IN (
    SELECT user_id
    FROM orders
    WHERE amount > ANY (SELECT amount FROM orders WHERE user_id = 1)
);

ANY 类似于 “至少比其中一个值大”，ANY (100, 200)。

4. > ALL

查询金额大于 所有 Alice 的订单金额 的用户：

1
2
3
4
5
6
7

SELECT name
FROM users
WHERE id IN (
    SELECT user_id
    FROM orders
    WHERE amount > ALL (SELECT amount FROM orders WHERE user_id = 1)
);

ALL 类似于 “比所有值都大”。

4. 相关子查询

1. 相关子查询

子查询依赖外层表的字段，每次外层表扫描一行，都会重新执行子查询。

例：查询每个用户大于自己平均订单金额的订单。

1
2
3
4
5
6
7

SELECT o.*
FROM orders o
WHERE o.amount > (
    SELECT AVG(o2.amount)
    FROM orders o2
    WHERE o2.user_id = o.user_id
);

• 外层表：orders o
• 内层子查询：SELECT AVG(o2.amount) FROM orders o2 WHERE o2.user_id = o.user_id

内层子查询依赖 外层表 o 的 user_id，这就是“相关子查询”的核心。

逐行执行逻辑

我们先看原始数据：

外层循环每行

外层表 orders o 每一行都会检查 amount 是否大于该用户的平均订单金额。

内层子查询计算每行的平均值

输出结果

只有大于自己平均订单金额的订单会被选出来。

2. 普通子查询 vs 相关子查询的执行顺序

普通子查询（不依赖外层表）

• 执行顺序：

  1. 先执行子查询，计算 AVG(amount) → 得到单一值
  2. 外层查询使用这个值去筛选每行数据

  执行顺序：子查询 → 外层查询

相关子查询（依赖外层表字段）

• 执行顺序：

  1. 外层表逐行扫描
  2. 对当前外层行，执行子查询 → 计算当前用户的 AVG
  3. 用子查询结果判断当前行是否满足条件
  4. 扫描下一行，重复步骤 2-3

  执行顺序：外层查询行扫描 → 对每行执行子查询

5. 总结对比表

六、SQL 执行顺序

这条执行路径是 SQL 的“灵魂线”，理解执行顺序可以让你写更复杂的查询：

1

FROM → JOIN → WHERE → GROUP BY → SUM/COUNT/AVG... → HAVING → SELECT → ORDER BY → LIMIT

七、总结

程序员职业的基础技能，必知必会。