Abrufen von Datensätzen mit maximalem Wert für jede Gruppe gruppierter SQL-Ergebnisse

Wie erhalten Sie die Zeilen, die den Maximalwert für jede gruppierte Menge enthalten?

Ich habe einige übermäßig komplizierte Variationen dieser Frage gesehen und keine mit einer guten Antwort. Ich habe versucht, ein möglichst einfaches Beispiel zusammenzustellen:

Wie würden Sie bei einer solchen Tabelle mit Spalten für Personen, Gruppen und Alter die älteste Person in jeder Gruppe erhalten? (Ein Gleichstand innerhalb einer Gruppe sollte das erste alphabetische Ergebnis liefern.)

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

Gewünschte Ergebnismenge:

Shawn | 1     | 42    
Laura | 2     | 39  

Es gibt eine supereinfache Möglichkeit, dies in MySQL zu tun:

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

Dies funktioniert, weil Sie in MySQL keine nicht gruppierten Spalten aggregieren dürfen. In diesem Fall gibt MySQL nur die erste Zeile zurück. Die Lösung besteht darin, zuerst die Daten so zu ordnen, dass für jede Gruppe zuerst die gewünschte Zeile und dann nach den Spalten gruppiert wird, für die Sie den Wert möchten.

Sie vermeiden komplizierte Unterabfragen, die versuchen, das max()usw. zu finden , und auch die Probleme, mehrere Zeilen zurückzugeben, wenn es mehr als eine mit demselben Maximalwert gibt (wie es die anderen Antworten tun würden).

Hinweis: Dies ist eine reine MySQL- Lösung. Alle anderen mir bekannten Datenbanken geben einen SQL-Syntaxfehler mit der Meldung "Nicht aggregierte Spalten werden nicht in der Gruppe nach Klausel aufgeführt" oder ähnlichem aus. Da diese Lösung undokumentiertes Verhalten verwendet, möchten die vorsichtigen möglicherweise einen Test einschließen, um zu bestätigen, dass sie weiterhin funktionieren, falls eine zukünftige Version von MySQL dieses Verhalten ändert.

Update Version 5.7:

Seit Version 5.7 enthält die sql-modeEinstellung ONLY_FULL_GROUP_BYstandardmäßig. Damit dies funktioniert, müssen Sie diese Option nicht haben (bearbeiten Sie die Optionsdatei für den Server, um diese Einstellung zu entfernen).

Die richtige Lösung ist:

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

Wie es funktioniert:

Es vergleicht jede Zeile omit allen Zeilen b, die denselben Wert in der Spalte Groupund einen größeren Wert in der Spalte haben Age. Jede Zeile, die onicht den Maximalwert ihrer Gruppe in der Spalte hat, Agestimmt mit einer oder mehreren Zeilen von überein b.

Das LEFT JOINmacht es die älteste Person in der Gruppe entspricht (die Personen umfasst , die allein in ihrer Gruppe sind) mit einer Reihe voller NULLs aus b( "no größten Alter in der Gruppe).
Durch INNER JOINdie Verwendung stimmen diese Zeilen nicht überein und werden ignoriert.

Die WHEREKlausel behält nur die Zeilen mit NULLs in den Feldern bei, aus denen extrahiert wurde b. Sie sind die ältesten Personen aus jeder Gruppe.

Weitere Lesungen

Diese und viele andere Lösungen werden im Buch SQL Antipatterns: Vermeiden der Fallstricke der Datenbankprogrammierung erläutert

Sie können sich einer Unterabfrage anschließen, die das MAX(Group)und zieht Age. Diese Methode ist auf die meisten RDBMS portierbar.

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;

Meine einfache Lösung für SQLite (und wahrscheinlich MySQL):

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

Es funktioniert jedoch nicht in PostgreSQL und möglicherweise auf einigen anderen Plattformen.

In PostgreSQL können Sie die DISTINCT ON- Klausel verwenden:

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

Ranking-Methode verwenden.

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

Ich bin mir nicht sicher, ob MySQL die Funktion row_number hat. In diesem Fall können Sie das gewünschte Ergebnis erzielen. Unter SQL Server können Sie Folgendes tun:

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;

Die Lösung von axiac hat am Ende für mich am besten funktioniert. Ich hatte jedoch eine zusätzliche Komplexität: einen berechneten "Maximalwert", abgeleitet aus zwei Spalten.

Verwenden wir das gleiche Beispiel: Ich möchte die älteste Person in jeder Gruppe. Wenn es Menschen gibt, die gleich alt sind, nehmen Sie die größte Person.

Ich musste den linken Join zweimal ausführen, um dieses Verhalten zu erhalten:

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;

Hoffe das hilft! Ich denke, es sollte einen besseren Weg geben, dies zu tun ...

Meine Lösung funktioniert nur, wenn Sie nur eine Spalte abrufen müssen. Für meine Anforderungen wurde jedoch die beste Lösung in Bezug auf die Leistung gefunden (es wird nur eine einzige Abfrage verwendet!):

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

Es wird GROUP_CONCAT verwendet, um eine geordnete Concat-Liste zu erstellen, und dann wird nur die erste Teilzeichenfolge erstellt.

Ich habe eine einfache Lösung mit 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

Verwenden von CTEs - Allgemeine Tabellenausdrücke:

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

In Oracle unten kann die Abfrage das gewünschte Ergebnis liefern.

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`

Sie können es auch versuchen

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

Ich würde Group nicht als Spaltennamen verwenden, da es sich um ein reserviertes Wort handelt. Das folgende SQL würde jedoch funktionieren.

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

Diese Methode bietet den Vorteil, dass Sie nach einer anderen Spalte sortieren und die anderen Daten nicht in den Papierkorb werfen können. Dies ist sehr nützlich in Situationen, in denen Sie versuchen, Bestellungen mit einer Spalte für Artikel aufzulisten, wobei die schwersten zuerst aufgelistet werden.

Quelle: http://dev.mysql.com/doc/refman/5.0/de/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;

Lass den Tabellennamen Menschen sein

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; 

Wenn ID (und alle Coulmns) von mytable benötigt wird

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
    )

Auf diese Weise erhalte ich die N max Zeilen pro Gruppe in 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
;

wie es funktioniert:

• selbst mit dem Tisch verbinden
• Gruppen werden von gemacht co.country = ci.country
• N Elemente pro Gruppe werden ) < 1so für 3 Elemente gesteuert -) <3
• Max oder Min zu bekommen hängt ab von: co.id < ci.id
  • co.id <ci.id - max
  • co.id> ci.id - min

Vollständiges Beispiel hier:

mysql wähle n max Werte pro Gruppe