Obter registros com valor máximo para cada grupo de resultados SQL agrupados

Como você obtém as linhas que contêm o valor máximo para cada conjunto agrupado?

Eu já vi algumas variações excessivamente complicadas nessa questão, e nenhuma com uma boa resposta. Eu tentei montar o exemplo mais simples possível:

Dada uma tabela como essa abaixo, com colunas de pessoa, grupo e faixa etária, como você obteria a pessoa mais velha de cada grupo? (Um empate dentro de um grupo deve dar o primeiro resultado alfabético)

Person | Group | Age
---
Bob  | 1     | 32  
Jill | 1     | 34  
Shawn| 1     | 42  
Jake | 2     | 29  
Paul | 2     | 36  
Laura| 2     | 39  

Conjunto de resultados desejado:

Shawn | 1     | 42    
Laura | 2     | 39  

Existe uma maneira super simples de fazer isso no mysql:

select * 
from (select * from mytable order by `Group`, age desc, Person) x
group by `Group`

Isso funciona porque no mysql você está autorizado a não agregada não-grupo-por colunas, caso em que o mysql retorna apenas a primeira linha. A solução é ordenar primeiro os dados de modo que, para cada grupo, a linha que você deseja seja primeiro e, em seguida, agrupe pelas colunas para as quais deseja o valor.

Você evita subconsultas complicadas que tentam encontrar o max()etc, e também os problemas de retornar várias linhas quando há mais de uma com o mesmo valor máximo (como as outras respostas fariam)

Nota: Esta é uma solução somente para mysql . Todos os outros bancos de dados que eu conheço lançarão um erro de sintaxe SQL com a mensagem "colunas não agregadas não estão listadas no grupo por cláusula" ou similar. Como esta solução usa comportamento não documentado , o mais cauteloso pode querer incluir um teste para afirmar que continua funcionando se uma versão futura do MySQL alterar esse comportamento.

Atualização da versão 5.7:

Desde a versão 5.7, a sql-modeconfiguração inclui ONLY_FULL_GROUP_BYpor padrão, portanto, para fazer isso funcionar, você não deve ter essa opção (edite o arquivo de opções do servidor para remover essa configuração).

A solução correta é:

SELECT o.*
FROM `Persons` o                    # 'o' from 'oldest person in group'
  LEFT JOIN `Persons` b             # 'b' from 'bigger age'
      ON o.Group = b.Group AND o.Age < b.Age
WHERE b.Age is NULL                 # bigger age not found

Como funciona:

Ele corresponde a cada linha ocom todas as linhas de bter o mesmo valor na coluna Groupe um valor maior na coluna Age. Qualquer linha que onão tenha o valor máximo de seu grupo na coluna Agecorresponderá a uma ou mais linhas de b.

O LEFT JOINfaz-lo coincidir com a pessoa mais velha do grupo (incluindo as pessoas que estão sozinhas em seu grupo) com uma linha completa de NULLs de b( 'não maior idade no grupo').
O uso INNER JOINfaz com que essas linhas não correspondam e são ignoradas.

A WHEREcláusula mantém apenas as linhas com NULLs nos campos extraídos b. Eles são as pessoas mais velhas de cada grupo.

Leituras adicionais

Esta solução e muitas outras são explicadas no livro Antipatterns SQL: Evitando as Armadilhas da Programação de Banco de Dados

Você pode ingressar em uma subconsulta que puxa o MAX(Group)e Age. Este método é portátil na maioria dos RDBMS.

SELECT t1.*
FROM yourTable t1
INNER JOIN
(
    SELECT `Group`, MAX(Age) AS max_age
    FROM yourTable
    GROUP BY `Group`
) t2
    ON t1.`Group` = t2.`Group` AND t1.Age = t2.max_age;

Minha solução simples para SQLite (e provavelmente MySQL):

SELECT *, MAX(age) FROM mytable GROUP BY `Group`;

No entanto, ele não funciona no PostgreSQL e talvez em outras plataformas.

No PostgreSQL você pode usar a cláusula DISTINCT ON :

SELECT DISTINCT ON ("group") * FROM "mytable" ORDER BY "group", "age" DESC;

Usando o método de classificação.

SELECT @rn :=  CASE WHEN @prev_grp <> groupa THEN 1 ELSE @rn+1 END AS rn,  
   @prev_grp :=groupa,
   person,age,groupa  
FROM   users,(SELECT @rn := 0) r        
HAVING rn=1
ORDER  BY groupa,age DESC,person

Não tenho certeza se o MySQL tem a função row_number. Nesse caso, você pode usá-lo para obter o resultado desejado. No SQL Server, você pode fazer algo semelhante a:

CREATE TABLE p
(
 person NVARCHAR(10),
 gp INT,
 age INT
);
GO
INSERT  INTO p
VALUES  ('Bob', 1, 32);
INSERT  INTO p
VALUES  ('Jill', 1, 34);
INSERT  INTO p
VALUES  ('Shawn', 1, 42);
INSERT  INTO p
VALUES  ('Jake', 2, 29);
INSERT  INTO p
VALUES  ('Paul', 2, 36);
INSERT  INTO p
VALUES  ('Laura', 2, 39);
GO

SELECT  t.person, t.gp, t.age
FROM    (
         SELECT *,
                ROW_NUMBER() OVER (PARTITION BY gp ORDER BY age DESC) row
         FROM   p
        ) t
WHERE   t.row = 1;

A solução da axiac é o que funcionou melhor para mim no final. No entanto, eu tinha uma complexidade adicional: um "valor máximo" calculado, derivado de duas colunas.

Vamos usar o mesmo exemplo: eu gostaria da pessoa mais velha de cada grupo. Se houver pessoas igualmente velhas, leve a pessoa mais alta.

Eu tive que executar a junção esquerda duas vezes para obter esse comportamento:

SELECT o1.* WHERE
    (SELECT o.*
    FROM `Persons` o
    LEFT JOIN `Persons` b
    ON o.Group = b.Group AND o.Age < b.Age
    WHERE b.Age is NULL) o1
LEFT JOIN
    (SELECT o.*
    FROM `Persons` o
    LEFT JOIN `Persons` b
    ON o.Group = b.Group AND o.Age < b.Age
    WHERE b.Age is NULL) o2
ON o1.Group = o2.Group AND o1.Height < o2.Height 
WHERE o2.Height is NULL;

Espero que isto ajude! Acho que deveria haver uma maneira melhor de fazer isso ...

Minha solução funciona apenas se você precisar recuperar apenas uma coluna; no entanto, para minhas necessidades, foi a melhor solução encontrada em termos de desempenho (ela usa apenas uma única consulta!):

SELECT SUBSTRING_INDEX(GROUP_CONCAT(column_x ORDER BY column_y),',',1) AS xyz,
   column_z
FROM table_name
GROUP BY column_z;

Ele usa GROUP_CONCAT para criar uma lista de concat ordenadas e, em seguida, faço a substring apenas para a primeira.

Eu tenho uma solução simples usando WHERE IN

SELECT a.* FROM `mytable` AS a    
WHERE a.age IN( SELECT MAX(b.age) AS age FROM `mytable` AS b GROUP BY b.group )    
ORDER BY a.group ASC, a.person ASC

Usando CTEs - expressões comuns de tabela:

WITH MyCTE(MaxPKID, SomeColumn1)
AS(
SELECT MAX(a.MyTablePKID) AS MaxPKID, a.SomeColumn1
FROM MyTable1 a
GROUP BY a.SomeColumn1
  )
SELECT b.MyTablePKID, b.SomeColumn1, b.SomeColumn2 MAX(b.NumEstado)
FROM MyTable1 b
INNER JOIN MyCTE c ON c.MaxPKID = b.MyTablePKID
GROUP BY b.MyTablePKID, b.SomeColumn1, b.SomeColumn2

--Note: MyTablePKID is the PrimaryKey of MyTable

No Oracle, a consulta abaixo pode fornecer o resultado desejado.

SELECT group,person,Age,
  ROWNUMBER() OVER (PARTITION BY group ORDER BY age desc ,person asc) as rankForEachGroup
  FROM tablename where rankForEachGroup=1

with CTE as 
(select Person, 
[Group], Age, RN= Row_Number() 
over(partition by [Group] 
order by Age desc) 
from yourtable)`


`select Person, Age from CTE where RN = 1`

Você também pode tentar

SELECT * FROM mytable WHERE age IN (SELECT MAX(age) FROM mytable GROUP BY `Group`) ;

Eu não usaria Grupo como nome da coluna, pois é uma palavra reservada. No entanto, seguir o SQL funcionaria.

SELECT a.Person, a.Group, a.Age FROM [TABLE_NAME] a
INNER JOIN 
(
  SELECT `Group`, MAX(Age) AS oldest FROM [TABLE_NAME] 
  GROUP BY `Group`
) b ON a.Group = b.Group AND a.Age = b.oldest

Esse método tem o benefício de permitir que você classifique por uma coluna diferente e não descarte os outros dados. É bastante útil em uma situação em que você está tentando listar pedidos com uma coluna para itens, listando os mais pesados ​​primeiro.

Fonte: http://dev.mysql.com/doc/refman/5.0/en/group-by-functions.html#function_group-concat

SELECT person, group,
    GROUP_CONCAT(
        DISTINCT age
        ORDER BY age DESC SEPARATOR ', follow up: '
    )
FROM sql_table
GROUP BY group;

deixe o nome da tabela ser pessoas

select O.*              -- > O for oldest table
from people O , people T
where O.grp = T.grp and 
O.Age = 
(select max(T.age) from people T where O.grp = T.grp
  group by T.grp)
group by O.grp; 

Se o ID (e todos os coulmns) for necessário no mytable

SELECT
    *
FROM
    mytable
WHERE
    id NOT IN (
        SELECT
            A.id
        FROM
            mytable AS A
        JOIN mytable AS B ON A. GROUP = B. GROUP
        AND A.age < B.age
    )

É assim que eu estou recebendo as N linhas máximas por grupo no mysql

SELECT co.id, co.person, co.country
FROM person co
WHERE (
SELECT COUNT(*)
FROM person ci
WHERE  co.country = ci.country AND co.id < ci.id
) < 1
;

como funciona:

• auto junção à mesa
• grupos são feitos por co.country = ci.country
• N elementos por grupo são controlados por ) < 1 isso para 3 elementos -) <3
• para obter max ou min depende de: co.id < ci.id
  • co.id <ci.id - máx
  • co.id> ci.id - min

Exemplo completo aqui:

mysql seleciona n valores máximos por grupo