EXECUTE (Transact-SQL)EXECUTE (Transact-SQL)

CETTE RUBRIQUE S’APPLIQUE À :ouiSQL Server (à partir de la version 2008)ouiAzure SQL DatabaseouiAzure SQL Data Warehouse ouiParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2008)yesAzure SQL DatabaseyesAzure SQL Data Warehouse yesParallel Data Warehouse

Exécute une chaîne de commande ou une chaîne de caractères dans un Transact-SQLTransact-SQL lot ou l’un des modules suivants : système stockées procédure, procédure stockée définie par l’utilisateur, procédure stockée CLR, fonction définie par l’utilisateur scalaire ou de la procédure stockée étendue.Executes a command string or character string within a Transact-SQLTransact-SQL batch, or one of the following modules: system stored procedure, user-defined stored procedure, CLR stored procedure, scalar-valued user-defined function, or extended stored procedure. L'instruction EXECUTE peut être utilisée pour envoyer des commandes directes à des serveurs liés.The EXECUTE statement can be used to send pass-through commands to linked servers. De plus, il est possible de définir explicitement le contexte dans lequel une chaîne de caractères ou une commande s'exécute.Additionally, the context in which a string or command is executed can be explicitly set. Les métadonnées pour le jeu de résultats peuvent être définies à l'aide des options WITH RESULT SETS.Metadata for the result set can be defined by using the WITH RESULT SETS options.

Important

Avant d'appeler EXECUTE avec une chaîne de caractères, validez cette dernière.Before you call EXECUTE with a character string, validate the character string. N'exécutez jamais une commande construite par une entrée utilisateur qui n'a pas été validée.Never execute a command constructed from user input that has not been validated.

Icône de lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

-- Syntax for SQL Server  

Execute a stored procedure or function  
[ { EXEC | EXECUTE } ]  
    {   
      [ @return_status = ]  
      { module_name [ ;number ] | @module_name_var }   
        [ [ @parameter = ] { value   
                           | @variable [ OUTPUT ]   
                           | [ DEFAULT ]   
                           }  
        ]  
      [ ,...n ]  
      [ WITH <execute_option> [ ,...n ] ]  
    }  
[;]  

Execute a character string  
{ EXEC | EXECUTE }   
    ( { @string_variable | [ N ]'tsql_string' } [ + ...n ] )  
    [ AS { LOGIN | USER } = ' name ' ]  
[;]  

Execute a pass-through command against a linked server  
{ EXEC | EXECUTE }  
    ( { @string_variable | [ N ] 'command_string [ ? ]' } [ + ...n ]  
        [ { , { value | @variable [ OUTPUT ] } } [ ...n ] ]  
    )   
    [ AS { LOGIN | USER } = ' name ' ]  
    [ AT linked_server_name ]  
[;]  

<execute_option>::=  
{  
        RECOMPILE   
    | { RESULT SETS UNDEFINED }   
    | { RESULT SETS NONE }   
    | { RESULT SETS ( <result_sets_definition> [,...n ] ) }  
}   

<result_sets_definition> ::=   
{  
    (  
         { column_name   
           data_type   
         [ COLLATE collation_name ]   
         [ NULL | NOT NULL ] }  
         [,...n ]  
    )  
    | AS OBJECT   
        [ db_name . [ schema_name ] . | schema_name . ]   
        {table_name | view_name | table_valued_function_name }  
    | AS TYPE [ schema_name.]table_type_name  
    | AS FOR XML   
}  
-- In-Memory OLTP   

Execute a natively compiled, scalar user-defined function  
[ { EXEC | EXECUTE } ]   
    {   
      [ @return_status = ]   
      { module_name | @module_name_var }   
        [ [ @parameter = ] { value   
                           | @variable   
                           | [ DEFAULT ]   
                           }  
        ]   
      [ ,...n ]   
      [ WITH <execute_option> [ ,...n ] ]   
    }  
<execute_option>::=  
{  
    | { RESULT SETS UNDEFINED }   
    | { RESULT SETS NONE }   
    | { RESULT SETS ( <result_sets_definition> [,...n ] ) }  
}  
-- Syntax for Azure SQL Database   

Execute a stored procedure or function  
[ { EXEC | EXECUTE } ]  
    {   
      [ @return_status = ]  
      { module_name  | @module_name_var }   
        [ [ @parameter = ] { value   
                           | @variable [ OUTPUT ]   
                           | [ DEFAULT ]   
                           }  
        ]  
      [ ,...n ]  
      [ WITH RECOMPILE ]  
    }  
[;]  

Execute a character string  
{ EXEC | EXECUTE }   
    ( { @string_variable | [ N ]'tsql_string' } [ + ...n ] )  
    [ AS {  USER } = ' name ' ]  
[;]  

<execute_option>::=  
{  
        RECOMPILE   
    | { RESULT SETS UNDEFINED }   
    | { RESULT SETS NONE }   
    | { RESULT SETS ( <result_sets_definition> [,...n ] ) }  
}   

<result_sets_definition> ::=   
{  
    (  
         { column_name   
           data_type   
         [ COLLATE collation_name ]   
         [ NULL | NOT NULL ] }  
         [,...n ]  
    )  
    | AS OBJECT   
        [ db_name . [ schema_name ] . | schema_name . ]   
        {table_name | view_name | table_valued_function_name }  
    | AS TYPE [ schema_name.]table_type_name  
    | AS FOR XML  
-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  

-- Execute a stored procedure  
[ { EXEC | EXECUTE } ]  
    procedure_name   
        [ { value | @variable [ OUT | OUTPUT ] } ] [ ,...n ] }  
[;]  

-- Execute a SQL string  
{ EXEC | EXECUTE }  
    ( { @string_variable | [ N ] 'tsql_string' } [ +...n ] )  
[;]  

ArgumentsArguments

@état_de_retour@return_status
Variable facultative de type entier qui stocke l'état du résultat d'un module.Is an optional integer variable that stores the return status of a module. Cette variable doit être déclarée dans le traitement, la procédure stockée ou la fonction avant d'être utilisée dans une instruction EXECUTE.This variable must be declared in the batch, stored procedure, or function before it is used in an EXECUTE statement.

Lorsqu’il est utilisé pour appeler une fonction de défini par l’utilisateur scalaire, le @état_de_retour variable peut être de n’importe quel type de données scalaire.When used to invoke a scalar-valued user-defined function, the @return_status variable can be of any scalar data type.

nom_modulemodule_name
Nom complet ou partiel de la procédure stockée ou de la fonction scalaire définie par l'utilisateur à appeler.Is the fully qualified or nonfully qualified name of the stored procedure or scalar-valued user-defined function to call. Les noms de module doivent respecter les règles de identificateurs.Module names must comply with the rules for identifiers. Les noms des procédures stockées étendues distinguent toujours les majuscules et les minuscules, quel que soit le classement du serveur.The names of extended stored procedures are always case-sensitive, regardless of the collation of the server.

Un module créé dans une autre base de données peut être exécuté si l'utilisateur est propriétaire du module ou possède l'autorisation nécessaire pour l'exécuter dans la base de données en question.A module that has been created in another database can be executed if the user running the module owns the module or has the appropriate permission to execute it in that database. Un module peut être exécuté sur un autre serveur SQL ServerSQL Server si l'utilisateur qui l'exécute a l'autorisation nécessaire pour utiliser ce serveur (accès à distance) et pour exécuter le module dans la base de données.A module can be executed on another server running SQL ServerSQL Server if the user running the module has the appropriate permission to use that server (remote access) and to execute the module in that database. Si le nom d'un serveur est spécifié mais qu'aucun nom de base de données n'est spécifié, le Moteur de base de données SQL ServerSQL Server Database Engine recherche le module dans la base de données par défaut de l'utilisateur.If a server name is specified but no database name is specified, the Moteur de base de données SQL ServerSQL Server Database Engine looks for the module in the default database of the user.

; nombre;number
S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

Entier facultatif qui regroupe les procédures de même nom.Is an optional integer that is used to group procedures of the same name. Ce paramètre n'est pas utilisé pour les procédures stockées étendues.This parameter is not used for extended stored procedures.

Note

Cette fonctionnalité sera supprimée dans une prochaine version de Microsoft SQL Server.This feature will be removed in a future version of Microsoft SQL Server. Évitez d'utiliser cette fonctionnalité dans de nouveaux travaux de développement, et prévoyez de modifier les applications qui utilisent actuellement cette fonctionnalité.Avoid using this feature in new development work, and plan to modify applications that currently use this feature.

Pour plus d’informations sur les groupes de procédures, consultez CREATE PROCEDURE ( Transact-SQL ) .For more information about procedure groups, see CREATE PROCEDURE (Transact-SQL).

@module_name_var@module_name_var
Nom d'une variable définie localement qui représente le nom d'un module.Is the name of a locally defined variable that represents a module name.

Cela peut être une variable qui conserve le nom d’une fonction définie par l’utilisateur compilée en mode natif, scalaire.This can be a variable that holds the name of a natively compiled, scalar user-defined function.

@paramètre@parameter
Paramètre de nom_module, comme défini dans le module.Is the parameter for module_name, as defined in the module. Les noms des paramètres doivent être précédés du symbole (@).Parameter names must be preceded by the at sign (@). Lorsqu’il est utilisé avec le @nom_paramètre=valeur formulaire, les noms de paramètres et les constantes n’ont pas de les fournir dans l’ordre dans lequel ils sont définis dans le module.When used with the @parameter_name=value form, parameter names and constants do not have to be supplied in the order in which they are defined in the module. Toutefois, si le @nom_paramètre=valeur formulaire est utilisé pour n’importe quel paramètre, il doit être utilisé pour tous les paramètres suivants.However, if the @parameter_name=value form is used for any parameter, it must be used for all subsequent parameters.

Par défaut, les paramètres acceptent les valeurs NULL.By default, parameters are nullable.

valeurvalue
Valeur du paramètre à passer au module ou à la commande directe.Is the value of the parameter to pass to the module or pass-through command. Si les noms des paramètres ne sont pas spécifiés, les valeurs des paramètres doivent être fournies dans l'ordre défini dans le module.If parameter names are not specified, parameter values must be supplied in the order defined in the module.

Lors de l'exécution de commandes directes sur des serveurs liés, l'ordre des valeurs des paramètres dépend du fournisseur OLE DB du serveur lié.When executing pass-through commands against linked servers, the order of the parameter values depends on the OLE DB provider of the linked server. La plupart des fournisseurs OLE DB lient les valeurs aux paramètres de gauche à droite.Most OLE DB providers bind values to parameters from left to right.

Si la valeur d'un paramètre est le nom d'un objet, une chaîne de caractères, ou si elle est déterminée par le nom d'une base de données ou d'un schéma, le nom complet doit être placé entre guillemets simples.If the value of a parameter is an object name, character string, or qualified by a database name or schema name, the whole name must be enclosed in single quotation marks. Si la valeur d'un paramètre est un mot clé, ce mot clé doit être mis entre guillemets doubles.If the value of a parameter is a keyword, the keyword must be enclosed in double quotation marks.

Si une valeur par défaut est définie dans le module, l'utilisateur peut exécuter le module sans spécifier de paramètre.If a default is defined in the module, a user can execute the module without specifying a parameter.

La valeur par défaut peut également être NULL.The default can also be NULL. La définition du module indique généralement l'action à réaliser si la valeur d'un paramètre est NULL.Generally, the module definition specifies the action that should be taken if a parameter value is NULL.

@variable@variable
Variable qui stocke un paramètre ou un paramètre de retour.Is the variable that stores a parameter or a return parameter.

OUTPUTOUTPUT
Spécifie que le module ou la chaîne de commandes renvoie un paramètre.Specifies that the module or command string returns a parameter. Le paramètre correspondant dans le module ou la chaîne de commandes doit également avoir été créé à l'aide du mot clé OUTPUT.The matching parameter in the module or command string must also have been created by using the keyword OUTPUT. Utilisez ce mot clé lorsque vous utilisez des variables de curseur comme paramètres.Use this keyword when you use cursor variables as parameters.

Si valeur est défini en tant que sortie d’un module exécuté sur un serveur lié, toute modification apportée aux correspondantsparamètre effectuée par OLE DB fournisseur doivent être copié dans la variable à la fin de l’exécution du module.If value is defined as OUTPUT of a module executed against a linked server, any changes to the corresponding @parameter performed by the OLE DB provider will be copied back to the variable at the end of the execution of module.

Si des paramètres OUTPUT sont utilisés et l’objectif est d’utiliser les valeurs de retournés dans d’autres instructions à l’intérieur du module ou un lot d’appel, la valeur du paramètre doit être passée en tant que variable, telles queparamètre = @variable.If OUTPUT parameters are being used and the intent is to use the return values in other statements within the calling batch or module, the value of the parameter must be passed as a variable, such as @parameter = @variable. Vous ne pouvez pas exécuter un module en spécifiant OUTPUT pour un paramètre qui n'est pas défini comme paramètre OUTPUT dans le module.You cannot execute a module by specifying OUTPUT for a parameter that is not defined as an OUTPUT parameter in the module. Il est impossible de passer des constantes à un module en utilisant OUTPUT ; le paramètre de retour nécessite le nom d'une variable.Constants cannot be passed to module by using OUTPUT; the return parameter requires a variable name. Le type de données de la variable doit être déclaré et une valeur doit être affectée avant d'exécuter la procédure.The data type of the variable must be declared and a value assigned before executing the procedure.

Lorsque l'instruction EXECUTE est utilisée sur une procédure stockée distante ou pour exécuter une commande directe sur un serveur lié, les paramètres OUTPUT ne peuvent pas avoir l'un des types de données des objets LOB.When EXECUTE is used against a remote stored procedure, or to execute a pass-through command against a linked server, OUTPUT parameters cannot be any one of the large object (LOB) data types.

Les paramètres de retour peuvent être de n'importe quel type, à l'exception des types LOB.Return parameters can be of any data type except the LOB data types.

DEFAULTDEFAULT
Fournit la valeur par défaut du paramètre telle qu'elle est définie dans le module.Supplies the default value of the parameter as defined in the module. Une erreur se produit quand le module attend une valeur pour un paramètre qui n'a pas de valeur définie par défaut et qu'un paramètre est manquant ou que le mot clé DEFAULT est spécifié.When the module expects a value for a parameter that does not have a defined default and either a parameter is missing or the DEFAULT keyword is specified, an error occurs.

@string_variable@string_variable
Nom d'une variable locale.Is the name of a local variable. @string_variable peut être char, varchar, nchar, ou nvarchar type de données. @string_variable can be any char, varchar, nchar, or nvarchar data type. Celles-ci incluent la (max) des types de données.These include the (max) data types.

[N] 'tsql_string'[N] 'tsql_string'
Chaîne constante.Is a constant string. tsql_string peut être nvarchar ou varchar type de données.tsql_string can be any nvarchar or varchar data type. Si N est inclus, la chaîne est interprétée en tant que nvarchar type de données.If the N is included, the string is interpreted as nvarchar data type.

En tant que <context_specification >AS <context_specification>
Spécifie le contexte dans lequel l'instruction est exécutée.Specifies the context in which the statement is executed.

ConnexionLOGIN
S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

Spécifie que le contexte dont l'identité doit être empruntée est une connexion.Specifies the context to be impersonated is a login. L'étendue de l'emprunt d'identité est le serveur.The scope of impersonation is the server.

UtilisateurUSER
Spécifie que le contexte dont l'identité doit être empruntée est un utilisateur de la base de données active.Specifies the context to be impersonated is a user in the current database. L'étendue de l'emprunt d'identité est limitée à la base de données active.The scope of impersonation is restricted to the current database. Le changement de contexte vers un utilisateur de base de données n'hérite pas des autorisations de cet utilisateur au niveau serveur.A context switch to a database user does not inherit the server-level permissions of that user.

Important

Lorsque le changement de contexte vers l'utilisateur de base de données est actif, toute tentative d'accès aux ressources en dehors de la base de données entraîne l'échec de l'instruction.While the context switch to the database user is active, any attempt to access resources outside the database will cause the statement to fail. Cela inclut l’utilisation base de données , les requêtes distribuées, requêtes et instructions qui font référence à une autre base de données à l’aide d’identificateurs de trois ou quatre parties.This includes USE database statements, distributed queries, and queries that reference another database by using three- or four-part identifiers.

'nom''name'
Nom d'utilisateur ou de connexion valide.Is a valid user or login name. nom doit être membre du rôle serveur fixe sysadmin ou exister en tant que principal dans sys.database_principals ou sys.server_principals, respectivement.name must be a member of the sysadmin fixed server role or exist as a principal in sys.database_principals or sys.server_principals, respectively.

nom ne peut pas être un compte intégré, tel que NT AUTHORITY\LocalService, NT AUTHORITY\NetworkService ou NT AUTHORITY\LocalSystem.name cannot be a built-in account, such as NT AUTHORITY\LocalService, NT AUTHORITY\NetworkService, or NT AUTHORITY\LocalSystem.

Pour plus d’informations, consultez spécifiant un utilisateur ou un nom de connexion plus loin dans cette rubrique.For more information, see Specifying a User or Login Name later in this topic.

[N] 'chaîne_de_commande'[N] 'command_string'
Chaîne constante qui contient la commande à passer via le serveur lié.Is a constant string that contains the command to be passed through to the linked server. Si N est inclus, la chaîne est interprétée en tant que nvarchar type de données.If the N is included, the string is interpreted as nvarchar data type.

[?][?]
Indique les paramètres dont les valeurs sont fournies dans le <arg-list > de commandes directes qui sont utilisés dans un EXEC('...', <arg-list>) à <linkedsrv > instruction.Indicates parameters for which values are supplied in the <arg-list> of pass-through commands that are used in an EXEC('…', <arg-list>) AT <linkedsrv> statement.

À linked_server_nameAT linked_server_name
S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

Spécifie que chaîne_de_commande est exécutée sur linked_server_name et, le cas échéant, sont renvoyés au client.Specifies that command_string is executed against linked_server_name and results, if any, are returned to the client. linked_server_name doit faire référence à une définition de serveur lié existante sur le serveur local.linked_server_name must refer to an existing linked server definition in the local server. Serveurs liés sont définis à l’aide de sp_addlinkedserver.Linked servers are defined by using sp_addlinkedserver.

AVEC <execute_option >WITH <execute_option>
Options d'exécution possibles.Possible execute options. Les options RESULT SETS ne peuvent pas être spécifiées dans une instruction INSERT… EXEC.The RESULT SETS options cannot be specified in an INSERT…EXEC statement.

TermeTerm DéfinitionDefinition
RECOMPILERECOMPILE Impose la compilation, l'utilisation et la suppression d'un nouveau plan après l'exécution du module.Forces a new plan to be compiled, used, and discarded after the module is executed. S'il existe un plan de requêtes pour le module, ce plan reste en mémoire cache.If there is an existing query plan for the module, this plan remains in the cache.

Utilisez cette option si le paramètre que vous fournissez est atypique ou si les données ont changé de manière significative.Use this option if the parameter you are supplying is atypical or if the data has significantly changed. Cette option n'est pas utilisée pour les procédures stockées étendues.This option is not used for extended stored procedures. Nous recommandons d'utiliser cette option modérément car elle est coûteuse.We recommend that you use this option sparingly because it is expensive.

Remarque : ne pourrez pas utiliser WITH RECOMPILE lorsque vous appelez une procédure stockée qui utilise la syntaxe OPENDATASOURCE.Note: You can not use WITH RECOMPILE when calling a stored procedure that uses OPENDATASOURCE syntax. L'option WITH RECOMPILE est ignorée lorsqu'un nom d'objet en quatre parties est spécifié.The WITH RECOMPILE option is ignored when a four-part object name is specified.

Remarque : RECOMPILE n’est pas pris en charge avec les fonctions définies par l’utilisateur scalaires compilées en mode natif.Note: RECOMPILE is not supported with natively compiled, scalar user-defined functions. Si vous devez recompiler, utilisez sp_recompile ( Transact-SQL ) .If you need to recompile, use sp_recompile (Transact-SQL).
JEUX DE RÉSULTATS NON DÉFINISRESULT SETS UNDEFINED S’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.

Cette option ne fournit aucune garantie quant aux résultats retournés, le cas échéant, et aucune définition n'est fournie.This option provides no guarantee of what results, if any, will be returned, and no definition is provided. L'instruction s'exécute sans erreur si des résultats sont retournés ou aucun résultat n'est retourné.The statement executes without error if any results are returned or no results are returned. RESULT SETS UNDEFINED correspond au comportement par défaut si aucun result_sets_option n'est fourni.RESULT SETS UNDEFINED is the default behavior if a result_sets_option is not provided.

Pour interpréter les fonctions scalaires définies par l’utilisateur et les fonctions scalaires définies par l’utilisateur compilées en mode natif, cette option n’est pas opérationnelle, car les fonctions retournent jamais un jeu de résultats.For interpreted scalar user-defined functions, and natively compiled scalar user-defined functions, this option is not operational because the functions never return a result set.
RESULT SETS NONERESULT SETS NONE S’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.

Garantit que l'instruction d'exécution ne retournera pas de résultats.Guarantees that the execute statement will not return any results. Si des résultats sont retournés, le traitement est abandonné.If any results are returned the batch is aborted.

Pour interpréter les fonctions scalaires définies par l’utilisateur et les fonctions scalaires définies par l’utilisateur compilées en mode natif, cette option n’est pas opérationnelle, car les fonctions retournent jamais un jeu de résultats.For interpreted scalar user-defined functions, and natively compiled scalar user-defined functions, this option is not operational because the functions never return a result set.
<result_sets_definition ><result_sets_definition> S’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.Applies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database.

Offre une garantie selon laquelle le résultat reviendra comme spécifié dans result_sets_definition.Provides a guarantee that the result will come back as specified in the result_sets_definition. Pour les instructions qui retournent plusieurs jeux de résultats, fournissez plusieurs result_sets_definition sections.For statements that return multiple result sets, provide multiple result_sets_definition sections. Placez chaque result_sets_definition entre parenthèses, séparées par des virgules.Enclose each result_sets_definition in parentheses, separated by commas. Pour plus d’informations, consultez <result_sets_definition > plus loin dans cette rubrique.For more information, see <result_sets_definition> later in this topic.

Cette option est toujours génère une erreur pour les fonctions définies par l’utilisateur scalaires compilées en mode natif, car les fonctions retournent jamais un jeu de résultats.This option always results in an error for natively compiled, scalar user-defined functions because the functions never return a result set.

<result_sets_definition > s’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database<result_sets_definition> Applies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database

Décrit les jeux de résultats retournés par les instructions exécutées.Describes the result sets returned by the executed statements. Les clauses de result_sets_definition ont la signification suivanteThe clauses of the result_sets_definition have the following meaning

TermeTerm DéfinitionDefinition
{{

column_namecolumn_name

data_typedata_type

[ COLLATE collation_name][ COLLATE collation_name]

[NULL | NON NULL][NULL | NOT NULL]

}}
Consultez le tableau ci-dessous.See the table below.
db_namedb_name Nom de la base de données contenant la table, la vue ou la fonction table.The name of the database containing the table, view or table valued function.
schema_nameschema_name Nom du schéma propriétaire de la table, de la vue ou de la fonction table.The name of the schema owning the table, view or table valued function.
table_name | view_name | table_valued_function_nametable_name | view_name | table_valued_function_name Spécifie que les colonnes retournées seront celles spécifiées dans la table, la vue ou la fonction table nommée.Specifies that the columns returned will be those specified in the table, view or table valued function named. Les variables de table, les tables temporaires et les synonymes ne sont pas pris en charge dans la syntaxe d'objet d'AS.Table variables, temporary tables, and synonyms are not supported in the AS object syntax.
AS TYPE [schema_name.]table_type_nameAS TYPE [schema_name.]table_type_name Spécifie que les colonnes retournées seront celles spécifiées dans le type de table.Specifies that the columns returned will be those specified in the table type.
AS FOR XMLAS FOR XML Spécifie que les résultats XML de l'instruction, ou de la procédure stockée appelée par l'instruction EXECUTE, sont convertis dans le même format que s'ils avaient été produits par une instruction SELECT …Specifies that the XML results from the statement or stored procedure called by the EXECUTE statement will be converted into the format as though they were produced by a SELECT … FOR XML …FOR XML … .statement. Tous les formats des directives de type dans l'instruction d'origine sont supprimés, et les résultats retournés sont les mêmes que si aucune directive de type n'avait été spécifiée.All formatting from the type directives in the original statement are removed, and the results returned are as though no type directive was specified. AS FOR XML ne convertit pas les résultats tabulaires non XML de l'instruction ou de la procédure stockée exécutée en XML.AS FOR XML does not convert non-XML tabular results from the executed statement or stored procedure into XML.
TermeTerm DéfinitionDefinition
column_namecolumn_name Nom de chaque colonne.The names of each column. Si le nombre de colonnes diffère du jeu de résultats, une erreur se produit et le lot est abandonné.If the number of columns differs from the result set, an error occurs and the batch is aborted. Si le nom d'une colonne diffère du jeu de résultats, le nom de colonne retourné correspondra au nom défini.If the name of a column differs from the result set, the column name returned will be set to the name defined.
data_typedata_type Types de données de chaque colonne.The data types of each column. Si les types de données diffèrent, une conversion implicite vers le type de données défini est effectuée.If the data types differ, an implicit conversion to the defined data type is performed. Si la conversion échoue, le lot est abandonnéIf the conversion fails the batch is aborted
COLLATE collation_nameCOLLATE collation_name Classement de chaque colonne.The collation of each column. En cas d'incompatibilité de classement, un classement implicite est tenté.If there is a collation mismatch, an implicit collation is attempted. Si cette opération échoue, le lot est abandonné.If that fails, the batch is aborted.
NULL | NON NULLNULL | NOT NULL Valeur Null possible dans chaque colonne.The nullability of each column. Si la possibilité de valeur NULL définie est NOT NULL et que les données retournées contiennent des valeurs NULL, une erreur a lieu et le lot est abandonné.If the defined nullability is NOT NULL and the data returned contains NULLs an error occurs and the batch is aborted. En l'absence de spécification, la valeur par défaut se conforme au paramètre des options ANSI_NULL_DFLT_ON et ANSI_NULL_DFLT_OFF.If not specified, the default value conforms to the setting of the ANSI_NULL_DFLT_ON and ANSI_NULL_DFLT_OFF options.

Le jeu de résultats réel qui est retourné pendant l'exécution peut différer du résultat défini à l'aide de la clause WITH RESULT SETS de l'une des manières suivantes : nombre de jeux de résultats, nombre de colonnes, nom de colonne, possibilité de valeur NULL et type de données.The actual result set being returned during execution can differ from the result defined using the WITH RESULT SETS clause in one of the following ways: number of result sets, number of columns, column name, nullability, and data type. Si le nombre de jeu de résultats diffère, une erreur se produit et le lot est abandonné.If the number of result sets differs, an error occurs and the batch is aborted.

NotesRemarks

Paramètres peuvent être fournis à l’aide valeur ou à l’aide denom_paramètre=valeur.Parameters can be supplied either by using value or by using @parameter_name=value. Un paramètre ne fait pas partie d’une transaction. Ainsi, si vous modifiez l’un d’eux dans une transaction et que vous restaurez cette dernière par la suite, le paramètre ne reprend pas sa valeur initiale.A parameter is not part of a transaction; therefore, if a parameter is changed in a transaction that is later rolled back, the value of the parameter does not revert to its previous value. La valeur renvoyée à l'appelant est toujours la valeur au moment du renvoie du module.The value returned to the caller is always the value at the time the module returns.

L'imbrication a lieu lorsqu'un module en appelle un autre ou exécute du code managé en faisant référence à un module CLR (Common Language Runtime), un type défini par l'utilisateur ou un agrégat.Nesting occurs when one module calls another or executes managed code by referencing a common language runtime (CLR) module, user-defined type, or aggregate. Le niveau d'imbrication augmente au début de l'exécution du module appelé ou de la référence au code managé ; il diminue à la fin de l'exécution du module appelé ou de la référence au code managé.The nesting level is incremented when the called module or managed code reference starts execution, and it is decremented when the called module or managed code reference has finished. Au-delà de 32 niveaux d'imbrication, l'ensemble de la chaîne d'appel échoue.Exceeding the maximum of 32 nesting levels causes the complete calling chain to fail. Le niveau d’imbrication actuel est stocké dans le @@NESTLEVEL fonction système.The current nesting level is stored in the @@NESTLEVEL system function.

Les procédures stockées distantes et les procédures stockées étendues n'étant pas incluses dans l'étendue d'une transaction (à moins qu'elles proviennent d'une instruction BEGIN DISTRIBUTED TRANSACTION ou qu'elles soient utilisées avec des options de configuration diverses), il est impossible d'annuler les commandes exécutées par l'appel de ces procédures.Because remote stored procedures and extended stored procedures are not within the scope of a transaction (unless issued within a BEGIN DISTRIBUTED TRANSACTION statement or when used with various configuration options), commands executed through calls to them cannot be rolled back. Pour plus d’informations, consultez procédures stockées système ( Transact-SQL ) et BEGIN DISTRIBUTED TRANSACTION ( Transact-SQL ) .For more information, see System Stored Procedures (Transact-SQL) and BEGIN DISTRIBUTED TRANSACTION (Transact-SQL).

Lorsque vous utilisez des variables de curseur, une erreur se produit si vous exécutez une procédure qui passe une variable de curseur avec un curseur qui lui est alloué.When you use cursor variables, if you execute a procedure that passes in a cursor variable with a cursor allocated to it an error occurs.

Il n'est pas nécessaire de spécifier le mot clé EXECUTE lorsque vous exécutez des modules si l'instruction est la première d'un lot.You do not have to specify the EXECUTE keyword when executing modules if the statement is the first one in a batch.

Pour plus d'informations spécifiques aux procédures stockées CLR, consultez Procédures stockées CLR.For additional information specific to CLR stored procedures, see CLR Stored Procedures.

Utilisation de l'instruction EXECUTE avec des procédures stockéesUsing EXECUTE with Stored Procedures

Il n'est pas nécessaire de spécifier le mot clé EXECUTE lorsque vous exécutez des procédures stockées si l'instruction est la première du traitement.You do not have to specify the EXECUTE keyword when you execute stored procedures when the statement is the first one in a batch.

Les procédures stockées système SQL ServerSQL Server commencent par les caractères sp_. SQL ServerSQL Server system stored procedures start with the characters sp_. Elles sont stockées physiquement dans le base de données Resource, mais apparaissent logiquement dans le schéma sys de chaque système et la base de données défini par l’utilisateur.They are physically stored in the Resource database, but logically appear in the sys schema of every system and user-defined database. Lorsque vous exécutez une procédure stockée système, que ce soit dans un lot ou dans un module, telle qu'une procédure stockée ou une fonction définie par l'utilisateur, il est recommandé de qualifier son nom avec le nom de schéma sys.When you execute a system stored procedure, either in a batch or inside a module such as a user-defined stored procedure or function, we recommend that you qualify the stored procedure name with the sys schema name.

Les procédures stockées étendues système SQL ServerSQL Server commencent par les caractères xp_, : elles se trouvent dans le schéma dbo de la base de données master. SQL ServerSQL Server system extended stored procedures start with the characters xp_, and these are contained in the dbo schema of the master database. Lorsque vous exécutez une procédure stockée système étendue, que ce soit dans un lot ou dans un module, telle qu'une procédure stockée ou une fonction définie par l'utilisateur, il est recommandé de qualifier son nom avec master.dbo.When you execute a system extended stored procedure, either in a batch or inside a module such as a user-defined stored procedure or function, we recommend that you qualify the stored procedure name with master.dbo.

Lorsque vous exécutez une procédure stockée définie par l'utilisateur, que ce soit dans un lot ou dans un module, telle qu'une procédure stockée ou une fonction définie par l'utilisateur, il est recommandé de qualifier son nom avec un nom de schéma.When you execute a user-defined stored procedure, either in a batch or inside a module such as a user-defined stored procedure or function, we recommend that you qualify the stored procedure name with a schema name. Il n'est pas conseillé de nommer une procédure stockée définie par l'utilisateur avec le même nom qu'une procédure stockée système.We do not recommend that you name a user-defined stored procedure with the same name as a system stored procedure. Pour plus d’informations sur l’exécution des procédures stockées, consultez exécuter une procédure stockée.For more information about executing stored procedures, see Execute a Stored Procedure.

Utilisation de l'instruction EXECUTE avec une chaîne de caractèresUsing EXECUTE with a Character String

Dans les versions antérieures de SQL ServerSQL Server, les chaînes de caractères sont limitées à 8 000 octets.In earlier versions of SQL ServerSQL Server, character strings are limited to 8,000 bytes. Cela nécessite de concaténer les chaînes volumineuses pour l'exécution dynamique.This requires concatenating large strings for dynamic execution. Dans SQL ServerSQL Server, le varchar (max) et nvarchar (max) peuvent être spécifiés des types de données qui autorisent des chaînes de caractères à être jusqu'à 2 gigaoctets de données.In SQL ServerSQL Server, the varchar(max) and nvarchar(max) data types can be specified that allow for character strings to be up to 2 gigabytes of data.

Les modifications du contexte de la base de données ne durent que jusqu'à la fin de l'instruction EXECUTE.Changes in database context last only until the end of the EXECUTE statement. Dans le code exemple qui suit, après l'exécution de l'instruction EXEC, le contexte de la base de données est master.For example, after the EXEC in this following statement is run, the database context is master.

USE master; EXEC ('USE AdventureWorks2012; SELECT BusinessEntityID, JobTitle FROM HumanResources.Employee;');  

Changement de contexteContext Switching

Vous pouvez utiliser la clause AS { LOGIN | USER } = ' name ' pour changer le contexte d'exécution d'une instruction dynamique.You can use the AS { LOGIN | USER } = ' name ' clause to switch the execution context of a dynamic statement. Lorsque le changement de contexte est spécifié sous la forme EXECUTE ('string') AS <context_specification>, la durée du changement est limitée à l'étendue de la requête en cours d'exécution.When the context switch is specified as EXECUTE ('string') AS <context_specification>, the duration of the context switch is limited to the scope of the query being executed.

Spécification d’un utilisateur ou un nom de connexion Specifying a User or Login Name

L'utilisateur ou le nom de connexion spécifié dans AS { LOGIN | USER } = ' name ' doit exister en tant que principal respectivement dans sys.database_principals ou sys.server_principals, faute de quoi l'instruction échoue.The user or login name specified in AS { LOGIN | USER } = ' name ' must exist as a principal in sys.database_principals or sys.server_principals, respectively, or the statement will fail. De plus, les autorisations IMPERSONATE doivent être accordées sur le principal.Additionally, IMPERSONATE permissions must be granted on the principal. À moins que l'appelant soit le propriétaire de la base de données ou un membre du rôle serveur fixe sysadmin, le principal doit exister même lorsque l'utilisateur accède à la base de données ou à une instance de SQL ServerSQL Server par le biais d'une appartenance à un groupe Windows.Unless the caller is the database owner or is a member of the sysadmin fixed server role, the principal must exist even when the user is accessing the database or instance of SQL ServerSQL Server through a Windows group membership. Par exemple, supposons les conditions suivantes :For example, assume the following conditions:

  • Le groupe CompanyDomain\SQLUsers a accès à la base de données Sales.CompanyDomain\SQLUsers group has access to the Sales database.

  • L'utilisateur CompanyDomain\SqlUser1 est membre de SQLUsers : il a donc un accès implicite à la base de données Sales.CompanyDomain\SqlUser1 is a member of SQLUsers and, therefore, has implicit access to the Sales database.

    Bien que CompanyDomain\SqlUser1 ait accès à la base de données via l’appartenance dans SQLUsers groupe, l’instruction EXECUTE @string_variable AS USER = 'CompanyDomain\SqlUser1' vont échouer car CompanyDomain\SqlUser1 n’existe pas en tant que principal dans la base de données.Although CompanyDomain\SqlUser1 has access to the database through membership in the SQLUsers group, the statement EXECUTE @string_variable AS USER = 'CompanyDomain\SqlUser1' will fail because CompanyDomain\SqlUser1 does not exist as a principal in the database.

Bonnes pratiquesBest Practices

Spécifiez une connexion ou un utilisateur qui possède les privilèges minimum requis pour effectuer les opérations définies dans l'instruction ou le module.Specify a login or user that has the least privileges required to perform the operations that are defined in the statement or module. Par exemple, ne spécifiez pas un nom de connexion qui a des autorisations au niveau serveur, si seules des autorisations au niveau base de données sont requises. Ne spécifiez pas non plus le compte d'un propriétaire de base de données, excepté si ces autorisations sont exigées.For example, do not specify a login name, which has server-level permissions, if only database-level permissions are required; or do not specify a database owner account unless those permissions are required.

PermissionsPermissions

Aucune autorisation n'est requise pour exécuter l'instruction EXECUTE.Permissions are not required to run the EXECUTE statement. Cependant, des autorisations sont requises sur les éléments sécurisables référencés dans la chaîne EXECUTE.However, permissions are required on the securables that are referenced within the EXECUTE string. Par exemple, si la chaîne contient une instruction INSERT, l'appelant de l'instruction EXECUTE doit posséder l'autorisation INSERT sur la table cible.For example, if the string contains an INSERT statement, the caller of the EXECUTE statement must have INSERT permission on the target table. Les autorisations sont vérifiées au moment où l'instruction EXECUTE est rencontrée, même si celle-ci est incluse dans un module.Permissions are checked at the time EXECUTE statement is encountered, even if the EXECUTE statement is included within a module.

Les autorisations EXECUTE pour un module sont accordées par défaut au propriétaire du module, qui peut les transmettre à d'autres utilisateurs.EXECUTE permissions for a module default to the owner of the module, who can transfer them to other users. Lorsqu'un module qui exécute une chaîne est lancé, les autorisations sont vérifiées dans le contexte non pas de l'utilisateur qui a créé le module, mais de celui qui exécute le module.When a module is run that executes a string, permissions are checked in the context of the user who executes the module, not in the context of the user who created the module. Cependant, si le même utilisateur est propriétaire du module appelant et du module appelé, la vérification de l'autorisation EXECUTE n'a pas lieu pour le second module.However, if the same user owns the calling module and the module being called, EXECUTE permission checking is not performed for the second module.

Si le module accède à d'autres objets de la base de données, l'exécution réussit lorsque vous avez l'autorisation EXECUTE sur le module et si l'une des conditions suivantes est remplie :If the module accesses other database objects, execution succeeds when you have EXECUTE permission on the module and one of the following is true:

  • Le module est repéré avec EXECUTE AS USER ou SELF et son propriétaire a les autorisations correspondantes sur l'objet référencé.The module is marked EXECUTE AS USER or SELF, and the module owner has the corresponding permissions on the referenced object. Pour plus d’informations sur l’emprunt d’identité dans un module, consultez Clause EXECUTE AS ( Transact-SQL ) .For more information about impersonation within a module, see EXECUTE AS Clause (Transact-SQL).

  • Le module est repéré avec EXECUTE AS CALLER et vous avez les autorisations correspondantes sur l'objet.The module is marked EXECUTE AS CALLER, and you have the corresponding permissions on the object.

  • Le module est repéré avec EXECUTE AS nom_utilisateur, et nom_utilisateur a les autorisations correspondantes sur l’objet.The module is marked EXECUTE AS user_name, and user_name has the corresponding permissions on the object.

Autorisations pour les changements de contexteContext Switching Permissions

Pour spécifier EXECUTE AS sur une connexion, l'appelant doit posséder les autorisations IMPERSONATE sur le nom de connexion spécifié.To specify EXECUTE AS on a login, the caller must have IMPERSONATE permissions on the specified login name. Pour spécifier EXECUTE AS sur un utilisateur de base de données, l'appelant doit posséder les autorisations IMPERSONATE sur le nom d'utilisateur spécifié.To specify EXECUTE AS on a database user, the caller must have IMPERSONATE permissions on the specified user name. Lorsqu'aucun contexte d'exécution n'est spécifié ou lorsque EXECUTE AS CALLER est spécifié, les autorisations IMPERSONATE ne sont pas requises.When no execution context is specified, or EXECUTE AS CALLER is specified, IMPERSONATE permissions are not required.

ExemplesExamples

A.A. Utilisation de l'instruction EXECUTE pour passer un seul paramètreUsing EXECUTE to pass a single parameter

La procédure stockée uspGetEmployeeManagers dans la base de données AdventureWorks2012AdventureWorks2012 attend un seul paramètre (@EmployeeID).The uspGetEmployeeManagers stored procedure in the AdventureWorks2012AdventureWorks2012 database expects one parameter (@EmployeeID). L’exemple suivant exécute la uspGetEmployeeManagers procédure stockée avec Employee ID 6 comme valeur de paramètre.The following examples execute the uspGetEmployeeManagers stored procedure with Employee ID 6 as its parameter value.

EXEC dbo.uspGetEmployeeManagers 6;  
GO  

La variable peut être désignée explicitement dans l'exécution :The variable can be explicitly named in the execution:

EXEC dbo.uspGetEmployeeManagers @EmployeeID = 6;  
GO  

Si ce qui suit est la première instruction dans un lot ou une osql ou sqlcmd script, EXEC n’est pas requis.If the following is the first statement in a batch or an osql or sqlcmd script, EXEC is not required.

dbo.uspGetEmployeeManagers 6;  
GO  
--Or  
dbo.uspGetEmployeeManagers @EmployeeID = 6;  
GO  

B.B. Utilisation de plusieurs paramètresUsing multiple parameters

L'exemple suivant exécute la procédure stockée spGetWhereUsedProductID dans la base de données AdventureWorks2012AdventureWorks2012.The following example executes the spGetWhereUsedProductID stored procedure in the AdventureWorks2012AdventureWorks2012 database. Il passe deux paramètres : le premier est l'identificateur d'un produit (819), et le second paramètre, @CheckDate,, est une valeur datetime.It passes two parameters: the first parameter is a product ID (819) and the second parameter, @CheckDate, is a datetime value.

DECLARE @CheckDate datetime;  
SET @CheckDate = GETDATE();  
EXEC dbo.uspGetWhereUsedProductID 819, @CheckDate;  
GO  

C.C. Utilisation de l'instruction EXECUTE 'tsql_string' avec une variableUsing EXECUTE 'tsql_string' with a variable

Le code exemple suivant montre comment EXECUTE manipule les chaînes construites dynamiquement qui contiennent des variables.The following example shows how EXECUTE handles dynamically built strings that contain variables. Cet exemple crée le curseur tables_cursor pour contenir la liste de toutes les tables définies par l'utilisateur dans la base de données AdventureWorks2012AdventureWorks2012, puis utilise cette liste pour reconstruire tous les index des tables.This example creates the tables_cursor cursor to hold a list of all user-defined tables in the AdventureWorks2012AdventureWorks2012 database, and then uses that list to rebuild all indexes on the tables.

DECLARE tables_cursor CURSOR  
   FOR  
   SELECT s.name, t.name   
   FROM sys.objects AS t  
   JOIN sys.schemas AS s ON s.schema_id = t.schema_id  
   WHERE t.type = 'U';  
OPEN tables_cursor;  
DECLARE @schemaname sysname;  
DECLARE @tablename sysname;  
FETCH NEXT FROM tables_cursor INTO @schemaname, @tablename;  
WHILE (@@FETCH_STATUS <> -1)  
BEGIN;  
   EXECUTE ('ALTER INDEX ALL ON ' + @schemaname + '.' + @tablename + ' REBUILD;');  
   FETCH NEXT FROM tables_cursor INTO @schemaname, @tablename;  
END;  
PRINT 'The indexes on all tables have been rebuilt.';  
CLOSE tables_cursor;  
DEALLOCATE tables_cursor;  
GO  

D.D. Utilisation de l'instruction EXECUTE avec une procédure stockée distanteUsing EXECUTE with a remote stored procedure

Le code exemple suivant exécute la procédure stockée uspGetEmployeeManagers sur le serveur distant SQLSERVER1 et stocke dans @retstat l'état du résultat qui indique la réussite ou l'échec.The following example executes the uspGetEmployeeManagers stored procedure on the remote server SQLSERVER1 and stores the return status that indicates success or failure in @retstat.

S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

DECLARE @retstat int;  
EXECUTE @retstat = SQLSERVER1.AdventureWorks2012.dbo.uspGetEmployeeManagers @BusinessEntityID = 6;  

E.E. Utilisation de l'instruction EXECUTE avec une variable de procédure stockéeUsing EXECUTE with a stored procedure variable

Le code exemple suivant crée une variable qui représente le nom d'une procédure stockée.The following example creates a variable that represents a stored procedure name.

DECLARE @proc_name varchar(30);  
SET @proc_name = 'sys.sp_who';  
EXEC @proc_name;  

F.F. Utilisation de l'instruction EXECUTE avec l'option DEFAULTUsing EXECUTE with DEFAULT

Le code exemple suivant crée une procédure stockée avec des valeurs par défaut pour les premier et troisième paramètres.The following example creates a stored procedure with default values for the first and third parameters. Lorsque la procédure est exécutée, ces valeurs par défaut sont insérées pour les premier et troisième paramètres si aucune valeur n'est passée dans l'appel ou si la valeur par défaut est spécifiée.When the procedure is run, these defaults are inserted for the first and third parameters when no value is passed in the call or when the default is specified. Notez les différentes façons d'utiliser le mot clé DEFAULT.Note the various ways the DEFAULT keyword can be used.

IF OBJECT_ID(N'dbo.ProcTestDefaults', N'P')IS NOT NULL  
   DROP PROCEDURE dbo.ProcTestDefaults;  
GO  
-- Create the stored procedure.  
CREATE PROCEDURE dbo.ProcTestDefaults (  
@p1 smallint = 42,   
@p2 char(1),   
@p3 varchar(8) = 'CAR')  
AS   
   SET NOCOUNT ON;  
   SELECT @p1, @p2, @p3  
;  
GO  

L'exécution de la procédure stockée Proc_Test_Defaults peut s'effectuer selon plusieurs combinaisons.The Proc_Test_Defaults stored procedure can be executed in many combinations.

-- Specifying a value only for one parameter (@p2).  
EXECUTE dbo.ProcTestDefaults @p2 = 'A';  
-- Specifying a value for the first two parameters.  
EXECUTE dbo.ProcTestDefaults 68, 'B';  
-- Specifying a value for all three parameters.  
EXECUTE dbo.ProcTestDefaults 68, 'C', 'House';  
-- Using the DEFAULT keyword for the first parameter.  
EXECUTE dbo.ProcTestDefaults @p1 = DEFAULT, @p2 = 'D';  
-- Specifying the parameters in an order different from the order defined in the procedure.  
EXECUTE dbo.ProcTestDefaults DEFAULT, @p3 = 'Local', @p2 = 'E';  
-- Using the DEFAULT keyword for the first and third parameters.  
EXECUTE dbo.ProcTestDefaults DEFAULT, 'H', DEFAULT;  
EXECUTE dbo.ProcTestDefaults DEFAULT, 'I', @p3 = DEFAULT;  

G.G. Utilisation de l'instruction EXECUTE avec AT linked_server_nameUsing EXECUTE with AT linked_server_name

Le code exemple suivant passe une chaîne de commandes à un serveur distant.The following example passes a command string to a remote server. Il crée un serveur lié SeattleSales qui pointe vers une autre instance de SQL ServerSQL Server et exécute une instruction DDL (CREATE TABLE) sur ce serveur lié.It creates a linked server SeattleSales that points to another instance of SQL ServerSQL Server and executes a DDL statement (CREATE TABLE) against that linked server.

S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

EXEC sp_addlinkedserver 'SeattleSales', 'SQL Server'  
GO  
EXECUTE ( 'CREATE TABLE AdventureWorks2012.dbo.SalesTbl   
(SalesID int, SalesName varchar(10)) ; ' ) AT SeattleSales;  
GO  

H.H. Utilisation de l'instruction EXECUTE WITH RECOMPILEUsing EXECUTE WITH RECOMPILE

L’exemple suivant exécute la Proc_Test_Defaults procédure stockée et force un nouveau plan de requête à compiler, utilisé et supprimées une fois que le module est exécuté.The following example executes the Proc_Test_Defaults stored procedure and forces a new query plan to be compiled, used, and discarded after the module is executed.

EXECUTE dbo.Proc_Test_Defaults @p2 = 'A' WITH RECOMPILE;  
GO  

I.I. Utilisation de l'instruction EXECUTE avec une fonction définie par l'utilisateurUsing EXECUTE with a user-defined function

Le code exemple suivant exécute la fonction scalaire ufnGetSalesOrderStatusText définie par l'utilisateur dans la base de données AdventureWorks2012AdventureWorks2012.The following example executes the ufnGetSalesOrderStatusText scalar user-defined function in the AdventureWorks2012AdventureWorks2012 database. Il utilise la variable @returnstatus pour stocker la valeur renvoyée par la fonction.It uses the variable @returnstatus to store the value returned by the function. Celle-ci attend un seul paramètre d'entrée, @Status,The function expects one input parameter, @Status. Cela est défini comme un tinyint type de données.This is defined as a tinyint data type.

DECLARE @returnstatus nvarchar(15);  
SET @returnstatus = NULL;  
EXEC @returnstatus = dbo.ufnGetSalesOrderStatusText @Status = 2;  
PRINT @returnstatus;  
GO  

J.J. Utilisation de l'instruction EXECUTE pour interroger une base de données Oracle sur un serveur liéUsing EXECUTE to query an Oracle database on a linked server

Le code exemple suivant exécute plusieurs instructions SELECT sur le serveur Oracle distant.The following example executes several SELECT statements at the remote Oracle server. Il commence par ajouter le serveur Oracle comme serveur lié puis crée ensuite la connexion au serveur lié.The example begins by adding the Oracle server as a linked server and creating linked server login.

S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

-- Setup the linked server.  
EXEC sp_addlinkedserver    
        @server='ORACLE',  
        @srvproduct='Oracle',  
        @provider='OraOLEDB.Oracle',   
        @datasrc='ORACLE10';  

EXEC sp_addlinkedsrvlogin   
    @rmtsrvname='ORACLE',  
    @useself='false',   
    @locallogin=null,   
    @rmtuser='scott',   
    @rmtpassword='tiger';  

EXEC sp_serveroption 'ORACLE', 'rpc out', true;  
GO  

-- Execute several statements on the linked Oracle server.  
EXEC ( 'SELECT * FROM scott.emp') AT ORACLE;  
GO  
EXEC ( 'SELECT * FROM scott.emp WHERE MGR = ?', 7902) AT ORACLE;  
GO  
DECLARE @v INT;   
SET @v = 7902;  
EXEC ( 'SELECT * FROM scott.emp WHERE MGR = ?', @v) AT ORACLE;  
GO   

K.K. Utilisation de l'instruction EXECUTE AS USER pour basculer le contexte vers un autre utilisateurUsing EXECUTE AS USER to switch context to another user

Le code exemple suivant exécute une chaîne Transact-SQLTransact-SQL qui crée une table et spécifie la clause AS USER pour basculer le contexte d'exécution de l'instruction de l'appelant vers l'utilisateur User1.The following example executes a Transact-SQLTransact-SQL string that creates a table and specifies the AS USER clause to switch the execution context of the statement from the caller to User1. Le Moteur de base de donnéesDatabase Engine vérifie les autorisations de User1 lorsque l'instruction est exécutée.The Moteur de base de donnéesDatabase Engine will check the permissions of User1 when the statement is run. User1 doit exister dans la base de données et posséder l'autorisation de créer des tables dans le schéma Sales, faute de quoi l'instruction échoue.User1 must exist as a user in the database and must have permission to create tables in the Sales schema, or the statement fails.

EXECUTE ('CREATE TABLE Sales.SalesTable (SalesID int, SalesName varchar(10));')  
AS USER = 'User1';  
GO  

L.L. Utilisation d'un paramètre avec l'instruction EXECUTE et AT linked_server_nameUsing a parameter with EXECUTE and AT linked_server_name

L'exemple suivant passe une chaîne de commande à un serveur distant en utilisant un point d'interrogation (?) comme espace réservé pour un paramètre.The following example passes a command string to a remote server by using a question mark (?) placeholder for a parameter. Cet exemple crée un serveur lié SeattleSales qui pointe vers une autre instance de SQL ServerSQL Server et exécute une instruction SELECT sur ce serveur lié.The example creates a linked server SeattleSales that points to another instance of SQL ServerSQL Server and executes a SELECT statement against that linked server. L'instruction SELECT utilise le point d'interrogation comme espace réservé pour le paramètre ProductID (952) qui est fourni après l'instruction.The SELECT statement uses the question mark as a place holder for the ProductID parameter (952), which is provided after the statement.

S’applique aux: SQL Server 2008SQL Server 2008 via SQL Server 2017SQL Server 2017Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017

-- Setup the linked server.  
EXEC sp_addlinkedserver 'SeattleSales', 'SQL Server'  
GO  
-- Execute the SELECT statement.  
EXECUTE ('SELECT ProductID, Name   
    FROM AdventureWorks2012.Production.Product  
    WHERE ProductID = ? ', 952) AT SeattleSales;  
GO  

M.M. Utilisation de l'instruction EXECUTE pour redéfinir un jeu de résultats uniqueUsing EXECUTE to redefine a single result set

Certains des exemples précédents ont exécuté EXEC dbo.uspGetEmployeeManagers 6; qui a retourné 7 colonnes.Some of the previous examples executed EXEC dbo.uspGetEmployeeManagers 6; which returned 7 columns. L'exemple suivant montre l'utilisation de la syntaxe WITH RESULT SET pour modifier les noms et types de données du jeu de résultats retourné.The following example demonstrates using the WITH RESULT SET syntax to change the names and data types of the returning result set.

S’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL DatabaseApplies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database

EXEC uspGetEmployeeManagers 16  
WITH RESULT SETS  
(   
   ([Reporting Level] int NOT NULL,  
    [ID of Employee] int NOT NULL,  
    [Employee First Name] nvarchar(50) NOT NULL,  
    [Employee Last Name] nvarchar(50) NOT NULL,  
    [Employee ID of Manager] nvarchar(max) NOT NULL,  
    [Manager First Name] nvarchar(50) NOT NULL,  
    [Manager Last Name] nvarchar(50) NOT NULL )  
);  

N.N. Utilisation de l'instruction EXECUTE pour redéfinir deux jeux de résultatsUsing EXECUTE to redefine a two result sets

Lorsque vous exécutez une instruction qui retourne plusieurs jeux de résultats, définissez chaque jeu de résultats attendu.When executing a statement that returns more than one result set, define each expected result set. L'exemple suivant dans AdventureWorks2012AdventureWorks2012 crée une procédure qui retourne deux jeux de résultats.The following example in AdventureWorks2012AdventureWorks2012 creates a procedure that returns two result sets. Ensuite, la procédure est exécutée à l’aide de la WITH RESULT SETS clause et en spécifiant les résultats de deux définitions de jeu.Then the procedure is executed using the WITH RESULT SETS clause, and specifying two result set definitions.

S’applique aux: SQL Server 2012SQL Server 2012 via SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL DatabaseApplies to: SQL Server 2012SQL Server 2012 through SQL Server 2017SQL Server 2017, Azure SQL DatabaseAzure SQL Database

--Create the procedure  
CREATE PROC Production.ProductList @ProdName nvarchar(50)  
AS  
-- First result set  
SELECT ProductID, Name, ListPrice  
    FROM Production.Product  
    WHERE Name LIKE @ProdName;  
-- Second result set   
SELECT Name, COUNT(S.ProductID) AS NumberOfOrders  
    FROM Production.Product AS P  
    JOIN Sales.SalesOrderDetail AS S  
        ON P.ProductID  = S.ProductID   
    WHERE Name LIKE @ProdName  
    GROUP BY Name;  
GO  

-- Execute the procedure   
EXEC Production.ProductList '%tire%'  
WITH RESULT SETS   
(  
    (ProductID int,   -- first result set definition starts here  
    Name Name,  
    ListPrice money)  
    ,                 -- comma separates result set definitions  
    (Name Name,       -- second result set definition starts here  
    NumberOfOrders int)  
);  

Exemples : Azure SQL Data WarehouseAzure SQL Data Warehouse et Parallel Data WarehouseParallel Data WarehouseExamples: Azure SQL Data WarehouseAzure SQL Data Warehouse and Parallel Data WarehouseParallel Data Warehouse

Exemple O: exécution de la procédure de baseExample O: Basic Procedure Execution

Exécution d’une procédure stockée :Executing a stored procedure:

EXEC proc1;  

Appel d’une procédure stockée avec le nom déterminé lors de l’exécution :Calling a stored procedure with name determined at runtime:

EXEC ('EXEC ' + @var);  

Appel d’une procédure stockée à partir d’une procédure stockée :Calling a stored procedure from within a stored procedure:

CREATE sp_first AS EXEC sp_second; EXEC sp_third;  

Exemple P: l’exécution de chaînesExample P: Executing Strings

Exécution d’une chaîne SQL :Executing a SQL string:

EXEC ('SELECT * FROM sys.types');  

Exécution d’une chaîne imbriquée :Executing a nested string:

EXEC ('EXEC (''SELECT * FROM sys.types'')');  

Exécution d’une variable de chaîne :Executing a string variable:

DECLARE @stringVar nvarchar(100);  
SET @stringVar = N'SELECT name FROM' + ' sys.sql_logins';  
EXEC (@stringVar);  

Exemple q : procédures avec des paramètresExample Q: Procedures with Parameters

L’exemple suivant crée une procédure avec des paramètres et illustre les 3 façons d’exécuter la procédure :The following example creates a procedure with parameters and demonstrates 3 ways to execute the procedure:

-- Uses AdventureWorks  

CREATE PROC ProcWithParameters  
    @name nvarchar(50),  
@color nvarchar (15)  
AS   
SELECT ProductKey, EnglishProductName, Color FROM [dbo].[DimProduct]  
WHERE EnglishProductName LIKE @name  
AND Color = @color;  
GO  

-- Executing using positional parameters  
EXEC ProcWithParameters N'%arm%', N'Black';  
-- Executing using named parameters in order  
EXEC ProcWithParameters @name = N'%arm%', @color = N'Black';  
-- Executing using named parameters out of order  
EXEC ProcWithParameters @color = N'Black', @name = N'%arm%';  
GO  

Voir aussiSee Also

@@NESTLEVEL (Transact-SQL) @@NESTLEVEL (Transact-SQL)
DECLARE @local_variable (Transact-SQL) DECLARE @local_variable (Transact-SQL)
Clause EXECUTE AS (Transact-SQL) EXECUTE AS Clause (Transact-SQL)
Utilitaire osql osql Utility
Principaux (moteur de base de données) Principals (Database Engine)
Rétablir ( Transact-SQL ) REVERT (Transact-SQL)
sp_addlinkedserver (Transact-SQL) sp_addlinkedserver (Transact-SQL)
Utilitaire sqlcmd sqlcmd Utility
SUSER_NAME ( Transact-SQL ) SUSER_NAME (Transact-SQL)
sys.database_principals (Transact-SQL) sys.database_principals (Transact-SQL)
sys.server_principals (Transact-SQL) sys.server_principals (Transact-SQL)
User_name ( Transact-SQL ) USER_NAME (Transact-SQL)
OPENDATASOURCE (Transact-SQL) OPENDATASOURCE (Transact-SQL)
Fonctions scalaires définies par l’utilisateur pour l’OLTP en mémoireScalar User-Defined Functions for In-Memory OLTP