FROM (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 de 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 de SQL Server, 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. Pour plus d'informations, consultez Requêtes distribuées.

• [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. Pour plus d'informations, consultez Requêtes distribuées.

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

  derived_table peut utiliser la fonctionnalité de 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. Pour plus d'informations, consultez Limitation du nombre d'ensembles de résultats au moyen de la clause TABLESAMPLE.

  [!REMARQUE]

  Lorsque vous utilisez TABLESAMPLE sur des bases de données mises à niveau vers SQL Server, leur niveau de compatibilité doit avoir une valeur supérieure ou égale à 90. Pour définir le niveau de compatibilité de la base de données, 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. 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. 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 prendre 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, il est probable que SQL Server retournera 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 :

  SELECT p.ProductID, v.VendorID
  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écifiée 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 la section Remarques 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 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 la section Notes et Utilisation des opérateurs PIVOT et UNPIVOT.

  [!REMARQUE]

  Lorsque vous utilisez PIVOT sur des bases de données mises à niveau vers SQL Server, leur niveau de compatibilité doit avoir une valeur supérieure ou égale à 90. Pour plus d'informations sur la définition du niveau de compatibilité d'une base de données, consultez Niveau de compatibilité ALTER DATABASE (Transact-SQL).

• 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'il est utilisé 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 ê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 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.

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

  [!REMARQUE]

  Lorsque vous utilisez UNPIVOT sur des bases de données mises à niveau vers SQL Server, leur niveau de compatibilité doit avoir une valeur supérieure ou égale à 90. Pour définir le niveau de compatibilité de la base de données, consultez Niveau de compatibilité ALTER DATABASE (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.

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.

Les versions antérieures de SQL Server prennent en charge la définition de jointures externes utilisant les opérateurs *= et =* dans la clause WHERE. SQL Server version 7.0 prend en charge la norme ISO. Cela fournit des opérateurs de jointure dans la clause FROM. Lorsque le niveau de compatibilité de la base de données est égal ou supérieur à 90, les opérateurs de jointure externe (*= et =*) ne sont pas pris en charge.

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

Utilisation des opérateurs PIVOT et UNPIVOT

Autorisations

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

Exemples

A. Utilisation d'une clause FROM simple

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

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

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

C. Utilisation de la syntaxe SQL-92 CROSS JOIN

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

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

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

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

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

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

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

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

K. Utilisation de l'opérateur APPLY

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

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

L. Utilisation des opérateurs PIVOT et UNPIVOT

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;

--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 5 rows into the table.
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

Voir aussi

Référence