Ausführliche Erklärung und praktische Anwendung von MYSQL-Fensterfunktionen (einschließlich Beispielen)

Mobile 2023-12-16 20:22:05 views: null

        MySQL-Fensterfunktionen bieten die Möglichkeit, Berechnungen über Gruppen hinweg durchzuführen, die der aktuellen Zeile zugeordnet sind. Fensterfunktionen unterscheiden sich von Aggregatfunktionen dadurch, dass Aggregatfunktionen Berechnungen für jede Gruppierung durchführen und eine Zeile für jede Gruppierung zurückgeben, während Fensterfunktionen nicht jede Gruppierung in einer Zeile ausgeben, sondern stattdessen die Berechnungsergebnisse jeder Gruppierung in der zugehörigen Zeile kombinieren .

Inhaltsverzeichnis

1. CUME_DIST übernimmt die kumulative Verteilung

2. Rangfolge innerhalb der DENSE_RANK-Partition

3. Bewertungswert FIRST_VALUE (erste Zeile)

4. LAST_VALUE-Bewertungswert (letzte Zeile)

5. NTH_VALUE-Bewertungswert (angegebene Zeile)

6. PERCENT_RANK ermittelt die relative Rangfolge der Partitionen

7. ROW_NUMBER ruft die Seriennummer der Partition ab

8. LAG

9. FÜHREN

十、NTILE

11. RANG

1. CUME_DIST übernimmt die kumulative Verteilung

Die MySQL-Funktion CUME_DIST() gibt die kumulative Verteilung der aktuellen Zeile zurück, d. h. das Verhältnis der Anzahl der Zeilen von der ersten bis zur letzten Zeile mit demselben Wert wie die aktuelle Zeile zur Gesamtanzahl der Zeilen in der Partition .

Grammatik:

CUME_DIST()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • partition_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Ein Wert größer als 0 und kleiner oder gleich 1, der die kumulative Verteilung der aktuellen Zeile darstellt.
  • Die Berechnungsformel lautet: (Anzahl der Zeilen vor der aktuellen Zeile + Anzahl der Zeilen mit demselben Wert wie die aktuelle Zeile) / Gesamtzahl der Zeilen in der Partition.

Beispiel:

mysql> select * from grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
mysql> SELECT *,
  CUME_DIST() OVER (
    PARTITION BY subject
    ORDER BY grade
  ) "cume_dist"
FROM grade;
+----+------+-------+---------+-------+---------------------+
| id | name | class | subject | grade | cume_dist           |
+----+------+-------+---------+-------+---------------------+
| 10 | Lucy | B     | English |     6 | 0.16666666666666666 |
|  4 | Tim  | A     | English |     7 |  0.6666666666666666 |
|  6 | Jim  | A     | English |     7 |  0.6666666666666666 |
| 11 | Jody | B     | English |     7 |  0.6666666666666666 |
|  5 | Tom  | A     | English |     8 |                   1 |
| 12 | Susy | B     | English |     8 |                   1 |
|  8 | Jody | B     | Math    |     6 | 0.16666666666666666 |
|  2 | Tom  | A     | Math    |     7 |  0.3333333333333333 |
|  3 | Jim  | A     | Math    |     8 |  0.6666666666666666 |
|  7 | Lucy | B     | Math    |     8 |  0.6666666666666666 |
|  1 | Tim  | A     | Math    |     9 |                   1 |
|  9 | Susy | B     | Math    |     9 |                   1 |
+----+------+-------+---------+-------+---------------------+

exist OVER Untergeordneter Vers:

  • PARTITION BY subject Partitionieren Sie alle Zeilen nach Konto.
  • ORDER BY grade sortiert die Zeilen innerhalb jeder Partition in aufsteigender Reihenfolge der Note.
  • CUME_DIST() berechnet die kumulative Verteilung jeder Zeile.

Beachten Sie, dass innerhalb jedes Fachs Zeilen mit derselben Note die gleiche kumulative Verteilung aufweisen.

2. Rangfolge innerhalb der DENSE_RANK-Partition

Die MySQL-Funktion DENSE_RANK() gibt den Rang innerhalb der Partition zurück, in der sich die aktuelle Zeile befindet, beginnend bei 1, aber ohne Lücken.

Grammatik:

DENSE_RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • partition_column_list:Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list:Die Liste der Spalten, die an der Sortierung beteiligt sind.

Rückgabewert:

  • Die Rangfolge innerhalb der Partition der aktuellen Zeile, beginnend bei 1, aber ohne Lücken.

Beispiel:

mysql> select * from grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Sehen Sie sich das Leistungsranking jedes Schülers nach Fach an 
mysql> SELECT *,
  DENSE_RANK() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "dense_rank",
  rank() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "rank"
FROM grade;
+----+------+-------+---------+-------+------------+------+
| id | name | class | subject | grade | dense_rank | rank |
+----+------+-------+---------+-------+------------+------+
|  5 | Tom  | A     | English |     8 |          1 |    1 |
| 12 | Susy | B     | English |     8 |          1 |    1 |
|  4 | Tim  | A     | English |     7 |          2 |    3 |
|  6 | Jim  | A     | English |     7 |          2 |    3 |
| 11 | Jody | B     | English |     7 |          2 |    3 |
| 10 | Lucy | B     | English |     6 |          3 |    6 |
|  1 | Tim  | A     | Math    |     9 |          1 |    1 |
|  9 | Susy | B     | Math    |     9 |          1 |    1 |
|  3 | Jim  | A     | Math    |     8 |          2 |    3 |
|  7 | Lucy | B     | Math    |     8 |          2 |    3 |
|  2 | Tom  | A     | Math    |     7 |          3 |    5 |
|  8 | Jody | B     | Math    |     6 |          4 |    6 |
+----+------+-------+---------+-------+------------+------+

exist OVER Untergeordneter Vers:

  • PARTITION NACH Betreff wird nach Betreff partitioniert.
  • ORDER BY grade DESC sortiert die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Klasse.
  • DENSE_RANK() gibt den Rang jeder Zeile innerhalb der zugehörigen Partition zurück.

Beachten Sie, dass innerhalb jedes Fachs Zeilen mit derselben Note die gleiche kumulative Verteilung aufweisen.

  • Um die Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Rangfolge jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten anzeigen.

mysql> SELECT 
  t.*,
  DENSE_RANK() OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
  ) "dense_rank"
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+------------+
| class | name | sum_grade | dense_rank |
+-------+------+-----------+------------+
| A     | Tim  | 16        |          1 |
| A     | Tom  | 15        |          2 |
| A     | Jim  | 15        |          2 |
| B     | Susy | 17        |          1 |
| B     | Lucy | 14        |          2 |
| B     | Jody | 13        |          3 |
+-------+------+-----------+------------+
  • davon Unterabfragen
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;
+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet DENSE_RANK() , um jede Zeile innerhalb der zugehörigen Partitionsrangfolge zurückzugeben. 

3. Bewertungswert FIRST_VALUE (erste Zeile)

Die MySQL-Funktion FIRST_VALUE() gibt den ausgewerteten Wert aus der ersten Zeile des Fensterrahmens zurück, der der aktuellen Zeile zugeordnet ist.

Grammatik:

FIRST_VALUE(expr)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • expr: Erforderlich. Es kann ein Spaltenname oder ein Ausdruck sein.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Gibt den Wert zurück, der in der ersten Zeile des Fensterrahmens ausgewertet wird, der der aktuellen Zeile zugeordnet ist.

Beispiel:

mysql> SELECT * FROM grade;

+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Zeigen Sie das Leistungsranking jedes Schülers nach Fach an. Sie müssen die Rangfolge jedes Schülers in jedem Fach von hoch nach niedrig und die beste Punktzahl in jedem Fach anzeigen.
mysql> SELECT 
  *,
  FIRST_VALUE(grade) OVER (
    PARTITION BY subject
    ORDER BY grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM grade;
+----+------+-------+---------+-------+-------------+
| id | name | class | subject | grade | first_grade |
+----+------+-------+---------+-------+-------------+
|  5 | Tom  | A     | English |     8 |           8 |
| 12 | Susy | B     | English |     8 |           8 |
|  4 | Tim  | A     | English |     7 |           8 |
|  6 | Jim  | A     | English |     7 |           8 |
| 11 | Jody | B     | English |     7 |           8 |
| 10 | Lucy | B     | English |     6 |           8 |
|  1 | Tim  | A     | Math    |     9 |           9 |
|  9 | Susy | B     | Math    |     9 |           9 |
|  3 | Jim  | A     | Math    |     8 |           9 |
|  7 | Lucy | B     | Math    |     8 |           9 |
|  2 | Tom  | A     | Math    |     7 |           9 |
|  8 | Jody | B     | Math    |     6 |           9 |
+----+------+-------+---------+-------+-------------+
  • Fensterfunktion:
FIRST_VALUE(grade) OVER (
  PARTITION BY subject
  ORDER BY grade DESC
  RANGE BETWEEN 
    UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
)

In der OVER-Klausel:

  • PARTITION NACH Betreff wird nach Betreff unterteilt
  • ORDER BY grade DESC sortiert die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Klasse.
  • RANGE BETWEEN UNBOUNDED PRECEDING UND UNBOUNDED FOLLOWING definiert den Fensterrahmen in jeder Partition relativ zur aktuellen Zeile, hier von der ersten Zeile bis zur letzten Zeile der Partition.
  • FIRST_VALUE(note) gibt die Note jeder Zeile in der ersten Zeile der zugehörigen Partition zurück. Da die Sortierung in umgekehrter Reihenfolge nach Note erfolgt, wird jeder Zeile eine Spalte hinzugefügt, um die beste Punktzahl anzuzeigen.​ 
  • Um die Rangfolge der Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Sortiernummer jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten und der besten Punktzahl in jeder Klasse anzeigen.
mysql> SELECT 
  t.*,
  FIRST_VALUE(t.sum_grade) OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+-------------+
| class | name | sum_grade | first_grade |
+-------+------+-----------+-------------+
| A     | Tim  | 16        | 16          |
| A     | Tom  | 15        | 16          |
| A     | Jim  | 15        | 16          |
| B     | Susy | 17        | 17          |
| B     | Lucy | 14        | 17          |
| B     | Jody | 13        | 17          |
+-------+------+-----------+-------------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;

+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet FIRST_VALUE(grade) , um jede Zeile innerhalb der zugehörigen Partitionsnoten in der ersten Zeile zurückzugeben .

4. LAST_VALUE-Bewertungswert (letzte Zeile)

Die MySQL-Funktion LAST_VALUE() gibt den ausgewerteten Wert aus der letzten Zeile des Fensterrahmens zurück, der der aktuellen Zeile zugeordnet ist.

Grammatik:

LAST_VALUE(expr)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • expr: Erforderlich. Es kann ein Spaltenname oder ein Ausdruck sein.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Gibt den ausgewerteten Wert aus der letzten Zeile des Fensterrahmens zurück, der der aktuellen Zeile zugeordnet ist.

Beispiel:

mysql> SELECT * FROM grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Zeigen Sie das Leistungsranking jedes Schülers nach Fach an. Sie müssen die Rangfolge jedes Schülers in jedem Fach von hoch nach niedrig und die beste Punktzahl in jedem Fach anzeigen.​ 
mysql> SELECT 
  *,
  LAST_VALUE(grade) OVER (
    PARTITION BY subject
    ORDER BY grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) last_grade
FROM grade;

+----+------+-------+---------+-------+------------+
| id | name | class | subject | grade | last_grade |
+----+------+-------+---------+-------+------------+
|  5 | Tom  | A     | English |     8 |          6 |
| 12 | Susy | B     | English |     8 |          6 |
|  4 | Tim  | A     | English |     7 |          6 |
|  6 | Jim  | A     | English |     7 |          6 |
| 11 | Jody | B     | English |     7 |          6 |
| 10 | Lucy | B     | English |     6 |          6 |
|  1 | Tim  | A     | Math    |     9 |          6 |
|  9 | Susy | B     | Math    |     9 |          6 |
|  3 | Jim  | A     | Math    |     8 |          6 |
|  7 | Lucy | B     | Math    |     8 |          6 |
|  2 | Tom  | A     | Math    |     7 |          6 |
|  8 | Jody | B     | Math    |     6 |          6 |
+----+------+-------+---------+-------+------------+
  • Fensterfunktion:
LAST_VALUE(grade) OVER (
  PARTITION BY subject
  ORDER BY grade DESC
  RANGE BETWEEN 
    UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
)

In der OVER-Klausel:

  • PARTITION NACH Betreff wird nach Betreff partitioniert.
  • ORDER BY grade DESC sortiert die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Klasse.
  • RANGE BETWEEN UNBOUNDED PRECEDING UND UNBOUNDED FOLLOWING definiert den Fensterrahmen in jeder Partition relativ zur aktuellen Zeile, hier von der ersten Zeile bis zur letzten Zeile der Partition.
  • LAST_VALUE(note) gibt die Note jeder Zeile in der ersten Zeile der zugehörigen Partition zurück. Da die Sortierung in umgekehrter Reihenfolge nach Note erfolgt, wird jeder Zeile eine Spalte hinzugefügt, in der die schlechteste Note angezeigt wird.​ 
  • Um die Rangfolge der Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Sortiernummer jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten und der besten Punktzahl in jeder Klasse anzeigen.
mysql> SELECT 
  t.*,
  LAST_VALUE(t.sum_grade) OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) last_grade
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+------------+
| class | name | sum_grade | last_grade |
+-------+------+-----------+------------+
| A     | Tim  | 16        | 15         |
| A     | Tom  | 15        | 15         |
| A     | Jim  | 15        | 15         |
| B     | Susy | 17        | 13         |
| B     | Lucy | 14        | 13         |
| B     | Jody | 13        | 13         |
+-------+------+-----------+------------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;
+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klassen, sortiert dann die Gesamtnoten in umgekehrter Reihenfolge innerhalb jeder Partition und gibt mit LAST_VALUE(note) die Note jeder Zeile in der letzten Zeile der zugehörigen Partition zurück.

5. NTH_VALUE-Bewertungswert (angegebene Zeile)

Die MySQL-Funktion NTH_VALUE() gibt den ausgewerteten Wert aus einer angegebenen Zeile im Fensterrahmen zurück, der der aktuellen Zeile zugeordnet ist.

Grammatik:

NTH_VALUE(expr, n)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

        NTH_VALUE(expr, 1) entspricht first_value(expr).​ 

Parameterbeschreibung:

  • expr：Erforderlich. Es kann ein Spaltenname oder ein Ausdruck sein.
  • n: Erforderlich. Geben Sie die Zeilennummer an.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Gibt den ausgewerteten Wert aus einer angegebenen Zeile im Fensterrahmen zurück, der der aktuellen Zeile zugeordnet ist.
  • Rückgabe NULL情况：Die angegebene Zeile existiert nicht.

Beispiel:

mysql> SELECT * FROM grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Zeigen Sie das Leistungsranking jedes Schülers nach Fach an. Sie müssen die Rangfolge jedes Schülers in jedem Fach von hoch nach niedrig und die beste Punktzahl in jedem Fach anzeigen.
mysql> SELECT 
  *,
  NTH_VALUE(grade, 1) OVER (
    PARTITION BY subject
    ORDER BY grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM grade;
+----+------+-------+---------+-------+-------------+
| id | name | class | subject | grade | first_grade |
+----+------+-------+---------+-------+-------------+
|  5 | Tom  | A     | English |     8 |           8 |
| 12 | Susy | B     | English |     8 |           8 |
|  4 | Tim  | A     | English |     7 |           8 |
|  6 | Jim  | A     | English |     7 |           8 |
| 11 | Jody | B     | English |     7 |           8 |
| 10 | Lucy | B     | English |     6 |           8 |
|  1 | Tim  | A     | Math    |     9 |           9 |
|  9 | Susy | B     | Math    |     9 |           9 |
|  3 | Jim  | A     | Math    |     8 |           9 |
|  7 | Lucy | B     | Math    |     8 |           9 |
|  2 | Tom  | A     | Math    |     7 |           9 |
|  8 | Jody | B     | Math    |     6 |           9 |
+----+------+-------+---------+-------+-------------+
  • Fensterfunktion:
NTH_VALUE(grade, 1) OVER (
  PARTITION BY subject
  ORDER BY grade DESC
  RANGE BETWEEN 
    UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
)

exist OVER Untergeordneter Vers:

  • PARTITION BY subject Wird nach Disziplinen aufgeteilt
  • ORDER BY grade DESC Sortieren Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Punktzahl.
  • RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING Definiert den Fensterrahmen, der der aktuellen Zeile in jeder Partition zugeordnet ist, hier von der ersten bis zur letzten Zeile der Partition.
  • NTH_VALUE(grade, 1) Gibt die Punktzahl der ersten Zeile jeder Zeile in der zugehörigen Partition zurück (grade). Da in umgekehrter Reihenfolge wie grade sortiert wird, wird jeder Zeile eine Spalte hinzugefügt, um die besten Ergebnisse anzuzeigen.

        Wenn Sie die schlechteste Punktzahl in jedem Fach in jeder Zeile anzeigen möchten, können Sie NTH_VALUE(grade, 3) anstelle von NTH_VALUE(grade, 1) in der obigen Anweisung verwenden. 

  • Um die Rangfolge der Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Sortiernummer jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten und der besten Punktzahl in jeder Klasse anzeigen.
mysql> SELECT 
  t.*,
  NTH_VALUE(t.sum_grade, 1) OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
    RANGE BETWEEN 
      UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
  ) first_grade
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+-------------+
| class | name | sum_grade | first_grade |
+-------+------+-----------+-------------+
| A     | Tim  | 16        | 16          |
| A     | Tom  | 15        | 16          |
| A     | Jim  | 15        | 16          |
| B     | Susy | 17        | 17          |
| B     | Lucy | 14        | 17          |
| B     | Jody | 13        | 17          |
+-------+------+-----------+-------------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;

+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet NTH_VALUE(t.sum_grade, 1) , um jede Zeile innerhalb der zugehörigen Partitionsnoten in der ersten Zeile zurückzugeben .

6. PERCENT_RANK ermittelt die relative Rangfolge der Partitionen

Die MySQL-Funktion PERCENT_RANK() gibt die relative Rangfolge innerhalb der Partition zurück, in der sich die aktuelle Zeile befindet, d. h. (Rang() – 1) / (Gesamtzahl der Zeilen in der Partition – 1).

Grammatik:

PERCENT_RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Eine Zahl zwischen 0 und 1 (einschließlich), die die relative Rangfolge innerhalb der Partition angibt, in der sich die aktuelle Zeile befindet. Die Berechnungsformel lautet (rank() - 1) / (分区总行数 - 1).

Beispiel:

mysql> SELECT * FROM grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Um die relative Rangfolge der Leistungen jedes Schülers nach Fach anzuzeigen, müssen Sie die relative Rangfolge der Leistungen jedes Schülers in jedem Fach von oben nach unten anzeigen.
mysql> SELECT *,
  rank() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "rank",
  PERCENT_RANK() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "percent_rank"
FROM grade;
+----+------+-------+---------+-------+------+--------------+
| id | name | class | subject | grade | rank | percent_rank |
+----+------+-------+---------+-------+------+--------------+
|  5 | Tom  | A     | English |     8 |    1 |            0 |
| 12 | Susy | B     | English |     8 |    1 |            0 |
|  4 | Tim  | A     | English |     7 |    3 |          0.4 |
|  6 | Jim  | A     | English |     7 |    3 |          0.4 |
| 11 | Jody | B     | English |     7 |    3 |          0.4 |
| 10 | Lucy | B     | English |     6 |    6 |            1 |
|  1 | Tim  | A     | Math    |     9 |    1 |            0 |
|  9 | Susy | B     | Math    |     9 |    1 |            0 |
|  3 | Jim  | A     | Math    |     8 |    3 |          0.4 |
|  7 | Lucy | B     | Math    |     8 |    3 |          0.4 |
|  2 | Tom  | A     | Math    |     7 |    5 |          0.8 |
|  8 | Jody | B     | Math    |     6 |    6 |            1 |
+----+------+-------+---------+-------+------+--------------+
  • Fensterfunktion:
PERCENT_RANK() OVER (
  PARTITION BY subject
  ORDER BY grade DESC
)

exist OVER in untergeordneter Phrase,

  • PARTITION BY subject Wird nach Disziplinen aufgeteilt
  • ORDER BY grade DESC Sortieren Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Punktzahl.
  • PERCENT_RANK() Gibt die relative Rangfolge jeder Zeile innerhalb der zugehörigen Partition zurück.
  • Um die relative Rangfolge der Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die relative Rangfolge der Gesamtpunktzahl jedes Schülers in jeder Klasse von hoch nach niedrig anzeigen.
mysql> SELECT t.*,
  PERCENT_RANK() OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
  ) "percent_rank"
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+--------------+
| class | name | sum_grade | percent_rank |
+-------+------+-----------+--------------+
| A     | Tim  | 16        |            0 |
| A     | Tom  | 15        |          0.5 |
| A     | Jim  | 15        |          0.5 |
| B     | Susy | 17        |            0 |
| B     | Lucy | 14        |          0.5 |
| B     | Jody | 13        |            1 |
+-------+------+-----------+--------------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;
+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet PERCENT_RANK() , um jede Zeile innerhalb der zugehörigen relativen Partitionsrangfolge zurückzugeben.

7. ROW_NUMBER ruft die Seriennummer der Partition ab

Die MySQL-Funktion ROW_NUMBER() gibt die Seriennummer in der Partition zurück, in der sich die aktuelle Zeile befindet, beginnend bei 1.

Grammatik:

ROW_NUMBER()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Die Seriennummer in der Partition, in der sich die aktuelle Zeile befindet, beginnend bei 1.

Beispiel:

mysql> SELECT * FROM grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Zeigen Sie die Rangfolge der Leistungen jedes Schülers nach Fach an. Sie müssen die Rangfolge der Leistungen jedes Schülers in jedem Fach von hoch nach niedrig anzeigen.​ 
mysql> SELECT *,
  ROW_NUMBER() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "row_number"
FROM grade;
+----+------+-------+---------+-------+------------+
| id | name | class | subject | grade | row_number |
+----+------+-------+---------+-------+------------+
|  5 | Tom  | A     | English |     8 |          1 |
| 12 | Susy | B     | English |     8 |          2 |
|  4 | Tim  | A     | English |     7 |          3 |
|  6 | Jim  | A     | English |     7 |          4 |
| 11 | Jody | B     | English |     7 |          5 |
| 10 | Lucy | B     | English |     6 |          6 |
|  1 | Tim  | A     | Math    |     9 |          1 |
|  9 | Susy | B     | Math    |     9 |          2 |
|  3 | Jim  | A     | Math    |     8 |          3 |
|  7 | Lucy | B     | Math    |     8 |          4 |
|  2 | Tom  | A     | Math    |     7 |          5 |
|  8 | Jody | B     | Math    |     6 |          6 |
+----+------+-------+---------+-------+------------+
  • Fensterfunktion: 
ROW_NUMBER() OVER (
  PARTITION BY subject
  ORDER BY grade DESC
)

exist OVER Untergeordneter Vers:

  • PARTITION BY subject Wird nach Disziplinen aufgeteilt
  • ORDER BY grade DESC Sortieren Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Punktzahl.
  • ROW_NUMBER() Gibt die Sequenznummer jeder Zeile innerhalb der zugehörigen Partition zurück.
  • Um die Sortiernummer der Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Sortiernummer jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten anzeigen.
mysql> SELECT t.*,
  ROW_NUMBER() OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
  ) "row_number"
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+------------+
| class | name | sum_grade | row_number |
+-------+------+-----------+------------+
| A     | Tim  | 16        |          1 |
| A     | Tom  | 15        |          2 |
| A     | Jim  | 15        |          3 |
| B     | Susy | 17        |          1 |
| B     | Lucy | 14        |          2 |
| B     | Jody | 13        |          3 |
+-------+------+-----------+------------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;
+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet ROW_NUMBER() , um jede Zeile innerhalb der zugehörigen Partitionssequenznummer zurückzugeben.

8. LAG

Die MySQL-Funktion LAG() gibt den Wert aus der angegebenen Zeile vor der aktuellen Zeile in der Partition zurück, in der sich die aktuelle Zeile befindet.

Grammatik:

LAG(expr[, offset[, default]])
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • expr: Erforderlich. Es kann ein Spaltenname oder ein Ausdruck sein.
  • offset: Optional. Die Anzahl der Zeilen, die von der aktuellen Zeile versetzt sind. Der Standardwert ist 1.
  • default: Optional. Es kann ein Spaltenname oder ein Ausdruck sein.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Der Wert aus der angegebenen Zeile vor der aktuellen Zeile in der Partition, in der sich die aktuelle Zeile befindet.

Beispiel:

mysql> SELECT * FROM revenue;
+----+------+---------+---------+
| id | year | quarter | revenue |
+----+------+---------+---------+
|  1 | 2020 | 1       |    3515 |
|  2 | 2020 | 2       |    3678 |
|  3 | 2020 | 3       |    4203 |
|  4 | 2020 | 4       |    3924 |
|  5 | 2021 | 1       |    3102 |
|  6 | 2021 | 2       |    3293 |
|  7 | 2021 | 3       |    3602 |
|  8 | 2021 | 4       |    2901 |
+----+------+---------+---------+
  • Vergleichen Sie den Umsatz des aktuellen Quartals mit dem Umsatz des nächsten Quartals mithilfe der MySQL-Funktion LAG(). Fügen Sie die Spalte next_quarter_revenue zu jeder Zeile hinzu, um den Umsatz des aktuellen Quartals mit dem Umsatz des nächsten Quartals mithilfe der MySQL-Funktion LAG() zu vergleichen:
mysql> SELECT
  *,
  LAG(revenue, 1) OVER (
    PARTITION BY year
    ORDER BY quarter DESC
  ) next_quarter_revenue
FROM revenue;

+----+------+---------+---------+----------------------+
| id | year | quarter | revenue | next_quarter_revenue |
+----+------+---------+---------+----------------------+
|  4 | 2020 | 4       |    3924 | NULL                 |
|  3 | 2020 | 3       |    4203 |                 3924 |
|  2 | 2020 | 2       |    3678 |                 4203 |
|  1 | 2020 | 1       |    3515 |                 3678 |
|  8 | 2021 | 4       |    2901 | NULL                 |
|  7 | 2021 | 3       |    3602 |                 2901 |
|  6 | 2021 | 2       |    3293 |                 3602 |
|  5 | 2021 | 1       |    3102 |                 3293 |
+----+------+---------+---------+----------------------+
  • Fensterfunktion:
LAG(revenue, 1) OVER (
  PARTITION BY year
  ORDER BY quarter DESC
) next_quarter_revenue

exist OVER Untergeordneter Vers:

  • PARTITION BY year Partitionieren Sie alle Zeilen nach Jahr
  • ORDER BY quarter DESC Ordnen Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Viertel an.
  • LAG(revenue, 1) Gibt die Rückgabe () für jede Zeile in der vorherigen Zeile (1) innerhalb der zugehörigen Partition zurück. revenue

        Dann wird in der Spalte next_quarter_revenue das Einkommen des nächsten Viertels der aktuellen Zeile gespeichert. Daher ist der Wert der Spalte next_quarter_revenue in der ersten Zeile jeder Partition null.

  • Standardwert verwenden:

mysql> SELECT
  *,
  LAG(revenue, 1, 0) OVER (
    PARTITION BY year
    ORDER BY quarter DESC
  ) next_quarter_revenue
FROM revenue;
+----+------+---------+---------+----------------------+
| id | year | quarter | revenue | next_quarter_revenue |
+----+------+---------+---------+----------------------+
|  4 | 2020 | 4       |    3924 |                    0 |
|  3 | 2020 | 3       |    4203 |                 3924 |
|  2 | 2020 | 2       |    3678 |                 4203 |
|  1 | 2020 | 1       |    3515 |                 3678 |
|  8 | 2021 | 4       |    2901 |                    0 |
|  7 | 2021 | 3       |    3602 |                 2901 |
|  6 | 2021 | 2       |    3293 |                 3602 |
|  5 | 2021 | 1       |    3102 |                 3293 |
+----+------+---------+---------+----------------------+

9. FÜHREN

Die MySQL-Funktion LEAD() gibt den Wert aus der Zeile innerhalb der angegebenen Zeile zurück, die auf die aktuelle Zeile in der Partition folgt, in der sich die aktuelle Zeile befindet.

Grammatik:

LEAD(expr[, offset[, default]])
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • expr: Erforderlich. Es kann ein Spaltenname oder ein Ausdruck sein.
  • offset: Optional. Die Anzahl der Zeilen, die von der aktuellen Zeile versetzt sind. Der Standardwert ist 1.
  • default: Optional. Es kann ein Spaltenname oder ein Ausdruck sein.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Der Wert aus der Zeile innerhalb der angegebenen Zeile, die auf die aktuelle Zeile in der Partition folgt, in der sich die aktuelle Zeile befindet.

Beispiel:

mysql> SELECT * FROM revenue;
+----+------+---------+---------+
| id | year | quarter | revenue |
+----+------+---------+---------+
|  1 | 2020 | 1       |    3515 |
|  2 | 2020 | 2       |    3678 |
|  3 | 2020 | 3       |    4203 |
|  4 | 2020 | 4       |    3924 |
|  5 | 2021 | 1       |    3102 |
|  6 | 2021 | 2       |    3293 |
|  7 | 2021 | 3       |    3602 |
|  8 | 2021 | 4       |    2901 |
+----+------+---------+---------+
  • Vergleichen Sie den Umsatz des aktuellen Quartals mit dem Umsatz des vorherigen Quartals mithilfe der MySQL-Funktion LEAD(). Fügen Sie die Spalte last_quarter_revenue zu jeder Zeile hinzu, indem Sie die MySQL-Funktion LEAD() verwenden, um den Umsatz des aktuellen Quartals mit dem Umsatz des vorherigen Quartals zu vergleichen:
mysql> SELECT
  *,
  LEAD(revenue, 1) OVER (
    PARTITION BY year
    ORDER BY quarter DESC
  ) last_quarter_revenue
FROM revenue;

+----+------+---------+---------+----------------------+
| id | year | quarter | revenue | last_quarter_revenue |
+----+------+---------+---------+----------------------+
|  4 | 2020 | 4       |    3924 |                 4203 |
|  3 | 2020 | 3       |    4203 |                 3678 |
|  2 | 2020 | 2       |    3678 |                 3515 |
|  1 | 2020 | 1       |    3515 | NULL                 |
|  8 | 2021 | 4       |    2901 |                 3602 |
|  7 | 2021 | 3       |    3602 |                 3293 |
|  6 | 2021 | 2       |    3293 |                 3102 |
|  5 | 2021 | 1       |    3102 | NULL                 |
+----+------+---------+---------+----------------------+
  • Fensterfunktion:
LEAD(revenue, 1) OVER (
  PARTITION BY year
  ORDER BY quarter DESC
) last_quarter_revenue

exist OVER Untergeordneter Vers:

  • PARTITION BY year Partitionieren Sie alle Zeilen nach Jahr
  • ORDER BY quarter DESC Ordnen Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Viertel an.
  • LEAD(revenue, 1) Gibt den Umsatz () für jede Zeile in der Zeile zurück, die unmittelbar auf (1) innerhalb der zugehörigen Partition folgt. revenue

        Dann wird in der Spalte last_quarter_revenue das Einkommen des vorherigen Quartals der aktuellen Zeile gespeichert. Daher ist der Wert der Spalte last_quarter_revenue in der letzten Zeile jeder Partition null.

  • Standardwert verwenden:
mysql> SELECT
  *,
  LEAD(revenue, 1, 0) OVER (
    PARTITION BY year
    ORDER BY quarter DESC
  ) last_quarter_revenue
FROM revenue;

+----+------+---------+---------+----------------------+
| id | year | quarter | revenue | last_quarter_revenue |
+----+------+---------+---------+----------------------+
|  4 | 2020 | 4       |    3924 |                 4203 |
|  3 | 2020 | 3       |    4203 |                 3678 |
|  2 | 2020 | 2       |    3678 |                 3515 |
|  1 | 2020 | 1       |    3515 |                    0 |
|  8 | 2021 | 4       |    2901 |                 3602 |
|  7 | 2021 | 3       |    3602 |                 3293 |
|  6 | 2021 | 2       |    3293 |                 3102 |
|  5 | 2021 | 1       |    3102 |                    0 |
+----+------+---------+---------+----------------------+

十、NTILE

Die MySQL-Funktion NTILE() unterteilt alle Zeilen in der Partition, in der sich die aktuelle Zeile befindet, möglichst gleichmäßig in die angegebene Anzahl von Intervallen und gibt die Intervallnummer zurück, in der sich die aktuelle Zeile befindet.

Jedes Intervall wird von MySQL als Ranking-Bucket bezeichnet. NTILE() Legen Sie eine Rangfolge für jeden Bucket-Index gemäß der angegebenen Reihenfolge fest.

Grammatik:

NTILE(buckets)
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • buckets: Erforderlich. Anzahl Fässer. Die maximale Anzahl an Buckets entspricht der Anzahl an Zeilen in dieser Partition.
  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Teilen Sie alle Zeilen in der Partition, in der sich die aktuelle Zeile befindet, möglichst gleichmäßig in die angegebene Anzahl von Rangfolge-Buckets auf und geben Sie die Rangfolge des Buckets zurück, in dem sich die aktuelle Zeile befindet.

Beispiel: 

  • Die folgende Anweisung zeigt die Verwendung von NTILE(3) , um sie in aufsteigender Reihenfolge in 3 Buckets zu unterteilen. Nach dem Prinzip einer möglichst gleichmäßigen Verteilung werden die Buckets 1-3 geordnet 1, und die Buckets 4–6 sind in der Rangfolge. Die Rangfolge ist 2, und die Buckets 7–9 sind in der Rangfolge 3. 
mysql> SELECT
  x,
  NTILE(3) over (
    ORDER BY x
  ) "ntile"
FROM (
    SELECT 1 x
    UNION
    SELECT 2 x
    UNION
    SELECT 3 x
    UNION
    SELECT 4 x
    UNION
    SELECT 5 x
    UNION
    SELECT 6 x
    UNION
    SELECT 7 x
    UNION
    SELECT 8 x
    UNION
    SELECT 9 x
) t;
+---+-------+
| x | ntile |
+---+-------+
| 1 |     1 |
| 2 |     1 |
| 3 |     1 |
| 4 |     2 |
| 5 |     2 |
| 6 |     2 |
| 7 |     3 |
| 8 |     3 |
| 9 |     3 |
+---+-------+
mysql> SELECT * FROM revenue;
+----+------+---------+---------+
| id | year | quarter | revenue |
+----+------+---------+---------+
|  1 | 2020 | 1       |    3515 |
|  2 | 2020 | 2       |    3678 |
|  3 | 2020 | 3       |    4203 |
|  4 | 2020 | 4       |    3924 |
|  5 | 2021 | 1       |    3102 |
|  6 | 2021 | 2       |    3293 |
|  7 | 2021 | 3       |    3602 |
|  8 | 2021 | 4       |    2901 |
+----+------+---------+---------+
  • Verwenden Sie die MySQL-Funktion NTILE() , um das Jahreseinkommen in aufsteigender Reihenfolge in zwei Bereiche aufzuteilen:
mysql> SELECT
  *,
  NTILE(2) OVER (
    PARTITION BY year
    ORDER BY revenue
  ) "ntile"
FROM revenue;
+----+------+---------+---------+-------+
| id | year | quarter | revenue | ntile |
+----+------+---------+---------+-------+
|  1 | 2020 | 1       |    3515 |     1 |
|  2 | 2020 | 2       |    3678 |     1 |
|  4 | 2020 | 4       |    3924 |     2 |
|  3 | 2020 | 3       |    4203 |     2 |
|  8 | 2021 | 4       |    2901 |     1 |
|  5 | 2021 | 1       |    3102 |     1 |
|  6 | 2021 | 2       |    3293 |     2 |
|  7 | 2021 | 3       |    3602 |     2 |
+----+------+---------+---------+-------+
  • Fensterfunktion:
NTILE(2) OVER (
  PARTITION BY year
  ORDER BY revenue
)

exist OVER Untergeordneter Vers:

  • PARTITION BY year Partitionieren Sie alle Zeilen nach Jahr
  • ORDER BY revenue Sortieren Sie die Zeilen in jeder Partition in aufsteigender Reihenfolge des Umsatzes
  • NTILE(2) Teilen Sie das Einkommen jeder Partition möglichst gleichmäßig auf zwei Eimer auf. Da es 4 Reihen pro Jahr gibt, gibt es 2 Reihen pro Eimer. Die ersten beiden Zeilen jedes Jahres haben also den Bucket-Rang 1 und die letzten beiden Zeilen jedes Jahres haben den Bucket-Rang 2.

11. RANG

Die MySQL RANK()-Funktion gibt den Rang innerhalb der Partition zurück, in der sich die aktuelle Zeile befindet, beginnend bei 1, jedoch mit Intervallen. Das heißt, derselbe Wert hat den gleichen Rang, aber der nächste unterschiedliche Wert wird mithilfe der row_number()-Nummer eingestuft. Gibt es zum Beispiel 2 Erstplatzierte, dann erhält der Drittplatzierte den 3. Platz. Dies unterscheidet sich von der Funktion „dense_rank()“.

Grammatik:

RANK()
OVER (
  [PARTITION BY partition_column_list]
  [ORDER BY order_column_list]
)

Parameterbeschreibung:

  • partition_column_list: Liste der an der Partitionierung beteiligten Spalten.
  • order_column_list: Liste der an der Sortierung beteiligten Spalten.

Rückgabewert:

  • Die Rangfolge innerhalb der Partition, in der sich die aktuelle Zeile befindet, beginnend bei 1, jedoch mit Intervallen.

Beispiel:

mysql> SELECT * FROM grade;
+----+------+-------+---------+-------+
| id | name | class | subject | grade |
+----+------+-------+---------+-------+
|  1 | Tim  | A     | Math    |     9 |
|  2 | Tom  | A     | Math    |     7 |
|  3 | Jim  | A     | Math    |     8 |
|  4 | Tim  | A     | English |     7 |
|  5 | Tom  | A     | English |     8 |
|  6 | Jim  | A     | English |     7 |
|  7 | Lucy | B     | Math    |     8 |
|  8 | Jody | B     | Math    |     6 |
|  9 | Susy | B     | Math    |     9 |
| 10 | Lucy | B     | English |     6 |
| 11 | Jody | B     | English |     7 |
| 12 | Susy | B     | English |     8 |
+----+------+-------+---------+-------+
  • Sehen Sie sich das Leistungsranking jedes Schülers nach Fach an, und sehen Sie sich das Ranking jedes Schülers in jedem Fach von oben nach unten an.
mysql> SELECT *,
  RANK() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "rank",
  dense_rank() OVER (
    PARTITION BY subject
    ORDER BY grade DESC
  ) "dense_rank"
FROM grade;
+----+------+-------+---------+-------+------+------------+
| id | name | class | subject | grade | rank | dense_rank |
+----+------+-------+---------+-------+------+------------+
|  5 | Tom  | A     | English |     8 |    1 |          1 |
| 12 | Susy | B     | English |     8 |    1 |          1 |
|  4 | Tim  | A     | English |     7 |    3 |          2 |
|  6 | Jim  | A     | English |     7 |    3 |          2 |
| 11 | Jody | B     | English |     7 |    3 |          2 |
| 10 | Lucy | B     | English |     6 |    6 |          3 |
|  1 | Tim  | A     | Math    |     9 |    1 |          1 |
|  9 | Susy | B     | Math    |     9 |    1 |          1 |
|  3 | Jim  | A     | Math    |     8 |    3 |          2 |
|  7 | Lucy | B     | Math    |     8 |    3 |          2 |
|  2 | Tom  | A     | Math    |     7 |    5 |          3 |
|  8 | Jody | B     | Math    |     6 |    6 |          4 |
+----+------+-------+---------+-------+------+------------+
  • Fensterfunktion:
RANK() OVER (
  PARTITION BY subject
  ORDER BY grade DESC
)

exist OVER Untergeordneter Vers:

  • PARTITION BY subject Wird nach Disziplinen aufgeteilt
  • ORDER BY grade DESC Sortieren Sie die Zeilen in jeder Partition in umgekehrter Reihenfolge nach Punktzahl.
  • RANK() Gibt den Rang jeder Zeile innerhalb der zugehörigen Partition zurück.

        Sie können den Unterschied zwischen RANK() und dense_rank() sehen.

  • Um die Gesamtpunktzahl jedes Schülers nach Klasse anzuzeigen, müssen Sie die Rangfolge jedes Schülers in jeder Klasse entsprechend der Gesamtpunktzahl von oben nach unten anzeigen.
mysql> SELECT t.*,
  RANK() OVER (
    PARTITION BY class
    ORDER BY t.sum_grade DESC
  ) "rank"
FROM (
    SELECT class,
      name,
      sum(grade) sum_grade
    FROM grade
    GROUP BY class, name
  ) t;
+-------+------+-----------+------+
| class | name | sum_grade | rank |
+-------+------+-----------+------+
| A     | Tim  | 16        |    1 |
| A     | Tom  | 15        |    2 |
| A     | Jim  | 15        |    2 |
| B     | Susy | 17        |    1 |
| B     | Lucy | 14        |    2 |
| B     | Jody | 13        |    3 |
+-------+------+-----------+------+
  • Die Unterabfrage verwendet die GROUP BY-Klausel und sum(), um die Gesamtnote jedes Schülers nach Klasse und Schüler zusammenzufassen.​ 
mysql> SELECT class,
  name,
  sum(grade) sum_grade
FROM grade
GROUP BY class, name;
+-------+------+-----------+
| class | name | sum_grade |
+-------+------+-----------+
| A     | Tim  | 16        |
| A     | Tom  | 15        |
| A     | Jim  | 15        |
| B     | Lucy | 14        |
| B     | Jody | 13        |
| B     | Susy | 17        |
+-------+------+-----------+

        Die Hauptanweisung unterteilt diese Unterabfrage nach Klasse, sortiert dann die Gesamtpunktzahl in umgekehrter Reihenfolge innerhalb jeder Partition und verwendet RANK() , um jede Zeile innerhalb der zugehörigen Partitionsrangfolge zurückzugeben.

Guess you like

Origin blog.csdn.net/imwucx/article/details/134720314
Recommended
Ranking
#2019110700005
What materials and procedures are required for patent transfer
What is the blockchain Ethereum triplet state root transaction root receipt root
Front-end study notes 04 --- About the insertion of html pictures and videos
Documents required for the filing of WeChat Mini Programs in special industries, the filing process of WeChat Mini Programs in special industries, how to file WeChat Mini Programs in special industries
2017 Qingdao-site tournament I The Squared Mosquito Coil
[BZOJ3165][HEOI2013]Segment (line segment tree without marking)
Kettle series: KettleEasyExpand, an open source Kettle universal plugin by Ma Jinju
The latest tutorial on making framework for iOS
DAX Section 6: Statistical Functions
Daily
More
2024-05-14(9)
2024-05-13(8)
2024-05-12(28)
2024-05-11(32)
2024-05-10(34)
2024-05-09(32)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)

Code World

© 2018 codetd.com