Obtenga registros con el valor máximo para cada grupo de resultados SQL agrupados

¿Cómo se obtienen las filas que contienen el valor máximo para cada conjunto agrupado?

He visto algunas variaciones demasiado complicadas en esta pregunta, y ninguna con una buena respuesta. He tratado de armar el ejemplo más simple posible:

Dada una tabla como la siguiente, con columnas de persona, grupo y edad, ¿cómo obtendría la persona más vieja en cada grupo? (Un empate dentro de un grupo debe dar el primer 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 deseado:

Shawn | 1     | 42    
Laura | 2     | 39  

Hay una manera súper simple de hacer esto en mysql:

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

Esto funciona porque en mysql se le permite no agregar columnas que no sean de grupo, en cuyo caso mysql solo devuelve la primera fila. La solución es primero ordenar los datos de manera que para cada grupo la fila que desee sea primero, luego agrupe por las columnas para las que desea el valor.

Evita las subconsultas complicadas que intentan encontrar el max()etc., y también los problemas de devolver varias filas cuando hay más de una con el mismo valor máximo (como lo harían las otras respuestas)

Nota: Esta es una solución solo para mysql . Todas las demás bases de datos que conozco arrojarán un error de sintaxis SQL con el mensaje "las columnas no agregadas no se enumeran en el grupo por cláusula" o similar. Debido a que esta solución utiliza un comportamiento indocumentado , los más cautelosos pueden incluir una prueba para afirmar que sigue funcionando si una versión futura de MySQL cambia este comportamiento.

Actualización de la versión 5.7:

Desde la versión 5.7, la sql-modeconfiguración incluye ONLY_FULL_GROUP_BYpor defecto, por lo que para que esto funcione se debe no tener esta opción (editar el archivo de opciones del servidor para eliminar esta configuración).

La solución correcta es:

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

Cómo funciona:

Hace coincidir cada fila ocon todas las filas que btienen el mismo valor en la columna Groupy un valor mayor en la columna Age. Cualquier fila que ono tenga el valor máximo de su grupo en la columna Agecoincidirá con una o más filas de b.

Esto LEFT JOINhace que coincida con la persona de más edad en el grupo (incluidas las personas que están solas en su grupo) con una fila llena de NULLs de b('no hay mayor edad en el grupo').
El uso INNER JOINhace que estas filas no coincidan y se ignoran.

La WHEREcláusula mantiene solo las filas que tienen NULLs en los campos extraídos de b. Son las personas más viejas de cada grupo.

Lecturas adicionales

Esta solución y muchas otras se explican en el libro Antipatterns de SQL: cómo evitar las trampas de la programación de bases de datos.

Puede unirse contra una subconsulta que extrae el MAX(Group)y Age. Este método es portátil en la mayoría de los 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;

Mi solución simple para SQLite (y probablemente MySQL):

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

Sin embargo, no funciona en PostgreSQL y quizás en otras plataformas.

En PostgreSQL puede usar la cláusula DISTINCT ON :

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

Usando el método de clasificación.

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

No estoy seguro si MySQL tiene la función row_number. Si es así, puede usarlo para obtener el resultado deseado. En SQL Server puede hacer algo similar 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;

La solución de axiac es lo que mejor me funcionó al final. Sin embargo, tenía una complejidad adicional: un "valor máximo" calculado, derivado de dos columnas.

Usemos el mismo ejemplo: me gustaría la persona de más edad en cada grupo. Si hay personas que son igualmente viejas, tome la persona más alta.

Tuve que realizar la unión izquierda dos veces para obtener este comportamiento:

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 esto ayude! Sin embargo, creo que debería haber una mejor manera de hacer esto ...

Mi solución funciona solo si necesita recuperar solo una columna, sin embargo, para mis necesidades, fue la mejor solución encontrada en términos de rendimiento (¡usa solo una consulta!):

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

Utiliza GROUP_CONCAT para crear una lista de concat ordenada y luego subcadena solo a la primera.

Tengo una solución simple 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

Uso de CTE: expresiones de tabla comunes:

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

En Oracle a continuación, la consulta puede dar el resultado deseado.

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`

También puedes probar

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

No usaría Grupo como nombre de columna ya que es una palabra reservada. Sin embargo, seguir SQL funcionaría.

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

Este método tiene la ventaja de permitirle clasificar por una columna diferente y no destruir los otros datos. Es bastante útil en una situación en la que intenta enumerar pedidos con una columna para artículos, enumerando primero los más pesados.

Fuente: 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;

deja que el nombre de la mesa sea gente

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; 

Si se necesita ID (y todas las coulmns) de 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
    )

Así es como obtengo las N filas máximas por grupo en 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
;

cómo funciona:

• auto unirse a la mesa
• los grupos son realizados por co.country = ci.country
• N elementos por grupo están controlados por ) < 13 elementos -) <3
• obtener max o min depende de: co.id < ci.id
  • co.id <ci.id - max
  • co.id> ci.id - min

Ejemplo completo aquí:

mysql selecciona n valores máximos por grupo