MIN / MAX¶

Syntaxe¶

Fonction d’agrégation

MAX( <expr> )

MIN( <expr> )

Fonction de fenêtre

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

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

Pour plus de détails sur la syntaxe de window_frame , voir Syntaxe et utilisation du cadre de fenêtre.

Renvoie¶

Le type de données de la valeur renvoyée est identique à celui des valeurs d’entrée.

Notes sur l’utilisation¶

• Pour assurer la compatibilité avec d’autres systèmes, le mot clé DISTINCT peut être spécifié en tant qu’argument pour MIN ou MAX, mais cela n’a aucun effet.

• Si la fonction est appelée en tant que fonction de fenêtrage, la fenêtre peut inclure un window_frame facultatif. Le window_frame (cumulatif ou glissant) spécifie le sous-ensemble de lignes de la fenêtre pour lesquelles les valeurs cumulées sont renvoyées. Si aucun window_frame n’est pas spécifié, la valeur par défaut est le cadre de fenêtre cumulatif suivant (conformément à la norme ANSI pour les fonctions de fenêtre) :

  RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

  Pour plus d’informations sur les cadres de fenêtre, y compris la syntaxe et des exemples, voir Syntaxe et utilisation du cadre de fenêtre.

Détails du classement¶

• 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.

Exemples¶

Le code suivant illustre l’utilisation de MIN et de MAX :

Créez une table et des données :

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');

Copy

Afficher les données :

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

Copy

Utiliser les fonctions MIN et MAX pour récupérer les valeurs les plus petites et les plus grandes dans la colonne nommée « d » :

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

Copy

Combiner la clause GROUP BY avec les fonctions MIN et MAX pour récupérer les valeurs les plus petites et les plus grandes dans chaque groupe (chaque groupe étant basé sur la valeur de la colonne k) :

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

Copy

Utiliser une clause PARTITION BY pour fractionner les données en groupes en fonction de la valeur de k. Notez que ceci est semblable à l’utilisation de GROUP BY. En particulier, notez que GROUP BY produit une ligne de sortie par groupe, tandis que PARTITION BY en génère une par ligne d’entrée.

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

Copy

Utiliser une clause ORDER BY de fenêtrage pour créer une fenêtre glissante de deux lignes de large et générer la valeur la plus élevée dans cette fenêtre. (N’oubliez pas que ORDER BY dans la clause de fenêtrage se distingue de ORDER BY au niveau de l’instruction.) Cet exemple utilise une seule partition, il n’y a donc pas de clause PARTITION BY dans la clause OVER().

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

Copy