| 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()) |