FROM (Transact-SQL)

 

CETTE RUBRIQUE S’APPLIQUE À : ouiSQL Server (à partir de la version 2008)ouiAzure SQL DatabaseouiAzure SQL Data WarehouseouiParallel Data Warehouse

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

Topic link icon Conventions de la syntaxe Transact-SQL

-- Syntax for SQL Server and Azure SQL Database  
  
[ 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 ] ) ]  
    | FOR SYSTEM_TIME <system_time>   
}  
<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 ]   
  
<system_time> ::=  
{  
       AS OF <date_time>  
    |  FROM <start_date_time> TO <end_date_time>  
    |  BETWEEN <start_date_time> AND <end_date_time>  
    |  CONTAINED IN (<start_date_time> , <end_date_time>)   
    |  ALL  
}  
  
    <date_time>::=  
        <date_time_literal> | @date_time_variable  
  
    <start_date_time>::=  
        <date_time_literal> | @date_time_variable  
  
    <end_date_time>::=  
        <date_time_literal> | @date_time_variable  
  

-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
FROM { <table_source> [ ,...n ] }  
  
<table_source> ::=   
{  
    [ database_name . [ schema_name ] . | schema_name . ] table_or_view_name [ AS ] table_or_view_alias  
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ]  
    | <joined_table>  
}  
  
<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 ] [ <join hint> ] JOIN  
    | LEFT  [ OUTER ] JOIN  
    | RIGHT [ OUTER ] JOIN  
    | FULL  [ OUTER ] JOIN  
  
<join_hint> ::=   
    REDUCE  
    | REPLICATE  
    | REDISTRIBUTE  
  

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

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

nom_table_ou_vue
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 sous la forme base de données.* schema. nom_objet*.

Si la table ou la vue existe en dehors de l’instance de SQL Serverl, utilisez un nom en quatre parties sous la forme linked_server.* catalog. schema. objet*. Pour plus d’informations, consultez sp_addlinkedserver (Transact-SQL). Un nom en quatre parties qui est construit à l’aide de la OPENDATASOURCE fonctionne comme la partie serveur du nom peut également servir à spécifier la source de la table distante. Lorsque OPENDATASOURCE est spécifiée, database_name et nom_schéma ne peuvent pas s’appliquer à toutes les sources de données et est sujette aux capacités du fournisseur OLE DB qui accède à l’objet distant.

[EN] alias_de_table
Est un alias de table_source qui peut être utilisé soit par facilité 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, ensemble de lignes ou de fonction table ou clause d’opérateur (tels que PIVOT ou UNPIVOT) est utilisé, requis alias_de_table à la fin de la clause est le nom de la table associée pour toutes les colonnes, y compris les colonnes de regroupement retournées.

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

fonction_ensemble_de_lignes

S’applique aux: SQL Server 2008 via SQL Server 2016 et Base de données SQL.

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 la liste des fonctions rowset, voir 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

S’applique aux: SQL Server 2008 via SQL Server 2016 et Base de données SQL.

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 dans le fichier.

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

S’applique aux: SQL Server 2008 via SQL Server 2016 et Base de données SQL.

Fournit une vue de l'ensemble de lignes d'un document XML. Pour plus d’informations, consultez OPENXML (Transact-SQL).

table_dérivée
Sous-requête qui récupère les lignes de la base de données. table_dérivée est utilisé en tant qu’entrée à la requête externe.

dérivés _table pouvez utiliser la Transact-SQL fonctionnalité de constructeur de valeur de table 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 valeur 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.

nom_table_ou_vue FOR SYSTEM_TIME<system_time></system_time>

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

Spécifie qu’une version spécifique de données est retournée à partir de la table temporelle spécifiée et sa table d’historique avec version système lié

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

System_CAPS_ICON_note.jpg 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. Lorsque spécifié avec PERCENT, sample_number est implicitement converti en un float valeur ; sinon, il est converti en bigint. PERCENT est la valeur par défaut.

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

ROWS
Spécifie qu’environ sample_number de lignes seront récupérées. Lorsque ROWS est spécifié, SQL Server retourne une valeur approximative du nombre de lignes indiqué. Lorsque ROWS est spécifié, le sample_number expression doit correspondre à une valeur entière supérieure à zéro.

REPEATABLE
Indique que l'exemple sélectionné peut être retourné à nouveau. Lorsque spécifié avec le même repeat_seed valeur, SQL Server renvoie le même sous-ensemble de lignes tant qu’aucune modifications n’ont été apportées aux lignes de la table. Lorsque spécifié par une autre repeat_seed valeur, SQL Server sera retour 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 bigint. Si repeat_seed n’est pas spécifié, SQL Server affecte une valeur aléatoire. Pour un spécifique repeat_seed valeur, le résultat de l’échantillonnage est toujours le même si aucune modification n’ont été appliquées à la table. Le repeat_seed expression 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.

INTERNE
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>
Pour SQL Server et Base de données SQL, qui spécifie le SQL Server requête optimiseur 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 indicateurs de jointure (Transact-SQL).

Pour SQL Data Warehouse et Parallel Data Warehouse, ces indicateurs de jointure s’appliquent aux jointures INNER sur deux colonnes de distribution incompatible. Ils peuvent améliorer les performances en limitant la quantité de transfert de données qui se produit pendant le traitement des requêtes. Indicateurs de la jointure autorisée pour SQL Data Warehouse et Parallel Data Warehouse sont les suivantes :

RÉDUIRE
Réduit le nombre de lignes à déplacer sur le côté droit de la jointure de la table afin d’assurer la compatibilité de deux tables de distribution incompatible. L’indicateur de réduction est également appelée un indicateur semi join.

REPLICATE
Génère les valeurs dans la colonne de jointure de la table sur le côté gauche de la jointure soient répliquées sur tous les nœuds. La table de droite est jointe à la version de ces colonnes répliquée.

REDISTRIBUER
Sources de données force deux à distribuer sur les colonnes spécifiées dans la clause JOIN. Pour une table distribuée, Parallel Data Warehouse effectue un déplacement aléatoire. Pour une table répliquée, Parallel Data Warehouse effectue un déplacement trim. Pour comprendre ces déplacent les types, consultez la section « Opérations Plan DMS requête » dans la rubrique « Présentation des Plans requête » dans la Parallel Data Warehouse product documentation. Cet indicateur peut améliorer les performances lorsque le plan de requête utilise un déplacement de diffusion pour résoudre une jointure incompatible de distribution.

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.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 conditions de recherche et les prédicats, voir la 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 | APPLIQUER de OUTER} right_table_source
Spécifie que la right_table_source de l’appliquer l’opérateur est évalué par rapport à chaque ligne de la left_table_source. Cette fonctionnalité est utile lorsque le right_table_source contient une fonction table qui prend des valeurs de colonne à partir de la left_table_source 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 lors de la right_table_source est évalué par rapport à une ligne spécifique de la left_table_source et retourne un jeu de résultats vide.

Lorsque OUTER est spécifié, une ligne est générée pour chaque ligne de la left_table_source même lorsque les right_table_source évalue par rapport à cette ligne et renvoie un jeu de résultats vide.

Pour plus d'informations, consultez la section Notes.

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

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 croisé dynamique<pivot_clause></pivot_clause>
Spécifie que la table_source est croisé dynamiquement sur le pivot_column. table_source est une table ou une expression de table. La sortie est une table qui contient toutes les colonnes de la table_source à l’exception de la pivot_column et value_column. Les colonnes de la table_source, à l’exception de la pivot_column et value_column, sont appelées colonnes de regroupement de l’opérateur pivot. Pour plus d’informations sur les opérateurs PIVOT et UNPIVOT, consultez à l’aide de PIVOT et UNPIVOT.

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 le column_list qui s’affiche dans le pivot_column de la 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’il est utilisé avec UNPIVOT, value_column ne peut pas être le nom d’une colonne existante dans l’entrée table_source.

POUR 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 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 la table_source. Il ne peut pas être une colonne existante de table_source portant ce nom.

IN (column_list )
Dans la clause PIVOT, répertorie les valeurs dans le pivot_column qui deviennent les noms de colonne de la table de sortie. La liste ne peut pas spécifier des noms de colonnes qui existent déjà dans l’entrée table_source qui est croisé dynamiquement.

Dans la clause UNPIVOT, répertorie les colonnes de table_source qui doivent être réduites en un seul pivot_column.

alias_de_table
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 à partir de plusieurs colonnes dans column_list en une seule colonne appelée pivot_column. Pour plus d’informations sur les opérateurs PIVOT et UNPIVOT, consultez à l’aide de PIVOT et UNPIVOT.

AS OF <date_time>

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

Renvoie une table avec un seul enregistrement par ligne contenant les valeurs qui étaient réelles (actuelles) au moment dans le passé spécifié. En interne, une union est effectuée entre la table temporelle et sa table d’historique. Les résultats sont filtrés de manière à renvoyer les valeurs de la ligne qui était valide au moment spécifié par le paramètre <date_time>. La valeur d’une ligne est considérée comme valide si la valeur system_start_time_column_name est inférieure ou égale à celle du paramètre <date_time> et si la valeur system_end_time_column_name est supérieure à celle du paramètre <date_time>.

FROM <start_date_time> TO <end_date_time>

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

Retourne une table avec les valeurs pour toutes les versions d’enregistrement qui étaient actives au sein de la plage de temps spécifié, indépendamment de si elles démarré actif avant la * <start_date_time> * paramètre la valeur pour l’argument FROM ou cessé actif après la * <end_date_time> * valeur de paramètre pour l’argument à.</end_date_time></start_date_time> En interne, une union est effectuée entre la table temporelle et sa table d’historique. Les résultats sont filtrés de manière à renvoyer les valeurs de toutes les versions de ligne qui étaient actives à tout moment de l’intervalle spécifié. Les lignes qui est devenue actives exactement sur la limite inférieure définie par le point de terminaison FROM sont inclus et lignes est devenue actives exactement sur la limite supérieure définie par le point de terminaison TO ne sont pas inclus.

BETWEEN <start_date_time> AND <end_date_time>

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

Identique à celle ci-dessus dans le **FROM <start_date_time>à <end_date_time> ** description, mais il comprend des lignes qui est devenue actives sur la limite supérieure définie par le <end_date_time>point de terminaison.</end_date_time> </end_date_time> </start_date_time>

CONTAINED IN (<start_date_time> , <end_date_time>)

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

Renvoie une table avec les valeurs de toutes les versions d’enregistrement qui ont été ouvertes et fermées dans l’intervalle de temps spécifié défini par les deux valeurs datetime de l’argument CONTAINED IN. Les lignes qui sont devenues actives exactement sur la limite inférieure ou qui ont cessé d’être actives exactement sur la limite supérieure sont incluses.

ALL
Retourne une table avec les valeurs de toutes les lignes de la table actuelle et la table d’historique.

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.

Les opérandes de gauche et de droite de l'opérateur APPLY sont des expressions de table. La principale différence entre ces opérandes est que le right_table_source peut utiliser une fonction table qui prend une colonne à partir de la left_table_source comme l’un des arguments de la fonction. Le left_table_source peut inclure des fonctions table, mais il ne peut pas contenir d’arguments qui sont des colonnes de la 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. Prend la valeur right_table_source par rapport à chaque ligne de la left_table_source pour produire des ensembles de lignes.

    Les valeurs dans le right_table_source dépendent left_table_source. right_table_source peut être représenté approximativement de cette façon : TVF(left_table_source.row), où TVF est une fonction table.

  2. Combine les jeux de résultats est générés pour chaque ligne de la version d’évaluation de right_table_source avec la left_table_source en effectuant une opération UNION.

    La liste des colonnes produites par le résultat de l’opérateur APPLY est l’ensemble de colonnes à partir de la left_table_source qui est associé à la liste des colonnes à partir de la right_table_source.

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

  1. Effectue un GROUP BY sur son input_table contre le regroupement colonnes et génère une ligne de sortie pour chaque groupe.

    Les colonnes de regroupement dans la ligne de sortie obtiennent les valeurs de colonne correspondante pour ce groupe dans le 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 la clause GROUP BY à l’étape précédente par rapport à la pivot_column.

      Pour chaque colonne de sortie dans le column_list, en sélectionnant un sous-groupe qui satisfait la condition :

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

    2. aggregate_function est évalué par rapport à la value_column sur ce sous-groupe et son résultat est retourné en tant que la valeur correspondante output_column. Si le sous-groupe est vide, SQL Server génère une valeur null pour ce 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.

Pour plus d’informations sur les opérateurs PIVOT et UNPIVOT, y compris des exemples, consultez à l’aide de PIVOT et UNPIVOT.

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

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.

  
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.

  
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 dans la base de données AdventureWorks2012. Une liste de toutes les combinaisons possibles des BusinessEntityID lignes et tous les Department est retournée.

  
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 de la base de données AdventureWorks2012. 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.

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

  
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.

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

  
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.

System_CAPS_ICON_important.jpg Important


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.

  
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.

  
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.

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

M. À l’aide de l’instruction FOR SYSTEM_TIME

S’applique aux: SQL Server 2016 via SQL Server 2016 et Base de données SQL.

L’exemple suivant utilise l’argument de date_time_literal_or_variable pour SYSTEM_TIME AS OF pour retourner des lignes de table qui ont été réelle (actuel) à compter du 1er janvier 2014.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME AS OF '2014-01-01'  
WHERE ManagerID = 5  

L’exemple suivant utilise la pour SYSTEM_TIME de date_time_literal_or_variable à date_time_literal_or_variable argument renvoie toutes les lignes qui étaient actives pendant la période définie en tant qu’à compter du 1er janvier 2013 et se terminant par 1er janvier 2014, à l’exclusion de la limite supérieure.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME FROM '2013-01-01' TO '2014-01-01'  
WHERE ManagerID = 5  

L’exemple suivant utilise le date_time_literal_or_variable pour SYSTEM_TIME entre et argument date_time_literal_or_variable pour renvoyer toutes les lignes qui étaient actives pendant la période définie en tant qu’à compter du 1er janvier 2013 et se terminant par le 1er janvier 2014, y compris la limite supérieure.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME BETWEEN '2013-01-01' AND '2014-01-01'  
WHERE ManagerID = 5  

L’exemple suivant utilise le pour argument IN du contenu SYSTEM_TIME (date_time_literal_or_variable, date_time_literal_or_variable) pour renvoyer toutes les lignes qui ont été ouverts et fermés pendant la période définie en tant qu’à compter du 1er janvier 2013 et se terminant par le 1er janvier 2014.

SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME CONTAINED IN ( '2013-01-01', '2014-01-01' )  
WHERE ManagerID = 5  

L’exemple suivant utilise une variable et non un littéral pour fournir les valeurs de date limite pour la requête.

DECLARE @AsOfFrom datetime2 = dateadd(month,-12, sysutcdatetime())  
DECLARE @AsOfTo datetime2 = dateadd(month,-6, sysutcdatetime())  
  
SELECT DepartmentNumber,   
    DepartmentName,   
    ManagerID,   
    ParentDepartmentNumber   
FROM DEPARTMENT  
FOR SYSTEM_TIME FROM @AsOfFrom TO @AsOfTo  
WHERE ManagerID = 5  
  

N. Utilisation d'une clause FROM simple

L’exemple suivant récupère la SalesTerritoryID et SalesTerritoryRegion colonnes à partir de la DimSalesTerritory table.

-- Uses AdventureWorks  
  
SELECT SalesTerritoryKey, SalesTerritoryRegion  
FROM DimSalesTerritory  
ORDER BY SalesTerritoryKey;  

O. À l’aide de la syntaxe INNER JOIN

L’exemple suivant retourne le SalesOrderNumber, ProductKey, et EnglishProductName colonnes à partir de la FactInternetSales et DimProduct tables où la clé de jointure, ProductKey, correspond à deux tables. Le SalesOrderNumber et EnglishProductName colonnes chaque existent dans une des tables uniquement, il n’est pas nécessaire de spécifier l’alias de table avec ces colonnes, comme illustré ; ces alias sont inclus pour une meilleure lisibilité. Le mot AS avant un alias de nom n’est pas obligatoire, mais est recommandé pour une meilleure lisibilité et pour se conformer à la norme ANSI.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis INNER JOIN DimProduct AS dp  
ON dp.ProductKey = fis.ProductKey;  

Étant donné que le INNER mot clé n’est pas requis pour les jointures internes, cette même requête peut être écrite en tant que :

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales fis JOIN DimProduct dp  
ON dp.ProductKey = fis.ProductKey;  

Un WHERE clause peut également être utilisée avec cette requête pour limiter les résultats. Cet exemple limite les résultats à SalesOrderNumber valeurs supérieures à 'SO5000' :

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis JOIN DimProduct AS dp  
ON dp.ProductKey = fis.ProductKey  
WHERE fis.SalesOrderNumber > 'SO50000'  
ORDER BY fis.SalesOrderNumber;  

P. À l’aide de la syntaxe LEFT OUTER JOIN et RIGHT OUTER JOIN

L’exemple suivant joint les FactInternetSales et DimProduct les tables sur le ProductKey colonnes. La syntaxe de jointure externe gauche conserve les lignes sans correspondance de la gauche (FactInternetSales) table. Étant donné que la FactInternetSales table ne contient aucun ProductKey les valeurs qui ne correspondent pas à la DimProduct table, cette requête renvoie les mêmes lignes que le premier exemple de jointure interne ci-dessus.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM FactInternetSales AS fis LEFT OUTER JOIN DimProduct AS dp  
ON dp.ProductKey = fis.ProductKey;  

Cette requête peut aussi être écrite sans la OUTER (mot clé).

Dans les jointures externes droites, les lignes sans correspondance de la table de droite sont conservés. L’exemple suivant renvoie les mêmes lignes que dans l’exemple de jointure externe gauche ci-dessus.

-- Uses AdventureWorks  
  
SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
FROM DimProduct AS dp RIGHT OUTER JOIN FactInternetSales AS fis  
ON dp.ProductKey = fis.ProductKey;  

La requête suivante utilise le DimSalesTerritory table comme la table de gauche dans une jointure externe gauche. Il récupère le SalesOrderNumber des valeurs à partir de la FactInternetSales table. Si aucune commande en tant que SalesTerritoryKey, la requête doit retourner une valeur NULL pour le SalesOrderNumber pour cette ligne. Cette requête est classée par la SalesOrderNumber colonne, afin que les valeurs NULL dans cette colonne s’affiche en haut des résultats.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst LEFT OUTER JOIN FactInternetSales AS fis  
ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Cette requête pourrait être réécrit avec une jointure externe droite pour extraire les mêmes résultats :

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM FactInternetSales AS fis RIGHT OUTER JOIN DimSalesTerritory AS dst  
ON fis.SalesTerritoryKey = dst.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Q. À l’aide de la syntaxe FULL OUTER JOIN

L’exemple suivant illustre une jointure externe complète, qui renvoie toutes les lignes des deux tables jointes, mais retourne la valeur NULL pour les valeurs qui ne correspondent pas à partir de l’autre table.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst FULL OUTER JOIN FactInternetSales AS fis  
ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

Cette requête peut aussi être écrite sans la OUTER (mot clé).

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, dst.SalesTerritoryRegion, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst FULL JOIN FactInternetSales AS fis  
ON dst.SalesTerritoryKey = fis.SalesTerritoryKey  
ORDER BY fis.SalesOrderNumber;  

R. À l’aide de la syntaxe CROSS JOIN

L’exemple suivant retourne le produit croisé de la FactInternetSales et DimSalesTerritory les tables. Une liste de toutes les combinaisons possibles des SalesOrderNumber et SalesTerritoryKey sont retournées. Notez l’absence de la ON clause dans la requête de jointure croisée.

-- Uses AdventureWorks  
  
SELECT dst.SalesTerritoryKey, fis.SalesOrderNumber  
FROM DimSalesTerritory AS dst CROSS JOIN FactInternetSales AS fis  
ORDER BY fis.SalesOrderNumber;  

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

L’exemple suivant utilise une table dérivée (un SELECT instruction après le FROM clause) pour retourner le CustomerKey et LastName colonnes de tous les clients dans le DimCustomer table avec BirthDate valeurs au plus tard le 1er janvier 1970 et le dernier nom de « Smith ».

-- Uses AdventureWorks  
  
SELECT CustomerKey, LastName  
FROM  
   (SELECT * FROM DimCustomer  
    WHERE BirthDate > '01/01/1970') AS DimCustomerDerivedTable  
WHERE LastName = 'Smith'  
ORDER BY LastName;  

T. RÉDUIRE l’exemple d’indicateur de jointure

L’exemple suivant utilise le REDUCE indicateur de jointure à modifier le traitement de la table dérivée dans la requête. Lors de l’utilisation la REDUCE indicateur de jointure dans cette requête, le fis.ProductKey est projetée, répliquées et apportées distinctes et ensuite jointe à DimProduct lors de la lecture aléatoire de DimProduct sur ProductKey. La table dérivée qui en résulte est distribuée sur fis.ProductKey.

-- Uses AdventureWorks  
  
EXPLAIN SELECT SalesOrderNumber  
FROM  
   (SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
    FROM DimProduct AS dp   
      INNER REDUCE JOIN FactInternetSales AS fis   
      ON dp.ProductKey = fis.ProductKey  
   ) AS dTable  
ORDER BY SalesOrderNumber;  

U. Exemple d’indicateur de jointure RÉPLIQUÉ

L’exemple suivant illustre la même requête que l’exemple précédent, à ceci près qu’un REPLICATE indicateur de jointure est utilisée au lieu du REDUCE indicateur de jointure. Utiliser le REPLICATE indicateur provoque les valeurs dans le ProductKey colonne (jointure) à partir de la FactInternetSales table soient répliquées sur tous les nœuds. Le DimProduct table est jointe à la version dupliquée de ces valeurs.

-- Uses AdventureWorks  
  
EXPLAIN SELECT SalesOrderNumber  
FROM  
   (SELECT fis.SalesOrderNumber, dp.ProductKey, dp.EnglishProductName  
    FROM DimProduct AS dp   
      INNER REPLICATE JOIN FactInternetSales AS fis  
      ON dp.ProductKey = fis.ProductKey  
   ) AS dTable  
ORDER BY SalesOrderNumber;  

V. À l’aide de l’indicateur REDISTRIBUTE afin de garantir un déplacement aléatoire pour une jointure incompatible de distribution

La requête suivante utilise l’indicateur de requête redistribuer sur une jointure incompatible de distribution. Cela garantit que l’optimiseur de requête utilise un déplacement aléatoire dans le plan de requête. Cela garantit également que le plan de requête n’utilise pas un déplacement de diffusion qui déplace une table distribuée à une table répliquée.

Dans l’exemple suivant, l’indicateur REDISTRIBUTE force un déplacement aléatoire sur la table FactInternetSales car ProductKey est la colonne de distribution pour DimProduct et n’est pas la colonne de distribution de FactInternetSales.

-- Uses AdventureWorks  
  
EXPLAIN  
SELECT dp.ProductKey, fis.SalesOrderNumber, fis.TotalProductCost  
FROM DimProduct dp INNER REDISTRIBUTE JOIN FactInternetSales fis  
ON dp.ProductKey = fis.ProductKey;  

CONTAINSTABLE (Transact-SQL)
DELETE (Transact-SQL)
FREETEXTTABLE (Transact-SQL)
INSERT (Transact-SQL)
OPENQUERY (Transact-SQL)
OPENROWSET (Transact-SQL)
Opérateurs (Transact-SQL)
Mise à jour (Transact-SQL)
OÙ (Transact-SQL)

Ajouts de la communauté

AJOUTER
Afficher: