Clause FROM

La clause FROM d’une requête répertorie les références de table (tables, vues et sous-requêtes) à partir desquelles les données sont sélectionnées. Si plusieurs références de table sont répertoriées, les tables doivent être jointes, à l’aide de la syntaxe appropriée de la clause FROM ou de la clause WHERE. Si aucun critère de jointure n’est spécifié, le système traite la requête comme jointure croisée (produit cartésien).

Syntaxe

FROM table_reference [, ...]

où table_reference est l’une des références suivantes :

with_subquery_table_name | table_name | ( subquery ) [ [ AS ] alias ]
table_reference [ NATURAL ] join_type table_reference [ USING ( join_column [, ...] ) ]
table_reference [ INNER ] join_type table_reference ON expr

Paramètres

with_subquery_table_name

Table définie par une sous-requête dans la Clause WITH.

table_name

Nom d’une table ou d’une vue.

alias

Nom alternatif temporaire d’une table ou d’une vue. Un alias doit être fourni pour une table dérivée d’une sous-requête. Dans les autres références de table, les alias sont facultatifs. Le AS mot clé est toujours facultatif. Les alias de table offrent un raccourci pratique pour identifier les tables dans d’autres parties d’une requête, telles que la clause WHERE.

Par exemple :

select * from sales s, listing l
where s.listid=l.listid

Si vous définissez un alias de table défini, l'alias doit être utilisé pour référencer cette table dans la requête.

Par exemple, si la requête l'estSELECT "tbl"."col" FROM "tbl" AS "t", elle échouera car le nom de la table est désormais essentiellement remplacé. Dans ce cas, une requête valide seraitSELECT "t"."col" FROM "tbl" AS "t".

alias_colonne

Nom alternatif temporaire pour une colonne dans une table ou une vue.

sous-requête

Une expression de requête qui correspond à une table. La table existe uniquement pendant la durée de la requête et reçoit généralement un nom ou un alias. Toutefois, l’alias n’est pas obligatoire. Vous pouvez aussi définir des noms de colonnes pour les tables qui proviennent de sous-requêtes. Il est important de nommer les alias de colonne lorsque vous souhaitez joindre les résultats des sous-requêtes à d’autres tables et lorsque vous voulez sélectionner ou limiter les colonnes ailleurs dans la requête.

Une sous-requête peut contenir une clause ORDER BY, mais cette clause peut n’avoir aucun effet si une clause LIMIT ou OFFSET n’est pas également spécifiée.

NATURAL

Définit une jointure qui utilise automatiquement toutes les paires de colonnes portant le même nom dans les deux tables comme colonnes de jointure. Aucune condition de jointure explicite n’est nécessaire. Par exemple, si les tables CATEGORY et EVENT ont toutes deux des colonnes nommées CATID, une jointure naturelle des tables est une jointure sur leurs colonnes CATID.

Note

Si une jointure NATURAL est spécifiée, mais qu’il n’y a aucune paire de colonnes portant le même nom dans les tables à joindre, la requête se résout par défaut en une jointure croisée.

join_type

Spécifiez l’un des types de jointure suivants :

• [INNER] JOIN

• LEFT [OUTER] JOIN

• RIGHT [OUTER] JOIN

• FULL [OUTER] JOIN

• CROSS JOIN

Les jointures croisées sont des jointures non qualifiées ; elles renvoient le produit cartésien des deux tables.

Les jointures internes et externes sont des jointures qualifiées. Elles sont qualifiés implicitement (en jointures naturelles), avec la syntaxe ON ou USING de la clause FROM, ou avec une condition de clause WHERE.

Une jointure interne renvoie les lignes correspondantes uniquement, en fonction de la condition de jointure ou d’une liste de colonnes de jointure. Une jointure externe renvoie toutes les lignes que la jointure interne équivalente renvoyerait, plus les lignes non correspondantes de la table de « gauche », de la table de « droite » ou des deux tables. La table de gauche est la première table de la liste et la table de droite la deuxième table. Les lignes non correspondantes contiennent des valeurs NULL pour combler les écarts dans les colonnes de sortie.

ON condition_jointure

Type de spécification de jointure où les colonnes de jointure sont définies comme condition qui suit le mot-clé ON. Par exemple :

sales join listing
on sales.listid=listing.listid and sales.eventid=listing.eventid

USING ( colonne_jointure [, ...] )

Type de spécification de jointure où les colonnes de jointure sont affichées entre parenthèses. Si plusieurs colonnes de jointure sont spécifiées, elles sont séparées par des virgules. Le mot-clé USING doit précéder la liste. Par exemple :

sales join listing
using (listid,eventid)

Notes d’utilisation

Les colonnes de jointure doivent avoir des types de données comparables.

Une jointure NATURAL ou USING conserve seulement l’une de chaque paire de colonnes de jointure dans le jeu de résultats intermédiaire.

Une jointure avec la syntaxe ON conserve les deux colonnes de jointure dans son jeu de résultats intermédiaire.

Voir aussi Clause WITH.

Exemples de clause JOIN

Une clause SQL JOIN permet de combiner les données de deux ou plusieurs tables sur la base de champs communs. Les résultats peuvent ou non changer en fonction de la méthode de jointure spécifiée. Pour obtenir plus d’informations sur la syntaxe d’une clause JOIN, consultez Paramètres.

La requête suivante est une jointure interne (sans le mot-clé JOIN) entre la table LISTING et la table SALES, où la valeur LISTID de la table LISTING est comprise entre 1 et 5. Cette requête met en correspondance les valeurs de la colonne LISTID dans les tables LISTING (table de gauche) et SALES (table de droite). Les résultats montrent que les valeurs LISTID 1, 4 et 5 correspondent aux critères.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing, sales
where listing.listid = sales.listid
and listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75

La requête suivante est une jointure externe gauche. Les jointures externes gauche et droite conservent les valeurs de l’une des tables jointes quand aucune correspondance n’est trouvée dans l’autre table. Les tables gauche et droite sont la première et la deuxième répertoriées dans la syntaxe. Les valeurs NULL sont utilisées pour combler les « écarts » du jeu de résultats. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que les valeurs LISTID 2 et 3 n’ont donné lieu à aucune vente.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing left outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     2 | NULL   | NULL
     3 | NULL   | NULL
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75

La requête suivante est une jointure externe droite. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que les valeurs LISTID 1, 4 et 5 correspondent aux critères.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing right outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75

La requête suivante est une jointure complète. Les jointures complètes conservent les valeurs des tables jointes lorsqu’aucune correspondance n’est trouvée dans l’autre table. Les tables gauche et droite sont la première et la deuxième répertoriées dans la syntaxe. Les valeurs NULL sont utilisées pour combler les « écarts » du jeu de résultats. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que les valeurs LISTID 2 et 3 n’ont donné lieu à aucune vente.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     2 | NULL   | NULL
     3 | NULL   | NULL
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75

La requête suivante est une jointure complète. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Seules les lignes qui ne donnent lieu à aucune vente (valeurs LISTID 2 et 3) figurent dans les résultats.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
and (listing.listid IS NULL or sales.listid IS NULL)
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     2 | NULL   | NULL
     3 | NULL   | NULL

L’exemple suivant est une jointure interne avec la clause ON. Dans ce cas, les lignes NULL ne sont pas renvoyées.

select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from sales join listing
on sales.listid=listing.listid and sales.eventid=listing.eventid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75

La requête suivante est une jointure croisée ou cartésienne de la table LISTING et de la table SALES avec un prédicat pour limiter les résultats. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table SALES et la table LISTING pour les valeurs LISTID 1, 2, 3, 4 et 5 dans les deux tables. Les résultats montrent que 20 lignes correspondent aux critères.

select sales.listid as sales_listid, listing.listid as listing_listid
from sales cross join listing
where sales.listid between 1 and 5
and listing.listid between 1 and 5
order by 1,2;

sales_listid | listing_listid
-------------+---------------
1            | 1
1            | 2
1            | 3
1            | 4
1            | 5
4            | 1
4            | 2
4            | 3
4            | 4
4            | 5
5            | 1
5            | 1
5            | 2
5            | 2
5            | 3
5            | 3
5            | 4
5            | 4
5            | 5
5            | 5

L’exemple suivant est une jointure naturelle entre deux tables. Dans ce cas, les colonnes listid, sellerid, eventid et dateid présentent des noms et des types de données identiques dans les deux tables et sont donc utilisées comme colonnes de jointure. Les résultats sont limités à seulement cinq lignes.

select listid, sellerid, eventid, dateid, numtickets
from listing natural join sales
order by 1
limit 5;

listid | sellerid  | eventid | dateid | numtickets
-------+-----------+---------+--------+-----------
113    | 29704     | 4699    | 2075   | 22
115    | 39115     | 3513    | 2062   | 14
116    | 43314     | 8675    | 1910   | 28
118    | 6079      | 1611    | 1862   | 9
163    | 24880     | 8253    | 1888   | 14

L’exemple suivant est une jointure entre deux tables avec la clause USING. Dans ce cas, les colonnes listid et eventid sont utilisées comme colonnes de jointure. Les résultats sont limités à seulement cinq lignes.

select listid, listing.sellerid, eventid, listing.dateid, numtickets
from listing join sales
using (listid, eventid)
order by 1
limit 5;

listid | sellerid | eventid | dateid | numtickets
-------+----------+---------+--------+-----------
1      | 36861    | 7872    | 1850   | 10
4      | 8117     | 4337    | 1970   | 8
5      | 1616     | 8647    | 1963   | 4
5      | 1616     | 8647    | 1963   | 4
6      | 47402    | 8240    | 2053   | 18

La requête suivante est une jointure interne de deux sous-requêtes de la clause FROM. La requête recherche le nombre de billets vendus et invendus pour les différentes catégories d’événements (concerts et spectacles). Les sous-requêtes de la clause FROM sont des sous-requêtes de table ; elles peuvent renvoyer plusieurs lignes et colonnes.

select catgroup1, sold, unsold
from
(select catgroup, sum(qtysold) as sold
from category c, event e, sales s
where c.catid = e.catid and e.eventid = s.eventid
group by catgroup) as a(catgroup1, sold)
join
(select catgroup, sum(numtickets)-sum(qtysold) as unsold
from category c, event e, sales s, listing l
where c.catid = e.catid and e.eventid = s.eventid
and s.listid = l.listid
group by catgroup) as b(catgroup2, unsold)

on a.catgroup1 = b.catgroup2
order by 1;

catgroup1 |  sold  | unsold
----------+--------+--------
Concerts  | 195444 |1067199
Shows     | 149905 | 817736