Catégories :

Fonctions d’agrégation (Général), Fonctions de la fenêtre (Cadre de fenêtre)

MIN / MAX

Renvoie la valeur minimale ou maximale des enregistrements correspondants à expr. Les valeurs NULL sont ignorées sauf si tous les enregistrements sont NULL, auquel cas une valeur NULL est renvoyée.

Voir aussi

COUNT , SUM

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 d’informations sur la syntaxe cadre_fenêtre , 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 cadre_fenêtre facultatif. cadre_fenêtre (cumulatif ou glissant) spécifie le sous-ensemble de lignes de la fenêtre pour lesquelles les valeurs cumulées sont renvoyées. Si cadre_fenêtre 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');

Afficher les données :

SELECT k, d FROM minmax_example;

Sortie :

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

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;

Sortie :

+--------+--------+
| MIN(D) | MAX(D) |
|--------+--------|
| 1      | 7      |
+--------+--------+

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;

Sortie :

+------+--------+--------+
| K    | MIN(D) | MAX(D) |
|------+--------+--------|
| 1    | 1      | 5      |
| 2    | 2      | 2      |
| 3    | NULL   | NULL   |
| NULL | 1      | 7      |
+------+--------+--------+

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;

Sortie :

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

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

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

Sortie :

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