Pour retrouver les données d'une table, elle est
interrogée. Une instruction SQL
SELECT
est utilisée pour faire cela. L'instruction est
divisée en liste de sélection (la partie qui liste les colonnes à
retourner), une liste de tables (la partie qui liste les tables à partir
desquelles les données seront retrouvées) et une qualification optionnelle
(la partie qui spécifie les restrictions). Par exemple, pour retrouver
toutes les lignes de la table temps
,
saisissez :
SELECT * FROM temps;
Ici, *
est un raccourci pour « toutes les
colonnes ».
[2]
Donc, le même résultat pourrait être obtenu avec :
SELECT ville, t_basse, t_haute, prcp, date FROM temps;
Le résultat devrait être ceci :
ville | t_basse | t_haute | prcp | date ---------------+---------+---------+------+------------ San Francisco | 46 | 50 | 0.25 | 1994-11-27 San Francisco | 43 | 57 | 0 | 1994-11-29 Hayward | 37 | 54 | | 1994-11-29 (3 rows)
Vous pouvez écrire des expressions, pas seulement des références à de simples colonnes, dans la liste de sélection. Par exemple, vous pouvez faire :
SELECT ville, (t_haute+t_basse)/2 AS temp_moy, date FROM temps;
Cela devrait donner :
ville | temp_moy | date ---------------+----------+------------ San Francisco | 48 | 1994-11-27 San Francisco | 50 | 1994-11-29 Hayward | 45 | 1994-11-29 (3 rows)
Notez comment la clause AS
est utilisée pour renommer
la sortie d'une colonne (cette clause AS
est
optionnelle).
Une requête peut être « qualifiée » en ajoutant une clause
WHERE
qui spécifie les lignes souhaitées. La clause
WHERE
contient une expression booléenne et seules les
lignes pour lesquelles l'expression booléenne est vraie sont renvoyées. Les
opérateurs booléens habituels (AND
,
OR
et NOT
) sont autorisés dans la
qualification. Par exemple, ce qui suit recherche le temps à San Francisco
les jours pluvieux :
SELECT * FROM temps WHERE ville = 'San Francisco' AND prcp > 0.0;
Résultat :
ville | t_basse | t_haute | prcp | date ---------------+---------+---------+------+------------ San Francisco | 46 | 50 | 0.25 | 1994-11-27 (1 row)
Vous pouvez demander à ce que les résultats d'une requête soient renvoyés dans un ordre trié :
SELECT * FROM temps ORDER BY ville;
ville | t_basse | t_haute | prcp | date --------------+---------+---------+------+------------ Hayward | 37 | 54 | | 1994-11-29 San Francisco | 43 | 57 | 0 | 1994-11-29 San Francisco | 46 | 50 | 0.25 | 1994-11-27
Dans cet exemple, l'ordre de tri n'est pas spécifié complètement, donc vous pouvez obtenir les lignes San Francisco dans n'importe quel ordre. Mais, vous auriez toujours obtenu les résultats affichés ci-dessus si vous aviez fait :
SELECT * FROM temps ORDER BY ville, t_basse;
Vous pouvez demander que les lignes dupliquées soient supprimées du résultat d'une requête :
SELECT DISTINCT ville FROM temps;
ville --------------- Hayward San Francisco (2 rows)
De nouveau, l'ordre des lignes résultat pourrait varier. Vous pouvez vous
assurer des résultats cohérents en utilisant DISTINCT
et ORDER BY
ensemble :
[3]
SELECT DISTINCT ville FROM temps ORDER BY ville;
[2]
Alors que SELECT *
est utile pour des requêtes rapides,
c'est généralement considéré comme un mauvais style dans un code en
production, car l'ajout d'une colonne dans la table changerait les
résultats.
[3]
Dans certains systèmes de bases de données, ceci incluant les anciennes
versions de PostgreSQL, l'implémentation de
DISTINCT
ordonne automatiquement les lignes. Du coup,
ORDER BY
n'est pas nécessaire. Mais, ceci n'est pas
requis par le standard SQL et PostgreSQL ne
vous garantit pas actuellement que DISTINCT
ordonne
les lignes.