SELECT¶

SELECT peut être utilisé soit comme une instruction, soit comme une clause dans d’autres instructions :

En tant qu’instruction, l’instruction SELECT est l’instruction SQL la plus couramment exécutée ; elle interroge la base de données et extrait un ensemble de lignes.
Comme clause, SELECT définit l’ensemble des colonnes retournées par une requête.

Voir aussi :: Syntaxe de requête

Syntaxe¶

[ ... ]
SELECT [ { ALL | DISTINCT } ]
       [ TOP <n> ]
       {

         -- Selecting all columns.
         [{<object_name>|<alias>}.]*
         [ EXCLUDE
           {
             <col_name>
             | ( <col_name>, <col_name>, ... )
           }
         ]
         [ RENAME
           {
             <col_name> AS <col_alias>
             | ( <col_name> AS <col_alias>, <col_name> AS <col_alias>, ... )
           }
         ]

       |

         -- Selecting specific columns.
         {
           [{<object_name>|<alias>}.]<col_name>
           | [{<object_name>|<alias>}.]$<col_position>
           | <expr>
         }
         [ [ AS ] <col_alias> ]
       }
       [ , ... ]
[ ... ]

Pour plus d’informations sur SELECT en tant qu’instruction, et sur les autres clauses de cette instruction, voir Syntaxe de requête.

Paramètres¶

ALL | DISTINCT

Indique si l’élimination des doublons doit être effectuée sur le jeu de résultats :

ALL inclut toutes les valeurs dans le jeu de résultats.
DISTINCT élimine les valeurs en double du jeu de résultats.

Par défaut : ALL

TOP n

Spécifie le nombre maximum de résultats à renvoyer. Voir TOP <n>.

object_name ou . alias

Indique l’identificateur d’objet ou l’alias d’objet tel que défini dans la clause FROM.

*

L’astérisque est un raccourci pour indiquer que la sortie doit inclure toutes les colonnes de l’objet spécifié, ou toutes les colonnes de tous les objets si * n’est pas qualifié avec un nom ou un alias d’objet.

EXCLUDE col_name . EXCLUDE (col_name, col_name, ...)

Lorsque vous sélectionnez toutes les colonnes (SELECT * ou SELECT table_name.*), spécifie les colonnes qui doivent être exclues des résultats.

Si vous effectuez une sélection à partir de plusieurs tables, utilisez SELECT table_name.* pour spécifier que vous voulez sélectionner toutes les colonnes d’une table spécifique et spécifiez le nom non qualifié de la colonne dans EXCLUDE. Par exemple :

SELECT table_a.* EXCLUDE column_in_table_a ,
  table_b.* EXCLUDE column_in_table_b
  ...

RENAME col_name AS col_alias . RENAME (col_name AS col_alias, col_name AS col_alias, ...)

Lorsque vous sélectionnez toutes les colonnes (SELECT * ou SELECT table_name.*), spécifie les alias de colonnes qui doivent être utilisés dans les résultats.

SELECT table_a.* RENAME column_in_table_a AS col_alias_a,
  table_b.* RENAME column_in_table_b AS col_alias_b
  ...

Note

Si vous spécifiez à la fois EXCLUDE et RENAME après SELECT * :

Vous devez spécifier EXCLUDE avant RENAME :

SELECT * EXCLUDE col_a RENAME col_b AS alias_b ...

Vous ne pouvez pas spécifier la même colonne dans EXCLUDE et RENAME.

col_name: Spécifie l’identificateur de colonne tel que défini dans la clause FROM.
$col_position: Spécifie la position de la colonne (basée sur 1) telle que définie dans la clause FROM. Si une colonne est référencée à partir d’une table, ce nombre ne peut pas dépasser le nombre maximum de colonnes dans la table.
expr: Spécifie une expression, telle qu’une expression mathématique, qui évalue à une valeur spécifique pour une ligne donnée.
[ AS ] col_alias: Spécifie l’alias de colonne attribué à l’expression de sortie. Il est utilisé comme nom d’affichage dans une liste SELECT de niveau supérieur et comme nom de colonne dans une vue en ligne.

Notes sur l’utilisation¶

Les alias et identificateurs sont insensibles à la casse par défaut. Pour préserver la casse, placez les lettres entre guillemets ("). Pour plus d’informations, voir Identificateurs d’objet.
Sans clause ORDER BY, les résultats renvoyés par SELECT sont un ensemble non ordonné. L’exécution répétée de la même requête dans les mêmes tables peut entraîner un ordre de sortie différent à chaque fois. Si l’ordre compte, utilisez la clause ORDER BY.
SELECT peut être utilisé non seulement comme une instruction indépendante, mais aussi en tant que clause dans d’autres instructions, par exemple INSERT INTO ... SELECT ...;. SELECT peut également être utilisé dans une sous-requête dans une instruction.

Exemples¶

Voici quelques exemples simples.

Configuration des données pour les exemples
Exemples de sélection de toutes les colonnes (SELECT *)
Exemples de sélection de colonnes spécifiques (SELECT colname)

De nombreux exemples supplémentaires sont inclus dans d’autres parties de la documentation, y compris la description détaillée de Syntaxe de requête.

Configuration des données pour les exemples¶

Certaines de ces requêtes ci-dessous utilisent les tables et les données suivantes :

CREATE TABLE employee_table (
    employee_ID INTEGER,
    last_name VARCHAR,
    first_name VARCHAR,
    department_ID INTEGER
    );

CREATE TABLE department_table (
    department_ID INTEGER,
    department_name VARCHAR
    );

INSERT INTO employee_table (employee_ID, last_name, first_name, department_ID) VALUES
    (101, 'Montgomery', 'Pat', 1),
    (102, 'Levine', 'Terry', 2),
    (103, 'Comstock', 'Dana', 2);

INSERT INTO department_table (department_ID, department_name) VALUES
    (1, 'Engineering'),
    (2, 'Customer Support'),
    (3, 'Finance');

Exemples de sélection de toutes les colonnes (SELECT *)¶

Sélection de toutes les colonnes de la table
Sélection de toutes les colonnes à l’exception d’une colonne
Sélection de toutes les colonnes à l’exception de deux colonnes ou plus
Sélection de toutes les colonnes et renommage d’une colonne
Sélection de toutes les colonnes et renommage de plusieurs colonnes
Sélection de toutes les colonnes, exclusion d’une colonne et renommage de plusieurs colonnes
Sélection de toutes les colonnes de plusieurs tables, exclusion d’une colonne et renommage d’une colonne

Sélection de toutes les colonnes de la table¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table :

SELECT * FROM employee_table;

+-------------+------------+------------+---------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT_ID |
|-------------+------------+------------+---------------|
|         101 | Montgomery | Pat        |             1 |
|         102 | Levine     | Terry      |             2 |
|         103 | Comstock   | Dana       |             2 |
+-------------+------------+------------+---------------+

Sélection de toutes les colonnes à l’exception d’une colonne¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table à l’exception de la colonne department_id :

SELECT * EXCLUDE department_id FROM employee_table;

+-------------+------------+------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME |
|-------------+------------+------------|
|         101 | Montgomery | Pat        |
|         102 | Levine     | Terry      |
|         103 | Comstock   | Dana       |
+-------------+------------+------------+

Sélection de toutes les colonnes à l’exception de deux colonnes ou plus¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table à l’exception des colonnes department_id et employee_id :

SELECT * EXCLUDE (department_id, employee_id) FROM employee_table;

+------------+------------+
| LAST_NAME  | FIRST_NAME |
|------------+------------|
| Montgomery | Pat        |
| Levine     | Terry      |
| Comstock   | Dana       |
+------------+------------+

Sélection de toutes les colonnes et renommage d’une colonne¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table et renommage de la colonne department_id :

SELECT * RENAME department_id AS department FROM employee_table;
+-------------+------------+------------+------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT |
|-------------+------------+------------+------------|
|         101 | Montgomery | Pat        |          1 |
|         102 | Levine     | Terry      |          2 |
|         103 | Comstock   | Dana       |          2 |
+-------------+------------+------------+------------+

Sélection de toutes les colonnes et renommage de plusieurs colonnes¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table et renommer les colonnes department_id et employee_id :

SELECT * RENAME (department_id AS department, employee_id AS id) FROM employee_table;

+-----+------------+------------+------------+
|  ID | LAST_NAME  | FIRST_NAME | DEPARTMENT |
|-----+------------+------------+------------|
| 101 | Montgomery | Pat        |          1 |
| 102 | Levine     | Terry      |          2 |
| 103 | Comstock   | Dana       |          2 |
+-----+------------+------------+------------+

Sélection de toutes les colonnes, exclusion d’une colonne et renommage de plusieurs colonnes¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table, exclure la colonne first_name et renommer les colonnes department_id et employee_id :

SELECT * EXCLUDE first_name RENAME (department_id AS department, employee_id AS id) FROM employee_table;

+-----+------------+------------+
|  ID | LAST_NAME  | DEPARTMENT |
|-----+------------+------------|
| 101 | Montgomery |          1 |
| 102 | Levine     |          2 |
| 103 | Comstock   |          2 |
+-----+------------+------------+

Sélection de toutes les colonnes de plusieurs tables, exclusion d’une colonne et renommage d’une colonne¶

Cet exemple joint deux tables et sélectionne toutes les colonnes des deux tables sauf une colonne de employee_table. L’exemple renomme également l’une des colonnes sélectionnées dans department_table.

SELECT
  employee_table.* EXCLUDE department_id,
  department_table.* RENAME department_name AS department
FROM employee_table INNER JOIN department_table
  ON employee_table.department_id = department_table.department_id
ORDER BY department, last_name, first_name;

+-------------+------------+------------+---------------+------------------+
| EMPLOYEE_ID | LAST_NAME  | FIRST_NAME | DEPARTMENT_ID | DEPARTMENT       |
|-------------+------------+------------+---------------+------------------|
|         103 | Comstock   | Dana       |             2 | Customer Support |
|         102 | Levine     | Terry      |             2 | Customer Support |
|         101 | Montgomery | Pat        |             1 | Engineering      |
+-------------+------------+------------+---------------+------------------+

Exemples de sélection de colonnes spécifiques (SELECT colname)¶

Sélection d’une seule colonne par son nom
Sélection de plusieurs colonnes par leur nom dans des tables jointes
Sélection d’une colonne par sa position
Spécification d’un alias pour une colonne dans la sortie

Sélection d’une seule colonne par son nom¶

Cet exemple montre comment rechercher le nom de famille d’un employé si vous connaissez son ID.

SELECT last_name FROM employee_table WHERE employee_ID = 101;
+------------+
| LAST_NAME  |
|------------|
| Montgomery |
+------------+

Sélection de plusieurs colonnes par leur nom dans des tables jointes¶

Cet exemple énumère chaque employé et le nom du service dans lequel il travaille. Les résultats sont classés dans l’ordre par nom de service, et au sein de chaque service, les employés sont classés dans l’ordre alphabétique. Cette requête utilise un Join pour relier les informations d’une table à celles d’une autre table.

SELECT department_name, last_name, first_name
    FROM employee_table INNER JOIN department_table
        ON employee_table.department_ID = department_table.department_ID
    ORDER BY department_name, last_name, first_name;
+------------------+------------+------------+
| DEPARTMENT_NAME  | LAST_NAME  | FIRST_NAME |
|------------------+------------+------------|
| Customer Support | Comstock   | Dana       |
| Customer Support | Levine     | Terry      |
| Engineering      | Montgomery | Pat        |
+------------------+------------+------------+

Sélection d’une colonne par sa position¶

Cet exemple montre comment utiliser $ pour spécifier une colonne par son numéro, plutôt que par son nom :

SELECT $2 FROM employee_table ORDER BY $2;
+------------+
| $2         |
|------------|
| Comstock   |
| Levine     |
| Montgomery |
+------------+

Spécification d’un alias pour une colonne dans la sortie¶

Cet exemple montre que les colonnes de sortie n’ont pas besoin d’être prises directement dans les tables de la clause FROM ; les colonnes de sortie peuvent être des expressions générales. Cet exemple calcule l’aire d’un cercle dont le rayon est de 2.0. Cet exemple montre également comment utiliser un alias de colonne pour que la sortie ait un nom de colonne significatif :

SELECT pi() * 2.0 * 2.0 AS area_of_circle;
+----------------+
| AREA_OF_CIRCLE |
|----------------|
|   12.566370614 |
+----------------+