Ottieni record con valore massimo per ogni gruppo di risultati SQL raggruppati

Come si ottengono le righe che contengono il valore massimo per ciascun set raggruppato?

Ho visto alcune variazioni eccessivamente complicate su questa domanda, e nessuna con una buona risposta. Ho provato a mettere insieme l'esempio più semplice possibile:

Data una tabella come quella di seguito, con le colonne persona, gruppo ed età, come otterresti la persona più anziana in ciascun gruppo? (Un pareggio all'interno di un gruppo dovrebbe dare il primo risultato alfabetico)

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

Set di risultati desiderato:

Shawn | 1     | 42    
Laura | 2     | 39  

C'è un modo semplicissimo per farlo in mysql:

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

Questo funziona perché in mysql ti è permesso di non aggregare colonne non raggruppate, nel qual caso mysql restituisce solo la prima riga. La soluzione è prima ordinare i dati in modo tale che per ogni gruppo sia la prima riga desiderata, quindi raggruppare per le colonne per le quali si desidera il valore.

Si evitano complicate query secondarie che tentano di trovare max()ecc, nonché i problemi di restituzione di più righe quando ce ne sono più di una con lo stesso valore massimo (come farebbero le altre risposte)

Nota: questa è una soluzione solo per mysql . Tutti gli altri database che conosco genereranno un errore di sintassi SQL con il messaggio "le colonne non aggregate non sono elencate nel gruppo per clausola" o simili. Poiché questa soluzione utilizza un comportamento non documentato , più prudente potrebbe voler includere un test per affermare che rimane funzionante qualora una versione futura di MySQL cambi questo comportamento.

Aggiornamento versione 5.7:

Dalla versione 5.7, l' sql-modeimpostazione include ONLY_FULL_GROUP_BYdi default, quindi per fare questo lavoro è necessario non avere questa opzione (Modificare il file opzione per il server di rimuovere questa impostazione).

La soluzione corretta è:

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

Come funziona:

Corrisponde a ciascuna riga da ocon tutte le righe baventi lo stesso valore in colonna Groupe un valore maggiore in colonna Age. Qualsiasi riga da onon avere il valore massimo del suo gruppo nella colonna Agecorrisponderà a una o più righe da b.

Lo LEFT JOINfa abbinare la persona più anziana nel gruppo (comprese le persone che sono sole nel loro gruppo) con una fila piena di NULLs da b("nessuna maggiore età nel gruppo").
L'uso INNER JOINrende queste righe non corrispondenti e vengono ignorate.

La WHEREclausola mantiene solo le righe che hanno NULLs nei campi estratti b. Sono le persone più anziane di ogni gruppo.

Ulteriori letture

Questa soluzione e molte altre sono spiegate nel libro SQL Antipatterns: evitare le insidie ​​della programmazione di database

Puoi unirti a una subquery che tira il MAX(Group)e Age. Questo metodo è portatile nella maggior parte dei 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;

La mia semplice soluzione per SQLite (e probabilmente MySQL):

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

Tuttavia, non funziona in PostgreSQL e forse in altre piattaforme.

In PostgreSQL puoi usare la clausola DISTINCT ON :

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

Utilizzando il metodo di classificazione.

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

Non sono sicuro che MySQL abbia la funzione row_number. Se è così puoi usarlo per ottenere il risultato desiderato. Su SQL Server puoi fare qualcosa di simile a:

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 soluzione di axiac è ciò che ha funzionato meglio per me alla fine. Avevo comunque un'ulteriore complessità: un "valore massimo" calcolato, derivato da due colonne.

Usiamo lo stesso esempio: vorrei la persona più anziana in ciascun gruppo. Se ci sono persone ugualmente anziane, prendi la persona più alta.

Ho dovuto eseguire il join sinistro due volte per ottenere questo comportamento:

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;

Spero che questo ti aiuti! Immagino che dovrebbe esserci un modo migliore per farlo però ...

La mia soluzione funziona solo se è necessario recuperare solo una colonna, tuttavia per le mie esigenze è stata la migliore soluzione trovata in termini di prestazioni (utilizza solo una singola query!):

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

Usa GROUP_CONCAT per creare un elenco di concat ordinato e quindi sottostringa solo al primo.

Ho una soluzione semplice usando 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

Utilizzo di CTE - Espressioni di tabella comuni:

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 sotto query può dare il risultato desiderato.

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`

Puoi anche provare

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

Non userei Group come nome di colonna poiché è una parola riservata. Comunque seguire SQL funzionerebbe.

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

Questo metodo ha il vantaggio di permetterti di classificarti secondo una colonna diversa e di non eliminare gli altri dati. È abbastanza utile in una situazione in cui si sta tentando di elencare gli ordini con una colonna per gli articoli, elencando prima il più pesante.

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

lascia che il nome della tabella sia gente

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; 

Se è necessario un documento d'identità (e tutti i coulmns) da 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
    )

Ecco come sto ottenendo le N max righe per gruppo 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
;

come funziona:

• self join al tavolo
• i gruppi sono fatti da co.country = ci.country
• N elementi per gruppo sono controllati da ) < 1così per 3 elementi -) <3
• per ottenere il massimo o il minimo dipende da: co.id < ci.id
  • co.id <ci.id - max
  • co.id> ci.id - min

Esempio completo qui:

mysql seleziona n valori massimi per gruppo