MySQL常用函数详解：从字符串处理到窗口函数的实战指南

很多人把 MySQL 装好之后，第一道坎根本不是建表，而是写 SELECT 时被各种各样的 MySQL 函数搞晕。字符串要截取、日期要格式化、数字要四舍五入、空值要处理、排名要分组，每一件事都对应一批函数，而且名字还长得特别像。网上搜"MySQL 函数"，出来的资料要么是官方文档那种干巴巴的语法清单，要么是碎片化的速查表，真正能让人看完会用的很少。所以我打算按实际干活时的思路，把最常用、最容易踩坑的这批函数完整梳理一遍，顺带把新手问得最多的几个问题——SUBSTRING 和 SUBSTR 有什么区别、ROUND 为什么不是我以为的结果、DATE_FORMAT 里 %Y 和 %y 是不是一个意思、有没有函数叫 sub_str——一次性说清楚。这篇文章适合刚学 MySQL 的人、准备数据库面试的开发，以及平时写统计报表被数据折磨的运营和数据分析同学。

1. 函数正式写进SQL之前，先拨正三组概念

网上搜"select函数"其实搜不到任何东西，因为 SELECT 是 SQL 的查询语句，不是函数。这个误区看起来很低级，但每天都有人在搜索引擎里敲，说明很多初学者把"SQL 里的关键字"和"函数"混在一起了。抛开这一点，我更想强调另外三组概念，它们决定了你后面能不能顺畅理解和使用函数。

1.1 函数、关键字和操作符，三者不是一回事

SQL 里有三样东西经常被混着叫，但性质完全不同：

• 关键字/语句：SELECT、FROM、WHERE、GROUP BY、ORDER BY，这些是 SQL 的骨架，不是一个值，也没有返回值。
• 操作符：+、-、*、/、=、>、LIKE，这些是运算符号，通常操作两个值。
• 函数：CONCAT、IF、DATE_FORMAT、ROUND，它们接收输入参数，经过内部逻辑处理后返回一个值。

判断一个东西是不是函数，最简单的办法是看它能不能单独出现在 SELECT 后面。SELECT SUBSTRING('abc',1,2) 能出来结果，所以 SUBSTRING 是函数。SELECT WHERE 会直接语法报错，所以 WHERE 只是语句的一部分。很多所谓"函数记不住"的问题，其实是根本没意识到自己只是需要某个操作符或者语句组合。

1.2 内置函数、自定义函数和存储过程别混用

MySQL 内置函数是数据库自带的，直接写名字就能用。自定义函数（CREATE FUNCTION）是你在库里创建的一个可复用的逻辑块，语法和内置函数类似，但写起来要定义返回类型、函数体，通常还用 BEGIN...END 包裹。存储过程（CREATE PROCEDURE）则更进一步，它可以包含多条 SQL、事务、游标、循环，有入参和出参，但调用时用的是 CALL 而不是写在 SELECT 里。

我见过不少人把存储过程和函数混为一谈，实际工作中我们的建议很简单：单行数据处理优先用内置函数，需要大量循环和事务逻辑才考虑存储过程，自定义函数能不用就不用——它一旦被查询引用，往往会让 MySQL 优化器难以预估成本，排查问题时多一层复杂度。

1.3 函数能出现在 SQL 的哪些位置

函数不是只能放在 SELECT 后面。这是很多基础教程讲得不透的地方。一个函数可以出现在：

• SELECT 后面：SELECT UPPER(name) FROM users，用来计算输出值。
• WHERE 后面：SELECT * FROM users WHERE CHAR_LENGTH(phone) = 11，用来过滤行。
• GROUP BY 后面：SELECT DATE(create_time), COUNT(*) FROM orders GROUP BY DATE(create_time)，用来按函数处理后的结果分组。
• HAVING 后面：SELECT user_id, SUM(amount) FROM orders GROUP BY user_id HAVING SUM(amount) > 1000，作用类似于 WHERE，但作用于分组后。
• ORDER BY 后面：SELECT * FROM products ORDER BY LENGTH(name) DESC，按函数计算结果排序。

同一个函数放在不同位置，性能含义完全不同。尤其 WHERE 里包函数，极容易让索引失效，后面第 8 节我会专门讲。这里大家先建立位置意识，写 SQL 时脑子里过一遍：这个函数我放在哪，它对索引有没有影响。

2. 字符串函数：解析、拼接与截断的日常操作

字符串处理占了我日常 SQL 编写量的一半以上。分类、去空格、提取子串、拼接字段、替换关键词，样样都绕不开字符串函数。

2.1 SUBSTRING、SUBSTR 和 sub_str 的纠葛

先澄清一个搜索热词：sub_str 函数。MySQL 里根本没有 sub_str 这个函数，正确答案是 SUBSTRING，它有一个同义词 SUBSTR。很多人搜不到，是因为下意识按"下划线缩写"的方式去猜函数名，但 MySQL 函数名不是这样缩写出来的。

SUBSTRING 的三种写法：

mysql复制SELECT SUBSTRING('hello world', 5);        -- 从第5个字符开始截到末尾，结果是 'o world'
SELECT SUBSTRING('hello world', 1, 3);     -- 从第1个字符开始截3位，结果是 'hel'
SELECT SUBSTRING('hello world', -5, 3);    -- 从倒数第5位开始截3位，结果是 'wor'

这里的起始位置从 1 开始，不是像编程语言那样从 0 开始。支持负数表示从尾部倒数。这个函数虽然叫 SUBSTRING，但它按字符截取，不按字节截取，所以处理多语言内容时比很多编程语言的 substring 更友好。

2.2 LOCATE、LEFT、RIGHT、SUBSTRING_INDEX 的组合用法

实际工作中很少直接傻写一个固定长度的 SUBSTRING，因为真实数据的长短不固定。更常见的思路是先定位、再截取。

LOCATE(substr, str) 返回 substr 在 str 中第一次出现的位置。比如 LOCATE('@', 'zhangsan@qq.com') 返回 9。INSTR 和 POSITION 也能做类似的事，但参数顺序不同：

mysql复制SELECT LOCATE('@', 'zhangsan@qq.com');   -- 9
SELECT INSTR('zhangsan@qq.com', '@');    -- 9
SELECT POSITION('@' IN 'zhangsan@qq.com') ; -- 9

LEFT 和 RIGHT 分别是取字符串左边和右边固定长度的子串。LEFT('2024-11-15', 4) 结果是 2024，RIGHT('13812345678', 4) 结果是 5678。这个在取编号、截手机号尾号时很好用。

SUBSTRING_INDEX 是个被低估的强函数。它按分隔符截取，语法是 SUBSTRING_INDEX(str, delimiter, count)，count 为正数时从左往右数到第 count 个分隔符返回左边全部内容，count 为负数时从右往左数到第 count 个分隔符返回右边全部内容：

mysql复制SELECT SUBSTRING_INDEX('a,b,c,d', ',', 2);    -- 'a,b'
SELECT SUBSTRING_INDEX('a,b,c,d', ',', -2);   -- 'c,d'
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('a,b,c,d', ',', 3), ',', -1);  -- 'c'

最后一个写法能从逗号分隔串里精确取出第 3 段，在清洗 CSV 格式数据时非常常用。注意 SUBSTRING_INDEX 不会处理分隔符不存在的情况，如果找不到分隔符，它返回整个字符串。

2.3 LENGTH 与 CHAR_LENGTH：中文字符串的第一个大坑

我见过一个真实的线上问题：业务方要求限制用户昵称不超过 20 个字符，代码里用 LENGTH(字段) 去判断，结果中文昵称明明肉眼只有 5 个字，却提示超长，用户疯狂投诉。

原因在于 MySQL 的 LENGTH 返回的是字节数，CHAR_LENGTH 返回的是字符数。在 utf8mb4 编码下，一个中文字符占 3 到 4 个字节，一个英文字符占 1 个字节。所以：

mysql复制SELECT LENGTH('你好abc');       -- 9
SELECT CHAR_LENGTH('你好abc');  -- 5

需要按用户感知的"几个字"来算时，必须用 CHAR_LENGTH。LENGTH 只在你真的关心存储占用和字节数时才用。这个坑在字符串函数里排第一，因为它不会报错，只会在数据量大了之后以各种诡异的形式暴露出来。

2.4 CONCAT、REPLACE、TRIM 这些高频拼接清洗函数

拼接字符串常用 CONCAT，但很多人不知道 CONCAT 的 NULL 传染问题：

mysql复制SELECT CONCAT('a', NULL, 'c');  -- NULL

如果某个字段是 NULL，CONCAT 整体返回 NULL。这个时候用 CONCAT_WS 更稳妥，它用第一个参数作为分隔符，并且会自动跳过 NULL：

mysql复制SELECT CONCAT_WS('-', '2024', '11', '15');   -- 2024-11-15
SELECT CONCAT_WS('-', '2024', NULL, '15');   -- 2024-15

REPLACE 用于替换字符串中的子串，可以做简单的脱敏，比如把手机号中间四位打码：

mysql复制SELECT CONCAT(LEFT('13812345678', 3), '****', RIGHT('13812345678', 4));
-- 138****5678

TRIM 系列函数用于去空格。LTRIM 去左边空格，RTRIM 去右边空格，TRIM 默认去两侧空格。它进阶用法是去掉指定字符：

mysql复制SELECT TRIM(BOTH 'x' FROM 'xxxhelloxxx');  -- 'hello'

这个写法在做脏数据清洗时很实用，比如用户导入的 Excel 中文全角空格、换行符混杂，可以配合 REPLACE('\n', '') 一起处理，而不是干调去空格。

字符串函数这一节如果只能记一个技巧，我会记 CONCAT_WS 和 SUBSTRING_INDEX 的组合，因为这两个函数能处理很大一部分"字段拼接后解析"的需求，比在代码里拆串爽快得多。

3. 数值计算与类型转换：从int+5说起

热词里有"mysql中int+5"，不少人是真的想知道在 MySQL 里怎么给一个整型字段加 5。但这个小问题背后牵扯出的类型概念，比操作本身重要得多。

3.1 INT(5) 不代表只能存 5 位，显示宽度和存储范围是两码事

很多新手在建表时看到 INT(5) 会误以为这个字段最多存 5 位数，超过 99999 就报错。其实 INT(5) 里的 5 叫显示宽度，它只影响 ZEROFILL 时前导零的显示，完全不影响存储范围。MySQL 中 INT 类型的存储范围是 -2147483648 到 2147483647，固定占 4 个字节，无论你写 INT、INT(5) 还是 INT(11)，范围都一样。

所以给 INT 字段加 5 的写法本身没有技术含量：

mysql复制SELECT price + 5 FROM products WHERE id = 1;
UPDATE products SET price = price + 5 WHERE id = 1;

真正要注意的是溢出。如果 price 已经接近 2147483647，再加 5 会溢出报错。设计表结构时如果金额、计数可能超过这个范围，提前用 BIGINT。金额字段更建议直接 DECIMAL(10,2) 而不是 INT，避免出现"分转元"的隐式转换。

3.2 ROUND、CEIL、FLOOR、TRUNCATE 的精度差异

ROUND 是四舍五入，CEIL 是向上取整，FLOOR 是向下取整，TRUNCATE 是直接截断，这四个函数各司其职：

mysql复制SELECT ROUND(3.45, 1);    -- 3.5
SELECT ROUND(3.44, 1);    -- 3.4
SELECT CEIL(3.01);        -- 4
SELECT FLOOR(3.99);       -- 3
SELECT TRUNCATE(3.456, 2); -- 3.45

有个细节很多人不知道：ROUND 在浮点数场景下可能产生让你意外的结果。SELECT ROUND(2.675, 2) 的结果不是 2.68，而是 2.67，因为 2.675 在二进制浮点里实际是 2.67499999...。如果对精度要求高，不要用 FLOAT/DOUBLE，改用 DECIMAL：

mysql复制SELECT ROUND(CAST(2.675 AS DECIMAL(10,3)), 2);  -- 2.68

金额类字段从一开始就用 DECIMAL，能避免一大类金融计算的脏数据。MOD 函数用于取余，等价于 % 操作符，在处理分页、奇偶判断、周期校验时很常用：

mysql复制SELECT MOD(17, 5);   -- 2
SELECT 17 % 5;       -- 2

3.3 显式 CAST 与隐式转换，能救索引也能毁查询

MySQL 允许字符串和数字之间进行隐式转换，比如 SELECT '123' + 1 会返回 124。但这种"方便"在 WHERE 条件里就是灾难。看这条查询：

mysql复制SELECT * FROM orders WHERE order_no = 123456;

如果 order_no 是 VARCHAR 类型，MySQL 会把 order_no 的所有值先转成数字再去比较，导致 order_no 列上的索引失效，全表扫描。反之如果列是 INT、查询条件是字符串，也会触发隐式转换。规则是：当字符串列和数字比较时，字符串会被转换为数字。

显式转换用 CAST 或 CONVERT：

mysql复制SELECT CAST('123' AS UNSIGNED);       -- 123
SELECT CAST(123 AS CHAR);             -- '123'
SELECT CAST('12.34' AS DECIMAL(10,2)); -- 12.34

判断一个查询有没有隐式转换隐患，看 EXPLAIN 里的 type 列，如果从 ref/range 变成了 ALL，大概率就是类型没对齐。这个经验比死记转换函数更有用。

数值函数这块说复杂也复杂，说简单也简单，核心就三点：选对类型、显式转换、别让精度问题在后期暴雷。

4. 日期时间函数：写日报周报月报前先统一口径

日期函数是报表查询的重灾区。同一个"今天"，有人用 CURDATE()，有人用 NOW()，有人用 SYSDATE()，统计出来的结果在边界时刻可能不一样。

4.1 NOW、CURDATE、CURTIME、SYSDATE 的差异

NOW() 返回当前的日期和时间，格式是 'YYYY-MM-DD HH:MM:SS'。CURDATE() 只返回日期部分，CURTIME() 只返回时间部分。

NOW 和 SYSDATE 的区别是面试常考点：NOW() 在一个查询语句开始执行时取得时间，整个查询期间保持不变；SYSDATE() 在函数执行的那一刻取时间。如果一条慢查询执行了 30 秒，NOW 在开头取值，SYSDATE 则可能随着执行到不同行而变化。绝大多数场景下我们应该用 NOW()，因为统计口径稳定。

mysql复制SELECT NOW();        -- 2024-11-15 14:30:00
SELECT CURDATE();    -- 2024-11-15
SELECT CURTIME();    -- 14:30:00

4.2 DATE_FORMAT 的格式化符号要记哪些

DATE_FORMAT 把日期时间格式化成指定字符串，是最常用的日期函数。需要重点记住的格式符：

mysql复制SELECT DATE_FORMAT(NOW(), '%Y-%m-%d');       -- 2024-11-15
SELECT DATE_FORMAT(NOW(), '%Y%m%d');         -- 20241115
SELECT DATE_FORMAT(NOW(), '%H:%i:%s');       -- 14:30:00

%m 和 %c 的区别是前者总是两位，后者不带前导零；%H 和 %h 的区别是 24 小时制和 12 小时制。搞混这两个，报表里凌晨的数据会乱。逆转换用 STR_TO_DATE，把符合格式的字符串转回日期：

mysql复制SELECT STR_TO_DATE('2024-11-15 14:30:00', '%Y-%m-%d %H:%i:%s');

4.3 日期加减与两个日期差怎么算

DATE_ADD 和 DATE_SUB 用于日期加减，单位可以是 DAY、MONTH、YEAR、HOUR、MINUTE、SECOND：

mysql复制SELECT DATE_ADD('2024-11-15', INTERVAL 1 DAY);    -- 2024-11-16
SELECT DATE_SUB('2024-11-15', INTERVAL 1 MONTH);  -- 2024-10-15

也可以用等价的表达式写法：'2024-11-15' + INTERVAL 1 DAY。你要算两个日期之间相差几周、几个月，用 DATEDIFF 只能得到天数，想按月份来就要 TIMESTAMPDIFF：

mysql复制SELECT DATEDIFF('2024-12-01', '2024-11-15');      -- 16
SELECT TIMESTAMPDIFF(MONTH, '2024-01-15', '2024-11-15');  -- 10
SELECT TIMESTAMPDIFF(HOUR, '2024-11-15 08:00:00', '2024-11-15 14:30:00');  -- 6

TIMESTAMPDIFF 的最后一个单位参数写在第一个，和直觉的顺序相反，使用频率高的话很容易记错，建议每次用的时候都核对一下。

4.4 查询"今天的数据"的正确姿势与索引命中

这是日期间题里最典型的性能坑。很多新人写：

mysql复制SELECT * FROM orders WHERE DATE(create_time) = CURDATE();

这条 SQL 逻辑完全正确，但 create_time 列上如果建了索引，这个查询用不上——因为 DATE(create_time) 把 create_time 的每个值都先做了一次函数运算，MySQL 没法直接走索引。正确写法是把它改成范围查询：

mysql复制SELECT * FROM orders
WHERE create_time >= CURDATE()
  AND create_time < DATE_ADD(CURDATE(), INTERVAL 1 DAY);

这样 create_time 列自身参与比较，索引可以正常命中。同理，按月份查 YEAR(create_time) = 2024 也应当改成 create_time >= '2024-01-01' AND create_time < '2025-01-01'。这个习惯一旦养成，报表查询的性能能提升一个量级。

5. 条件与流程控制：让SQL在数据里做选择

SQL 是声明式语言，但如果数据需要按条件分支，函数也能帮你实现"逻辑判断"。最常见的三个工具是 IF、CASE WHEN 和一组空值处理函数。

5.1 IF 函数和小项目里最简单条件逻辑

IF(expr, true_value, false_value) 是 MySQL 里最简单的条件函数：

mysql复制SELECT IF(score >= 60, '及格', '不及格') AS result FROM exams;

它的本质是：当 expr 为真时返回第二个参数，否则返回第三个参数。注意 MySQL 的判断标准是 0 为假、非 0 为真，NULL 也为假。所以 SELECT IF(NULL, 'a', 'b') 的结果是 b。

IF 适合条件少的场景，但嵌套多了可读性会急剧变差。IF(IF(...)) 这种写法让人头大，遇到三个以上分支时应该换 CASE WHEN。

5.2 CASE WHEN 比多条 IF 更顺手

CASE WHEN 是 SQL 里的 switch-case，有两种写法。简单 CASE 适用于等值判断：

mysql复制SELECT CASE status
    WHEN 1 THEN '待支付'
    WHEN 2 THEN '已支付'
    WHEN 3 THEN '已发货'
    ELSE '未知'
END AS status_text
FROM orders;

搜索 CASE 适用于范围判断：

mysql复制SELECT
    user_id,
    CASE
        WHEN amount >= 1000 THEN '高消费'
        WHEN amount >= 100 THEN '中消费'
        ELSE '低消费'
    END AS level
FROM user_orders;

CASE WHEN 还可以和聚合函数组合，实现"条件计数"和"条件求和"。比如统计已支付和未支付订单数，不用写两条 SQL：

mysql复制SELECT
    SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) AS paid_count,
    SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) AS unpaid_count
FROM orders;

这种写法在报表里极其常见，值得重点掌握。

5.3 IFNULL、COALESCE、NULLIF 处理空值三板斧

NULL 是 SQL 里最容易出问题的值，它既不是 0 也不是空字符串，和它做任何运算结果都是 NULL：'a' + NULL 结果是 NULL，SUM(amount) 遇到全部 NULL 时返回 NULL 而不是 0。

IFNULL(expr1, expr2) 把 NULL 替换成默认值：

mysql复制SELECT IFNULL(commission, 0) FROM sales;

COALESCE(expr1, expr2, expr3, ...) 返回参数列表中第一个非 NULL 值，可以传多个参数。比如一个用户可能有手机号、邮箱、微信三种联系方式，取第一个不为空的：

mysql复制SELECT COALESCE(phone, email, wechat, '无联系方式') FROM users;

NULLIF(expr1, expr2) 是反向操作，两个值相等时返回 NULL，否则返回第一个值。最经典的应用是防止除零错误：

mysql复制SELECT total_amount / NULLIF(total_count, 0) AS avg_price FROM orders;

如果 total_count 是 0，NULLIF 把它变成 NULL，除法结果变成 NULL，而不是报"division by zero"错误。报表层再配合 IFNULL 把 NULL 显示成 0 或空。

空值和条件函数永远绑定出现，写任何 SQL 之前都应该先问一遍：这里有没有可能出现 NULL？出现后我要显示什么？

6. 聚合函数与分组统计：COUNT 的细节藏得最深

聚合函数是在 GROUP BY 的基础上工作的，它们把多行数据压缩成一行。日常最常用的是 COUNT、SUM、AVG、MAX、MIN，以及一个能拼接分组内容的 GROUP_CONCAT。

6.1 COUNT(*)、COUNT(1)、COUNT(字段) 到底有什么不一样

面试问得最多的问题，也是日常报表写错概率最高的点：

• COUNT(*) 统计行数，包括所有行，不管某列是不是 NULL。
• COUNT(1) 和 COUNT(*) 效果几乎一样，但语义上是用常量 1 去填充，实际也是统计行数。
• COUNT(字段) 只统计该字段非 NULL 的行数。如果某行这个字段是 NULL，这行不会被计入。

mysql复制SELECT COUNT(*) FROM users;            -- 所有用户数
SELECT COUNT(phone) FROM users;        -- 填了手机号的用户数

InnoDB 引擎下 COUNT(*) 和 COUNT(1) 的性能差异可以忽略，但 COUNT(字段) 是语义问题，不是性能问题。业务上要区分"总人数"和"填写了手机号的人数"，必须用不同的 COUNT。

6.2 SUM、AVG、MAX、MIN 在聚合场景的共性规律

SUM 求和时自动忽略 NULL。如果某一组所有行都是 NULL，SUM 返回 NULL，此时需要 IFNULL(SUM(x), 0) 来兜底。

AVG 同样忽略 NULL。注意 AVG(score) 不等于 SUM(score)/COUNT(*)，因为 NULL 行的存在会让分母不一样。比如 3 行数据，成绩分别是 80、90、NULL，AVG 返回 85（只除以 2），而 SUM/COUNT 是 170/3 约等于 56.67，两者天差地别。使用时要明确业务口径。

MAX 和 MIN 不仅对数字有用，对字符串和日期同样适用：MAX(create_time) 取最新时间，MIN(price) 取最低价，MAX(name) 按字符集排序取最大。

6.3 GROUP_CONCAT：把多个值拼到一行

GROUP_CONCAT 能把分组内的多个值拼成一个字符串，用逗号分隔：

mysql复制SELECT dept_id, GROUP_CONCAT(emp_name ORDER BY emp_id SEPARATOR '、')
FROM employees
GROUP BY dept_id;

它支持 ORDER BY 和 SEPARATOR，可以控制拼接顺序和分隔符。默认长度限制是 1024 字节，超长会被截断。如果拼接长文本，需要调大 group_concat_max_len 参数。这个函数在生成"一个用户的所有标签""一个分类下的所有子类名"时很好用。

6.4 分组统计配合 HAVING 和 ORDER BY 排序

WHERE 和 HAVING 的区分是新手最容易踩的坑。WHERE 在分组前过滤行，HAVING 在分组后过滤组。想筛选出"订单数超过 10 的客户"，只能写 HAVING：

mysql复制SELECT user_id, COUNT(*) AS order_cnt, SUM(amount) AS total_amount
FROM orders
WHERE create_time >= '2024-01-01'
GROUP BY user_id
HAVING order_cnt > 10
ORDER BY total_amount DESC;

注意这里 WHERE 先按时间过滤原始行，再分组，分组后再用 HAVING 过滤组，最后 ORDER BY 排序。执行顺序是 WHERE → GROUP BY → HAVING → ORDER BY。搞清这个顺序，写复杂报表时思路会清晰很多。

另外一个常见的 MySQL 5.7 之后的坑是 ONLY_FULL_GROUP_BY 模式。默认开启时，SELECT 的列如果不在聚合函数里，就必须出现在 GROUP BY 中，否则报错。上面例子里的 user_id 要出现在 GROUP BY 里，就是因为它在 SELECT 中不是聚合列。习惯这个约束后，写 SQL 的规范性会好很多。

7. 窗口函数：MySQL 8.0 之后写排名和累计不再绕弯子

如果你的 MySQL 还是 5.7，很多排名和累计需求要靠临时变量实现，又难写又难读。MySQL 8.0 引入了窗口函数，把分组内排名、累计求和、移动平均这类问题从"需要子查询"简化成了"一个 OVER 子句"。

7.1 ROW_NUMBER、RANK、DENSE_RANK 三兄弟怎么区分

三个函数都用于编号，区别在于对并列数据的处理方式：

• ROW_NUMBER() 不管是否并列，给每一行分配一个连续且唯一的序号：1、2、3、4。
• RANK() 遇到并列时占用后续序号并跳号：1、1、3、4。
• DENSE_RANK() 遇到并列时不跳号：1、1、2、3。

mysql复制SELECT
    emp_name,
    salary,
    ROW_NUMBER() OVER (ORDER BY salary DESC) AS row_num,
    RANK() OVER (ORDER BY salary DESC) AS rank_num,
    DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank_num
FROM employees;

如果业务报表上需要"并列第一名之后下一名从第几开始"，用 RANK；如果只是记录优秀等级序列，用 DENSE_RANK；如果只想要一个物理行号，用 ROW_NUMBER。

7.2 分组内取前 N 名，面试和报表里的常客

窗口函数最典型的场景是"每个部门工资最高的前 3 名"。写法是先在子查询里生成行号，再在外面过滤：

mysql复制SELECT dept_id, emp_name, salary
FROM (
    SELECT
        dept_id,
        emp_name,
        salary,
        ROW_NUMBER() OVER (PARTITION BY dept_id ORDER BY salary DESC) AS rn
    FROM employees
) t
WHERE rn <= 3;

PARTITION BY 负责分组，ORDER BY 负责组内排序，ROW_NUMBER 生成组内序号。这个模式可以举一反三地用在"每个分类销量前 10 的商品""每个用户金额最大的前 5 笔订单"。面试题里十有八九会出现这种 TopN 问题，背下这个模板基本能应付。

7.3 SUM() OVER() 做累计求和，LAG/LEAD 算同环比

窗口函数不只有排名。SUM() OVER() 可以做累计求和。比如按月份累加的销售额：

mysql复制SELECT
    month,
    sales_amount,
    SUM(sales_amount) OVER (ORDER BY month) AS running_total
FROM monthly_sales;

LAG 和 LEAD 可以取当前行之前或之后某一行值，用来计算同比环比：

mysql复制SELECT
    month,
    sales_amount,
    LAG(sales_amount, 1) OVER (ORDER BY month) AS prev_month_sales,
    ROUND((sales_amount - LAG(sales_amount, 1) OVER (ORDER BY month))
        / LAG(sales_amount, 1) OVER (ORDER BY month) * 100, 2) AS mom_growth_rate
FROM monthly_sales;

窗口函数是在 WHERE、GROUP BY 执行完之后才计算的，所以不能在 WHERE 里直接用 row_number() = 1。如果想按排名过滤，必须像上面 TopN 一样包一层子查询。这个执行顺序一定要记牢，不然写出来会直接语法报错，报错还看不懂。

8. 排查函数导致的问题，我一般按这个顺序检查

函数本身不难，难的是查询性能突然变差、结果出现诡异的值时，怎么快速定位是不是函数引起的。以下是我实际排查问题时固定的检查顺序。

8.1 WHERE 里包函数，索引有没有被白白浪费

第一件事，把 EXPLAIN 拉出来看 type 列。如果该走索引的查询变成了 ALL，大概率 WHERE 里的列被函数包了。最常见的三种写法：

• WHERE DATE(create_time) = CURDATE()
• WHERE YEAR(create_time) = 2024
• WHERE SUBSTRING(phone, 1, 3) = '138'

正确的做法是让列保持原样，把函数作用在条件那一侧：

mysql复制WHERE create_time >= '2024-01-01' AND create_time < '2025-01-01'
WHERE phone LIKE '138%'

EXPLAIN 里的 key_len 和 rows 也能辅助判断。养成写复杂查询前先看 EXPLAIN 的习惯，能提前拦下一大半性能问题。

8.2 隐式转换让 varchar 和 int 打架

第二件事，检查 WHERE 等号两侧类型是否一致。字符串列和数字比较、UNION 两边类型不同、JOIN 关联列类型不同，都会触发隐式转换。排查方法很粗暴：打开 EXPLAIN，如果索引失效，再看列类型和查询参数类型是否匹配。

比较两个字段时尤其要注意：

mysql复制SELECT * FROM a JOIN b ON a.user_id = b.user_id;

假设 a.user_id 是 VARCHAR，b.user_id 是 BIGINT，JOIN 时可能把字符串转成数字，索引失效且结果可能不正确。表结构设计阶段就要把关联字段的类型对齐，这是最省事的解法。

8.3 NULL 传染：一个 NULL 让整条结果变 NULL

第三件事，检查运算和拼接里有没有 NULL。SELECT price * discount FROM products，当某行 discount 为 NULL 时结果就是 NULL，不是 0。排查时数一下：concat 拼接是否返回了 NULL，sum 是否返回 NULL 而不是 0，case when 是否走了 else 分支但没有 default。解决方式很简单：业务上允许为 NULL 的字段，在进入运算之前先用 IFNULL 或 COALESCE 给定默认值。

8.4 函数排查的自查清单

我整理了一份自检表，实际报错排查时直接照着过：

这张表我贴在办公桌前贴了很久，每次排查都从里面找方向，效率比瞎翻文档高很多。其实函数写出问题不可怕，可怕的是没有一套检查思路，反复在原地打转。

最后再分享一个实际工作中的习惯。我在写稍微复杂一点的统计 SQL 时，会先把需求拆成三个问题：要过滤哪些行、要按什么分组、要计算什么指标。然后才动手选函数。比如"统计每个月新增的付费用户中，高消费用户占比"，我先过滤付费用户，再按月分组，再用 CASE WHEN 和 COUNT 组合算分子分母。这个时候你会发现，函数只是工具，真正重要的是 SQL 的执行顺序和业务口径。把顺序理解透了、把格式统一了，绝大多数 MySQL 函数的使用问题都能自己解决。