DELETE (Transact-SQL)

S’applique à : ouiSQL Server (toutes les versions prises en charge) OuiAzure SQL Database OuiAzure SQL Managed Instance ouiAzure Synapse Analytics OuiParallel Data Warehouse

Supprime une ou plusieurs lignes d’une table ou d’une vue dans SQL Server.

Icône du lien de rubrique Conventions de la syntaxe Transact-SQL

Syntaxe

-- Syntax for SQL Server and Azure SQL Database  
  
[ 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   
}  
-- Syntax for Azure Synapse Analytics

[ WITH <common_table_expression> [ ,...n ] ] 
DELETE [database_name . [ schema ] . | schema. ] table_name  
FROM [database_name . [ schema ] . | schema. ] table_name 
JOIN {<join_table_source>}[ ,...n ]  
ON <join_condition>
[ WHERE <search_condition> ]   
[ OPTION ( <query_options> [ ,...n ]  ) ]  
[; ]  

<join_table_source> ::=   
{  
    [ database_name . [ schema_name ] . | schema_name . ] table_or_view_name [ AS ] table_or_view_alias 
    [ <tablesample_clause>]  
    | derived_table [ AS ] table_alias [ ( column_alias [ ,...n ] ) ]  
}  
-- Syntax for Parallel Data Warehouse  
  
DELETE 
    [ FROM [database_name . [ schema ] . | schema. ] table_name ]   
    [ WHERE <search_condition> ]   
    [ OPTION ( <query_options> [ ,...n ]  ) ]  
[; ]  

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.

Arguments

WITH <common_table_expression>
Spécifie l'ensemble de résultats nommé temporaire, également appelé « expression de table commune », défini dans l'étendue de l'instruction DELETE. Le jeu de résultats est dérivé d'une instruction SELECT.

Les expressions de table communes peuvent également s'utiliser avec les instructions SELECT, INSERT, UPDATE et CREATE VIEW. Pour plus d’informations, consultez WITH common_table_expression (Transact-SQL).

TOP ( expression ) [ PERCENT ]
Spécifie le nombre ou le pourcentage de lignes aléatoires qui seront supprimées. L'argument expression peut être un nombre ou un pourcentage de lignes. Les lignes référencées dans l'expression TOP utilisée dans les instructions INSERT, UPDATE ou DELETE ne sont pas triées dans un ordre précis. Pour plus d’informations, consultez TOP (Transact-SQL).

FROM
Mot clé facultatif qui peut être inséré entre le mot clé DELETE et le table_or_view_name cible rowset_function_limited.

table_alias
Alias spécifié dans la clause FROM table_source représentant la table ou la vue de laquelle les lignes doivent être supprimées.

server_name
S’applique à : SQL Server 2008 et versions ultérieures.

Nom du serveur (utilisant un nom de serveur lié ou la fonction OPENDATASOURCE comme nom de serveur) sur lequel se trouve la table ou la vue. Si server_name est spécifié, database_name et schema_name sont obligatoires.

database_name
Nom de la base de données.

schema_name
Nom du schéma auquel appartient la vue ou la table.

table_or_view_name
Nom de la table ou de la vue à partir desquelles les lignes doivent être supprimées.

Une variable de table, dans son étendue, est également utilisable comme source de la table dans une instruction DELETE.

La vue référencée par table_or_view_name doit pouvoir être mise à jour et faire référence à une seule table de base dans la clause FROM de la définition de la vue. Pour plus d’informations sur les vues pouvant être mises à jour, consultez CREATE VIEW (Transact-SQL).

rowset_function_limited
S’applique à : SQL Server 2008 et versions ultérieures.

Fonction OPENQUERY ou OPENROWSET, selon les capacités du fournisseur.

WITH ( <table_hint_limited> [... n] )
Spécifie un ou plusieurs indicateurs de table autorisés pour une table cible. Le mot clé WITH et les parenthèses sont obligatoires. NOLOCK et READUNCOMMITTED ne sont pas autorisés. Pour plus d’informations sur les indicateurs de table, consultez Indicateurs de table (Transact-SQL).

<OUTPUT_Clause>
Retourne des lignes supprimées ou des expressions basées sur ces lignes au cours de l'exécution de l'opération DELETE. Aucune instruction DML ciblant des vues ou des tables distantes ne prend en charge la clause OUTPUT. Pour plus d’informations sur les arguments et le comportement de cette clause, consultez Clause OUTPUT (Transact-SQL).

FROM table_source
Spécifie une clause FROM supplémentaire. Cette extension Transact-SQL de l’instruction DELETE permet de spécifier des données de <table_source> et de supprimer les lignes correspondantes de la table référencée dans la première clause FROM.

Cette extension, qui spécifie une jointure, peut être utilisée dans la clause WHERE à la place d'une sous-requête pour identifier les lignes à supprimer.

Pour plus d’informations, consultez FROM (Transact-SQL).

WHERE
Spécifie les conditions limitant le nombre de lignes à supprimer. Si une clause WHERE n'est pas spécifiée, DELETE supprime toutes les lignes de la table.

Il existe deux types d'opérations de suppression, en fonction des conditions définies dans la clause WHERE :

  • Une suppression par recherche spécifie une condition de recherche permettant de désigner les lignes à supprimer. Par exemple, WHERE column_name = value.

  • Une suppression positionnée utilise la clause CURRENT OF pour spécifier un curseur. La suppression a lieu à la position actuelle du curseur. Cette opération peut être plus précise qu’une instruction DELETE élaborée qui utilise une clause WHERE search_condition pour spécifier les lignes à supprimer. Une instruction DELETE par recherche supprime plusieurs lignes si la condition de recherche n'identifie pas de façon univoque une ligne unique.

<search_condition>
Spécifie les conditions de limitation applicables aux lignes à supprimer. Le nombre de prédicats inclus dans une condition de recherche est illimité. Pour plus d’informations, consultez Condition de recherche (Transact-SQL).

CURRENT OF
Spécifie que l'instruction DELETE s'effectue à l'emplacement actuel du curseur spécifié.

GLOBAL
Indique que cursor_name fait référence à un curseur global.

cursor_name
Nom du curseur ouvert à partir duquel a lieu l'extraction. Si un curseur global et un curseur local portent tous les deux le nom cursor_name, cet argument fait référence au curseur global si GLOBAL est spécifié, et au curseur local dans tous les autres cas. Le curseur doit pouvoir gérer les mises à jour.

cursor_variable_name
Nom d'une variable curseur. La variable de curseur doit référencer un curseur qui autorise les mises à jour.

OPTION ( <query_hint> [ , ... n] )
Mots clés spécifiant les indicateurs d’optimiseur utilisés pour personnaliser le traitement de l’instruction par le Moteur de base de données. Pour plus d’informations, consultez Indicateurs de requête (Transact-SQL).

Bonnes pratiques

Pour supprimer toutes les lignes dans une table, utilisez TRUNCATE TABLE. TRUNCATE TABLE est plus rapide et utilise moins de ressources du système et du journal des transactions que l’instruction DELETE. TRUNCATE TABLE présente des restrictions, par exemple, la table ne peut pas participer à la réplication. Pour plus d’informations, consultez TRUNCATE TABLE (Transact-SQL).

Utilisez la fonction @@ROWCOUNT pour retourner le nombre de lignes supprimées à l’application cliente. Pour plus d’informations, consultez @@ROWCOUNT (Transact-SQL).

Gestion des erreurs

Vous pouvez implémenter la gestion des erreurs pour l’instruction DELETE en spécifiant cette dernière dans une construction TRY...CATCH.

L’instruction DELETE peut échouer si elle viole un déclencheur ou si elle essaie de supprimer une ligne référencée par des données dans une autre table avec une contrainte FOREIGN KEY. Si l’instruction DELETE supprime plusieurs lignes et qu’une de ces lignes viole un déclencheur ou une contrainte, une erreur est retournée et aucune ligne n’est supprimée.

Quand une instruction DELETE rencontre une erreur arithmétique (erreur de dépassement, de division par zéro ou de domaine) qui se produit lors de l’évaluation de l’expression, le Moteur de base de données gère ces erreurs comme si SET ARITHABORT avait la valeur ON. Le reste du lot est annulé et un message d'erreur est retourné.

Interopérabilité

DELETE peut s'utiliser dans le corps d'une fonction définie par l'utilisateur si l'objet modifié est une variable de table.

Lorsque vous supprimez une ligne qui contient une colonne FILESTREAM, vous supprimez également ses fichiers de système de fichiers sous-jacents. Les fichiers sous-jacents sont supprimés par le garbage collector FILESTREAM. Pour plus d’informations, consultez Accéder aux données FILESTREAM avec Transact-SQL.

La clause FROM ne peut pas être spécifiée dans une instruction DELETE qui référence, directement ou indirectement, à une vue sur laquelle est défini un déclencheur INSTEAD OF. Pour plus d’informations sur les déclencheurs INSTEAD OF, consultez CREATE TRIGGER (Transact-SQL).

Limitations et restrictions

Lorsque TOP est utilisé avec DELETE, les lignes référencées ne sont pas réorganisées dans un ordre particulier et la clause ORDER BY ne peut pas être spécifiée directement dans cette instruction. Si vous devez utiliser une clause TOP pour supprimer des lignes dans un ordre chronologique significatif, vous devez associer à cette clause TOP une clause ORDER BY dans une instruction de sous-sélection. Consultez la section Exemples plus loin dans cette rubrique.

TOP ne peut pas être utilisé dans une instruction DELETE avec des vues partitionnées.

Comportement de verrouillage

Par défaut, une instruction DELETE acquiert toujours un verrou intentionnel exclusif (IX) sur l’objet table et les pages qu’elle modifie, un verrou exclusif (X) sur les lignes qu’elle modifie et maintient ces verrous jusqu’à ce que la transaction se termine.

Un verrou intentionnel exclusif (IX) empêche toute autre transaction de modifier le même jeu de données ; les opérations de lecture ne peuvent avoir lieu qu’avec l’indicateur NOLOCK ou le niveau d’isolation « lecture non validée ». Vous pouvez spécifier des indicateurs de table pour remplacer ce comportement par défaut pour la durée de l'instruction DELETE en spécifiant une autre méthode de verrouillage ; toutefois, nous vous recommandons de ne recourir aux indicateurs qu'en dernier ressort et seulement si vous êtes un développeur ou un administrateur de base de données expérimenté. Pour plus d’informations, consultez Indicateurs de table (Transact-SQL).

Lors de la suppression de lignes d’un segment de mémoire, le Moteur de base de données peut utiliser le verrouillage de ligne ou de page pour l’opération. Par conséquent, les pages rendues vides par l'opération de suppression demeurent allouées au segment de mémoire. Lorsque des pages vides ne sont pas désallouées, l'espace associé ne peut pas être réutilisé par d'autres objets dans la base de données.

Pour supprimer des lignes d'un segment de mémoire et désallouer des pages, utilisez l'une des méthodes suivantes.

  • Spécifiez l'indicateur TABLOCK dans l'instruction DELETE. Grâce à l’indicateur TABLOCK, l’opération de suppression utilise un verrou IX sur l’objet au lieu d’un verrou de ligne ou de page. Les pages sont ainsi désallouées. Pour plus d’informations sur l’indicateur TABLOCK, consultez Indicateurs de table (Transact-SQL).

  • Utilisez TRUNCATE TABLE si toutes les lignes doivent être supprimées de la table.

  • Créez un index cluster sur le segment de mémoire avant de supprimer les lignes. Vous pouvez supprimer l'index cluster après avoir supprimé les lignes. Cette méthode prend plus de temps que les méthodes précédentes et utilise davantage de ressources temporaires.

Notes

Les pages vides peuvent être supprimées d’un segment de mémoire à tout moment à l’aide de l’instruction ALTER TABLE <table_name> REBUILD.

Comportement de journalisation

L'instruction DELETE est toujours entièrement journalisée.

Sécurité

Autorisations

Les autorisations DELETE sont obligatoires sur la table cible. Des autorisations SELECT sont également requises si l’instruction comporte une clause WHERE.

Les autorisations DELETE sont attribuées par défaut aux membres du rôle serveur fixe sysadmin, aux membres des rôles de base de données fixes db_owner et db_datawriter ainsi qu’au propriétaire de la table. Les membres des rôles sysadmin, db_owner et db_securityadmin ainsi que le propriétaire de la table peuvent transférer des autorisations à d’autres utilisateurs.

Exemples

Category Éléments syntaxiques proposés
Syntaxe de base Suppression
Limitation des lignes supprimées WHERE • FROM • curseur •
Suppression de lignes dans une table distante Serveur lié • fonction d'ensemble de lignes OPENQUERY • fonction d'ensemble de lignes OPENDATASOURCE
Capture des résultats de l’instruction DELETE Clause OUTPUT

Syntaxe de base

Les exemples fournis dans cette section présentent les fonctionnalités de base de l'instruction DELETE en utilisant la syntaxe minimale requise.

R. Utilisation de DELETE sans clause WHERE

L'exemple suivant supprime toutes les lignes de la table SalesPersonQuotaHistory dans la base de données AdventureWorks2012 , car aucune clause WHERE ne limite le nombre de lignes supprimées.

DELETE FROM Sales.SalesPersonQuotaHistory;  
GO  

Limitation des lignes supprimées

Les exemples de cette section montrent comment limiter le nombre de lignes qui seront supprimées.

B. Utilisation de la clause WHERE pour supprimer un jeu de lignes

L’exemple suivant supprime toutes les lignes de la table ProductCostHistory de la base de données AdventureWorks2012 dans lesquelles la valeur de la colonne StandardCost est supérieure à 1000.00.

DELETE FROM Production.ProductCostHistory  
WHERE StandardCost > 1000.00;  
GO  

L'exemple suivant illustre une clause WHERE plus complexe. La clause WHERE définit deux conditions qui doivent être rencontrées pour déterminer les lignes à supprimer. La valeur dans la colonne StandardCost doit être comprise entre 12.00 et 14.00 , tandis que la valeur dans la colonne SellEndDate doit être Null. L’exemple imprime également la valeur de la fonction @@ROWCOUNT afin de retourner le nombre de lignes supprimées.

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

C. Utilisation d'un curseur pour déterminer la ligne à supprimer

L’exemple suivant supprime une seule ligne de la table EmployeePayHistory de la base de données AdventureWorks2012 en utilisant un curseur nommé complex_cursor. La suppression est appliquée uniquement à la ligne actuellement extraite à partir du curseur.

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  

D. Utilisation de jointures et de sous-requêtes sur les données d'une table pour supprimer des lignes dans une autre table

Les exemples suivants illustrent deux façons de supprimer des lignes dans une table selon les données figurant dans une autre table. Dans les deux exemples, des lignes de la table SalesPersonQuotaHistory de la base de données AdventureWorks2012 sont supprimées en fonction des ventes de l’année stockées dans la table SalesPerson. La première instruction DELETE montre une solution de sous-requête compatible ISO tandis que la seconde instruction DELETE montre l’extension Transact-SQL FROM pour joindre les deux tables.

-- 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  
-- No need to mention target table more than once.  
  
DELETE spqh  
  FROM  
        Sales.SalesPersonQuotaHistory AS spqh  
    INNER JOIN Sales.SalesPerson AS sp  
        ON spqh.BusinessEntityID = sp.BusinessEntityID  
  WHERE  sp.SalesYTD > 2500000.00;  

E. Utilisation de TOP pour limiter le nombre de lignes supprimées

Quand une clause TOP (n) est utilisée avec DELETE, l’opération de suppression est effectuée sur une sélection aléatoire de n lignes. L’exemple suivant supprime de manière aléatoire 20 lignes de la table PurchaseOrderDetail de la base de données AdventureWorks2012 dont la date d’échéance est antérieure au 1er juillet 2006.

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

Si vous devez utiliser une clause TOP pour supprimer des lignes dans un ordre chronologique significatif, vous devez associer à cette clause TOP une clause ORDER BY dans une instruction de sous-sélection. La requête suivante supprime les 10 lignes de la table PurchaseOrderDetail dont la date d'expiration est la plus proche. Pour garantir que seules 10 lignes sont supprimées, la colonne spécifiée dans l'instruction de sous-sélection (PurchaseOrderID) constitue la clé primaire de la table. L'utilisation d'une colonne non-clé dans l'instruction de sous-sélection peut entraîner la suppression de plus de 10 lignes si la colonne spécifiée contient des valeurs dupliquées.

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

Suppression de lignes dans une table distante

Les exemples présentés dans cette section montrent comment supprimer des lignes dans une table distante en utilisant un serveur lié ou une fonction d’ensemble de lignes pour référencer la table distante. Une table distante existe sur un serveur différent ou une instance différente de SQL Server.

S’applique à : SQL Server 2008 et versions ultérieures.

F. Suppression de données dans une table distante en utilisant un serveur lié

L'exemple ci-dessous supprime des lignes dans une table distante. L’exemple commence par créer un lien vers la source de données distante en utilisant sp_addlinkedserver. Le nom du serveur lié, MyLinkServer, est ensuite spécifié comme partie du nom d’objet en quatre parties qui se présente sous la forme serveur.catalogue.schéma.objet.

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  

G. Suppression de données dans une table distante en utilisant la fonction OPENQUERY

L’exemple suivant supprime des lignes d’une table distante en spécifiant la fonction d’ensemble de lignes OPENQUERY. Le nom de serveur lié créé dans l'exemple précédent est utilisé dans cet exemple.

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

H. Suppression de données dans une table distante en utilisant la fonction OPENDATASOURCE

L’exemple suivant supprime des lignes d’une table distante en spécifiant la fonction d’ensemble de lignes OPENDATASOURCE. Spécifiez un nom de serveur valide pour la source de données en utilisant le format server_name ou server_name\instance_name.

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

Capture des résultats de l’instruction DELETE

I. Utilisation de DELETE avec la clause OUTPUT

L’exemple suivant montre comment enregistrer les résultats d’une instruction DELETE dans une variable de table dans la base de données 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  

J. Utilisation de la clause OUTPUT avec <from_table_name> dans une instruction DELETE

L’exemple suivant supprime des lignes de la table ProductProductPhoto de la base de données AdventureWorks2012 en fonction de critères de recherche définis dans la clause FROM de l’instruction DELETE. La clause OUTPUT retourne les colonnes DELETED.ProductID, DELETED.ProductPhotoIDde la table en cours de suppression et les colonnes de la table Product . Cette méthode s'utilise dans la clause FROM pour spécifier les lignes à supprimer.

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  

Exemples : Azure Synapse Analytics et Analytics Platform System (PDW)

K. Supprimer toutes les lignes d’une table

L'exemple suivant supprime toutes les lignes de la table Table1car aucune clause WHERE ne limite le nombre de lignes supprimées.

DELETE FROM Table1;  

L. Supprimer (DELETE) un ensemble de lignes d’une table

L’exemple suivant supprime toutes les lignes de la table Table1 dont la valeur est supérieure à 1000.00 dans la colonne StandardCost.

DELETE FROM Table1  
WHERE StandardCost > 1000.00;  

M. Utilisation de LABEL avec une instruction DELETE

L’exemple suivant utilise une étiquette avec l’instruction DELETE.

DELETE FROM Table1  
OPTION ( LABEL = N'label1' );  
  

N. Utilisation d’une étiquette et d’un indicateur de requête avec l’instruction DELETE

Cette requête présente la syntaxe de base pour utiliser un indicateur de jointure de requête avec l’instruction DELETE. Pour plus d’informations sur les indicateurs de jointure et la clause OPTION, voir Clause OPTION (Transact-SQL).

-- Uses AdventureWorks  
  
DELETE FROM dbo.FactInternetSales  
WHERE ProductKey IN (   
    SELECT T1.ProductKey FROM dbo.DimProduct T1   
    JOIN dbo.DimProductSubcategory T2  
    ON T1.ProductSubcategoryKey = T2.ProductSubcategoryKey  
    WHERE T2.EnglishProductSubcategoryName = 'Road Bikes' )  
OPTION ( LABEL = N'CustomJoin', HASH JOIN ) ;  

O. Supprimer avec une clause WHERE

Cette requête montre comment supprimer avec une clause WHERE et non avec une clause FROM.

DELETE tableA WHERE EXISTS (
SELECT TOP 1 1 FROM tableB tb WHERE tb.col1 = tableA.col1
)

P. Supprimer en fonction du résultat de la jointure avec une autre table

Cet exemple montre comment supprimer d’une table en fonction du résultat de la jointure avec une autre table.

CREATE TABLE dbo.Table1   
    (ColA int NOT NULL, ColB decimal(10,3) NOT NULL);  
GO  

CREATE TABLE dbo.Table2   
    (ColA int PRIMARY KEY NOT NULL, ColB decimal(10,3) NOT NULL);  
GO  
INSERT INTO dbo.Table1 VALUES(1, 10.0), (1, 20.0);  
INSERT INTO dbo.Table2 VALUES(1, 0.0);  
GO  

DELETE dbo.Table2   
FROM dbo.Table2   
    INNER JOIN dbo.Table1   
    ON (dbo.Table2.ColA = dbo.Table1.ColA)
    WHERE dboTable2.ColA = 1;  

Voir aussi

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)