Clausola OUTPUT (Transact-SQL)OUTPUT Clause (Transact-SQL)

SI APPLICA A: sìSQL Server sìDatabase SQL di Azure noAzure SQL Data Warehouse noParallel Data Warehouse APPLIES TO: yesSQL Server yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Restituisce le informazioni da (o le espressioni basate su) ogni riga interessata da un'istruzione INSERT, UPDATE, DELETE o MERGE.Returns information from, or expressions based on, each row affected by an INSERT, UPDATE, DELETE, or MERGE statement. Questi risultati possono essere restituiti all'applicazione di elaborazione per l'utilizzo nei messaggi di errore, l'archiviazione e altri scopi simili dell'applicazione.These results can be returned to the processing application for use in such things as confirmation messages, archiving, and other such application requirements. I risultati possono anche essere inseriti in una tabella o in una variabile di tabella.The results can also be inserted into a table or table variable. Inoltre, è possibile acquisire i risultati di una clausola OUTPUT in un'istruzione nidificata INSERT, UPDATE, DELETE o MERGE e inserire tali risultati in una vista o tabella di destinazione.Additionally, you can capture the results of an OUTPUT clause in a nested INSERT, UPDATE, DELETE, or MERGE statement, and insert those results into a target table or view.

Nota

Un'istruzione UPDATE, INSERT o DELETE in cui è presente una clausola OUTPUT restituirà righe al client anche se l'istruzione rileva errori e ne viene eseguito il rollback.An UPDATE, INSERT, or DELETE statement that has an OUTPUT clause will return rows to the client even if the statement encounters errors and is rolled back. Se durante l'esecuzione dell'istruzione si verifica un errore, il risultato non deve essere utilizzato.The result should not be used if any error occurs when you run the statement.

Usata in:Used in:

DELETEDELETE

INSERTINSERT

UPDATEUPDATE

MERGEMERGE

Icona di collegamento a un argomentoConvenzioni della sintassi Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SintassiSyntax

  
<OUTPUT_CLAUSE> ::=  
{  
    [ OUTPUT <dml_select_list> INTO { @table_variable | output_table } [ ( column_list ) ] ]  
    [ OUTPUT <dml_select_list> ]  
}  
<dml_select_list> ::=  
{ <column_name> | scalar_expression } [ [AS] column_alias_identifier ]  
    [ ,...n ]  
  
<column_name> ::=  
{ DELETED | INSERTED | from_table_name } . { * | column_name }  
    | $action  

ArgomentiArguments

@table_variable@table_variable
Specifica una variabile table in cui vengono inserite le righe restituite invece di essere restituite al chiamante.Specifies a table variable that the returned rows are inserted into instead of being returned to the caller. @table_variable deve essere dichiarato prima dell'istruzione INSERT, UPDATE, DELETE o MERGE.@table_variable must be declared before the INSERT, UPDATE, DELETE, or MERGE statement.

Se non si specifica column_list, la variabile table deve avere lo stesso numero di colonne del set dei risultati OUTPUT.If column_list is not specified, the table variable must have the same number of columns as the OUTPUT result set. Le eccezioni sono le colonne calcolate e Identity, le quali devono essere ignorate.The exceptions are identity and computed columns, which must be skipped. Se column_list viene specificato, le colonne omesse devono consentire i valori Null oppure devono avere valori predefiniti assegnati.If column_list is specified, any omitted columns must either allow null values or have default values assigned to them.

Per altre informazioni sulle variabili table, vedere table (Transact-SQL) .For more information about table variables, see table (Transact-SQL).

output_tableoutput_table
Specifica una tabella in cui vengono inserite le righe restituite invece di essere restituite al chiamante.Specifies a table that the returned rows are inserted into instead of being returned to the caller. output_table può essere una tabella temporanea.output_table may be a temporary table.

Se non si specifica column_list, la tabella deve avere lo stesso numero di colonne del set dei risultati OUTPUT.If column_list is not specified, the table must have the same number of columns as the OUTPUT result set. Le eccezioni sono le colonne calcolate e Identity,The exceptions are identity and computed columns. che devono essere ignorate.These must be skipped. Se column_list viene specificato, le colonne omesse devono consentire i valori Null oppure devono avere valori predefiniti assegnati.If column_list is specified, any omitted columns must either allow null values or have default values assigned to them.

output_table non può:output_table cannot:

  • avere trigger abilitati definitiHave enabled triggers defined on it.

  • Partecipare in un vincolo di chiave esternaParticipate on either side of a FOREIGN KEY constraint.

  • avere regole abilitate o vincoli CHECK.Have CHECK constraints or enabled rules.

column_listcolumn_list
Elenco facoltativo dei nomi di colonna nella tabella di destinazione della clausola INTO.Is an optional list of column names on the target table of the INTO clause. È analogo all'elenco delle colonne consentite nell'istruzione INSERT.It is analogous to the column list allowed in the INSERT statement.

scalar_expressionscalar_expression
Qualsiasi combinazione di simboli e operatori che restituisce un unico valore.Is any combination of symbols and operators that evaluates to a single value. Le funzioni di aggregazione non sono consentite in scalar_expression.Aggregate functions are not permitted in scalar_expression.

Qualsiasi riferimento alle colonne della tabella che viene modificata deve essere qualificato con il prefisso INSERTED o DELETED.Any reference to columns in the table being modified must be qualified with the INSERTED or DELETED prefix.

column_alias_identifiercolumn_alias_identifier
Nome alternativo utilizzato per fare riferimento al nome della colonna.Is an alternative name used to reference the column name.

DELETEDDELETED
Prefisso di colonna che specifica il valore eliminato dall'operazione di aggiornamento o di eliminazione.Is a column prefix that specifies the value deleted by the update or delete operation. Le colonne con prefisso DELETED riflettono il valore prima del completamento dell'istruzione UPDATE, DELETE o MERGE.Columns prefixed with DELETED reflect the value before the UPDATE, DELETE, or MERGE statement is completed.

DELETED non può essere utilizzato con la clausola OUTPUT nell'istruzione INSERT.DELETED cannot be used with the OUTPUT clause in the INSERT statement.

INSERTEDINSERTED
Prefisso di colonna che specifica il valore aggiunto dall'operazione di inserimento o aggiornamento.Is a column prefix that specifies the value added by the insert or update operation. Le colonne con prefisso INSERTED riflettono il valore dopo il completamento dell'istruzione UPDATE, INSERT o MERGE ma prima dell'esecuzione dei trigger.Columns prefixed with INSERTED reflect the value after the UPDATE, INSERT, or MERGE statement is completed but before triggers are executed.

INSERTED non può essere utilizzato con la clausola OUTPUT nell'istruzione DELETE.INSERTED cannot be used with the OUTPUT clause in the DELETE statement.

from_table_namefrom_table_name
Prefisso di colonna che specifica una tabella inclusa nella clausola FROM di un'istruzione DELETE, UPDATE o MERGE utilizzata per specificare le righe da aggiornare o eliminare.Is a column prefix that specifies a table included in the FROM clause of a DELETE, UPDATE, or MERGE statement that is used to specify the rows to update or delete.

Se anche la tabella che viene modificata è specificata nella clausola FROM, qualsiasi riferimento alle colonne della tabella deve essere qualificato con il prefisso INSERTED o DELETED.If the table being modified is also specified in the FROM clause, any reference to columns in that table must be qualified with the INSERTED or DELETED prefix.

*
Specifica che tutte le colonne interessate dall'azione di eliminazione, inserimento o aggiornamento saranno restituite nell'ordine in cui esistono nella tabella.Specifies that all columns affected by the delete, insert, or update action will be returned in the order in which they exist in the table.

Ad esempio, OUTPUT DELETED.* nell'istruzione DELETE seguente restituisce tutte le colonne eliminate dalla tabella ShoppingCartItem:For example, OUTPUT DELETED.* in the following DELETE statement returns all columns deleted from the ShoppingCartItem table:

DELETE Sales.ShoppingCartItem  
    OUTPUT DELETED.*;  

column_namecolumn_name
Riferimento di colonna esplicito.Is an explicit column reference. Qualsiasi riferimento alla tabella che viene modificata deve essere qualificato correttamente tramite il prefisso INSERTED o DELETED in base alle esigenze, ad esempio: INSERTED . column_name.Any reference to the table being modified must be correctly qualified by either the INSERTED or the DELETED prefix as appropriate, for example: INSERTED .column_name.

$action$action
È disponibile solo per l'istruzione MERGE.Is available only for the MERGE statement. Specifica una colonna di tipo nvarchar(10) nella clausola OUTPUT in un'istruzione MERGE che restituisce uno dei tre valori per ogni riga: 'INSERT', 'UPDATE' o 'DELETE', a seconda dell'azione eseguita su quella riga.Specifies a column of type nvarchar(10) in the OUTPUT clause in a MERGE statement that returns one of three values for each row: 'INSERT', 'UPDATE', or 'DELETE', according to the action that was performed on that row.

RemarksRemarks

La clausola OUTPUT <dml_select_list> e la clausola OUTPUT <dml_select_list> INTO { @ table_variable | output_table } possono essere definite in un'unica istruzione INSERT, UPDATE, DELETE o MERGE.The OUTPUT <dml_select_list> clause and the OUTPUT <dml_select_list> INTO { @table_variable | output_table } clause can be defined in a single INSERT, UPDATE, DELETE, or MERGE statement.

Nota

Se non specificato diversamente, i riferimenti alla clausola OUTPUT fanno riferimento a entrambe le clausole OUTPUT e OUTPUT INTO.Unless specified otherwise, references to the OUTPUT clause refer to both the OUTPUT clause and the OUTPUT INTO clause.

La clausola OUTPUT può risultare utile per recuperare il valore delle colonne calcolate o Identity dopo un'operazione di INSERT o UPDATE.The OUTPUT clause may be useful to retrieve the value of identity or computed columns after an INSERT or UPDATE operation.

Quando una colonna calcolata è inclusa nell'elenco <dml_select_list>, la colonna corrispondente nella tabella di output o nella variabile di tabella non è una colonna calcolata.When a computed column is included in the <dml_select_list>, the corresponding column in the output table or table variable is not a computed column. I valori della nuova colonna corrispondono ai valori calcolati quando è stata eseguita l'istruzione.The values in the new column are the values that were computed at the time the statement was executed.

Non vi è alcuna garanzia che l'ordine in cui vengono applicate le modifiche alla tabella e l'ordine in cui le righe vengono inserite nella tabella di output o variabile della tabella corrispondano.There is no guarantee that the order in which the changes are applied to the table and the order in which the rows are inserted into the output table or table variable will correspond.

Se le variabili o i parametri vengono modificati come parte di un'istruzione UPDATE, la clausola OUTPUT restituisce sempre il valore della variabile o del parametro prima dell'esecuzione dell'istruzione e non il valore modificato.If parameters or variables are modified as part of an UPDATE statement, the OUTPUT clause always returns the value of the parameter or variable as it was before the statement executed instead of the modified value.

È possibile utilizzare OUTPUT con un'istruzione UPDATE o DELETE posizionata in un cursore che utilizza la sintassi WHERE CURRENT OF.You can use OUTPUT with an UPDATE or DELETE statement positioned on a cursor that uses WHERE CURRENT OF syntax.

La clausola OUTPUT non è supportata nelle istruzioni seguenti:The OUTPUT clause is not supported in the following statements:

  • istruzioni DML che fanno riferimento a viste partizionate locali, viste partizionate distribuite o tabelle remoteDML statements that reference local partitioned views, distributed partitioned views, or remote tables.

  • istruzioni INSERT che contengono un'istruzione EXECUTE.INSERT statements that contain an EXECUTE statement.

  • I predicati full-text non sono consentiti nella clausola OUTPUT quando il livello di compatibilità del database è impostato su 100.Full-text predicates are not allowed in the OUTPUT clause when the database compatibility level is set to 100.

  • La clausola OUTPUT INTO non può essere utilizzata per l'inserimento in una vista o funzione di set di righe.The OUTPUT INTO clause cannot be used to insert into a view, or rowset function.

  • Non è possibile creare una funzione definita dall'utente se contiene una clausola OUTPUT INTO con una tabella come destinazione.A user-defined function cannot be created if it contains an OUTPUT INTO clause that has a table as its target.

Per impedire un comportamento non deterministico, la clausola OUTPUT non può contenere i riferimenti seguenti:To prevent nondeterministic behavior, the OUTPUT clause cannot contain the following references:

  • Sottoquery o funzioni definite dall'utente che eseguono l'accesso ai dati dell'utente o di sistema o che si presume eseguano tale accesso.Subqueries or user-defined functions that perform user or system data access, or are assumed to perform such access. Si presuppone che le funzioni definite dall'utente eseguano l'accesso ai dati se non sono associati allo schema.User-defined functions are assumed to perform data access if they are not schema-bound.

  • Colonna di una vista o di una funzione inline con valori di tabella se tale colonna viene definita mediante uno dei metodi seguenti:A column from a view or inline table-valued function when that column is defined by one of the following methods:

    • Sottoquery.A subquery.

    • Funzione definita dall'utente che esegue, o si presume esegua, l'accesso ai dati dell'utente o di sistema.A user-defined function that performs user or system data access, or is assumed to perform such access.

    • Colonna calcolata che contiene una funzione definita dall'utente che esegue l'accesso ai dati dell'utente o di sistema nella relativa definizione.A computed column that contains a user-defined function that performs user or system data access in its definition.

    Quando SQL ServerSQL Server rileva una colonna di questo tipo nella clausola OUTPUT, viene generato l'errore 4186.When SQL ServerSQL Server detects such a column in the OUTPUT clause, error 4186 is raised.

Inserimento di dati restituiti da una clausola OUTPUT in una tabellaInserting Data Returned From an OUTPUT Clause Into a Table

Quando si acquisiscono i risultati di una clausola OUTPUT in un'istruzione nidificata INSERT, UPDATE, DELETE o MERGE e si inseriscono tali risultati in una tabella di destinazione, tenere presente le considerazioni seguenti:When you are capturing the results of an OUTPUT clause in a nested INSERT, UPDATE, DELETE, or MERGE statement and inserting those results into a target table, keep the following information in mind:

  • L'intera operazione è di tipo atomico.The whole operation is atomic. È necessario eseguire sia l'istruzione INSERT esterna che l'istruzione DMl interna contenente la clausola OUTPUT. In caso contrario, l'intera istruzione avrà esito negativo.Either both the INSERT statement and the nested DML statement that contains the OUTPUT clause execute, or the whole statement fails.

  • Alla destinazione dell'istruzione INSERT esterna si applicano le restrizioni seguenti:The following restrictions apply to the target of the outer INSERT statement:

    • La destinazione non può essere una tabella remota, una vista o un'espressione di tabella comune.The target cannot be a remote table, view, or common table expression.

    • Nella destinazione non può essere presente un vincolo FOREIGN KEY né un vincolo FOREIGN KEY può fare riferimento alla destinazione stessa.The target cannot have a FOREIGN KEY constraint, or be referenced by a FOREIGN KEY constraint.

    • Nella destinazione non è possibile definire trigger.Triggers cannot be defined on the target.

    • La destinazione non può partecipare alla replica di tipo merge oppure a sottoscrizioni aggiornabili per la replica transazionale.The target cannot participate in merge replication or updatable subscriptions for transactional replication.

  • All'istruzione DML nidificata si applicano le restrizioni seguenti:The following restrictions apply to the nested DML statement:

    • La destinazione non può essere una tabella remota o una vista partizionata.The target cannot be a remote table or partitioned view.

    • Nell'origine non può essere contenuta una clausola <dml_table_source>.The source itself cannot contain a <dml_table_source> clause.

  • La clausola OUTPUT INTO non è supportata in istruzioni INSERT che contengono una clausola <dml_table_source>.The OUTPUT INTO clause is not supported in INSERT statements that contain a <dml_table_source> clause.

  • @@ROWCOUNT restituisce solo le righe inserite dall'istruzione INSERT esterna.@@ROWCOUNT returns the rows inserted only by the outer INSERT statement.

  • @@IDENTITY, SCOPE_IDENTITY e IDENT_CURRENT restituiscono solo i valori Identity generati dall'istruzione DML annidata e non quelli generati dall'istruzione INSERT esterna.@@IDENTITY, SCOPE_IDENTITY, and IDENT_CURRENT return identity values generated only by the nested DML statement, and not those generated by the outer INSERT statement.

  • Le notifiche delle query considerano l'istruzione come entità singola e il tipo di qualsiasi messaggio creato sarà il tipo dell'istruzione DML nidificata, anche se la modifica significativa proviene dall'istruzione INSERT esterna stessa.Query notifications treat the statement as a single entity, and the type of any message that is created will be the type of the nested DML, even if the significant change is from the outer INSERT statement itself.

  • Nella clausola <dml_table_source> le clausole SELECT e WHERE non possono includere sottoquery, funzioni di aggregazione, funzioni di rango, predicati full-text, funzioni definite dall'utente che eseguono l'accesso ai dati o la funzione TEXTPTR.In the <dml_table_source> clause, the SELECT and WHERE clauses cannot include subqueries, aggregate functions, ranking functions, full-text predicates, user-defined functions that perform data access, or the TEXTPTR function.

ParallelismParallelism

Una clausola OUTPUT che restituisce i risultati al client usa sempre un piano seriale.An OUTPUT clause that returns results to the client will always use a serial plan.

Nel contesto di un database impostato a un livello di compatibilità pari a 130 o superiore, se un'operazione INSERT...SELECT usa un hint WITH (TABLOCK) per l'istruzione SELECT e usa anche OUTPUT...INTO per l'inserimento in una tabella temporanea o di utente, la tabella di destinazione per INSERT...SELECT sarà idonea per il parallelismo a seconda del costo del sottoalbero.In the context of a database set to compatibility level 130 or higher, if an INSERT...SELECT operation uses a WITH (TABLOCK) hint for the SELECT statement and also uses OUTPUT...INTO to insert into a temporary or user table, then the target table for the INSERT...SELECT will be eligible for parallelism depending on the subtree cost. La tabella di destinazione cui si fa riferimento nella clausola OUTPUT INTO non sarà idonea per il parallelismo.The target table referenced in the OUTPUT INTO clause will not be eligible for parallelism.

TriggerTriggers

Le colonne restituite da OUTPUT riflettono i dati dopo il completamento dell'istruzione INSERT, UPDATE o DELETE ma prima dell'esecuzione dei trigger.Columns returned from OUTPUT reflect the data as it is after the INSERT, UPDATE, or DELETE statement has completed but before triggers are executed.

Per i trigger INSTEAD OF, i risultati restituiti vengono generati come se le istruzioni INSERT, UPDATE o DELETE siano state effettivamente completate, anche se non si verifica alcuna modifica come risultato dell'operazione trigger.For INSTEAD OF triggers, the returned results are generated as if the INSERT, UPDATE, or DELETE had actually occurred, even if no modifications take place as the result of the trigger operation. Se un'istruzione che include una clausola OUTPUT viene utilizzata all'interno del corpo di un trigger, gli alias di tabella devono essere utilizzati per fare riferimento al trigger inserted e alle tabelle deleted per evitare la duplicazione dei riferimenti di colonna con le tabelle INSERTED e DELETED associate a OUTPUT.If a statement that includes an OUTPUT clause is used inside the body of a trigger, table aliases must be used to reference the trigger inserted and deleted tables to avoid duplicating column references with the INSERTED and DELETED tables associated with OUTPUT.

Se la clausola OUTPUT viene specificata senza specificare anche la parola chiave INTO, la destinazione dell'operazione DML non può avere trigger abilitati definiti per l'azione DML specificata.If the OUTPUT clause is specified without also specifying the INTO keyword, the target of the DML operation cannot have any enabled trigger defined on it for the given DML action. Ad esempio, se la clausola OUTPUT viene definita in un'istruzione UPDATE, la tabella di destinazione non può avere alcun trigger UPDATE abilitato.For example, if the OUTPUT clause is defined in an UPDATE statement, the target table cannot have any enabled UPDATE triggers.

Se è impostata l'opzione disallow results from triggers di sp_configure, una clausola OUTPUT senza clausola INTO provoca l'esito negativo dell'istruzione quando viene richiamata dall'interno di un trigger.If the sp_configure option disallow results from triggers is set, an OUTPUT clause without an INTO clause causes the statement to fail when it is invoked from within a trigger.

Tipi di datiData Types

La clausola OUTPUT supporta i tipi di dati Large Object: nvarchar(max) , varchar(max) , varbinary(max) , text, ntext, image, e xml.The OUTPUT clause supports the large object data types: nvarchar(max), varchar(max), varbinary(max), text, ntext, image, and xml. Quando si usa la clausola .WRITE nell'istruzione UPDATE per modificare una colonna di tipo nvarchar(max) , varchar(max) o varbinary(max) , vengono restituite le immagini complete precedenti e successive dei valori se contengono dei riferimenti.When you use the .WRITE clause in the UPDATE statement to modify an nvarchar(max), varchar(max), or varbinary(max) column, the full before and after images of the values are returned if they are referenced. La funzione TEXTPTR( ) non può comparire in un'espressione in una colonna di tipo text, ntext o image nella clausola OUTPUT.The TEXTPTR( ) function cannot appear as part of an expression on a text, ntext, or image column in the OUTPUT clause.

CodeQueues

È possibile utilizzare la clausola OUTPUT nelle applicazioni che utilizzano le tabelle come code oppure per mantenere i risultati intermedi delle query.You can use OUTPUT in applications that use tables as queues, or to hold intermediate result sets. In altre parole, l'applicazione aggiunge o rimuove costantemente le righe dalla tabella.That is, the application is constantly adding or removing rows from the table. Nell'esempio seguente viene utilizzata la clausola OUTPUT in un'istruzione DELETE per restituire la riga eliminata all'applicazione chiamante.The following example uses the OUTPUT clause in a DELETE statement to return the deleted row to the calling application.

USE AdventureWorks2012;  
GO  
DELETE TOP(1) dbo.DatabaseLog WITH (READPAST)  
OUTPUT deleted.*  
WHERE DatabaseLogID = 7;  
GO  
  

In questo esempio viene rimossa una riga da una tabella utilizzata come coda e i valori eliminati vengono restituiti all'applicazione di elaborazione in una singola azione.This example removes a row from a table used as a queue and returns the deleted values to the processing application in a single action. È possibile implementare anche altri tipi di semantica, ad esempio l'utilizzo di una tabella per implementare uno stack.Other semantics may also be implemented, such as using a table to implement a stack. SQL ServerSQL Server non garantisce tuttavia l'ordine in cui le righe vengono elaborate e restituite dalle istruzioni DML che utilizzano la clausola OUTPUT.However, SQL ServerSQL Server does not guarantee the order in which rows are processed and returned by DML statements using the OUTPUT clause. Spetta all'applicazione includere una clausola WHERE appropriata per garantire la semantica desiderata oppure tenere in considerazione che quando più righe possono essere incluse nell'operazione DML, non viene garantito alcun ordine particolare.It is up to the application to include an appropriate WHERE clause that can guarantee the desired semantics, or understand that when multiple rows may qualify for the DML operation, there is no guaranteed order. Nell'esempio seguente viene utilizzata una sottoquery e viene presupposto che l'unicità sia una caratteristica della colonna DatabaseLogID per implementare la semantica di ordinamento desiderata.The following example uses a subquery and assumes uniqueness is a characteristic of the DatabaseLogID column in order to implement the desired ordering semantics.

USE tempdb;  
GO  
CREATE TABLE dbo.table1  
(  
    id INT,  
    employee VARCHAR(32)  
);  
GO  
  
INSERT INTO dbo.table1 VALUES   
      (1, 'Fred')  
     ,(2, 'Tom')  
     ,(3, 'Sally')  
     ,(4, 'Alice');  
GO  
  
DECLARE @MyTableVar TABLE  
(  
    id INT,  
    employee VARCHAR(32)  
);  
  
PRINT 'table1, before delete'   
SELECT * FROM dbo.table1;  
  
DELETE FROM dbo.table1  
OUTPUT DELETED.* INTO @MyTableVar  
WHERE id = 4 OR id = 2;  
  
PRINT 'table1, after delete'  
SELECT * FROM dbo.table1;  
  
PRINT '@MyTableVar, after delete'  
SELECT * FROM @MyTableVar;  
  
DROP TABLE dbo.table1;  
  
--Results  
--table1, before delete  
--id          employee  
------------- ------------------------------  
--1           Fred  
--2           Tom  
--3           Sally  
--4           Alice  
--  
--table1, after delete  
--id          employee  
------------- ------------------------------  
--1           Fred  
--3           Sally  
--@MyTableVar, after delete  
--id          employee  
------------- ------------------------------  
--2           Tom  
--4           Alice  
  

Nota

Utilizzare l'hint di tabella READPAST nelle istruzioni UPDATE e DELETE se lo scenario consente a più applicazioni di eseguire una operazione di lettura distruttiva da una tabella.Use the READPAST table hint in UPDATE and DELETE statements if your scenario allows for multiple applications to perform a destructive read from one table. Ciò evita i problemi relativi ai blocchi che possono verificarsi se un'altra applicazione sta già leggendo il primo record qualificato nella tabella.This prevents locking issues that can come up if another application is already reading the first qualifying record in the table.

AutorizzazioniPermissions

Le autorizzazioni SELECT sono necessarie in ogni colonna recuperata tramite <dml_select_list> o usata in <scalar_expression>.SELECT permissions are required on any columns retrieved through <dml_select_list> or used in <scalar_expression>.

Le autorizzazioni INSERT sono necessarie in ogni tabella specificata in <output_table>.INSERT permissions are required on any tables specified in <output_table>.

EsempiExamples

A.A. Utilizzo di OUTPUT INTO con un'istruzione INSERT sempliceUsing OUTPUT INTO with a simple INSERT statement

Nell'esempio seguente viene inserita una riga nella tabella ScrapReason e viene usata la clausola OUTPUT per restituire i risultati dell'istruzione alla variabile @MyTableVar``table.The following example inserts a row into the ScrapReason table and uses the OUTPUT clause to return the results of the statement to the @MyTableVar``table variable. Poiché la colonna ScrapReasonID è definita con una proprietà IDENTITY, non è specificato un valore nell'istruzione INSERT per quella colonna.Because the ScrapReasonID column is defined with an IDENTITY property, a value is not specified in the INSERT statement for that column. Si noti tuttavia che il valore generato da Motore di databaseDatabase Engine per quella colonna viene restituito nella clausola OUTPUT nella colonna inserted.ScrapReasonID.However, note that the value generated by the Motore di databaseDatabase Engine for that column is returned in the OUTPUT clause in the column inserted.ScrapReasonID.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table( NewScrapReasonID smallint,  
                           Name varchar(50),  
                           ModifiedDate datetime);  
INSERT Production.ScrapReason  
    OUTPUT INSERTED.ScrapReasonID, INSERTED.Name, INSERTED.ModifiedDate  
        INTO @MyTableVar  
VALUES (N'Operator error', GETDATE());  
  
--Display the result set of the table variable.  
SELECT NewScrapReasonID, Name, ModifiedDate FROM @MyTableVar;  
--Display the result set of the table.  
SELECT ScrapReasonID, Name, ModifiedDate   
FROM Production.ScrapReason;  
GO  
  

B.B. Utilizzo di OUTPUT con un'istruzione DELETEUsing OUTPUT with a DELETE statement

Nell'esempio seguente vengono eliminate tutte le righe nella tabella ShoppingCartItem.The following example deletes all rows in the ShoppingCartItem table. La clausola OUTPUT deleted.* specifica che i risultati dell'istruzione DELETE, ovvero tutte le colonne nelle righe eliminate, devono essere restituiti all'applicazione chiamante.The clause OUTPUT deleted.* specifies that the results of the DELETE statement, that is all columns in the deleted rows, be returned to the calling application. L'istruzione SELECT che segue verifica i risultati dell'operazione di eliminazione nella tabella ShoppingCartItem.The SELECT statement that follows verifies the results of the delete operation on the ShoppingCartItem table.

USE AdventureWorks2012;  
GO  
DELETE Sales.ShoppingCartItem  
OUTPUT DELETED.*   
WHERE ShoppingCartID = 20621;  
  
--Verify the rows in the table matching the WHERE clause have been deleted.  
SELECT COUNT(*) AS [Rows in Table] FROM Sales.ShoppingCartItem WHERE ShoppingCartID = 20621;  
GO  
  

C.C. Utilizzo di OUTPUT INTO con un'istruzione UPDATEUsing OUTPUT INTO with an UPDATE statement

Nell'esempio seguente viene aggiornata la colonna VacationHours nella tabella Employee del 25% per le prime 10 righe.The following example updates the VacationHours column in the Employee table by 25 percent for the first 10 rows. La clausola OUTPUT restituisce il valore VacationHours esistente prima di applicare l'istruzione UPDATE nella colonna deleted.VacationHours e il valore aggiornato nella colonna inserted.VacationHours alla variabile di tabella @MyTableVar.The OUTPUT clause returns the VacationHours value that exists before applying the UPDATE statement in the column deleted.VacationHours, and the updated value in the column inserted.VacationHours to the @MyTableVar table variable.

Questa variabile è seguita da due istruzioni SELECT che restituiscono i valori in @MyTableVar e i risultati dell'operazione di aggiornamento nella tabella Employee.Two SELECT statements follow that return the values in @MyTableVar and the results of the update operation in the Employee table.

USE AdventureWorks2012;  
GO  
  
DECLARE @MyTableVar table(  
    EmpID int NOT NULL,  
    OldVacationHours int,  
    NewVacationHours int,  
    ModifiedDate datetime);  
  
UPDATE TOP (10) HumanResources.Employee  
SET VacationHours = VacationHours * 1.25,  
    ModifiedDate = GETDATE()   
OUTPUT inserted.BusinessEntityID,  
       deleted.VacationHours,  
       inserted.VacationHours,  
       inserted.ModifiedDate  
INTO @MyTableVar;  
  
--Display the result set of the table variable.  
SELECT EmpID, OldVacationHours, NewVacationHours, ModifiedDate  
FROM @MyTableVar;  
GO  
--Display the result set of the table.  
SELECT TOP (10) BusinessEntityID, VacationHours, ModifiedDate  
FROM HumanResources.Employee;  
GO  
  

D.D. Utilizzo di OUTPUT INTO per restituire un'espressioneUsing OUTPUT INTO to return an expression

Nell'esempio seguente viene utilizzato come base l'esempio C definendo un'espressione nella clausola OUTPUT come differenza tra il valore VacationHours aggiornato e il valore VacationHours prima dell'applicazione dell'aggiornamento.The following example builds on example C by defining an expression in the OUTPUT clause as the difference between the updated VacationHours value and the VacationHours value before the update was applied. Il valore di questa espressione viene restituito alla variabile @MyTableVar``table nella colonna VacationHoursDifference.The value of this expression is returned to the @MyTableVar``table variable in the column VacationHoursDifference.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table(  
    EmpID int NOT NULL,  
    OldVacationHours int,  
    NewVacationHours int,  
    VacationHoursDifference int,  
    ModifiedDate datetime);  
  
UPDATE TOP (10) HumanResources.Employee  
SET VacationHours = VacationHours * 1.25,  
    ModifiedDate = GETDATE()  
OUTPUT inserted.BusinessEntityID,  
       deleted.VacationHours,  
       inserted.VacationHours,  
       inserted.VacationHours - deleted.VacationHours,  
       inserted.ModifiedDate  
INTO @MyTableVar;  
  
--Display the result set of the table variable.  
SELECT EmpID, OldVacationHours, NewVacationHours,   
    VacationHoursDifference, ModifiedDate  
FROM @MyTableVar;  
GO  
SELECT TOP (10) BusinessEntityID, VacationHours, ModifiedDate  
FROM HumanResources.Employee;  
GO  
  

E.E. Utilizzo di OUTPUT INTO con from_table_name in un'istruzione UPDATEUsing OUTPUT INTO with from_table_name in an UPDATE statement

Nell'esempio seguente viene aggiornata la colonna ScrapReasonID nella tabella WorkOrder per tutti gli ordini di lavoro con valori ProductID e ScrapReasonID specificati.The following example updates the ScrapReasonID column in the WorkOrder table for all work orders with a specified ProductID and ScrapReasonID. La clausola OUTPUT INTO restituisce i valori dalla tabella in fase di aggiornamento (WorkOrder) e anche dalla tabella Product.The OUTPUT INTO clause returns values from the table being updated (WorkOrder) and also from the Product table. La tabella Product viene utilizzata nella clausola FROM per specificare le righe da aggiornare.The Product table is used in the FROM clause to specify the rows to update. Poiché per la tabella WorkOrder è stato definito un trigger AFTER UPDATE, è necessaria la parola chiave INTO.Because the WorkOrder table has an AFTER UPDATE trigger defined on it, the INTO keyword is required.

USE AdventureWorks2012;  
GO  
DECLARE @MyTestVar table (  
    OldScrapReasonID int NOT NULL,   
    NewScrapReasonID int NOT NULL,   
    WorkOrderID int NOT NULL,  
    ProductID int NOT NULL,  
    ProductName nvarchar(50)NOT NULL);  
  
UPDATE Production.WorkOrder  
SET ScrapReasonID = 4  
OUTPUT deleted.ScrapReasonID,  
       inserted.ScrapReasonID,   
       inserted.WorkOrderID,  
       inserted.ProductID,  
       p.Name  
    INTO @MyTestVar  
FROM Production.WorkOrder AS wo  
    INNER JOIN Production.Product AS p   
    ON wo.ProductID = p.ProductID   
    AND wo.ScrapReasonID= 16  
    AND p.ProductID = 733;  
  
SELECT OldScrapReasonID, NewScrapReasonID, WorkOrderID,   
    ProductID, ProductName   
FROM @MyTestVar;  
GO  
  

F.F. Utilizzo di OUTPUT INTO con from_table_name in un'istruzione DELETEUsing OUTPUT INTO with from_table_name in a DELETE statement

Nell'esempio seguente vengono eliminate le righe nella tabella ProductProductPhoto in base ai criteri di ricerca definiti nella clausola FROM dell'istruzione DELETE.The following example deletes rows in the ProductProductPhoto table based on search criteria defined in the FROM clause of DELETE statement. La clausola OUTPUT restituisce le colonne dalla tabella che viene eliminata (deleted.ProductID, deleted.ProductPhotoID) e dalla tabella Product.The OUTPUT clause returns columns from the table being deleted (deleted.ProductID, deleted.ProductPhotoID) and columns from the Product table. Questa tabella viene utilizzata nella clausola FROM per specificare le righe da eliminare.This table is used in the FROM clause to specify the rows to delete.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table (  
    ProductID int NOT NULL,   
    ProductName nvarchar(50)NOT NULL,  
    ProductModelID int NOT NULL,   
    PhotoID int NOT NULL);  
  
DELETE Production.ProductProductPhoto  
OUTPUT DELETED.ProductID,  
       p.Name,  
       p.ProductModelID,  
       DELETED.ProductPhotoID  
    INTO @MyTableVar  
FROM Production.ProductProductPhoto AS ph  
JOIN Production.Product as p   
    ON ph.ProductID = p.ProductID   
    WHERE p.ProductModelID BETWEEN 120 and 130;  
  
--Display the results of the table variable.  
SELECT ProductID, ProductName, ProductModelID, PhotoID   
FROM @MyTableVar  
ORDER BY ProductModelID;  
GO  
  

G.G. Utilizzo di OUTPUT INTO con un tipo di dati LOBUsing OUTPUT INTO with a large object data type

Nell'esempio seguente viene aggiornato un valore parziale in DocumentSummary, una colonna di tipo nvarchar(max) della tabella Production.Document, tramite la clausola .WRITE.The following example updates a partial value in DocumentSummary, an nvarchar(max) column in the Production.Document table, by using the .WRITE clause. La parola components viene sostituta con la parola features specificando la parola sostitutiva, la posizione iniziale (offset) della parola da sostituire nei dati esistenti e il numero di caratteri da sostituire (lunghezza).The word components is replaced by the word features by specifying the replacement word, the beginning location (offset) of the word to be replaced in the existing data, and the number of characters to be replaced (length). Nell'esempio viene usata la clausola OUTPUT per restituire le immagini precedenti e successive della colonna DocumentSummary alla variabile @MyTableVar``table.The example uses the OUTPUT clause to return the before and after images of the DocumentSummary column to the @MyTableVar``table variable. Si noti che vengono restituite le immagini complete precedenti e successive della colonna DocumentSummary.Note that the full before and after images of the DocumentSummary column are returned.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table (  
    SummaryBefore nvarchar(max),  
    SummaryAfter nvarchar(max));  
  
UPDATE Production.Document  
SET DocumentSummary .WRITE (N'features',28,10)  
OUTPUT deleted.DocumentSummary,   
       inserted.DocumentSummary   
    INTO @MyTableVar  
WHERE Title = N'Front Reflector Bracket Installation';  
  
SELECT SummaryBefore, SummaryAfter   
FROM @MyTableVar;  
GO  
  

H.H. Utilizzo di OUTPUT in un trigger INSTEAD OFUsing OUTPUT in an INSTEAD OF trigger

Nell'esempio seguente viene utilizzata la clausola OUTPUT in un trigger per restituire i risultati dell'operazione trigger.The following example uses the OUTPUT clause in a trigger to return the results of the trigger operation. Viene prima creata una vista nella tabella ScrapReason e quindi definito un trigger INSTEAD OF INSERT nella vista che consente all'utente di modificare esclusivamente la colonna Name della tabella di base.First, a view is created on the ScrapReason table, and then an INSTEAD OF INSERT trigger is defined on the view that lets only the Name column of the base table to be modified by the user. Poiché la colonna ScrapReasonID è una colonna IDENTITY nella tabella di base, il trigger ignora il valore specificato dall'utente,Because the column ScrapReasonID is an IDENTITY column in the base table, the trigger ignores the user-supplied value. consentendo a Motore di databaseDatabase Engine di generare automaticamente il valore corretto.This allows the Motore di databaseDatabase Engine to automatically generate the correct value. Inoltre, il valore specificato dall'utente per ModifiedDate viene ignorato e impostato sulla data corrente.Also, the value supplied by the user for ModifiedDate is ignored and is set to the current date. La clausola OUTPUT restituisce i valori di fatto inseriti nella tabella ScrapReason.The OUTPUT clause returns the values actually inserted into the ScrapReason table.

USE AdventureWorks2012;  
GO  
IF OBJECT_ID('dbo.vw_ScrapReason','V') IS NOT NULL  
    DROP VIEW dbo.vw_ScrapReason;  
GO  
CREATE VIEW dbo.vw_ScrapReason  
AS (SELECT ScrapReasonID, Name, ModifiedDate  
    FROM Production.ScrapReason);  
GO  
CREATE TRIGGER dbo.io_ScrapReason   
    ON dbo.vw_ScrapReason  
INSTEAD OF INSERT  
AS  
BEGIN  
--ScrapReasonID is not specified in the list of columns to be inserted   
--because it is an IDENTITY column.  
    INSERT INTO Production.ScrapReason (Name, ModifiedDate)  
        OUTPUT INSERTED.ScrapReasonID, INSERTED.Name,   
               INSERTED.ModifiedDate  
    SELECT Name, getdate()  
    FROM inserted;  
END  
GO  
INSERT vw_ScrapReason (ScrapReasonID, Name, ModifiedDate)  
VALUES (99, N'My scrap reason','20030404');  
GO  
  

Di seguito è riportato il set di risultati generato il 12 aprile 2004 ('2004-04-12').Here is the result set generated on April 12, 2004 ('2004-04-12'). Si noti che le colonne ScrapReasonIDActual e ModifiedDate riflettono i valori generati dall'operazione trigger invece dei valori specificati nell'istruzione INSERT.Notice that the ScrapReasonIDActual and ModifiedDate columns reflect the values generated by the trigger operation instead of the values provided in the INSERT statement.

ScrapReasonID  Name             ModifiedDate  
-------------  ---------------- -----------------------  
17             My scrap reason  2004-04-12 16:23:33.050

I.I. Utilizzo di OUTPUT INTO con le colonne calcolate e IdentityUsing OUTPUT INTO with identity and computed columns

Nell'esempio seguente viene creata la tabella EmployeeSales, in cui vengono quindi inserite diverse righe tramite un'istruzione INSERT con un'istruzione SELECT per il recupero dei dati dalle tabelle di origine.The following example creates the EmployeeSales table and then inserts several rows into it using an INSERT statement with a SELECT statement to retrieve data from source tables. La tabella EmployeeSales include una colonna Identity (EmployeeID) e una colonna calcolata (ProjectedSales).The EmployeeSales table contains an identity column (EmployeeID) and a computed column (ProjectedSales).

USE AdventureWorks2012 ;  
GO  
IF OBJECT_ID ('dbo.EmployeeSales', 'U') IS NOT NULL  
    DROP TABLE dbo.EmployeeSales;  
GO  
CREATE TABLE dbo.EmployeeSales  
( EmployeeID   int IDENTITY (1,5)NOT NULL,  
  LastName     nvarchar(20) NOT NULL,  
  FirstName    nvarchar(20) NOT NULL,  
  CurrentSales money NOT NULL,  
  ProjectedSales AS CurrentSales * 1.10   
);  
GO  
DECLARE @MyTableVar table(  
  EmployeeID   int NOT NULL,  
  LastName     nvarchar(20) NOT NULL,  
  FirstName    nvarchar(20) NOT NULL,  
  CurrentSales money NOT NULL,  
  ProjectedSales money NOT NULL  
  );  
  
INSERT INTO dbo.EmployeeSales (LastName, FirstName, CurrentSales)  
  OUTPUT INSERTED.LastName,   
         INSERTED.FirstName,   
         INSERTED.CurrentSales  
  INTO @MyTableVar  
    SELECT c.LastName, c.FirstName, sp.SalesYTD  
    FROM Sales.SalesPerson AS sp  
    INNER JOIN Person.Person AS c  
        ON sp.BusinessEntityID = c.BusinessEntityID  
    WHERE sp.BusinessEntityID LIKE '2%'  
    ORDER BY c.LastName, c.FirstName;  
  
SELECT EmployeeID, LastName, FirstName, CurrentSales, ProjectedSales  
FROM @MyTableVar;  
GO  
SELECT EmployeeID, LastName, FirstName, CurrentSales, ProjectedSales  
FROM dbo.EmployeeSales;  
GO  
  

J.J. Utilizzo di OUTPUT e OUTPUT INTO in una singola istruzioneUsing OUTPUT and OUTPUT INTO in a single statement

Nell'esempio seguente vengono eliminate le righe nella tabella ProductProductPhoto in base ai criteri di ricerca definiti nella clausola FROM dell'istruzione DELETE.The following example deletes rows in the ProductProductPhoto table based on search criteria defined in the FROM clause of DELETE statement. La clausola OUTPUT INTO restituisce le colonne dalla tabella che viene eliminata (deleted.ProductID, deleted.ProductPhotoID) e dalla tabella Product alla variabile @MyTableVar``table.The OUTPUT INTO clause returns columns from the table being deleted (deleted.ProductID, deleted.ProductPhotoID) and columns from the Product table to the @MyTableVar``table variable. La tabella Product viene utilizzata nella clausola FROM per specificare le righe da eliminare.The Product table is used in the FROM clause to specify the rows to delete. La clausola OUTPUT restituisce all'applicazione chiamante le colonne deleted.ProductID, deleted.ProductPhotoID e la data e l'ora in cui la riga è stata eliminata dalla tabella ProductProductPhoto.The OUTPUT clause returns the deleted.ProductID, deleted.ProductPhotoID columns and the date and time the row was deleted from the ProductProductPhoto table to the calling application.

USE AdventureWorks2012;  
GO  
DECLARE @MyTableVar table (  
    ProductID int NOT NULL,   
    ProductName nvarchar(50)NOT NULL,  
    ProductModelID int NOT NULL,   
    PhotoID int NOT NULL);  
  
DELETE Production.ProductProductPhoto  
OUTPUT DELETED.ProductID,  
       p.Name,  
       p.ProductModelID,  
       DELETED.ProductPhotoID  
    INTO @MyTableVar  
OUTPUT DELETED.ProductID, DELETED.ProductPhotoID, GETDATE() AS DeletedDate   
FROM Production.ProductProductPhoto AS ph  
JOIN Production.Product as p   
    ON ph.ProductID = p.ProductID   
WHERE p.ProductID BETWEEN 800 and 810;  
  
--Display the results of the table variable.  
SELECT ProductID, ProductName, PhotoID, ProductModelID   
FROM @MyTableVar;  
GO  
  

K.K. Inserimento dei dati restituiti da una clausola OUTPUTInserting data returned from an OUTPUT clause

Nell'esempio seguente vengono acquisiti i dati restituiti dalla clausola OUTPUT di un'istruzione MERGE e tali dati vengono inseriti in un'altra tabella.The following example captures data returned from the OUTPUT clause of a MERGE statement, and inserts that data into another table. L'istruzione MERGE aggiorna la colonna Quantity della tabella ProductInventory su base giornaliera, in base agli ordini elaborati nella tabella SalesOrderDetail.The MERGE statement updates the Quantity column of the ProductInventory table daily, based on orders that are processed in the SalesOrderDetail table. Vengono inoltre eliminate le righe dei prodotti le cui scorte scendono a 0 oppure a un valore inferiore.It also deletes rows for products whose inventories drop to 0 or below. In questo esempio vengono acquisite le righe eliminate, che vengono inserite in un'altra tabella, ZeroInventory, in cui viene tenuta traccia dei prodotti senza scorte.The example captures the rows that are deleted and inserts them into another table, ZeroInventory, which tracks products with no inventory.

USE AdventureWorks2012;  
GO  
IF OBJECT_ID(N'Production.ZeroInventory', N'U') IS NOT NULL  
    DROP TABLE Production.ZeroInventory;  
GO  
--Create ZeroInventory table.  
CREATE TABLE Production.ZeroInventory (DeletedProductID int, RemovedOnDate DateTime);  
GO  
  
INSERT INTO Production.ZeroInventory (DeletedProductID, RemovedOnDate)  
SELECT ProductID, GETDATE()  
FROM  
(   MERGE Production.ProductInventory AS pi  
    USING (SELECT ProductID, SUM(OrderQty) FROM Sales.SalesOrderDetail AS sod  
           JOIN Sales.SalesOrderHeader AS soh  
           ON sod.SalesOrderID = soh.SalesOrderID  
           AND soh.OrderDate = '20070401'  
           GROUP BY ProductID) AS src (ProductID, OrderQty)  
    ON (pi.ProductID = src.ProductID)  
    WHEN MATCHED AND pi.Quantity - src.OrderQty <= 0  
        THEN DELETE  
    WHEN MATCHED  
        THEN UPDATE SET pi.Quantity = pi.Quantity - src.OrderQty  
    OUTPUT $action, deleted.ProductID) AS Changes (Action, ProductID)  
WHERE Action = 'DELETE';  
IF @@ROWCOUNT = 0  
PRINT 'Warning: No rows were inserted';  
GO  
SELECT DeletedProductID, RemovedOnDate FROM Production.ZeroInventory;  
  

Vedere ancheSee Also

DELETE (Transact-SQL) DELETE (Transact-SQL)
INSERT (Transact-SQL) INSERT (Transact-SQL)
UPDATE (Transact-SQL) UPDATE (Transact-SQL)
table (Transact-SQL) table (Transact-SQL)
CREATE TRIGGER (Transact-SQL) CREATE TRIGGER (Transact-SQL)
sp_configure (Transact-SQL)sp_configure (Transact-SQL)