OUTPUT (cláusula de Transact-SQL)OUTPUT Clause (Transact-SQL)

SE APLICA A: síSQL Server síAzure SQL Database noAzure Synapse Analytics (SQL DW) noAlmacenamiento de datos paralelosAPPLIES TO: yesSQL Server yesAzure SQL Database noAzure Synapse Analytics (SQL DW) noParallel Data Warehouse

Devuelve información de las filas afectadas por una instrucción INSERT, UPDATE, DELETE o MERGE, o expresiones basadas en esas filas.Returns information from, or expressions based on, each row affected by an INSERT, UPDATE, DELETE, or MERGE statement. Estos resultados se pueden devolver a la aplicación de procesamiento para que los utilice en mensajes de confirmación, archivado y otros requisitos similares de una aplicación.These results can be returned to the processing application for use in such things as confirmation messages, archiving, and other such application requirements. Los resultados también se pueden insertar en una tabla o variable de tabla.The results can also be inserted into a table or table variable. Además, puede capturar los resultados de una cláusula OUTPUT en una instrucción anidada INSERT, UPDATE, DELETE o MERGE, e insertar los resultados en una tabla de destino o vista.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

Una instrucción UPDATE, INSERT o DELETE que tenga una cláusula OUTPUT devolverá filas al cliente aunque la instrucción encuentre errores y se revierta.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. El resultado no se debe usar si se produce algún error al ejecutar la instrucción.The result should not be used if any error occurs when you run the statement.

Se usa en:Used in:

DELETEDELETE

INSERTINSERT

UPDATEUPDATE

MERGEMERGE

Icono de vínculo de tema Convenciones de sintaxis de Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SintaxisSyntax

  
<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  

ArgumentosArguments

@table_variable@table_variable
Especifica una variable tabla en la que se insertan las filas devueltas en lugar de devolverse al autor de la llamada.Specifies a table variable that the returned rows are inserted into instead of being returned to the caller. Se debe declarar @table_variable antes de la instrucción INSERT, UPDATE, DELETE o MERGE.@table_variable must be declared before the INSERT, UPDATE, DELETE, or MERGE statement.

Si no se especifica lista_de_columnas, la variable tabla debe tener el mismo número de columnas que el conjunto de resultados de OUTPUT.If column_list is not specified, the table variable must have the same number of columns as the OUTPUT result set. Las excepciones son las columnas de identidad y calculadas, que deben omitirse.The exceptions are identity and computed columns, which must be skipped. Si se especifica lista_de_columnas, las columnas omitidas deben aceptar valores NULL o tener valores predeterminados asignados.If column_list is specified, any omitted columns must either allow null values or have default values assigned to them.

Para obtener más información sobre las variables tabla, vea tabla (Transact-SQL).For more information about table variables, see table (Transact-SQL).

tabla_de_salidaoutput_table
Especifica una tabla en la que se insertan las filas devueltas en lugar de devolverse al autor de la llamada.Specifies a table that the returned rows are inserted into instead of being returned to the caller. tabla_de_salida puede ser una tabla temporal.output_table may be a temporary table.

Si no se especifica lista_de_columnas, la tabla debe tener el mismo número de columnas que el conjunto de resultados de OUTPUT.If column_list is not specified, the table must have the same number of columns as the OUTPUT result set. Las excepciones son las columnas de identidad y calculadas.The exceptions are identity and computed columns. Éstas deben omitirse.These must be skipped. Si se especifica lista_de_columnas, las columnas omitidas deben aceptar valores NULL o tener valores predeterminados asignados.If column_list is specified, any omitted columns must either allow null values or have default values assigned to them.

tabla_de_salida no puede:output_table cannot:

  • Tener definidos desencadenadores habilitados.Have enabled triggers defined on it.

  • Participar en alguna de las partes de una restricción FOREIGN KEY.Participate on either side of a FOREIGN KEY constraint.

  • Tener restricciones CHECK o reglas habilitadas.Have CHECK constraints or enabled rules.

lista_de_columnascolumn_list
Es una lista opcional de nombres de columna de la tabla de destino de la cláusula INTO.Is an optional list of column names on the target table of the INTO clause. Es equivalente a la lista de columnas permitida en la instrucción INSERT.It is analogous to the column list allowed in the INSERT statement.

scalar_expressionscalar_expression
Es cualquier combinación de símbolos y operadores que se evalúa como un solo valor.Is any combination of symbols and operators that evaluates to a single value. En expresión_escalar no se permiten funciones de agregado.Aggregate functions are not permitted in scalar_expression.

Cualquier referencia a las columnas de la tabla que se va a modificar debe calificarse con el prefijo 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
Es un nombre alternativo que se utiliza para hacer referencia al nombre de columna.Is an alternative name used to reference the column name.

DELETEDDELETED
Es un prefijo de columna que especifica el valor eliminado en la operación de actualización o eliminación.Is a column prefix that specifies the value deleted by the update or delete operation. Las columnas con prefijo DELETED reflejan el valor antes de que se complete la instrucción UPDATE, DELETE o MERGE.Columns prefixed with DELETED reflect the value before the UPDATE, DELETE, or MERGE statement is completed.

DELETED no se puede utilizar con la cláusula OUTPUT en la instrucción INSERT.DELETED cannot be used with the OUTPUT clause in the INSERT statement.

INSERTEDINSERTED
Es un prefijo de columna que especifica el valor agregado en la operación de inserción o actualización.Is a column prefix that specifies the value added by the insert or update operation. Las columnas con prefijo INSERTED reflejan el valor después de que se complete la instrucción UPDATE, INSERT o MERGE, pero antes de que se ejecuten los desencadenadores.Columns prefixed with INSERTED reflect the value after the UPDATE, INSERT, or MERGE statement is completed but before triggers are executed.

INSERTED no se puede utilizar con la cláusula OUTPUT en la instrucción DELETE.INSERTED cannot be used with the OUTPUT clause in the DELETE statement.

from_table_namefrom_table_name
Es un prefijo de columna que especifica una tabla incluida en la cláusula FROM de una instrucción DELETE, UPDATE o MERGE que se utiliza para especificar las filas que se van a actualizar o eliminar.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.

Si la tabla que se va a modificar se especifica también en la cláusula FROM, cualquier referencia a las columnas de esa tabla deben calificarse con el prefijo 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.

*
Especifica que todas las columnas afectadas por la acción de eliminación, inserción o actualización se devuelvan en el orden en que se encuentran en la tabla.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.

Por ejemplo, OUTPUT DELETED.* en la siguiente instrucción DELETE devuelve todas las columnas eliminadas de la tabla 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
Es una referencia explícita a una columna.Is an explicit column reference. Cualquier referencia a la tabla que se va a modificar se debe certificar correctamente mediante el prefijo INSERTED o DELETED, según corresponda; por ejemplo: 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
Solo está disponible para la instrucción MERGE.Is available only for the MERGE statement. Especifica una columna de tipo nvarchar(10) en la cláusula OUTPUT de una instrucción MERGE que devuelve uno de estos tres valores por cada fila: "INSERT", "UPDATE" o "DELETE", según la acción realizada en esa fila.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.

ObservacionesRemarks

Las cláusulas OUTPUT <dml_select_list> clause and the OUTPUT <dml_select_list> INTO { @ table_variable | output_table } se pueden definir en una única instrucción 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

A menos que se indique lo contrario, las referencias a la cláusula OUTPUT se refieren tanto a la cláusula OUTPUT como a la cláusula OUTPUT INTO.Unless specified otherwise, references to the OUTPUT clause refer to both the OUTPUT clause and the OUTPUT INTO clause.

La cláusula OUTPUT puede ser útil para recuperar el valor de las columnas de identidad o calculadas después de una operación con INSERT o UPDATE.The OUTPUT clause may be useful to retrieve the value of identity or computed columns after an INSERT or UPDATE operation.

Cuando se incluye una columna calculada en <lista_de_selección_dml>, la columna correspondiente de la tabla de salida o la variable de tabla no es una columna calculada.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. Los valores de la nueva columna son los que se calcularon en el momento en que se ejecutó la instrucción.The values in the new column are the values that were computed at the time the statement was executed.

No se garantiza que coincidan el orden en que se aplican los cambios en la tabla y el orden en que se insertan las filas en la tabla de salida o variable de tabla.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.

Si se modifican parámetros o variables como parte de una instrucción UPDATE, la cláusula OUTPUT siempre devuelve el valor del parámetro o la variable tal como se encontraba antes de ejecutar la instrucción, en lugar de devolver el valor modificado.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.

OUTPUT se puede utilizar con una instrucción UPDATE o DELETE en un cursor que utilice la sintaxis WHERE CURRENT OF.You can use OUTPUT with an UPDATE or DELETE statement positioned on a cursor that uses WHERE CURRENT OF syntax.

La cláusula OUTPUT no se admite en las siguientes instrucciones:The OUTPUT clause is not supported in the following statements:

  • Instrucciones DML que hacen referencia a vistas locales con particiones, vistas distribuidas con particiones o tablas remotas.DML statements that reference local partitioned views, distributed partitioned views, or remote tables.

  • Instrucciones INSERT que contienen una instrucción EXECUTE.INSERT statements that contain an EXECUTE statement.

  • Los predicados de texto completo no están permitidos en la cláusula OUTPUT cuando el nivel de compatibilidad de la base de datos está establecido en 100.Full-text predicates are not allowed in the OUTPUT clause when the database compatibility level is set to 100.

  • La cláusula OUTPUT INTO no se puede utilizar para realizar inserciones en vistas o en una función de conjunto de filas.The OUTPUT INTO clause cannot be used to insert into a view, or rowset function.

  • No se puede crear una función definida por el usuario si contiene una cláusula OUTPUT INTO que tiene una tabla como destino.A user-defined function cannot be created if it contains an OUTPUT INTO clause that has a table as its target.

Para evitar el comportamiento no determinista, la cláusula OUTPUT no puede contener las referencias siguientes:To prevent nondeterministic behavior, the OUTPUT clause cannot contain the following references:

  • Subconsultas o funciones definidas por el usuario que obtienen acceso a datos de usuario o del sistema, o que se asume que obtienen dicho acceso.Subqueries or user-defined functions that perform user or system data access, or are assumed to perform such access. Se supone que las funciones definidas por el usuario realizan el acceso a los datos si no están enlazadas a un esquema.User-defined functions are assumed to perform data access if they are not schema-bound.

  • Una columna de una vista o función insertada con valores de tabla si la columna se define mediante uno de los métodos siguientes:A column from a view or inline table-valued function when that column is defined by one of the following methods:

    • Una subconsulta.A subquery.

    • Una función definida por el usuario que obtiene acceso a datos de usuario o del sistema, o que se asume que obtiene dicho acceso.A user-defined function that performs user or system data access, or is assumed to perform such access.

    • Una columna calculada que contiene una función definida por el usuario que obtiene acceso a datos de usuario o del sistema en su definición.A computed column that contains a user-defined function that performs user or system data access in its definition.

    Cuando SQL ServerSQL Server detecta este tipo de columna en la cláusula OUTPUT, se produce el error 4186.When SQL ServerSQL Server detects such a column in the OUTPUT clause, error 4186 is raised.

Insertar datos devueltos de una cláusula OUTPUT en una tablaInserting Data Returned From an OUTPUT Clause Into a Table

Al capturar los resultados de una cláusula OUTPUT en una instrucción INSERT, UPDATE, DELETE o MERGE anidada e insertarlos en una tabla de destino, tenga presente la información siguiente: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:

  • Toda la operación es atómica.The whole operation is atomic. Se ejecutarán la instrucción INSERT y la instrucción DML anidada que contiene la cláusula OUTPUT, o bien se producirá un error en toda la instrucción.Either both the INSERT statement and the nested DML statement that contains the OUTPUT clause execute, or the whole statement fails.

  • Las restricciones siguientes se aplican al destino de la instrucción INSERT externa:The following restrictions apply to the target of the outer INSERT statement:

    • El destino no puede ser una expresión de tabla común, vista o tabla remota.The target cannot be a remote table, view, or common table expression.

    • El destino no puede tener una restricción FOREIGN KEY, ni ser objeto de referencia por una restricción FOREIGN KEY.The target cannot have a FOREIGN KEY constraint, or be referenced by a FOREIGN KEY constraint.

    • No se pueden definir desencadenadores en el destino.Triggers cannot be defined on the target.

    • El destino no puede participar en la replicación de mezcla ni en las suscripciones actualizables para la replicación transaccional.The target cannot participate in merge replication or updatable subscriptions for transactional replication.

  • Las restricciones siguientes se aplican a la instrucción DML anidada:The following restrictions apply to the nested DML statement:

    • El destino no puede ser una tabla remota ni una vista con particiones.The target cannot be a remote table or partitioned view.

    • El propio origen no puede contener una cláusula <dml_table_source>.The source itself cannot contain a <dml_table_source> clause.

  • La cláusula OUTPUT INTO no se admite en instrucciones INSERT que contengan una cláusula <dml_table_source>.The OUTPUT INTO clause is not supported in INSERT statements that contain a <dml_table_source> clause.

  • @@ROWCOUNT devuelve las filas insertadas únicamente por la instrucción INSERT externa.@@ROWCOUNT returns the rows inserted only by the outer INSERT statement.

  • @@IDENTITY, SCOPE_IDENTITY e IDENT_CURRENT devuelven los valores de identidad generados solo por la instrucción DML anidada, y no los generados por la instrucción INSERT externa.@@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.

  • Las notificaciones de consulta tratan la instrucción como una entidad única, y el tipo de cualquier mensaje creado es el del DML anidado, aunque el cambio significativo provenga de la propia instrucción INSERT externa.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.

  • En la cláusula <dml_table_source>, las cláusulas SELECT y WHERE no pueden incluir subconsultas, funciones de agregado, funciones de categoría, predicados de texto completo, funciones definidas por el usuario que realicen accesos a datos, ni la función 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.

ParalelismoParallelism

Una cláusula OUTPUT que devuelve resultados al cliente siempre usará un plan en serie.An OUTPUT clause that returns results to the client will always use a serial plan.

En el contexto de una base de datos configurada en el nivel de compatibilidad 130 o superior, si en una operación INSERT…SELECT se usa una sugerencia WITH (TABLOCK) para la instrucción SELECT y también OUTPUT…INTO para insertar en una tabla temporal o de usuario, la tabla de destino para la instrucción INSERT…SELECT será apta para el paralelismo según el costo de subárbol.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 tabla de destino a la que se hace referencia en la cláusula OUTPUT INTO no será apta para el paralelismo.The target table referenced in the OUTPUT INTO clause will not be eligible for parallelism.

DesencadenadoresTriggers

Las columnas devueltas de OUTPUT reflejan los datos tal como estaban después de completarse la instrucción INSERT, UPDATE o DELETE, pero antes de ejecutarse los desencadenadores.Columns returned from OUTPUT reflect the data as it is after the INSERT, UPDATE, or DELETE statement has completed but before triggers are executed.

En el caso de los desencadenadores INSTEAD OF, los resultados devueltos se generan como si la operación de INSERT, UPDATE o DELETE se hubiese producido realmente, aunque no se produzcan modificaciones como resultado de la operación del desencadenador.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. Si se utiliza una instrucción que incluye una cláusula OUTPUT en el cuerpo de un desencadenador, deben utilizarse alias de tabla para hacer referencia a las tablas inserted y deleted del desencadenador con el fin de evitar la duplicación de las referencias a columnas con las tablas INSERTED y DELETED asociadas 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.

Si la cláusula OUTPUT se especifica sin especificar también la palabra clave INTO, el destino de la operación DML no puede tener definido ningún desencadenador habilitado para la acción DML dada.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. Por ejemplo, si se define la cláusula OUTPUT en una instrucción UPDATE, la tabla de destino no puede tener desencadenadores UPDATE habilitados.For example, if the OUTPUT clause is defined in an UPDATE statement, the target table cannot have any enabled UPDATE triggers.

Si se establece la opción disallow results from triggers de sp_configure, una cláusula OUTPUT sin una cláusula INTO hará que la instrucción genere un error cuando se llame desde un desencadenador.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.

Tipo de datosData Types

La cláusula OUTPUT admite los tipos de datos de objetos grandes: nvarchar(max) , varchar(max) , varbinary(max) , text, ntext, image y xml.The OUTPUT clause supports the large object data types: nvarchar(max), varchar(max), varbinary(max), text, ntext, image, and xml. Cuando se usa la cláusula .WRITE en la instrucción UPDATE para modificar una columna de tipo nvarchar(max) , varchar(max) o varbinary(max) , se devuelven las imágenes anterior y posterior completas de los valores si se hace referencia a ellas.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 función TEXTPTR() no puede aparecer como parte de una expresión en una columna de tipo text, ntext o image en la cláusula OUTPUT.The TEXTPTR( ) function cannot appear as part of an expression on a text, ntext, or image column in the OUTPUT clause.

ColasQueues

OUTPUT se puede utilizar en aplicaciones que utilizan tablas como colas, o para contener conjuntos de resultados intermedios.You can use OUTPUT in applications that use tables as queues, or to hold intermediate result sets. Dicho de otro modo, la aplicación agrega o quita filas de la tabla constantemente.That is, the application is constantly adding or removing rows from the table. En el ejemplo siguiente se utiliza la cláusula OUTPUT en una instrucción DELETE para devolver la fila eliminada a la aplicación que realiza la llamada.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  
  

En este ejemplo, se quita una fila de una tabla utilizada como cola y se devuelven los valores eliminados a la aplicación de procesamiento en una única acción.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. También se puede implementar otro tipo de semántica, como utilizar una tabla para implementar una pila.Other semantics may also be implemented, such as using a table to implement a stack. No obstante, SQL ServerSQL Server no garantiza el orden en que las instrucciones DML procesan y devuelven las filas por medio de la cláusula OUTPUT.However, SQL ServerSQL Server does not guarantee the order in which rows are processed and returned by DML statements using the OUTPUT clause. Es la aplicación la que debe incluir una cláusula WHERE que garantice la semántica deseada, o reconocer que, si hay varias filas aptas para la operación DML, no se garantiza el orden.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. En el ejemplo siguiente se utiliza una subconsulta y se supone que la unicidad es una característica de la columna DatabaseLogID para implementar la semántica de ordenación deseada.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

Use la sugerencia de tabla READPAST en las instrucciones UPDATE y DELETE si el escenario permite que varias aplicaciones realicen una lectura destructiva de una tabla.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. De esta forma se impide que surjan problemas de bloqueo si otra aplicación ya está leyendo el primer registro de la tabla que reúne los requisitos.This prevents locking issues that can come up if another application is already reading the first qualifying record in the table.

PermisosPermissions

Se requieren permisos SELECT en las columnas recuperadas a través de <lista_de_selección_dml> o usadas en <expresión_escalar>.SELECT permissions are required on any columns retrieved through <dml_select_list> or used in <scalar_expression>.

Se requieren permisos INSERT en las tablas especificadas en <tabla_de_salida>.INSERT permissions are required on any tables specified in <output_table>.

EjemplosExamples

A.A. Utilizar OUTPUT INTO con una instrucción INSERT simpleUsing OUTPUT INTO with a simple INSERT statement

En el siguiente ejemplo se inserta una fila en la tabla ScrapReason y se usa la cláusula OUTPUT para devolver los resultados de la instrucción a la variable @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. Como la columna ScrapReasonID se ha definido con una propiedad IDENTITY, no se especifica ningún valor en la instrucción INSERT de esa columna.Because the ScrapReasonID column is defined with an IDENTITY property, a value is not specified in the INSERT statement for that column. No obstante, tenga en cuenta que el valor generado por el Motor de base de datosDatabase Engine para esa columna se devuelve en la cláusula OUTPUT de la columna inserted.ScrapReasonID.However, note that the value generated by the Motor de base de datosDatabase 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. Usar OUTPUT con una instrucción DELETEUsing OUTPUT with a DELETE statement

En el ejemplo siguiente se eliminan todas las filas de la tabla ShoppingCartItem.The following example deletes all rows in the ShoppingCartItem table. La cláusula OUTPUT deleted.* especifica que se devuelvan a la aplicación que realiza la llamada los resultados de la instrucción DELETE, es decir, todas las columnas de las filas eliminadas.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. La instrucción SELECT posterior comprueba los resultados de la operación de eliminación en la tabla 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. Usar OUTPUT INTO con una instrucción UPDATEUsing OUTPUT INTO with an UPDATE statement

En el ejemplo siguiente se actualiza un 25 por ciento la columna VacationHours de las 10 primeras filas de la tabla Employee.The following example updates the VacationHours column in the Employee table by 25 percent for the first 10 rows. La cláusula OUTPUT devuelve el valor de VacationHours antes de aplicar la instrucción UPDATE en la columna deleted.VacationHours y el valor actualizado en la columna inserted.VacationHours en la variable de tabla @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.

Las dos instrucciones SELECT que le siguen devuelven los valores en @MyTableVar y los resultados de la operación de actualización en la tabla 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. Usar OUTPUT INTO para devolver una expresiónUsing OUTPUT INTO to return an expression

El ejemplo siguiente, que se basa en el ejemplo C, define una expresión en la cláusula OUTPUT como la diferencia entre el valor actualizado de VacationHours y el valor de VacationHours antes de aplicar la actualización.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. El valor de esta expresión se devuelve a la variable @MyTableVar``table en la columna 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. Usar OUTPUT INTO con from_table_name en una instrucción UPDATEUsing OUTPUT INTO with from_table_name in an UPDATE statement

En el ejemplo siguiente se actualiza la columna ScrapReasonID de la tabla WorkOrder para todas las órdenes de trabajo en las que se especifique ProductID y ScrapReasonID.The following example updates the ScrapReasonID column in the WorkOrder table for all work orders with a specified ProductID and ScrapReasonID. La cláusula OUTPUT INTO devuelve los valores de la tabla que se actualiza (WorkOrder) y de la tabla Product.The OUTPUT INTO clause returns values from the table being updated (WorkOrder) and also from the Product table. La tabla Product se utiliza en la cláusula FROM para especificar las filas que se van a actualizar.The Product table is used in the FROM clause to specify the rows to update. Dado que la tabla WorkOrder tiene definido un desencadenador AFTER UPDATE, se requiere la palabra clave 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. Usar OUTPUT INTO con from_table_name en una instrucción DELETEUsing OUTPUT INTO with from_table_name in a DELETE statement

En el ejemplo siguiente se eliminan las filas de la tabla ProductProductPhoto según los criterios de búsqueda definidos en la cláusula FROM de la instrucción DELETE.The following example deletes rows in the ProductProductPhoto table based on search criteria defined in the FROM clause of DELETE statement. La cláusula OUTPUT devuelve columnas de la tabla que se elimina (deleted.ProductID, deleted.ProductPhotoID) y de la tabla Product.The OUTPUT clause returns columns from the table being deleted (deleted.ProductID, deleted.ProductPhotoID) and columns from the Product table. La tabla se utiliza en la cláusula FROM para especificar las filas que se van a eliminar.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. Usar OUTPUT INTO con un tipo de datos de objetos grandesUsing OUTPUT INTO with a large object data type

En el ejemplo siguiente se actualiza un valor parcial de DocumentSummary, una columna de tipo nvarchar(max) de la tabla Production.Document, utilizando la cláusula .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 palabra components se sustituye por la palabra features al especificar la palabra sustituta, la ubicación inicial (desplazamiento) de la palabra que se va a sustituir en los datos existentes y el número de caracteres que se va a sustituir (longitud).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). En el ejemplo se usa la cláusula OUTPUT para devolver las imágenes anterior y posterior de la columna DocumentSummary a la variable @MyTableVar``table.The example uses the OUTPUT clause to return the before and after images of the DocumentSummary column to the @MyTableVar``table variable. Observe que se devuelven las imágenes anterior y posterior completas de la columna 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. Usar OUTPUT en un desencadenador INSTEAD OFUsing OUTPUT in an INSTEAD OF trigger

En el ejemplo siguiente se utiliza la cláusula OUTPUT en un desencadenador para devolver los resultados de la operación del desencadenador.The following example uses the OUTPUT clause in a trigger to return the results of the trigger operation. En primer lugar se crea una vista en la tabla ScrapReason y, después, en la vista se define un desencadenador INSTEAD OF INSERT que permite al usuario modificar únicamente la columna Name de la tabla 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. Puesto que la columna ScrapReasonID es una columna IDENTITY de la tabla base, el desencadenador omite el valor suministrado por el usuario.Because the column ScrapReasonID is an IDENTITY column in the base table, the trigger ignores the user-supplied value. Esto permite que el Motor de base de datosDatabase Engine genere automáticamente el valor correcto.This allows the Motor de base de datosDatabase Engine to automatically generate the correct value. Asimismo, se omite el valor suministrado por el usuario para ModifiedDate, que se establece en la fecha actual.Also, the value supplied by the user for ModifiedDate is ignored and is set to the current date. La cláusula OUTPUT devuelve los valores reales insertados en la tabla 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  
  

Éste es el conjunto de resultados generado el 12 de abril de 2004 ('2004-04-12').Here is the result set generated on April 12, 2004 ('2004-04-12'). Tenga en cuenta que las columnas ScrapReasonIDActual y ModifiedDate reflejan los valores generados en la operación del desencadenador en lugar de los valores suministrados en la instrucción 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. Usar OUTPUT INTO con columnas de identidad y calculadasUsing OUTPUT INTO with identity and computed columns

En el ejemplo siguiente se crea la tabla EmployeeSales y, después, se insertan en ella varias filas utilizando una instrucción INSERT con una instrucción SELECT para recuperar los datos de las tablas de origen.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 tabla EmployeeSales contiene una columna de identidad (EmployeeID) y una columna calculada (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.EmployeeID,
         INSERTED.LastName,   
         INSERTED.FirstName,   
         INSERTED.CurrentSales,
         INSERTED.ProjectedSales
  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. Usar OUTPUT y OUTPUT INTO en una sola instrucciónUsing OUTPUT and OUTPUT INTO in a single statement

En el ejemplo siguiente se eliminan las filas de la tabla ProductProductPhoto según los criterios de búsqueda definidos en la cláusula FROM de la instrucción DELETE.The following example deletes rows in the ProductProductPhoto table based on search criteria defined in the FROM clause of DELETE statement. La cláusula OUTPUT INTO devuelve las columnas de la tabla que se elimina (deleted.ProductID, deleted.ProductPhotoID) y columnas de la tabla Product a la variable @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 tabla Product se utiliza en la cláusula FROM para especificar las filas que se van a eliminar.The Product table is used in the FROM clause to specify the rows to delete. La cláusula OUTPUT devuelve las columnas deleted.ProductID y deleted.ProductPhotoID, y la fecha y hora de eliminación de la fila de la tabla ProductProductPhoto a la aplicación que realiza la llamada.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. Insertar los datos devueltos por una cláusula OUTPUTInserting data returned from an OUTPUT clause

El ejemplo siguiente captura datos devueltos por la cláusula OUTPUT de una instrucción MERGE y los inserta en otra tabla.The following example captures data returned from the OUTPUT clause of a MERGE statement, and inserts that data into another table. La instrucción MERGE actualiza diariamente la columna Quantity de la tabla ProductInventory en función de los pedidos procesados en la tabla SalesOrderDetail.The MERGE statement updates the Quantity column of the ProductInventory table daily, based on orders that are processed in the SalesOrderDetail table. También elimina las filas correspondientes a los productos cuyas existencias están en el valor 0 o por debajo de este valor.It also deletes rows for products whose inventories drop to 0 or below. En el ejemplo, se capturan las filas que se eliminan y se insertan en otra tabla, ZeroInventory, que realiza el seguimiento de los productos sin existencias.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;  
  

Consulte tambiénSee 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)