Obtenez des enregistrements avec une valeur maximale pour chaque groupe de résultats SQL groupés

Comment obtenez-vous les lignes qui contiennent la valeur maximale pour chaque ensemble groupé?

J'ai vu des variations trop compliquées sur cette question, et aucune avec une bonne réponse. J'ai essayé de rassembler l'exemple le plus simple possible:

Étant donné un tableau comme celui-ci ci-dessous, avec les colonnes personne, groupe et âge, comment obtiendriez-vous la personne la plus âgée dans chaque groupe? (Une égalité au sein d'un groupe devrait donner le premier résultat alphabétique)

Person | Group | 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    
Laura | 2     | 39  

Il y a un moyen super simple de le faire dans mysql:

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

Cela fonctionne parce que dans mysql, vous êtes autorisé à ne pas agréger les colonnes non groupées, auquel cas mysql renvoie simplement la première ligne. La solution consiste à d'abord classer les données de telle sorte que pour chaque groupe, la ligne souhaitée soit la première, puis à regrouper en fonction des colonnes pour lesquelles vous souhaitez obtenir la valeur.

Vous évitez les sous-requêtes compliquées qui tentent de trouver max()etc., ainsi que les problèmes de renvoi de plusieurs lignes lorsqu'il y en a plusieurs avec la même valeur maximale (comme le feraient les autres réponses)

Remarque: il s'agit d'une solution réservée à mysql . Toutes les autres bases de données que je connais lèveront une erreur de syntaxe SQL avec le message "les colonnes non agrégées ne sont pas répertoriées dans la clause group by" ou similaire. Parce que cette solution utilise sans papier comportement, plus prudent peut vouloir inclure un test pour affirmer qu'il reste à travailler si une version future de MySQL changer ce comportement.

Mise à jour de la version 5.7:

Depuis la version 5.7, le sql-modeparamètre inclut ONLY_FULL_GROUP_BYpar défaut, donc pour que cela fonctionne, vous ne devez pas avoir cette option (modifiez le fichier d'options du serveur pour supprimer ce paramètre).

La bonne solution est:

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

Comment ça fonctionne:

Il fait correspondre chaque ligne de oavec toutes les lignes bayant la même valeur dans la colonne Groupet une plus grande valeur dans la colonne Age. Toute ligne one contenant pas la valeur maximale de son groupe dans la colonne Agecorrespondra à une ou plusieurs lignes de b.

Le LEFT JOINfait correspondre la personne la plus âgée du groupe (y compris les personnes seules dans leur groupe) avec une rangée pleine de NULLs de b(«pas de plus grand âge dans le groupe»).
L'utilisation INNER JOINrend ces lignes non identiques et elles sont ignorées.

La WHEREclause ne conserve que les lignes ayant NULLs dans les champs extraits de b. Ce sont les personnes les plus âgées de chaque groupe.

Lectures complémentaires

Cette solution et bien d'autres sont expliquées dans le livre SQL Antipatterns: éviter les pièges de la programmation de base de données

Vous pouvez vous joindre à une sous-requête qui tire le MAX(Group)et Age. Cette méthode est portable sur la plupart des SGBDR.

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;

Ma solution simple pour SQLite (et probablement MySQL):

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

Cependant, cela ne fonctionne pas dans PostgreSQL et peut-être sur d'autres plateformes.

Dans PostgreSQL, vous pouvez utiliser la clause DISTINCT ON :

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

Utilisation de la méthode de classement.

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

Je ne sais pas si MySQL a la fonction row_number. Si c'est le cas, vous pouvez l'utiliser pour obtenir le résultat souhaité. Sur SQL Server, vous pouvez faire quelque chose de similaire à:

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 solution d'Axiac est finalement celle qui a le mieux fonctionné pour moi. J'avais cependant une complexité supplémentaire: une "valeur max" calculée, dérivée de deux colonnes.

Prenons le même exemple: je voudrais la personne la plus âgée de chaque groupe. S'il y a des gens qui sont tout aussi âgés, prenez la personne la plus grande.

J'ai dû effectuer la jointure gauche deux fois pour obtenir ce comportement:

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;

J'espère que cela t'aides! Je suppose qu'il devrait y avoir une meilleure façon de le faire ...

Ma solution ne fonctionne que si vous avez besoin de récupérer une seule colonne, mais pour mes besoins était la meilleure solution trouvée en termes de performances (elle n'utilise qu'une seule requête!):

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

Il utilise GROUP_CONCAT afin de créer une liste de concaturation ordonnée puis je sous-chaîne à la première seulement.

J'ai une solution simple en utilisant 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

Utilisation des CTE - Expressions de table communes:

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

Dans Oracle ci-dessous, la requête peut donner le résultat souhaité.

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`

Vous pouvez aussi essayer

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

Je n'utiliserais pas Group comme nom de colonne car c'est un mot réservé. Cependant, suivre SQL fonctionnerait.

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

Cette méthode a l'avantage de vous permettre de classer par une colonne différente et de ne pas jeter les autres données. C'est très utile dans une situation où vous essayez de répertorier les commandes avec une colonne d'articles, en répertoriant les plus lourdes en premier.

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

que le nom de la table soit des personnes

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 l'ID (et tous les coulmns) est nécessaire à partir 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
    )

Voici comment j'obtiens les N max lignes par groupe dans 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
;

Comment ça fonctionne:

• se joindre à la table
• les groupes se font par co.country = ci.country
• N éléments par groupe sont contrôlés par ) < 1 donc pour 3 éléments -) <3
• pour obtenir max ou min dépend de: co.id < ci.id
  • co.id <ci.id - max
  • co.id> ci.id - min

Exemple complet ici:

mysql sélectionner n valeurs max par groupe