SQL 查询执行顺序与常见错误

写 SQL 时，语句的书写顺序和数据库的逻辑处理顺序并不完全一致。理解查询的逻辑执行顺序，可以帮助定位很多常见错误，例如字段找不到、分组报错、聚合结果异常、LEFT JOIN 结果少于预期等。

SELECT 的书写顺序#

一条常见查询语句通常写成：

1
SELECT column1,
2
       COUNT(*) AS total
3
FROM table_a a
4
JOIN table_b b
5
  ON a.id = b.a_id
6
WHERE a.status = 'ACTIVE'
7
GROUP BY column1
8
HAVING COUNT(*) > 1
9
ORDER BY total DESC;

书写顺序是：

1
SELECT
2
FROM
3
JOIN / ON
4
WHERE
5
GROUP BY
6
HAVING
7
ORDER BY

但这不是数据库理解查询时的逻辑顺序。

SELECT 的逻辑执行顺序#

更接近数据库处理过程的顺序是：

1
1. FROM
2
2. JOIN / ON
3
3. WHERE
4
4. GROUP BY
5
5. HAVING
6
6. SELECT
7
7. ORDER BY

可以理解为：

1
先确定数据来自哪些表
2
再确定表之间如何连接
3
再过滤原始行
4
然后分组
5
再过滤分组后的结果
6
最后选择要显示的字段并排序

这也是为什么有些字段别名不能在 WHERE 中直接使用，因为 WHERE 发生在 SELECT 之前。

例如：

1
SELECT salary * 12 AS annual_salary
2
FROM lecturer
3
WHERE annual_salary > 100000;

这类写法在很多数据库中会报错，因为 WHERE 执行时，annual_salary 这个别名还没有生成。

更稳妥的写法是：

1
SELECT salary * 12 AS annual_salary
2
FROM lecturer
3
WHERE salary * 12 > 100000;

WHERE 与 HAVING 的区别#

WHERE 用来过滤原始行，发生在分组之前。

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
WHERE duration > 1
5
GROUP BY subjectcode;

这表示：先过滤出 duration > 1 的 lab，再按课程分组统计。

HAVING 用来过滤分组后的结果，发生在 GROUP BY 之后。

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
GROUP BY subjectcode
5
HAVING COUNT(*) > 2;

这表示：先按课程分组统计，再只保留 lab 数量大于 2 的课程。

对比：

子句	过滤对象	是否能直接使用聚合函数
`WHERE`	分组前的原始行	通常不能
`HAVING`	分组后的结果	可以

错误示例：

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
WHERE COUNT(*) > 2
5
GROUP BY subjectcode;

问题在于 WHERE 阶段还没有完成分组，也就没有 COUNT(*) 的结果。

正确写法：

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
GROUP BY subjectcode
5
HAVING COUNT(*) > 2;

ON 与 WHERE 的区别#

ON 用来描述表和表之间如何匹配。

1
SELECT s.studentno,
2
       s.fname,
3
       se.subjectcode
4
FROM student s
5
JOIN student_enrolment se
6
  ON s.studentno = se.studentno;

WHERE 用来在连接结果中继续过滤数据。

1
SELECT s.studentno,
2
       s.fname,
3
       se.subjectcode
4
FROM student s
5
JOIN student_enrolment se
6
  ON s.studentno = se.studentno
7
WHERE se.subjectcode = 'CSE21DB';

在 INNER JOIN 中，把条件放在 ON 或 WHERE 中，很多时候结果相同。

但在 LEFT JOIN 中，ON 和 WHERE 的位置会明显影响结果。

LEFT JOIN 中 WHERE 的陷阱#

假设要列出所有讲师，以及他们的授课安排：

1
SELECT l.staffno,
2
       l.fname,
3
       le.subjectcode
4
FROM lecturer l
5
LEFT JOIN lecture le
6
  ON l.staffno = le.staffno;

LEFT JOIN 的含义是：保留左表 lecturer 的全部记录，即使右表 lecture 没有匹配，也显示出来，只是右表字段为 NULL。

如果后面加上：

1
WHERE le.subjectcode = 'CSE21DB'

完整语句变成：

1
SELECT l.staffno,
2
       l.fname,
3
       le.subjectcode
4
FROM lecturer l
5
LEFT JOIN lecture le
6
  ON l.staffno = le.staffno
7
WHERE le.subjectcode = 'CSE21DB';

这会把 le.subjectcode 为 NULL 的行过滤掉。结果上，LEFT JOIN 很容易表现得像 INNER JOIN。

如果想保留没有授课记录的讲师，就不能简单地把右表过滤条件放到 WHERE 中，而应根据查询目的调整条件位置。

例如只匹配某门课，但仍保留所有讲师：

1
SELECT l.staffno,
2
       l.fname,
3
       le.subjectcode
4
FROM lecturer l
5
LEFT JOIN lecture le
6
  ON l.staffno = le.staffno
7
 AND le.subjectcode = 'CSE21DB';

这里条件写在 ON 中，表示连接时只匹配 CSE21DB，但左表 lecturer 仍然保留。

GROUP BY 常见规则#

使用 GROUP BY 时，SELECT 中出现的字段通常分为两类：

1
分组字段
2
聚合结果

例如：

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
GROUP BY subjectcode;

subjectcode 是分组字段，COUNT(*) 是聚合结果。

如果写成：

1
SELECT subjectcode,
2
       labno,
3
       COUNT(*) AS total
4
FROM lab
5
GROUP BY subjectcode;

这里 labno 既不是聚合函数，也不在 GROUP BY 中，很多数据库会报错。

正确做法之一是把 labno 也加入分组：

1
SELECT subjectcode,
2
       labno,
3
       COUNT(*) AS total
4
FROM lab
5
GROUP BY subjectcode,
6
         labno;

但这会改变统计粒度：从“按课程统计”变成“按课程 + lab 编号统计”。

因此写 GROUP BY 前要先判断统计粒度：

1
我要按什么维度统计？
2
一行结果代表什么？
3
哪些字段只是展示，哪些字段用于聚合？

COUNT(*)、COUNT(column)、COUNT(DISTINCT column)#

这三个写法很常见，但含义不同。

写法	含义
`COUNT(*)`	统计行数，包括字段为 `NULL` 的行
`COUNT(column)`	统计该字段非 `NULL` 的行数
`COUNT(DISTINCT column)`	统计该字段去重后的非 `NULL` 数量

示例：

1
SELECT COUNT(*) AS all_rows,
2
       COUNT(email) AS rows_with_email,
3
       COUNT(DISTINCT city) AS different_cities
4
FROM student;

如果某些学生的 email 是 NULL，那么 COUNT(email) 会少于 COUNT(*)。

这一点在统计报名人数、邮箱数量、实际填写字段数量时很重要。

NULL 的常见影响#

NULL 表示未知或缺失，不等同于空字符串，也不等同于 0。

错误写法：

1
SELECT *
2
FROM student
3
WHERE email = NULL;

正确写法：

1
SELECT *
2
FROM student
3
WHERE email IS NULL;

判断非空：

1
SELECT *
2
FROM student
3
WHERE email IS NOT NULL;

聚合时也要注意 NULL：

1
SELECT AVG(feepaid)
2
FROM student;

AVG(column) 会忽略 NULL 值，而不是把 NULL 当成 0。

ORDER BY 与别名#

ORDER BY 通常可以使用 SELECT 中定义的别名，因为它在逻辑顺序上发生在 SELECT 之后。

1
SELECT subjectcode,
2
       COUNT(*) AS total
3
FROM lab
4
GROUP BY subjectcode
5
ORDER BY total DESC;

这里 total 是 COUNT(*) 的别名，可以用于排序。

也可以直接写聚合表达式：

1
ORDER BY COUNT(*) DESC;

多表查询的排错顺序#

复杂 SQL 出错时，不要一上来就看完整语句。可以按步骤拆开：

1
1. 先查主表，确认基础数据存在
2
2. 加第一张 JOIN 表，确认连接条件正确
3
3. 再加第二张 JOIN 表
4
4. 加 WHERE 条件
5
5. 加 GROUP BY
6
6. 加 HAVING
7
7. 最后加 ORDER BY

例如先查：

1
SELECT *
2
FROM lecturer;

再加连接：

1
SELECT *
2
FROM lecturer l
3
LEFT JOIN lecture le
4
  ON l.staffno = le.staffno;

再逐步减少字段、增加过滤条件和分组。

这种方式比直接改一整条复杂 SQL 更容易定位问题。

常见错误总结#

问题	常见原因
字段不存在	表别名写错、字段来自另一张表、字段名拼写错误
分组报错	`SELECT` 中有非聚合字段没有写进 `GROUP BY`
查询结果比预期少	`WHERE` 条件过滤过多，或 `LEFT JOIN` 被写成类似 `INNER JOIN`
统计数量异常	混淆 `COUNT(*)` 和 `COUNT(column)`
查不到空值	使用了 `= NULL`，应改为 `IS NULL`
排序不符合预期	字段类型、空值、别名或排序方向不符合预期

总结#

SQL 查询不是简单从上到下执行。理解逻辑顺序后，很多错误会变得更容易解释：

1
FROM / JOIN 先确定数据来源
2
WHERE 过滤原始行
3
GROUP BY 形成分组
4
HAVING 过滤分组结果
5
SELECT 决定显示内容
6
ORDER BY 最后排序

写复杂查询时，先确认“数据从哪来”，再确认“怎么过滤”，最后再处理“怎么统计和展示”。这比直接拼完整 SQL 更稳定。

音乐

音乐