Section courante

A propos

Section administrative du site

SELECT

 Sélectionne
PostgreSQL

Syntaxe

[ WITH [ RECURSIVE ] with_query [, ...] ]
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
[ * | expression [ [ AS ] output_name ] [, ...] ]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY grouping_element [, ...] ]
[ HAVING condition ]
[ WINDOW window_name AS ( window_definition ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start [ ROW | ROWS ] ]
[ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
[ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ] [ NOWAIT | SKIP LOCKED ] [...] ]

où from_item peut être l'un des éléments suivants :

[ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
[ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ]
[ LATERAL ] ( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
[ LATERAL ] function_name ( [ argument [, ...] ] )
[ WITH ORDINALITY ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
[ LATERAL ] function_name ( [ argument [, ...] ] ) [ AS ] alias ( column_definition [, ...] )
[ LATERAL ] function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
[ LATERAL ] ROWS FROM( function_name ( [ argument [, ...] ] ) [ AS ( column_definition [, ...] ) ] [, ...] )
[ WITH ORDINALITY ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]

et grouping_element peut être l'un des éléments suivants :

( )
expression
( expression [, ...] )
ROLLUP ( { expression | ( expression [, ...] ) } [, ...] )
CUBE ( { expression | ( expression [, ...] ) } [, ...] )
GROUPING SETS ( grouping_element [, ...] )

et with_query est :

with_query_name [ ( column_name [, ...] ) ] AS ( select | values | insert | update | delete )

TABLE [ ONLY ] table_name [ * ]

Paramètres

Nom Description
WITH Ce paramètre permet d'indiquer une ou plusieurs sous-requêtes pouvant être référencées par nom dans la requête principale. Les sous-requêtes agissent effectivement comme des tables ou des vues temporaires pendant la durée de la requête principale. Chaque sous-requête peut être une instruction SELECT, TABLE, VALUES, INSERT, UPDATE ou DELETE. Lors de l'écriture d'une instruction de modification de données (INSERT, UPDATE ou DELETE) dans WITH, il est habituel d'inclure une clause RETURNING. C'est la sortie de RETURNING, et non la table sous-jacente que l'instruction modifie, formant la table temporaire étant lue par la requête principale. Si RETURNING est omis, l'instruction est toujours exécutée, mais elle ne produit aucune sortie et ne peut donc pas être référencée en tant que table par la requête principale. Un nom (sans qualification de schéma) doit être spécifié pour chaque requête WITH. Facultativement, une liste de noms de colonnes peut être spécifiée ; si cela est omis, les noms de colonnes sont déduits de la sous-requête. Si RECURSIVE est spécifié, il permet à une sous-requête SELECT de se référencer par son nom. Une telle sous-requête doit avoir la format :

non_recursive_term UNION [ ALL | DISTINCT ] recursive_term

où l'autoréférence récursive doit apparaître à droite de l'UNION. Une seule auto-référence récursive est autorisée par requête. Les instructions de modification de données récursives ne sont pas prises en charge, mais vous pouvez utiliser les résultats d'une requête SELECT récursive dans une instruction de modification de données. Un autre effet de RECURSIVE est que les requêtes WITH n'ont pas besoin d'être ordonnées : une requête peut en référencer une autre qui se trouve plus tard dans la liste. (Cependant, les références circulaires ou la récursivité mutuelle ne sont pas implémentées.) Sans RECURSIVE, les requêtes WITH peuvent uniquement référencer les requêtes WITH soeurs antérieures dans la liste WITH. Une propriété clef des requêtes WITH est qu'elles ne sont évaluées qu'une seule fois par exécution de la requête primaire, même si la requête primaire y fait référence plus d'une fois. En particulier, les instructions de modification de données sont garanties pour être exécutées une et une seule fois, que la requête principale lise tout ou partie de leur sortie. Lorsqu'il y a plusieurs requêtes dans la clause WITH, RECURSIVE ne doit être écrit qu'une seule fois, immédiatement après WITH. Elle s'applique à toutes les requêtes de la clause WITH, bien qu'elle n'ait aucun effet sur les requêtes qui n'utilisent pas de récursivité ou de références directes. La requête principale et les requêtes WITH sont toutes (théoriquement) exécutées en même temps. Cela implique que les effets d'une instruction de modification de données dans WITH ne peuvent pas être vus à partir d'autres parties de la requête, autrement qu'en lisant sa sortie RETURNING. Si deux de ces instructions de modification de données tentent de modifier la même ligne, les résultats ne sont pas spécifiés.
FROM Ce paramètre permet d'indiquer une ou plusieurs tables source pour le SELECT. Si plusieurs sources sont spécifiées, le résultat est le produit cartésien (jointure croisée) de toutes les sources. Mais généralement, des conditions de qualification sont ajoutées (via WHERE) pour restreindre les lignes renvoyées à un petit sous-ensemble du produit cartésien.
table_name Ce paramètre permet d'indiquer le nom (éventuellement qualifié par le schéma) d'une table ou d'une vue existante. Si ONLY est spécifié avant le nom de la table, seule cette table est analysée. Si ONLY n'est pas spécifié, la table et toutes ses tables descendantes (le cas échéant) sont analysées. Facultativement, * peut être spécifié après le nom de la table pour indiquer explicitement que les tables descendantes sont incluses.
alias Ce paramètre permet d'indiquer un nom de remplacement pour l'élément FROM contenant l'alias. Un alias est utilisé par souci de concision ou pour éliminer l'ambiguïté des auto-jointures (où la même table est analysée plusieurs fois). Lorsqu'un alias est fourni, il masque complètement le nom réel de la table ou de la fonction ; par exemple, étant donné FROM gladir AS f, le reste du SELECT doit faire référence à cet élément FROM comme f et non gladir. Si un alias est écrit, une liste d'alias de colonne peut également être écrite pour fournir des noms de substitution pour une ou plusieurs colonnes de la table.
TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] Ce paramètre permet d'indiquer une clause TABLESAMPLE après un table_name indique que la sampling_method spécifiée doit être utilisée pour récupérer un sous-ensemble des lignes de cette table. Cet échantillonnage précède l'application de tout autre filtre tel que les clauses WHERE. La distribution standard de PostgreSQL comprend deux méthodes d'échantillonnage, BERNOULLI et SYSTEM, et d'autres méthodes d'échantillonnage peuvent être installées dans la base de données via des extensions. Les méthodes d'échantillonnage BERNOULLI et SYSTEM acceptent chacune un seul argument qui est la fraction de la table à échantillonner, exprimée en pourcentage entre 0 et 100. Ce paramètre peut être n'importe quelle expression à valeur réelle. (D'autres méthodes d'échantillonnage peuvent accepter des arguments plus nombreux ou différents.) Ces deux méthodes renvoient chacune un échantillon choisi au hasard de la table contenant approximativement le pourcentage spécifié des lignes de la table. La méthode BERNOULLI parcourt la table entière et sélectionne ou ignore les lignes individuelles indépendamment avec la probabilité spécifiée. La méthode SYSTEM effectue un échantillonnage au niveau du bloc avec chaque bloc ayant la chance spécifiée d'être sélectionné ; toutes les lignes de chaque bloc sélectionné sont renvoyées. La méthode SYSTEM est nettement plus rapide que la méthode BERNOULLI lorsque de petits pourcentages d'échantillonnage sont spécifiés, mais elle peut renvoyer un échantillon moins aléatoire de la table en raison des effets de regroupement. La clause facultative REPEATABLE spécifie un nombre de départ ou une expression à utiliser pour générer des nombres aléatoires dans la méthode d'échantillonnage. La valeur de départ peut être n'importe quelle valeur à virgule flottante non nulle. Deux requêtes spécifiant les mêmes valeurs de départ et de paramètre sélectionneront le même échantillon de la table, si la table n'a pas été modifiée entre-temps. Mais différentes valeurs de départ produiront généralement des échantillons différents. Si REPEATABLE n'est pas donné, un nouvel échantillon aléatoire est sélectionné pour chaque requête, sur la base d'une graine générée par le système. Notez que certaines méthodes d'échantillonnage supplémentaires n'acceptent pas REPEATABLE et produiront toujours de nouveaux échantillons à chaque utilisation.
select Ce paramètre permet d'indiquer un sous-SELECT peut apparaître dans la clause FROM. Cela agit comme si sa sortie était créée en tant que table temporaire pour la durée de cette seule commande SELECT. Notez que le sous-SELECT doit être entouré de parenthèses et qu'un alias doit lui être fourni. Une commande VALUES peut également être utilisée ici.
with_query_name Ce paramètre permet d'indiquer une requête WITH est référencée en écrivant son nom, comme si le nom de la requête était un nom de table. (En fait, la requête WITH masque toute table réelle du même nom pour les besoins de la requête principale. Si nécessaire, vous pouvez faire référence à une table réelle du même nom en qualifiant le schéma du nom de la table.) Un alias peut être fourni de la même manière que pour une table.
function_name Ce paramètre permet d'indiquer les appels de fonction peuvent apparaître dans la clause FROM. (Ceci est particulièrement utile pour les fonctions qui renvoient des ensembles de résultats, mais n'importe quelle fonction peut être utilisée.) Cela agit comme si la sortie de la fonction avait été créée en tant que table temporaire pour la durée de cette seule commande SELECT. Lorsque la clause facultative WITH ORDINALITY est ajoutée à l'appel de fonction, une nouvelle colonne est ajoutée après toutes les colonnes de sortie de la fonction avec une numérotation pour chaque ligne. Un alias peut être fourni de la même manière que pour une table. Si un alias est écrit, une liste d'alias de colonne peut également être écrite pour fournir des noms de substitution pour un ou plusieurs attributs du type de retour composite de la fonction, y compris la colonne ajoutée par ORDINALITY si elle est présente. Plusieurs appels de fonction peuvent être combinés en un seul élément de clause FROM en les entourant de ROWS FROM( ... ). La sortie d'un tel élément est la concaténation de la première ligne de chaque fonction, puis de la deuxième ligne de chaque fonction,... Si certaines fonctions produisent moins de lignes que d'autres, des valeurs nulles sont substituées aux données manquantes, de sorte que le le nombre total de lignes renvoyées est toujours le même que pour la fonction ayant produit le plus de lignes. Si la fonction a été définie comme renvoyant le type de données de l'enregistrement, alors un alias ou le mot clé AS doit être présent, suivi d'une liste de définitions de colonnes sous la forme ( nom_colonne type_données [, ... ]). La liste de définitions de colonnes doit correspondre au nombre réel et aux types de colonnes renvoyés par la fonction. Lors de l'utilisation de la syntaxe ROWS FROM( ... ), si l'une des fonctions nécessite une liste de définitions de colonnes, il est préférable de placer la liste de définitions de colonnes après l'appel de fonction dans ROWS FROM( ... ). Une liste de définitions de colonnes peut être placée après la construction ROWS FROM( ... ) uniquement s'il n'y a qu'une seule fonction et aucune clause WITH ORDINALITY. Pour utiliser ORDINALITY avec une liste de définitions de colonnes, vous devez utiliser la syntaxe ROWS FROM( ... ) et placer la liste de définitions de colonnes dans ROWS FROM( ... ).
join_type Un des :

[ INNER ] JOIN
LEFT [ OUTER ] JOIN
RIGHT [ OUTER ] JOIN
FULL [ OUTER ] JOIN
CROSS JOIN

Pour les types de jointure INNER et OUTER, une condition de jointure doit être spécifiée, à savoir exactement l'une des suivantes : NATURAL, ON join_condition ou USING (join_column [, ...]). Pour CROSS JOIN, aucune de ces clauses ne peut apparaître. Une clause JOIN combine deux éléments FROM, que nous appellerons par commodité «tables», bien qu'en réalité ils puissent être n'importe quel type d'élément FROM. Utilisez des parenthèses si nécessaire pour déterminer l'ordre d'imbrication. En l'absence de parenthèses, les JOIN s'emboîtent de gauche à droite. Dans tous les cas, JOIN se lie plus étroitement que les virgules séparant les éléments de la liste FROM. CROSS JOIN et INNER JOIN produisent un produit cartésien simple, le même résultat que celui obtenu en listant les deux tables au niveau supérieur de FROM, mais limité par la condition de jointure (le cas échéant). CROSS JOIN équivaut à INNER JOIN ON (TRUE), c'est-à-dire qu'aucune ligne n'est supprimée par qualification. Ces types de jointure ne sont qu'une commodité de notation, car ils ne font rien que vous ne puissiez faire avec plain FROM et WHERE. LEFT OUTER JOIN renvoie toutes les lignes du produit cartésien qualifié Cette ligne de gauche est étendue sur toute la largeur de la table jointe en insérant des valeurs nulles pour les colonnes de droite. Notez que seule la propre condition de la clause JOIN est prise en compte pour décider quelles lignes ont des correspondances. Les conditions extérieures sont appliquées par la suite. Inversement, RIGHT OUTER JOIN renvoie toutes les lignes jointes, plus une ligne pour chaque ligne de droite sans correspondance (étendue avec des valeurs NULL à gauche). C'est juste une commodité de notation, puisque vous pouvez le convertir en un LEFT OUTER JOIN en basculant les tables de gauche et de droite. FULL OUTER JOIN renvoie toutes les lignes jointes, plus une ligne pour chaque ligne de gauche sans correspondance (étendue avec des valeurs NULL à droite), plus une ligne pour chaque ligne de droite sans correspondance (étendue avec des valeurs NULL à gauche).
ON join_condition Ce paramètre permet d'indiquer une expression résultant en une valeur de type booléen (similaire à une clause WHERE) spécifiant quelles lignes d'une jointure sont considérées comme correspondant.
USING ( join_column [, ...] ) Ce paramètre permet d'indiquer une clause de la format USING ( a, b, ... ) est un raccourci pour ON left_table.a = right_table.a AND left_table.b = right_table.b .... De plus, USING implique qu'un seul de chaque paire d'équivalents les colonnes seront incluses dans la sortie de la jointure, pas les deux.
NATURAL Ce paramètre permet d'indiquer un raccourci pour une liste USING mentionnant toutes les colonnes des deux tables ayant des noms correspondants. S'il n'y a pas de noms de colonnes communs, NATURAL est équivalent à ON TRUE.
LATERAL Ce paramètre permet au sous-SELECT de faire référence aux colonnes d'éléments FROM apparaissant avant lui dans la liste FROM. Le mot clef LATERAL peut précéder une rubrique sous-SELECT FROM. (Sans LATERAL, chaque sous-SELECT est évalué indépendamment et ne peut donc faire référence à aucun autre élément FROM.) LATERAL peut également précéder un élément FROM d'appel de fonction, mais dans ce cas, il s'agit d'un mot parasite, car l'expression de la fonction peut faire référence à des éléments FROM antérieurs dans tous les cas. Un élément LATERAL peut apparaître au niveau supérieur dans la liste FROM, ou dans une arborescence JOIN. Dans ce dernier cas, il peut également faire référence à tous les éléments se trouvant sur le côté gauche d'un JOIN alors qu'il se trouve sur le côté droit. Lorsqu'un élément FROM contient des références croisées LATERAL, l'évaluation se déroule comme suit : pour chaque ligne de l'élément FROM fournissant la ou les colonnes référencées, ou ensemble de lignes de plusieurs éléments FROM fournissant les colonnes, l'élément LATERAL est évalué à l'aide les valeurs des colonnes de cette ligne ou de cet ensemble de lignes. Les lignes résultantes sont jointes comme d'habitude avec les lignes à partir desquelles elles ont été calculées. Ceci est répété pour chaque ligne ou ensemble de lignes de la (des) table(s) source(s) de colonne. La ou les tables source de la colonne doivent être INNER ou LEFT jointes à l'élément LATERAL, sinon il n'y aurait pas d'ensemble de lignes bien défini à partir duquel calculer chaque ensemble de lignes pour l'élément LATERAL. Ainsi, bien qu'une construction telle que X RIGHT JOIN LATERAL Y soit syntaxiquement valide, il n'est pas permis à Y de faire référence à X.
WHERE Ce paramètre permet d'indiquer la condition de filtre. La clause WHERE facultative a le format générale suivant :

WHERE condition

où condition est toute expression donnant un résultat de type booléen. Toute ligne ne satisfaisant pas à cette condition sera éliminée de la sortie. Une ligne satisfait la condition si elle renvoie true lorsque les valeurs de ligne réelles sont remplacées par des références de variable.
GROUP BY Ce paramètre permet d'indiquer un regroupement par groupe. La clause GROUP BY facultative a le format générale suivant :

GROUP BY grouping_element [, ...]

GROUP BY condensera en une seule ligne toutes les lignes sélectionnées partageant les mêmes valeurs pour les expressions groupées. Une expression utilisée à l'intérieur d'un grouping_element peut être un nom de colonne d'entrée, ou le nom ou le numéro ordinal d'une colonne de sortie (élément de liste SELECT), ou une expression arbitraire formée à partir de valeurs de colonne d'entrée. En cas d'ambiguïté, un nom GROUP BY sera interprété comme un nom de colonne d'entrée plutôt qu'un nom de colonne de sortie. Si l'un des GROUPING SETS, ROLLUP ou CUBE est présent en tant qu'éléments de regroupement, alors la clause GROUP BY dans son ensemble définit un certain nombre d'ensembles de regroupement indépendants. L'effet de ceci est équivalent à la construction d'un UNION ALL entre les sous-requêtes avec les ensembles de regroupement individuels comme clauses GROUP BY. Les fonctions d'agrégat, le cas échéant, sont calculées sur toutes les lignes composant chaque groupe, produisant une valeur distincte pour chaque groupe. (S'il y a des fonctions d'agrégat mais pas de clause GROUP BY, la requête est traitée comme ayant un seul groupe comprenant toutes les lignes sélectionnées.) L'ensemble de lignes fourni à chaque fonction d'agrégat peut être filtré davantage en attachant une clause FILTER à la fonction d'agrégat appel. Lorsqu'une clause FILTER est présente, seules les lignes lui correspondant sont incluses dans l'entrée de cette fonction d'agrégat. Lorsque GROUP BY est présent, ou des fonctions d'agrégation sont présentes, il n'est pas valide pour les expressions de liste SELECT de faire référence à des colonnes non groupées, sauf dans les fonctions d'agrégation ou lorsque la colonne non groupée dépend fonctionnellement des colonnes groupées, car il y aurait autrement plus plus d'une valeur possible à retourner pour une colonne non groupée. Une dépendance fonctionnelle existe si les colonnes regroupées (ou un sous-ensemble de celles-ci) sont la clef primaire de la table contenant la colonne non regroupée. Gardez à l'esprit que toutes les fonctions d'agrégat sont évaluées avant d'évaluer les expressions «scalaires» dans la clause HAVING ou la liste SELECT. Cela signifie que, par exemple, une expression CASE ne peut pas être utilisée pour ignorer l'évaluation d'une fonction d'agrégation. FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent pas être spécifiés avec GROUP BY.
HAVING Ce paramètre permet d'indiquer l'avoir. La clause facultative HAVING a le format générale suivant :

HAVING condition

où la condition est la même que celle spécifiée pour la clause WHERE. Le HAVING élimine les lignes de groupe ne satisfaisant pas la condition. HAVING est différent de WHERE : WHERE filtre les lignes individuelles avant l'application de GROUP BY, tandis que HAVING filtre les lignes de groupe créées par GROUP BY. Chaque colonne référencée dans condition doit référencer sans ambiguïté une colonne de regroupement, à moins que la référence n'apparaisse dans une fonction d'agrégat ou que la colonne non regroupée dépende fonctionnellement des colonnes de regroupement. La présence de HAVING transforme une requête en requête groupée même s'il n'y a pas de clause GROUP BY. C'est la même chose que ce qui se passe lorsque la requête contient des fonctions d'agrégat mais pas de clause GROUP BY. Toutes les lignes sélectionnées sont considérées comme formant un seul groupe, et la liste SELECT et la clause HAVING peuvent uniquement référencer des colonnes de table à partir de fonctions d'agrégat. Une telle requête émettra une seule ligne si la condition HAVING est vraie, zéro ligne si elle n'est pas vraie. FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent pas être spécifiés avec HAVING.
WINDOW Ce paramètre permet d'indiquer une fenêtre de données. La clause optionnelle WINDOW a le format générale :

WINDOW window_name AS ( window_definition ) [, ...]

où window_name est un nom pouvant être référencé à partir des clauses OVER ou des définitions de fenêtre suivantes, et window_definition est :

[ existing_window_name ]
[ PARTITION BY expression [, ...] ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ frame_clause ]

Si un existing_window_name est spécifié, il doit faire référence à une entrée antérieure dans la liste WINDOW ; la nouvelle fenêtre copie sa clause de partitionnement à partir de cette entrée, ainsi que sa clause de commande, le cas échéant. Dans ce cas, la nouvelle fenêtre ne peut pas spécifier sa propre clause PARTITION BY, et elle ne peut spécifier ORDER BY que si la fenêtre copiée n'en a pas. La nouvelle fenêtre utilise toujours sa propre clause frame ; la fenêtre copiée ne doit pas spécifier de clause frame. Les éléments de la liste PARTITION BY sont interprétés de la même manière que les éléments d'une clause GROUP BY, sauf qu'il s'agit toujours d'expressions simples et jamais du nom ou du numéro d'une colonne de sortie. Une autre différence est que ces expressions peuvent contenir des appels de fonction d'agrégat, qui ne sont pas autorisés dans une clause GROUP BY normale. Ils sont autorisés ici car le fenêtrage se produit après le regroupement et l'agrégation. De même, les éléments de la liste ORDER BY sont interprétés de la même manière que les éléments d'une clause ORDER BY, sauf que les expressions sont toujours considérées comme des expressions simples et jamais le nom ou le numéro d'une colonne de sortie. L'option frame_clause définit le cadre de fenêtre pour les fonctions de fenêtre qui dépendent du cadre (ce n'est pas le cas pour toutes). Le cadre de fenêtre est un ensemble de lignes liées pour chaque ligne de la requête (appelée la ligne actuelle). La frame_clause peut être l'un des :

{ RANGE | ROWS } frame_start
{ RANGE | ROWS } BETWEEN frame_start AND frame_end

où frame_start et frame_end peuvent être l'un des :

UNBOUNDED PRECEDING
value PRECEDING
CURRENT ROW
value FOLLOWING
UNBOUNDED FOLLOWING

Si frame_end est omis, la valeur par défaut est CURRENT ROW. Les restrictions sont que frame_start ne peut pas être UNBOUNDED FOLLOWING, frame_end ne peut pas être UNBOUNDED PRECEDING, et le choix frame_end ne peut pas apparaître plus tôt dans la liste ci-dessus que le choix frame_start - par exemple, RANGE BETWEEN CURRENT ROW AND value PRECEDING n'est pas autorisé. L'option de cadrage par défaut est RANGE UNBOUNDED PRECEDING, étant la même que RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ; il définit la trame comme étant toutes les lignes du démarrage de la partition jusqu'au dernier pair de la ligne actuelle (une ligne que ORDER BY considère comme équivalente à la ligne actuelle, ou toutes les lignes s'il n'y a pas ORDER BY). En général, UNBOUNDED PRECEDING signifie que la trame commence par la première ligne de la partition, et de même UNBOUNDED FOLLOWING signifie que la trame se termine par la dernière ligne de la partition (quel que soit le mode RANGE ou ROWS). En mode ROWS, CURRENT ROW signifie que la trame commence ou se termine par la ligne actuelle ; mais en mode RANGE, cela signifie que la trame commence ou se termine par le premier ou le dernier pair de la ligne actuelle dans l'ordre ORDER BY. Les cas de valeur PRECEDING et de valeur FOLLOWING ne sont actuellement autorisés qu'en mode ROWS. Ils indiquent que le cadre commence ou se termine par la ligne comptant de nombreuses lignes avant ou après la ligne actuelle. valeur doit être une expression entière ne contenant aucune variable, fonction d'agrégat ou fonction de fenêtre. La valeur ne doit pas être nulle ou négative ; mais il peut être zéro, ce qui sélectionne la ligne actuelle elle-même. Attention, les options ROWS peuvent produire des résultats imprévisibles si le classement ORDER BY ne classe pas les lignes de manière unique. Les options RANGE sont conçues pour garantir que les lignes étant des pairs dans l'ordre ORDER BY sont traitées de la même manière ; toutes les lignes homologues seront dans le même cadre. Le but d'une clause WINDOW est de spécifier le comportement des fonctions de fenêtre apparaissant dans la liste SELECT ou la clause ORDER BY de la requête. Ces fonctions peuvent référencer les entrées de clause WINDOW par leur nom dans leurs clauses OVER. Cependant, une entrée de clause WINDOW ne doit être référencée nulle part ; s'il n'est pas utilisé dans la requête, il est simplement ignoré. Il est possible d'utiliser des fonctions de fenêtre sans aucune clause WINDOW, car un appel de fonction de fenêtre peut spécifier sa définition de fenêtre directement dans sa clause OVER. Toutefois, la clause WINDOW économise la saisie lorsque la même définition de fenêtre est nécessaire pour plusieurs fonctions de fenêtre. Actuellement, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent pas être spécifiés avec WINDOW.
SELECT Ce paramètre permet d'indiquer (entre les mots clefs SELECT et FROM) les expressions formant les lignes de sortie de l'instruction SELECT. Les expressions peuvent (et font généralement) faire référence à des colonnes calculées dans la clause FROM. Tout comme dans une table, chaque colonne de sortie d'un SELECT a un nom. Dans un SELECT simple, ce nom est simplement utilisé pour étiqueter la colonne à afficher, mais lorsque le SELECT est une sous-requête d'une requête plus grande, le nom est considéré par la requête plus large comme le nom de colonne de la table virtuelle produite par le sous -mettre en doute. Pour spécifier le nom à utiliser pour une colonne de sortie, écrivez AS output_name après l'expression de la colonne. (Vous pouvez omettre AS, mais uniquement si le nom de sortie souhaité ne correspond à aucun mot-clef PostgreSQL. Pour vous protéger contre d'éventuels ajouts de mots-clefs futurs, il est recommandé de toujours écrire AS ou de mettre entre guillemets le nom de sortie. ) Si vous ne spécifiez pas de nom de colonne, un nom est choisi automatiquement par PostgreSQL. Si l'expression de la colonne est une simple référence de colonne, le nom choisi est le même que le nom de cette colonne. Dans des cas plus complexes, un nom de fonction ou de type peut être utilisé, ou le système peut se rabattre sur un nom généré tel que ?column?. Le nom d'une colonne de sortie peut être utilisé pour faire référence à la valeur de la colonne dans les clauses ORDER BY et GROUP BY, mais pas dans les clauses WHERE ou HAVING ; là, vous devez écrire l'expression à la place. Au lieu d'une expression, «*» peut être écrit dans la liste de sortie comme raccourci pour toutes les colonnes des lignes sélectionnées. En outre, vous pouvez écrire table_name.* comme raccourci pour les colonnes provenant uniquement de cette table. Dans ces cas, il n'est pas possible de spécifier de nouveaux noms avec AS ; les noms des colonnes de sortie seront les mêmes que les noms des colonnes de la table. Selon la norme SQL, les expressions de la liste de sortie doivent être calculées avant d'appliquer DISTINCT, ORDER BY ou LIMIT. Ceci est évidemment nécessaire lors de l'utilisation de DISTINCT, car sinon, il n'est pas clair quelles valeurs sont rendues distinctes. Cependant, dans de nombreux cas, il est pratique que les expressions de sortie soient calculées après ORDER BY et LIMIT ; en particulier si la liste de sortie contient des fonctions volatiles ou coûteuses. Avec ce comportement, l'ordre des évaluations de fonction est plus intuitif et il n'y aura pas d'évaluations correspondant à des lignes qui n'apparaissent jamais dans la sortie. Le PostgreSQL évaluera efficacement les expressions de sortie après tri et limitation, tant que ces expressions ne sont pas référencées dans DISTINCT, ORDER BY ou GROUP BY. (Comme contre-exemple, SELECT f(x) FROM tab ORDER BY 1 doit clairement évaluer f(x) avant le tri.) Les expressions de sortie contenant des fonctions de retour d'ensemble sont effectivement évaluées après le tri et avant la limitation, de sorte que LIMIT agira pour couper désactiver la sortie d'une fonction de retour d'ensemble. Note : Les versions de PostgreSQL antérieures à la 9.6 ne fournissaient aucune garantie concernant le timing de l'évaluation des expressions de sortie par rapport au tri et à la limitation ; cela dépendait de la forme du plan de requête choisi.
DISTINCT Ce paramètre permet d'indiquer de ne pas doublé les lignes. Si SELECT DISTINCT est spécifié, toutes les lignes en double sont supprimées de l'ensemble de résultats (une ligne est conservée pour chaque groupe de doublons). SELECT ALL spécifie le contraire : toutes les lignes sont conservées ; c'est la valeur par défaut. SELECT DISTINCT ON ( expression [, ...] ) ne conserve que la première ligne de chaque ensemble de lignes où les expressions données sont évaluées comme égales. Les expressions DISTINCT ON sont interprétées selon les mêmes règles que pour ORDER BY. Notez que la «première rangée» de chaque ensemble est imprévisible à moins que ORDER BY ne soit utilisé pour garantir que la rangée souhaitée apparaisse en premier. Par exemple :

SELECT DISTINCT ON (emplacement) emplacement, heure, rapport FROM rapport_meteo ORDER BY emplacement, heure DESC;
récupère le rapport météo le plus récent pour chaque emplacement. Mais si nous n'avions pas utilisé ORDER BY pour forcer l'ordre décroissant des valeurs temporelles pour chaque emplacement, nous aurions obtenu un rapport d'une heure imprévisible pour chaque emplacement. Les expressions DISTINCT ON doivent correspondre aux expressions ORDER BY les plus à gauche. La clause ORDER BY contiendra normalement des expressions supplémentaires déterminant la priorité souhaitée des lignes dans chaque groupe DISTINCT ON. Actuellement, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent pas être spécifiés avec DISTINCT.
UNION Ce paramètre permet d'indiquer une union de différentes sources de données. La clause UNION a cette forme générale :

select_statement UNION [ ALL | DISTINCT ] select_statement

select_statement est une instruction SELECT sans clause ORDER BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE ou FOR KEY SHARE. (ORDER BY et LIMIT peuvent être attachés à une sous-expression si elle est entourée de parenthèses. Sans parenthèses, ces clauses seront considérées comme s'appliquant au résultat de l'UNION, et non à son expression d'entrée de droite.) L'opérateur UNION calcule l'union d'ensembles des lignes renvoyées par les instructions SELECT impliquées. Une ligne est dans l'union de deux ensembles de résultats si elle apparaît dans au moins un des ensembles de résultats. Les deux instructions SELECT représentant les opérandes directs de l'UNION doivent produire le même nombre de colonnes et les colonnes correspondantes doivent être de types de données compatibles. Le résultat de UNION ne contient aucune ligne en double, sauf si l'option ALL est spécifiée. Le ALL empêche l'élimination des doublons. (Par conséquent, UNION ALL est généralement beaucoup plus rapide que UNION ; utilisez ALL lorsque vous le pouvez.) Le DISTINCT peut être écrit pour spécifier explicitement le comportement par défaut d'élimination des lignes en double. Plusieurs opérateurs UNION dans la même instruction SELECT sont évalués de gauche à droite, sauf indication contraire par des parenthèses. Actuellement, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent être spécifiés ni pour un résultat UNION ni pour toute entrée d'UNION.
INTERSECT Ce paramètre permet d'indiquer une intersection. La clause INTERSECT a un format général :

select_statement INTERSECT [ ALL | DISTINCT ] select_statement

instruction_select est une instruction SELECT sans clause ORDER BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE ou FOR KEY SHARE. L'opérateur INTERSECT calcule l'intersection définie des lignes renvoyées par les instructions SELECT impliquées. Une ligne se trouve à l'intersection de deux ensembles de résultats si elle apparaît dans les deux ensembles de résultats. Le résultat d'INTERSECT ne contient aucune ligne en double à moins que l'option ALL ne soit spécifiée. Avec ALL, une ligne ayant m doublons dans le tableau de gauche et n doublons dans le tableau de droite apparaîtra min(m,n) fois dans l'ensemble de résultats. Le DISTINCT peut être écrit pour spécifier explicitement le comportement par défaut d'élimination des lignes en double. Plusieurs opérateurs INTERSECT dans la même instruction SELECT sont évalués de gauche à droite, sauf indication contraire entre parenthèses. Le INTERSECT se lie plus étroitement que UNION. Autrement dit, A UNION B INTERSECT C sera lu comme A UNION (B INTERSECT C). Actuellement, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent être spécifiés ni pour un résultat INTERSECT ni pour toute entrée d'INTERSECT.
EXCEPT Ce paramètre permet d'indiquer une exception. La clause EXCEPT a cette format générale :

select_statement EXCEPT [ ALL | DISTINCT ] select_statement

select_statement est une instruction SELECT sans clause ORDER BY, LIMIT, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE ou FOR KEY SHARE. L'opérateur EXCEPT calcule l'ensemble de lignes se trouvant dans le résultat de l'instruction SELECT de gauche mais pas dans le résultat de celle de droite. Le résultat de EXCEPT ne contient aucune ligne en double à moins que l'option ALL ne soit spécifiée. Avec ALL, une ligne ayant m doublons dans le tableau de gauche et n doublons dans le tableau de droite apparaîtra max(m-n,0) fois dans l'ensemble de résultats. Le DISTINCT peut être écrit pour spécifier explicitement le comportement par défaut d'élimination des lignes en double. Plusieurs opérateurs EXCEPT dans la même instruction SELECT sont évalués de gauche à droite, sauf indication contraire entre parenthèses. EXCEPT se lie au même niveau que UNION. Actuellement, FOR NO KEY UPDATE, FOR UPDATE, FOR SHARE et FOR KEY SHARE ne peuvent pas être spécifiés pour un résultat EXCEPT ou pour toute entrée d'un EXCEPT.
ORDER BY Ce paramètre permet d'indiquer l'ordre de tri. La clause optionnelle ORDER BY a ce format générale :

ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...]

La clause ORDER BY provoque le tri des lignes de résultat en fonction de la ou des expressions spécifiées. Si deux lignes sont égales selon l'expression la plus à gauche, elles sont comparées selon l'expression suivante et ainsi de suite. S'ils sont égaux selon toutes les expressions spécifiées, ils sont renvoyés dans un ordre dépendant de l'implémentation. Chaque expression peut être le nom ou le numéro ordinal d'une colonne de sortie (élément de liste SELECT), ou il peut s'agir d'une expression arbitraire formée à partir de valeurs de colonne d'entrée. Le nombre ordinal fait référence à la position ordinale (de gauche à droite) de la colonne de sortie. Cette fonctionnalité permet de définir un classement sur la base d'une colonne n'ayant pas de nom unique. Ce n'est jamais absolument nécessaire car il est toujours possible d'affecter un nom à une colonne de sortie à l'aide de la clause AS. Il est également possible d'utiliser des expressions arbitraires dans la clause ORDER BY, y compris des colonnes qui n'apparaissent pas dans la liste de sortie SELECT. Ainsi l'énoncé suivant est valable :

SELECT nom FROM distributeurs ORDER BY code;
Une limitation de cette fonctionnalité est qu'une clause ORDER BY s'appliquant au résultat d'une clause UNION, INTERSECT ou EXCEPT ne peut spécifier qu'un nom ou un numéro de colonne de sortie, pas une expression. Si une expression ORDER BY est un nom simple correspondant à la fois à un nom de colonne de sortie et à un nom de colonne d'entrée, ORDER BY l'interprétera comme le nom de colonne de sortie. C'est le contraire du choix que GROUP BY fera dans la même situation. Cette incohérence est faite pour être compatible avec le standard SQL. On peut éventuellement ajouter le mot clef ASC (croissant) ou DESC (décroissant) après n'importe quelle expression dans la clause ORDER BY. S'il n'est pas spécifié, ASC est supposé par défaut. Alternativement, un nom d'opérateur de commande spécifique peut être spécifié dans la clause USING. Un opérateur de commande doit être un membre inférieur ou supérieur à une famille d'opérateurs B-tree. La fonction ASC est généralement équivalent à USING «et DESC est généralement équivalent à USING». (Mais le créateur d'un type de données défini par l'utilisateur peut définir exactement quel est l'ordre de tri par défaut, et il peut correspondre à des opérateurs portant d'autres noms.) Si NULLS LAST est spécifié, les valeurs nulles sont triées après toutes les valeurs non nulles ; si NULLS FIRST est spécifié, les valeurs nulles sont triées avant toutes les valeurs non nulles. Si ni l'un ni l'autre n'est spécifié, le comportement par défaut est NULLS LAST lorsque ASC est spécifié ou implicite, et NULLS FIRST lorsque DESC est spécifié (ainsi, la valeur par défaut est d'agir comme si les valeurs NULL étaient plus grandes que les non NULL). Lorsque USING est spécifié, l'ordre des valeurs NULL par défaut dépend du fait que l'opérateur est inférieur ou supérieur à. Notez que les options de classement ne s'appliquent qu'à l'expression qu'elles suivent ; par exemple ORDER BY x, y DESC ne signifie pas la même chose que ORDER BY x DESC, y DESC. Les données de chaîne de caractères sont triées en fonction du classement s'appliquant à la colonne en cours de tri. Cela peut être remplacé au besoin en incluant une clause COLLATE dans l'expression, par exemple ORDER BY mycolumn COLLATE "en_US".
LIMIT Ce paramètre permet d'indiquer la limite ou l'intervalle où extraire les données. La clause LIMIT se compose de deux sous-clauses indépendantes :

LIMIT { count | ALL }
OFFSET start

count spécifie le nombre maximum de lignes à retourner, tandis que start spécifie le nombre de lignes à ignorer avant de commencer à retourner des lignes. Lorsque les deux sont spécifiés, les lignes de début sont ignorées avant de commencer à compter le nombre de lignes à renvoyer. Si l'expression count est évaluée à NULL, elle est traitée comme LIMIT ALL, c'est-à-dire sans limite. Si start est évalué à NULL, il est traité de la même manière que OFFSET 0. Le SQL:2008 a introduit une syntaxe différente pour obtenir le même résultat, que PostgreSQL prend également en charge. Il est :

OFFSET start { ROW | ROWS } FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY

Dans cette syntaxe, la valeur de départ ou de comptage est requise par la norme pour être une constante littérale, un paramètre ou un nom de variable ; en tant qu'extension PostgreSQL, d'autres expressions sont autorisées, mais devront généralement être mises entre parenthèses pour éviter toute ambiguïté. Si count est omis dans une clause FETCH, sa valeur par défaut est 1. Le ROW et ROWS ainsi que FIRST et NEXT sont des mots parasites n'influençant pas les effets de ces clauses. Selon la norme, la clause OFFSET doit précéder la clause FETCH si les deux sont présentes ; mais PostgreSQL est plus souple et permet l'un ou l'autre ordre. Lors de l'utilisation de LIMIT, il est conseillé d'utiliser une clause ORDER BY contraignant les lignes de résultat dans un ordre unique. Sinon, vous obtiendrez un sous-ensemble imprévisible des lignes de la requête - vous demandez peut-être les dixième à vingtième lignes, mais les dixième à vingtième dans quel ordre ? Vous ne savez pas quelle commande sauf si vous spécifiez ORDER BY. Le planificateur de requêtes prend en compte LIMIT lors de la génération d'un plan de requête, vous obtiendrez donc très probablement des plans différents (générant des ordres de lignes différents) en fonction de ce que vous utilisez pour LIMIT et OFFSET. Ainsi, l'utilisation de différentes valeurs LIMIT/OFFSET pour sélectionner différents sous-ensembles d'un résultat de requête donnera des résultats incohérents à moins que vous n'appliquiez un ordre de résultat prévisible avec ORDER BY. Ce n'est pas un bogue; c'est une conséquence inhérente du fait que SQL ne promet pas de fournir les résultats d'une requête dans un ordre particulier à moins que ORDER BY ne soit utilisé pour contraindre l'ordre. Il est même possible que des exécutions répétées de la même requête LIMIT renvoient différents sous-ensembles des lignes d'une table, s'il n'y a pas un ORDER BY pour forcer la sélection d'un sous-ensemble déterministe. Encore une fois, ce n'est pas un bogue ; le déterminisme des résultats n'est tout simplement pas garanti dans un tel cas.

Description

Cette instruction permet de récupérer des lignes d'une table ou d'une vue.

Remarques



Dernière mise à jour : Jeudi, le 14 Octobre 2021