Wie der Titel schon sagt, möchte ich die erste Zeile jeder Reihe von Zeilen auswählen, die mit a gruppiert sind GROUP BY.

Insbesondere, wenn ich eine purchasesTabelle habe, die so aussieht:

SELECT * FROM purchases;

Mein Output:

id | Kunde | gesamt
--- + ---------- + ------
 1 | Joe | 5
 2 | Sally | 3
 3 | Joe | 2
 4 | Sally | 1

Ich möchte nach iddem größten Kauf ( total) fragen, den jeder getätigt hat customer. Etwas wie das:

SELECT FIRST(id), customer, FIRST(total)
FROM  purchases
GROUP BY customer
ORDER BY total DESC;

Erwartete Ausgabe:

ERSTE (id) | Kunde | ERSTE (insgesamt)
---------- + ---------- + -------------
        1 | Joe | 5
        2 | Sally | 3

Unter Oracle 9.2+ (nicht 8i + wie ursprünglich angegeben), SQL Server 2005+, PostgreSQL 8.4+, DB2, Firebird 3.0+, Teradata, Sybase, Vertica:

WITH summary AS (
    SELECT p.id, 
           p.customer, 
           p.total, 
           ROW_NUMBER() OVER(PARTITION BY p.customer 
                                 ORDER BY p.total DESC) AS rk
      FROM PURCHASES p)
SELECT s.*
  FROM summary s
 WHERE s.rk = 1

Unterstützt von jeder Datenbank:

Aber Sie müssen Logik hinzufügen, um Bindungen zu lösen:

  SELECT MIN(x.id),  -- change to MAX if you want the highest
         x.customer, 
         x.total
    FROM PURCHASES x
    JOIN (SELECT p.customer,
                 MAX(total) AS max_total
            FROM PURCHASES p
        GROUP BY p.customer) y ON y.customer = x.customer
                              AND y.max_total = x.total
GROUP BY x.customer, x.total

In PostgreSQL ist dies normalerweise einfacher und schneller (weitere Leistungsoptimierung siehe unten):

SELECT DISTINCT ON (customer)
       id, customer, total
FROM   purchases
ORDER  BY customer, total DESC, id;

Oder kürzer (wenn nicht so klar) mit Ordnungszahlen der Ausgabespalten:

SELECT DISTINCT ON (2)
       id, customer, total
FROM   purchases
ORDER  BY 2, 3 DESC, 1;

Wenn totalkann NULL sein (wird in beiden Fällen nicht schaden, aber Sie möchten vorhandene Indizes abgleichen ):

...
ORDER  BY customer, total DESC NULLS LAST, id;

Hauptpunkte

• DISTINCT ONist eine PostgreSQL-Erweiterung des Standards (wobei nur DISTINCTdie gesamte SELECTListe definiert ist).

• Listen Sie eine beliebige Anzahl von Ausdrücken in der DISTINCT ONKlausel auf. Der kombinierte Zeilenwert definiert Duplikate. Das Handbuch:

  Offensichtlich werden zwei Zeilen als unterschiedlich betrachtet, wenn sie sich in mindestens einem Spaltenwert unterscheiden. Nullwerte werden in diesem Vergleich als gleich angesehen.

  Meine kühne Betonung.

• DISTINCT ONkann mit kombiniert werden ORDER BY. Führende Ausdrücke in ORDER BYmüssen in der Menge der Ausdrücke in enthalten sein DISTINCT ON, aber Sie können die Reihenfolge zwischen diesen frei ändern. Beispiel. Sie können zusätzliche Ausdrücke hinzufügen ORDER BY, um eine bestimmte Zeile aus jeder Gruppe von Peers auszuwählen. Oder, wie es im Handbuch heißt :

  Die DISTINCT ONAusdrücke müssen mit den ORDER BY Ausdrücken ganz links übereinstimmen . Die ORDER BYKlausel enthält normalerweise zusätzliche Ausdrücke, die die gewünschte Priorität von Zeilen innerhalb jeder DISTINCT ONGruppe bestimmen .

  Ich habe idals letzten Punkt hinzugefügt , um die Verbindung zu lösen:
  "Wählen Sie die Zeile mit der kleinsten idaus jeder Gruppe, die die höchste teilt total."

  Um die Ergebnisse so zu ordnen, dass sie nicht mit der Sortierreihenfolge übereinstimmen, die die erste pro Gruppe bestimmt, können Sie die obige Abfrage in einer äußeren Abfrage mit einer anderen verschachteln ORDER BY. Beispiel.

• Wenn totalNULL sein kann, möchten Sie höchstwahrscheinlich die Zeile mit dem größten Wert ungleich Null. Fügen Sie NULLS LASTwie gezeigt hinzu. Sehen:

  • PostgreSQL nach Datum / Uhrzeit sortieren asc, null zuerst?

• Die SELECTListe ist nicht durch Ausdrücke in eingeschränkt DISTINCT ONoder ORDER BYin irgendeiner Weise. (Wird im obigen einfachen Fall nicht benötigt):

  • Sie müssen keinen der Ausdrücke in DISTINCT ONoder einfügen ORDER BY.

  • Sie können jeden anderen Ausdruck in die SELECTListe aufnehmen. Dies ist hilfreich, um viel komplexere Abfragen durch Unterabfragen und Aggregat- / Fensterfunktionen zu ersetzen.

• Ich habe mit Postgres-Versionen 8.3 - 12 getestet. Aber die Funktion ist mindestens seit Version 7.1 vorhanden, also im Grunde immer.

Index

Der perfekte Index für die obige Abfrage wäre ein mehrspaltiger Index , der alle drei Spalten in übereinstimmender Reihenfolge und mit übereinstimmender Sortierreihenfolge umfasst:

CREATE INDEX purchases_3c_idx ON purchases (customer, total DESC, id);

Kann zu spezialisiert sein. Verwenden Sie es jedoch, wenn die Leseleistung für die jeweilige Abfrage von entscheidender Bedeutung ist. Wenn Sie DESC NULLS LASTin der Abfrage haben, verwenden Sie dasselbe im Index, damit die Sortierreihenfolge übereinstimmt und der Index anwendbar ist.

Effektivität / Leistungsoptimierung

Wägen Sie Kosten und Nutzen ab, bevor Sie für jede Abfrage maßgeschneiderte Indizes erstellen. Das Potenzial des obigen Index hängt weitgehend von der Datenverteilung ab .

Der Index wird verwendet, weil er vorsortierte Daten liefert. In Postgres 9.2 oder höher kann die Abfrage auch nur dann von einem Index-Scan profitieren, wenn der Index kleiner als die zugrunde liegende Tabelle ist. Der Index muss jedoch vollständig gescannt werden.

• Für wenige Zeilen pro Kunde (hohe Kardinalität in der Spalte customer) ist dies sehr effizient. Dies gilt umso mehr, wenn Sie ohnehin eine sortierte Ausgabe benötigen. Der Nutzen verringert sich mit einer wachsenden Anzahl von Zeilen pro Kunde.
  Im Idealfall haben Sie genug Zeit work_mem, um den beteiligten Sortierschritt im RAM zu verarbeiten und nicht auf die Festplatte zu übertragen. Im Allgemeinen kann eine work_mem zu hohe Einstellung jedoch nachteilige Auswirkungen haben. Berücksichtigen Sie SET LOCALaußergewöhnlich große Abfragen. Finden Sie heraus, wie viel Sie brauchen EXPLAIN ANALYZE. Die Erwähnung von " Disk: " im Sortierschritt weist auf die Notwendigkeit von mehr hin:

  • Konfigurationsparameter work_mem in PostgreSQL unter Linux
  • Optimieren Sie die einfache Abfrage mithilfe von ORDER BY-Datum und -Text

• Für viele Zeilen pro Kunde (geringe Kardinalität in der Spalte customer) wäre ein loser Index-Scan (auch als "Skip-Scan" bezeichnet) (viel) effizienter, dies ist jedoch bis Postgres 12 nicht implementiert. (Eine Implementierung für Nur-Index-Scans ist in Entwicklung für Postgres 13. Siehe hier und hier .)
  Derzeit gibt es schnellere Abfragetechniken , um dies zu ersetzen. Insbesondere, wenn Sie einen separaten Tisch mit eindeutigen Kunden haben, was der typische Anwendungsfall ist. Aber auch wenn Sie nicht:

  • Optimieren Sie die GROUP BY-Abfrage, um die neueste Zeile pro Benutzer abzurufen
  • Optimieren Sie die gruppenweise maximale Abfrage
  • Fragen Sie die letzten N verwandten Zeilen pro Zeile ab

Benchmark

Ich hatte hier einen einfachen Benchmark, der mittlerweile veraltet ist. Ich habe es in dieser separaten Antwort durch einen detaillierten Benchmark ersetzt .

Benchmark

Testen der interessantesten Kandidaten mit Postgres 9.4 und 9.5 mit einer halbwegs realistischen Tabelle von 200.000 Zeilen in purchasesund 10.000 unterschiedlichencustomer_id ( durchschnittlich 20 Zeilen pro Kunde ).

Für Postgres 9.5 habe ich einen zweiten Test mit effektiv 86446 verschiedenen Kunden durchgeführt. Siehe unten ( durchschnittlich 2,3 Zeilen pro Kunde ).

Installieren

Haupttisch

CREATE TABLE purchases (
  id          serial
, customer_id int  -- REFERENCES customer
, total       int  -- could be amount of money in Cent
, some_column text -- to make the row bigger, more realistic
);

Ich verwende eine serial(PK-Einschränkung unten hinzugefügt) und eine Ganzzahl, customer_idda dies ein typischeres Setup ist. Wird auch hinzugefügt some_column, um normalerweise mehr Spalten auszugleichen.

Dummy-Daten, PK, Index - eine typische Tabelle enthält auch einige tote Tupel:

INSERT INTO purchases (customer_id, total, some_column)    -- insert 200k rows
SELECT (random() * 10000)::int             AS customer_id  -- 10k customers
     , (random() * random() * 100000)::int AS total     
     , 'note: ' || repeat('x', (random()^2 * random() * random() * 500)::int)
FROM   generate_series(1,200000) g;

ALTER TABLE purchases ADD CONSTRAINT purchases_id_pkey PRIMARY KEY (id);

DELETE FROM purchases WHERE random() > 0.9; -- some dead rows

INSERT INTO purchases (customer_id, total, some_column)
SELECT (random() * 10000)::int             AS customer_id  -- 10k customers
     , (random() * random() * 100000)::int AS total     
     , 'note: ' || repeat('x', (random()^2 * random() * random() * 500)::int)
FROM   generate_series(1,20000) g;  -- add 20k to make it ~ 200k

CREATE INDEX purchases_3c_idx ON purchases (customer_id, total DESC, id);

VACUUM ANALYZE purchases;

customer Tabelle - für übergeordnete Abfrage

CREATE TABLE customer AS
SELECT customer_id, 'customer_' || customer_id AS customer
FROM   purchases
GROUP  BY 1
ORDER  BY 1;

ALTER TABLE customer ADD CONSTRAINT customer_customer_id_pkey PRIMARY KEY (customer_id);

VACUUM ANALYZE customer;

In meinem zweiten Test für 9.5 habe ich das gleiche Setup verwendet, aber mit random() * 100000zu generieren customer_id, um nur wenige Zeilen pro zu erhalten customer_id.

Objektgrößen für Tabelle purchases

Mit dieser Abfrage generiert .

               what                | bytes/ct | bytes_pretty | bytes_per_row
-----------------------------------+----------+--------------+---------------
 core_relation_size                | 20496384 | 20 MB        |           102
 visibility_map                    |        0 | 0 bytes      |             0
 free_space_map                    |    24576 | 24 kB        |             0
 table_size_incl_toast             | 20529152 | 20 MB        |           102
 indexes_size                      | 10977280 | 10 MB        |            54
 total_size_incl_toast_and_indexes | 31506432 | 30 MB        |           157
 live_rows_in_text_representation  | 13729802 | 13 MB        |            68
 ------------------------------    |          |              |
 row_count                         |   200045 |              |
 live_tuples                       |   200045 |              |
 dead_tuples                       |    19955 |              |

Abfragen

1. row_number()in CTE ( siehe andere Antwort )

WITH cte AS (
   SELECT id, customer_id, total
        , row_number() OVER(PARTITION BY customer_id ORDER BY total DESC) AS rn
   FROM   purchases
   )
SELECT id, customer_id, total
FROM   cte
WHERE  rn = 1;

2. row_number()in Unterabfrage (meine Optimierung)

SELECT id, customer_id, total
FROM   (
   SELECT id, customer_id, total
        , row_number() OVER(PARTITION BY customer_id ORDER BY total DESC) AS rn
   FROM   purchases
   ) sub
WHERE  rn = 1;

3. DISTINCT ON( siehe andere Antwort )

SELECT DISTINCT ON (customer_id)
       id, customer_id, total
FROM   purchases
ORDER  BY customer_id, total DESC, id;

4. rCTE mit LATERALUnterabfrage ( siehe hier )

WITH RECURSIVE cte AS (
   (  -- parentheses required
   SELECT id, customer_id, total
   FROM   purchases
   ORDER  BY customer_id, total DESC
   LIMIT  1
   )
   UNION ALL
   SELECT u.*
   FROM   cte c
   ,      LATERAL (
      SELECT id, customer_id, total
      FROM   purchases
      WHERE  customer_id > c.customer_id  -- lateral reference
      ORDER  BY customer_id, total DESC
      LIMIT  1
      ) u
   )
SELECT id, customer_id, total
FROM   cte
ORDER  BY customer_id;

5. customerTabelle mit LATERAL( siehe hier )

SELECT l.*
FROM   customer c
,      LATERAL (
   SELECT id, customer_id, total
   FROM   purchases
   WHERE  customer_id = c.customer_id  -- lateral reference
   ORDER  BY total DESC
   LIMIT  1
   ) l;

6. array_agg()mit ORDER BY( siehe andere Antwort )

SELECT (array_agg(id ORDER BY total DESC))[1] AS id
     , customer_id
     , max(total) AS total
FROM   purchases
GROUP  BY customer_id;

Ergebnisse

Ausführungszeit für die oben genannten Abfragen mit EXPLAIN ANALYZE(und allen Optionen deaktiviert ), am besten aus 5 Läufen .

Alle Abfragen verwendeten eine Nur - Indexsuche auf purchases2_3c_idx(unter anderen Stufen). Einige von ihnen nur für die kleinere Größe des Index, andere effektiver.

A. Postgres 9.4 mit 200k Reihen und ~ 20 pro customer_id

1. 273.274 ms  
2. 194.572 ms  
3. 111.067 ms  
4.  92.922 ms  
5.  37.679 ms  -- winner
6. 189.495 ms

B. Das gleiche gilt für Postgres 9.5

1. 288.006 ms
2. 223.032 ms  
3. 107.074 ms  
4.  78.032 ms  
5.  33.944 ms  -- winner
6. 211.540 ms  

C. Wie B., jedoch mit ~ 2,3 Zeilen pro customer_id

1. 381.573 ms
2. 311.976 ms
3. 124.074 ms  -- winner
4. 710.631 ms
5. 311.976 ms
6. 421.679 ms

Verwandte Benchmarks

Hier ist ein neuer Test von "ogr" mit 10 Millionen Zeilen und 60.000 einzigartigen "Kunden" auf Postgres 11.5 (Stand: September 2019). Die Ergebnisse stimmen immer noch mit dem überein, was wir bisher gesehen haben:

• Richtige Möglichkeit, für jede einzelne Kennung auf die neueste Zeile zuzugreifen?

Ursprünglicher (veralteter) Benchmark von 2011

Ich habe drei Tests mit PostgreSQL 9.1 in einer realen Tabelle mit 65579 Zeilen und einspaltigen btree-Indizes für jede der drei beteiligten Spalten durchgeführt und die beste Ausführungszeit von 5 Läufen genommen.
Vergleich der ersten Abfrage ( A) von @OMGPonies mit der obigen DISTINCT ONLösung ( B):

1. Wählen Sie die gesamte Tabelle aus. In diesem Fall werden 5958 Zeilen angezeigt.

   A: 567.218 ms
   B: 386.673 ms
   

2. Verwenden Sie die Bedingung, WHERE customer BETWEEN x AND ydie zu 1000 Zeilen führt.

   A: 249.136 ms
   B:  55.111 ms
   

3. Wählen Sie einen einzelnen Kunden mit WHERE customer = x.

   A:   0.143 ms
   B:   0.072 ms
   

Der gleiche Test wurde mit dem in der anderen Antwort beschriebenen Index wiederholt

CREATE INDEX purchases_3c_idx ON purchases (customer, total DESC, id);

1A: 277.953 ms  
1B: 193.547 ms

2A: 249.796 ms -- special index not used  
2B:  28.679 ms

3A:   0.120 ms  
3B:   0.048 ms

Das ist üblich Größte-n-pro-GruppeProblem, das bereits gut getestete und hochoptimierte Lösungen hat . Persönlich bevorzuge ich die Left Join-Lösung von Bill Karwin (der ursprüngliche Beitrag mit vielen anderen Lösungen ).

Beachten Sie, dass eine Reihe von Lösungen für dieses häufig auftretende Problem überraschenderweise in einer der offiziellsten Quellen, dem MySQL-Handbuch, zu finden sind ! Siehe Beispiele für häufig verwendete Abfragen: Die Zeilen, die das gruppenweise Maximum einer bestimmten Spalte enthalten .

In Postgres können Sie Folgendes verwenden array_agg:

SELECT  customer,
        (array_agg(id ORDER BY total DESC))[1],
        max(total)
FROM purchases
GROUP BY customer

Dies gibt Ihnen den idgrößten Einkauf jedes Kunden.

Einige Dinge zu beachten:

• array_aggist eine Aggregatfunktion, mit der es funktioniert GROUP BY.
• array_aggMit dieser Option können Sie eine Reihenfolge angeben, die nur auf sich selbst beschränkt ist, damit die Struktur der gesamten Abfrage nicht eingeschränkt wird. Es gibt auch eine Syntax zum Sortieren von NULL-Werten, wenn Sie etwas anderes als die Standardeinstellung ausführen müssen.
• Sobald wir das Array erstellt haben, nehmen wir das erste Element. (Postgres-Arrays sind 1-indiziert, nicht 0-indiziert).
• Sie können array_aggauf ähnliche Weise für Ihre dritte Ausgabespalte verwenden, dies max(total)ist jedoch einfacher.
• Im Gegensatz DISTINCT ONdazu array_aggkönnen Sie mit verwenden GROUP BY, falls Sie dies aus anderen Gründen möchten.

Die Lösung ist, wie von Erwin erwähnt, aufgrund des Vorhandenseins von SubQs nicht sehr effizient

select * from purchases p1 where total in
(select max(total) from purchases where p1.customer=customer) order by total desc;

Ich benutze diesen Weg (nur postgresql): https://wiki.postgresql.org/wiki/First/last_%28aggregate%29

-- Create a function that always returns the first non-NULL item
CREATE OR REPLACE FUNCTION public.first_agg ( anyelement, anyelement )
RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
        SELECT $1;
$$;

-- And then wrap an aggregate around it
CREATE AGGREGATE public.first (
        sfunc    = public.first_agg,
        basetype = anyelement,
        stype    = anyelement
);

-- Create a function that always returns the last non-NULL item
CREATE OR REPLACE FUNCTION public.last_agg ( anyelement, anyelement )
RETURNS anyelement LANGUAGE sql IMMUTABLE STRICT AS $$
        SELECT $2;
$$;

-- And then wrap an aggregate around it
CREATE AGGREGATE public.last (
        sfunc    = public.last_agg,
        basetype = anyelement,
        stype    = anyelement
);

Dann sollte Ihr Beispiel fast so funktionieren wie es ist:

SELECT FIRST(id), customer, FIRST(total)
FROM  purchases
GROUP BY customer
ORDER BY FIRST(total) DESC;

CAVEAT: Die NULL-Zeilen werden ignoriert

Bearbeiten 1 - Verwenden Sie stattdessen die Erweiterung postgres

Jetzt benutze ich diesen Weg: http://pgxn.org/dist/first_last_agg/

So installieren Sie auf Ubuntu 14.04:

apt-get install postgresql-server-dev-9.3 git build-essential -y
git clone git://github.com/wulczer/first_last_agg.git
cd first_last_app
make && sudo make install
psql -c 'create extension first_last_agg'

Es ist eine Postgres-Erweiterung, die Ihnen erste und letzte Funktionen bietet. anscheinend schneller als der obige Weg.

Bearbeiten 2 - Bestellen und Filtern

Wenn Sie Aggregatfunktionen (wie diese) verwenden, können Sie die Ergebnisse ordnen, ohne dass die Daten bereits bestellt werden müssen:

http://www.postgresql.org/docs/current/static/sql-expressions.html#SYNTAX-AGGREGATES

Das äquivalente Beispiel für die Bestellung wäre also etwa:

SELECT first(id order by id), customer, first(total order by id)
  FROM purchases
 GROUP BY customer
 ORDER BY first(total);

Natürlich können Sie bestellen und filtern, wie Sie es für das Aggregat halten. Es ist eine sehr mächtige Syntax.

Die Abfrage:

SELECT purchases.*
FROM purchases
LEFT JOIN purchases as p 
ON 
  p.customer = purchases.customer 
  AND 
  purchases.total < p.total
WHERE p.total IS NULL

WIE FUNKTIONIERT DAS! (Ich war dort)

Wir möchten sicherstellen, dass wir für jeden Einkauf nur die höchste Summe haben.

Einige theoretische Dinge (überspringen Sie diesen Teil, wenn Sie nur die Abfrage verstehen wollen)

Sei Total eine Funktion T (Kunde, ID), die einen Wert mit dem Namen und der ID zurückgibt. Um zu beweisen, dass die angegebene Summe (T (Kunde, ID)) die höchste ist, müssen wir beweisen, dass wir beides beweisen wollen

• ∀x T (Kunde, ID)> T (Kunde, x) (diese Summe ist höher als alle anderen Summen für diesen Kunden)

ODER

• ¬∃x T (Kunde, ID) <T (Kunde, x) (für diesen Kunden gibt es keine höhere Summe)

Der erste Ansatz erfordert, dass wir alle Datensätze für diesen Namen erhalten, die ich nicht wirklich mag.

Der zweite braucht eine kluge Methode, um zu sagen, dass es keinen höheren Datensatz als diesen geben kann.

Zurück zu SQL

Wenn wir die Tabelle mit dem Namen verlassen und die Summe kleiner als die verknüpfte Tabelle ist:

      LEFT JOIN purchases as p 
      ON 
      p.customer = purchases.customer 
      AND 
      purchases.total < p.total

Wir stellen sicher, dass alle Datensätze, die einen anderen Datensatz mit der höheren Summe für denselben Benutzer haben, verbunden werden:

purchases.id, purchases.customer, purchases.total, p.id, p.customer, p.total
1           , Tom           , 200             , 2   , Tom   , 300
2           , Tom           , 300
3           , Bob           , 400             , 4   , Bob   , 500
4           , Bob           , 500
5           , Alice         , 600             , 6   , Alice   , 700
6           , Alice         , 700

Dies hilft uns, bei jedem Einkauf nach der höchsten Gesamtsumme zu filtern, ohne dass eine Gruppierung erforderlich ist:

WHERE p.total IS NULL

purchases.id, purchases.name, purchases.total, p.id, p.name, p.total
2           , Tom           , 300
4           , Bob           , 500
6           , Alice         , 700

Und das ist die Antwort, die wir brauchen.

Sehr schnelle Lösung

SELECT a.* 
FROM
    purchases a 
    JOIN ( 
        SELECT customer, min( id ) as id 
        FROM purchases 
        GROUP BY customer 
    ) b USING ( id );

und wirklich sehr schnell, wenn die Tabelle nach id indiziert ist:

create index purchases_id on purchases (id);

In SQL Server können Sie dies tun:

SELECT *
FROM (
SELECT ROW_NUMBER()
OVER(PARTITION BY customer
ORDER BY total DESC) AS StRank, *
FROM Purchases) n
WHERE StRank = 1

Explaination: Hier Gruppe von auf der Grundlage von Kunden durchgeführt wird und bestellt es dann insgesamt dann jede solche Gruppe Seriennummern als die Gäste gegeben und wir nehmen aus ersten 1 Kunden , dessen Strank 1

Verwenden Sie die ARRAY_AGGFunktion für PostgreSQL , U-SQL , IBM DB2 und Google BigQuery SQL :

SELECT customer, (ARRAY_AGG(id ORDER BY total DESC))[1], MAX(total)
FROM purchases
GROUP BY customer

In PostgreSQL besteht eine andere Möglichkeit darin, die first_valueFensterfunktion in Kombination zu verwenden mit SELECT DISTINCT:

select distinct customer_id,
                first_value(row(id, total)) over(partition by customer_id order by total desc, id)
from            purchases;

Ich habe ein Composite erstellt (id, total), sodass beide Werte von demselben Aggregat zurückgegeben werden. Sie können sich natürlich immer first_value()zweimal bewerben .

Die akzeptierte Lösung "Unterstützt von jeder Datenbank" von OMG Ponies hat eine gute Geschwindigkeit aus meinem Test.

Hier biete ich einen gleichen Ansatz, aber eine vollständigere und sauberere Lösung für jede Datenbank. Bindungen werden berücksichtigt (vorausgesetzt, Sie möchten nur eine Zeile für jeden Kunden erhalten, sogar mehrere Datensätze für die maximale Gesamtsumme pro Kunde), und andere Kauffelder (z. B. purchase_payment_id) werden für die tatsächlich übereinstimmenden Zeilen in der Kauftabelle ausgewählt.

Unterstützt von jeder Datenbank:

select * from purchase
join (
    select min(id) as id from purchase
    join (
        select customer, max(total) as total from purchase
        group by customer
    ) t1 using (customer, total)
    group by customer
) t2 using (id)
order by customer

Diese Abfrage ist relativ schnell, insbesondere wenn ein zusammengesetzter Index wie (Kunde, Gesamt) in der Kauftabelle vorhanden ist.

Anmerkung:

1. t1, t2 sind Unterabfrage-Alias, die je nach Datenbank entfernt werden können.

2. Vorsichtsmaßnahme : Die using (...)Klausel wird derzeit in MS-SQL und Oracle db ab dieser Bearbeitung im Januar 2017 nicht unterstützt. Sie müssen sie selbst auf z on t2.id = purchase.id. B. usw. erweitern. Die USING-Syntax funktioniert in SQLite, MySQL und PostgreSQL.

Snowflake / Teradata unterstützt eine QUALIFYKlausel, die wie HAVINGbei Fensterfunktionen funktioniert:

SELECT id, customer, total
FROM PURCHASES
QUALIFY ROW_NUMBER() OVER(PARTITION BY p.customer ORDER BY p.total DESC) = 1

• Wenn Sie eine Zeile (aufgrund Ihrer spezifischen Bedingung) aus der Gruppe der aggregierten Zeilen auswählen möchten.

• Wenn Sie zusätzlich zu eine andere ( sum/avg) Aggregationsfunktion verwenden möchten max/min. Somit kann man keinen Hinweis mit verwendenDISTINCT ON

Sie können die nächste Unterabfrage verwenden:

SELECT  
    (  
       SELECT **id** FROM t2   
       WHERE id = ANY ( ARRAY_AGG( tf.id ) ) AND amount = MAX( tf.amount )   
    ) id,  
    name,   
    MAX(amount) ma,  
    SUM( ratio )  
FROM t2  tf  
GROUP BY name

Sie können durch eine amount = MAX( tf.amount )beliebige Bedingung mit einer Einschränkung ersetzen : Diese Unterabfrage darf nicht mehr als eine Zeile zurückgeben

Aber wenn Sie solche Dinge tun möchten, suchen Sie wahrscheinlich nach Fensterfunktionen

Für SQl Server ist der effizienteste Weg:

with
ids as ( --condition for split table into groups
    select i from (values (9),(12),(17),(18),(19),(20),(22),(21),(23),(10)) as v(i) 
) 
,src as ( 
    select * from yourTable where  <condition> --use this as filter for other conditions
)
,joined as (
    select tops.* from ids 
    cross apply --it`s like for each rows
    (
        select top(1) * 
        from src
        where CommodityId = ids.i 
    ) as tops
)
select * from joined

und vergessen Sie nicht, einen Clustered-Index für verwendete Spalten zu erstellen