Kategorien:

Aggregationsfunktionen (Allgemein), Fensterfunktionen (Fensterrahmen)

MAX

Gibt den maximalen Wert für die Datensätze innerhalb des Ausdrucks expr zurück. NULL-Werte werden ignoriert, es sei denn, alle Datensätze sind NULL. In diesem Fall wird ein NULL-Wert zurückgegeben.

Siehe auch::

COUNT, SUM, MIN

Syntax

Aggregatfunktion

MAX( <expr> )
Copy

Fensterfunktionen

MAX( <expr> ) [ OVER ( [ PARTITION BY <expr1> ] [ ORDER BY <expr2> [ <window_frame> ] ] ) ]
Copy

Weitere Informationen zur Syntax von window_frame finden Sie unter Syntax und Nutzung von Fensterrahmen.

Rückgabewerte

Der Datentyp des zurückgegebenen Wertes entspricht dem Datentyp des Eingabewerts.

Nutzungshinweise

  • Aus Gründen der Kompatibilität mit anderen Systemen kann das Schlüsselwort DISTINCT als Argument für die Funktion angegeben werden, aber dies hat keine Auswirkungen.

  • Wenn die Funktion als Fensterfunktion aufgerufen wird, kann das Fenster einen optionalen window_frame enthalten. Der window_frame (entweder kumulativ oder gleitend) gibt die Teilmenge der Zeilen innerhalb des Fensters an, für die die summierten Werte zurückgegeben werden sollen. Wenn kein window_frame angegeben wird, ist der Standard der folgende kumulative Fensterrahmen (gemäß dem ANSI-Standard für Fensterfunktionen):

    RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

    Weitere Informationen zu Fensterrahmen, einschließlich Syntax und Beispiele, finden Sie unter Syntax und Nutzung von Fensterrahmen.

Sortierungsdetails

  • The comparisons follow the collation based on the input arguments‘ collations and precedences.

  • The collation of the result is the same as the collation of the input.

Beispiele

In den folgenden Beispielen wird die Verwendung der Funktion MAX() gezeigt.

Erstellen Sie eine Tabelle und Daten:

CREATE OR REPLACE TABLE sample_table(k CHAR(4), d CHAR(4));

INSERT INTO sample_table VALUES
    ('1', '1'), ('1', '5'), ('1', '3'),
    ('2', '2'), ('2', NULL),
    ('3', NULL),
    (NULL, '7'), (NULL, '1');
Copy

Zeigen Sie die Daten an:

SELECT k, d
    FROM sample_table
    ORDER BY k, d;
Copy
+------+------+
| K    | D    |
|------+------|
| 1    | 1    |
| 1    | 3    |
| 1    | 5    |
| 2    | 2    |
| 2    | NULL |
| 3    | NULL |
| NULL | 1    |
| NULL | 7    |
+------+------+

Verwenden Sie die Funktion MAX, um den größten Wert in der Spalte mit dem Namen d abzurufen:

SELECT MAX(d) FROM sample_table;
Copy
+--------+                                                                      
| MAX(D) |
|--------|
| 7      |
+--------+

Kombinieren Sie die GROUP BY-Klausel mit der Funktion MAX, um den kleinsten und den größten Wert in jeder Gruppe abzurufen (wobei jede Gruppe auf dem Wert der Spalte k basiert):

SELECT k, MAX(d)
  FROM sample_table 
  GROUP BY k
  ORDER BY k;
Copy
+------+--------+                                                               
| K    | MAX(D) |
|------+--------|
| 1    | 5      |
| 2    | 2      |
| 3    | NULL   |
| NULL | 7      |
+------+--------+

Verwenden Sie eine PARTITION BY-Klausel, um die Daten basierend auf dem Wert von k in Gruppen zu unterteilen. Dies ähnelt der Verwendung von GROUP BY, ist jedoch nicht mit ihr identisch. Beachten Sie insbesondere, dass GROUP BY eine Ausgabezeile pro Gruppe erzeugt, während PARTITION BY eine Ausgabezeile pro Eingabezeile erzeugt.

SELECT k, d, MAX(d) OVER (PARTITION BY k)
  FROM sample_table
  ORDER BY k, d;
Copy
+------+------+------------------------------+                                  
| K    | D    | MAX(D) OVER (PARTITION BY K) |
|------+------+------------------------------|
| 1    | 1    | 5                            |
| 1    | 3    | 5                            |
| 1    | 5    | 5                            |
| 2    | 2    | 2                            |
| 2    | NULL | 2                            |
| 3    | NULL | NULL                         |
| NULL | 1    | 7                            |
| NULL | 7    | 7                            |
+------+------+------------------------------+

Verwenden Sie eine ORDER BY-Klausel zur Fenstererstellung (Windowing), um ein gleitendes Fenster mit einer Breite von zwei Zeilen zu erstellen, und geben Sie den höchsten Wert in diesem Fenster aus. (Denken Sie daran, dass sich ORDER BY in der Windowing-Klausel von ORDER BY auf Anweisungsebene unterscheidet.) In diesem Beispiel wird eine einzelne Partition verwendet, daher gibt es in der OVER()-Klausel keine PARTITION BY-Klausel.

SELECT k, d, MAX(d) OVER (ORDER BY k, d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
  FROM sample_table
  ORDER BY k, d;
Copy
+------+------+----------------------------------------------------------------------+
| K    | D    | MAX(D) OVER (ORDER BY K, D ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) |
|------+------+----------------------------------------------------------------------|
| 1    | 1    | 1                                                                    |
| 1    | 3    | 3                                                                    |
| 1    | 5    | 5                                                                    |
| 2    | 2    | 5                                                                    |
| 2    | NULL | 2                                                                    |
| 3    | NULL | NULL                                                                 |
| NULL | 1    | 1                                                                    |
| NULL | 7    | 7                                                                    |
+------+------+----------------------------------------------------------------------+