DELETE (Transact-SQL)

 

Quita una o varias filas de una tabla o vista de SQL Server.

Se aplica a: SQL Server (desde SQL Server 2008 hasta la versión actual), Base de datos SQL de Azure.

Convenciones de sintaxis de Transact-SQL

Sintaxis

[ WITH <common_table_expression> [ ,...n ] ]
DELETE 
    [ TOP (expression ) [ PERCENT ] ] 
    [ FROM ] 
    { { table_alias
      | <object> 
      | rowset_function_limited 
      [ WITH (table_hint_limited [ ...n ] ) ] } 
      | @table_variable
    }
    [ <OUTPUT Clause> ]
    [ FROM table_source [ ,...n ] ] 
    [ WHERE { <search_condition> 
            | { [ CURRENT OF 
                   { { [ GLOBAL ] cursor_name } 
                       | cursor_variable_name 
                   } 
                ]
              }
            } 
    ] 
    [ OPTION ( <Query Hint> [ ,...n ] ) ] 
[; ]

<object> ::=
{ 
    [ server_name.database_name.schema_name. 
      | database_name. [ schema_name ] . 
      | schema_name.
    ]
    table_or_view_name 
}

Argumentos

• WITH <common_table_expression>
  Especifica el conjunto de resultados de nombre temporal, también conocido como expresión de tabla común, definido dentro del ámbito de la instrucción DELETE. El conjunto de resultados se deriva de una instrucción SELECT.

  Las expresiones de tabla comunes también se pueden utilizar con las instrucciones SELECT, INSERT, UPDATE y CREATE VIEW. Para obtener más información, consulte WITH common_table_expression (Transact-SQL).

• TOP (expression) [ PERCENT ]
  Especifica el número o el porcentaje de filas aleatorias que se van a eliminar.expression puede ser un número o un porcentaje de las filas. Las filas a las que se hace referencia en la expresión TOP utilizada con INSERT, UPDATE o DELETE no se ordenan. Para más información, consulte TOP (Transact-SQL).

• FROM
  Palabra clave opcional que se puede usar entre la palabra clave DELETE y el destino table_or_view_name o rowset_function_limited.

• table_alias
  Alias especificado en la cláusula FROM table_source que representa la tabla o vista de la que se van a eliminar las filas.

• server_name

  Se aplica a: desde SQL Server 2008 hasta SQL Server 2014.

  Nombre del servidor (un nombre de servidor vinculado o la función OPENDATASOURCE como nombre de servidor) en el que se encuentra la tabla o la vista. Si se especifica server_name, son obligatorios database_name y schema_name.

• database_name
  El nombre de la base de datos.

• schema_name
  Nombre del esquema al que pertenece la tabla o la vista.

• table_or view_name
  Nombre de la tabla o vista cuyas filas se van a quitar.

  En este ámbito, se puede utilizar una variable de tabla como origen de tabla de una instrucción DELETE.

  La vista a la que hace referencia table_or_view_name debe poderse actualizar y debe hacer referencia exactamente a una tabla base de la cláusula FROM de la definición de vista. Para obtener más información acerca de las vistas que se pueden actualizar, vea CREATE VIEW (Transact-SQL).

• rowset_function_limited

  Se aplica a: desde SQL Server 2008 hasta SQL Server 2014.

  Función OPENQUERY u OPENROWSET, dependiendo del proveedor.

• WITH ( <table_hint_limited> [... n] )
  Especifica una o varias sugerencias de tabla que están permitidas en una tabla de destino. La palabra clave WITH y los paréntesis son obligatorios. No se permiten NOLOCK ni READUNCOMMITTED. Para obtener más información acerca de las sugerencias de tabla, vea Sugerencias de tabla (Transact-SQL).

• <OUTPUT_Clause>
  Devuelve filas eliminadas, o expresiones basadas en ellas, como parte de la operación DELETE. La cláusula OUTPUT no se admite en instrucciones DML dirigidas a tablas o vistas remotas. Para obtener más información, consulte OUTPUT (cláusula de Transact-SQL).

• FROM table_source
  Especifica una cláusula FROM adicional. Esta extensión de Transact-SQL para DELETE permite especificar datos de <table_source> y eliminar las filas correspondientes de la tabla en la primera cláusula FROM.

  Se puede utilizar esta extensión, que especifica una combinación, en lugar de una subconsulta en la cláusula WHERE para identificar las filas que se van a quitar.

  Para más información, consulte FROM (Transact-SQL).

• WHERE
  Especifica las condiciones utilizadas para limitar el número de filas que se van a eliminar. Si no se proporciona una cláusula WHERE, DELETE quita todas las filas de la tabla.

  Hay dos formas de operaciones de eliminación, que se basan en las condiciones que se especifiquen en la cláusula WHERE:

  • Las eliminaciones por búsqueda especifican una condición de búsqueda que califica las filas que se van a eliminar. Por ejemplo, WHERE column_name = value.

  • Las eliminaciones por posición utilizan la cláusula CURRENT OF para especificar un cursor. La operación de eliminación se produce en la posición actual del cursor. Este método puede ser más preciso que una instrucción DELETE por búsqueda que utilice una cláusula WHERE search_condition para calificar las filas que se van a eliminar. Una instrucción DELETE por búsqueda elimina varias filas si la condición de búsqueda no identifica exclusivamente una única fila.

• <search_condition>
  Especifica las condiciones restrictivas de las filas que se van a eliminar. No hay límite en el número de predicados que se pueden incluir en una condición de búsqueda. Para más información, consulte Condiciones de búsqueda (Transact-SQL).

• CURRENT OF
  Especifica que la instrucción DELETE se ejecutará en la posición actual del cursor especificado.

• GLOBAL
  Especifica que cursor_name hace referencia a un cursor global.

• cursor_name
  Es el nombre del cursor abierto desde el que se realiza la captura. Si hay un cursor global y otro local con el nombre cursor_name, este argumento hace referencia al cursor global si se especifica GLOBAL; de lo contrario, hace referencia al cursor local. El cursor debe permitir actualizaciones.

• cursor_variable_name
  Nombre de una variable de cursor. La variable de cursor debe hacer referencia a un cursor que permita realizar actualizaciones.

• OPCIÓN ( < query_hint > [ ,... n] )
  Palabras clave que indican que se utilizan sugerencias del optimizador para personalizar el procesamiento de la instrucción por parte del Motor de base de datos. Para obtener más información, consulte Sugerencias de consulta (Transact-SQL).

Procedimientos recomendados

Para eliminar todas las filas de una tabla, use TRUNCATE TABLE. TRUNCATE TABLE es más rápido que DELETE y utiliza menos recursos de los registros de transacciones y de sistema. TRUNCATE TABLE tiene restricciones; por ejemplo, la tabla no puede participar en la replicación. Para obtener más información, consulte TRUNCATE TABLE (Transact-SQL).

Use la función @@ROWCOUNT para devolver el número de filas eliminadas a la aplicación cliente. Para más información, consulte @@ROWCOUNT (Transact-SQL).

Tratamiento de errores

Puede implementar el control de errores de la instrucción DELETE especificando la instrucción en una construcción TRY…CATCH.

La instrucción DELETE puede tener un error si infringe un desencadenador o intenta quitar una fila a la que hacen referencia datos de otra tabla con una restricción FOREIGN KEY. Si la instrucción DELETE quita varias filas y cualquiera de las filas eliminadas infringe un desencadenador o restricción, se cancela la instrucción, se devuelve un error y no se elimina ninguna fila.

Cuando una instrucción DELETE encuentra un error aritmético (desbordamiento, división entre cero o error de dominio) al evaluar una expresión, el Motor de base de datos trata ese error como si SET ARITHABORT fuese ON. Se cancela el resto del proceso por lotes y se devuelve un mensaje de error.

Interoperabilidad

Es posible utilizar DELETE en el cuerpo de una función definida por el usuario si el objeto que se va a modificar es una variable de tabla.

Al eliminar una fila que contiene una columna FILESTREAM, también elimina los archivos del sistema de archivos subyacentes. El recolector de elementos no utilizados de FILESTREAM quita los archivos subyacentes. Para más información, consulte Obtener acceso a datos FILESTREAM con Transact-SQL.

No se puede especificar la cláusula FROM en una instrucción DELETE que haga referencia, directa o indirectamente, a una vista que tiene definido un desencadenador INSTEAD OF. Para obtener más información acerca de los desencadenadores INSTEAD OF, vea CREATE TRIGGER (Transact-SQL).

Limitaciones y restricciones

Cuando se usa TOP con DELETE, las filas a las que hace referencia no están organizadas de ninguna manera y la cláusula ORDER BY no se puede especificar directamente en esta instrucción. Si necesita utilizar TOP para eliminar filas por un orden cronológico significativo, debe usar TOP junto con una cláusula ORDER BY en una instrucción de subselección. Vea la sección Ejemplos que aparece más adelante en este tema.

TOP no se puede usar en una instrucción DELETE con vistas divididas en particiones.

Comportamiento del bloqueo

De forma predeterminada, una instrucción DELETE siempre adquiere un bloqueo exclusivo (X) en la tabla que modifica y retiene ese bloqueo hasta que se completa la transacción. Al utilizar un bloqueo exclusivo (X), el resto de las transacciones no pueden modificar los datos; las operaciones de lectura solo se pueden realizar si se utiliza la sugerencia NOLOCK o el nivel de aislamiento de lectura no confirmada. Puede especificar sugerencias de tabla para invalidar este comportamiento predeterminado durante la ejecución de la instrucción DELETE especificando otro método de bloqueo, sin embargo se recomienda que solo los desarrolladores y administradores de bases de datos experimentados usen las sugerencias y únicamente como último recurso. Para obtener más información, consulte Sugerencias de tabla (Transact-SQL).

Cuando se eliminan filas de un montón, Motor de base de datos puede usar bloqueo de filas o páginas para la operación. Como consecuencia, las páginas que han quedado vacías por la operación de eliminación permanecen asignadas al montón. Si no se cancela la asignación de las páginas vacías, otros objetos de la base de datos no pueden volver a utilizar el espacio asociado.

Para eliminar las filas de un montón y cancelar la asignación de las páginas, use uno de los métodos siguientes.

• Especifique la sugerencia TABLOCK en la instrucción DELETE. Si se utiliza la sugerencia TABLOCK, la operación de eliminación aplica un bloqueo exclusivo a la tabla, en lugar de un bloqueo de fila o de página. Esto permite cancelar la asignación de las páginas. Para obtener más información acerca de la sugerencia TABLOCK, vea Sugerencias de tabla (Transact-SQL).

• Se debe utilizar TRUNCATE TABLE si se van a eliminar todas las filas de la tabla.

• Cree un índice clúster en el montón antes de eliminar las filas. Puede quitar el índice clúster tras eliminar las filas. Este método requiere más tiempo que los métodos anteriores y utiliza más recursos temporales.

Nota

Las páginas vacías se pueden quitar de un montón en cualquier momento con la instrucción ALTER TABLE <table_name> REBUILD.

Comportamiento del registro

La instrucción DELETE siempre está registrada totalmente.

Seguridad

Permisos

Se requieren permisos DELETE en la tabla de destino. También se requieren los permisos para utilizar SELECT si la instrucción contiene una cláusula WHERE.

Los permisos para utilizar DELETE corresponden de forma predeterminada a los miembros del rol fijo de servidor sysadmin, de los roles fijos de base de datos db_owner y db_datawriter y al propietario de la tabla. Los miembros de los roles sysadmin, db_owner y db_securityadmin y el propietario de la tabla pueden transferir permisos a otros usuarios.

Ejemplos

Categoría	Elementos de sintaxis ofrecidos
Sintaxis básica	DELETE
Limitar las filas eliminadas	WHERE • FROM • cursor •
Eliminar filas de una tabla remota	Servidor vinculado • función de conjunto de filas OPENQUERY • función de conjunto de filas OPENDATASOURCE
Capturar los resultados de la instrucción DELETE	Cláusula OUTPUT

Sintaxis básica

En los ejemplos de esta sección se muestra la funcionalidad básica de la instrucción DELETE usando la sintaxis mínima requerida.

A. Utilizar DELETE sin la cláusula WHERE

En el ejemplo siguiente se eliminan todas las filas de la tabla SalesPersonQuotaHistory de la base de datos AdventureWorks2012 porque no se utiliza una cláusula WHERE para limitar el número de filas eliminadas.

DELETE FROM Sales.SalesPersonQuotaHistory;
GO

Limitar las filas eliminadas

En los ejemplos de esta sección se muestra cómo se limita el número de filas que se van a eliminar.

A. Usar la cláusula WHERE para eliminar un conjunto de filas

En el ejemplo siguiente se eliminan todas las filas de la tabla ProductCostHistory de la base de datos AdventureWorks2012 en las que el valor de la columna StandardCost es superior a 1000.00.

DELETE FROM Production.ProductCostHistory
WHERE StandardCost > 1000.00;
GO

En el siguiente ejemplo se muestra una cláusula WHERE más compleja. La cláusula WHERE define dos condiciones que deben cumplirse para determinar las filas que se van a eliminar. El valor de la columna StandardCost debe estar comprendido entre 12.00 y 14.00 y el valor de la columna SellEndDate debe ser NULL. En el ejemplo se imprime también el valor desde la función @@ROWCOUNT para devolver el número de filas eliminadas.

DELETE Production.ProductCostHistory
WHERE StandardCost BETWEEN 12.00 AND 14.00
      AND EndDate IS NULL;
PRINT 'Number of rows deleted is ' + CAST(@@ROWCOUNT as char(3));

B. Usar un cursor para determinar la fila que se va a eliminar

En el ejemplo siguiente se elimina una fila única de la tabla EmployeePayHistory de la base de datos AdventureWorks2012 mediante un cursor denominado mycursor. La operación de eliminación solo afecta a la única fila que se captura actualmente del cursor.

DECLARE complex_cursor CURSOR FOR
    SELECT a.BusinessEntityID
    FROM HumanResources.EmployeePayHistory AS a
    WHERE RateChangeDate <> 
         (SELECT MAX(RateChangeDate)
          FROM HumanResources.EmployeePayHistory AS b
          WHERE a.BusinessEntityID = b.BusinessEntityID) ;
OPEN complex_cursor;
FETCH FROM complex_cursor;
DELETE FROM HumanResources.EmployeePayHistory
WHERE CURRENT OF complex_cursor;
CLOSE complex_cursor;
DEALLOCATE complex_cursor;
GO

C. Usar combinaciones y subconsultas en los datos de una tabla para eliminar filas de otra tabla

En los siguientes ejemplos se muestran dos maneras de eliminar filas de una tabla en función de los datos de otra tabla. En ambos ejemplos, se eliminan las filas de la tabla SalesPersonQuotaHistory de la base de datos AdventureWorks2012 basándose en las ventas del año hasta la fecha almacenadas en la tabla SalesPerson. La primera instrucción DELETE muestra la solución de subconsulta compatible con ISO y la segunda instrucción DELETE muestra la extensión de FROM de Transact-SQL para unir las dos tablas.

-- SQL-2003 Standard subquery


DELETE FROM Sales.SalesPersonQuotaHistory 
WHERE BusinessEntityID IN 
    (SELECT BusinessEntityID 
     FROM Sales.SalesPerson 
     WHERE SalesYTD > 2500000.00);
GO

-- Transact-SQL extension

DELETE FROM Sales.SalesPersonQuotaHistory 
FROM Sales.SalesPersonQuotaHistory AS spqh
INNER JOIN Sales.SalesPerson AS sp
ON spqh.BusinessEntityID = sp.BusinessEntityID
WHERE sp.SalesYTD > 2500000.00;
GO

-- Mention target table, SalesPersonQuotaHistory, only once. Simpler.

DELETE spqh
  FROM
               Sales.SalesPersonQuotaHistory AS spqh
    INNER JOIN Sales.SalesPerson             AS sp   ON spqh.BusinessEntityID = sp.BusinessEntityID
  WHERE
    sp.SalesYTD > 2500000.00;

A. Utilizar TOP para limitar el número de filas eliminadas

Cuando se utiliza una cláusula TOP (n) con DELETE, la operación de eliminación se realiza en una selección aleatoria de n número de filas. En el ejemplo siguiente se eliminan 20 filas aleatorias de la tabla PurchaseOrderDetail de la base de datos AdventureWorks2012 cuyas fechas de vencimiento sean anteriores al primero de julio de 2006.

DELETE TOP (20) 
FROM Purchasing.PurchaseOrderDetail
WHERE DueDate < '20020701';
GO

Si necesita utilizar TOP para eliminar filas por un orden cronológico significativo, debe utilizarla junto con ORDER BY en una instrucción de subselección. La siguiente consulta elimina de la tabla PurchaseOrderDetail las 10 filas con las fechas de vencimiento más antiguas. Para garantizar que solo se eliminen 10 filas, la columna especificada en la instrucción de subselección (PurchaseOrderID) es la clave principal de la tabla. El uso de una columna sin clave en la instrucción de subselección podría causar la eliminación de más de 10 filas si la columna especificada contiene valores duplicados.

DELETE FROM Purchasing.PurchaseOrderDetail
WHERE PurchaseOrderDetailID IN
   (SELECT TOP 10 PurchaseOrderDetailID 
    FROM Purchasing.PurchaseOrderDetail 
    ORDER BY DueDate ASC);
GO

Eliminar filas de una tabla remota

En los ejemplos de esta sección se muestra cómo se eliminan filas de una tabla remota mediante un servidor vinculado o una función de conjunto de filas para hacer referencia a la tabla remota. Una tabla remota existe en un servidor o instancia diferente de SQL Server.

Se aplica a: desde SQL Server 2008 hasta SQL Server 2014.

A. Eliminar datos de una tabla remota usando un servidor vinculado

En el ejemplo siguiente se eliminan filas de una tabla remota. En el ejemplo se comienza creando un vínculo al origen de datos remoto mediante sp_addlinkedserver. El nombre del servidor vinculado, MyLinkServer, se especifica después como parte del nombre de objeto de cuatro partes con el formato server.catalog.schema.object.

USE master;
GO
-- Create a link to the remote data source. 
-- Specify a valid server name for @datasrc as 'server_name' or 'server_name\instance_name'.

EXEC sp_addlinkedserver @server = N'MyLinkServer',
    @srvproduct = N' ',
    @provider = N'SQLNCLI', 
    @datasrc = N'server_name',
    @catalog = N'AdventureWorks2012';
GO

-- Specify the remote data source using a four-part name 
-- in the form linked_server.catalog.schema.object.

DELETE MyLinkServer.AdventureWorks2012.HumanResources.Department WHERE DepartmentID > 16;
GO

B. Eliminar datos de una tabla remota con la función OPENQUERY

En el ejemplo siguiente se eliminan filas de una tabla remota especificando la función de conjunto de filas OPENQUERY. En este ejemplo se usa el nombre del servidor vinculado creado en el ejemplo anterior.

DELETE OPENQUERY (MyLinkServer, 'SELECT Name, GroupName FROM AdventureWorks2012.HumanResources.Department
WHERE DepartmentID = 18');
GO

C. Eliminar datos de una tabla remota con una función OPENDATASOURCE

En el ejemplo siguiente se elimina una fila de una tabla remota especificando la función de conjunto de filas OPENDATASOURCE. Especifique un nombre de servidor válido para el origen de datos con el formato nombre_servidor o nombre_servidor\nombre_instancia.

DELETE FROM OPENDATASOURCE('SQLNCLI',
    'Data Source= <server_name>; Integrated Security=SSPI')
    .AdventureWorks2012.HumanResources.Department 
WHERE DepartmentID = 17;'

Capturar los resultados de la instrucción DELETE

A. Usar DELETE con la cláusula OUTPUT

En el ejemplo siguiente se muestra cómo se guardan los resultados de una instrucción DELETE en una variable de tabla en la base de datos AdventureWorks2012.

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

B. Usar OUTPUT con <from_table_name> en una instrucción DELETE

En el ejemplo siguiente se eliminan las filas de la tabla ProductProductPhoto de la base de datos AdventureWorks2012 según los criterios de búsqueda definidos en la cláusula FROM de la instrucción DELETE. La cláusula OUTPUT devuelve columnas de la tabla que se elimina (DELETED.ProductID, DELETED.ProductPhotoID) y de la tabla Product. Esta información se utiliza en la cláusula FROM para especificar las filas que se deben eliminar.

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

Vea también

CREATE TRIGGER (Transact-SQL)
INSERT (Transact-SQL)
SELECT (Transact-SQL)
TRUNCATE TABLE (Transact-SQL)
UPDATE (Transact-SQL)
WITH common_table_expression (Transact-SQL)
@@ROWCOUNT (Transact-SQL)