Comment supprimer de plusieurs tables à l'aide de INNER JOIN dans SQL Server

Dans MySQL, vous pouvez utiliser la syntaxe

DELETE t1,t2 
FROM table1 AS t1 
INNER JOIN table2 t2 ...
INNER JOIN table3 t3 ...

Comment faire la même chose dans SQL Server?

Vous pouvez profiter de la pseudo table "supprimée" dans cet exemple. Quelque chose comme:

begin transaction;

   declare @deletedIds table ( id int );

   delete from t1
   output deleted.id into @deletedIds
   from table1 as t1
    inner join table2 as t2
      on t2.id = t1.id
    inner join table3 as t3
      on t3.id = t2.id;

   delete from t2
   from table2 as t2
    inner join @deletedIds as d
      on d.id = t2.id;

   delete from t3
   from table3 as t3 ...

commit transaction;

Évidemment, vous pouvez faire une «sortie supprimée». sur la deuxième suppression également, si vous aviez besoin de quelque chose à rejoindre pour la troisième table.

En remarque, vous pouvez également faire insert. * Sur une instruction d'insertion, et inséré. * Et supprimé. * Sur une instruction de mise à jour.

EDIT: Avez-vous également envisagé d'ajouter un déclencheur sur la table1 pour supprimer de la table2 + 3? Vous serez à l'intérieur d'une transaction implicite, et vous aurez également les pseudo-tables «inséré » et «supprimé » disponibles.

1. Vous pouvez toujours configurer des suppressions en cascade sur les relations des tables.

2. Vous pouvez encapsuler les multiples suppressions dans une procédure stockée.

3. Vous pouvez utiliser une transaction pour garantir une unité de travail.

Vous pouvez utiliser la syntaxe JOIN dans la clause FROM dans DELETE dans SQL Server, mais vous supprimez toujours de la première table uniquement et c'est l'extension Transact-SQL propriétaire qui est une alternative à la sous-requête.

De l'exemple ici :

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

Exemple de suppression de certains enregistrements de la table principale et des enregistrements correspondants de deux tables détaillées:

BEGIN TRAN

  -- create temporary table for deleted IDs
  CREATE TABLE #DeleteIds (
    Id INT NOT NULL PRIMARY KEY
  )

  -- save IDs of master table records (you want to delete) to temporary table    
  INSERT INTO #DeleteIds(Id)
  SELECT DISTINCT mt.MasterTableId
  FROM MasterTable mt 
  INNER JOIN ... 
  WHERE ...  

  -- delete from first detail table using join syntax
  DELETE d
  FROM DetailTable_1 D
  INNER JOIN #DeleteIds X
    ON D.MasterTableId = X.Id


  -- delete from second detail table using IN clause  
  DELETE FROM DetailTable_2
  WHERE MasterTableId IN (
    SELECT X.Id
    FROM #DeleteIds X
  )


  -- and finally delete from master table
  DELETE d
  FROM MasterTable D
  INNER JOIN #DeleteIds X
    ON D.MasterTableId = X.Id

  -- do not forget to drop the temp table
  DROP TABLE #DeleteIds

COMMIT

Je me demande juste ... est-ce vraiment possible dans MySQL? il supprimera t1 et t2? ou j'ai juste mal compris la question.

Mais si vous souhaitez simplement supprimer table1 avec plusieurs conditions de jointure, ne créez pas d'alias pour la table que vous souhaitez supprimer

ce:

DELETE t1,t2 
FROM table1 AS t1 
INNER JOIN table2 t2 ...
INNER JOIN table3 t3 ...

devrait être écrit comme ceci pour fonctionner en MSSQL:

DELETE table1
FROM table1 
INNER JOIN table2 t2 ...
INNER JOIN table3 t3 ...

pour comparer la façon dont les deux autres SGBDR courants effectuent une opération de suppression:

http://mssql-to-postgresql.blogspot.com/2007/12/deleting-duplicates-in-postgresql-ms.html

Fondamentalement, non, vous devez faire trois instructions de suppression dans une transaction, les enfants d'abord, puis les parents. La configuration de suppressions en cascade est une bonne idée si ce n'est pas une chose ponctuelle et que son existence ne sera pas en conflit avec une configuration de déclencheur existante.

Dans SQL Server, il n'existe aucun moyen de supprimer plusieurs tables à l'aide de la jointure. Vous devez donc d'abord supprimer de l'enfant avant de supprimer le parent du formulaire.

Il s'agit d'une autre façon de supprimer des enregistrements sans laisser d'orphelins.

Declare @user Table (keyValue int, someString varchar (10))
insérer dans @user
valeurs (1, '1 valeur')

insérer dans @user
valeurs (2, '2 valeur')

insérer dans @user
valeurs (3, '3 valeur')

Declare @password Table (keyValue int, details varchar (10))
insérer dans @password
valeurs (1, '1 Mot de passe')
insérer dans @password
valeurs (2, '2 Mot de passe')
insérer dans @password
valeurs (3, '3 Mot de passe')

        --avant la suppression
  sélectionnez * à partir de @password une jointure interne @user b
                sur a.keyvalue = b.keyvalue
  sélectionnez * dans #deletedID de @user où keyvalue = 1 - cela fonctionne comme l'exemple de sortie
  supprimer @user où keyvalue = 1
  supprimer @password où keyvalue in (sélectionnez keyvalue from #deletedid)

  --Après suppression--
  sélectionnez * à partir de @password une jointure interne @user b
                sur a.keyvalue = b.keyvalue

Tout a été signalé. Utilisez simplement DELETE ON CASCADEsur le parent tableou supprimez du child-tableau parent.

Comme Aaron l'a déjà souligné, vous pouvez définir le comportement de suppression sur CASCADE et cela supprimera les enregistrements enfants lorsqu'un enregistrement parent est supprimé. À moins que vous ne souhaitiez qu'une sorte d'autre magie se produise (auquel cas les points 2, 3 de la réponse d'Aaron seraient utiles), je ne vois pas pourquoi vous auriez besoin de supprimer avec des jointures internes.

Pour s'appuyer sur la réponse de John Gibb, pour supprimer un ensemble de données dans deux tables avec une relation FK:

--*** To delete from tblMain which JOINs to (has a FK of) tblReferredTo's PK  
--       i.e.  ON tblMain.Refer_FK = tblReferredTo.ID
--*** !!! If you're CERTAIN that no other rows anywhere also refer to the 
--      specific rows in tblReferredTo !!!
BEGIN TRAN;

    --*** Keep the ID's from tblReferredTo when we DELETE from tblMain
    DECLARE @tblDeletedRefs TABLE ( ID INT );
    --*** DELETE from the referring table first
    DELETE FROM tblMain 
    OUTPUT DELETED.Refer_FK INTO @tblDeletedRefs  -- doesn't matter that this isn't DISTINCT, the following DELETE still works.
    WHERE ..... -- be careful if filtering, what if other rows 
                --   in tblMain (or elsewhere) also point to the tblReferredTo rows?

    --*** Now we can remove the referred to rows, even though tblMain no longer refers to them.
    DELETE tblReferredTo
    FROM   tblReferredTo INNER JOIN @tblDeletedRefs Removed  
            ON tblReferredTo.ID = Removed.ID;

COMMIT TRAN;

DELETE     TABLE1 LIN
FROM TABLE1 LIN
INNER JOIN TABLE2 LCS ON  CONDITION
WHERE CONDITION

$ sql = "DELETE FROM basic_tbl, education_tbl, personal_tbl, address_tbl, department_tbl UTILISATION basic_tbl, education_tbl, personal_tbl, address_tbl, department_tbl OU b_id= e_id= p_id= a_id= d_id= '" id $. ». « ; $ rs = mysqli_query ($ con, $ sql);