SQL select 仅在列上具有最大值的行[重复]

Question

想要改进这篇文章？ 提供这个问题的详细答案，包括引文和解释为什么你的答案是正确的。 没有足够细节的答案可能会被编辑或删除。

这个问题在这里已经有了答案：

检索每组中的最后一条记录 - MySQL （33 个答案）

3年前关闭。

我有这张文件表（这里是简化版）：

ID	转	内容
1	1	...
2	1	...
1	2	...
1	3	...

我如何 select 每个 id 一行并且只有最大转速？
使用上述数据，结果应包含两行： [1, 3, ...]和[2, 1, ..] 。 我正在使用MySQL 。

目前，我在while循环中使用检查来检测和覆盖结果集中的旧转速。 但这是实现结果的唯一方法吗？ 没有SQL解决方案吗？

Answer 1

乍一看...

您只需要一个带有MAX聚合函数的GROUP BY子句：

SELECT id, MAX(rev)
FROM YourTable
GROUP BY id

从来没有那么简单，不是吗？

我刚刚注意到您也需要content列。

这是 SQL 中一个非常常见的问题：在每个组标识符的列中找到具有某个最大值的行的整个数据。 在我的职业生涯中，我听到了很多。 实际上，这是我在当前工作的技术面试中回答的问题之一。

实际上，Stack Overflow 社区创建了一个标签来处理此类问题非常普遍： best-n-per-group 。

基本上，您有两种方法可以解决该问题：

加入简单group-identifier, max-value-in-group子查询

在这种方法中，您首先在子查询中找到group-identifier, max-value-in-group （上面已经解决）。 然后你将你的表加入到子查询中，同时group-identifier和max-value-in-group相等：

SELECT a.id, a.rev, a.contents
FROM YourTable a
INNER JOIN (
    SELECT id, MAX(rev) rev
    FROM YourTable
    GROUP BY id
) b ON a.id = b.id AND a.rev = b.rev

Left Joining with self，调整连接条件和过滤器

在这种方法中，您离开了与自身连接的表。 平等进入group-identifier 。 然后，2个聪明的举动：

1. 第二个连接条件是左侧值小于右侧值
2. 当您执行第 1 步时，实际具有最大值的行将在右侧具有NULL （它是LEFT JOIN ，记得吗？）。 然后，我们过滤连接的结果，只显示右侧为NULL的行。

所以你最终得到：

SELECT a.*
FROM YourTable a
LEFT OUTER JOIN YourTable b
    ON a.id = b.id AND a.rev < b.rev
WHERE b.id IS NULL;

结论

两种方法都带来完全相同的结果。

如果您有两行与group-identifier max-value-in-group ，则这两行都将在两种方法的结果中。

这两种方法都与 SQL ANSI 兼容，因此，无论其“风格”如何，都可以与您最喜欢的 RDBMS 一起使用。

这两种方法也对性能友好，但是您的里程可能会有所不同（RDBMS、数据库结构、索引等）。 因此，当您选择一种方法而不是另一种方法时，基准测试. 并确保您选择对您最有意义的那个。

Answer 2

我的偏好是使用尽可能少的代码......

您可以使用IN试试这个：

SELECT * 
FROM t1 WHERE (id,rev) IN 
( SELECT id, MAX(rev)
  FROM t1
  GROUP BY id
)

在我看来，它不那么复杂......更易于阅读和维护。

Answer 3

我很惊讶没有答案提供 SQL 窗口函数解决方案：

SELECT a.id, a.rev, a.contents
  FROM (SELECT id, rev, contents,
               ROW_NUMBER() OVER (PARTITION BY id ORDER BY rev DESC) ranked_order
          FROM YourTable) a
 WHERE a.ranked_order = 1 

在 SQL 标准 ANSI/ISO 标准 SQL:2003 中添加，后来通过 ANSI/ISO 标准 SQL:2008 进行了扩展，现在所有主要供应商都可以使用窗口（或窗口）函数。 有更多类型的排名函数可用于处理平局问题： RANK, DENSE_RANK, PERSENT_RANK 。

Answer 4

另一个解决方案是使用相关子查询：

select yt.id, yt.rev, yt.contents
    from YourTable yt
    where rev = 
        (select max(rev) from YourTable st where yt.id=st.id)

在 (id,rev) 上有一个索引几乎可以将子查询呈现为一个简单的查找......

以下是与@AdrianCarneiro 的答案（子查询，leftjoin）中的解决方案的比较，基于 MySQL 测量，InnoDB 表有约 100 万条记录，组大小为：1-3。

虽然对于全表扫描，子查询/leftjoin/相关时间相互关联为 6/8/9，但当涉及直接查找或批处理（ id in (1,2,3) ）时，子查询比其他查询慢得多（由于重新运行子查询）。 但是，我无法区分 leftjoin 和相关解决方案的速度。

最后一点，当 leftjoin 在组中创建 n*(n+1)/2 连接时，它的性能可能会受到组大小的严重影响......

Answer 5

我不能保证性能，但这是一个受 Microsoft Excel 限制启发的技巧。 它有一些很好的功能

好东西

• 即使有平局，它也应该只强制返回一个“最大记录”（有时有用）
• 它不需要加入

方法

它有点难看，需要您对rev列的有效值范围有所了解。 让我们假设我们知道rev列是一个介于 0.00 和 999 之间的数字，包括小数，但小数点右侧只有两位数（例如 34.17 是一个有效值）。

事情的要点是您通过字符串连接/打包主要比较字段以及您想要的数据来创建一个合成列。 这样，您可以强制 SQL 的 MAX() 聚合函数返回所有数据（因为它已被打包到单个列中）。 然后你必须解压数据。

以下是上面示例的外观，用 SQL 编写

SELECT id, 
       CAST(SUBSTRING(max(packed_col) FROM 2 FOR 6) AS float) as max_rev,
       SUBSTRING(max(packed_col) FROM 11) AS content_for_max_rev 
FROM  (SELECT id, 
       CAST(1000 + rev + .001 as CHAR) || '---' || CAST(content AS char) AS packed_col
       FROM yourtable
      ) 
GROUP BY id

包装首先强制rev列是一个已知字符长度的数字，而不考虑rev的值，例如

• 3.2 变成 1003.201
• 57 变成 1057.001
• 923.88 变为 1923.881

如果你做对了，两个数字的字符串比较应该产生与两个数字的数字比较相同的“最大值”，并且使用 substring 函数很容易转换回原始数字（它可以以一种或另一种形式提供到处）。

Answer 6

唯一标识符？ 是的！ 唯一标识符！

开发 MySQL DB 的最佳方法之一是让每个id AUTOINCREMENT （来源 MySQL.com）。 这可以带来多种优势，这里不一一赘述。 该问题的问题在于其示例具有重复的 ID。 这无视了唯一标识符的这些巨大优势，同时也让那些已经熟悉这一点的人感到困惑。

最干净的解决方案

DB小提琴

较新版本的 MySQL 默认启用ONLY_FULL_GROUP_BY ，并且这里的许多解决方案在这种情况下的测试将失败。

即便如此，我们也可以简单地选择DISTINCT someuniquefield 、 MAX( whateverotherfieldtoselect ) 、 ( *somethirdfield )等，而不必担心理解结果或查询是如何工作的：

SELECT DISTINCT t1.id, MAX(t1.rev), MAX(t2.content)
FROM Table1 AS t1
JOIN Table1 AS t2 ON t2.id = t1.id AND t2.rev = (
    SELECT MAX(rev) FROM Table1 t3 WHERE t3.id = t1.id
)
GROUP BY t1.id;

• SELECT DISTINCT Table1.id, max(Table1.rev), max(Table2.content) : Return DISTINCT somefield, MAX() some otherfield, 最后一个MAX()是多余的，因为我知道它只是一行，但它是必需的查询。
• FROM Employee : 搜索表。
• JOIN Table1 AS Table2 ON Table2.rev = Table1.rev : 在第一个表上加入第二个表，因为，我们需要获取 max(table1.rev) 的注释。
• GROUP BY Table1.id ：强制将每个员工的薪水排在最前面的行作为返回结果。

请注意，由于在 OP 的问题中“内容”是“...”，因此无法测试它是否有效。 所以，我把它改成了“..a”，“..b”，所以，我们现在实际上可以看到结果是正确的：

id  max(Table1.rev) max(Table2.content)
1   3   ..d
2   1   ..b

为什么是干净的？ DISTINCT() 、 MAX()等都很好地利用了 MySQL 索引。 这会更快。 或者，如果您有索引，并且将其与查看所有行的查询进行比较，它会快得多。

原始解决方案

禁用ONLY_FULL_GROUP_BY ，我们仍然可以使用GROUP BY ，但是我们只在 Salary 上使用它，而不是在 id 上：

SELECT *
FROM
    (SELECT *
    FROM Employee
    ORDER BY Salary DESC)
AS employeesub
GROUP BY employeesub.Salary;

• SELECT * ：返回所有字段。
• FROM Employee : 搜索表。
• (SELECT *...)子查询：返回所有人员，按薪水排序。
• GROUP BY employeesub.Salary ：强制将每个员工的排在最前面的 Salary 行作为返回结果。

唯一行解决方案

请注意关系数据库的定义：“表中的每一行都有自己的唯一键。” 这意味着，在问题的示例中， id必须是唯一的，在这种情况下，我们可以这样做：

SELECT *
FROM Employee
WHERE Employee.id = 12345
ORDER BY Employee.Salary DESC
LIMIT 1

希望这是一个解决问题的解决方案，并帮助每个人更好地了解数据库中正在发生的事情。

Answer 7

像这样的东西？

SELECT yourtable.id, rev, content
FROM yourtable
INNER JOIN (
    SELECT id, max(rev) as maxrev
    FROM yourtable
    GROUP BY id
) AS child ON (yourtable.id = child.id) AND (yourtable.rev = maxrev)

Answer 8

完成这项工作的另一种方法是在 OVER PARTITION 子句中使用MAX()分析函数

SELECT t.*
  FROM
    (
    SELECT id
          ,rev
          ,contents
          ,MAX(rev) OVER (PARTITION BY id) as max_rev
      FROM YourTable
    ) t
  WHERE t.rev = t.max_rev 

这篇文章中已经记录的另一个ROW_NUMBER() OVER PARTITION 解决方案是

SELECT t.*
  FROM
    (
    SELECT id
          ,rev
          ,contents
          ,ROW_NUMBER() OVER (PARTITION BY id ORDER BY rev DESC) rank
      FROM YourTable
    ) t
  WHERE t.rank = 1 

这 2 SELECT 在 Oracle 10g 上运行良好。

MAX() 解决方案的运行速度肯定比ROW_NUMBER()解决方案更快，因为MAX()复杂度为O(n)而ROW_NUMBER()复杂度最低为O(n.log(n)) ，其中n表示表中的记录数！

Answer 9

我喜欢使用基于NOT EXIST的解决方案来解决这个问题：

SELECT 
  id, 
  rev
  -- you can select other columns here
FROM YourTable t
WHERE NOT EXISTS (
   SELECT * FROM YourTable t WHERE t.id = id AND rev > t.rev
)

这将选择组内具有最大值的所有记录，并允许您选择其他列。

Answer 10

注意：在 MySQL 8 天以上的时间里，我可能不会再推荐这个了。 好多年没用过了。

我几乎从未见过提到的第三种解决方案是特定于 MySQL 的，如下所示：

SELECT id, MAX(rev) AS rev
 , 0+SUBSTRING_INDEX(GROUP_CONCAT(numeric_content ORDER BY rev DESC), ',', 1) AS numeric_content
FROM t1
GROUP BY id

是的，它看起来很糟糕（转换为字符串并返回等），但根据我的经验，它通常比其他解决方案更快。 也许这只是针对我的用例，但我已经在具有数百万条记录和许多唯一 ID 的表上使用它。 也许是因为 MySQL 在优化其他解决方案方面做得很差（至少在我提出这个解决方案的 5.0 天）。

一件重要的事情是 GROUP_CONCAT 对它可以建立的字符串有一个最大长度。 您可能希望通过设置group_concat_max_len变量来提高此限制。 请记住，如果您有大量行，这将限制缩放。

无论如何，如果您的内容字段已经是文本，则上述内容不会直接起作用。 在这种情况下，您可能想要使用不同的分隔符，例如 \0 。 您还将更快地遇到group_concat_max_len限制。

Answer 11

SELECT *
FROM Employee
where Employee.Salary in (select max(salary) from Employee group by Employe_id)
ORDER BY Employee.Salary

Answer 12

我想，你想要这个？

select * from docs where (id, rev) IN (select id, max(rev) as rev from docs group by id order by id)  

SQL Fiddle：检查这里

Answer 13

不是 mySQL ，但对于其他发现此问题并使用 SQL 的人来说，解决每个组最大 n问题的另一种方法是在 MS SQL 中使用Cross Apply

WITH DocIds AS (SELECT DISTINCT id FROM docs)

SELECT d2.id, d2.rev, d2.content
FROM DocIds d1
CROSS APPLY (
  SELECT Top 1 * FROM docs d
  WHERE d.id = d1.id
  ORDER BY rev DESC
) d2

这是 SqlFiddle 中的一个示例

Answer 14

由于这是关于这个问题的最受欢迎的问题，我也会在这里重新发布另一个答案：

看起来有更简单的方法可以做到这一点（但仅限于 MySQL ）：

select *
from (select * from mytable order by id, rev desc ) x
group by id

请感谢用户 Bohemian在这个问题中的回答，因为它为这个问题提供了如此简洁和优雅的答案。

编辑：尽管此解决方案适用于许多人，但从长远来看可能不稳定，因为 MySQL 不保证 GROUP BY 语句将为不在 GROUP BY 列表中的列返回有意义的值。 因此，使用此解决方案需要您自担风险！

Answer 15

我会用这个：

select t.*
from test as t
join
   (select max(rev) as rev
    from test
    group by id) as o
on o.rev = t.rev

子查询 SELECT 可能不太高效，但在 JOIN 子句中似乎可用。 我不是优化查询方面的专家，但我在 MySQL、PostgreSQL、FireBird 上进行过尝试，效果非常好。

您可以在多个连接和 WHERE 子句中使用此模式。 这是我的工作示例（解决与表“firmy”相同的问题）：

select *
from platnosci as p
join firmy as f
on p.id_rel_firmy = f.id_rel
join (select max(id_obj) as id_obj
      from firmy
      group by id_rel) as o
on o.id_obj = f.id_obj and p.od > '2014-03-01'

在有十几条记录的桌子上询问，在不太强大的机器上花费不到 0,01 秒。

我不会使用 IN 子句（正如上面某处提到的那样）。 IN 用于与短的常量列表一起使用，而不是作为基于子查询的查询过滤器。 这是因为 IN 中的子查询是针对每个扫描的记录执行的，这会使查询花费很长时间。

Answer 16

这个怎么样：

SELECT all_fields.*  
FROM (SELECT id, MAX(rev) FROM yourtable GROUP BY id) AS max_recs  
LEFT OUTER JOIN yourtable AS all_fields 
ON max_recs.id = all_fields.id

Answer 17

如果您在 select 语句中有许多字段，并且您希望通过优化代码获得所有这些字段的最新值：

select * from
(select * from table_name
order by id,rev desc) temp
group by id 

Answer 18

此解决方案仅从 YourTable 中选择一个，因此速度更快。 根据 sqlfiddle.com 上的测试，它仅适用于 MySQL 和 SQLite（用于 SQLite 删除 DESC）。 也许可以对其进行调整以使用我不熟悉的其他语言。

SELECT *
FROM ( SELECT *
       FROM ( SELECT 1 as id, 1 as rev, 'content1' as content
              UNION
              SELECT 2, 1, 'content2'
              UNION
              SELECT 1, 2, 'content3'
              UNION
              SELECT 1, 3, 'content4'
            ) as YourTable
       ORDER BY id, rev DESC
   ) as YourTable
GROUP BY id

Answer 19

这是一个很好的方法

使用以下代码：

with temp as  ( 
select count(field1) as summ , field1
from table_name
group by field1 )
select * from temp where summ = (select max(summ) from temp)

Answer 20

我喜欢通过按某个列对记录进行排名来做到这一点。 在这种情况下，对按id分组的rev值进行排名。 rev较高的人排名较低。 所以最高rev的排名为 1。

select id, rev, content
from
 (select
    @rowNum := if(@prevValue = id, @rowNum+1, 1) as row_num,
    id, rev, content,
    @prevValue := id
  from
   (select id, rev, content from YOURTABLE order by id asc, rev desc) TEMP,
   (select @rowNum := 1 from DUAL) X,
   (select @prevValue := -1 from DUAL) Y) TEMP
where row_num = 1;

不确定引入变量是否会使整个事情变慢。 但至少我没有查询YOURTABLE两次。

Answer 21

以相反的顺序对 rev 字段进行排序，然后按 id 分组，id 给出每个分组的第一行，即具有最高 rev 值的那一行。

SELECT * FROM (SELECT * FROM table1 ORDER BY id, rev DESC) X GROUP BY X.id;

在http://sqlfiddle.com/中使用以下数据进行了测试

CREATE TABLE table1
    (`id` int, `rev` int, `content` varchar(11));

INSERT INTO table1
    (`id`, `rev`, `content`)
VALUES
    (1, 1, 'One-One'),
    (1, 2, 'One-Two'),
    (2, 1, 'Two-One'),
    (2, 2, 'Two-Two'),
    (3, 2, 'Three-Two'),
    (3, 1, 'Three-One'),
    (3, 3, 'Three-Three')
;

这在 MySql 5.5 和 5.6 中给出了以下结果

id  rev content
1   2   One-Two
2   2   Two-Two
3   3   Three-Two

Answer 22

这是另一种解决方案，希望对某人有所帮助

Select a.id , a.rev, a.content from Table1 a
inner join 
(SELECT id, max(rev) rev FROM Table1 GROUP BY id) x on x.id =a.id and x.rev =a.rev

Answer 23

这些答案都不适合我。

这对我有用。

with score as (select max(score_up) from history)
select history.* from score, history where history.score_up = score.max

Answer 24

这是仅使用具有该字段最大值的字段检索记录的另一种解决方案。 这适用于我工作的平台 SQL400。 在本示例中，FIELD5 字段中具有最大值的记录将由以下 SQL 语句检索。

SELECT A.KEYFIELD1, A.KEYFIELD2, A.FIELD3, A.FIELD4, A.FIELD5
  FROM MYFILE A
 WHERE RRN(A) IN
   (SELECT RRN(B) 
      FROM MYFILE B
     WHERE B.KEYFIELD1 = A.KEYFIELD1 AND B.KEYFIELD2 = A.KEYFIELD2
     ORDER BY B.FIELD5 DESC
     FETCH FIRST ROW ONLY)

Answer 25

当您将rev和id组合为MAX()的一个maxRevId值，然后将其拆分回原始值时，您可以在没有连接的情况下进行选择：

SELECT maxRevId & ((1 << 32) - 1) as id, maxRevId >> 32 AS rev
FROM (SELECT MAX(((rev << 32) | id)) AS maxRevId
      FROM YourTable
      GROUP BY id) x;

当存在复杂连接而不是单个表时，这尤其快。 使用传统方法，复杂的连接将进行两次。

当rev和id是INT UNSIGNED （32 位）并且组合值适合BIGINT UNSIGNED （64 位）时，上述组合很简单。 当id和rev大于 32 位值或由多列组成时，您需要将该值组合成例如具有适当填充的二进制值MAX() 。

Answer 26

解释

这不是纯 SQL。 这将使用 SQLAlchemy ORM。

我来这里是为了寻求 SQLAlchemy 的帮助，所以我将用 python/SQLAlchemy 版本复制 Adrian Carneiro 的答案，特别是外连接部分。

此查询回答以下问题：

“你能把这组记录（基于相同的id）中版本号最高的记录还给我吗”。

这允许我复制记录、更新它、增加它的版本号，并拥有旧版本的副本，以便我可以显示随时间的变化。

代码

MyTableAlias = aliased(MyTable)
newest_records = appdb.session.query(MyTable).select_from(join(
    MyTable, 
    MyTableAlias, 
    onclause=and_(
        MyTable.id == MyTableAlias.id,
        MyTable.version_int < MyTableAlias.version_int
    ),
    isouter=True
    )
).filter(
    MyTableAlias.id  == None,
).all()

在 PostgreSQL 数据库上测试。

Answer 27

我用下面的方法来解决我自己的问题。 我首先创建了一个临时表并插入了每个唯一 ID 的最大转速值。

CREATE TABLE #temp1
(
    id varchar(20)
    , rev int
)
INSERT INTO #temp1
SELECT a.id, MAX(a.rev) as rev
FROM 
    (
        SELECT id, content, SUM(rev) as rev
        FROM YourTable
        GROUP BY id, content
    ) as a 
GROUP BY a.id
ORDER BY a.id

然后我将这些最大值 (#temp1) 加入到所有可能的 id/content 组合中。 通过这样做，我自然会过滤掉非最大 id/content 组合，并留下每个唯一的最大转速值。

SELECT a.id, a.rev, content
FROM #temp1 as a
LEFT JOIN
    (
        SELECT id, content, SUM(rev) as rev
        FROM YourTable
        GROUP BY id, content
    ) as b on a.id = b.id and a.rev = b.rev
GROUP BY a.id, a.rev, b.content
ORDER BY a.id