Die Anwendung Mehrerer Fenster Funktionen Auf Der Gleichen Partition

Ist es möglich, mehrere Fenster Funktionen auf der gleichen partition? (Korrigiert mich, wenn ich nicht mit dem richtigen Vokabular)

Beispielsweise können Sie tun

SELECT name, first_value() over (partition by name order by date) from table1

Aber gibt es eine Möglichkeit, etwas zu tun:

SELECT name, (first_value() as f, last_value() as l (partition by name order by date)) from table1

Wo wir sind mit zwei Funktionen in das gleiche Fenster?

Referenz:
http://postgresql.ro/docs/8.4/static/tutorial-window.html

InformationsquelleAutor Verhogen | 2009-12-13
  1. 22

    Können Sie nicht nur verwenden Sie das Fenster per Auswahl

    Etwas wie

    SELECT  name, 
        first_value() OVER (partition by name order by date) as f, 
        last_value() OVER (partition by name order by date) as l 
from table1

    Auch von Ihrer Referenz, die Sie tun können, es so

    SELECT sum(salary) OVER w, avg(salary) OVER w
FROM empsalary
WINDOW w AS (PARTITION BY depname ORDER BY salary DESC)
    • Ist es immer noch die effizienteste Abfrage, wenn die Anzahl der PARTITION BY erhöht ?
    • Sie müssen, verwenden Sie den parameter in first_value() and last_value(). Ich denke, es sollte Datum.
    • nach der Postgres-Dokumentation, mit der exakt gleichen PARTITION BY und ORDER BY Klauseln wird sichergestellt, dass alle Fenster-Funktionen verwenden die gleichen einzelnen Durchlauf über die Daten. postgresql.org/docs/9.1/...
    InformationsquelleAutor Adriaan Stander
  2. 15

    Warnung : ich glaube nicht, löschen Sie diese Antwort, da es scheint, technisch richtig und daher kann hilfreich sein, aber Vorsicht, dass PARTITION BY bar ORDER BY foo ist wahrscheinlich nicht, was Sie tun möchten sowieso. In der Tat, Aggregat-Funktionen nicht berechnen Sie die partition, die Elemente als ein ganzes. Das ist SELECT avg(foo) OVER (PARTITION BY bar ORDER BY foo) ist nicht gleichbedeutend zu SELECT avg(foo) OVER (PARTITION BY bar) (siehe den Nachweis am Ende der Antwort).

    Obwohl es nicht die Leistung verbessern per se, wenn Sie mehrere Male auf die gleiche partition, die Sie wahrscheinlich wollen verwenden Sie die zweite syntax vorgeschlagen astander, und nicht nur, weil es billiger ist, zu schreiben. Hier ist warum.

    Betrachten Sie die folgende Abfrage :

    SELECT 
  array_agg(foo)
    OVER (PARTITION BY bar ORDER BY foo), 
  avg(baz)
    OVER (PARTITION BY bar ORDER BY foo) 
FROM 
  foobar;

    Da im Prinzip der Sortierung hat keine Auswirkung auf die Berechnung des Durchschnitts, Sie könnten versucht sein, verwenden Sie stattdessen die folgende Abfrage (keine Bestellung auf der zweiten partition) :

    SELECT 
  array_agg(foo) 
    OVER (PARTITION BY bar ORDER BY foo), 
  avg(baz)
    OVER (PARTITION BY bar) 
FROM 
  foobar;

    Dies ist ein großer Fehler, wie es länger dauern wird. Beweis :

    > EXPLAIN ANALYZE SELECT array_agg(foo) OVER (PARTITION BY bar ORDER BY foo), avg(baz) OVER (PARTITION BY bar ORDER BY foo) FROM foobar;
                                                           QUERY PLAN                                                        
---------------------------------------------------------------------------------------------------------------------------------
 WindowAgg  (cost=215781.92..254591.76 rows=1724882 width=12) (actual time=969.659..2353.865 rows=1724882 loops=1)
   ->  Sort  (cost=215781.92..220094.12 rows=1724882 width=12) (actual time=969.640..1083.039 rows=1724882 loops=1)
         Sort Key: bar, foo
         Sort Method: quicksort  Memory: 130006kB
         ->  Seq Scan on foobar  (cost=0.00..37100.82 rows=1724882 width=12) (actual time=0.027..393.815 rows=1724882 loops=1)
 Total runtime: 2458.969 ms
(6 lignes)

> EXPLAIN ANALYZE SELECT array_agg(foo) OVER (PARTITION BY bar ORDER BY foo), avg(baz) OVER (PARTITION BY bar) FROM foobar;
                                                              QUERY PLAN                                                           
---------------------------------------------------------------------------------------------------------------------------------------
 WindowAgg  (cost=215781.92..276152.79 rows=1724882 width=12) (actual time=938.733..2958.811 rows=1724882 loops=1)
   ->  WindowAgg  (cost=215781.92..250279.56 rows=1724882 width=12) (actual time=938.699..2033.172 rows=1724882 loops=1)
         ->  Sort  (cost=215781.92..220094.12 rows=1724882 width=12) (actual time=938.683..1062.568 rows=1724882 loops=1)
               Sort Key: bar, foo
               Sort Method: quicksort  Memory: 130006kB
               ->  Seq Scan on foobar  (cost=0.00..37100.82 rows=1724882 width=12) (actual time=0.028..377.299 rows=1724882 loops=1)
 Total runtime: 3060.041 ms
(7 lignes)

    Nun, wenn Sie sich dieses Themas bewusst sind, natürlich werden Sie die gleiche partition überall. Aber wenn man das Zehnfache oder mehr der gleichen partition und aktualisieren Sie es über Tage, es ist ziemlich einfach zu vergessen, fügen Sie die ORDER BY - Klausel auf eine partition, die braucht nicht von selbst.

    Hier kommt die WINDOW syntax, die verhindern, dass Sie solche fahrlässigen Fehler (vorausgesetzt natürlich, Sie wissen es besser, zu minimieren die Anzahl der verschiedenen Fenster-Funktionen). Das folgende ist strikt identisch (so weit ich erzählen kann, von EXPLAIN ANALYZE) an der ersten Abfrage :

    SELECT
  array_agg(foo)
    OVER qux,
  avg(baz)
    OVER qux
FROM
  foobar
WINDOW
  qux AS (PARTITION BY bar ORDER BY bar)

    Post-Warnung-update :

    Verstehe ich die Aussage, dass "SELECT avg(foo) OVER (PARTITION BY bar ORDER BY foo) ist nicht gleichbedeutend zu SELECT avg(foo) OVER (PARTITION BY bar)" fraglich erscheint, so ist hier ein Beispiel :

    # SELECT * FROM foobar;
 foo | bar 
-----+-----
   1 |   1
   2 |   2
   3 |   1
   4 |   2
(4 lines)

# SELECT array_agg(foo) OVER qux, avg(foo) OVER qux FROM foobar WINDOW qux AS (PARTITION BY bar);
 array_agg | avg 
-----------+-----
 {1,3}     |   2
 {1,3}     |   2
 {2,4}     |   3
 {2,4}     |   3
 (4 lines)

# SELECT array_agg(foo) OVER qux, avg(foo) OVER qux FROM foobar WINDOW qux AS (PARTITION BY bar ORDER BY foo);
 array_agg | avg 
-----------+-----
 {1}       |   1
 {1,3}     |   2
 {2}       |   2
 {2,4}     |   3
(4 lines)
    • In der Abmahnung heißt es, "Das heißt, SELECT avg(foo) OVER (PARTITION BY bar ORDER BY foo) ist nicht äquivalent zu SELECT avg(foo) OVER (PARTITION BY-bar)." Warum ist es nicht?
    • Ich kann kaum glauben, dass SELECT avg(foo) OVER (PARTITION BY bar ORDER BY foo) ist NICHT entspricht SELECT avg(foo) OVER (PARTITION BY bar) wie weit wir diskutieren ResultSet. Beweisen Sie bitte, dass Sie sich unterscheiden. Der Zeitpunkt der Ausführung kann natürlich variieren (wie bauen Sie zwei Unbenannte windows anstelle von einem), aber die Ergebnisse sind immer noch die gleichen.
    • Führen Sie einfach die WINDOW Befehl meiner Antwort auf dieses minimal-Beispiel : create table foobar(foo float, bar int); insert into foobar values (1,1); insert into foobar values (3,1); mit und ohne ORDER BY.
    • Ich bin nicht in SQL nicht mehr genug, um zuverlässig beantworten warum, aber versuchen, das Beispiel in meinem vorherigen Kommentar (vielleicht fügen Sie einige Linien deutlicher machen), die array_agg() Ausgabe geben einen Hinweis.
    • Ich habe aktualisiert die Antwort mit einem Beispiel.
    • Verdammt, du hast dich verändert mein Verständnis von PARTITION Dank! (Für Interessierte: mit ORDER BY es gibt Zeilen {1; 2}, und ohne es gibt {2; 2}.
    • DANKE. Jetzt verstehe ich. Hier ist ein weiteres gutes Beispiel: postgresql.org/docs/9.1/static/tutorial-window.html. Dann, die ORDER BY sortiert die Zeilen in das Fenster, und Verfahren Sie in dieser Reihenfolge, einschließlich nur die aktuelle und die zuvor Zeilen, ignorieren von Zeilen, die nach aktuellen oder nicht in das Fenster.

    InformationsquelleAutor Skippy le Grand Gourou
Schreibe einen Kommentar