Obtenez les n premiers enregistrements pour chaque groupe de résultats groupés

L'exemple suivant est le plus simple possible, même si toute solution doit être capable de s'adapter au nombre de n résultats supérieurs nécessaires:

Étant donné un tableau comme celui-ci ci-dessous, avec des colonnes de personne, de groupe et d'âge, comment obtiendriez-vous les 2 personnes les plus âgées de chaque groupe? (Les égalités au sein des groupes ne devraient pas donner plus de résultats, mais donner les 2 premiers par ordre alphabétique)

+ -------- + ------- + ----- +
| Personne | Groupe | Age |
+ -------- + ------- + ----- +
| Bob | 1 | 32 |
| Jill | 1 | 34 |
| Shawn | 1 | 42 |
| Jake | 2 | 29 |
| Paul | 2 | 36 |
| Laura | 2 | 39 |
+ -------- + ------- + ----- +

Ensemble de résultats souhaité:

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

REMARQUE: Cette question s'appuie sur une précédente - Obtenir des enregistrements avec une valeur maximale pour chaque groupe de résultats SQL groupés - pour obtenir une seule ligne supérieure de chaque groupe, et qui a reçu une excellente réponse spécifique à MySQL de @Bohemian:

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

J'adorerais pouvoir développer cela, même si je ne vois pas comment.

Voici une façon de le faire, en utilisant UNION ALL(Voir SQL Fiddle avec Démo ). Cela fonctionne avec deux groupes, si vous avez plus de deux groupes, vous devez spécifier le groupnombre et ajouter des requêtes pour chacun 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
)

Il existe différentes façons de procéder, consultez cet article pour déterminer le meilleur itinéraire pour votre situation:

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

Éditer:

Cela peut également fonctionner pour vous, cela génère un numéro de ligne pour chaque enregistrement. En utilisant un exemple du lien ci-dessus, cela ne retournera que les enregistrements avec un numéro de ligne inférieur ou égal à 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;

Voir la démo

Dans d'autres bases de données, vous pouvez le faire en utilisant ROW_NUMBER. MySQL ne prend pas en charge ROW_NUMBERmais vous pouvez utiliser des variables pour l'émuler:

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

Le voir fonctionner en ligne: sqlfiddle

Edit Je viens de remarquer que bluefeet a publié une réponse très similaire: +1 pour lui. Cependant cette réponse présente deux petits avantages:

1. C'est une seule requête. Les variables sont initialisées dans l'instruction SELECT.
2. Il gère les cravates comme décrit dans la question (ordre alphabétique par nom).

Je vais donc le laisser ici au cas où cela pourrait aider quelqu'un.

Essaye ça:

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

DEMO

Que diriez-vous d'utiliser l'auto-adhésion:

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;

Donne moi:

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

J'ai été fortement inspiré par la réponse de Bill Karwin à sélectionner les 10 meilleurs disques pour chaque catégorie

De plus, j'utilise SQLite, mais cela devrait fonctionner sur MySQL.

Autre chose: dans ce qui précède, j'ai remplacé la groupcolonne par une groupnamecolonne pour plus de commodité.

Modifier :

Suite au commentaire du PO concernant les résultats de cravates manquants, j'ai augmenté la réponse de Snuffin pour montrer toutes les cravates. Cela signifie que si les derniers sont des égalités, plus de 2 lignes peuvent être renvoyées, comme indiqué ci-dessous:

.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;

Donne moi:

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

La solution Snuffin semble assez lente à exécuter lorsque vous avez beaucoup de lignes et que les solutions Mark Byers / Rick James et Bluefeet ne fonctionnent pas sur mon environnement (MySQL 5.6) car order by est appliqué après l'exécution de select, voici donc une variante des solutions Marc Byers / Rick James pour résoudre ce problème (avec une sélection imbriquée supplémentaire):

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;

J'ai essayé une requête similaire sur une table ayant 5 millions de lignes et elle renvoie le résultat en moins de 3 secondes

Regarde ça:

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;

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

Si les autres réponses ne sont pas assez rapides, essayez ce code :

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;

Production:

+---------------------------+------+------------------+------------+
| 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 | ...

Je voulais partager cela parce que j'ai passé beaucoup de temps à chercher un moyen simple de l'implémenter dans un programme java sur lequel je travaille. Cela ne donne pas tout à fait la sortie que vous recherchez, mais c'est proche. La fonction appelée dans mysql GROUP_CONCAT()fonctionnait très bien pour spécifier le nombre de résultats à renvoyer dans chaque groupe. Utiliser LIMITou l'une des autres façons sophistiquées d'essayer de faire cela COUNTne fonctionnait pas pour moi. Donc, si vous êtes prêt à accepter une sortie modifiée, c'est une excellente solution. Disons que j'ai une table appelée «étudiant» avec les identifiants des étudiants, leur sexe et gpa. Disons que je veux top 5 gpas pour chaque sexe. Ensuite, je peux écrire la requête comme ceci

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

Notez que le paramètre '5' lui indique le nombre d'entrées à concaténer dans chaque ligne

Et la sortie ressemblerait à quelque chose comme

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

Vous pouvez également modifier la ORDER BYvariable et les ordonner d'une manière différente. Donc, si j'avais l'âge de l'élève, je pourrais remplacer le «gpa desc» par «age desc» et cela fonctionnera! Vous pouvez également ajouter des variables à l'instruction group by pour obtenir plus de colonnes dans la sortie. C'est donc juste une façon que j'ai trouvée qui est assez flexible et fonctionne bien si vous êtes d'accord avec la simple liste des résultats.

Dans SQL Server row_numer()est une fonction puissante qui peut obtenir le résultat facilement comme ci-dessous

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

Il y a une très bonne réponse à ce problème chez MySQL - Comment obtenir les N premières lignes par chaque groupe

Sur la base de la solution dans le lien référencé, votre requête serait comme:

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;

où nest le top net your_tableest le nom de votre table.

Je pense que l'explication dans la référence est vraiment claire. Pour une référence rapide, je vais le copier et le coller ici:

Actuellement MySQL ne prend pas en charge la fonction ROW_NUMBER () qui peut attribuer un numéro de séquence dans un groupe, mais comme solution de contournement, nous pouvons utiliser des variables de session MySQL.

Ces variables ne nécessitent pas de déclaration et peuvent être utilisées dans une requête pour effectuer des calculs et stocker des résultats intermédiaires.

@current_country: = country Ce code est exécuté pour chaque ligne et stocke la valeur de la colonne country dans la variable @current_country.

@country_rank: = IF (@current_country = country, @country_rank + 1, 1) Dans ce code, si @current_country est le même, nous incrémentons le rang, sinon définissez-le sur 1. Pour la première ligne, @current_country est NULL, donc le rang est également mis à 1.

Pour un classement correct, nous devons avoir ORDER BY pays, population DESC