FROM (Transact-SQL)

  • Article

Mis à jour : 5 décembre 2005

Spécifie les tables, les vues, les tables dérivées ou jointes utilisées dans les instructions DELETE, SELECT et UPDATE. Dans l'instruction SELECT, la clause FROM est obligatoire sauf lorsque la liste de sélection ne contient que des constantes, des variables et des expressions arithmétiques (aucun nom de colonne).

Icône Lien de rubriqueConventions de syntaxe de Transact-SQL

Syntaxe

[ FROM { <table_source> } [ ,...n ] ] 
<table_source> ::= 
{
        table_or_view_name [ [ AS ] table_alias ] [ <tablesample_clause> ] 
        [ WITH ( < table_hint > [ [ , ]...n ] ) ] 
    | rowset_function [ [ AS ] table_alias ] 
        [ ( bulk_column_alias [ ,...n ] ) ] 
        | user_defined_function [ [ AS ] table_alias ] [ (column_alias [ ,...n ] ) ]
    | OPENXML <openxml_clause> 
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ] 
    | <joined_table> 
    | <pivoted_table> 
    | <unpivoted_table>
      | @variable [ [ AS ] table_alias ]
        | @variable.function_call ( expression [ ,...n ] ) [ [ AS ] table_alias ] [ (column_alias [ ,...n ] ) ]

}

<tablesample_clause> ::= 
    TABLESAMPLE [SYSTEM] ( sample_number [ PERCENT | ROWS ] ) 
        [ REPEATABLE ( repeat_seed ) ] 

<joined_table> ::= 
{
    <table_source> <join_type> <table_source> ON <search_condition> 
    | <table_source> CROSS JOIN <table_source> 
    | left_table_source { CROSS | OUTER } APPLY right_table_source 
    | [ ( ] <joined_table> [ ) ] 
}
<join_type> ::= 
    [ { INNER | { { LEFT | RIGHT | FULL } [ OUTER ] } } [ <join_hint> ] ]
    JOIN

<pivoted_table> ::=
        table_source PIVOT <pivot_clause> table_alias

<pivot_clause> ::=
        ( aggregate_function ( value_column ) 
        FOR pivot_column 
        IN ( <column_list> ) 
    ) 

<unpivoted_table> ::=
        table_source UNPIVOT <unpivot_clause> table_alias

<unpivot_clause> ::=
        ( value_column FOR pivot_column IN ( <column_list> ) ) 

<column_list> ::=
          column_name [ ,...n ]

Arguments

  • <table_source>
    Spécifie une table, une vue ou une source de table dérivée, avec ou sans alias, à utiliser dans l'instruction Transact-SQL. Vous pouvez utiliser jusqu'à 256 sources de table dans une instruction, bien que cette limite varie en fonction de la mémoire disponible et de la complexité des autres expressions constituant la requête. Les requêtes individuelles, pour leur part, n'acceptent pas toujours 256 sources de table. Une variable de table peut être spécifiée comme source de table.

    ms177634.note(fr-fr,SQL.90).gifRemarque :
    Les performances des requêtes risquent de baisser si le nombre des tables référencées dans une requête est élevé. Les durées de compilation et d'optimisation sont également affectées par d'autres facteurs. Parmi ceux-ci figurent les index et les vues indexées sur chaque <table_source>, ainsi que la taille de <select_list> dans l'instruction SELECT.

    L'ordre des sources de table derrière le mot clé FROM n'a aucune incidence sur l'ensemble de résultats retourné. SQL Server 2005 retourne des erreurs lorsque des noms dupliqués apparaissent dans la clause FROM.

  • table_or_view_name
    Nom d'une table ou d'une vue.

    Si la table ou la vue existe dans une autre base de données sur le même ordinateur qui exécute une instance de SQL Server, utilisez un nom autorisé qui respecte la syntaxe database.schema.object_name. Si la table ou la vue existe en dehors du serveur local sur un serveur lié, utilisez un nom à quatre composantes dans la formule linked_server.catalog.schema.object. Un nom de table ou de vue à quatre composantes est construit à l'aide de la fonction OPENDATASOURCE, car la composante serveur du nom peut également être utilisée comme source de la table. Pour plus d'informations sur cette fonction, consultez OPENDATASOURCE (Transact-SQL).

  • [AS] table_alias
    Alias de table_source utilisé soit par commodité, soit pour distinguer une table ou une vue dans une jointure réflexive ou une sous-requête. Un alias correspond souvent au raccourci du nom de table utilisé pour faire référence à des colonnes spécifiques des tables dans une jointure. Si le même nom de colonne existe dans plusieurs tables de la jointure, SQL Server exige que le nom de la colonne soit qualifié par un nom de table, un nom de vue ou un alias. Le nom de table ne peut pas être utilisé si un alias est défini.

    Lorsqu'une table dérivée, un ensemble de lignes ou une fonction table, ou encore une clause d'opérateur (telle que PIVOT ou UNPIVOT) sont utilisés, l'alias table_alias requis à la fin de la clause est le nom de la table associé pour toutes les colonnes retournées, notamment les colonnes de regroupement.

  • WITH (<table_hint> )
    Spécifie que l'optimiseur de requête utilise une stratégie d'optimisation ou de verrouillage avec cette table et pour cette instruction. Pour plus d'informations, consultez Indicateur de table (T-SQL).

    Dans SQL Server 2005, à quelques exceptions près, les indicateurs de table sont pris en charge dans la clause FROM uniquement s'ils sont spécifiés avec le mot clé WITH. Ils doivent également être spécifiés à l'aide de crochets.

    Les indicateurs autorisés avec et sans le mot clé WITH sont les suivants : NOLOCK, READUNCOMMITTED, UPDLOCK, REPEATABLEREAD, SERIALIZABLE, READCOMMITTED, FASTFIRSTROW, TABLOCK, TABLOCKX, PAGLOCK, ROWLOCK, NOWAIT, READPAST, XLOCK et NOEXPAND. Lorsque ces indicateurs de table sont spécifiés sans le mot clé WITH, ils doivent l'être seuls. Par exemple : FROM t (fastfirstrow).

    Lorsque l'indicateur est spécifié avec une autre option, comme dans (fastfirstrow, index(myindex), il doit l'être avec le mot clé WITH comme suit :

    FROM t WITH (fastfirstrow, index(myindex)).

    Le mot clé WITH n'est pas obligatoire avec des indicateurs lorsque la base de données a un niveau de compatibilité égal ou inférieur à 80.

  • rowset_function
    Spécifie une des fonctions d'ensemble de lignes, telle que OPENROWSET, qui retourne un objet pouvant être utilisé à la place d'une référence de table. Pour plus d'informations sur une liste des fonctions d'ensembles de lignes, consultez Fonctions Rowset (Transact-SQL).

  • bulk_column_alias
    Alias facultatif qui peut remplacer un nom de colonne dans l'ensemble de résultats. Les alias de colonne sont autorisés uniquement dans les instructions SELECT qui utilisent la fonction OPENROWSET avec l'option BULK. Lorsque vous utilisez bulk_column_alias, spécifiez un alias pour chaque colonne de table dans le même ordre que les colonnes du fichier.

    ms177634.note(fr-fr,SQL.90).gifRemarque :
    Cet alias remplace l'attribut NAME dans les éléments COLUMN d'un fichier XML, le cas échéant.
  • user_defined_function
    Spécifie une fonction table.
  • OPENXML <openxml_clause>
    Fournit une vue de l'ensemble des lignes d'un document XML. Pour plus d'informations, consultez OPENXML (Transact-SQL).
  • derived_table
    Sous-requête qui récupère les lignes de la base de données. Le paramètre derived_table est utilisé comme entrée de la requête externe.
  • column_alias
    Alias facultatif qui peut remplacer un nom de colonne dans l'ensemble de résultats de la table dérivée. Utilisez un alias de colonne pour chaque colonne de la liste de sélection et placez l'intégralité de la liste d'alias entre parenthèses.

  • <tablesample_clause>
    Spécifie qu'un exemple de données est retourné à partir de la table. L'exemple peut être approximatif. Cette clause peut être utilisée sur toute table primaire ou jointe dans une instruction SELECT, UPDATE ou DELETE. TABLESAMPLE ne peut pas être spécifiée avec des vues. Pour plus d'informations, consultez Limitation du nombre d'ensembles de résultats au moyen de la clause TABLESAMPLE.

    ms177634.note(fr-fr,SQL.90).gifRemarque :
    Lorsque vous utilisez TABLESAMPLE sur des bases de données mises à niveau sur SQL Server 2005, leur niveau de compatibilité doit être défini sur 90. Pour définir le niveau de compatibilité des bases de données, consultez sp_dbcmptlevel (Transact-SQL).
  • SYSTEM
    Méthode d'échantillonnage dépendante d'une implémentation et spécifiée par ANSI SQL. Dans SQL Server 2005, il s'agit de la seule méthode disponible et elle s'applique par défaut. SYSTEM applique une méthode d'échantillonnage basée sur les pages, dans laquelle est choisie une série aléatoire de pages issues d'un exemple. Toutes les lignes sur ces pages sont retournées comme un exemple de sous-ensemble. Pour plus d'informations, consultez Limitation du nombre d'ensembles de résultats au moyen de la clause TABLESAMPLE.
  • sample_number
    Expression numérique constante exacte ou approximative qui représente le pourcentage ou le nombre de lignes. Avec une spécification PERCENT, sample_number est converti implicitement en une valeur float. Dans le cas contraire, il est converti en bigint. PERCENT est la valeur par défaut.
  • PERCENT
    Spécifie qu'un pourcentage sample_number de lignes de la table doit en être extrait. Avec une spécification PERCENT, SQL Server retourne une approximation du pourcentage spécifié. Avec une spécification PERCENT, l'expression sample_number doit correspondre à une valeur comprise entre 0 et 100.
  • ROWS
    Spécifie qu'environ sample_number de lignes seront extraites. Avec une spécification ROWS, SQL Server retourne un nombre de lignes approximatif. Avec une spécification ROWS, l'expression sample_number doit correspondre à une valeur entière supérieure à zéro.
  • REPEATABLE
    Indique que l'exemple sélectionné peut être retourné à nouveau. Avec une spécification de la même valeur repeat_seed , SQL Server retourne le même sous-ensemble de lignes tant qu'aucune modification n'a été apportée aux lignes de la table. Avec une spécification autre que la valeur repeat_seed, SQL Server retourne probablement d'autres exemples de lignes dans la table. Les actions suivantes sur la table sont considérées comme des modifications : insertion, mise à jour, suppression, reconstruction ou défragmentation d'index et restauration ou attachement de la base de données.
  • repeat_seed
    Expression d'un entier de type constante utilisée par SQL Server pour générer un nombre aléatoire. repeat_seed est de type bigint. Si la valeur repeat_seed n'est pas spécifiée, SQL Server affecte une valeur aléatoire. Pour une valeur repeat_seed spécifique, le résultat de l'échantillonnage est toujours identique, à condition qu'aucune modification ne soit apportée à la table. L'expression repeat_seed doit correspondre à un entier supérieur à zéro.
  • <joined_table>
    Ensemble de résultats correspondant au produit de deux ou plusieurs tables. Pour plusieurs jointures, utilisez les parenthèses pour modifier l'ordre naturel des jointures.
  • <join_type>
    Spécifie le type d'opération de jointure.
  • INNER
    Spécifie toutes les paires correspondantes des lignes retournées. Supprime les lignes n'ayant pas de correspondance entre les deux tables. Lorsqu'aucun type de jointure n'est spécifié, cet argument est la valeur par défaut.
  • FULL [ OUTER ]
    Spécifie qu'une ligne de la table de gauche ou de droite ne respectant pas la condition de jointure est comprise dans l'ensemble de résultats et que les colonnes de sortie correspondant à l'autre table comportent des valeurs NULL. Cette information est fournie en plus de toutes les lignes généralement retournées par la fonction INNER JOIN.
  • LEFT [ OUTER ]
    Spécifie que toutes les lignes de la table de gauche ne respectant pas la condition de jointure sont comprises dans l'ensemble de résultats et que les colonnes de sortie de l'autre table ont des valeurs NULL en plus de toutes les lignes retournées par la jointure interne.
  • RIGHT [OUTER]
    Spécifie que toutes les lignes de la table de droite ne respectant pas la condition de jointure sont comprises dans l'ensemble de résultats et que les colonnes de sortie correspondant à l'autre table ont des valeurs NULL en plus de toutes les lignes retournées par la jointure interne.
  • <join_hint>
    Spécifie que l'optimiseur de requête SQL Server utilise un indicateur de jointure ou un algorithme d'exécution par jointure spécifiée dans la clause FROM de la requête. Pour plus d'informations, consultez Indicateur de jointure (Transact-SQL).
  • JOIN
    Indique que l'opération de jointure spécifiée doit avoir lieu entre les sources de table ou les vues spécifiés.

  • ON <search_condition>
    Spécifie la condition sur laquelle se base la jointure. Celle-ci peut spécifier tout prédicat, bien que les opérateurs de colonne et de comparaison soient souvent utilisés, par exemple :

    SELECT p.ProductID, v.VendorID
FROM Production.Product AS p 
JOIN Purchasing.ProductVendor AS v
ON (p.ProductID = v.ProductID);

    Lorsqu'une condition spécifie des colonnes, celles-ci ne doivent pas nécessairement avoir le même nom ou le même type de données. Toutefois, si les types de données sont différents, ils doivent être compatibles ou pouvoir être convertis implicitement par SQL Server 2005. Si les types de données ne peuvent pas être convertis implicitement, la condition de jointure doit le faire explicitement à l'aide de la fonction CONVERT.

    Il se peut que des prédicats n'impliquent qu'une seule des tables jointes dans la clause ON. Ces prédicats peuvent également figurer dans la clause WHERE de la requête. Bien que la position de ces prédicats soit sans importance dans le cas de jointures INNER, ils peuvent aboutir à un résultat différent dans le cas de jointures OUTER. En effet, les prédicats figurant dans la clause ON sont appliqués à la table avant de l'être à la jointure, tandis que la clause WHERE est sémantiquement appliquée au résultat de la jointure.

    Pour plus d'informations sur les critères de recherche et les prédicats, consultez Condition de recherche (Transact-SQL).

  • CROSS JOIN
    Spécifie le produit croisé de deux tables. Retourne les mêmes lignes comme si aucune clause WHERE n'avait été spécifiée dans une ancienne jointure d'un style différent de SQL-92.

  • left_table_source{ CROSS | OUTER } APPLY right_table_source
    Spécifie que right_table_source de l'opérateur APPLY est évaluée par rapport à chaque ligne de left_table_source. Cette fonctionnalité est utile lorsque right_table_source contient une fonction table qui retire les valeurs de colonne de left_table_source pour les traiter comme l'un de ses arguments.

    Soit CROSS, soit OUTER doit être spécifié avec APPLY. Avec une spécification CROSS, aucune ligne n'est produite lorsque right_table_source est évaluée par rapport à une ligne spécifiée de left_table_source ; de plus, un ensemble de résultats vide est retourné.

    Avec une spécification OUTER, une ligne est produite pour chaque ligne de left_table_source, même si right_table_source est évaluée par rapport à celle-ci ; de plus, un ensemble de résultats vide est retourné.

    Pour plus d'informations, consultez la section Notes et Utilisation de APPLY.

  • left_table_source
    Source de table, telle qu'elle est définie dans l'argument précédent. Pour plus d'informations, consultez la section Remarques.
  • right_table_source
    Source de table, telle qu'elle est définie dans l'argument précédent. Pour plus d'informations, consultez la section Notes.

  • table_source PIVOT <pivot_clause>
    Spécifie que la table_source est croisée dynamiquement sur pivot_column. table_source est une table ou une expression de table. La sortie est une table contenant toutes les colonnes de table_source, à l'exception de pivot_column et de value_column. Les colonnes de table_source, à l'exception de pivot_column et de value_column, sont appelées colonnes de groupement de l'opérateur pivot.

    PIVOT opère un regroupement sur la table d'entrée en regard des colonnes de regroupement et retourne une ligne par groupe. Qui plus est, la sortie contient une colonne pour chaque valeur spécifiée dans column_list qui s'affiche dans pivot_column de input_table.

    Pour plus d'informations, consultez la section Notes et Utilisation des opérateurs PIVOT et UNPIVOT.

    ms177634.note(fr-fr,SQL.90).gifRemarque :
    Lorsque vous utilisez PIVOT sur des bases de données mises à niveau vers SQL Server 2005, leur niveau de compatibilité doit être défini sur 90. Pour définir le niveau de compatibilité des bases de données, consultez sp_dbcmptlevel (Transact-SQL).

  • aggregate_function
    Fonction d'agrégation système ou définie par l'utilisateur. Cette fonction doit être indifférente aux valeurs NULL. Une fonction d'agrégation indifférente aux valeurs NULL ne prend pas en considération les valeurs NULL dans le groupe, bien qu'elle évalue la valeur d'agrégation.

    La fonction d'agrégation système COUNT(*) n'est pas autorisée.

  • value_column
    Colonne de valeur de l'opérateur PIVOT. Lorsqu'elle est utilisée avec UNPIVOT, value_column ne peut pas être le nom d'une colonne existante dans la table_source d'entrée.

  • FOR pivot_column
    Colonne de tableau croisé dynamique de l'opérateur PIVOT. pivot_column doit être d'un type implicitement ou explicitement convertible en nvarchar(). Cette colonne ne peut pas être de type image ou rowversion.

    Lorsque l'opérateur UNPIVOT est utilisé, pivot_column est le nom de la colonne de sortie qui est limitée à table_source. Il ne peut pas exister de colonne portant ce nom dans table_source.

  • IN **(**column_list )
    Répertorie les valeurs dans pivot_column, dans la clause PIVOT, qui deviennent des noms de colonne de la table de sortie. La liste ne peut pas spécifier de nom de colonne existant dans la table_source d'entrée qui est croisée dynamiquement.

    Répertorie les colonnes dans table_source, dans la clause UNPIVOT, pour être limitées à une seule pivot_column.

  • table_alias
    Nom d'alias de la table de sortie. pivot_table_alias doit être spécifié.

  • UNPIVOT < unpivot_clause >
    Spécifie que la table d'entrée est restreinte de plusieurs colonnes dans column_list à une seule colonne appelée pivot_column.

    Pour plus d'informations, consultez la section Notes et Utilisation des opérateurs PIVOT et UNPIVOT.

    ms177634.note(fr-fr,SQL.90).gifRemarque :
    Lorsque vous utilisez UNPIVOT sur des bases de données mises à niveau vers SQL Server 2005, leur niveau de compatibilité doit être défini sur 90. Pour définir le niveau de compatibilité des bases de données, consultez sp_dbcmptlevel (Transact-SQL).

Notes

La clause FROM prend en charge la syntaxe SQL-92 pour les tables jointes et les tables dérivées. La syntaxe SQL-92 fournit les opérateurs de jointure INNER, LEFT OUTER, RIGHT OUTER, FULL OUTER et CROSS.

Les opérateurs de jointure de sortie (*= et =*) ne sont pas pris en charge lorsque le niveau de compatibilité de la base de données est défini sur 90.

UNION et JOIN à l'intérieur d'une clause FROM sont pris en charge aussi bien dans les vues que dans les tables dérivées et les sous-requêtes.

Une jointure réflexive est une table qui effectue une jointure avec elle-même. Les insertions ou les mises à jour basées sur une jointure réflexive suivent l'ordre de la clause FROM.

Sachant que SQL Server 2005 prend en compte les statistiques de distribution et de cardinalité à partir des serveurs liés qui fournissent les statistiques de distribution des colonnes, l'indicateur de jointure REMOTE n'est pas réellement nécessaire pour forcer l'évaluation d'une jointure à distance. Le processeur de requêtes SQL Server prend en considération les statistiques distantes et détermine l'opportunité ou non d'une stratégie de jointure distante. L'indicateur de jointure REMOTE est utile pour les fournisseurs qui ne produisent pas de statistiques de distribution des colonnes. Pour plus d'informations, consultez Conditions associées aux statistiques de distribution pour les fournisseurs OLE DB.

Pour plus d'informations sur le mode de fonctionnement des jointures, consultez Principes de base des jointures et Utilisation des jointures.

Utilisation de APPLY

Les opérandes de gauche et de droite de l'opérateur APPLY sont des expressions de table. Leur principale différence repose sur le fait que right_table_source peut utiliser une fonction table prenant une colonne à partir de left_table_source comme l'un de ses arguments. left_table_source peut inclure des fonctions table, mais elle ne peut pas contenir des arguments qui sont des colonnes de right_table_source.

L'opérateur APPLY fonctionne de la même façon pour produire la source de table pour la clause FROM :

  1. Évalue right_table_source par rapport à chaque ligne de left_table_source pour produire des ensembles de lignes.
    Les valeurs de right_table_source dépendent de left_table_source. right_table_source peut être représentée approximativement de la façon suivante : TVF(left_table_source.row), où TVF est une fonction table.
  2. Associe les ensembles de résultats produits pour chaque ligne lors de l'évaluation de right_table_source avec left_table_source, en effectuant une opération UNION ALL.
    La liste de colonnes résultant de l'opérateur APPLY est l'ensemble de colonnes issu de left_table_source, qui est combiné à une liste de colonnes issue de right_table_source.

Utilisation de PIVOT et UNPIVOT

pivot_column et value_column sont des colonnes de regroupement utilisées par l'opérateur PIVOT. PIVOT suit le processus ci-après pour obtenir l'ensemble de résultats de sortie :

  1. Il effectue une opération GROUP BY sur sa input_table par rapport aux colonnes de regroupement. Il produit aussi une ligne de sortie pour chaque groupe.
    Les colonnes de regroupement dans la ligne de sortie obtiennent les valeurs de colonnes correspondantes pour ce groupe dans input_table.
  2. Il génère des valeurs pour les colonnes dans la liste correspondante pour chaque sortie en effectuant les opérations suivantes :
    1. Regroupement supplémentaire des lignes générées dans GROUP BY lors de l'étape précédente, par rapport à pivot_column.
      Sélection d'un sous-groupe qui répond à ce critère, pour chaque colonne de sortie dans column_list :
      pivot_column = CONVERT(<data type of pivot_column>, 'output_column')
    2. aggregate_function est évaluée par rapport à value_column sur ce sous-groupe, et son résultat est retourné en tant que valeur de la output_column correspondante. Si le sous-groupe est vide, SQL Server génère une valeur NULL pour cette output_column. Si la fonction d'agrégation est COUNT et que le sous-groupe est vide, la valeur zéro (0) est retournée.

Pour plus d'informations, consultez Utilisation des opérateurs PIVOT et UNPIVOT.

Autorisations

Nécessite les autorisations pour les instructions DELETE, SELECT ou UPDATE.

Exemples

A. Utilisation d'une clause FROM simple

L'exemple suivant extrait les colonnes TerritoryID et Name à partir de la table SalesTerritory dans l'exemple de base de données AdventureWorks.

USE AdventureWorks ;
GO
SELECT TerritoryID, Name
FROM Sales.SalesTerritory
ORDER BY TerritoryID ;

Voici l'ensemble des résultats.

TerritoryID Name                          
----------- ------------------------------
1           Northwest                     
2           Northeast                     
3           Central                       
4           Southwest                     
5           Southeast                     
6           Canada                        
7           France                        
8           Germany                       
9           Australia                     
10          United Kingdom                
(10 row(s) affected)

B. Utilisation des indicateurs d'optimiseur TABLOCK et HOLDLOCK

La transaction partielle suivante illustre le mode de placement d'un verrou de table partagé explicite sur Employee et le mode de lecture de l'index. Le verrou est présent pendant toute la transaction.

USE AdventureWorks ;
GO
BEGIN TRAN
SELECT COUNT(*) 
FROM HumanResources.Employee WITH (TABLOCK, HOLDLOCK) ;

C. Utilisation de la syntaxe SQL-92 CROSS JOIN

L'exemple suivant retourne le produit croisé des deux tables Employee et Department. La liste de toutes les combinaisons possibles des lignes EmployeeID et Department est retournée.

USE AdventureWorks ;
GO
SELECT e.EmployeeID, d.Name AS Department
FROM HumanResources.Employee AS e
CROSS JOIN HumanResources.Department AS d
ORDER BY e.EmployeeID, d.Name ;

D. Utilisation de la syntaxe SQL-92 FULL OUTER JOIN

L'exemple suivant retourne le nom de produit et toute commande correspondante dans la table SalesOrderDetail. Il retourne également toutes les commandes dont les produits ne sont pas répertoriés dans la table Product ainsi que tous les produits dont les commandes sont différentes de celles répertoriées dans la table Product.

USE AdventureWorks ;
GO
-- The OUTER keyword following the FULL keyword is optional.
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
FULL OUTER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
WHERE p.ProductID IS NULL OR sod.ProductID IS NULL
ORDER BY p.Name ;

E. Utilisation de la syntaxe SQL-92 LEFT OUTER JOIN

L'exemple suivant joint deux tables sur ProductID et conserve les lignes sans correspondance de la table de gauche. La table Product correspond à la table SalesOrderDetail sur les colonnes ProductID de chaque table. Tous les produits, qu'ils soient commandés ou non, apparaissent dans l'ensemble de résultats.

USE AdventureWorks ;
GO
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
LEFT OUTER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY p.Name ;

F. Utilisation de la syntaxe SQL-92 INNER JOIN

L'exemple suivant retourne tous les noms de produits et tous les ID des commandes.

USE AdventureWorks ;
GO
-- By default, SQL Server performs an INNER JOIN if only the JOIN 
-- keyword is specified.
SELECT p.Name, sod.SalesOrderID
FROM Production.Product AS p
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY p.Name ;

G. Utilisation de la syntaxe SQL-92 RIGHT OUTER JOIN

L'exemple suivant joint deux tables sur TerritoryID et conserve les lignes sans correspondance de la table de droite. La table SalesTerritory correspond à la table SalesPerson sur la colonne TerritoryID de chaque table. Tous les vendeurs apparaissent dans l'ensemble de résultats, qu'un territoire leur ait été attribué ou non.

USE AdventureWorks ;
GO
SELECT st.Name AS Territory, sp.SalesPersonID
FROM Sales.SalesTerritory AS st 
RIGHT OUTER JOIN Sales.SalesPerson AS sp
ON st.TerritoryID = sp.TerritoryID ;

H. Utilisation des indicateurs de jointure HASH et MERGE

L'exemple suivant effectue une jointure sur trois tables parmi les tables Product, ProductVendor et Vendor afin de produire une liste de produits et de leurs fournisseurs. L'optimiseur de requête joint Product et ProductVendor (p et pv) à l'aide de la jointure MERGE. Ensuite, les résultats de la jointure MERGE Product et ProductVendor (p et pv) sont joints à l'aide de HASH à la table Vendor pour produire (p et pv) et v.

ms177634.note(fr-fr,SQL.90).gifImportant :
Lorsqu'un indicateur de jointure est spécifié, le mot clé INNER n'est plus facultatif et doit être déclaré de manière explicite pour l'exécution d'une jointure INNER JOIN. 
USE AdventureWorks ;
GO
SELECT p.Name AS ProductName, v.Name AS VendorName
FROM Production.Product AS p 
INNER MERGE JOIN Purchasing.ProductVendor AS pv 
ON p.ProductID = pv.ProductID
INNER HASH JOIN Purchasing.Vendor AS v
ON pv.VendorID = v.VendorID
ORDER BY p.Name, v.Name ;

I. Utilisation d'une table dérivée

L'exemple suivant se sert d'une table dérivée, d'une instruction SELECT après la clause FROM, pour retourner les prénoms et noms de tous les employés ainsi que leurs villes de résidence.

USE AdventureWorks ;
GO
SELECT RTRIM(c.FirstName) + ' ' + LTRIM(c.LastName) AS Name,
 d.City
FROM Person.Contact AS c
INNER JOIN HumanResources.Employee e ON c.ContactID = e.ContactID 
INNER JOIN
   (SELECT ea.AddressID, ea.EmployeeID, a.City 
    FROM Person.Address AS a
    INNER JOIN HumanResources.EmployeeAddress AS ea
    ON a.AddressID = ea.AddressID) AS d
ON e.EmployeeID = d.EmployeeID
ORDER BY c.LastName, c.FirstName;

J. Utilisation de TABLESAMPLE pour lire des données à partir d'un exemple de lignes dans une table

L'exemple suivant utilise TABLESAMPLE dans la clause FROM pour retourner environ 10 % de toutes les lignes dans la table Customer de la base de données AdventureWorks.

USE AdventureWorks ;
GO
SELECT *
FROM Sales.Customer TABLESAMPLE SYSTEM (10 PERCENT) ;

K. Utilisation de APPLY

L'exemple suivant suppose que les tables ci-après associées au schéma suivant existent dans la base de données :

  • Departments: DeptID, DivisionID, DeptName, DeptMgrID
  • EmpMgr: MgrID, EmpID
  • Employees: EmpID, EmpLastName, EmpFirstName, EmpSalary

Il existe également une fonction table, GetReports(MgrID), qui retourne la liste de tous les employés (EmpID, EmpLastName, EmpSalary) qui rendent directement ou indirectement compte au MgrID spécifié.

L'exemple utilise APPLY pour retourner tous les services et tous les employés en faisant partie. Si un service particulier est dépourvu d'employés, aucune ligne ne sera retournée pour celui-ci.

SELECT DeptID, DeptName, DeptMgrID, EmpID, EmpLastName, EmpSalary
FROM Departments d CROSS APPLY dbo.GetReports(d.DeptMgrID) ;

Si vous souhaitez que la requête produise des lignes pour ces services sans employés, ce qui produira des valeurs NULL pour les colonnes EmpID, EmpLastName et EmpSalary, utilisez plutôt OUTER APPLY.

SELECT DeptID, DeptName, DeptMgrID, EmpID, EmpLastName, EmpSalary
FROM Departments d OUTER APPLY dbo.GetReports(d.DeptMgrID) ;

L. Utilisation de PIVOT et UNPIVOT

L'exemple suivant retourne le nombre de commandes passées par les ID d'employés 164, 198, 223, 231 et 233, classées par ID de fournisseur.

USE AdventureWorks
GO
SELECT VendorID, [164] AS Emp1, [198] AS Emp2, [223] AS Emp3, [231] AS Emp4, [233] AS Emp5
FROM 
(SELECT PurchaseOrderID, EmployeeID, VendorID
FROM Purchasing.PurchaseOrderHeader) AS p
PIVOT
(
COUNT (PurchaseOrderID)
FOR EmployeeID IN
( [164], [198], [223], [231], [233] )
) AS pvt
ORDER BY VendorID;

Voici un ensemble de résultats partiel :

VendorID    Emp1        Emp2        Emp3        Emp4        Emp5
1           4           3           5           4           4
2           4           1           5           5           5
3           4           3           5           4           4
4           4           2           5           5           4
5           5           1           5           5           5

Pour exécuter l'opérateur UNPIVOT sur la table, partez du principe que l'ensemble de résultats produit dans l'exemple précédent est stocké en tant que pvt. La requête est la suivante :

--Create the table and insert values as portrayed in the previous example.
CREATE TABLE pvt (VendorID int, Emp1 int, Emp2 int,
Emp3 int, Emp4 int, Emp5 int);
GO
INSERT INTO pvt VALUES (1,4,3,5,4,4);
INSERT INTO pvt VALUES (2,4,1,5,5,5);
INSERT INTO pvt VALUES (3,4,3,5,4,4);
INSERT INTO pvt VALUES (4,4,2,5,5,4);
INSERT INTO pvt VALUES (5,5,1,5,5,5);
GO
--Unpivot the table.
SELECT VendorID, Employee, Orders
FROM 
    (SELECT VendorID, Emp1, Emp2, Emp3, Emp4, Emp5
    FROM pvt) AS p
UNPIVOT
    (Orders FOR Employee IN 
        (Emp1, Emp2, Emp3, Emp4, Emp5)
)AS unpvt
GO

Voici un ensemble de résultats partiel :

VendorID    Employee    Orders
1           Emp1        4
1           Emp2        3
1           Emp3        5
1           Emp4        4
1           Emp5        4
2           Emp1        4
2           Emp2        1
2           Emp3        5
2           Emp4        5
2           Emp5        5

Voir aussi

Référence

CONTAINSTABLE (Transact-SQL)
DELETE (Transact-SQL)
FREETEXTTABLE (Transact-SQL)
INSERT (Transact-SQL)
OPENQUERY (Transact-SQL)
OPENROWSET (Transact-SQL)
Opérateurs (Transact-SQL)
UPDATE (Transact-SQL)
WHERE (Transact-SQL)

Aide et Informations

Assistance sur SQL Server 2005

Historique des modifications

Version Historique

5 décembre 2005
Contenu modifié :
  • Correction apportée à l'exemple I : Utilisation d'une table dérivée.