EXECUTE (Transact-SQL)

Aplica-se a: simSQL Server (todas as versões compatíveis) SimBanco de Dados SQL do Azure SimInstância Gerenciada do Azure SQL simAzure Synapse Analytics simParallel Data Warehouse

Executa uma cadeia de caracteres de comando, uma cadeia de caracteres em um lote Transact-SQL ou um dos seguintes módulos: procedimento armazenado do sistema, procedimento armazenado definido pelo usuário, procedimento armazenado CLR, função de valor escalar definida pelo usuário ou procedimento armazenado estendido. A instrução EXECUTE pode ser usada para enviar comandos de passagem aos servidores vinculados. Além disso, o contexto no qual uma cadeia de caracteres ou comando é executado pode ser definido explicitamente. É possível definir metadados para o conjunto de resultados usando as opções do WITH RESULT SETS.

Importante

Antes de chamar EXECUTE com uma cadeia de caracteres, valide a cadeia de caracteres. Nunca execute um comando construído por uma entrada de usuário que não foi validada.

Ícone de link do tópico Convenções da sintaxe Transact-SQL

Sintaxe

O bloco de código a seguir mostra a sintaxe no SQL Server 2019. Como alternativa, em vez disso, confira a sintaxe no SQL Server 2017 e versões anteriores.

-- Syntax for SQL Server 2019

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   
}  

O bloco de código a seguir mostra a sintaxe no SQL Server 2017 e versões anteriores. Como alternativa, em vez disso, confira a sintaxe no SQL Server 2019.

-- Syntax for SQL Server 2017 and earleir  

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 Synapse Analytics 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 ] )  
[;]  

Observação

Para ver a sintaxe do Transact-SQL para o SQL Server 2014 e versões anteriores, confira a Documentação das versões anteriores.

Argumentos

@return_status
É uma variável de inteiro opcional que armazena o status de retorno de um módulo. Essa variável deve ser declarada no lote, procedimento armazenado ou função para ser usada antes em uma instrução EXECUTE.

Quando usada para invocar uma função definida pelo usuário com valor escalar, a variável @return_status pode ser de qualquer tipo de dados escalar.

module_name
É o nome totalmente qualificado do procedimento armazenado ou do valor escalar da função a ser chamada, definida pelo usuário. Os nomes de módulos devem obedecer às regras de identificadores. Os nomes de procedimentos armazenados estendidos sempre têm diferenciação entre maiúsculas e minúsculas, independentemente da ordenação do servidor.

Um módulo que tenha sido criado em outro banco de dados poderá ser executado se o usuário que estiver executando o módulo for o proprietário ou se tiver permissão apropriada para executá-lo no referido banco de dados. Um módulo poderá ser executado em outro servidor que executa SQL Server se o usuário que estiver executando o módulo tiver a permissão apropriada para usar esse servidor (acesso remoto) e executar o módulo no referido banco de dados. Se você especificar um nome de servidor mas não especificar um nome de banco de dados, o Mecanismo de Banco de Dados do SQL Server procurará o módulo no banco de dados padrão do usuário.

;number
Aplica-se a: SQL Server 2008 e posterior

É um inteiro opcional usado para agrupar procedimentos do mesmo nome. Esse parâmetro não é usado para procedimentos armazenados estendidos.

Observação

Esse recurso será removido em uma versão futura do Microsoft SQL Server. Evite usar esse recurso em desenvolvimentos novos e planeje modificar os aplicativos que atualmente o utilizam.

Para obter mais informações sobre grupos de procedimentos, consulte CREATE PROCEDURE (Transact-SQL).

@module_name_var
É o nome de uma variável localmente definida que representa um nome de módulo.

Isso pode ser uma variável que contém o nome de uma função escalar definida pelo usuário compilada nativamente.

@parameter
É o parâmetro do module_name, conforme definido no módulo. Os nomes de parâmetro devem ser precedidos pelo sinal de arroba (@). Quando usados com o formato @parameter_name=value, os nomes de parâmetro e constantes não precisam ser fornecidos na ordem em que são definidos no módulo. Porém, se o formato @parameter_name=value for usado para um parâmetro, ele deverá ser usado para todos os parâmetros seguintes.

Por padrão, os parâmetros são anuláveis.

value
É o valor do parâmetro a ser informado ao módulo ou comando de passagem. Se não forem especificados nomes de parâmetro, os valores de parâmetro deverão ser fornecidos na ordem definida no módulo.

Na execução dos comandos de passagem em servidores vinculados, a ordem dos valores de parâmetro dependerá do provedor OLE DB do servidor vinculado. A maioria dos provedores OLE DB associa valores para os parâmetros da esquerda para a direita.

Se o valor de um parâmetro for o nome de um objeto, cadeia de caracteres ou qualificado por um nome de esquema ou nome de banco de dados, o nome todo deverá ficar dentro de aspas simples. Se o valor de um parâmetro for uma palavra-chave, a palavra-chave deverá ficar dentro de aspas duplas.

Se você passar uma única palavra que não começa com @ e que não está entre aspas, por exemplo, se você esquecer @ em um nome de parâmetro, a palavra será tratada como uma cadeia de caracteres nvarchar, apesar das aspas ausentes.

Se um padrão estiver definido no módulo, um usuário poderá executar o módulo sem especificar um parâmetro.

O padrão também pode ser NULL. Geralmente, a definição de módulo especificará a ação a ser tomada se um valor de parâmetro for NULL.

@variable
É a variável que armazena um parâmetro ou um parâmetro de retorno.

OUTPUT
Especifica que o módulo ou a cadeia de caracteres de comando deve retornar um parâmetro. O parâmetro correspondente no módulo ou na cadeia de caracteres de comando também deve ter sido criado com o uso da palavra-chave OUTPUT. Use essa palavra-chave quando você usar variáveis de cursor como parâmetros.

Se value for definido como OUTPUT de um módulo executado em um servidor vinculado, as alterações feitas no @parameter correspondente pelo Provedor OLE DB serão copiadas novamente para a variável no final da execução do módulo.

Se os parâmetros OUTPUT estiverem sendo usados e a intenção for usar os valores retornados em outras instruções no lote ou módulo de chamada, o valor do parâmetro deverá ser passado como uma variável, como @parameter = @variable. Não é possível executar um módulo especificando OUTPUT para um parâmetro que não esteja definido como OUTPUT no módulo. Não é possível passar constantes ao módulo usando OUTPUT; o parâmetro de retorno requer um nome de variável. O tipo de dados da variável deve ser declarado e ter um valor atribuído antes da execução do procedimento.

Quando EXECUTE é usado em um procedimento armazenado remoto ou para executar um comando de passagem em um servidor vinculado, os parâmetros OUTPUT não podem ser nenhum dos tipos de dados LOB (objeto grande).

Os parâmetros de retorno podem ser de qualquer tipo de dados, exceto os tipos de dados LOB.

DEFAULT
Fornece o valor padrão do parâmetro como definido no módulo. Quando o módulo esperar um valor para um parâmetro que não tem um padrão definido e houver um parâmetro ausente ou a palavra-chave DEFAULT estiver especificada, ocorrerá um erro.

@string_variable
É o nome de uma variável local. @string_variable pode ser qualquer tipo de dados char, varchar, nchar ou nvarchar. Incluem os tipos de dados (max) .

[N] 'tsql_string'
É uma cadeia de caracteres constante. tsql_string pode ser qualquer tipo de dados nvarchar ou varchar. Se N for incluído, a cadeia de caracteres será interpretada como o tipo de dados nvarchar.

AS <context_specification>
Especifica o contexto no qual a instrução é executada.

LOGIN
Aplica-se a: SQL Server 2008 e posterior

Especifica que o contexto para ser representado é um logon. O escopo de personificação é o servidor.

USER
Especifica que o contexto a ser representado é um usuário no banco de dados atual. O escopo de representação é restrito ao banco de dados atual. Uma opção de contexto para um usuário de banco de dados não herda as permissões em nível de servidor desse usuário.

Importante

Enquanto a opção de contexto para o usuário do banco de dados estiver ativa, qualquer tentativa de acessar os recursos fora do banco de dados causará a falha da instrução. Isso inclui instruções USE database, consultas distribuídas e consultas que referenciam outro banco de dados usando identificadores de três ou quatro partes.

'name'
É um usuário ou nome de logon válido. name deve ser membro da função de servidor fixa sysadmin ou existir como uma entidade de segurança em sys.database_principals ou sys.server_principals, respectivamente.

name não pode ser uma conta interna, como NT AUTHORITY\LocalService, NT AUTHORITY\NetworkService ou NT AUTHORITY\LocalSystem.

Para obter mais informações, consulte Especificando um nome de logon ou usuário mais adiante neste tópico.

[N] 'command_string'
É uma cadeia de caracteres constante que contém o comando a ser passado ao servidor vinculado. Se N for incluído, a cadeia de caracteres será interpretada como o tipo de dados nvarchar.

[?]
Indica parâmetros para os quais valores são fornecidos na <arg-list> de comandos de passagem usados em uma instrução EXEC('...', <arg-list>) AT <linkedsrv>.

AT linked_server_name
Aplica-se a: SQL Server 2008 e posterior

Especifica que command_string é executada em linked_server_name e os resultados, se houver, são retornados ao cliente. linked_server_name deve referenciar uma definição de servidor vinculado existente no servidor local. Os servidores vinculados são definidos por meio de sp_addlinkedserver.

WITH <execute_option>
Opções de execução possíveis. As opções de RESULT SETS não podem ser especificadas em uma instrução INSERT...EXEC.

AT DATA_SOURCE data_source_name Aplica-se a: SQL Server 2019 (15.x) e posterior

Especifica que a command_string é executada no data_source_name e os resultados, se houver, são retornados ao cliente. data_source_name deve se referir a uma definição de EXTERNAL DATA SOURCE no banco de dados. Somente as fontes de dados que apontam para o SQL Server são compatíveis. Além disso, para as fonte de dados de cluster de Big Data do SQL Server que apontam para pool de computação, o pool de dados ou o pool de armazenamento são compatíveis. As fontes de dados são definidas usando CREATE EXTERNAL DATA SOURCE.

WITH <execute_option>
Opções de execução possíveis. As opções de RESULT SETS não podem ser especificadas em uma instrução INSERT...EXEC.

Termo Definição
RECOMPILE Força a compilação, a utilização e o descarte de um novo plano após a execução do módulo. Se houver um plano de consulta existente para o módulo, esse plano permanecerá no cache.

Use essa opção se o parâmetro sendo fornecido for atípico ou se os dados tiverem sido alterados significativamente. Ela não é usada para procedimentos armazenados estendidos. É aconselhável usar essa opção se realmente for necessário porque ela é expansiva.

Observação: Não é possível usar WITH RECOMPILE ao chamar um procedimento armazenado que usa a sintaxe OPENDATASOURCE. A opção WITH RECOMPILE será ignorada quando um nome de objeto de quatro partes for especificado.

Observação: RECOMPILE não é compatível com funções escalares definidas pelo usuário compiladas nativamente. Se precisar recompilar, use sp_recompile (Transact-SQL).
RESULT SETS UNDEFINED Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure.

Esta opção não fornece nenhuma garantia de quais resultados, se houver, serão retornados. Além disso, não é fornecida nenhuma definição. A instrução é executada sem erro se algum resultado for retornado ou se nenhum resultado for retornado. RESULT SETS UNDEFINED será o comportamento padrão se não for fornecido result_sets_option.

Para funções escalares interpretadas definidas pelo usuário e funções escalares compiladas nativamente definidas pelo usuário, essa opção não funciona porque as funções nunca retornam um conjunto de resultados.
RESULT SETS NONE Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure.

Garante que a instrução execute não retornará nenhum resultado. Se algum resultado for retornado, o lote será anulado.

Para funções escalares interpretadas definidas pelo usuário e funções escalares compiladas nativamente definidas pelo usuário, essa opção não funciona porque as funções nunca retornam um conjunto de resultados.
<result_sets_definition> Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure.

Fornece uma garantia de que o resultado voltará como especificado em result_sets_definition. Para instruções que retornam vários conjuntos de resultados, forneça várias seções de result_sets_definition. Coloque cada result_sets_definition entre parênteses, separada por vírgulas. Para obter mais informações, confira <result_sets_definition> mais adiante neste tópico.

Essa opção sempre resulta em um erro para funções escalares definidas pelo usuário compiladas nativamente, porque as funções não retornam um conjunto de resultados.

<result_sets_definition> Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure

Descreve os conjuntos de resultados retornados pelas instruções executadas. As cláusulas de result_sets_definition têm o seguinte significado

Termo Definição
{

column_name

data_type

[ COLLATE collation_name]

[NULL | NOT NULL]

}
Veja a tabela abaixo.
db_name O nome do banco de dados que contém a tabela, a exibição ou a função com valor de tabela.
schema_name O nome do esquema proprietário da tabela, da exibição ou da função com valor de tabela.
table_name | view_name | table_valued_function_name Especifica que as colunas retornadas serão as especificadas na tabela, exibição ou função com valor de tabela nomeada. Não há suporte para variáveis de tabela, tabelas temporárias e sinônimos na sintaxe de objetos do AS.
AS TYPE [schema_name.]table_type_name Especifica que as colunas retornadas serão as especificadas no tipo de tabela.
AS FOR XML Especifica que os resultados XML da instrução ou procedimento armazenado chamado pela instrução EXECUTE serão convertidos no formato como se fossem gerados por uma instrução SELECT ... FOR XML ... Toda a formatação das políticas do tipo na instrução original é removida, e os resultados são retornados como se nenhuma política do tipo fosse especificada. AS FOR XML não converte em XML os resultados de tabela não XML da instrução executada ou do procedimento armazenado.
Termo Definição
column_name Os nomes de cada coluna. Se o número de colunas for diferente do conjunto de resultados, ocorrerá um erro e o lote será anulado. Se o nome de uma coluna for diferente do conjunto de resultados, o nome de coluna retornado será definido como o nome definido.
data_type Os tipos de dados de cada coluna. Se os tipos de dados forem diferentes, será executada uma conversão implícita para o tipo de dados definido. Se a conversão falhar, o lote será anulado
COLLATE collation_name A ordenação de cada coluna. Se houver uma incompatibilidade de ordenação, será tentada uma ordenação implícita. Se isso falhar, o lote será anulado.
NULL | NOT NULL A nulidade de cada coluna. Se a nulidade definida for NOT NULL e os dados retornados contiver NULLs, ocorrerá um erro e o lote será anulado. Se não especificado, o valor padrão se conforma à configuração das opções do ANSI_NULL_DFLT_ON e ANSI_NULL_DFLT_OFF.

O conjunto de resultados real retornado durante execução pode diferir do resultado definido usando a cláusula WITH RESULT SETS de uma das seguintes maneiras: número de conjuntos de resultados, número de colunas, nome de coluna, nulidade e tipo de dados. Se o número de conjuntos de resultados for diferente, ocorrerá um erro e o lote será anulado.

Comentários

Os parâmetros podem ser fornecidos com value ou @parameter_name=value. . Um parâmetro não faz parte de uma transação; portanto, se um parâmetro for alterado em uma transação que for posteriormente revertida, o parâmetro não será revertido para seu valor anterior. O valor retornado ao chamador será sempre o valor no momento do retorno do módulo.

O aninhamento ocorre quando um módulo chama outro ou executa código gerenciado, fazendo referência a um módulo CLR (Common Language Runtime) a um tipo definido pelo usuário ou agregação. O nível de aninhamento é aumentado quando o módulo chamado ou a referência de código gerenciado inicia a execução e diminuído quando ela termina. Exceder o máximo de 32 níveis de aninhamento faz com que toda a cadeia de chamada falhe. O nível de aninhamento atual é armazenado na função do sistema @@NESTLEVEL.

Como os procedimentos armazenados remotos e estendidos não estão no escopo de uma transação (a menos que emitidos em uma instrução BEGIN DISTRIBUTED TRANSACTION ou quando usados com várias opções de configuração), os comandos executados por meio de chamadas a eles não poderão ser revertidos. Para obter mais informações, consulte Procedimentos armazenados do sistema (Transact-SQL) e BEGIN DISTRIBUTED TRANSACTION (Transact-SQL).

Ao utilizar variáveis de cursor, se você executar um procedimento que passe em uma variável de cursor com um cursor alocado a ele, ocorrerá um erro.

Não é necessário especificar a palavra-chave EXECUTE durante a execução de módulos se a instrução for a primeira em um lote.

Para obter informações adicionais específicas de procedimentos armazenados CLR, consulte Procedimentos armazenados CLR.

Usando EXECUTE com procedimentos armazenados

Não será preciso especificar a palavra-chave EXECUTE durante a execução de procedimentos armazenados quando a instrução for a primeira em um lote.

Procedimentos armazenados do sistema SQL Server iniciam com os caracteres sp_. Eles estão fisicamente armazenados no banco de dados Resource, mas são exibidos logicamente no esquema sys de cada sistema e banco de dados definido pelo usuário. Quando você executa um procedimento armazenado de sistema, em um lote ou dentro de um módulo, como a função ou o procedimento armazenado definido pelo usuário, recomendamos qualificar o nome do procedimento armazenado com o nome do esquema sys.

Os procedimentos armazenados estendidos de sistema SQL Server iniciam com os caracteres xp_ e estão contidos no esquema dbo do banco de dados mestre. Quando você executa um procedimento armazenado estendido de sistema, em um lote ou dentro de um módulo, como a função ou o procedimento armazenado definido pelo usuário, recomendamos qualificar o nome do procedimento armazenado com master.dbo.

Quando você executa um procedimento definido pelo usuário, em um lote ou dentro de um módulo, como a função ou o procedimento armazenado definido pelo usuário, recomendamos qualificar o nome do procedimento armazenado com um nome de esquema. Não recomendamos nomear um procedimento armazenado definido pelo usuário com o mesmo nome de uma procedimento armazenado no sistema. Para obter mais informações sobre a execução de procedimentos armazenados, consulte Executar um procedimento armazenado.

Usando EXECUTE com uma cadeia de caracteres

Em versões anteriores de SQL Server, as cadeias de caracteres estão limitadas a 8.000 bytes. Isso requer a concatenação de cadeias de caracteres grandes para execução dinâmica. No SQL Server, os tipos de dados varchar(max) e nvarchar(max) podem ser especificados para permitir que as cadeias de caracteres tenham até 2 gigabytes de dados.

As alterações no contexto de banco de dados duram apenas até o fim da instrução EXECUTE. Por exemplo, depois que EXEC na instrução seguinte é executado, o contexto de banco de dados se torna o mestre.

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

Alternância de contexto

Você pode usar a cláusula AS { LOGIN | USER } = ' name ' para alternar o contexto de execução de uma instrução dinâmica. Quando a alternância de contexto for especificada como EXECUTE ('string') AS <context_specification>, a duração dessa alternância estará limitada ao escopo da consulta sendo executada.

Especificando um nome de logon ou usuário

O nome de logon ou de usuário especificado em AS { LOGIN | USER } = ' name ' deve existir como principal em sys.database_principals ou sys.server_principals, respectivamente, ou a instrução falhará. Além disso, as permissões IMPERSONATE devem ser concedidas na entidade de segurança. A menos que o chamador seja o proprietário do banco de dados ou membro da função de servidor fixa sysadmin, o principal deverá existir quando o usuário estiver acessando o banco de dados ou a instância de SQL Server por meio de uma associação de grupo do Windows. Por exemplo, considere as seguintes condições:

  • O grupo CompanyDomain\SQLUsers tem acesso ao banco de dados de vendas.

  • CompanyDomain\SqlUser1 é membro de SQLUsers e, por isso, tem acesso implícito ao banco de dados de vendas.

Embora CompanyDomain\SqlUser1 tenha acesso ao banco de dados por meio da associação ao grupo SQLUsers, a instrução EXECUTE @string_variable AS USER = 'CompanyDomain\SqlUser1' falhará porque CompanyDomain\SqlUser1 não existe como uma entidade de segurança no banco de dados.

Práticas Recomendadas

Especifique um logon ou um usuário que tenha os privilégios mínimos necessários para executar as operações definidas na instrução ou módulo. Por exemplo, não especifique um nome de logon que tenha permissões em nível de servidor se apenas as permissões em nível de banco de dados forem necessárias; ou não especifique uma conta de proprietário de banco de dados, a menos que essas permissões sejam solicitadas.

Permissões

Não são solicitadas permissões para executar a instrução EXECUTE. Porém, são solicitadas permissões nos protegíveis mencionados na cadeia de caracteres EXECUTE. Por exemplo, se a cadeia de caracteres tiver uma instrução INSERT, o chamador da instrução EXECUTE deverá ter a permissão INSERT na tabela de destino. As permissões são verificadas quando a instrução EXECUTE for encontrada, mesmo se ela estiver incluída em um módulo.

As permissões EXECUTE de um padrão de módulo para o proprietário do módulo, que pode transferi-las a outros usuários. Quando um módulo que executa uma cadeia de caracteres é executado, as permissões são verificadas no contexto do usuário que executa o módulo e não no contexto do usuário que o criou. Entretanto, se o mesmo usuário for proprietário do módulo chamador e do módulo sendo chamado, a verificação da permissão EXECUTE não será feita para o segundo módulo.

Se o módulo acessar outros objetos de banco de dados, a execução ocorrerá quando a permissão EXECUTE estiver no módulo e uma das seguintes condições for verdadeira:

  • O módulo está marcado como EXECUTE AS USER ou SELF, e o seu proprietário tem as permissões correspondentes no objeto mencionado. Para obter mais informações sobre a representação dentro de um módulo, consulte Cláusula EXECUTE AS (Transact-SQL).

  • O módulo está marcado como EXECUTE AS CALLER e você tem as permissões correspondentes no objeto.

  • O módulo está marcado como EXECUTE AS user_name, e user_name tem as permissões correspondentes no objeto.

Permissões de alternância de contexto

Para especificar EXECUTE AS em um logon, o chamador precisa ter permissões IMPERSONATE no nome de logon especificado. Para especificar EXECUTE AS em um usuário de banco de dados, o chamador precisa ter permissões IMPERSONATE no nome de usuário especificado. Quando nenhum contexto de execução é especificado ou EXECUTE AS CALLER é especificado, as permissões de IMPERSONATE não são solicitadas.

Exemplos: SQL Server

a. Usando EXECUTE para passar um único parâmetro

O procedimento armazenado uspGetEmployeeManagers no banco de dados AdventureWorks2012 espera um parâmetro (@EmployeeID). Os exemplos a seguir executam o procedimento armazenado uspGetEmployeeManagers com Employee ID 6 como seu valor de parâmetro.

EXEC dbo.uspGetEmployeeManagers 6;  
GO  

A variável pode ser nomeada explicitamente na execução:

EXEC dbo.uspGetEmployeeManagers @EmployeeID = 6;  
GO  

Se o exemplo a seguir for a primeira instrução de um lote ou em um script osql ou sqlcmd, EXEC não será obrigatório.

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

B. Usando vários parâmetros

O exemplo a seguir executa o procedimento armazenado spGetWhereUsedProductID no banco de dados AdventureWorks2012. Ele passa dois parâmetros: o primeiro é uma identificação de produto (819) e o segundo @CheckDate, é um valor datetime.

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

C. Usando EXECUTE 'tsql_string' com uma variável

O exemplo seguinte mostra como EXECUTE controla dinamicamente as cadeias de caracteres criadas que contêm variáveis. Esse exemplo cria o cursor tables_cursor para manter uma lista de todas as tabelas definidas pelo usuário no banco de dados AdventureWorks2012 e, depois, usa essa lista para criar novamente todos os índices nas tabelas.

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. Usando EXECUTE com um procedimento armazenado remoto

O exemplo a seguir executa o procedimento uspGetEmployeeManagers armazenado no servidor remoto SQLSERVER1 e armazena o status de retorno que indica o êxito ou a falha em @retstat.

Aplica-se a: SQL Server 2008 e posterior

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

E. Usando EXECUTE com uma variável de procedimento armazenado

O exemplo seguinte cria uma variável que representa um nome de procedimento armazenado.

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

F. Usando EXECUTE com DEFAULT

O exemplo seguinte cria um procedimento armazenado com valores padrão para o primeiro e terceiro parâmetros. Quando o procedimento é executado, esses padrões serão inseridos para o primeiro e terceiro parâmetros quando nenhum valor for informado na chamada ou quando o padrão for especificado. Observe os vários modos que a palavra-chave DEFAULT pode ser usada.

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  

O procedimento armazenado Proc_Test_Defaults pode ser executado em muitas combinações.

-- 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. Usando EXECUTE com AT linked_server_name

O exemplo seguinte envia uma cadeia de caracteres de comando a um servidor remoto. Ele cria um servidor vinculado SeattleSales que aponta para outra instância de SQL Server e executa uma instrução DDL (CREATE TABLE) nesse servidor vinculado.

Aplica-se a: SQL Server 2008 e posterior

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

H. Usando EXECUTE WITH RECOMPILE

O exemplo a seguir executa o procedimento armazenado Proc_Test_Defaults e força a compilação, o uso e o descarte de um novo plano de consulta após a execução do módulo.

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

I. Usando EXECUTE com uma função definida pelo usuário

O exemplo a seguir executa a função escalar definida pelo usuário ufnGetSalesOrderStatusText no banco de dados AdventureWorks2012. É utilizada a variável @returnstatus para armazenar o valor retornado pela função. A função espera um parâmetro de entrada, @Status. Isso é definido como um tipo de dados tinyint.

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

J. Usando EXECUTE para consultar um banco de dados Oracle em um servidor vinculado

O exemplo a seguir executa várias instruções SELECT no servidor remoto Oracle. O exemplo começa adicionando o servidor Oracle como um servidor vinculado e criando o logon de servidor vinculado.

Aplica-se a: SQL Server 2008 e posterior

-- 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. Usando EXECUTE AS USER para alternar o contexto para outro usuário

O exemplo a seguir executa uma cadeia de caracteres Transact-SQL que cria uma tabela e especifica a cláusula AS USER para alternar o contexto de execução da instrução do chamador para User1. O Mecanismo de Banco de Dados verificará as permissões de User1 quando a instrução for executada. User1 deve existir como um usuário no banco de dados e deve ter permissão para criar tabelas no esquema Sales, caso contrário, haverá falha na instrução.

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

L. Usando um parâmetro com EXECUTE e AT linked_server_name

O exemplo a seguir envia uma cadeia de caracteres de comando a um servidor remoto usando um ponto de interrogação (?) como espaço reservado de um parâmetro. O exemplo cria um servidor vinculado SeattleSales que aponta para outra instância de SQL Server e executa uma instrução SELECT nesse servidor vinculado. A instrução SELECT usa o ponto de interrogação como um espaço reservado para o parâmetro ProductID (952), fornecido após a instrução.

Aplica-se a: SQL Server 2008 e posterior

-- 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. Usando EXECUTE para redefinir um único conjunto de resultados

Alguns dos exemplos anteriores executaram EXEC dbo.uspGetEmployeeManagers 6; que retornou 7 colunas. O exemplo a seguir demonstra o uso da sintaxe WITH RESULT SET para alterar os nomes e tipos de dados do conjunto de resultados retornado.

Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure

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. Usando EXECUTE para redefinir dois conjuntos de resultados

Ao executar uma instrução que retorna mais de um conjunto de resultados, defina cada conjunto de resultados esperado. O exemplo a seguir em AdventureWorks2012 cria um procedimento armazenado que retorna dois conjuntos de resultados. Em seguida, o procedimento é executado com a cláusula WITH RESULT SETS e com a especificação definições de dois conjuntos de resultados.

Aplica-se a: SQL Server 2012 (11.x) e posterior, Banco de Dados SQL do Azure

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

O. Usando EXECUTE com AT DATA_SOURCE data_source_name para consultar um SQL Server remoto

O exemplo a seguir passa uma cadeia de caracteres de comando para uma fonte de dados externa apontando para uma Instância do SQL Server.

Aplica-se a: SQL Server 2019 (15.x) e posterior

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

P. Usando EXECUTE com AT DATA_SOURCE data_source_name para consultar um pool de computação no Cluster de Big Data do SQL Server

O exemplo a seguir passa uma cadeia de caracteres de comando para uma fonte de dados externa apontando para um pool de computação no Cluster de Big Data do SQL Server. O exemplo cria uma fonte de dados SqlComputePool em um pool de computação no Cluster de Big Data do SQL Server e executa uma instrução SELECT na fonte de dados.

Aplica-se a: SQL Server 2019 (15.x) e posterior

CREATE EXTERNAL DATA SOURCE SqlComputePool 
WITH (LOCATION = 'sqlcomputepool://controller-svc/default');
EXECUTE ( 'SELECT @@SERVERNAME' ) AT DATA_SOURCE SqlComputePool;  
GO  

Q. Usando EXECUTE com AT DATA_SOURCE data_source_name para consultar um pool de dados no Cluster de Big Data do SQL Server

O exemplo a seguir passa uma cadeia de caracteres de comando para uma fonte de dados externa apontando para um pool de computação no cluster de Big Data do SQL Server. O exemplo cria uma fonte de dados SqlDataPool em um pool de dados no cluster de Big Data do SQL Server e executa uma instrução SELECT na fonte de dados.

Aplica-se a: SQL Server 2019 (15.x) e posterior

CREATE EXTERNAL DATA SOURCE SqlDataPool 
WITH (LOCATION = 'sqldatapool://controller-svc/default');
EXECUTE ( 'SELECT @@SERVERNAME' ) AT DATA_SOURCE SqlDataPool;  
GO  

R. Usando EXECUTE com AT DATA_SOURCE data_source_name para consultar um pool de armazenamento no Cluster de Big Data do SQL Server

O exemplo a seguir passa uma cadeia de caracteres de comando para uma fonte de dados externa apontando para um pool de computação no Cluster de Big Data do SQL Server. O exemplo cria uma fonte de dados SqlStoragePool em um pool de dados no Cluster de Big Data do SQL Server e executa uma instrução SELECT na fonte de dados.

Aplica-se a: SQL Server 2019 (15.x) e posterior

CREATE EXTERNAL DATA SOURCE SqlStoragePool
WITH (LOCATION = 'sqlhdfs://controller-svc/default');
EXECUTE ( 'SELECT @@SERVERNAME' ) AT DATA_SOURCE SqlStoragePool;  
GO  

Exemplos: Azure Synapse Analytics

A: Execução de procedimento armazenado

Executando um procedimento armazenado:

EXEC proc1;  

Chamando um procedimento armazenado com um nome determinado em runtime:

EXEC ('EXEC ' + @var);  

Chamando um procedimento armazenado em um procedimento armazenado:

CREATE sp_first AS EXEC sp_second; EXEC sp_third;  

B: Como executar cadeias de caracteres

Executando uma cadeia de caracteres SQL:

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

Executando uma cadeia de caracteres aninhada:

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

Executando uma variável de cadeia de caracteres:

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

C: Procedimentos com parâmetros

O seguinte exemplo cria um procedimento com parâmetros e demonstra três maneiras de executar o procedimento:

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

Consulte Também

@@NESTLEVEL (Transact-SQL)
DECLARE @local_variable (Transact-SQL)
Cláusula EXECUTE AS (Transact-SQL)
Utilitário osql
Entidades (Mecanismo de Banco de Dados)
REVERT (Transact-SQL)
sp_addlinkedserver (Transact-SQL)
Utilitário sqlcmd
SUSER_NAME (Transact-SQL)
sys.database_principals (Transact-SQL)
sys.server_principals (Transact-SQL)
USER_NAME (Transact-SQL)
OPENDATASOURCE (Transact-SQL)
Funções escalares definidas pelo usuário para OLTP in-memory