MIN¶

Syntaxe¶

Fonction d’agrégation

MIN( <expr> )

Fonction de fenêtre

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

Pour plus de détails sur la syntaxe window_frame, voir Syntaxe et utilisation des fonctions 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 des raisons de compatibilité avec d’autres systèmes, vous pouvez spécifier le mot-clé DISTINCT en tant qu’argument de la fonction, 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 Notes sur l’utilisation des cadres 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¶

Ces exemples montrent comment utiliser la fonction MIN.

Créez une table et des données :

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

Afficher les données :

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

Utilisez la fonction MIN pour récupérer la plus petite valeur dans la colonne nommée d :

SELECT MIN(d) FROM sample_table;

Copy

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

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

SELECT k, MIN(d)
  FROM sample_table 
  GROUP BY k
  ORDER BY k;

Copy

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

Utilisez une clause PARTITION BY pour fractionner les données en groupes en fonction de la valeur de k. Ceci est semblable à l’utilisation de GROUP BY, sans être identique. En particulier, 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, MIN(d) OVER (PARTITION BY k)
  FROM sample_table
  ORDER BY k, d;

Copy

+------+------+------------------------------+                                  
| K    | D    | MIN(D) OVER (PARTITION BY K) |
|------+------+------------------------------|
| 1    | 1    | 1                            |
| 1    | 3    | 1                            |
| 1    | 5    | 1                            |
| 2    | 2    | 2                            |
| 2    | NULL | 2                            |
| 3    | NULL | NULL                         |
| NULL | 1    | 1                            |
| NULL | 7    | 1                            |
+------+------+------------------------------+

Utilisez une clause ORDER BY pour créer une fenêtre glissante de deux lignes de large et générer la valeur la plus faible dans cette fenêtre. (N’oubliez pas que ORDER BY dans la clause OVER 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, MIN(d) OVER (ORDER BY k, d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
  FROM sample_table
  ORDER BY k, d;

Copy

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