Uzyskaj rekordy o maksymalnej wartości dla każdej grupy zgrupowanych wyników SQL

Jak uzyskać wiersze zawierające maksymalną wartość dla każdego zgrupowanego zestawu?

Widziałem pewne zbyt skomplikowane warianty tego pytania i żadne z dobrą odpowiedzią. Próbowałem stworzyć najprostszy możliwy przykład:

Biorąc pod uwagę poniższą tabelę z kolumnami osoby, grupy i wieku, w jaki sposób uzyskasz najstarszą osobę w każdej grupie? (Remis w grupie powinien dać pierwszy wynik alfabetyczny)

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

Pożądany zestaw wyników:

Shawn | 1     | 42    
Laura | 2     | 39  

Jest bardzo prosty sposób, aby to zrobić w mysql:

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

Działa to, ponieważ w mysql nie można agregować kolumn nie grupujących według, w którym to przypadku mysql zwraca tylko pierwszy wiersz. Rozwiązaniem jest takie uporządkowanie danych, aby dla każdej grupy najpierw był wiersz, który chcesz, a następnie grupowanie według kolumn, dla których chcesz uzyskać wartość.

Unikasz skomplikowanych podzapytań, które próbują znaleźć max()itp., A także problemów ze zwracaniem wielu wierszy, gdy jest więcej niż jeden o tej samej wartości maksymalnej (tak jak zrobiłyby to inne odpowiedzi)

Uwaga: jest to rozwiązanie tylko dla MySQL . Wszystkie inne bazy danych, które znam, wyrzucą błąd składniowy SQL z komunikatem „kolumny nie zagregowane nie są wymienione w grupie według klauzul” lub podobne. Ponieważ to rozwiązanie wykorzystuje nieudokumentowane zachowanie, bardziej ostrożni mogą chcieć dołączyć test, aby stwierdzić, że nadal działa, jeśli przyszła wersja MySQL zmieni to zachowanie.

Aktualizacja wersji 5.7:

Od wersji 5.7 sql-modeustawienie zawiera ONLY_FULL_GROUP_BYdomyślnie, więc aby to zadziałało, nie możesz mieć tej opcji (edytuj plik opcji dla serwera, aby usunąć to ustawienie).

Prawidłowe rozwiązanie to:

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

Jak to działa:

Pasuje do każdego wiersza oze wszystkimi wierszami bo tej samej wartości w kolumnie Groupi większej wartości w kolumnie Age. Każdy wiersz, który onie ma maksymalnej wartości swojej grupy w kolumnie, Agebędzie pasował do jednego lub więcej wierszy z b.

LEFT JOINSprawia, że pasuje najstarszą osobą w grupie (w tym osoby, które są same w grupie) z rzędu pełnej NULLsz b( „bez największego wieku w grupie”).
Użycie INNER JOINpowoduje, że te wiersze nie pasują i są ignorowane.

WHEREKlauzula utrzymuje tylko wiersze o NULLsw pól wydobytych z b. Są to najstarsze osoby z każdej grupy.

Dalsze odczyty

To i wiele innych rozwiązań wyjaśniono w książce SQL Antipatterns: Unikanie pułapek programowania baz danych

Możesz dołączyć do podzapytania, które ściąga MAX(Group)i Age. Ta metoda jest przenośna w większości 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;

Moje proste rozwiązanie dla SQLite (i prawdopodobnie MySQL):

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

Jednak nie działa w PostgreSQL i może na niektórych innych platformach.

W PostgreSQL możesz użyć klauzuli DISTINCT ON :

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

Przy użyciu metody rankingu.

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

Nie jestem pewien, czy MySQL ma funkcję numer_wiersza. Jeśli tak, możesz go użyć, aby uzyskać pożądany rezultat. Na SQL Server możesz zrobić coś podobnego do:

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;

Ostatecznie rozwiązanie Axiac było dla mnie najlepsze. Miałem jednak dodatkową złożoność: obliczoną „wartość maksymalną”, uzyskaną z dwóch kolumn.

Użyjmy tego samego przykładu: chciałbym, aby najstarsza osoba w każdej grupie. Jeśli są ludzie w tym samym wieku, weź najwyższą osobę.

Musiałem wykonać lewe połączenie dwa razy, aby uzyskać takie zachowanie:

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;

Mam nadzieję że to pomoże! Myślę jednak, że powinien być lepszy sposób na zrobienie tego ...

Moje rozwiązanie działa tylko wtedy, gdy potrzebujesz pobrać tylko jedną kolumnę, jednak dla moich potrzeb było to najlepsze rozwiązanie znalezione pod względem wydajności (używa tylko jednego zapytania!):

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

Używa GROUP_CONCAT, aby utworzyć uporządkowaną listę konkat, a następnie podciąć tylko do pierwszej.

Mam proste rozwiązanie, używając 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

Korzystanie z CTE - typowe wyrażenia tabelowe:

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

W Oracle poniżej zapytanie może dać pożądany wynik.

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`

Możesz także spróbować

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

Nie użyłbym grupy jako nazwy kolumny, ponieważ jest to słowo zastrzeżone. Jednak następujące SQL działałoby.

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

Zaletą tej metody jest możliwość pozycjonowania według innej kolumny i nie niszczenie innych danych. Jest to bardzo przydatne w sytuacji, gdy próbujesz wyświetlić listę zamówień z kolumną zawierającą pozycje, na początku najcięższą.

Źródło: 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;

niech nazwa stołu to ludzie

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; 

Jeśli potrzebne jest ID (i wszystkie coulmns) z 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
    )

W ten sposób otrzymuję N maks wierszy na grupę w 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
;

jak to działa:

• samodzielnie dołączyć do stołu
• grupy są tworzone przez co.country = ci.country
• N elementów na grupę jest kontrolowanych przez ) < 1to dla 3 elementów -) <3
• uzyskanie maksymalnej lub minimalnej zależy od: co.id < ci.id
  • co.id <ci.id - max
  • co.id> ci.id - min

Pełny przykład tutaj:

mysql wybierz n maks. wartości na grupę