SQL DELETE hits constraints - sql

Question

Let's look at the famous Nortwind database. Say I run DELETE FROM Clients.
In MSAccess, when one runs a DELETE statement against a table with referential integrity constraints, Jet will delete the records it can delete, and leave the other ones. In this case, it would delete only the Clients for which there are no Orders.
In SQL Server, doing this seems to just fail, with a message stating that The DELETE statement conflicted with the REFERENCE constraint .....
My question therefore is: is there a simple way to let SQL Server delete just those records that can be deleted ? or do I have to add a WHERE ClientId NOT IN (SELECT Id FROM Clients) ?
In other words, can I make SQL Server DELETE work like Jet's DELETE ?
For info: I am not THAT lazy, but there are MANY constraints there and I'd like to keep my code simple...

Answer 1

Another approach is to delete in loop (row by row) using CURSOR and TRY .. CATCH block to ignore problems with deleting referenced rows.
In this approach you don't have to model your existing and future constraints.
Example:
SET NOCOUNT ON; -- use not to have "(N row(s) affected)" for each deleted row
DECLARE del_cursor CURSOR
FOR SELECT ClientID FROM Clients
DECLARE #CurrentClientID INT -- use your proper type
DECLARE #message VARCHAR(200) -- just for building messages
OPEN del_cursor
FETCH NEXT FROM del_cursor
INTO #CurrentClientID
WHILE ##FETCH_STATUS = 0
BEGIN
BEGIN TRY
DELETE FROM Clients WHERE CURRENT OF del_cursor
END TRY
BEGIN CATCH
SET #message = 'Row ' + CAST(#CurrentClientID AS VARCHAR) + ' cannot be deleted - skipping.'
PRINT #message
END CATCH
FETCH NEXT FROM del_cursor
INTO #CurrentClientID
END
CLOSE del_cursor
DEALLOCATE del_cursor
You may wrap above example with CREATE PROCEDURE DeleteClients and use EXEC DeleteClients instead of DELETE FROM Clients

Answer 2

Your options are:
Cascading Delete - Will delete all records that are dependent on
those clients.
Drop constraint (I don't recommend this :))
Check ahead of time that it can be delete and will not have a conflict

Answer 3

If you want to leave rows that have FK references, then there are only a couple of options, and none of them are pretty:
Check constraints before you do the delete
Modify the query to have the where clauses for the FK as you mentioned in your question
Change your logic to delete rows one at a time, commit each row and rollback the delete if it fails.
The 'least lousy' option really depends on how many FKs are there, how many rows you'll be deleting and the likelihood that a row has FK dependencies. If that is a relatively rare event, then option #3 may be best, although I would tend to lean towards the first two options.

Answer 4

I know it is a little bit complicated solution but you need to do it only once.
How about a trigger to prevent the deletions?
create table parent(
id int not null primary key
)
create table son(
id int not null primary key,
idparent int)
alter table son add foreign key(idparent) references parent(id)
insert into parent values(1)
insert into parent values(2)
insert into parent values(3)
insert into son values(1,1)
--select * from parent
--select * from son
create trigger preventDelete
on parent
instead of delete
as
begin
delete from parent where id not in (select idparent from son) and id in (select id from deleted)
end
delete from parent
records 2 and 3 will be deleted

Answer 5

Try this, it will generate your statements. Excuse the format I wrote it very quickly:
DECLARE #i INT, #SQL NVARCHAR(2000), #TABLENAME NVARCHAR(100)
SET #i = 1
SET #TABLENAME = 'informer_alert'
SET #SQL = ''
DECLARE #col VARCHAR(50), #basecol VARCHAR(50), #tname VARCHAR(50)
DECLARE #TABLE TABLE ([table] VARCHAR(50), col VARCHAR(50), basecol VARCHAR(50))
INSERT INTO #TABLE
SELECT t.name, sc.name, sc2.name
FROM sys.foreign_key_columns fk
INNER JOIN sys.tables t ON fk.parent_object_id = t.OBJECT_ID
INNER JOIN syscolumns sc ON fk.parent_column_id = sc.colorder
AND sc.id = fk.parent_object_id
INNER JOIN syscolumns sc2 ON fk.referenced_object_id = sc2.id
AND fk.constraint_column_id = sc2.colorder
WHERE fk.referenced_object_id = (SELECT OBJECT_ID
FROM sys.tables
WHERE name = #TABLENAME)
WHILE (#i <= (SELECT COUNT(*) FROM #TABLE))
BEGIN
SELECT #tname = [table], #col = col, #basecol = basecol
FROM (SELECT ROW_NUMBER() OVER(ORDER BY col) [N],
[table], col, basecol
FROM #TABLE) A
WHERE A.N = #i
SET #SQL = #SQL + ' DELETE FROM ' + #TABLENAME + ' WHERE ' + #basecol + ' NOT IN (SELECT ' + #col+ ' FROM ' + #tname + ')'
SET #i = #i + 1
END
SELECT #SQL

Answer 6

If you want to keep code simple (you said that) let you CREATE VIEW over your table.
Define WHERE clause to get only deletable rows.
Then you may just DELETE FROM ClientsDeletable.
Remember about DELETE permission for your new view.
Script example:
CREATE VIEW ClientsDeletable
AS
SELECT *
FROM Clients
WHERE
ClientID NOT IN (SELECT CliID FROM ForeignTab1)
AND
ClientID NOT IN (SELECT CliID FROM ForeignTab2)
Notice, that FROM cannot contains JOINs - other way you'll get error:
Msg 4405, Level 16, State 1, Line 1
View or function 'ClientsDeletable' is not updatable because the modification affects multiple base tables.