Condividi tramite

EXECUTE (Transact-SQL)

  • Articolo

Si applica a: SQL Server database SQL di Azure Istanza gestita di SQL di Azure endpoint di analisi SQL di Azure Synapse AnalyticsPlatform System (PDW)in Microsoft FabricWarehouse nel database SQL di Microsoft Fabricin Microsoft Fabric

Esegue una stringa di comando o una stringa di caratteri all'interno di un batch Transact-SQL oppure uno dei moduli seguenti: stored procedure di sistema, stored procedure definita dall'utente, stored procedure CLR, funzione definita dall'utente a valori scalari o stored procedure estesa. L'istruzione EXEC o EXECUTE può essere usata per inviare comandi pass-through ai server collegati. È inoltre possibile impostare in modo esplicito il contesto di esecuzione di una stringa o di un comando. I metadati per il set di risultati possono essere definiti usando le opzioni di WITH RESULT SETS.

Importante

Prima di chiamare EXECUTE con una stringa di caratteri, convalidare la stringa di caratteri. Non eseguire mai un comando costruito dall'input dell'utente che non è stato convalidato.

Convenzioni relative alla sintassi Transact-SQL

Sintassi

Il blocco di codice seguente illustra la sintassi in SQL Server 2019 (15.x) e versioni successive. In alternativa, vedere la sintassi in SQL Server 2017 e versioni precedenti.

Sintassi per SQL Server 2019 e versioni successive.

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

Il blocco di codice seguente illustra la sintassi in SQL Server 2017 (14.x) e nelle versioni precedenti. In alternativa, vedere la sintassi in SQL Server 2019.

Sintassi per SQL Server 2017 e versioni precedenti.

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

Sintassi per 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 ] ) }
}

Sintassi per il database SQL di Azure.

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

Sintassi per Azure Synapse Analytics e 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 ] )
[ ; ]

Sintassi per 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 ] ) }
}

Argomenti

@return_status

Variabile integer facoltativa che archivia lo stato restituito di un modulo. Questa variabile deve essere dichiarata nel batch, nella stored procedure o nella funzione prima che venga usata in un'istruzione EXECUTE.

Se usato per richiamare una funzione definita dall'utente con valori scalari, la variabile @return_status può essere di qualsiasi tipo di dati scalare.

module_name

Nome completo o non qualificato della stored procedure o della funzione definita dall'utente con valori scalari da chiamare. I nomi di modulo devono essere conformi alle regole per gli identificatori. Per i nomi delle stored procedure estese la combinazione di maiuscole e minuscole è sempre rilevante, indipendentemente dalle regole di confronto del server.

Un modulo creato in un altro database può essere eseguito se l'utente che esegue il modulo è proprietario del modulo o dispone dell'autorizzazione appropriata per eseguirla nel database. È possibile eseguire un modulo in un altro server che esegue SQL Server se l'utente che lo esegue dispone delle autorizzazioni appropriate per usare quel server (accesso remoto) e per eseguire il modulo in quello specifico database. Se si specifica il nome del server ma non quello del database, il motore di database di SQL Server cerca automaticamente il modulo nel database predefinito dell'utente.

;number

Intero facoltativo utilizzato per raggruppare le routine con lo stesso nome. Questo parametro non viene usato per le stored procedure estese.

Nota

Questa funzionalità verrà rimossa nelle versioni future di SQL Server. Evitare di usare questa funzionalità in un nuovo progetto di sviluppo e prevedere interventi di modifica nelle applicazioni in cui è attualmente implementata.

Per altre informazioni sui gruppi di procedure, vedere CREATE PROCEDURE.

@module_name_var

Nome di una variabile definita localmente che rappresenta un nome di modulo.

Può essere una variabile che contiene il nome di una funzione scalare definita dall'utente compilata in modo nativo.

@parameter

Parametro per module_name, come definito nel modulo. I nomi dei parametri devono essere preceduti da at sign (@). Se usato con il valore @parameter_name = modulo, i nomi dei parametri e le costanti non devono essere specificati nell'ordine in cui sono definiti nel modulo. Tuttavia, se il valore @parameter_name = modulo viene usato per qualsiasi parametro, deve essere usato per tutti i parametri successivi.

Per impostazione predefinita, i parametri ammettono valori Null.

value

Valore del parametro da passare al modulo o al comando pass-through. Se i nomi dei parametri non vengono specificati, i valori dei parametri devono essere specificati nell'ordine definito nel modulo.

Durante l'esecuzione di comandi pass-through in server collegati, l'ordine dei valori dei parametri dipende dal provider OLE DB del server collegato. La maggior parte dei provider OLE DB associa i valori ai parametri da sinistra a destra.

Se il valore di un parametro è il nome di un oggetto, una stringa di caratteri o un nome qualificato dal nome del database o dello schema, l'intero nome deve essere racchiuso tra virgolette singole. Se il valore di un parametro è rappresentato da una parola chiave, questa deve essere racchiusa tra virgolette doppie.

Se si passa una singola parola che non inizia con @, che non è racchiusa tra virgolette (ad esempio, se si dimentica @ su un nome di parametro), la parola viene considerata come una stringa nvarchar, nonostante le virgolette mancanti.

Se nel modulo è definito un valore predefinito, l'utente può eseguire il modulo senza specificare un parametro.

Il valore predefinito può essere anche NULL. In genere, la definizione del modulo specifica l'azione che deve essere eseguita se un valore di parametro è NULL.

@variable

Variabile che archivia un parametro o un parametro restituito.

OUTPUT

Specifica che il modulo o la stringa di comando restituisce un parametro. Il parametro corrispondente nel modulo o nella stringa di comando deve essere stato creato anche usando la parola chiave OUTPUT. Specificare questa parola chiave quando come parametri si utilizzano variabili di cursore.

Se valore viene definito come OUTPUT di un modulo eseguito su un server collegato, le modifiche apportate al @parameter corrispondente eseguito dal provider OLE DB vengono copiate nuovamente nella variabile alla fine dell'esecuzione del modulo.

Se vengono usati OUTPUT parametri e la finalità consiste nell'usare i valori restituiti in altre istruzioni all'interno del batch o del modulo chiamante, il valore del parametro deve essere passato come variabile, ad esempio @parameter = @variable. Non è possibile eseguire un modulo specificando OUTPUT per un parametro non definito come parametro OUTPUT nel modulo. Le costanti non possono essere passate al modulo usando OUTPUT; il parametro restituito richiede un nome di variabile. Prima di eseguire una procedura, è necessario dichiarare il tipo dei dati della variabile e assegnare un valore.

Quando EXECUTE viene usato in una stored procedure remota o per eseguire un comando pass-through su un server collegato, OUTPUT parametri non possono essere uno dei tipi di dati LOB (Large Object).

I parametri restituiti possono essere di un tipo di dati qualsiasi, tranne i tipi di dati LOB.

DEFAULT

Valore predefinito del parametro, come definito nel modulo. Quando il modulo prevede un valore per un parametro che non ha un valore predefinito definito e che manca un parametro o viene specificata la parola chiave DEFAULT, si verifica un errore.

@string_variable

Nome di una variabile locale. @string_variable può essere qualsiasi char, varchar, ncharo tipo di dati nvarchar. Sono inclusi i tipi di dati (max).

[N]'tsql_string'

Stringa costante. tsql_string può essere di tipo nvarchar o varchar. Se il N è incluso, la stringa viene interpretata come tipo di dati nvarchar.

AS context_specification

Specifica il contesto in cui viene eseguita l'istruzione.

LOGIN

Specifica che il contesto da rappresentare è un account di accesso. L'ambito di rappresentazione è il server.

USER

Specifica che il contesto da rappresentare è un utente nel database corrente. L'ambito di rappresentazione è limitato al database corrente. Un cambio di contesto a un utente del database non eredita le autorizzazioni a livello di server di tale utente.

Importante

Mentre il passaggio di contesto all'utente del database è attivo, qualsiasi tentativo di accesso alle risorse esterne al database causa l'esito negativo dell'istruzione. Sono incluse USE <database> istruzioni, query distribuite e query che fanno riferimento a un altro database usando identificatori in tre parti o quattro parti.

'name'

Nome utente o account di accesso valido. L'argomento nome deve essere un membro del ruolo predefinito del server sysadmin o esistere rispettivamente come entità di sicurezza in sys.database_principals o sys.server_principals.

Questo argomento non può essere un account predefinito, ad esempio NT AUTHORITY\LocalService, NT AUTHORITY\NetworkServiceo NT AUTHORITY\LocalSystem.

Per altre informazioni, vedere Specifica di un utente o di un nome di accesso più avanti in questo articolo.

[N]'command_string'

Stringa costante che contiene il comando da passare al server collegato. Se il N è incluso, la stringa viene interpretata come tipo di dati nvarchar.

[?]

Indica i parametri per i quali vengono forniti i valori nella <arg-list> dei comandi pass-through usati in un'istruzione EXECUTE ('...', <arg-list>) AT <linkedsrv>.

AT linked_server_name

Specifica che command_string viene eseguita in linked_server_name e che gli eventuali risultati vengono restituiti al client. linked_server_name deve fare riferimento a una definizione esistente nel server locale di un server collegato. I server collegati vengono definiti tramite sp_addlinkedserver.

  • WITH <execute_option>

    Opzioni di esecuzione possibili. Le opzioni di RESULT SETS non possono essere specificate in un'istruzione INSERT...EXECUTE.

AT DATA_SOURCE data_source_name

si applica a: SQL Server 2019 (15.x) e versioni successive.

Specifica che command_string viene eseguita in data_source_name e che gli eventuali risultati vengono restituiti al client. data_source_name deve fare riferimento a una definizione di EXTERNAL DATA SOURCE esistente nel database. Sono supportate solo le origini dati che puntano a SQL Server. Inoltre, per le origini dati del cluster Big Data di SQL Server che puntano al pool di calcolo, al pool di dati o al pool di archiviazione sono supportate. Le origini dati vengono definite usando CREATE EXTERNAL DATA SOURCE.

  • WITH <execute_option>

    Opzioni di esecuzione possibili. Le opzioni di RESULT SETS non possono essere specificate in un'istruzione INSERT...EXECUTE.

    Termine Definizione
    RECOMPILE Forza la compilazione, l'utilizzo e l'eliminazione di un nuovo piano dopo l'esecuzione del modulo. Se è presente un piano di query esistente per il modulo, questo piano rimane nella cache.

    Usare questa opzione se il parametro fornito è atipico o se i dati sono stati modificati in modo significativo. Questa opzione non viene usata per le stored procedure estese. È consigliabile usare questa opzione con moderazione perché è costosa.

    Nota: Non è possibile usare WITH RECOMPILE quando si chiama una stored procedure che usa OPENDATASOURCE sintassi. L'opzione WITH RECOMPILE viene ignorata quando viene specificato un nome di oggetto in quattro parti.

    Nota:RECOMPILE non è supportato con funzioni definite dall'utente scalari compilate in modo nativo. Se è necessario ricompilare, usare sp_recompile.
    RESULT SETS UNDEFINED Questa opzione non garantisce quali risultati, se presenti, vengono restituiti e non viene fornita alcuna definizione. L'istruzione viene eseguita senza errore se vengono restituiti risultati o se non ne vengono restituiti. RESULT SETS UNDEFINED è il comportamento predefinito se non viene fornito un result_sets_option.

    Per le funzioni scalari interpretate definite dall'utente e le funzioni scalari definite dall'utente compilate in modo nativo, questa opzione non è operativa perché le funzioni non restituiscono mai un set di risultati.

    Si applica a: SQL Server 2012 (11.x) e versioni successive e database SQL di Azure.
    RESULT SETS NONE Garantisce che l'istruzione EXECUTE non restituisca alcun risultato. Se vengono restituiti risultati il batch viene interrotto.

    Per le funzioni scalari interpretate definite dall'utente e le funzioni scalari definite dall'utente compilate in modo nativo, questa opzione non è operativa perché le funzioni non restituiscono mai un set di risultati.

    Si applica a: SQL Server 2012 (11.x) e versioni successive e database SQL di Azure.
    <result_sets_definition> Garantisce che il risultato venga restituito come specificato nel result_sets_definition. Per le istruzioni che restituiscono più set di risultati, specificare più sezioni result_sets_definition. Racchiudere ogni sezione result_sets_definition tra parentesi, separando le diverse sezioni con virgole. Per altre informazioni, vedere <result_sets_definition> più avanti in questo articolo.

    Questa opzione genera sempre un errore per le funzioni scalari definite dall'utente compilate in modo nativo, poiché le funzioni non restituiscono mai un set di risultati.

    Si applica a: SQL Server 2012 (11.x) e versioni successive e database SQL di Azure.

    <result_sets_definition> descrive i set di risultati restituiti dalle istruzioni eseguite. Le clausole del result_sets_definition hanno il significato seguente:

    Termine Definizione
    { column_name data_type
    [ COLLATE collation_name ]
    [NULL | NOT NULL] }    		 Vedere la tabella seguente.
    db_name Nome del database contenente la tabella, la vista o la funzione con valori di tabella.
    schema_name Nome dello schema proprietario della tabella, della vista o della funzione con valori di tabella.
    table_name | view_name | table_valued_function_name Specifica che le colonne restituite sono quelle specificate nella tabella, nella vista o nella funzione con valori di tabella denominata. Le variabili di tabella, le tabelle temporanee e i sinonimi non sono supportate nella sintassi degli oggetti AS.
    AS TYPE [ schema_name. ]table_type_name Specifica che le colonne restituite sono quelle specificate nel tipo di tabella.
    AS FOR XML Specifica che i risultati XML dell'istruzione o della stored procedure chiamata dall'istruzione EXECUTE vengono convertiti nel formato come se fossero prodotti da un'istruzione SELECT ... FOR XML .... Tutta la formattazione delle direttive di tipo nell'istruzione originale viene rimossa e i risultati restituiti sono come se non fosse stata specificata alcuna direttiva di tipo. AS FOR XML non converte i risultati tabulari non XML dall'istruzione eseguita o dalla stored procedure in XML.
    Termine Definizione
    column_name Nomi di ogni colonna. Se il numero di colonne è diverso dal set di risultati, si verifica un errore e il batch viene interrotto. Se il nome di una colonna è diverso dal set di risultati, il nome della colonna restituito verrà impostato sul nome definito.
    data_type Tipi di dati di ogni colonna. Se i tipi di dati sono diversi, viene eseguita una conversione implicita al tipo di dati definito. Se la conversione ha esito negativo il batch viene interrotto
    COLLATE collation_name Regole di confronto di ogni colonna. Se è presente una mancata corrispondenza delle regole di confronto, viene tentata una regola di confronto implicita. Se la conversione ha esito negativo il batch viene interrotto.
    NULL | NOT NULL Ammissione di valori Null di ogni colonna. Se il valore Nullbility definito è NOT NULL e i dati restituiti contengono valori Null, si verifica un errore e il batch viene interrotto. Se non specificato, il valore predefinito è conforme all'impostazione delle opzioni di ANSI_NULL_DFLT_ON e ANSI_NULL_DFLT_OFF.

    Il set di risultati effettivo restituito durante l'esecuzione può differire dal risultato definito usando la clausola WITH RESULT SETS in uno dei modi seguenti: numero di set di risultati, numero di colonne, nome colonna, valori Null e tipo di dati. Se il numero di set di risultati è diverso, si verifica un errore e il batch viene interrotto.

Osservazioni:

I parametri possono essere forniti usando valore o @parameter_name = valore. Un parametro non fa parte di una transazione; pertanto, se un parametro viene modificato in una transazione di cui viene eseguito il rollback in un secondo momento, il valore del parametro non ripristina il valore precedente. Il valore restituito al chiamante corrisponde sempre al valore specificato al termine del modulo.

La nidificazione si verifica quando un modulo ne chiama un altro o quando esegue codice gestito tramite riferimenti a un modulo CLR (Common Language Runtime), un tipo definito dall'utente o una funzione di aggregazione. Il livello di annidamento viene incrementato quando il modulo chiamato o il riferimento al codice gestito avvia l'esecuzione e decrementa quando il modulo chiamato o il riferimento al codice gestito termina. Se viene superato il numero massimo di 32 livelli di nidificazione, l'intera catena di chiamata ha esito negativo. Il livello di annidamento corrente viene archiviato nella funzione di sistema @@NESTLEVEL.

Poiché le stored procedure remote e le stored procedure estese non rientrano nell'ambito di una transazione (a meno che non vengano eseguite all'interno di un'istruzione BEGIN DISTRIBUTED TRANSACTION o se usate con varie opzioni di configurazione), i comandi eseguiti tramite chiamate a tali stored procedure non possono essere sottoposti a rollback. Per altre informazioni, vedere Stored procedure di sistema e BEGIN DISTRIBUTED TRANSACTION.

Quando si usano variabili di cursore, se si esegue una routine che passa una variabile di cursore con un cursore allocato, si verifica un errore.

Non è necessario specificare la parola chiave EXECUTE quando si eseguono moduli se l'istruzione è la prima in un batch.

Per altre informazioni specifiche delle stored procedure CLR, vedere stored procedure CLR.

Usare EXECUTE con stored procedure

Non è necessario specificare la parola chiave EXECUTE quando si eseguono stored procedure quando l'istruzione è la prima in un batch.

Le stored procedure di sistema di SQL Server iniziano con i caratteri sp_. Vengono archiviati fisicamente nel database di risorse, ma vengono visualizzati logicamente nello schema sys di ogni sistema e database definito dall'utente. Se si esegue una stored procedure di sistema in un batch oppure all'interno di un modulo quale una stored procedure o una funzione definita dall'utente, è consigliabile qualificare il nome della stored procedure con il nome dello schema sys.

Le stored procedure estese del sistema SQL Server iniziano con i caratteri xp_e sono contenute nello schema dbo del database master. Quando si esegue una stored procedure estesa di sistema, in un batch o all'interno di un modulo, ad esempio una stored procedure o una funzione definita dall'utente, è consigliabile qualificare il nome della stored procedure con master.dbo.

Se si esegue una stored procedure definita dall'utente in un batch o all'interno di un modulo quale una funzione o una stored procedure definita dall'utente, è consigliabile qualificare il nome della stored procedure con un nome di schema. Non è consigliabile assegnare un nome a una stored procedure definita dall'utente con lo stesso nome di una stored procedure di sistema. Per altre informazioni sull'esecuzione di stored procedure, vedere Eseguire una stored procedure.

Usare EXECUTE con una stringa di caratteri

In SQL Server è possibile specificare i tipi di dati varchar(max) e nvarchar(max), che supportano stringhe di caratteri fino a 2 GB di dati.

Le modifiche nel contesto del database durano solo fino alla fine dell'istruzione EXECUTE. Ad esempio, dopo l'esecuzione del EXECUTE in questa istruzione seguente, il contesto del database viene master.

USE master;

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

Cambio di contesto

È possibile utilizzare la clausola AS { LOGIN | USER } = '<name>' per cambiare il contesto di esecuzione di un'istruzione dinamica. Se il cambio di contesto viene specificato come EXECUTE ('string') AS <context_specification>, la durata del cambio di contesto è limitata all'ambito della query in fase di esecuzione.

Specificare un utente o un nome di accesso

Il nome dell'utente o dell'account di accesso specificato in AS { LOGIN | USER } = '<name>' deve esistere come entità rispettivamente in sys.database_principals o sys.server_principals oppure l'istruzione ha esito negativo. Inoltre, IMPERSONATE autorizzazioni devono essere concesse all'entità. A meno che il chiamante non sia il proprietario del database o sia membro del sysadmin ruolo predefinito del server, l'entità deve esistere anche quando l'utente accede al database o all'istanza di SQL Server tramite un'appartenenza a un gruppo di Windows. Si suppongano ad esempio le condizioni seguenti:

  • CompanyDomain\SQLUsers gruppo ha accesso al database di Sales.

  • CompanyDomain\SqlUser1 è membro di SQLUsers e pertanto ha accesso implicito al database Sales.

Sebbene CompanyDomain\SqlUser1 abbia accesso al database tramite l'appartenenza al gruppo di SQLUsers, l'istruzione EXECUTE @string_variable AS USER = 'CompanyDomain\SqlUser1' ha esito negativo perché CompanyDomain\SqlUser1 non esiste come entità nel database.

Procedure consigliate

Specificare un account di accesso o un utente che disponga almeno dei privilegi necessari per eseguire le operazioni definite nell'istruzione o nel modulo. Ad esempio, non specificare un nome di accesso con autorizzazioni a livello di server, se sono necessarie solo autorizzazioni a livello di database. In alternativa, non specificare un account proprietario del database a meno che non siano necessarie tali autorizzazioni.

Autorizzazioni

Le autorizzazioni non sono necessarie per eseguire l'istruzione EXECUTE. Tuttavia, le autorizzazioni sono necessarie per le entità a protezione diretta a cui viene fatto riferimento all'interno della stringa EXECUTE. Ad esempio, se la stringa contiene un'istruzione INSERT, il chiamante dell'istruzione EXECUTE deve disporre dell'autorizzazione INSERT per la tabella di destinazione. Le autorizzazioni vengono controllate al momento in cui viene rilevata EXECUTE istruzione, anche se l'istruzione EXECUTE è inclusa in un modulo.

EXECUTE autorizzazioni per un modulo per impostazione predefinita al proprietario del modulo, che possono trasferirle ad altri utenti. Quando si esegue un modulo che esegue una stringa, la verifica delle autorizzazioni viene eseguita nel contesto dell'utente che esegue il modulo e non nel contesto dell'utente che l'ha creato. Tuttavia, se lo stesso utente è proprietario del modulo chiamante e del modulo chiamato, EXECUTE controllo delle autorizzazioni non viene eseguito per il secondo modulo.

Se il modulo accede ad altri oggetti di database, l'esecuzione ha esito positivo quando si dispone dell'autorizzazione EXECUTE per il modulo e una delle condizioni seguenti è vera:

  • Il modulo è contrassegnato EXECUTE AS USER o EXECUTE AS SELFe il proprietario del modulo dispone delle autorizzazioni corrispondenti per l'oggetto a cui si fa riferimento. Per altre informazioni sulla rappresentazione all'interno di un modulo, vedere clausola EXECUTE AS.

  • Il modulo è contrassegnato EXECUTE AS CALLERe si dispone delle autorizzazioni corrispondenti per l'oggetto .

  • Il modulo è contrassegnato EXECUTE AS <user_name>e <user_name> dispone delle autorizzazioni corrispondenti per l'oggetto .

Autorizzazioni di cambio del contesto

Per specificare EXECUTE AS in un account di accesso, il chiamante deve disporre di autorizzazioni IMPERSONATE per il nome di accesso specificato. Per specificare EXECUTE AS per un utente del database, il chiamante deve disporre delle autorizzazioni IMPERSONATE per il nome utente specificato. Quando non viene specificato alcun contesto di esecuzione o EXECUTE AS CALLER viene specificato, IMPERSONATE autorizzazioni non sono necessarie.

Esempi: SQL Server

Gli esempi di codice Transact-SQL in questo articolo usano il database di esempio AdventureWorks2022 o AdventureWorksDW2022, che è possibile scaricare dalla home page Microsoft SQL Server Samples and Community Projects.

R. Usare EXECUTE per passare un singolo parametro

La uspGetEmployeeManagers stored procedure nel database AdventureWorks2022 prevede un parametro (@EmployeeID). Gli esempi seguenti eseguono la stored procedure uspGetEmployeeManagers con Employee ID 6 come valore di parametro.

EXECUTE dbo.uspGetEmployeeManagers 6;
GO

La variabile può essere specificata in modo esplicito durante l'esecuzione.

EXECUTE dbo.uspGetEmployeeManagers @EmployeeID = 6;
GO

Se di seguito è riportata la prima istruzione in un batch o in uno script di sqlcmd, non è necessario EXECUTE.

dbo.uspGetEmployeeManagers 6;
GO

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

B. Usare più parametri

Nell'esempio seguente viene eseguita la spGetWhereUsedProductID stored procedure nel database AdventureWorks2022. Vengono passati due parametri: il primo è un ID prodotto (819), il secondo (@CheckDate,) è un valore di tipo datetime.

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

EXECUTE dbo.uspGetWhereUsedProductID 819, @CheckDate;
GO

C. Usare EXECUTE 'tsql_string' con una variabile

Nell'esempio seguente viene illustrato come l'istruzione EXECUTE gestisca stringhe compilate in modo dinamico contenenti variabili. Nell'esempio viene creato il cursore tables_cursor che include un elenco di tutte le tabelle definite dall'utente nel database AdventureWorks2022, quindi l'elenco viene utilizzato per ricompilare tutti gli indici nella tabella.

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. Usare EXECUTE con una stored procedure remota

Nell'esempio seguente viene eseguita la stored procedure uspGetEmployeeManagers nel server remoto SQLSERVER1 e lo stato restituito, che indica se la stored procedure è stata eseguita correttamente o meno, viene archiviato in @retstat.

DECLARE @retstat AS INT;

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

E. Usare EXECUTE con una variabile di stored procedure

Nell'esempio seguente viene creata una variabile che rappresenta il nome di una stored procedure.

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

EXECUTE @proc_name;

F. Usare EXECUTE con DEFAULT

Nell'esempio seguente viene creata una stored procedure con valori predefiniti per il primo e il terzo parametro. Quando si esegue la procedura, se nella chiamata non viene passato alcun valore oppure viene specificato il valore predefinito, i valori predefiniti vengono utilizzati per il primo e il terzo parametro. Si notino i vari utilizzi della parola chiave 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

La stored procedure Proc_Test_Defaults può essere eseguita in molte combinazioni.

-- 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. Usare EXECUTE con AT linked_server_name

Nell'esempio seguente una stringa di comando viene passata a un server remoto. Verrà creato un server collegato SeattleSales che punta a un'altra istanza di SQL Server ed esegue un'istruzione DDL (CREATE TABLE) in tale server collegato.

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

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

H. Usare EXECUTE WITH RECOMPILE

L'esempio seguente esegue la stored procedure Proc_Test_Defaults e impone la compilazione, l'uso e l'eliminazione di un nuovo piano di query dopo l'esecuzione del modulo.

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

I. Usare EXECUTE con una funzione definita dall'utente

Nell'esempio seguente viene eseguita la ufnGetSalesOrderStatusText funzione scalare definita dall'utente nel database AdventureWorks2022. Viene utilizzata la variabile @returnstatus per archiviare il valore restituito dalla funzione. Per la funzione è previsto un parametro di input (@Status) Questo è definito con il tipo di dati tinyint.

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

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

PRINT @returnstatus;
GO

J. Usare EXECUTE per eseguire query su un database Oracle in un server collegato

Nell'esempio seguente vengono eseguite più istruzioni SELECT nel server Oracle remoto. Viene innanzitutto aggiunto il server Oracle come server collegato e quindi viene creato l'account di accesso per il server collegato.

-- 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. Usare EXECUTE AS USER per cambiare contesto a un altro utente

Nell'esempio seguente viene eseguita una stringa Transact-SQL che crea una tabella e viene quindi specificata la clausola AS USER per cambiare il contesto di esecuzione dell'istruzione dal chiamante a User1. Il motore di database controlla le autorizzazioni di User1 quando viene eseguita l'istruzione . User1 deve esistere come utente nel database e deve disporre delle autorizzazioni necessarie per creare tabelle nello schema Sales. In caso contrario, l'istruzione avrà esito negativo.

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

.L Usare un parametro con EXECUTE e AT linked_server_name

Nell'esempio seguente una stringa di comando viene passata a un server remoto utilizzando un punto interrogativo (?) come segnaposto per un parametro. Viene quindi creato un server collegato SeattleSales che punta a un'altra istanza di SQL Server e viene eseguita un'istruzione SELECT su tale server collegato. L'istruzione SELECT utilizza il punto interrogativo come segnaposto per il parametro ProductID (952), specificato dopo l'istruzione.

-- 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. Usare EXECUTE per ridefinire un singolo set di risultati

Si applica a: SQL Server 2012 (11.x) e versioni successive e database SQL di Azure.

Alcuni degli esempi precedenti sono stati eseguiti EXECUTE dbo.uspGetEmployeeManagers 6; che hanno restituito sette colonne. Nell'esempio seguente viene illustrato l'utilizzo della sintassi WITH RESULT SET per modificare i nomi e i tipi di dati del set di risultati ottenuto.

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. Usare EXECUTE per ridefinire due set di risultati

Si applica a: SQL Server 2012 (11.x) e versioni successive e database SQL di Azure.

Quando si esegue un'istruzione che restituisce più di un set di risultati, definire ogni set di risultati previsto. Nell'esempio seguente in AdventureWorks2022 viene creata una stored procedure che restituisce due set di risultati. La routine viene quindi eseguita usando la clausola WITH RESULT SETS e specificando due definizioni del set di risultati.

--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 Usare EXECUTE con AT DATA_SOURCE data_source_name per eseguire query su un'istanza remota di SQL Server

si applica a: SQL Server 2019 (15.x) e versioni successive.

Nell'esempio seguente una stringa di comando viene passata a un'origine dati esterna che punta a un'istanza di SQL Server.

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

P. Usare EXECUTE con AT DATA_SOURCE data_source_name per eseguire query sul pool di calcolo nel cluster Big Data di SQL Server

si applica a: SQL Server 2019 (15.x).

Nell'esempio seguente una stringa di comando viene passata a un'origine dati esterna che punta a un pool di calcolo nel cluster Big Data di SQL Server. Nell'esempio viene creata un'origine dati SqlComputePool in un pool di calcolo nel cluster Big Data di SQL Server e viene eseguita un'istruzione SELECT sull'origine dati.

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

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

D. Usare EXECUTE con AT DATA_SOURCE data_source_name per eseguire query sul pool di dati nel cluster Big Data di SQL Server

si applica a: SQL Server 2019 (15.x).

Nell'esempio seguente viene passata una stringa di comando a un'origine dati esterna che punta al pool di calcolo nel cluster Big Data di SQL Server. L'esempio crea un'origine dati SqlDataPool su un pool di dati in BDC ed esegue un'istruzione SELECT sull'origine dati.

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

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

.R Usare EXECUTE con AT DATA_SOURCE data_source_name per eseguire query sul pool di archiviazione nel cluster Big Data di SQL Server

si applica a: SQL Server 2019 (15.x).

Nell'esempio seguente una stringa di comando viene passata a un'origine dati esterna che punta a un pool di calcolo nel cluster Big Data di SQL Server. Nell'esempio viene creata un'origine dati SqlStoragePool in un pool di dati nel cluster Big Data di SQL Server e viene eseguita un'istruzione SELECT sull'origine dati.

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

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

Esempi: Azure Synapse Analytics

Gli esempi di codice Transact-SQL in questo articolo usano il database di esempio AdventureWorks2022 o AdventureWorksDW2022, che è possibile scaricare dalla home page Microsoft SQL Server Samples and Community Projects.

R: Esecuzione di routine di base

Eseguire una stored procedure:

EXECUTE proc1;

Chiamare una stored procedure con il nome determinato in fase di esecuzione:

EXECUTE ('EXECUTE ' + @var);

Chiamare una stored procedure dall'interno di una stored procedure:

CREATE sp_first AS EXECUTE sp_second; EXECUTE sp_third;

B: Eseguire stringhe

Eseguire una stringa SQL:

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

Eseguire una stringa nidificata:

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

Eseguire una variabile stringa:

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

EXECUTE (@stringVar);

C: Procedure con parametri

L'esempio seguente crea una routine con parametri e illustra tre modi per eseguire la procedura:

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

Eseguire usando i parametri posizionali:

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

Eseguire usando i parametri denominati nell'ordine:

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

Eseguire usando parametri denominati non in ordine:

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

Contenuto correlato