Kategorien:

Aggregatfunktionen (Allgemein), Fensterfunktionen (Fensterrahmen)

MIN / MAX

Gibt den minimalen oder maximalen Wert für die Datensätze innerhalb von Ausdruck 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 Fensterrahmen finden Sie unter Fensterrahmensyntax und Verwendung.

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 Fensterrahmen enthalten. Der Fensterrahmen (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 Fensterrahmen 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 Beispielen, finden Sie unter Fensterrahmensyntax und Verwendung.

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;

Ausgabe:

+------+------+
| K    | D    |
|------+------|
| 1    | 1    |
| 1    | 5    |
| 1    | 3    |
| 2    | 2    |
| 2    | NULL |
| 3    | NULL |
| NULL | 7    |
| NULL | 1    |
+------+------+

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;

Ausgabe:

+--------+--------+
| 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;

Ausgabe:

+------+--------+--------+
| 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;

Ausgabe:

+------+------+------------------------------+
| K    | D    | MAX(D) OVER (PARTITION BY K) |
|------+------+------------------------------|
| 1    | 1    | 5                            |
| 1    | 5    | 5                            |
| 1    | 3    | 5                            |
| 2    | 2    | 2                            |
| 2    | NULL | 2                            |
| 3    | NULL | NULL                         |
| NULL | 7    | 7                            |
| NULL | 1    | 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.)

SELECT k, d, MAX(d) OVER (ORDER BY k ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
  FROM minmax_example;

Ausgabe:

+------+------+-------------------------------------------------------------------+
| K    | D    | MAX(D) OVER (ORDER BY K ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) |
|------+------+-------------------------------------------------------------------|
| 1    | 1    | 1                                                                 |
| 1    | 5    | 5                                                                 |
| 1    | 3    | 5                                                                 |
| 2    | 2    | 3                                                                 |
| 2    | NULL | 2                                                                 |
| 3    | NULL | NULL                                                              |
| NULL | 7    | 7                                                                 |
| NULL | 1    | 7                                                                 |
+------+------+-------------------------------------------------------------------+