FROM (Transact-SQL)

Spécifie les tables, les vues, les tables dérivées et les tables jointes utilisées dans les instructions DELETE, SELECT et UPDATE dans SQL Server 2012. 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).

Conventions de la syntaxe 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 ] ]
    | 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> [ AS ] table_alias

<pivot_clause> ::=
        ( aggregate_function ( value_column [ [ , ]...n ]) 
        FOR pivot_column 
        IN ( <column_list> ) 
    ) 

<unpivoted_table> ::=
    table_source UNPIVOT <unpivot_clause> [ AS ] 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, une variable de table 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 peuvent ne pas prendre en charge 256 sources de table.

  [!REMARQUE]

  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 après le mot clé FROM n'a aucune incidence sur le jeu de résultats retourné. SQL Server 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 la même instance d'SQL Server, utilisez un nom complet qui respecte la syntaxe database.schema.object_name.

  Si la table ou la vue existe en dehors de l'instance d'SQL Server l, utilisez un nom en quatre parties sous la forme linked_server.catalog.schema.object. Pour plus d'informations, consultez sp_addlinkedserver (Transact-SQL). Un nom en quatre parties est construit à l'aide de la fonction OPENDATASOURCE, car la partie serveur du nom peut également être utilisée pour spécifier la source de la table distante. Lorsque OPENDATASOURCE est spécifié, database_name et schema_name peuvent ne pas s'appliquer à toutes les sources de données ; par ailleurs, ils dépendent des fonctionnalités du fournisseur OLE DB qui accède à l'objet distant.

• [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 aux 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 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 Indicateurs de table (Transact-SQL).

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

  L'utilisation des fonctions OPENROWSET et OPENQUERY pour spécifier un objet distant dépend des fonctionnalités du fournisseur OLE DB qui accède à l'objet.

• bulk_column_alias
  Alias facultatif qui peut remplacer un nom de colonne dans le jeu 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.

  [!REMARQUE]

  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 de 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. derived_table est utilisé comme entrée de la requête externe.

  derived_table peut utiliser le constructeur de valeurs de table Transact-SQL pour spécifier plusieurs lignes. Par exemple, SELECT * FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ) AS MyTable(a, b);. Pour plus d'informations, consultez Constructeur de valeurs de table (Transact-SQL).

• column_alias
  Alias facultatif qui peut remplacer un nom de colonne dans le jeu 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 de colonnes 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é avec des vues.

  [!REMARQUE]

  Lorsque vous utilisez TABLESAMPLE sur des bases de données mises à niveau vers SQL Server, le niveau de compatibilité de la base de données est défini à 110 ou plus, PIVOT n'est pas autorisé dans une requête d'expression de table commune récursive (CTE). Pour plus d'informations, consultez Niveau de compatibilité ALTER DATABASE (Transact-SQL).

• SYSTEM
  Méthode d'échantillonnage dépendante de l'implémentation et spécifiée par les normes ISO. Dans SQL Server, il s'agit de la seule méthode d'échantillonnage disponible et elle s'applique par défaut. SYSTEM applique une méthode d'échantillonnage basée sur des pages, dans laquelle un jeu de pages aléatoire est choisi pour l'exemple ; toutes les lignes de ces pages sont retournées comme exemple de sous-ensemble.

• sample_number
  Expression numérique constante exacte ou approximative qui représente le pourcentage ou le nombre de lignes. Lorsqu'il est spécifié avec PERCENT, sample_number est converti implicitement en une valeur float ; sinon, il est converti en bigint. PERCENT est la valeur par défaut.

• PERCENT
  Spécifie qu'un pourcentage sample_number des lignes de la table doit être récupéré à partir de cette dernière. Lorsque PERCENT est spécifié, SQL Server retourne une approximation du pourcentage spécifié. Lorsque PERCENT est spécifié, l'expression sample_number doit correspondre à une valeur comprise entre 0 et 100.

• ROWS
  Spécifie qu'un nombre approximatif de lignes équivalent à sample_number doit être récupéré. Lorsque ROWS est spécifié, SQL Server retourne une valeur approximative du nombre de lignes indiqué. Lorsque ROWS est spécifié, 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. Lorsqu'il est spécifié avec 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. Lorsqu'il est spécifié avec une autre valeur repeat_seed, SQL Server retourne vraisemblablement d'autres exemples de lignes de la table. Les actions suivantes effectuées sur la table sont considérées comme des modifications : insertion, mise à jour, suppression, reconstruction ou défragmentation d'index, restauration ou attachement de 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>
  Jeu de résultats correspondant au produit de deux ou plusieurs tables. Pour plusieurs jointures, utilisez des parenthèses afin de modifier l'ordre naturel des jointures.

• <join_type>
  Spécifie le type d'opération de jointure.

• INNER
  Spécifie que toutes les paires correspondantes de lignes sont retournées. Supprime les lignes n'ayant pas de correspondance dans 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 qui ne respecte pas la condition de jointure est incluse dans le jeu de résultats et que les colonnes de sortie qui correspondent à l'autre table ont des valeurs NULL. Cela s'ajoute à toutes les lignes généralement retournées par INNER JOIN.

• LEFT [ OUTER ]
  Spécifie que toutes les lignes de la table de gauche qui ne respectent pas la condition de jointure sont incluses dans le jeu 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 qui ne respectent pas la condition de jointure sont incluses dans le jeu de résultats et que les colonnes de sortie qui correspondent à 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) pour chaque jointure spécifiée dans la clause FROM de la requête. Pour plus d'informations, consultez Indicateurs 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ées.

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

  USE AdventureWorks2012 ;
  GO
  SELECT p.ProductID, v.BusinessEntityID
  FROM Production.Product AS p 
  JOIN Purchasing.ProductVendor AS v
  ON (p.ProductID = v.ProductID);
  

  Lorsque la 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. Si les types de données ne peuvent pas être convertis implicitement, la condition doit convertir explicitement le type de données à 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 le right_table_source de l'opérateur APPLY est évalué par rapport à chaque ligne de left_table_source. Cette fonctionnalité est utile lorsque right_table_source contient une fonction table qui prend les valeurs de colonnes de left_table_source pour les traiter comme l'un de ses arguments.

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

  Lorsque OUTER est spécifié, une ligne est produite pour chaque ligne de left_table_source, même lorsque right_table_source est évalué par rapport à cette ligne ; de plus, un jeu de résultats vide est retourné.

  Pour plus d'informations, consultez les remarques.

• left_table_source
  Source de table, telle qu'elle est définie dans l'argument précédent. Pour plus d'informations, consultez les 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 Remarques.

• table_source PIVOT <pivot_clause>
  Spécifie que table_source est croisé 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 regroupement de l'opérateur pivot.

  PIVOT opère un regroupement sur la table d'entrée par rapport aux colonnes de regroupement et retourne une ligne par groupe. En outre, la sortie contient une colonne pour chaque valeur spécifiée dans column_list qui s'affiche dans le pivot_column de input_table.

  Pour plus d'informations, consultez les remarques qui suivent.

• aggregate_function
  Fonction d'agrégation système ou définie par l'utilisateur qui accepte une ou plusieurs entrées. 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 lors de l'évaluation de 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 le table_source d'entrée.

• FOR pivot_column
  Colonne de tableau croisé dynamique de l'opérateur PIVOT. pivot_column doit appartenir à un type de données 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 réduite à partir de 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 doivent devenir des noms de colonnes de la table de sortie. La liste ne peut pas spécifier de noms de colonnes déjà existants dans le table_source d'entrée qui est croisé dynamiquement.

  Répertorie les colonnes dans table_source, dans la clause UNPIVOT, qui doivent être réduites à un seul 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 réduite de plusieurs colonnes dans column_list à une seule colonne appelée pivot_column.

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.

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 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 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.

Utilisation de l'opérateur 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 qui prend une colonne de left_table_source comme l'un des arguments de cette fonction. left_table_source peut inclure des fonctions table, mais ne peut pas contenir d'arguments qui représentent 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é approximativement de la façon suivante : TVF(left_table_source.row), où TVF est une fonction table.

2. Associe les jeux de résultats produits pour chaque ligne lors de l'évaluation de right_table_source à 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 associé à la liste de colonnes issue de right_table_source.

Utilisation des opérateurs 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 le jeu de résultats de sortie :

1. Il effectue une opération GROUP BY sur son input_table par rapport aux colonnes de regroupement et produit 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 de colonnes pour chaque ligne de 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 à la condition ci-après, pour chaque colonne de sortie dans column_list :

      pivot_column = CONVERT(<data type of pivot_column>, 'output_column')

   2. aggregate_function est évalué par rapport à value_column sur ce sous-groupe et son résultat est retourné en tant que valeur output_column correspondante. Si le sous-groupe est vide, SQL Server génère une valeur NULL pour output_column. Si la fonction d'agrégation est COUNT et si le sous-groupe est vide, la valeur zéro (0) est retournée.

Autorisations

Nécessite les autorisations appropriées pour l'instruction DELETE, SELECT ou UPDATE.

Exemples

A.Utilisation d'une clause FROM simple

L'exemple suivant récupère les colonnes TerritoryID et Name à partir de la table SalesTerritory dans l'exemple de base de données AdventureWorks2012.

USE AdventureWorks2012 ;
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 conservé pendant toute la transaction.

USE AdventureWorks2012 ;
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 BusinessEntityID et Department est retournée.

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

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

L'exemple suivant retourne le nom de produit et les commandes correspondantes dans la table SalesOrderDetail. Il retourne également les commandes dont les produits ne sont pas répertoriés dans la table Product, ainsi que tous les produits dont la commande est différente de celle répertoriée dans la table Product.

USE AdventureWorks2012 ;
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 le jeu de résultats.

USE AdventureWorks2012 ;
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 de commandes.

USE AdventureWorks2012 ;
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 le jeu de résultats, qu'un secteur leur ait été attribué ou non.

USE AdventureWorks2012 ;
GO
SELECT st.Name AS Territory, sp.BusinessEntityID
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 d'une 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.

USE AdventureWorks2012 ;
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.BusinessEntityID = v.BusinessEntityID
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 leur ville de résidence.

USE AdventureWorks2012 ;
GO
SELECT RTRIM(p.FirstName) + ' ' + LTRIM(p.LastName) AS Name, d.City
FROM Person.Person AS p
INNER JOIN HumanResources.Employee e ON p.BusinessEntityID = e.BusinessEntityID 
INNER JOIN
   (SELECT bea.BusinessEntityID, a.City 
    FROM Person.Address AS a
    INNER JOIN Person.BusinessEntityAddress AS bea
    ON a.AddressID = bea.AddressID) AS d
ON p.BusinessEntityID = d.BusinessEntityID
ORDER BY p.LastName, p.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 de la table Customer.

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

K.Utilisation de l'opérateur 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 qui en font partie. Si un service particulier est dépourvu d'employés, aucune ligne n'est 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 génère des lignes pour ces services sans employés, ce qui produira des valeurs NULL pour les colonnes EmpID, EmpLastName et EmpSalary, utilisez OUTER APPLY à la place.

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

L.Utilisation des opérateurs 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 AdventureWorks2012;
GO
SELECT VendorID, [250] AS Emp1, [251] AS Emp2, [256] AS Emp3, [257] AS Emp4, [260] AS Emp5
FROM 
(SELECT PurchaseOrderID, EmployeeID, VendorID
FROM Purchasing.PurchaseOrderHeader) AS p
PIVOT
(
COUNT (PurchaseOrderID)
FOR EmployeeID IN
( [250], [251], [256], [257], [260] )
) AS pvt
ORDER BY VendorID;

Voici un jeu 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 supprimer le tableau croisé dynamique, partez du principe que le jeu 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 dbo.pvt (VendorID int, Emp1 int, Emp2 int,
Emp3 int, Emp4 int, Emp5 int);
GO
INSERT INTO dbo.pvt VALUES 
 (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);
GO
--Unpivot the table.
SELECT VendorID, Employee, Orders
FROM 
    (SELECT VendorID, Emp1, Emp2, Emp3, Emp4, Emp5
    FROM dbo.pvt) AS p
UNPIVOT
    (Orders FOR Employee IN 
        (Emp1, Emp2, Emp3, Emp4, Emp5)
)AS unpvt
GO

Voici un jeu 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

M.Utilisation de l'opérateur CROSS APPLY

L'exemple suivant récupère un instantané de tous les plans de requête résidant dans la mémoire cache des plans, en interrogeant la vue de gestion dynamique sys.dm_exec_cached_plans pour récupérer les descripteurs de plan de tous les plans de requête dans le cache. L'opérateur CROSS APPLY est spécifié pour transmettre les descripteurs de plan à sys.dm_exec_query_plan. La sortie du plan d'exécution de requêtes XML pour chaque plan actuellement dans la mémoire cache des plans se trouve dans la colonne query_plan de la table retournée.

USE master;
GO
SELECT dbid, object_id, query_plan 
FROM sys.dm_exec_cached_plans AS cp 
CROSS APPLY sys.dm_exec_query_plan(cp.plan_handle); 
GO

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)