SQL去重技术全解析：从DISTINCT到窗口函数-代码聚汇网

SQL去重技术全解析：从DISTINCT到窗口函数

鬼斧神工119·2026-08-24·阅读 24 GEO检测（免费）

SQL去重DISTINCT窗口函数

|难度：普通|阅读约 15 分钟

1. 为什么SQL去重如此重要？

在数据处理工作中，数据去重可能是最基础也最频繁遇到的需求之一。想象一下这样的场景：你从不同渠道收集了客户信息，准备进行营销活动，却发现同一个客户在系统中存在多条记录；或者分析销售数据时，由于系统同步机制导致交易被重复记录。这些重复数据如果不处理，轻则影响分析结果的准确性，重则可能导致业务决策的重大失误。

SQL作为关系型数据库的标准查询语言，提供了多种去重方法，从简单的DISTINCT关键字到复杂的窗口函数组合。不同的方法适用于不同的场景，性能差异可能达到几个数量级。特别是在处理千万级甚至更大规模的数据时，选择不当的去重方法可能导致查询时间从几秒飙升到几小时。

提示：在实际项目中，去重操作往往不是独立存在的，通常需要结合数据清洗、转换和聚合等多个步骤一起考虑。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 基础去重方法：DISTINCT的妙用与局限

2.1 DISTINCT的基本用法

DISTINCT是SQL中最直接的去重关键字，它作用于SELECT语句中指定的所有列，返回这些列组合的唯一值。

sql复制-- 基本用法：获取唯一的客户城市列表
SELECT DISTINCT city FROM customers;

-- 多列去重：获取唯一的城市-国家组合
SELECT DISTINCT city, country FROM customers;

DISTINCT的工作原理是在内存中构建一个哈希表，将查询结果的每一行与已存在的行进行比较，只保留第一次出现的唯一组合。这种机制决定了它的几个重要特性：

它作用于SELECT子句中的所有列，不能单独指定某些列去重
结果集的排序是不确定的，除非显式使用ORDER BY
对于NULL值，DISTINCT会将其视为相同的值，只保留一个NULL

2.2 DISTINCT的性能考量

虽然DISTINCT语法简单，但在大数据量下可能成为性能瓶颈。数据库优化器处理DISTINCT的方式通常有两种：

排序去重：先对所有数据进行排序，然后扫描排序后的数据，跳过重复项
哈希去重：在内存中构建哈希表，通过哈希值快速判断重复

当数据量超过内存容量时，这两种方法都会导致大量磁盘I/O操作。我曾经在一个项目中遇到一个看似简单的DISTINCT查询，在1000万行数据上执行了超过5分钟，而改用其他方法后只需几秒钟。

注意：在包含大量重复值的列上使用DISTINCT通常效率较高，而在高基数列（如ID列）上使用则可能非常低效。

2.3 DISTINCT与GROUP BY的异同

很多人困惑DISTINCT和GROUP BY的区别，因为它们在某些情况下可以互换：

sql复制-- 这两种写法结果相同
SELECT DISTINCT department, job_title FROM employees;
SELECT department, job_title FROM employees GROUP BY department, job_title;

但它们本质上是不同的操作：

DISTINCT是简单的去重操作
GROUP BY是分组聚合操作，通常与聚合函数一起使用

在大多数现代数据库系统中，这两种写法在性能上没有显著差异，优化器会将其转换为相同的执行计划。但在某些复杂查询中，GROUP BY可能提供更多的优化机会。

3. 高级去重技术：窗口函数的强大能力

3.1 窗口函数基础

窗口函数（Window Functions）是SQL中处理复杂去重需求的利器。与GROUP BY不同，窗口函数不会减少结果集的行数，而是为每一行计算一个值，基于与当前行相关的行集合（称为"窗口"）。

常见的窗口函数包括：

ROW_NUMBER(): 为窗口内的每一行分配唯一的序号
RANK(): 相同的值会有相同的排名，下一个排名会跳过重复的数量
DENSE_RANK(): 相同的值有相同的排名，但排名连续不跳过

3.2 使用ROW_NUMBER()实现精确去重

ROW_NUMBER()是最常用的去重窗口函数，它可以为每组重复值中的一行分配序号1，其他行分配递增序号，然后我们只需要保留序号为1的行：

sql复制WITH ranked_data AS (
  SELECT 
    *,
    ROW_NUMBER() OVER (PARTITION BY column1, column2 ORDER BY some_column) AS rn
  FROM your_table
)
SELECT * FROM ranked_data WHERE rn = 1;

这种方法特别适合以下场景：

需要保留重复组中的"第一条"或"最后一条"记录（通过ORDER BY控制）
去重标准涉及多个列的组合
需要同时保留原始表中的其他列

3.3 性能优化技巧

窗口函数虽然强大，但在大数据集上可能消耗大量资源。以下是一些优化建议：

合理选择PARTITION BY列：只包含真正需要去重的列，多余的列会增加分区数量
谨慎使用ORDER BY：如果没有明确的排序需求，可以使用常量值如ORDER BY NULL
限制处理的数据量：先通过WHERE条件过滤数据，再应用窗口函数
考虑使用临时表：对于复杂查询，先筛选出必要数据存入临时表，再处理

我曾经优化过一个从2小时降到30秒的查询，关键就是先通过WHERE条件将数据从1000万行减少到5万行，再应用窗口函数。

4. 实战案例：电商订单数据清洗

4.1 问题描述

假设我们有一个电商订单表orders，由于系统问题导致部分订单被重复导入，现在需要清洗数据，保留每个订单的最新记录。表结构如下：

sql复制CREATE TABLE orders (
    order_id VARCHAR(20),  -- 订单ID
    user_id INT,           -- 用户ID
    order_time TIMESTAMP,  -- 下单时间
    amount DECIMAL(10,2),  -- 订单金额
    -- 其他字段...
    import_time TIMESTAMP  -- 数据导入时间
);

4.2 解决方案

我们需要识别出具有相同order_id的记录，只保留import_time最大的一条：

sql复制WITH ranked_orders AS (
  SELECT 
    *,
    ROW_NUMBER() OVER (PARTITION BY order_id ORDER BY import_time DESC) AS rn
  FROM orders
)
SELECT * FROM ranked_orders WHERE rn = 1;

如果还需要考虑order_time等其他因素，可以调整ORDER BY子句：

sql复制ORDER BY COALESCE(import_time, order_time) DESC, order_time DESC

4.3 性能对比

在我的测试环境中，对1000万条订单数据（约10%重复率）进行去重：

方法	执行时间	备注
DISTINCT	12.3秒	无法满足需求，因为需要保留完整记录
GROUP BY+MAX	8.7秒	需要子查询获取完整记录
窗口函数	5.2秒	最简洁高效的解决方案

5. 特殊场景处理技巧

5.1 部分列去重

有时我们需要基于部分列去重，但同时需要保留其他列的值。例如，从客户表中获取每个城市的一个代表客户：

sql复制WITH city_rep AS (
  SELECT 
    *,
    ROW_NUMBER() OVER (PARTITION BY city ORDER BY customer_since) AS rn
  FROM customers
)
SELECT customer_id, customer_name, city 
FROM city_rep 
WHERE rn = 1;

5.2 多条件去重

更复杂的场景可能需要组合多个条件进行去重。例如，找出每个产品类别中价格最低和最高的产品：

sql复制WITH product_ranks AS (
  SELECT 
    *,
    ROW_NUMBER() OVER (PARTITION BY category_id ORDER BY price ASC) AS cheapest,
    ROW_NUMBER() OVER (PARTITION BY category_id ORDER BY price DESC) AS most_expensive
  FROM products
)
SELECT * FROM product_ranks 
WHERE cheapest = 1 OR most_expensive = 1;

5.3 大数据量分批处理

对于超大数据集，可以考虑分批处理：

sql复制-- 假设我们按日期分批处理
DECLARE @start_date DATE = '2023-01-01';
DECLARE @end_date DATE = '2023-01-31';

WHILE @start_date < '2024-01-01'
BEGIN
    -- 处理当月数据
    WITH monthly_data AS (...)
    INSERT INTO clean_table
    SELECT ... FROM monthly_data WHERE ...;
    
    -- 移动到下个月
    SET @start_date = DATEADD(MONTH, 1, @start_date);
    SET @end_date = DATEADD(MONTH, 1, @end_date);
END

6. 跨数据库平台的注意事项

不同数据库系统对去重操作的支持有所差异：

6.1 MySQL的特别考虑

MySQL 8.0+支持窗口函数，但早期版本需要使用其他方法：

sql复制-- MySQL 5.7及以下版本的替代方案
SELECT t1.*
FROM your_table t1
INNER JOIN (
    SELECT MIN(id) AS min_id, column1, column2
    FROM your_table
    GROUP BY column1, column2
) t2 ON t1.id = t2.min_id;

6.2 PostgreSQL的高级特性

PostgreSQL提供了一些特有的去重功能，如DISTINCT ON：

sql复制-- 获取每个城市最新的客户记录
SELECT DISTINCT ON (city) *
FROM customers
ORDER BY city, customer_since DESC;

6.3 SQL Server的优化提示

SQL Server中可以使用OPTION提示影响优化器行为：

sql复制WITH cte AS (...)
SELECT * FROM cte
OPTION (MAXDOP 4); -- 限制并行度

7. 常见陷阱与解决方案

7.1 NULL值处理

NULL值在去重时经常导致意外结果，因为NULL不等于任何值，包括它自己：

sql复制-- 假设column1包含NULL值
SELECT DISTINCT column1 FROM your_table;
-- 结果中可能包含多个NULL

-- 解决方案：将NULL转换为特定值
SELECT DISTINCT COALESCE(column1, '') FROM your_table;

7.2 字符编码问题

不同编码的相同字符可能被视为不同值：

sql复制-- 假设数据库中有'café'和'café'（不同编码）
SELECT DISTINCT name FROM coffee_shops;
-- 可能返回两行

-- 解决方案：规范化字符串
SELECT DISTINCT NORMALIZE(name) FROM coffee_shops;

7.3 性能突然下降

有时相同的查询在不同数据量下性能差异巨大，这通常是由于执行计划变化导致的。解决方案包括：

更新统计信息
使用查询提示
重构查询逻辑

8. 监控与优化去重查询

8.1 执行计划分析

理解查询执行计划是优化的关键。例如，在SQL Server中：

sql复制-- 查看执行计划
SET SHOWPLAN_TEXT ON;
GO
SELECT DISTINCT ...;
GO
SET SHOWPLAN_TEXT OFF;

重点关注：

是否使用了合适的索引
排序操作的成本
内存授予是否充足

8.2 索引策略

为去重列创建适当的索引可以大幅提升性能：

sql复制-- 为常用去重列组合创建索引
CREATE INDEX idx_customer_location ON customers(city, country);

复合索引的列顺序应与查询中的PARTITION BY或GROUP BY顺序一致。

8.3 资源监控

大型去重操作可能消耗大量资源，需要监控：

内存使用情况
临时数据库空间
锁等待时间

在SQL Server中可以使用以下DMV查询：

sql复制SELECT 
    session_id,
    start_time,
    status,
    cpu_time,
    logical_reads,
    writes
FROM sys.dm_exec_requests
WHERE session_id > 50;

9. 替代方案与工具集成

9.1 ETL工具中的去重

许多ETL工具提供了内置的去重组件，通常比SQL更高效：

SSIS: 有专门的数据去重转换组件
Informatica: 提供"Distinct"转换
Talend: 使用tUniqRow组件

9.2 使用临时表分阶段处理

对于极其复杂或大数据量的去重需求，可以考虑分阶段处理：

sql复制-- 阶段1：提取需要去重的键到临时表
SELECT DISTINCT key1, key2 INTO #keys FROM source_table;

-- 阶段2：从原表获取完整记录
SELECT t.* 
FROM source_table t
INNER JOIN #keys k ON t.key1 = k.key1 AND t.key2 = k.key2;

9.3 应用层去重

在某些场景下，将部分去重逻辑移到应用层可能更合适，特别是当：

去重规则非常复杂
需要结合业务逻辑
数据量适中

例如使用Python的pandas库：

python复制import pandas as pd

# 读取数据
df = pd.read_sql("SELECT * FROM table", engine)

# 基于多列去重
df_unique = df.drop_duplicates(subset=['col1', 'col2'], keep='last')

10. 实际项目中的经验分享

在我参与的一个金融数据分析项目中，我们需要从数十亿条交易记录中识别并移除重复交易。经过多次迭代，我们最终采用了以下策略：

预处理阶段：使用Hadoop进行初步去重，基于交易ID哈希值分片处理
精确去重阶段：将预处理后的数据加载到SQL Server，使用窗口函数进行精确去重
验证阶段：抽样检查去重结果，确保没有误删有效交易

关键教训：

不要试图在单个SQL查询中完成所有工作，分阶段处理更可靠
对于超大数据集，考虑使用近似去重算法先减少数据量
建立完善的验证机制，确保去重过程没有引入错误

另一个电商项目的经验是，对于用户行为数据，我们采用了"软去重"方法：不是完全删除重复记录，而是标记它们并保留最早的记录。这为后续分析保留了更多灵活性。