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¶

Les sections suivantes décrivent la syntaxe de cette commande :

Sélection de toutes les colonnes
Sélection de colonnes spécifiques

Sélection de toutes les colonnes¶

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

       [ ILIKE '<pattern>' ]

       [ EXCLUDE
         {
           <col_name> | ( <col_name>, <col_name>, ... )
         }
       ]

       [ REPLACE
         {
           ( <expr> AS <col_name> [ , <expr> AS <col_name>, ... ] )
         }
       ]

       [ RENAME
         {
           <col_name> AS <col_alias>
           | ( <col_name> AS <col_alias>, <col_name> AS <col_alias>, ... )
         }
       ]

Vous pouvez spécifier les combinaisons de mots-clés suivantes après SELECT *. Les mots-clés doivent être présentés dans l’ordre indiqué ci-dessous :

SELECT * ILIKE ... REPLACE ...

SELECT * ILIKE ... RENAME ...

SELECT * ILIKE ... REPLACE ... RENAME ...

SELECT * EXCLUDE ... REPLACE ...

SELECT * EXCLUDE ... RENAME ...

SELECT * EXCLUDE ... REPLACE ... RENAME ...

SELECT * REPLACE ... RENAME ...

Sélection de colonnes spécifiques¶

[ ... ]
SELECT [ { ALL | DISTINCT } ]
       [ TOP <n> ]
       {
         [{<object_name>|<alias>}.]<col_name>
         | [{<object_name>|<alias>}.]$<col_position>
         | <expr>
       }
       [ [ AS ] <col_alias> ]
       [ , ... ]
[ ... ]

Une virgule de fin est acceptée dans une liste de colonnes. Par exemple, l’instruction SELECT suivante est prise en charge :

SELECT emp_id,
       name,
       dept,
  FROM employees;

Pour plus d’informations sur SELECT en tant qu’instruction, et sur les autres clauses de l’instruction, consultez 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. Les colonnes sont renvoyées dans l’ordre indiqué en exécutant la commande DESCRIBE sur l’objet.

Lorsque vous spécifiez *, vous pouvez également spécifier ILIKE, EXCLUDE, REPLACE, et RENAME :

ILIKE 'pattern'

Spécifie que seules les colonnes qui correspondent à pattern doivent être incluses dans les résultats.

Dans pattern, vous pouvez utiliser les caractères SQL génériques :

Utilisez un trait de soulignement (_) pour faire correspondre n’importe quel caractère unique.
Utilisez un signe de pourcentage (%) pour faire correspondre toute séquence de zéro caractère ou plus.

Pour faire correspondre une séquence n’importe où dans le nom de la colonne, commencez et terminez le modèle par %.

La correspondance est insensible à la casse.

Si aucune colonne ne correspond au modèle spécifié, une erreur de compilation se produit (001080 (42601): ... SELECT with no columns).

EXCLUDE col_name . EXCLUDE (col_name, col_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
  ...

REPLACE (expr AS col_name [ , expr AS col_name, ...] )

Remplace la valeur de col_name par la valeur de l’expression évaluée expr.

Par exemple, pour ajouter la chaîne 'DEPT-' aux valeurs de la colonne department_id, utilisez :

SELECT * REPLACE ('DEPT-' || department_id AS department_id) ...

Pour col_name :

La colonne doit exister et ne peut pas être filtrée par ILIKE ou EXCEPT.
Vous ne pouvez pas spécifier la même colonne plus d’une fois dans la liste des remplacements.
Si la colonne se trouve dans plusieurs tables (par exemple, dans les deux tables d’une jointure), l’instruction échoue avec une erreur de type « colonne ambiguë ».

expr doit évaluer une seule valeur.

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

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

Lorsque vous spécifiez une combinaison de mots-clés après SELECT * :

Vous ne pouvez pas spécifier à la fois ILIKE et EXCLUDE.
Si vous spécifiez EXCLUDE avec RENAME ou REPLACE :
- Vous devez spécifier EXCLUDE avant RENAME ou REPLACE :
  SELECT * EXCLUDE col_a RENAME col_b AS alias_b ...
  SELECT * EXCLUDE employee_id REPLACE ('DEPT-' || department_id AS department_id) ...
- Vous ne pouvez pas spécifier la même colonne dans EXCLUDE et RENAME.
Si vous spécifiez ILIKE avec RENAME ou REPLACE, vous devez d’abord spécifier ILIKE :
```
SELECT * ILIKE '%id%' RENAME department_id AS department ...
```
```
SELECT * ILIKE '%id%' REPLACE ('DEPT-' || department_id AS department_id) ...
```

Si vous spécifiez REPLACE et RENAME :

Vous devez spécifier REPLACE avant :

SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME employee_id as employee ...

Vous pouvez spécifier le même nom de colonne dans REPLACE et RENAME :

SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME department_id as department ...

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.

N’attribuez pas d’alias de colonne identique au nom d’une autre colonne référencée dans la requête. Par exemple, si vous sélectionnez des colonnes nommées prod_id et product_id, n’attribuez pas à prod_id l’alias product_id. Voir Cas d’erreur : Spécification d’un alias correspondant à un autre nom de colonne.

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.
Dans de nombreux cas, lorsque vous utilisez un alias de colonne pour une expression (par exemple expr AS col_alias) dans d’autres parties de la même requête (dans JOIN, FROM, WHERE, GROUP BY, d’autres expressions de colonne, etc.), l’expression n’est évaluée qu’une seule fois.

Notez toutefois que dans certains cas, l’expression peut être évaluée plusieurs fois, ce qui peut se traduire par des valeurs différentes pour l’alias utilisé dans différentes parties de la même requête.

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.

Pour des exemples liés à l’interrogation d’une table d’événements (dont le schéma est prédéfini par Snowflake), voir Affichage des messages de journalisation et Affichage des données de trace.

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 dont les noms correspondent à un modèle
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 dont les noms correspondent à un modèle et renommage d’une colonne
Sélection de toutes les colonnes, exclusion d’une colonne et renommage de plusieurs colonnes
Sélection de toutes les colonnes et remplacement de la valeur d’une colonne
Sélection de toutes les colonnes, remplacement de la valeur d’une colonne et renommage de la colonne
Sélection de toutes les colonnes dont les noms correspondent à un modèle et remplacement de la valeur d’une colonne
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 dont les noms correspondent à un modèle¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table avec des noms contenant id :

SELECT * ILIKE '%id%' FROM employee_table;

+-------------+---------------+
| EMPLOYEE_ID | DEPARTMENT_ID |
|-------------+---------------|
|         101 |             1 |
|         102 |             2 |
|         103 |             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 dont les noms correspondent à un modèle et renommage d’une colonne¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table avec des noms contenant id et renommer la colonne department_id :

SELECT * ILIKE '%id%' RENAME department_id AS department FROM employee_table;

+-------------+------------+
| EMPLOYEE_ID | DEPARTMENT |
|-------------+------------|
|         101 |          1 |
|         102 |          2 |
|         103 |          2 |
+-------------+------------+

Sélection de toutes les colonnes et remplacement de la valeur d’une colonne¶

Cet exemple montre comment sélectionner toutes les colonnes dans employee_table et remplacer la valeur de la colonne department_id par l’ID précédé de DEPT- :

SELECT * REPLACE ('DEPT-' || department_id AS department_id) FROM employee_table;

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

Sélection de toutes les colonnes, remplacement de la valeur d’une colonne et renommage de la colonne¶

Cet exemple montre comment sélectionner toutes les colonnes dans employee_table et remplacer la valeur de la colonne department_id par l’ID précédé de DEPT-, et renommer la colonne :

SELECT * REPLACE ('DEPT-' || department_id AS department_id) RENAME department_id AS department FROM employee_table;

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

Sélection de toutes les colonnes dont les noms correspondent à un modèle et remplacement de la valeur d’une colonne¶

Cet exemple montre comment sélectionner toutes les colonnes de employee_table dont le nom contient id et ajouter DEPT- aux valeurs de la colonne department_id :

SELECT * ILIKE '%id%' REPLACE('DEPT-' || department_id AS department_id) FROM employee_table;

+-------------+---------------+
| EMPLOYEE_ID | DEPARTMENT_ID |
|-------------+---------------|
|         101 | DEPT-1        |
|         102 | DEPT-2        |
|         103 | DEPT-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
Cas d’erreur : Spécification d’un alias correspondant à un autre nom de colonne

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

Cas d’erreur : Spécification d’un alias correspondant à un autre nom de colonne¶

Cet exemple montre pourquoi il n’est pas recommandé d’utiliser un alias de colonne correspondant au nom d’une autre colonne utilisée dans la requête. Cette requête GROUP BY entraîne une erreur de compilation SQL, et non une erreur de colonne ambiguë. L’alias prod_id attribué à product_id dans table1 correspond au nom de la colonne prod_id dans table2. La solution la plus simple à cette erreur consiste à donner à la colonne un alias différent.

CREATE OR REPLACE TABLE table1 (product_id NUMBER);

CREATE OR REPLACE TABLE table2 (prod_id NUMBER);

SELECT t1.product_id AS prod_id, t2.prod_id
  FROM table1 AS t1 JOIN table2 AS t2
    ON t1.product_id=t2.prod_id
  GROUP BY prod_id, t2.prod_id;

001104 (42601): SQL compilation error: error line 1 at position 7
'T1.PRODUCT_ID' in select clause is neither an aggregate nor in the group by clause.