¿Cómo elimino de varias tablas usando INNER JOIN en SQL Server?

En MySQL puedes usar la sintaxis

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

¿Cómo hago lo mismo en SQL Server?

Puede aprovechar la pseudotabla "eliminada" en este ejemplo. Algo como:

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;

Obviamente, puede hacer una 'salida eliminada'. en la segunda eliminación también, si necesita algo para unirse a la tercera mesa.

Como nota al margen, también puede insertar. * En una declaración de inserción, y tanto insertar. * Como eliminado. * En una declaración de actualización.

EDITAR: Además, ¿ha considerado agregar un activador en la tabla1 para eliminar de la tabla2 + 3? Estará dentro de una transacción implícita y también tendrá disponibles las pseudo-tablas "insertadas " y "eliminadas ".

1. Siempre puede configurar eliminaciones en cascada en las relaciones de las tablas.

2. Puede encapsular las múltiples eliminaciones en un procedimiento almacenado.

3. Puede utilizar una transacción para garantizar una unidad de trabajo.

Puede usar la sintaxis JOIN en la cláusula FROM en DELETE en SQL Server, pero aún así elimina solo de la primera tabla y su extensión Transact-SQL patentada, que es alternativa a la subconsulta.

De ejemplo aquí :

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

Ejemplo para eliminar algunos registros de la tabla maestra y los registros correspondientes de dos tablas de detalle:

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

Me pregunto ... ¿es eso realmente posible en MySQL? eliminará t1 y t2? o simplemente entendí mal la pregunta.

Pero si solo desea eliminar table1 con múltiples condiciones de combinación, simplemente no alias la tabla que desea eliminar

esta:

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

debe escribirse así para que funcione en MSSQL:

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

para contrastar cómo los otros dos RDBMS comunes realizan una operación de eliminación:

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

Básicamente, no, tiene que hacer tres declaraciones de eliminación en una transacción, los niños primero y luego los padres. La configuración de eliminaciones en cascada es una buena idea si esto no es algo único y su existencia no entrará en conflicto con ninguna configuración de disparador existente.

En el servidor SQL no hay forma de eliminar varias tablas usando join. Por lo tanto, primero debe eliminar del niño antes de eliminar el formulario principal.

Esta es una forma alternativa de eliminar registros sin dejar huérfanos.

Declare @user Table (keyValue int, someString varchar (10))
insertar en @user
valores (1, '1 valor')

insertar en @user
valores (2, 'valor 2')

insertar en @user
valores (3, 'valor 3')

Declare @password Table (keyValue int, detalles varchar (10))
insertar en @password
valores (1, '1 contraseña')
insertar en @password
valores (2, '2 Contraseña')
insertar en @password
valores (3, '3 Contraseña')

        - antes de la eliminación
  seleccione * de @password a combinación interna @user b
                en a.keyvalue = b.keyvalue
  seleccione * en #deletedID de @user donde keyvalue = 1 - esto funciona como el ejemplo de salida
  eliminar @user donde keyvalue = 1
  eliminar @password donde keyvalue in (seleccione keyvalue de #deletedid)

  --Después de la eliminación--
  seleccione * de @password a combinación interna @user b
                en a.keyvalue = b.keyvalue

Todo ha sido señalado. Simplemente use DELETE ON CASCADEen el padre tableo elimínelo del child-tableal parent.

Como Aaron ya ha señalado, puede establecer el comportamiento de eliminación en CASCADA y eso eliminará los registros secundarios cuando se elimine un registro principal. A menos que desee que suceda algún otro tipo de magia (en cuyo caso los puntos 2, 3 de la respuesta de Aaron serían útiles), no veo por qué necesitaría eliminar con combinaciones internas.

Para construir sobre la respuesta de John Gibb, para eliminar un conjunto de datos en dos tablas con una relación 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 EL USO basic_tbl, education_tbl, personal_tbl, address_tbl, department_tbl DONDE b_id= e_id= p_id= a_id= d_id= '" $ id.. "' "; $ rs = mysqli_query ($ con, $ sql);