Obtenga los mejores registros n para cada grupo de resultados agrupados

El siguiente es el ejemplo más simple posible, aunque cualquier solución debería poder escalar a la cantidad de n resultados necesarios:

Dada una tabla como la siguiente, con columnas de persona, grupo y edad, ¿cómo obtendría las 2 personas más viejas en cada grupo? (Los lazos dentro de los grupos no deberían arrojar más resultados, sino dar los 2 primeros en orden alfabético)

+ -------- + ------- + ----- +
El | Persona | Grupo | Edad |
+ -------- + ------- + ----- +
El | Bob | 1 | 32
El | Jill 1 | 34
El | Shawn 1 | 42 |
El | Jake 2 | 29 |
El | Paul | 2 | 36
El | Laura | 2 | 39
+ -------- + ------- + ----- +

Conjunto de resultados deseado:

+ -------- + ------- + ----- +
El | Shawn 1 | 42 |
El | Jill 1 | 34
El | Laura | 2 | 39
El | Paul | 2 | 36
+ -------- + ------- + ----- +

NOTA: Esta pregunta se basa en una anterior: obtenga registros con el valor máximo para cada grupo de resultados SQL agrupados , para obtener una sola fila superior de cada grupo y que recibió una gran respuesta específica de MySQL de @Bohemian:

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

Me encantaría poder construir a partir de esto, aunque no veo cómo.

Aquí hay una manera de hacer esto, usando UNION ALL(Ver SQL Fiddle with Demo ). Esto funciona con dos grupos, si tiene más de dos grupos, deberá especificar el groupnúmero y agregar consultas para cada uno group:

(
  select *
  from mytable 
  where `group` = 1
  order by age desc
  LIMIT 2
)
UNION ALL
(
  select *
  from mytable 
  where `group` = 2
  order by age desc
  LIMIT 2
)

Hay una variedad de formas de hacer esto, consulte este artículo para determinar la mejor ruta para su situación:

http://www.xaprb.com/blog/2006/12/07/how-to-select-the-firstleastmax-row-per-group-in-sql/

Editar:

Esto también podría funcionar para usted, genera un número de fila para cada registro. Usando un ejemplo del enlace de arriba, esto devolverá solo aquellos registros con un número de fila menor o igual a 2:

select person, `group`, age
from 
(
   select person, `group`, age,
      (@num:=if(@group = `group`, @num +1, if(@group := `group`, 1, 1))) row_number 
  from test t
  CROSS JOIN (select @num:=0, @group:=null) c
  order by `Group`, Age desc, person
) as x 
where x.row_number <= 2;

Ver demo

En otras bases de datos puedes hacer esto usando ROW_NUMBER. MySQL no es compatible, ROW_NUMBERpero puede usar variables para emularlo:

SELECT
    person,
    groupname,
    age
FROM
(
    SELECT
        person,
        groupname,
        age,
        @rn := IF(@prev = groupname, @rn + 1, 1) AS rn,
        @prev := groupname
    FROM mytable
    JOIN (SELECT @prev := NULL, @rn := 0) AS vars
    ORDER BY groupname, age DESC, person
) AS T1
WHERE rn <= 2

Véalo trabajando en línea: sqlfiddle

Editar Acabo de notar que bluefeet publicó una respuesta muy similar: +1 para él. Sin embargo, esta respuesta tiene dos pequeñas ventajas:

1. Es una sola consulta. Las variables se inicializan dentro de la instrucción SELECT.
2. Maneja los lazos como se describe en la pregunta (orden alfabético por nombre).

Así que lo dejaré aquí en caso de que pueda ayudar a alguien.

Prueba esto:

SELECT a.person, a.group, a.age FROM person AS a WHERE 
(SELECT COUNT(*) FROM person AS b 
WHERE b.group = a.group AND b.age >= a.age) <= 2 
ORDER BY a.group ASC, a.age DESC

MANIFESTACIÓN

¿Qué tal usar auto-unión:

CREATE TABLE mytable (person, groupname, age);
INSERT INTO mytable VALUES('Bob',1,32);
INSERT INTO mytable VALUES('Jill',1,34);
INSERT INTO mytable VALUES('Shawn',1,42);
INSERT INTO mytable VALUES('Jake',2,29);
INSERT INTO mytable VALUES('Paul',2,36);
INSERT INTO mytable VALUES('Laura',2,39);

SELECT a.* FROM mytable AS a
  LEFT JOIN mytable AS a2 
    ON a.groupname = a2.groupname AND a.age <= a2.age
GROUP BY a.person
HAVING COUNT(*) <= 2
ORDER BY a.groupname, a.age DESC;

me da

a.person    a.groupname  a.age     
----------  -----------  ----------
Shawn       1            42        
Jill        1            34        
Laura       2            39        
Paul        2            36      

La respuesta de Bill Karwin me inspiró fuertemente a Seleccionar los 10 mejores registros para cada categoría

Además, estoy usando SQLite, pero esto debería funcionar en MySQL.

Otra cosa: en lo anterior, reemplacé la groupcolumna con una groupnamecolumna por conveniencia.

Editar :

Después del comentario del OP con respecto a los resultados de empate faltantes, incrementé la respuesta del snuffin para mostrar todos los empates. Esto significa que si los últimos son empates, se pueden devolver más de 2 filas, como se muestra a continuación:

.headers on
.mode column

CREATE TABLE foo (person, groupname, age);
INSERT INTO foo VALUES('Paul',2,36);
INSERT INTO foo VALUES('Laura',2,39);
INSERT INTO foo VALUES('Joe',2,36);
INSERT INTO foo VALUES('Bob',1,32);
INSERT INTO foo VALUES('Jill',1,34);
INSERT INTO foo VALUES('Shawn',1,42);
INSERT INTO foo VALUES('Jake',2,29);
INSERT INTO foo VALUES('James',2,15);
INSERT INTO foo VALUES('Fred',1,12);
INSERT INTO foo VALUES('Chuck',3,112);


SELECT a.person, a.groupname, a.age 
FROM foo AS a 
WHERE a.age >= (SELECT MIN(b.age)
                FROM foo AS b 
                WHERE (SELECT COUNT(*)
                       FROM foo AS c
                       WHERE c.groupname = b.groupname AND c.age >= b.age) <= 2
                GROUP BY b.groupname)
ORDER BY a.groupname ASC, a.age DESC;

me da

person      groupname   age       
----------  ----------  ----------
Shawn       1           42        
Jill        1           34        
Laura       2           39        
Paul        2           36        
Joe         2           36        
Chuck       3           112      

La solución Snuffin parece bastante lenta de ejecutar cuando tienes muchas filas y las soluciones Mark Byers / Rick James y Bluefeet no funcionan en mi entorno (MySQL 5.6) porque el orden por se aplica después de la ejecución de select, así que aquí hay una variante de las soluciones de Marc Byers / Rick James para solucionar este problema (con una selección imbricada adicional):

select person, groupname, age
from
(
    select person, groupname, age,
    (@rn:=if(@prev = groupname, @rn +1, 1)) as rownumb,
    @prev:= groupname 
    from 
    (
        select person, groupname, age
        from persons 
        order by groupname ,  age desc, person
    )   as sortedlist
    JOIN (select @prev:=NULL, @rn :=0) as vars
) as groupedlist 
where rownumb<=2
order by groupname ,  age desc, person;

Intenté una consulta similar en una tabla que tiene 5 millones de filas y devuelve el resultado en menos de 3 segundos

Mira esto:

SELECT
  p.Person,
  p.`Group`,
  p.Age
FROM
  people p
  INNER JOIN
  (
    SELECT MAX(Age) AS Age, `Group` FROM people GROUP BY `Group`
    UNION
    SELECT MAX(p3.Age) AS Age, p3.`Group` FROM people p3 INNER JOIN (SELECT MAX(Age) AS Age, `Group` FROM people GROUP BY `Group`) p4 ON p3.Age < p4.Age AND p3.`Group` = p4.`Group` GROUP BY `Group`
  ) p2 ON p.Age = p2.Age AND p.`Group` = p2.`Group`
ORDER BY
  `Group`,
  Age DESC,
  Person;

Fiddle de SQL: http://sqlfiddle.com/#!2/cdbb6/15

Si las otras respuestas no son lo suficientemente rápidas Prueba este código :

SELECT
        province, n, city, population
    FROM
      ( SELECT  @prev := '', @n := 0 ) init
    JOIN
      ( SELECT  @n := if(province != @prev, 1, @n + 1) AS n,
                @prev := province,
                province, city, population
            FROM  Canada
            ORDER BY
                province   ASC,
                population DESC
      ) x
    WHERE  n <= 3
    ORDER BY  province, n;

Salida:

+---------------------------+------+------------------+------------+
| province                  | n    | city             | population |
+---------------------------+------+------------------+------------+
| Alberta                   |    1 | Calgary          |     968475 |
| Alberta                   |    2 | Edmonton         |     822319 |
| Alberta                   |    3 | Red Deer         |      73595 |
| British Columbia          |    1 | Vancouver        |    1837970 |
| British Columbia          |    2 | Victoria         |     289625 |
| British Columbia          |    3 | Abbotsford       |     151685 |
| Manitoba                  |    1 | ...

Quería compartir esto porque pasé mucho tiempo buscando una manera fácil de implementar esto en un programa Java en el que estoy trabajando. Esto no da la salida que estás buscando, pero está cerca. La función llamada mysql GROUP_CONCAT()funcionó muy bien para especificar cuántos resultados devolver en cada grupo. Usar LIMITo alguna de las otras formas elegantes de tratar de hacer esto COUNTno funcionó para mí. Entonces, si está dispuesto a aceptar una salida modificada, es una gran solución. Digamos que tengo una tabla llamada 'estudiante' con identificación de estudiante, su género y gpa. Digamos que quiero superar los 5 gpas para cada género. Entonces puedo escribir la consulta así

SELECT sex, SUBSTRING_INDEX(GROUP_CONCAT(cast(gpa AS char ) ORDER BY gpa desc), ',',5) 
AS subcategories FROM student GROUP BY sex;

Tenga en cuenta que el parámetro '5' le dice cuántas entradas concatenar en cada fila

Y la salida se vería algo así

+--------+----------------+
| Male   | 4,4,4,4,3.9    |
| Female | 4,4,3.9,3.9,3.8|
+--------+----------------+

También puede cambiar la ORDER BYvariable y ordenarlas de una manera diferente. Entonces, si tuviera la edad del estudiante, podría reemplazar el 'gpa desc' con 'age desc' y ¡funcionará! También puede agregar variables al grupo por declaración para obtener más columnas en la salida. Entonces, esta es solo una forma en que encontré que es bastante flexible y funciona bien si está de acuerdo con solo enumerar los resultados.

En SQL Server row_numer()es una función poderosa que puede obtener resultados fácilmente como a continuación

select Person,[group],age
from
(
select * ,row_number() over(partition by [group] order by age desc) rn
from mytable
) t
where rn <= 2

Hay una muy buena respuesta a este problema en MySQL: cómo obtener las mejores filas N por cada grupo

Según la solución en el enlace al que se hace referencia, su consulta sería como:

SELECT Person, Group, Age
   FROM
     (SELECT Person, Group, Age, 
                  @group_rank := IF(@group = Group, @group_rank + 1, 1) AS group_rank,
                  @current_group := Group 
       FROM `your_table`
       ORDER BY Group, Age DESC
     ) ranked
   WHERE group_rank <= `n`
   ORDER BY Group, Age DESC;

donde nesta el top nyyour_table es el nombre de tu mesa.

Creo que la explicación en la referencia es realmente clara. Para una referencia rápida, lo copiaré y pegaré aquí:

Actualmente MySQL no admite la función ROW_NUMBER () que puede asignar un número de secuencia dentro de un grupo, pero como solución alternativa podemos usar variables de sesión de MySQL.

Estas variables no requieren declaración, y pueden usarse en una consulta para hacer cálculos y almacenar resultados intermedios.

@current_country: = country Este código se ejecuta para cada fila y almacena el valor de la columna del país en la variable @current_country.

@country_rank: = IF (@current_country = country, @country_rank + 1, 1) En este código, si @current_country es el mismo, incrementamos el rango; de lo contrario, configúrelo en 1. Para la primera fila @current_country es NULL, por lo que el rango es también establecido en 1.

Para una clasificación correcta, necesitamos ORDENAR POR país, población DESC