Catégories :: Fonctions d’agrégation (général)

MIN_BY / MAX_BY¶

Recherche la ou les lignes contenant la valeur minimale ou maximale d’une colonne et renvoie la valeur d’une autre colonne dans cette ligne.

Par exemple, si une table contient les colonnes employee_id et salary, MIN_BY(employee_id, salary) renvoie la valeur de la colonne employee_id pour la ligne dont la valeur de la colonne salary est la plus faible.

Si plusieurs lignes contiennent la valeur minimale ou maximale spécifiée, la fonction est non déterministe.

Pour renvoyer les valeurs de plusieurs lignes, spécifiez l’argument facultatif maximum_number_of_values_to_return. Avec cet argument supplémentaire :

La fonction renvoie un ARRAY contenant les valeurs d’une colonne pour les lignes ayant les valeurs les plus basses ou les plus hautes d’une colonne spécifiée.
Les valeurs dans les ARRAY sont triées par leurs valeurs correspondantes dans la colonne contenant les valeurs minimales ou maximales.
Si plusieurs lignes contiennent ces valeurs les plus basses ou les plus hautes, la fonction est non déterministe.

Par exemple, MIN_BY(employee_id, salary, 5) renvoie un ARRAY des valeurs de la colonne employee_id pour les cinq lignes contenant les valeurs les plus basses de la colonne salary. Les IDs de ARRAY sont triés par les valeurs correspondantes de la colonne salary.

Voir aussi: MIN / MAX

Syntaxe¶

MIN_BY( <col_to_return>, <col_containing_mininum> [ , <maximum_number_of_values_to_return> ] )

MAX_BY( <col_to_return>, <col_containing_maximum> [ , <maximum_number_of_values_to_return> ] )

Arguments¶

Obligatoire :

col_to_return: Colonne contenant la valeur à renvoyer.
col_containing_mininum , . col_containing_maximum: Colonne contenant la valeur minimale ou maximale.

Facultatif :

maximum_number_of_values_to_return: Nombre entier constant spécifiant le nombre maximum de valeurs à renvoyer. Vous devez spécifier un nombre positif. Le nombre maximum que vous pouvez spécifier est 1000.

Renvoie¶

Si maximum_number_of_values_to_return n’est pas spécifié, la fonction renvoie une valeur du même type que col_to_return.
Si maximum_number_of_values_to_return est spécifié, la fonction renvoie un ARRAY contenant des valeurs du même type que col_to_return. Les valeurs dans les ARRAY sont triées par leurs valeurs col_containing_mininum / col_containing_maximum correspondantes.

Par exemple, MIN_BY(employee_id, salary, 5) renvoie les IDs des employés ayant les cinq salaires les plus bas, triés par salary (dans l’ordre décroissant).

Notes sur l’utilisation¶

La fonction ignore les valeurs NULL dans col_containing_mininum et col_containing_maximum.
Si toutes les valeurs de col_containing_mininum ou col_containing_maximum sont NULL, la fonction renvoie NULL (que l’argument facultatif maximum_number_of_values_to_return soit spécifié ou non).

Exemples¶

Ces exemples montrent comment utiliser les fonctions MIN_BY et MAX_BY.

Pour exécuter ces exemples, exécutez les instructions suivantes pour configurer la table et les données pour les exemples :

CREATE OR REPLACE TABLE employees(employee_id NUMBER, department_id NUMBER, salary NUMBER);

INSERT INTO employees VALUES
  (1001, 10, 10000),
  (1020, 10, 9000),
  (1030, 10, 8000),
  (900, 20, 15000),
  (2000, 20, NULL),
  (2010, 20, 15000);

Exécutez l’instruction suivante pour afficher le contenu de cette table :

SELECT * FROM employees;

+-------------+---------------+--------+
| EMPLOYEE_ID | DEPARTMENT_ID | SALARY |
|-------------+---------------+--------|
|        1001 |            10 |  10000 |
|        1020 |            10 |   9000 |
|        1030 |            10 |   8000 |
|         900 |            20 |  15000 |
|        2000 |            20 |   NULL |
|        2010 |            20 |  15000 |
+-------------+---------------+--------+

L’exemple suivant renvoie les IDs des employés dont le salaire est le plus élevé et le plus bas :

SELECT MIN_BY(employee_id, salary), MAX_BY(employee_id, salary) from employees;

+-----------------------------+-----------------------------+
| MIN_BY(EMPLOYEE_ID, SALARY) | MAX_BY(EMPLOYEE_ID, SALARY) |
|-----------------------------+-----------------------------|
|                        1030 |                         900 |
+-----------------------------+-----------------------------+

Remarques :

Étant donné que plus d’une ligne contient la valeur maximale de la colonne salary , la fonction est non déterministe et pourrait renvoyer l’ID de l’employé pour une ligne différente lors d’exécutions ultérieures.
La fonction ignore la valeur NULL de la colonne salary lors de la détermination des lignes avec les valeurs minimum et maximum.

L’exemple suivant renvoie un ARRAY contenant les IDs des employés ayant les trois salaires les plus élevés et les plus bas :

SELECT MIN_BY(employee_id, salary, 3), MAX_BY(employee_id, salary, 3) from employees;

+--------------------------------+--------------------------------+
| MIN_BY(EMPLOYEE_ID, SALARY, 3) | MAX_BY(EMPLOYEE_ID, SALARY, 3) |
|--------------------------------+--------------------------------|
| [                              | [                              |
|   1030,                        |   900,                         |
|   1020,                        |   2010,                        |
|   1001                         |   1001                         |
| ]                              | ]                              |
+--------------------------------+--------------------------------+

Comme le montre l’exemple, les valeurs du ARRAY sont triées en fonction des valeurs correspondantes de la colonne salary :

MIN_BY renvoie les IDs des employés triés par leur salaire dans l’ordre croissant.
MAX_BY renvoie les IDs des employés triés par leur salaire dans l’ordre décroissant.

Si plusieurs de ces lignes contiennent la même valeur dans la colonne salary , l’ordre des valeurs renvoyées pour ce salaire est non déterministe.