SELECT

Clause FROM

La clause FROM spécifie une ou plusieurs table sources pour le SELECT. Si plusieurs sources sont spécifiées, le résultat est conceptuellement le produit cartésien de toutes les lignes dans toutes les sources --- mais habituellement les conditions de qualification sont ajoutées pour limiter les lignes retournées à un sous-ensemble du produit cartésien.

Quand FROM est un simple nom de table, il inclut implicitement les lignes des sous-tables (enfant dans l'héritage) de la table. ONLY supprimera les lignes des sous-tables de la table. Avant PostgreSQL 7.1, c'était le résultat par défaut, et l'ajout de sous-tables était réalisé en ajoutant * au nom de la table. Cet ancien comportement est disponible via la commande SET SQL_Inheritance TO OFF;

Un FROM pzut aussi être une sous-sélection entre parenthèses (notez qu'une clause alias est nécessaire pour une sous-sélection !).C'est une fonctionnalité très commode car c'est le seul moyen d'obtenir des niveaux multiples de groupage, agrégation, ou triage dans une seule requête.

Finalement, un FROM peut être une clause JOIN, qui combine deux FROM plus simples. (Utilisez les parenthèses si nécessaire pour déterminer l'ordre).

Une CROSS JOIN ou INNER JOIN est un simple produit cartésien, le même que vous obtenez en listant les deux items au niveau supérieur de FROM. CROSS JOIN est équivalent à INNER JOIN ON (TRUE), aucune ligne n'est supprimée par la qualification. Ces types de jointures ne sont que des conventions de notation, car elles ne font rien que vous pouvez faire avec des FROM et WHERE pleinement qualifiés.

LEFT OUTER JOIN renvoit toutes les lignes dans le produit cartésien qualifié (i.e., toutes les lignes combinées qui passent la condition ON), plus une copie de chaque ligne dans le côté gauche de la table pour lequel il n'y a pas de côté droit qui satisfasse la condition ON. Cette ligne côté gauche est étendue sur la largeur complète de la table jointe en insérant des NULL dans les colonnes côté droit. Notez que seule la propre condition de jointure de ON ou USING est prise en considération lors de la décision de savoir quelles lignes sont appariées. Les conditions ON ou WHERE sont appliquées plus tard.

À l'inverse, RIGHT OUTER JOIN retourne toutes les lignes jointes, plus une ligne pour chaque ligne côté droit non appariée (étendue avec des NULL côté gauche). C'est juste une convention de notation, car vous pouvez la convertir en LEFT OUTER JOIN en basculant les entrées droite et gauche.

FULL OUTER JOIN renvoit toutes les lignes jointes, plus une ligne pour chaque ligne côté gauche non appariée (étendue avec des NULL côté droit), plus une ligne pour chaque ligne côté droit non appariée (étendue avec des NULL côté gauche).

Pour tous les types JOIN sauf CROSS JOIN, vous devez écrire exactement un des ON join_condition, USING ( join_column_list ), ou NATURAL. ON est le cas le plus général : vous pouvez écrire une expression de qualification comprenant les deux tables à joindre. Une liste de colonne USING ( a, b, ... ) est un raccourci pour la condition ON left_table.a = right_table.a AND left_table.b = right_table.b ... Également, USING implique que seule une paire de chaque colonne équivalente sera inclue dans la sortie JOIN, pas les deux. NATURAL est un raccourci pour une liste USING qui mentionne toutes les colonnes nommées de façon similaire dans les tables.

Clause WHERE

La condition optionnelle WHERE a la forme générale :

WHERE boolean_expr
    

     expr cond_op expr
    

     log_op expr
    

Clause GROUP BY

GROUP BY spécifie une table groupée dérivée de l'application de cette clause :

GROUP BY expression [, ...]
    

GROUP BY condensera en une seule ligne toutes les lignes sélectionnées qui partagent les mêmes valeurs pour les colonnes groupées. Les fonctions agrégat, si elles existent, sont calculées à travers toutes les lignes complétant chaque groupe, produisant une valeur séparée pour chaque groupe (puisque sans GROUP BY, un agrégat produit une seule valeur calculée à travers toutes les lignes sélectionnées). Quand GROUP BY est présent, il n'est pas valide pour l'expression de sortie de SELECT de se référer aux colonnes non groupées sauf dans des fonctions agrégat, car elles auront plus d'une valeur possible à retourner pour une colonne non groupée.

A GROUP BY peut être un nom de colonne d'entrée, ou le nom ou le chiffre ordinal d'une sortie colonne (expression SELECT), ou ce peut être une expression arbitraire formée de valeurs d'entrées colonnes. En cas d'ambiguïté, un nom GROUP BY sera interprété comme un nom d'entrée colonne d'avantage que comme un nom de sortie colonne.

Clause HAVING

a condition optionnelle HAVING a la forme générale :

HAVING boolean_expr
    

HAVING spécifie une table groupée dérivée par l'élimination de groupes de lignes qui ne satisfont pas boolean_expr. HAVING est différent de WHERE: WHERE filtre les lignes individuelles avant l'application de GROUP BY, tandis que HAVING filtre les groupes de lignes crées par GROUP BY.

Chaque colonne référencée dans boolean_expr dera sans ambiguïté référence à un groupement de colonnes, à moins que la référence apparaisse dans une fonction agrégat.

Clause ORDER BY

ORDER BY expression [ ASC | DESC | USING operator ] [, ...]
    

Un ORDER BY peut être le nom ou le nombre ordinal d'une sortie colonne (expression SELECT), ou un expression arbitraire formée des valeurs d'entrées colonnes. En cas d'ambiguïté, un nom ORDER BY sera interprété comme un nom de sortie colonne.

Le nombre ordinal se réfère à la position ordinale (de gauche à droite) de la colonne résultante. Cette fonctionnalité fait qu'il est possible de définir un ordre sur la base d'une colonne qui n'a pas de nom propre. Ce n'est jamais absolument nécessaire car il est toujours possible d'assigner un nom à la colonne résultante en utilisant la clause AS, ex. :

SELECT title, date_prod + 1 AS newlen FROM films ORDER BY newlen;
    

Il est aussi possible de faire un ORDER BY sur des expressions arbitraires (une extension vers SQL92), incluant les champs qui n'apparaissent pas dans le résultat du SELECT. Ainsi l'instruction suivante est valide :

SELECT name FROM distributors ORDER BY code;
    

Notez que si un ORDER BY est un simple nom qui apparie ensemble un résultat de nom de colonne et un nom d'entrée colonne, ORDER BY l'interprétera comme nom de colonne résultat. C'est à l'opposé du choix que GROUP BY ferait dans la même situation. Cette inconsistence est autorisée dans le standard SQL92.

Optionnellement on peut ajouter le mot-clé DESC (descendant) ou ASC (ascendant) après chaque nom de colonne dans la clause ORDER BY. Si non spécifié, ASC est prit par défaut. De façon alternative, un nom d'opérateur d'ordonnancement spécifique peut être spécifié. ASC est équivalent à USING < et DESC est équivalent à USING >.

La valeur null trie certaines autres valeurs dans le domaine. En d'autres termes, avec un tri ascendant les null font un tri à la fin et avec un tri descendant ils font le tri au début.

Clause UNION

table_query UNION [ ALL ] table_query
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    

L'opérateur UNION calcule l'ensemble des lignes retournées par les requêtes incluses. Les deux SELECT qui représentent les opérandes directes de UNION doivent produire le même nombre de colonnes, et les colonnes correspondantes doivent être de types compatibles.

Le résultat de UNION ne contient pas de lignes dupliquées à moins que l'option ALL soit spécifiée. ALL évite l'élimination des dupliquées.

Les opérateurs multiples UNION dans la même instruction SELECT sont évalués de gauche à droite, à moins qu'ils soient entre parenthèses.

Couramment, FOR UPDATE ne peut pas être spécifié soit pour un résultat UNION soit pour les entrées de UNION.

Clause INTERSECT

table_query INTERSECT [ ALL ] table_query
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    

INTERSECT est similaire à UNION, excepté qu'elle produit seulement les lignes apparaissant dans les deux sorties de requête, plus que les lignes apparaissant dans chacune séparément.

Le résultat d'un INTERSECT ne contient pas de lignes dupliquées sauf si l'option ALL option est spécifiée. Avec ALL, une ligne qui a m duplicats dans L et n duplicats dans R apparaitra min(m,n) fois.

Les opérateurs INTERSECT multiples dans la même instruction SELECT sont évalués de gauche à droite, sauf si des parenthèses l'indiquent autrement. INTERSECT lie plus étroitement que UNION --- ce qui fait que, A UNION B INTERSECT C sera lu comme A UNION (B INTERSECT C) sauf spécification différente par les parenthèses.

Clause EXCEPT

table_query EXCEPT [ ALL ] table_query
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    

EXCEPT est similaire à UNION, sauf qu'il ne produit que des lignes qui apparaissent dans la sortie gauche de la requête mais pas dans la sortie droite.

Le résultat de EXCEPT ne contient pas de lignes dupliquées sauf si l'option ALL option est spécifiée. Avec ALL, une ligne qui a m duplicats dans L et n duplicats dans R apparaitra comme max(m-n,0) fois.

Les opérateurs EXCEPT multiples dans la même instruction SELECT sont évalués de gauche à droite, sauf si des parenthèses l'indiquent autrement. EXCEPT lie au même niveau que UNION.

Clause LIMIT

    LIMIT { count | ALL }
    OFFSET start
    

LIMIT vous permet de retrouver juste une partie des lignes qui sont générées par le reste de la requête. Si une limite est donnée, pas d'avantage de lignes ne seront retournées. Si un décalage est donné, ces diverses lignes seront sautées avant de lancer la récupération de lignes.

Quand on utilise LIMIT, c'est une bonne idée d'utiliser aussi la clause ORDER BY qui contraint les lignes résultantes en un ordre unique. Autrement vous obtiendrez un sous-ensemble imprévisible de lignes de la requête --- vous pouvez demander la dixième ligne dans une vingtaine de lignes, mais la dixième dans quel ordre ? Vous ne connaissez pas l'ordonnancement sauf si vous spécifiez ORDER BY.

Depuis PostgreSQL version 7.0, l'optimiseur de requête prend en compte LIMIT quand il génère son plan de requête, ainsi vous obtiendrez différents plans (rendant divers ordonnancements de lignes) selon que vous utilisez LIMIT ou OFFSET. Ainsi, l'utilisation de valeurs LIMIT/OFFSET différentes pour sélectionner différents sous-ensembles d'un résultat de requête donnera des résultats inconsistants sauf si vous forcez un résultat à être prévisible par l'ordonnancement de ORDER BY. ce n'est pas un bug; c'est une conséquence inhérente au fait que le SQL ne promet pas de délivrer les résultats d'une requête dans un ordre particulier sauf si ORDER BY est utiliser pour contraindre l'ordre.

Extensions

PostgreSQL permet d'omettre la clause FROM d'une requête. Cette fonctionnalité vient du langage de requête PostQuel. Il est d'un usage franc pour calculer les résultats d'expressions de constante simple :

SELECT 2+2;

 ?column?
----------
        4
  

SELECT distributors.* WHERE distributors.name = 'Westward';

 did | name
-----+----------
 108 | Westward
  

SELECT distributors.* FROM distributors d;
  

SELECT d.* FROM distributors d;
  

SELECT distributors.* FROM distributors d, distributors distributors;
  

SQL92

 
table_query UNION [ALL]
    [CORRESPONDING [BY (column [,...])]]
    table_query