Kategorien:

Aggregatfunktionen (Allgemein), Fensterfunktionen (Fensterrahmen)

MIN / MAX

Gibt den minimalen oder maximalen Wert für die Datensätze innerhalb von 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

Syntax

Aggregatfunktion

MAX( <expr> )

MIN( <expr> )

Fensterfunktionen

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

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

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 MIN oder MAX angegeben werden. Es hat jedoch 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

Der folgende Code veranschaulicht die Verwendung von MIN und MAX:

Erstellen Sie eine Tabelle und Daten:

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

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

Zeigen Sie die Daten an:

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

Verwenden Sie die Funktionen MIN und MAX, um den kleinsten und den größten Wert in der Spalte „d“ abzurufen:

SELECT MIN(d), MAX(d) FROM minmax_example;
+--------+--------+
| MIN(D) | MAX(D) |
|--------+--------|
| 1      | 7      |
+--------+--------+

Kombinieren Sie die GROUP BY-Klausel mit den Funktionen MIN und 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, MIN(d), MAX(d)
  FROM minmax_example 
  GROUP BY k
  ORDER BY k;
+------+--------+--------+
| K    | MIN(D) | MAX(D) |
|------+--------+--------|
| 1    | 1      | 5      |
| 2    | 2      | 2      |
| 3    | NULL   | NULL   |
| NULL | 1      | 7      |
+------+--------+--------+

Verwenden Sie eine PARTITION BY-Klausel, um die Daten basierend auf dem Wert von k in Gruppen zu unterteilen. Beachten Sie, dass dies der Verwendung von GROUP BY ähnelt, jedoch nicht mit ihr identisch ist. 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 minmax_example
  ORDER BY k, d;
+------+------+------------------------------+
| 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 minmax_example
  ORDER BY k, d;
+------+------+----------------------------------------------------------------------+
| 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                                                                    |
+------+------+----------------------------------------------------------------------+
⇧
Zurück zum Anfang