带有外键约束的sql删除

Question

I have three tables, one of them is a relation table, for example:

Table People has primary key : peopleid ;
Table Pet has primary key : petid ;
Table Own has two foreign keys: peopleid and petid , they together serve as the primary key of table Own

Now
I'm trying to delete a person from Table People given peopleid , meanwhile, the pets this person own should be deleted, as well as the relationship stored in table Own

Please shed some light, thanks in advance!

Edit: My question is how to write the sql to achieve this.

Answer 1

One option is to use a multitable DELETE statement, to delete rows from all three tables, for example:

DELETE o.*
     , t.*
     , p.*
  FROM pet t
  JOIN own o
    ON o.petid = t.petid
  JOIN people p
    ON p.peopleid = o.peopleid
 WHERE p.peopleid = :b_peopleid

But... there's an issue with foreign keys. The rows may be deleted in an order that causes foreign key constraints to be violated. This isn't a problem with MyISAM, since it doesn't enforce foreign keys. But with InnoDB, if there are foreign key constraints defined, this can be a problem Unfortunately, InnoDB doesn't (yet?) support deferrable constraints, so the closest workaround to this is to temporarily disable foreign key checks...

SET foreign_key_checks = 0 ;

then the DELETE statement, and then re-enable the foreign key checks...

SET foreign_key_checks = 1; 

But this disables ALL foreign key checks in the session, not just the foreign keys defined on the tables referenced in the DELETE. So, this approach is less than ideal, because of the potential for introducing inconsistent data.

(For example, if there's another table with a foreign key that references pet.petid, and we delete the "parent" row from pet, that may leave a rows in the "child" table that reference a non-existent key.)

DELETE row(s) from pet ?

The data model suggests that a pet may be related to more than one people . For example:

pet:    petid    petname
            ------   -------
            1        Spot

    people: peopleid name
            -------- ------
            2        Jack
            3        Jill

    own:    petid    peopleid
            -------  --------
            1        2
            1        3

If we were to delete "Jack", we could remove the associated row in "own" (the relationship between "Jack" and "Spot". But in this scenario, "Spot" is also related to "Jill". There's another row in own that references "Spot", so we wouldn't be able to remove "Spot", without also removing "Spot"'s relationship to "Jill".

So, the question is, do we really want to delete "Spot" in this case?

If we do really want to delete "Spot", we would also need to remove that other row from own too, the one that relates "Spot" and "Jill". We can accomplish that using two references to the own table; one to get the relationship between "Jack" and his owned pet , and another to get all of the own rows that reference "Spot".

DELETE r.*
     , t.*
     , p.*
  FROM pet t
  JOIN own r
    ON r.petid = t.petid
  JOIN own o
    ON o.petid = t.petid
  JOIN people p
    ON p.peopleid = o.peopleid
 WHERE p.peopleid = :b_peopleid

On the other hand, if we don't want to remove "Spot", because the "Jill"/"Spot" row in own also references "Spot", we might be able to do something very similar. (I don't a SQL example for this.)

---

Some other options for dealing with foreign key relationships that may be workable for your use-case are BEFORE DELETE triggers, and/or ON DELETE rules on the foreign key constraints.)

If we had ON DELETE CASCADE rules defined on the foreign keys from own that reference people and pet , we could allow that to remove the rows from own .

Then we could use that first example DELETE statement in my answer, and we could omit the reference to o.* in the DELETE list, and just specify t.* and p.* . (We still need the reference to the own table in the FROM clause, to get the relationship between people ("Jack") and pet ("Spot"), so we know which rows from pet to remove.

---

Otherwise, you could run three separate DELETE statements. But the order that the DELETE statements are executed may actually remove information you need, to determine which rows in the other tables need to be deleted. This means you would likely need to query the tables to find the rows to be deleted, save that information, and then perform the required deletes, in an appropriate order.

---

Another workable approach to this kind of "delete" problem is to emulate a delete with an update of a "deleted_flag" type column on the row.

That is, rather than issue a DELETE statement, the application instead issues an UPDATE to set a special purpose "deleted_flag" on each row. But, the application use cases have to be designed for this, and almost all the queries that look for "non-deleted" data need to incorporate predicates that exclude the "deleted" rows. If logically deleted rows do actually do need to be deleted from the tables, then the DELETE statements can be run by a separate batch process.

Answer 2

I think what you need is ON DELETE CASCADE .
Using this, you can automatically remove all the table references, if you delete a primary key row.

In your case, if you delete a person using peopleid , it will automatically remove the references from Own table.

Sample SQL statement

CREATE TABLE Own (
peopleid int(11) NOT NULL,
KEY peopleid (peopleid),
FOREIGN KEY (peopleid)
REFERENCES People (peopleid)
ON DELETE CASCADE
) ENGINE=InnoDB;  

Since pet table has no foreign key to people table, you need to define a trigger to auto delete pet entries when people entries are deleted.

CREATE TRIGGER pet_delete AFTER DELETE on own
FOR EACH ROW
BEGIN
    DELETE FROM Pet
    WHERE Pet.petid = old.petid;
END  

After defining the cascade rule and trigger, if you execute:

DELETE FROM People WHERE peopleid = 3  

it will automatically delete entries from own table with peopleid = 3 and the corresponding petid from Pet table.

Check this link for more details.
http://www.mysqltutorial.org/mysql-on-delete-cascade/
MySQL Trigger: Delete From Table AFTER DELETE