EXECUTE (Transact-SQL)

Sintaxe

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

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 ]
[;]

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 usado para invocar uma função definida pelo usuário de 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 estar de acordo com as regras dos identificadores. Os nomes de procedimentos armazenados estendidos sempre têm diferenciação entre maiúsculas e minúsculas, independentemente do agrupamento 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
  É 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.

• @parameter
  É o parâmetro do module_name, como definido no módulo. Os nomes de parâmetro devem ser precedidos pelo sinal de arroba (@). Quando usados com a forma @parameter_name=value, as constantes e os nomes de parâmetros não precisam ser fornecidos na ordem em que estão definidos no módulo. Porém, se a forma @parameter_name=value for usada para qualquer parâmetro, ela deverá ser usada para todos os parâmetros subsequentes.

  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 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, qualquer alteração efetuada no @parameter correspondente executada pelo provedor OLE DB será copiada novamente na 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 de retorno em outras instruções no lote ou módulo que efetua a chamada, o valor do parâmetro deverá ser informado 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 espera um valor para um parâmetro que não tenha um padrão definido, um parâmetro estiver faltando ou a palavra-chave DEFAULT estiver especificada, ocorre um erro.

• WITH RECOMPILE
  Força um novo plano de compilação que será usado e descartado 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
  Você não pode 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 em quatro partes for especificado.

• @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 de 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. Para obter mais informações, consulte Compreendendo o contexto de execução.

• LOGIN
  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 personificação é restringido 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 fazem menção a outro banco de dados usando identificadores em três ou quatro partes. Para estender o escopo da opção de contexto para fora do banco de dados atual, consulte Estendendo representação de banco de dados com EXECUTE AS.

• 'name'
  É um nome de logon ou usuário válido. name deve ser membro da função de servidor fixa sysadmin ou existir como entidade 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 em <arg-list> de comandos de passagem usados em uma instrução EXEC('…', <arg-list>) AT <linkedsrv>.

• linked_server_namede AT
  Especifica que command_string é executado em linked_server_name e que os resultados, se existirem, serão retornados ao cliente. linked_server_name deve se referir a uma definição de servidor vinculado existente no servidor local. Os servidores vinculados são definidos com o uso de sp_addlinkedserver.

Comentários

Os parâmetros podem ser fornecidos pelo uso de value ou de @parameter_name = value.. O parâmetro não faz parte de uma transação; portanto, se um parâmetro for alterado em uma transação revertida posteriormente, o valor do parâmetro não será revertido ao 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 de 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 será preciso especificar a palavra-chave EXECUTE durante a execução de módulos se a instrução for a primeira em um lote.

Usando EXECUTE com procedimentos armazenados

Usando EXECUTE com uma cadeia de caracteres

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

Alternância de contexto

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. Para obter mais informações, consulte Cadeias de propriedade.

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

Exemplos

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

USE AdventureWorks2008R2;
GO
EXEC dbo.uspGetEmployeeManagers 6;
GO

EXEC dbo.uspGetEmployeeManagers @BusinessEntityID = 6;
GO

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

B. Usando vários parâmetros

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

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

USE AdventureWorks2008R2;
GO
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

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

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

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

F. Usando EXECUTE com DEFAULT

USE AdventureWorks2008R2;
GO
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

-- 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 linked_server_name de AT

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

H. Usando EXECUTE WITH RECOMPILE

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

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

USE AdventureWorks2008R2;
GO
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

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

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

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

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

Consulte também

Referência

Conceitos