Debian Codegraph @

tests/delete/tests.py

raw
1 from math import ceil
2
3 from django.db import connection, models
4 from django.db.models import ProtectedError, Q, RestrictedError
5 from django.db.models.deletion import Collector
6 from django.db.models.sql.constants import GET_ITERATOR_CHUNK_SIZE
7 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
8
9 from .models import (
10 B1,
11 B2,
12 B3,
13 MR,
14 A,
15 Avatar,
16 B,
17 Base,
18 Child,
19 DeleteBottom,
20 DeleteTop,
21 GenericB1,
22 GenericB2,
23 GenericDeleteBottom,
24 HiddenUser,
25 HiddenUserProfile,
26 M,
27 M2MFrom,
28 M2MTo,
29 MRNull,
30 Origin,
31 P,
32 Parent,
33 R,
34 RChild,
35 RChildChild,
36 Referrer,
37 S,
38 T,
39 User,
40 create_a,
41 get_default_r,
42 )
43
44
45 class OnDeleteTests(TestCase):
46 def setUp(self):
47 self.DEFAULT = get_default_r()
48
49 def test_auto(self):
50 a = create_a("auto")
51 a.auto.delete()
52 self.assertFalse(A.objects.filter(name="auto").exists())
53
54 def test_non_callable(self):
55 msg = "on_delete must be callable."
56 with self.assertRaisesMessage(TypeError, msg):
57 models.ForeignKey("self", on_delete=None)
58 with self.assertRaisesMessage(TypeError, msg):
59 models.OneToOneField("self", on_delete=None)
60
61 def test_auto_nullable(self):
62 a = create_a("auto_nullable")
63 a.auto_nullable.delete()
64 self.assertFalse(A.objects.filter(name="auto_nullable").exists())
65
66 def test_setvalue(self):
67 a = create_a("setvalue")
68 a.setvalue.delete()
69 a = A.objects.get(pk=a.pk)
70 self.assertEqual(self.DEFAULT, a.setvalue.pk)
71
72 def test_setnull(self):
73 a = create_a("setnull")
74 a.setnull.delete()
75 a = A.objects.get(pk=a.pk)
76 self.assertIsNone(a.setnull)
77
78 def test_setdefault(self):
79 a = create_a("setdefault")
80 a.setdefault.delete()
81 a = A.objects.get(pk=a.pk)
82 self.assertEqual(self.DEFAULT, a.setdefault.pk)
83
84 def test_setdefault_none(self):
85 a = create_a("setdefault_none")
86 a.setdefault_none.delete()
87 a = A.objects.get(pk=a.pk)
88 self.assertIsNone(a.setdefault_none)
89
90 def test_cascade(self):
91 a = create_a("cascade")
92 a.cascade.delete()
93 self.assertFalse(A.objects.filter(name="cascade").exists())
94
95 def test_cascade_nullable(self):
96 a = create_a("cascade_nullable")
97 a.cascade_nullable.delete()
98 self.assertFalse(A.objects.filter(name="cascade_nullable").exists())
99
100 def test_protect(self):
101 a = create_a("protect")
102 msg = (
103 "Cannot delete some instances of model 'R' because they are "
104 "referenced through protected foreign keys: 'A.protect'."
105 )
106 with self.assertRaisesMessage(ProtectedError, msg) as cm:
107 a.protect.delete()
108 self.assertEqual(cm.exception.protected_objects, {a})
109
110 def test_protect_multiple(self):
111 a = create_a("protect")
112 b = B.objects.create(protect=a.protect)
113 msg = (
114 "Cannot delete some instances of model 'R' because they are "
115 "referenced through protected foreign keys: 'A.protect', "
116 "'B.protect'."
117 )
118 with self.assertRaisesMessage(ProtectedError, msg) as cm:
119 a.protect.delete()
120 self.assertEqual(cm.exception.protected_objects, {a, b})
121
122 def test_protect_path(self):
123 a = create_a("protect")
124 a.protect.p = P.objects.create()
125 a.protect.save()
126 msg = (
127 "Cannot delete some instances of model 'P' because they are "
128 "referenced through protected foreign keys: 'R.p'."
129 )
130 with self.assertRaisesMessage(ProtectedError, msg) as cm:
131 a.protect.p.delete()
132 self.assertEqual(cm.exception.protected_objects, {a})
133
134 def test_do_nothing(self):
135 # Testing DO_NOTHING is a bit harder: It would raise IntegrityError for
136 # a normal model, so we connect to pre_delete and set the fk to a known
137 # value.
138 replacement_r = R.objects.create()
139
140 def check_do_nothing(sender, **kwargs):
141 obj = kwargs["instance"]
142 obj.donothing_set.update(donothing=replacement_r)
143
144 models.signals.pre_delete.connect(check_do_nothing)
145 a = create_a("do_nothing")
146 a.donothing.delete()
147 a = A.objects.get(pk=a.pk)
148 self.assertEqual(replacement_r, a.donothing)
149 models.signals.pre_delete.disconnect(check_do_nothing)
150
151 def test_do_nothing_qscount(self):
152 """
153 A models.DO_NOTHING relation doesn't trigger a query.
154 """
155 b = Base.objects.create()
156 with self.assertNumQueries(1):
157 # RelToBase should not be queried.
158 b.delete()
159 self.assertEqual(Base.objects.count(), 0)
160
161 def test_inheritance_cascade_up(self):
162 child = RChild.objects.create()
163 child.delete()
164 self.assertFalse(R.objects.filter(pk=child.pk).exists())
165
166 def test_inheritance_cascade_down(self):
167 child = RChild.objects.create()
168 parent = child.r_ptr
169 parent.delete()
170 self.assertFalse(RChild.objects.filter(pk=child.pk).exists())
171
172 def test_cascade_from_child(self):
173 a = create_a("child")
174 a.child.delete()
175 self.assertFalse(A.objects.filter(name="child").exists())
176 self.assertFalse(R.objects.filter(pk=a.child_id).exists())
177
178 def test_cascade_from_parent(self):
179 a = create_a("child")
180 R.objects.get(pk=a.child_id).delete()
181 self.assertFalse(A.objects.filter(name="child").exists())
182 self.assertFalse(RChild.objects.filter(pk=a.child_id).exists())
183
184 def test_setnull_from_child(self):
185 a = create_a("child_setnull")
186 a.child_setnull.delete()
187 self.assertFalse(R.objects.filter(pk=a.child_setnull_id).exists())
188
189 a = A.objects.get(pk=a.pk)
190 self.assertIsNone(a.child_setnull)
191
192 def test_setnull_from_parent(self):
193 a = create_a("child_setnull")
194 R.objects.get(pk=a.child_setnull_id).delete()
195 self.assertFalse(RChild.objects.filter(pk=a.child_setnull_id).exists())
196
197 a = A.objects.get(pk=a.pk)
198 self.assertIsNone(a.child_setnull)
199
200 def test_o2o_setnull(self):
201 a = create_a("o2o_setnull")
202 a.o2o_setnull.delete()
203 a = A.objects.get(pk=a.pk)
204 self.assertIsNone(a.o2o_setnull)
205
206 def test_restrict(self):
207 a = create_a("restrict")
208 msg = (
209 "Cannot delete some instances of model 'R' because they are "
210 "referenced through restricted foreign keys: 'A.restrict'."
211 )
212 with self.assertRaisesMessage(RestrictedError, msg) as cm:
213 a.restrict.delete()
214 self.assertEqual(cm.exception.restricted_objects, {a})
215
216 def test_restrict_multiple(self):
217 a = create_a("restrict")
218 b3 = B3.objects.create(restrict=a.restrict)
219 msg = (
220 "Cannot delete some instances of model 'R' because they are "
221 "referenced through restricted foreign keys: 'A.restrict', "
222 "'B3.restrict'."
223 )
224 with self.assertRaisesMessage(RestrictedError, msg) as cm:
225 a.restrict.delete()
226 self.assertEqual(cm.exception.restricted_objects, {a, b3})
227
228 def test_restrict_path_cascade_indirect(self):
229 a = create_a("restrict")
230 a.restrict.p = P.objects.create()
231 a.restrict.save()
232 msg = (
233 "Cannot delete some instances of model 'P' because they are "
234 "referenced through restricted foreign keys: 'A.restrict'."
235 )
236 with self.assertRaisesMessage(RestrictedError, msg) as cm:
237 a.restrict.p.delete()
238 self.assertEqual(cm.exception.restricted_objects, {a})
239 # Object referenced also with CASCADE relationship can be deleted.
240 a.cascade.p = a.restrict.p
241 a.cascade.save()
242 a.restrict.p.delete()
243 self.assertFalse(A.objects.filter(name="restrict").exists())
244 self.assertFalse(R.objects.filter(pk=a.restrict_id).exists())
245
246 def test_restrict_path_cascade_direct(self):
247 a = create_a("restrict")
248 a.restrict.p = P.objects.create()
249 a.restrict.save()
250 a.cascade_p = a.restrict.p
251 a.save()
252 a.restrict.p.delete()
253 self.assertFalse(A.objects.filter(name="restrict").exists())
254 self.assertFalse(R.objects.filter(pk=a.restrict_id).exists())
255
256 def test_restrict_path_cascade_indirect_diamond(self):
257 delete_top = DeleteTop.objects.create()
258 b1 = B1.objects.create(delete_top=delete_top)
259 b2 = B2.objects.create(delete_top=delete_top)
260 delete_bottom = DeleteBottom.objects.create(b1=b1, b2=b2)
261 msg = (
262 "Cannot delete some instances of model 'B1' because they are "
263 "referenced through restricted foreign keys: 'DeleteBottom.b1'."
264 )
265 with self.assertRaisesMessage(RestrictedError, msg) as cm:
266 b1.delete()
267 self.assertEqual(cm.exception.restricted_objects, {delete_bottom})
268 self.assertTrue(DeleteTop.objects.exists())
269 self.assertTrue(B1.objects.exists())
270 self.assertTrue(B2.objects.exists())
271 self.assertTrue(DeleteBottom.objects.exists())
272 # Object referenced also with CASCADE relationship can be deleted.
273 delete_top.delete()
274 self.assertFalse(DeleteTop.objects.exists())
275 self.assertFalse(B1.objects.exists())
276 self.assertFalse(B2.objects.exists())
277 self.assertFalse(DeleteBottom.objects.exists())
278
279 def test_restrict_gfk_no_fast_delete(self):
280 delete_top = DeleteTop.objects.create()
281 generic_b1 = GenericB1.objects.create(generic_delete_top=delete_top)
282 generic_b2 = GenericB2.objects.create(generic_delete_top=delete_top)
283 generic_delete_bottom = GenericDeleteBottom.objects.create(
284 generic_b1=generic_b1,
285 generic_b2=generic_b2,
286 )
287 msg = (
288 "Cannot delete some instances of model 'GenericB1' because they "
289 "are referenced through restricted foreign keys: "
290 "'GenericDeleteBottom.generic_b1'."
291 )
292 with self.assertRaisesMessage(RestrictedError, msg) as cm:
293 generic_b1.delete()
294 self.assertEqual(cm.exception.restricted_objects, {generic_delete_bottom})
295 self.assertTrue(DeleteTop.objects.exists())
296 self.assertTrue(GenericB1.objects.exists())
297 self.assertTrue(GenericB2.objects.exists())
298 self.assertTrue(GenericDeleteBottom.objects.exists())
299 # Object referenced also with CASCADE relationship can be deleted.
300 delete_top.delete()
301 self.assertFalse(DeleteTop.objects.exists())
302 self.assertFalse(GenericB1.objects.exists())
303 self.assertFalse(GenericB2.objects.exists())
304 self.assertFalse(GenericDeleteBottom.objects.exists())
305
306
307 class DeletionTests(TestCase):
308 def test_sliced_queryset(self):
309 msg = "Cannot use 'limit' or 'offset' with delete()."
310 with self.assertRaisesMessage(TypeError, msg):
311 M.objects.all()[0:5].delete()
312
313 def test_pk_none(self):
314 m = M()
315 msg = "M object can't be deleted because its id attribute is set to None."
316 with self.assertRaisesMessage(ValueError, msg):
317 m.delete()
318
319 def test_m2m(self):
320 m = M.objects.create()
321 r = R.objects.create()
322 MR.objects.create(m=m, r=r)
323 r.delete()
324 self.assertFalse(MR.objects.exists())
325
326 r = R.objects.create()
327 MR.objects.create(m=m, r=r)
328 m.delete()
329 self.assertFalse(MR.objects.exists())
330
331 m = M.objects.create()
332 r = R.objects.create()
333 m.m2m.add(r)
334 r.delete()
335 through = M._meta.get_field("m2m").remote_field.through
336 self.assertFalse(through.objects.exists())
337
338 r = R.objects.create()
339 m.m2m.add(r)
340 m.delete()
341 self.assertFalse(through.objects.exists())
342
343 m = M.objects.create()
344 r = R.objects.create()
345 MRNull.objects.create(m=m, r=r)
346 r.delete()
347 self.assertFalse(not MRNull.objects.exists())
348 self.assertFalse(m.m2m_through_null.exists())
349
350 def test_bulk(self):
351 s = S.objects.create(r=R.objects.create())
352 for i in range(2 * GET_ITERATOR_CHUNK_SIZE):
353 T.objects.create(s=s)
354 # 1 (select related `T` instances)
355 # + 1 (select related `U` instances)
356 # + 2 (delete `T` instances in batches)
357 # + 1 (delete `s`)
358 self.assertNumQueries(5, s.delete)
359 self.assertFalse(S.objects.exists())
360
361 def test_instance_update(self):
362 deleted = []
363 related_setnull_sets = []
364
365 def pre_delete(sender, **kwargs):
366 obj = kwargs["instance"]
367 deleted.append(obj)
368 if isinstance(obj, R):
369 related_setnull_sets.append([a.pk for a in obj.setnull_set.all()])
370
371 models.signals.pre_delete.connect(pre_delete)
372 a = create_a("update_setnull")
373 a.setnull.delete()
374
375 a = create_a("update_cascade")
376 a.cascade.delete()
377
378 for obj in deleted:
379 self.assertIsNone(obj.pk)
380
381 for pk_list in related_setnull_sets:
382 for a in A.objects.filter(id__in=pk_list):
383 self.assertIsNone(a.setnull)
384
385 models.signals.pre_delete.disconnect(pre_delete)
386
387 def test_deletion_order(self):
388 pre_delete_order = []
389 post_delete_order = []
390
391 def log_post_delete(sender, **kwargs):
392 pre_delete_order.append((sender, kwargs["instance"].pk))
393
394 def log_pre_delete(sender, **kwargs):
395 post_delete_order.append((sender, kwargs["instance"].pk))
396
397 models.signals.post_delete.connect(log_post_delete)
398 models.signals.pre_delete.connect(log_pre_delete)
399
400 r = R.objects.create()
401 s1 = S.objects.create(r=r)
402 s2 = S.objects.create(r=r)
403 t1 = T.objects.create(s=s1)
404 t2 = T.objects.create(s=s2)
405 rchild = RChild.objects.create(r_ptr=r)
406 r_pk = r.pk
407 r.delete()
408 self.assertEqual(
409 pre_delete_order,
410 [
411 (T, t2.pk),
412 (T, t1.pk),
413 (RChild, rchild.pk),
414 (S, s2.pk),
415 (S, s1.pk),
416 (R, r_pk),
417 ],
418 )
419 self.assertEqual(
420 post_delete_order,
421 [
422 (T, t1.pk),
423 (T, t2.pk),
424 (RChild, rchild.pk),
425 (S, s1.pk),
426 (S, s2.pk),
427 (R, r_pk),
428 ],
429 )
430
431 models.signals.post_delete.disconnect(log_post_delete)
432 models.signals.pre_delete.disconnect(log_pre_delete)
433
434 def test_relational_post_delete_signals_happen_before_parent_object(self):
435 deletions = []
436
437 def log_post_delete(instance, **kwargs):
438 self.assertTrue(R.objects.filter(pk=instance.r_id))
439 self.assertIs(type(instance), S)
440 deletions.append(instance.id)
441
442 r = R.objects.create()
443 s = S.objects.create(r=r)
444 s_id = s.pk
445 models.signals.post_delete.connect(log_post_delete, sender=S)
446
447 try:
448 r.delete()
449 finally:
450 models.signals.post_delete.disconnect(log_post_delete)
451
452 self.assertEqual(len(deletions), 1)
453 self.assertEqual(deletions[0], s_id)
454
455 @skipUnlessDBFeature("can_defer_constraint_checks")
456 def test_can_defer_constraint_checks(self):
457 u = User.objects.create(avatar=Avatar.objects.create())
458 a = Avatar.objects.get(pk=u.avatar_id)
459 # 1 query to find the users for the avatar.
460 # 1 query to delete the user
461 # 1 query to delete the avatar
462 # The important thing is that when we can defer constraint checks there
463 # is no need to do an UPDATE on User.avatar to null it out.
464
465 # Attach a signal to make sure we will not do fast_deletes.
466 calls = []
467
468 def noop(*args, **kwargs):
469 calls.append("")
470
471 models.signals.post_delete.connect(noop, sender=User)
472
473 self.assertNumQueries(3, a.delete)
474 self.assertFalse(User.objects.exists())
475 self.assertFalse(Avatar.objects.exists())
476 self.assertEqual(len(calls), 1)
477 models.signals.post_delete.disconnect(noop, sender=User)
478
479 @skipIfDBFeature("can_defer_constraint_checks")
480 def test_cannot_defer_constraint_checks(self):
481 u = User.objects.create(avatar=Avatar.objects.create())
482 # Attach a signal to make sure we will not do fast_deletes.
483 calls = []
484
485 def noop(*args, **kwargs):
486 calls.append("")
487
488 models.signals.post_delete.connect(noop, sender=User)
489
490 a = Avatar.objects.get(pk=u.avatar_id)
491 # The below doesn't make sense... Why do we need to null out
492 # user.avatar if we are going to delete the user immediately after it,
493 # and there are no more cascades.
494 # 1 query to find the users for the avatar.
495 # 1 query to delete the user
496 # 1 query to null out user.avatar, because we can't defer the constraint
497 # 1 query to delete the avatar
498 self.assertNumQueries(4, a.delete)
499 self.assertFalse(User.objects.exists())
500 self.assertFalse(Avatar.objects.exists())
501 self.assertEqual(len(calls), 1)
502 models.signals.post_delete.disconnect(noop, sender=User)
503
504 def test_hidden_related(self):
505 r = R.objects.create()
506 h = HiddenUser.objects.create(r=r)
507 HiddenUserProfile.objects.create(user=h)
508
509 r.delete()
510 self.assertEqual(HiddenUserProfile.objects.count(), 0)
511
512 def test_large_delete(self):
513 TEST_SIZE = 2000
514 objs = [Avatar() for i in range(0, TEST_SIZE)]
515 Avatar.objects.bulk_create(objs)
516 # Calculate the number of queries needed.
517 batch_size = connection.ops.bulk_batch_size(["pk"], objs)
518 # The related fetches are done in batches.
519 batches = ceil(len(objs) / batch_size)
520 # One query for Avatar.objects.all() and then one related fast delete for
521 # each batch.
522 fetches_to_mem = 1 + batches
523 # The Avatar objects are going to be deleted in batches of
524 # GET_ITERATOR_CHUNK_SIZE.
525 queries = fetches_to_mem + TEST_SIZE // GET_ITERATOR_CHUNK_SIZE
526 self.assertNumQueries(queries, Avatar.objects.all().delete)
527 self.assertFalse(Avatar.objects.exists())
528
529 def test_large_delete_related(self):
530 TEST_SIZE = 2000
531 s = S.objects.create(r=R.objects.create())
532 for i in range(TEST_SIZE):
533 T.objects.create(s=s)
534
535 batch_size = max(connection.ops.bulk_batch_size(["pk"], range(TEST_SIZE)), 1)
536
537 # TEST_SIZE / batch_size (select related `T` instances)
538 # + 1 (select related `U` instances)
539 # + TEST_SIZE / GET_ITERATOR_CHUNK_SIZE (delete `T` instances in batches)
540 # + 1 (delete `s`)
541 expected_num_queries = ceil(TEST_SIZE / batch_size)
542 expected_num_queries += ceil(TEST_SIZE / GET_ITERATOR_CHUNK_SIZE) + 2
543
544 self.assertNumQueries(expected_num_queries, s.delete)
545 self.assertFalse(S.objects.exists())
546 self.assertFalse(T.objects.exists())
547
548 def test_delete_with_keeping_parents(self):
549 child = RChild.objects.create()
550 parent_id = child.r_ptr_id
551 child.delete(keep_parents=True)
552 self.assertFalse(RChild.objects.filter(id=child.id).exists())
553 self.assertTrue(R.objects.filter(id=parent_id).exists())
554
555 def test_delete_with_keeping_parents_relationships(self):
556 child = RChild.objects.create()
557 parent_id = child.r_ptr_id
558 parent_referent_id = S.objects.create(r=child.r_ptr).pk
559 child.delete(keep_parents=True)
560 self.assertFalse(RChild.objects.filter(id=child.id).exists())
561 self.assertTrue(R.objects.filter(id=parent_id).exists())
562 self.assertTrue(S.objects.filter(pk=parent_referent_id).exists())
563
564 childchild = RChildChild.objects.create()
565 parent_id = childchild.rchild_ptr.r_ptr_id
566 child_id = childchild.rchild_ptr_id
567 parent_referent_id = S.objects.create(r=childchild.rchild_ptr.r_ptr).pk
568 childchild.delete(keep_parents=True)
569 self.assertFalse(RChildChild.objects.filter(id=childchild.id).exists())
570 self.assertTrue(RChild.objects.filter(id=child_id).exists())
571 self.assertTrue(R.objects.filter(id=parent_id).exists())
572 self.assertTrue(S.objects.filter(pk=parent_referent_id).exists())
573
574 def test_queryset_delete_returns_num_rows(self):
575 """
576 QuerySet.delete() should return the number of deleted rows and a
577 dictionary with the number of deletions for each object type.
578 """
579 Avatar.objects.bulk_create(
580 [Avatar(desc="a"), Avatar(desc="b"), Avatar(desc="c")]
581 )
582 avatars_count = Avatar.objects.count()
583 deleted, rows_count = Avatar.objects.all().delete()
584 self.assertEqual(deleted, avatars_count)
585
586 # more complex example with multiple object types
587 r = R.objects.create()
588 h1 = HiddenUser.objects.create(r=r)
589 HiddenUser.objects.create(r=r)
590 HiddenUserProfile.objects.create(user=h1)
591 existed_objs = {
592 R._meta.label: R.objects.count(),
593 HiddenUser._meta.label: HiddenUser.objects.count(),
594 HiddenUserProfile._meta.label: HiddenUserProfile.objects.count(),
595 }
596 deleted, deleted_objs = R.objects.all().delete()
597 self.assertCountEqual(deleted_objs.keys(), existed_objs.keys())
598 for k, v in existed_objs.items():
599 self.assertEqual(deleted_objs[k], v)
600
601 def test_model_delete_returns_num_rows(self):
602 """
603 Model.delete() should return the number of deleted rows and a
604 dictionary with the number of deletions for each object type.
605 """
606 r = R.objects.create()
607 h1 = HiddenUser.objects.create(r=r)
608 h2 = HiddenUser.objects.create(r=r)
609 HiddenUser.objects.create(r=r)
610 HiddenUserProfile.objects.create(user=h1)
611 HiddenUserProfile.objects.create(user=h2)
612 m1 = M.objects.create()
613 m2 = M.objects.create()
614 MR.objects.create(r=r, m=m1)
615 r.m_set.add(m1)
616 r.m_set.add(m2)
617 r.save()
618 existed_objs = {
619 R._meta.label: R.objects.count(),
620 HiddenUser._meta.label: HiddenUser.objects.count(),
621 MR._meta.label: MR.objects.count(),
622 HiddenUserProfile._meta.label: HiddenUserProfile.objects.count(),
623 M.m2m.through._meta.label: M.m2m.through.objects.count(),
624 }
625 deleted, deleted_objs = r.delete()
626 self.assertEqual(deleted, sum(existed_objs.values()))
627 self.assertCountEqual(deleted_objs.keys(), existed_objs.keys())
628 for k, v in existed_objs.items():
629 self.assertEqual(deleted_objs[k], v)
630
631 def test_proxied_model_duplicate_queries(self):
632 """
633 #25685 - Deleting instances of a model with existing proxy
634 classes should not issue multiple queries during cascade
635 deletion of referring models.
636 """
637 avatar = Avatar.objects.create()
638 # One query for the Avatar table and a second for the User one.
639 with self.assertNumQueries(2):
640 avatar.delete()
641
642 def test_only_referenced_fields_selected(self):
643 """
644 Only referenced fields are selected during cascade deletion SELECT
645 unless deletion signals are connected.
646 """
647 origin = Origin.objects.create()
648 expected_sql = str(
649 Referrer.objects.only(
650 # Both fields are referenced by SecondReferrer.
651 "id",
652 "unique_field",
653 )
654 .filter(origin__in=[origin])
655 .query
656 )
657 with self.assertNumQueries(2) as ctx:
658 origin.delete()
659 self.assertEqual(ctx.captured_queries[0]["sql"], expected_sql)
660
661 def receiver(instance, **kwargs):
662 pass
663
664 # All fields are selected if deletion signals are connected.
665 for signal_name in ("pre_delete", "post_delete"):
666 with self.subTest(signal=signal_name):
667 origin = Origin.objects.create()
668 signal = getattr(models.signals, signal_name)
669 signal.connect(receiver, sender=Referrer)
670 with self.assertNumQueries(2) as ctx:
671 origin.delete()
672 self.assertIn(
673 connection.ops.quote_name("large_field"),
674 ctx.captured_queries[0]["sql"],
675 )
676 signal.disconnect(receiver, sender=Referrer)
677
678
679 class FastDeleteTests(TestCase):
680 def test_fast_delete_all(self):
681 with self.assertNumQueries(1) as ctx:
682 User.objects.all().delete()
683 sql = ctx.captured_queries[0]["sql"]
684 # No subqueries is used when performing a full delete.
685 self.assertNotIn("SELECT", sql)
686
687 def test_fast_delete_fk(self):
688 u = User.objects.create(avatar=Avatar.objects.create())
689 a = Avatar.objects.get(pk=u.avatar_id)
690 # 1 query to fast-delete the user
691 # 1 query to delete the avatar
692 self.assertNumQueries(2, a.delete)
693 self.assertFalse(User.objects.exists())
694 self.assertFalse(Avatar.objects.exists())
695
696 def test_fast_delete_m2m(self):
697 t = M2MTo.objects.create()
698 f = M2MFrom.objects.create()
699 f.m2m.add(t)
700 # 1 to delete f, 1 to fast-delete m2m for f
701 self.assertNumQueries(2, f.delete)
702
703 def test_fast_delete_revm2m(self):
704 t = M2MTo.objects.create()
705 f = M2MFrom.objects.create()
706 f.m2m.add(t)
707 # 1 to delete t, 1 to fast-delete t's m_set
708 self.assertNumQueries(2, f.delete)
709
710 def test_fast_delete_qs(self):
711 u1 = User.objects.create()
712 u2 = User.objects.create()
713 self.assertNumQueries(1, User.objects.filter(pk=u1.pk).delete)
714 self.assertEqual(User.objects.count(), 1)
715 self.assertTrue(User.objects.filter(pk=u2.pk).exists())
716
717 def test_fast_delete_instance_set_pk_none(self):
718 u = User.objects.create()
719 # User can be fast-deleted.
720 collector = Collector(using="default")
721 self.assertTrue(collector.can_fast_delete(u))
722 u.delete()
723 self.assertIsNone(u.pk)
724
725 def test_fast_delete_joined_qs(self):
726 a = Avatar.objects.create(desc="a")
727 User.objects.create(avatar=a)
728 u2 = User.objects.create()
729 self.assertNumQueries(1, User.objects.filter(avatar__desc="a").delete)
730 self.assertEqual(User.objects.count(), 1)
731 self.assertTrue(User.objects.filter(pk=u2.pk).exists())
732
733 def test_fast_delete_inheritance(self):
734 c = Child.objects.create()
735 p = Parent.objects.create()
736 # 1 for self, 1 for parent
737 self.assertNumQueries(2, c.delete)
738 self.assertFalse(Child.objects.exists())
739 self.assertEqual(Parent.objects.count(), 1)
740 self.assertEqual(Parent.objects.filter(pk=p.pk).count(), 1)
741 # 1 for self delete, 1 for fast delete of empty "child" qs.
742 self.assertNumQueries(2, p.delete)
743 self.assertFalse(Parent.objects.exists())
744 # 1 for self delete, 1 for fast delete of empty "child" qs.
745 c = Child.objects.create()
746 p = c.parent_ptr
747 self.assertNumQueries(2, p.delete)
748 self.assertFalse(Parent.objects.exists())
749 self.assertFalse(Child.objects.exists())
750
751 def test_fast_delete_large_batch(self):
752 User.objects.bulk_create(User() for i in range(0, 2000))
753 # No problems here - we aren't going to cascade, so we will fast
754 # delete the objects in a single query.
755 self.assertNumQueries(1, User.objects.all().delete)
756 a = Avatar.objects.create(desc="a")
757 User.objects.bulk_create(User(avatar=a) for i in range(0, 2000))
758 # We don't hit parameter amount limits for a, so just one query for
759 # that + fast delete of the related objs.
760 self.assertNumQueries(2, a.delete)
761 self.assertEqual(User.objects.count(), 0)
762
763 def test_fast_delete_empty_no_update_can_self_select(self):
764 """
765 Fast deleting when DatabaseFeatures.update_can_self_select = False
766 works even if the specified filter doesn't match any row (#25932).
767 """
768 with self.assertNumQueries(1):
769 self.assertEqual(
770 User.objects.filter(avatar__desc="missing").delete(),
771 (0, {}),
772 )
773
774 def test_fast_delete_combined_relationships(self):
775 # The cascading fast-delete of SecondReferrer should be combined
776 # in a single DELETE WHERE referrer_id OR unique_field.
777 origin = Origin.objects.create()
778 referer = Referrer.objects.create(origin=origin, unique_field=42)
779 with self.assertNumQueries(2):
780 referer.delete()
781
782 def test_fast_delete_aggregation(self):
783 # Fast-deleting when filtering against an aggregation result in
784 # a single query containing a subquery.
785 Base.objects.create()
786 with self.assertNumQueries(1):
787 self.assertEqual(
788 Base.objects.annotate(
789 rels_count=models.Count("rels"),
790 )
791 .filter(rels_count=0)
792 .delete(),
793 (1, {"delete.Base": 1}),
794 )
795 self.assertIs(Base.objects.exists(), False)
796
797 def test_fast_delete_empty_result_set(self):
798 user = User.objects.create()
799 with self.assertNumQueries(0):
800 self.assertEqual(
801 User.objects.filter(pk__in=[]).delete(),
802 (0, {}),
803 )
804 self.assertSequenceEqual(User.objects.all(), [user])
805
806 def test_fast_delete_full_match(self):
807 avatar = Avatar.objects.create(desc="bar")
808 User.objects.create(avatar=avatar)
809 with self.assertNumQueries(1):
810 User.objects.filter(~Q(pk__in=[]) | Q(avatar__desc="foo")).delete()
811 self.assertFalse(User.objects.exists())