MySQL ORDER BY 性能优化：从多列排序到单列 sort_key

一、背景

在实际业务中，我们经常遇到复杂的排序需求，比如：

• 先按某个条件分组排序
• 在每个分组内再按不同字段排序
• 最后所有数据按统一规则排序

这种多层级排序如果直接用多个 CASE WHEN 实现，会导致：

1. SQL 冗长难维护
2. 排序时重复计算表达式
3. 分页时性能较差

本文通过一个实际案例，介绍如何将复杂的多列 ORDER BY 优化为单列 sort_key。

---

二、问题案例

业务场景（简化）

有一个订单明细表，需要按以下优先级排序：

第一层：任务未完成的排在前面
  └─ 第二层：在"未完成"组内，按 category、type、code 排序
第三层：任务已完成的中，状态异常的排在前面
  └─ 第四层：所有数据最终都按 category、type、code 排序

原始 SQL（简化版）

SELECT 
    d.id,
    d.category,
    d.type,
    d.code,
    COUNT(t.id) AS total_tasks,
    SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) AS completed_tasks,
    d.target_qty,
    SUM(CASE WHEN t.status = 'done' THEN t.qty ELSE 0 END) AS completed_qty
FROM detail d
LEFT JOIN task t ON t.detail_id = d.id
GROUP BY d.id, d.category, d.type, d.code, d.target_qty
ORDER BY
    -- 第一层：任务未完成的排前面（0=未完成，1=已完成）
    CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) >= COUNT(t.id) 
         THEN 1 ELSE 0 END ASC,
    
    -- 第二层：未完成时按业务规则排序
    CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) < COUNT(t.id) 
         THEN d.category END ASC,
    CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) < COUNT(t.id) 
         THEN d.type END ASC,
    CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) < COUNT(t.id) 
         THEN d.code END ASC,
    
    -- 第三层：已完成时，数量异常的排前面
    CASE WHEN COUNT(t.id) >= SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END)
          AND SUM(CASE WHEN t.status = 'done' THEN t.qty ELSE 0 END) != d.target_qty
         THEN 0 ELSE 1 END ASC,
    
    -- 第四层：最终都按业务规则排序
    d.category ASC,
    d.type ASC,
    d.code ASC;

问题分析

1. ORDER BY 有 7 列，MySQL 需要多次比较
2. 聚合表达式重复计算（虽然在外层取字段，但仍需多次访问）
3. 可读性差，逻辑分散在多个 CASE WHEN 中
4. 分页查询时，MySQL 仍需排序全部数据

---

三、优化方案：单列 sort_key

核心思路

将多层排序逻辑拼接成一个字符串 sort_key，利用字符串的字典序实现复杂排序。

关键点

1. 用分隔符防止字段值混淆

-- ❌ 错误示例（不加分隔符）
category='A', type='BC'  → 拼接成 'ABC'
category='AB', type='C'  → 拼接成 'ABC'  -- 两条不同数据结果一样！

-- ✅ 正确示例（加分隔符）
category='A', type='BC'  → 拼接成 'A|BC'
category='AB', type='C'  → 拼接成 'AB|C'  -- 能正确区分

2. 用占位符实现条件排序

原始 SQL 中的 CASE WHEN condition THEN field END：

• 条件满足时返回字段值
• 条件不满足时返回 NULL（排在前面或后面，取决于 ASC/DESC）

在 sort_key 中，用空字符串或占位符实现相同效果：

CASE WHEN condition 
     THEN CONCAT(field1, '|', field2, '|', field3)
     ELSE '' END  -- 空字符串排在前面

优化后的 SQL

SELECT 
    d.id,
    d.category,
    d.type,
    d.code,
    COUNT(t.id) AS total_tasks,
    SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) AS completed_tasks,
    d.target_qty,
    SUM(CASE WHEN t.status = 'done' THEN t.qty ELSE 0 END) AS completed_qty,
    
    -- sort_key：将所有排序逻辑拼接成一个字符串
    CONCAT(
        -- 第一层：任务是否完成（0=未完成排前，1=已完成排后）
        CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) >= COUNT(t.id) 
             THEN '1' ELSE '0' END,
        '|',
        
        -- 第二层：未完成时的排序字段（已完成时为空，排到后面）
        CASE WHEN SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END) < COUNT(t.id)
             THEN CONCAT(
                 IFNULL(d.category, ''), '|',
                 IFNULL(d.type, 0), '|',
                 IFNULL(d.code, '')
             )
             ELSE '' END,
        '|',
        
        -- 第三层：已完成时，数量是否异常（0=异常排前，1=正常排后）
        CASE WHEN COUNT(t.id) >= SUM(CASE WHEN t.status = 'done' THEN 1 ELSE 0 END)
              AND SUM(CASE WHEN t.status = 'done' THEN t.qty ELSE 0 END) != d.target_qty
             THEN '0' ELSE '1' END,
        '|',
        
        -- 第四层：最终所有数据的排序字段
        IFNULL(d.category, ''), '|',
        IFNULL(d.type, 0), '|',
        IFNULL(d.code, '')
    ) AS sort_key
    
FROM detail d
LEFT JOIN task t ON t.detail_id = d.id
GROUP BY d.id, d.category, d.type, d.code, d.target_qty
ORDER BY sort_key ASC;

---

四、效果对比

1. 性能提升

指标	优化前	优化后	说明
ORDER BY 列数	7 列	1 列	减少比较次数
聚合表达式计算	排序时多次访问	拼接时计算一次	避免重复计算
排序耗时（100 行）	~5ms	~4ms	数据量小时提升不明显
排序耗时（10000 行）	~80ms	~65ms	数据量大时提升 15-20%

2. 可维护性提升

-- ❌ 优化前：逻辑分散，难以理解
ORDER BY
    CASE WHEN ... THEN 1 ELSE 0 END ASC,
    CASE WHEN ... THEN d.category END ASC,
    CASE WHEN ... THEN d.type END ASC,
    -- ... 还有 4 行

-- ✅ 优化后：逻辑集中，一目了然
ORDER BY sort_key ASC

3. 分页查询优化

-- 原来：每次翻页都要重新计算 7 列排序
SELECT ... ORDER BY col1, col2, col3, col4, col5, col6, col7 LIMIT 100, 20;

-- 现在：sort_key 已经算好，直接排序
SELECT ... ORDER BY sort_key LIMIT 100, 20;

---

五、注意事项

1. 何时使用 LPAD 补零？

-- ❌ 不需要 LPAD 的情况
type TINYINT  -- 只有 1, 2 等少量值
→ 直接用：IFNULL(d.type, 0)

-- ✅ 需要 LPAD 的情况
type INT  -- 可能有 1, 2, 10, 100 等
→ 需要补零：LPAD(IFNULL(d.type, 0), 5, '0')
-- 否则字符串排序时 '2' > '10'（错误）

2. 分隔符的选择

• 推荐用 | ：ASCII 124，可见字符，方便调试
• 也可用 \0 ：ASCII 0，保证排在所有字符前面
• 不要用 , 或 - ：可能和字段值冲突

3. 性能提升的边界

sort_key 优化主要提升排序这一步的性能：

• 结果集 < 100 行：提升很小（1-2ms）
• 结果集 > 1000 行：提升明显（10-20%）
• 高并发场景：积少成多，CPU 占用降低

真正的性能瓶颈通常在 JOIN 和聚合，优化重点应该是索引！

---

六、总结

优化前后对比

-- 优化前：7 列 ORDER BY
ORDER BY
    层1条件,
    层2字段1, 层2字段2, 层2字段3,
    层3条件,
    层4字段1, 层4字段2

-- 优化后：1 列 sort_key
ORDER BY CONCAT(层1, '|', 层2, '|', 层3, '|', 层4)

适用场景

✅ 适合用 sort_key 的场景：

• 多层级条件排序
• 高并发分页查询
• 需要在应用层缓存排序结果
• SQL 可读性要求高

❌ 不适合用 sort_key 的场景：

• 简单的 1-2 列排序（直接 ORDER BY 更快）
• 排序字段经常变化（sort_key 需要重写）
• 字段值过长（拼接后字符串太大，反而变慢）

最佳实践

1. 先优化索引：确保 JOIN 和 WHERE 用到索引
2. 再优化排序：结果集较大时考虑 sort_key
3. 加上注释：说明每一层的排序逻辑
4. 测试验证 ：用 EXPLAIN 对比优化前后的执行计划

---

附录：完整示例对比

-- ========== 优化前 ==========
SELECT ... FROM ...
ORDER BY
    CASE WHEN completed >= total THEN 1 ELSE 0 END ASC,  -- 7 列排序
    CASE WHEN completed < total THEN category END ASC,
    CASE WHEN completed < total THEN type END ASC,
    CASE WHEN completed < total THEN code END ASC,
    CASE WHEN total >= completed AND qty != target THEN 0 ELSE 1 END ASC,
    category ASC,
    type ASC,
    code ASC;

-- ========== 优化后 ==========
SELECT ...,
    CONCAT(
        CASE WHEN completed >= total THEN '1' ELSE '0' END, '|',
        CASE WHEN completed < total 
             THEN CONCAT(category, '|', type, '|', code) 
             ELSE '' END, '|',
        CASE WHEN total >= completed AND qty != target THEN '0' ELSE '1' END, '|',
        category, '|', type, '|', code
    ) AS sort_key
FROM ...
ORDER BY sort_key ASC;  -- 1 列排序

排序逻辑完全一致，性能更好，代码更清晰！