EXECUTE (Transact-SQL)

Article
12/22/2024

S’applique à :SQL Server Base de données Azure SQL Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW)Point de terminaison d'analyse SQL dans Microsoft Fabric Entrepôt dans Microsoft Fabric Base de données SQL dans Microsoft Fabric

Exécute une chaîne de commande ou de caractères dans un lot Transact-SQL ou l’un des modules suivants : procédure stockée système, procédure stockée définie par l’utilisateur, procédure stockée CLR, fonction scalaire définie par l’utilisateur ou procédure stockée étendue. L’instruction EXEC ou EXECUTE peut être utilisée pour envoyer des commandes directes à des serveurs liés. 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. Les métadonnées du jeu de résultats peuvent être définies à l’aide des options de WITH RESULT SETS.

Important

Avant d’appeler EXECUTE avec une chaîne de caractères, validez la chaîne de caractères. N’exécutez jamais une commande construite à partir d’une entrée utilisateur qui n’a pas été validée.

Conventions de la syntaxe Transact-SQL

Syntaxe

Le bloc de code suivant montre la syntaxe dans SQL Server 2019 (15.x) et les versions ultérieures. Vous pouvez également consulter la syntaxe dans SQL Server 2017 et versions antérieures à la place.

Syntaxe pour SQL Server 2019 et versions ultérieures.

-- 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 ]
    [ AT DATA_SOURCE data_source_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
}

Le bloc de code suivant montre la syntaxe dans SQL Server 2017 (14.x) et les versions antérieures. Vous pouvez également consulter la syntaxe dans SQL Server 2019 à la place.

Syntaxe pour SQL Server 2017 et versions antérieures.

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

Syntaxe de 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 ] ) }
}

Syntaxe pour 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
}

Syntaxe pour Azure Synapse Analytics et 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 ] )
[ ; ]

Syntaxe de Microsoft Fabric.

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

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

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

Arguments

@return_status

Variable entière facultative qui stocke l’état de retour d’un module. Cette variable doit être déclarée dans le lot, la procédure stockée ou la fonction avant d’être utilisée dans une instruction EXECUTE.

Lorsqu’elle est utilisée pour appeler une fonction définie par l’utilisateur à valeur scalaire, la variable @return_status peut être de n’importe quel type de données scalaire.

module_name

Nom complet ou non qualifié de la procédure stockée ou de la fonction scalaire définie par l’utilisateur à appeler. Les noms des modules doivent respecter les règles applicables aux identificateurs. Les noms des procédures stockées étendues distinguent toujours les majuscules et les minuscules, quel que soit le classement du serveur.

Un module créé dans une autre base de données peut être exécuté si l’utilisateur exécutant le module possède le module ou dispose de l’autorisation appropriée pour l’exécuter dans cette base de données. Un module peut être exécuté sur un autre serveur SQL 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. 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 Server recherche le module dans la base de données par défaut de l'utilisateur.

;number

Entier facultatif utilisé pour regrouper les procédures du même nom. Ce paramètre n’est pas utilisé pour les procédures stockées étendues.

Remarque

Cette fonctionnalité sera supprimée dans une version future de 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é.

Pour plus d’informations sur les groupes de procédures, consultez CREATE PROCEDURE.

@module_name_var

Nom d’une variable définie localement qui représente un nom de module.

Il peut s’agir d’une variable qui conserve le nom d’une fonction scalaire définie par l’utilisateur et compilée en mode natif.

@parameter

Paramètre de module_name, tel que défini dans le module. Les noms de paramètres doivent être précédés du signe à l’adresse (@). Lorsqu’ils sont utilisés avec la valeur @parameter_name = formulaire, les noms de paramètres et les constantes ne doivent pas être fournis dans l’ordre dans lequel ils sont définis dans le module. Toutefois, si la valeur @parameter_name = formulaire est utilisée pour n’importe quel paramètre, elle doit être utilisée pour tous les paramètres suivants.

Par défaut, les paramètres acceptent les valeurs NULL.

value

Valeur du paramètre à transmettre au module ou à la commande directe. Si les noms de paramètres ne sont pas spécifiés, les valeurs de paramètre doivent être fournies dans l’ordre défini dans le 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é. La plupart des fournisseurs OLE DB lient les valeurs aux paramètres de gauche à droite.

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. Si la valeur d'un paramètre est un mot clé, ce mot clé doit être mis entre guillemets doubles.

Si vous passez un mot unique qui ne commence pas par @, qui n’est pas placé entre guillemets (par exemple, si vous oubliez @ sur un nom de paramètre), le mot est traité comme un nvarchar chaîne, malgré les guillemets manquants.

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.

La valeur par défaut peut également être NULL. En règle générale, la définition du module spécifie l’action qui doit être effectuée si une valeur de paramètre est NULL.

@variable

Variable qui stocke un paramètre ou un paramètre de retour.

OUTPUT

Spécifie que le module ou la chaîne de commandes renvoie un paramètre. Le paramètre correspondant dans le module ou la chaîne de commande doit également avoir été créé à l’aide du mot clé OUTPUT. Utilisez ce mot clé lorsque vous utilisez des variables de curseur comme paramètres.

Si valeur est définie comme OUTPUT d’un module exécuté sur un serveur lié, les modifications apportées aux @parameter correspondantes effectuées par le fournisseur OLE DB sont copiées vers la variable à la fin de l’exécution du module.

Si OUTPUT paramètres sont utilisés et que l’intention est d’utiliser les valeurs de retour dans d’autres instructions dans le lot ou le module appelant, la valeur du paramètre doit être passée en tant que variable, telle que @parameter = @variable. Vous ne pouvez pas exécuter de module en spécifiant OUTPUT pour un paramètre qui n’est pas défini comme paramètre OUTPUT dans le module. Les constantes ne peuvent pas être transmises au module à l’aide de OUTPUT; le paramètre de retour nécessite un nom de variable. 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.

Lorsque EXECUTE est utilisé sur une procédure stockée distante ou pour exécuter une commande directe sur un serveur lié, OUTPUT paramètres ne peuvent pas être un des types de données LOB (Large Object).

Les paramètres de retour peuvent être de n'importe quel type, à l'exception des types LOB.

DEFAULT

Fournit la valeur par défaut du paramètre telle qu'elle est définie dans le module. Lorsque le module attend une valeur pour un paramètre qui n’a pas de valeur par défaut définie et qu’un paramètre est manquant ou que le mot clé DEFAULT est spécifié, une erreur se produit.

@string_variable

Nom d’une variable locale. @string_variable peut être n’importe quel char, varchar, ncharou type de données nvarchar. Les types de données (max) sont inclus.

[N]'tsql_string'

Chaîne constante. tsql_string peut être de type nvarchar ou varchar. Si la N est incluse, la chaîne est interprétée comme type de données nvarchar.

AS context_specification

Spécifie le contexte dans lequel l'instruction est exécutée.

Spécifie que le contexte dont l'identité doit être empruntée est une connexion. L'étendue de l'emprunt d'identité est le serveur.

Utilisateur

Spécifie que le contexte dont l'identité doit être empruntée est un utilisateur de la base de données active. L'étendue de l'emprunt d'identité est limitée à la base de données active. Un commutateur de contexte vers un utilisateur de base de données n’hérite pas des autorisations au niveau du serveur de cet utilisateur.

Important

Bien que le commutateur de contexte vers l’utilisateur de la base de données soit actif, toute tentative d’accès aux ressources en dehors de la base de données provoque l’échec de l’instruction. Cela inclut des instructions USE <database>, des requêtes distribuées et des requêtes qui référencent une autre base de données à l’aide d’identificateurs en trois parties ou en quatre parties.

'name'

Nom d’utilisateur ou de connexion valide. Le nom argument doit être membre du rôle serveur fixe sysadmin ou exister en tant que principal dans sys.database_principals ou sys.server_principals, respectivement.

Cet argument ne peut pas être un compte intégré, tel que NT AUTHORITY\LocalService, NT AUTHORITY\NetworkServiceou NT AUTHORITY\LocalSystem.

Pour plus d’informations, consultez Spécification d’un nom d’utilisateur ou de connexion plus loin dans cet article.

[N]'command_string'

Chaîne constante qui contient la commande à transmettre au serveur lié. Si la N est incluse, la chaîne est interprétée comme type de données nvarchar.

[?]

Indique les paramètres pour lesquels les valeurs sont fournies dans la <arg-list> des commandes directes utilisées dans une instruction EXECUTE ('...', <arg-list>) AT <linkedsrv>.

AT linked_server_name

Spécifie l’exécution de command_string sur linked_server_name. Les résultats, le cas échéant, sont renvoyés au client. linked_server_name doit faire référence à une définition de serveur lié existante sur le serveur local. Les serveurs liés sont définis au moyen de sp_addlinkedserver.

WITH <execute_option>

Options d'exécution possibles. Les options RESULT SETS ne peuvent pas être spécifiées dans une instruction INSERT...EXECUTE.

AT DATA_SOURCE data_source_name

s’applique à: SQL Server 2019 (15.x) et versions ultérieures.

Spécifie l’exécution de command_string sur linked_server_name. Les résultats, le cas échéant, sont renvoyés au client. data_source_name devez faire référence à une définition de EXTERNAL DATA SOURCE existante dans la base de données. Seules les sources de données qui pointent vers SQL Server sont prises en charge. En outre, pour les sources de données de cluster Big Data SQL Server qui pointent vers le pool de calcul, le pool de données ou le pool de stockage sont pris en charge. Les sources de données sont définies à l’aide de CRÉER UNE SOURCE DE DONNÉES EXTERNES.

WITH <execute_option>

Options d'exécution possibles. Les options RESULT SETS ne peuvent pas être spécifiées dans une instruction INSERT...EXECUTE.

Terme	Définition
`RECOMPILE`	Impose la compilation, l'utilisation et la suppression d'un nouveau plan après l'exécution du module. S’il existe un plan de requête existant pour le module, ce plan reste dans le cache. Utilisez cette option si le paramètre que vous fournissez est atypique ou si les données ont considérablement changé. Cette option n’est pas utilisée pour les procédures stockées étendues. Nous vous recommandons d’utiliser cette option avec parcimonie, car elle est coûteuse. Remarque : vous ne pouvez pas utiliser `WITH RECOMPILE` lors de l’appel d’une procédure stockée qui utilise `OPENDATASOURCE` syntaxe. L’option `WITH RECOMPILE` est ignorée lorsqu’un nom d’objet en quatre parties est spécifié. Remarque :`RECOMPILE` n’est pas pris en charge avec les fonctions scalaires définies par l’utilisateur compilées en mode natif. Si vous devez recompiler, utilisez sp_recompile.
`RESULT SETS UNDEFINED`	Cette option ne garantit aucun résultat, le cas échéant, et aucune définition n’est fournie. L'instruction s'exécute sans erreur si des résultats sont retournés ou aucun résultat n'est retourné. `RESULT SETS UNDEFINED` est le comportement par défaut si un result_sets_option n’est pas fourni. Pour les fonctions scalaires interprétées définies par l’utilisateur et les fonctions scalaires compilées en mode natif, cette option n’est pas opérationnelle, car les fonctions ne retournent jamais un jeu de résultats. s’applique à: SQL Server 2012 (11.x) et versions ultérieures, et Azure SQL Database.
`RESULT SETS NONE`	Garantit que l’instruction `EXECUTE` ne retourne aucun résultat. Si des résultats sont retournés, le traitement est abandonné. Pour les fonctions scalaires interprétées définies par l’utilisateur et les fonctions scalaires compilées en mode natif, cette option n’est pas opérationnelle, car les fonctions ne retournent jamais un jeu de résultats. s’applique à: SQL Server 2012 (11.x) et versions ultérieures, et Azure SQL Database.
`<result_sets_definition>`	Fournit une garantie que le résultat revient comme spécifié dans la `result_sets_definition`. Pour les instructions qui retournent plusieurs jeux de résultats, fournissez plusieurs sections result_sets_definition. Placez chaque result_sets_definition entre parenthèses, séparées par des virgules. Pour plus d’informations, consultez `<result_sets_definition>` plus loin dans cet article. Cette option génère toujours une erreur pour les fonctions scalaires définies par l’utilisateur et compilées en mode natif, car les fonctions ne retournent jamais un jeu de résultats. s’applique à: SQL Server 2012 (11.x) et versions ultérieures, et Azure SQL Database.

<result_sets_definition> décrit les jeux de résultats retournés par les instructions exécutées. Les clauses du result_sets_definition ont la signification suivante :

Terme	Définition
{ column_name data_type [ COLLATE collation_name ] [NULL \| NOT NULL] }	Consultez le tableau suivant.
db_name	Nom de la base de données contenant la fonction table, vue ou table.
schema_name	Nom du schéma propriétaire de la fonction table, vue ou table.
table_name \| view_name \| table_valued_function_name	Spécifie que les colonnes retournées sont celles spécifiées dans la fonction table, vue ou table nommée. Les variables de table, les tables temporaires et les synonymes ne sont pas pris en charge dans la syntaxe de l’objet AS.
AS TYPE [ schema_name. ]table_type_name	Spécifie que les colonnes retournées sont celles spécifiées dans le type de table.
AS 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 au format comme s’ils étaient produits par une instruction `SELECT ... FOR XML ...`. Toutes les mises en forme des directives de type de l’instruction d’origine sont supprimées et les résultats retournés sont comme si aucune directive de type n’a été spécifiée. AS FOR XML ne convertit pas les résultats tabulaires non XML de l’instruction exécutée ou de la procédure stockée en XML.

Terme	Définition
column_name	Nom de chaque colonne. Si le nombre de colonnes diffère du jeu de résultats, une erreur se produit et le lot est abandonné. Si le nom d'une colonne diffère du jeu de résultats, le nom de colonne retourné correspondra au nom défini.
data_type	Types de données de chaque colonne. Si les types de données diffèrent, une conversion implicite vers le type de données défini est effectuée. Si la conversion échoue, le lot est abandonné
COLLATE collation_name	Classement de chaque colonne. S’il existe une incompatibilité de classement, un classement implicite est tenté. Si cette opération échoue, le lot est abandonné.
NULL \| NOT NULL	Valeur Null possible dans chaque colonne. Si la valeur nullabilité définie est `NOT NULL` et que les données retournées contiennent des valeurs Null, une erreur se produit et le lot est abandonné. Si elle n’est pas spécifiée, la valeur par défaut est conforme au paramètre des options `ANSI_NULL_DFLT_ON` et `ANSI_NULL_DFLT_OFF`.

Le jeu de résultats réel 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, nullabilité et type de données. Si le nombre de jeu de résultats diffère, une erreur se produit et le lot est abandonné.

Notes

Les paramètres peuvent être fournis à l’aide de valeur ou à l’aide de @parameter_name = valeur. Un paramètre ne fait pas partie d’une transaction ; par conséquent, si un paramètre est modifié dans une transaction qui est restaurée ultérieurement, la valeur du paramètre ne revient pas à sa valeur précédente. La valeur renvoyée à l'appelant est toujours la valeur au moment du renvoie du module.

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. Le niveau d’imbrication incrémente lorsque la référence de module ou de code managé appelé démarre l’exécution et décrémente lorsque le module appelé ou la référence de code managé se termine. Au-delà de 32 niveaux d'imbrication, l'ensemble de la chaîne d'appel échoue. Le niveau d’imbrication actuel est stocké dans la fonction système @@NESTLEVEL.

Étant donné que les procédures stockées distantes et les procédures stockées étendues ne se trouvent pas dans l’étendue d’une transaction (sauf si elles sont émises dans une instruction BEGIN DISTRIBUTED TRANSACTION ou lorsqu’elles sont utilisées avec différentes options de configuration), les commandes exécutées par le biais d’appels ne peuvent pas être restaurées. Pour plus d’informations, consultez procédures stockées système et BEGIN DISTRIBUTED TRANSACTION.

Lorsque vous utilisez des variables de curseur, si vous exécutez une procédure qui passe dans une variable de curseur avec un curseur qui lui est alloué, une erreur se produit.

Vous n’avez pas besoin de spécifier le mot clé EXECUTE lors de l’exécution de modules si l’instruction est la première dans un lot.

Pour plus d’informations sur les procédures stockées CLR, consultez procédures stockées CLR.

Utiliser EXECUTE avec des procédures stockées

Vous n’avez pas besoin de spécifier le mot clé EXECUTE lorsque vous exécutez des procédures stockées lorsque l’instruction est la première dans un lot.

Les procédures stockées système SQL Server commencent par les caractères sp_. Ils sont physiquement stockés dans la base de données de ressources , mais apparaissent logiquement dans le schéma sys de chaque base de données système et définie par l’utilisateur. 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.

Les procédures stockées étendues du système SQL Server commencent par les caractères xp_, et celles-ci sont contenues dans le schéma dbo de la base de données master. Lorsque vous exécutez une procédure stockée étendue par le système, dans un lot ou dans un module tel qu’une procédure stockée définie par l’utilisateur ou une fonction, nous vous recommandons de qualifier le nom de la procédure stockée avec 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. Nous vous déconseillons 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. Pour plus d’informations sur l’exécution de procédures stockées, consultez Exécuter une procédure stockée.

Utiliser EXECUTE avec une chaîne de caractères

Dans SQL Server, il est possible de spécifier les types de données varchar(max) et nvarchar(max) qui permettent aux chaînes de caractères d’occuper jusqu’à 2 gigaoctets (Go) de données.

Les modifications apportées au contexte de base de données ne se terminent que jusqu’à la fin de l’instruction EXECUTE. Par exemple, après l’exécution du EXECUTE dans cette instruction suivante, le contexte de base de données est master.

USE master;

EXECUTE ('USE AdventureWorks2022; SELECT BusinessEntityID, JobTitle FROM HumanResources.Employee;');

Changement de contexte

Vous pouvez utiliser la clause AS { LOGIN | USER } = '<name>' pour changer le contexte d'exécution d'une instruction dynamique. 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.

Le nom d’utilisateur ou de connexion spécifié dans AS { LOGIN | USER } = '<name>' doit exister en tant que principal dans sys.database_principals ou sys.server_principals respectivement, ou l’instruction échoue. En outre, IMPERSONATE autorisations doivent être accordées sur le principal. Sauf si l’appelant est le propriétaire de la base de données ou est membre du rôle serveur fixe sysadmin, le principal doit exister même lorsque l’utilisateur accède à la base de données ou à l’instance de SQL Server par le biais d’une appartenance à un groupe Windows. Par exemple, supposons les conditions suivantes :

CompanyDomain\SQLUsers groupe a accès à la base de données Sales.
CompanyDomain\SqlUser1 est membre de SQLUsers et, par conséquent, a un accès implicite à la base de données Sales.

Bien que CompanyDomain\SqlUser1 ait accès à la base de données via l’appartenance au groupe SQLUsers, l’instruction EXECUTE @string_variable AS USER = 'CompanyDomain\SqlUser1' échoue, car CompanyDomain\SqlUser1 n’existe pas en tant que principal de la base de données.

Meilleures pratiques

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. Par exemple, ne spécifiez pas de nom de connexion, qui dispose d’autorisations au niveau du serveur, si seules les autorisations au niveau de la base de données sont requises. Ou ne spécifiez pas de compte propriétaire de base de données, sauf si ces autorisations sont requises.

Autorisations

Les autorisations ne sont pas requises pour exécuter l’instruction EXECUTE. Toutefois, les autorisations sont requises sur les éléments sécurisables référencés dans la chaîne EXECUTE. Par exemple, si la chaîne contient une instruction INSERT, l’appelant de l’instruction EXECUTE doit avoir INSERT autorisation sur la table cible. Les autorisations sont vérifiées au moment où l’instruction EXECUTE est rencontrée, même si l’instruction EXECUTE est incluse dans un module.

EXECUTE autorisations d’un module par défaut au propriétaire du module, qui peut les transférer à d’autres utilisateurs. 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. Toutefois, si le même utilisateur possède le module appelant et le module appelé, EXECUTE vérification des autorisations n’est pas effectuée pour le deuxième module.

Si le module accède à d’autres objets de base de données, l’exécution réussit lorsque vous disposez d’une autorisation EXECUTE sur le module et que l’une des conditions suivantes est remplie :

Le module est marqué EXECUTE AS USER ou EXECUTE AS SELF, et le propriétaire du module dispose des autorisations correspondantes sur l’objet référencé. Pour plus d’informations sur l’emprunt d’identité dans un module, consultez clause EXECUTE AS.
Le module est marqué EXECUTE AS CALLERet vous disposez des autorisations correspondantes sur l’objet.
Le module est marqué EXECUTE AS <user_name>et <user_name> dispose des autorisations correspondantes sur l’objet.

Autorisations de basculement de contexte

Pour spécifier EXECUTE AS sur une connexion, l’appelant doit disposer d’autorisations IMPERSONATE sur le nom de connexion spécifié. Pour spécifier EXECUTE AS sur un utilisateur de base de données, l’appelant doit disposer d’autorisations IMPERSONATE sur le nom d’utilisateur spécifié. Quand aucun contexte d’exécution n’est spécifié ou EXECUTE AS CALLER est spécifié, IMPERSONATE autorisations ne sont pas requises.

Exemples : SQL Server

Les exemples de code Transact-SQL de cet article utilisent l’exemple de base de données AdventureWorks2022 ou AdventureWorksDW2022, que vous pouvez télécharger à partir de la page d’accueil Microsoft SQL Server Samples and Community Projects.

R. Utiliser EXECUTE pour passer un seul paramètre

La procédure stockée uspGetEmployeeManagers de la base de données AdventureWorks2022 attend un seul paramètre (@EmployeeID). Dans les exemples suivants, la procédure stockée uspGetEmployeeManagers est exécutée avec Employee ID 6 comme valeur de paramètre.

EXECUTE dbo.uspGetEmployeeManagers 6;
GO

La variable peut être désignée explicitement dans l'exécution :

EXECUTE dbo.uspGetEmployeeManagers @EmployeeID = 6;
GO

Si l’instruction suivante est la première instruction d’un lot ou d’un script sqlcmd, EXECUTE n’est pas nécessaire.

dbo.uspGetEmployeeManagers 6;
GO

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

B. Utiliser plusieurs paramètres

L’exemple suivant exécute la procédure stockée spGetWhereUsedProductID dans la base de données AdventureWorks2022. Il transmet deux paramètres : le premier paramètre est un ID de produit (819) et le deuxième paramètre @CheckDate est une valeur datetime.

DECLARE @CheckDate AS DATETIME;
SET @CheckDate = GETDATE();

EXECUTE dbo.uspGetWhereUsedProductID 819, @CheckDate;
GO

C. Utiliser EXECUTE 'tsql_string' avec une variable

Le code exemple suivant montre comment EXECUTE manipule les chaînes construites dynamiquement qui contiennent des 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 AdventureWorks2022, puis utilise cette liste pour reconstruire tous les index des tables.

DECLARE tables_cursor CURSOR
    FOR SELECT s.name, t.name FROM sys.objects AS t
    INNER JOIN sys.schemas AS s ON s.schema_id = t.schema_id
    WHERE t.type = 'U';

OPEN tables_cursor;

DECLARE @schemaname AS sysname;
DECLARE @tablename AS 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;

D. Utiliser EXECUTE avec une procédure stockée distante

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.

DECLARE @retstat AS INT;

EXECUTE
    @retstat = SQLSERVER1.AdventureWorks2022.dbo.uspGetEmployeeManagers
    @BusinessEntityID = 6;

E. Utiliser EXECUTE avec une variable de procédure stockée

Le code exemple suivant crée une variable qui représente le nom d'une procédure stockée.

DECLARE @proc_name AS VARCHAR (30);
SET @proc_name = 'sys.sp_who';

EXECUTE @proc_name;

F. Utiliser EXECUTE avec 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. 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. Notez les différentes façons d'utiliser le mot clé DEFAULT.

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.

-- 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. Utiliser EXECUTE avec AT linked_server_name

Le code exemple suivant passe une chaîne de commandes à un serveur distant. Il crée un serveur lié SeattleSales qui pointe vers une autre instance de SQL Server et exécute une instruction DDL (CREATE TABLE) sur ce serveur lié.

EXECUTE sp_addlinkedserver 'SeattleSales', 'SQL Server';
GO

EXECUTE ('CREATE TABLE AdventureWorks2022.dbo.SalesTbl
(SalesID INT, SalesName VARCHAR(10)); ') AT SeattleSales;
GO

H. Utiliser EXECUTE WITH RECOMPILE

L’exemple de code suivant exécute la procédure stockée Proc_Test_Defaults et impose la compilation, l’utilisation et la suppression d’un nouveau plan de requête après l’exécution du module.

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

I. Utiliser EXECUTE avec une fonction définie par l’utilisateur

L’exemple suivant exécute la fonction scalaire ufnGetSalesOrderStatusText définie par l’utilisateur dans la base de données AdventureWorks2022. Il utilise la variable @returnstatus pour stocker la valeur renvoyée par la fonction. Celle-ci attend un seul paramètre d'entrée, @Status, Le type de données tinyint est défini.

DECLARE @returnstatus AS NVARCHAR (15);
SET @returnstatus = NULL;

EXECUTE
    @returnstatus = dbo.ufnGetSalesOrderStatusText
    @Status = 2;

PRINT @returnstatus;
GO

J. Utiliser EXECUTE pour interroger une base de données Oracle sur un serveur lié

Le code exemple suivant exécute plusieurs instructions SELECT sur le serveur Oracle distant. Il commence par ajouter le serveur Oracle comme serveur lié puis crée ensuite la connexion au serveur lié.

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

EXECUTE sp_addlinkedsrvlogin
    @rmtsrvname = 'ORACLE',
    @useself = 'false',
    @locallogin = NULL,
    @rmtuser = 'scott',
    @rmtpassword = 'tiger';

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

-- Execute several statements on the linked Oracle server.
EXECUTE ('SELECT * FROM scott.emp') AT ORACLE;
GO

EXECUTE ('SELECT * FROM scott.emp WHERE MGR = ?', 7902) AT ORACLE;
GO

DECLARE @v AS INT;
SET @v = 7902;

EXECUTE ('SELECT * FROM scott.emp WHERE MGR = ?', @v) AT ORACLE;
GO

K. Utiliser EXECUTE AS USER pour basculer le contexte vers un autre utilisateur

Le code exemple suivant exécute une chaîne Transact-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. Le moteur de base de données vérifie les autorisations de User1 lors de l’exécution de l’instruction. 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.

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

L. Utiliser un paramètre avec EXECUTE et 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. Cet exemple crée un serveur lié SeattleSales qui pointe vers une autre instance de SQL Server et exécute une instruction SELECT sur ce serveur lié. 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.

-- Setup the linked server.
EXECUTE sp_addlinkedserver 'SeattleSales', 'SQL Server';
GO

-- Execute the SELECT statement.
EXECUTE ('SELECT ProductID, Name
    FROM AdventureWorks2022.Production.Product
    WHERE ProductID = ? ', 952) AT SeattleSales;
GO

M. Utiliser EXECUTE pour redéfinir un jeu de résultats unique

s’applique à: SQL Server 2012 (11.x) et versions ultérieures, et Azure SQL Database.

Certains exemples précédents ont exécuté EXECUTE dbo.uspGetEmployeeManagers 6; qui a retourné sept colonnes. 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é.

EXECUTE 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. Utiliser EXECUTE pour redéfinir deux jeux de résultats

s’applique à: SQL Server 2012 (11.x) et versions ultérieures, et Azure SQL Database.

Lorsque vous exécutez une instruction qui retourne plusieurs jeux de résultats, définissez chaque jeu de résultats attendu. L'exemple suivant dans AdventureWorks2022 crée une procédure qui retourne deux jeux de résultats. Ensuite, la procédure est exécutée à l’aide de la clause WITH RESULT SETS et en spécifiant deux définitions de jeu de résultats.

--Create the procedure
CREATE PROCEDURE 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
    INNER JOIN Sales.SalesOrderDetail AS S
        ON P.ProductID = S.ProductID
WHERE Name LIKE @ProdName
GROUP BY Name;
GO

-- Execute the procedure
EXECUTE Production.ProductList '%tire%' WITH RESULT SETS
(
    -- first result set definition starts here
    (ProductID INT,
    [Name] NAME,
    ListPrice MONEY)
    -- comma separates result set definitions
    ,
    -- second result set definition starts here
    ([Name] NAME,
    NumberOfOrders INT)
);

O. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger un serveur SQL Server distant

s’applique à: SQL Server 2019 (15.x) et versions ultérieures.

L’exemple suivant passe une chaîne de commande à une source de données externe pointant vers une instance de SQL Server.

EXECUTE ( 'SELECT @@SERVERNAME' ) AT DATA_SOURCE my_sql_server;
GO

P. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de calcul dans un cluster Big Data SQL Server

s’applique à: SQL Server 2019 (15.x).

L’exemple suivant passe une chaîne de commande à une source de données externe pointant vers un pool de calcul dans SQL Server Cluster Big Data. L’exemple crée une source de données SqlComputePool par rapport à un pool de calcul dans SQL Server Cluster Big Data et exécute une instruction SELECT sur la source de données.

CREATE EXTERNAL DATA SOURCE SqlComputePool
WITH (LOCATION = 'sqlcomputepool://controller-svc/default');

EXECUTE ('SELECT @@SERVERNAME') AT DATA_SOURCE SqlComputePool;
GO

Q. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de données dans un cluster Big Data SQL Server

s’applique à: SQL Server 2019 (15.x).

L’exemple suivant transmet une chaîne de commande à une source de données externe pointant vers un pool de calcul dans le cluster Big Data SQL Server (BDC). L’exemple crée une source de données SqlDataPool sur un pool de données dans BDC et exécute une instruction SELECT sur la source de données.

CREATE EXTERNAL DATA SOURCE SqlDataPool
WITH (LOCATION = 'sqldatapool://controller-svc/default');

EXECUTE ('SELECT @@SERVERNAME') AT DATA_SOURCE SqlDataPool;
GO

R. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de stockage dans un cluster Big Data SQL Server

s’applique à: SQL Server 2019 (15.x).

L’exemple suivant passe une chaîne de commande à une source de données externe pointant vers un pool de calcul dans SQL Server Cluster Big Data. L’exemple crée une source de données SqlStoragePool par rapport à un pool de calcul dans SQL Server Cluster Big Data et exécute une instruction SELECT sur la source de données.

CREATE EXTERNAL DATA SOURCE SqlStoragePool
WITH (LOCATION = 'sqlhdfs://controller-svc/default');

EXECUTE ('SELECT @@SERVERNAME') AT DATA_SOURCE SqlStoragePool;
GO

Exemples : Azure Synapse Analytics

R : Exécution de procédure de base

Exécutez une procédure stockée :

EXECUTE proc1;

Appelez une procédure stockée avec le nom déterminé au moment de l’exécution :

EXECUTE ('EXECUTE ' + @var);

Appelez une procédure stockée à partir d’une procédure stockée :

CREATE sp_first AS EXECUTE sp_second; EXECUTE sp_third;

B : Exécuter des chaînes

Exécutez une chaîne SQL :

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

Exécutez une chaîne imbriquée :

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

Exécutez une variable de chaîne :

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

EXECUTE (@stringVar);

C : Procédures avec des paramètres

L’exemple suivant crée une procédure avec des paramètres et montre trois façons d’exécuter la procédure :

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

Exécutez à l’aide de paramètres positionnels :

EXECUTE ProcWithParameters N'%arm%', N'Black';

Exécutez à l’aide de paramètres nommés dans l’ordre :

EXECUTE ProcWithParameters
    @name = N'%arm%',
    @color = N'Black';

Exécutez à l’aide de paramètres nommés hors de l’ordre :

EXECUTE ProcWithParameters
    @color = N'Black',
    @name = N'%arm%';
GO

Partager via

EXECUTE (Transact-SQL)

Syntaxe

Arguments

@return_status

module_name

;number

@module_name_var

@parameter

value

@variable

OUTPUT

DEFAULT

@string_variable

[N]'tsql_string'

AS context_specification

Connexion

Utilisateur

'name'

[N]'command_string'

[?]

AT linked_server_name

AT DATA_SOURCE data_source_name

Notes

Utiliser EXECUTE avec des procédures stockées

Utiliser EXECUTE avec une chaîne de caractères

Changement de contexte

Spécifier un nom d’utilisateur ou de connexion

Meilleures pratiques

Autorisations

Autorisations de basculement de contexte

Exemples : SQL Server

R. Utiliser EXECUTE pour passer un seul paramètre

B. Utiliser plusieurs paramètres

C. Utiliser EXECUTE 'tsql_string' avec une variable

D. Utiliser EXECUTE avec une procédure stockée distante

E. Utiliser EXECUTE avec une variable de procédure stockée

F. Utiliser EXECUTE avec DEFAULT

G. Utiliser EXECUTE avec AT linked_server_name

H. Utiliser EXECUTE WITH RECOMPILE

I. Utiliser EXECUTE avec une fonction définie par l’utilisateur

J. Utiliser EXECUTE pour interroger une base de données Oracle sur un serveur lié

K. Utiliser EXECUTE AS USER pour basculer le contexte vers un autre utilisateur

L. Utiliser un paramètre avec EXECUTE et AT linked_server_name

M. Utiliser EXECUTE pour redéfinir un jeu de résultats unique

N. Utiliser EXECUTE pour redéfinir deux jeux de résultats

O. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger un serveur SQL Server distant

P. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de calcul dans un cluster Big Data SQL Server

Q. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de données dans un cluster Big Data SQL Server

R. Utiliser EXECUTE avec AT DATA_SOURCE data_source_name pour interroger le pool de stockage dans un cluster Big Data SQL Server

Exemples : Azure Synapse Analytics

R : Exécution de procédure de base

B : Exécuter des chaînes

C : Procédures avec des paramètres

Contenu connexe

Commentaires

Ressources supplémentaires