| 1 |
from operator import attrgetter |
| 2 |
|
| 3 |
from django.contrib.contenttypes.models import ContentType |
| 4 |
from django.db import models |
| 5 |
from django.db.models import Count |
| 6 |
from django.test import TestCase |
| 7 |
|
| 8 |
from .models import ( |
| 9 |
Base, |
| 10 |
Child, |
| 11 |
Derived, |
| 12 |
Feature, |
| 13 |
Item, |
| 14 |
ItemAndSimpleItem, |
| 15 |
Leaf, |
| 16 |
Location, |
| 17 |
OneToOneItem, |
| 18 |
Proxy, |
| 19 |
ProxyRelated, |
| 20 |
RelatedItem, |
| 21 |
Request, |
| 22 |
ResolveThis, |
| 23 |
SimpleItem, |
| 24 |
SpecialFeature, |
| 25 |
) |
| 26 |
|
| 27 |
|
| 28 |
class DeferRegressionTest(TestCase): |
| 29 |
def test_basic(self): |
| 30 |
# Deferred fields should really be deferred and not accidentally use |
| 31 |
# the field's default value just because they aren't passed to __init__ |
| 32 |
|
| 33 |
Item.objects.create(name="first", value=42) |
| 34 |
obj = Item.objects.only("name", "other_value").get(name="first") |
| 35 |
# Accessing "name" doesn't trigger a new database query. Accessing |
| 36 |
# "value" or "text" should. |
| 37 |
with self.assertNumQueries(0): |
| 38 |
self.assertEqual(obj.name, "first") |
| 39 |
self.assertEqual(obj.other_value, 0) |
| 40 |
|
| 41 |
with self.assertNumQueries(1): |
| 42 |
self.assertEqual(obj.value, 42) |
| 43 |
|
| 44 |
with self.assertNumQueries(1): |
| 45 |
self.assertEqual(obj.text, "xyzzy") |
| 46 |
|
| 47 |
with self.assertNumQueries(0): |
| 48 |
self.assertEqual(obj.text, "xyzzy") |
| 49 |
|
| 50 |
# Regression test for #10695. Make sure different instances don't |
| 51 |
# inadvertently share data in the deferred descriptor objects. |
| 52 |
i = Item.objects.create(name="no I'm first", value=37) |
| 53 |
items = Item.objects.only("value").order_by("-value") |
| 54 |
self.assertEqual(items[0].name, "first") |
| 55 |
self.assertEqual(items[1].name, "no I'm first") |
| 56 |
|
| 57 |
RelatedItem.objects.create(item=i) |
| 58 |
r = RelatedItem.objects.defer("item").get() |
| 59 |
self.assertEqual(r.item_id, i.id) |
| 60 |
self.assertEqual(r.item, i) |
| 61 |
|
| 62 |
# Some further checks for select_related() and inherited model |
| 63 |
# behavior (regression for #10710). |
| 64 |
c1 = Child.objects.create(name="c1", value=42) |
| 65 |
c2 = Child.objects.create(name="c2", value=37) |
| 66 |
Leaf.objects.create(name="l1", child=c1, second_child=c2) |
| 67 |
|
| 68 |
obj = Leaf.objects.only("name", "child").select_related()[0] |
| 69 |
self.assertEqual(obj.child.name, "c1") |
| 70 |
|
| 71 |
self.assertQuerySetEqual( |
| 72 |
Leaf.objects.select_related().only("child__name", "second_child__name"), |
| 73 |
[ |
| 74 |
"l1", |
| 75 |
], |
| 76 |
attrgetter("name"), |
| 77 |
) |
| 78 |
|
| 79 |
# Models instances with deferred fields should still return the same |
| 80 |
# content types as their non-deferred versions (bug #10738). |
| 81 |
ctype = ContentType.objects.get_for_model |
| 82 |
c1 = ctype(Item.objects.all()[0]) |
| 83 |
c2 = ctype(Item.objects.defer("name")[0]) |
| 84 |
c3 = ctype(Item.objects.only("name")[0]) |
| 85 |
self.assertTrue(c1 is c2 is c3) |
| 86 |
|
| 87 |
# Regression for #10733 - only() can be used on a model with two |
| 88 |
# foreign keys. |
| 89 |
results = Leaf.objects.only("name", "child", "second_child").select_related() |
| 90 |
self.assertEqual(results[0].child.name, "c1") |
| 91 |
self.assertEqual(results[0].second_child.name, "c2") |
| 92 |
|
| 93 |
results = Leaf.objects.only( |
| 94 |
"name", "child", "second_child", "child__name", "second_child__name" |
| 95 |
).select_related() |
| 96 |
self.assertEqual(results[0].child.name, "c1") |
| 97 |
self.assertEqual(results[0].second_child.name, "c2") |
| 98 |
|
| 99 |
# Regression for #16409 - make sure defer() and only() work with annotate() |
| 100 |
self.assertIsInstance( |
| 101 |
list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list |
| 102 |
) |
| 103 |
self.assertIsInstance( |
| 104 |
list(SimpleItem.objects.annotate(Count("feature")).only("name")), list |
| 105 |
) |
| 106 |
|
| 107 |
def test_ticket_16409(self): |
| 108 |
# Regression for #16409 - make sure defer() and only() work with annotate() |
| 109 |
self.assertIsInstance( |
| 110 |
list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list |
| 111 |
) |
| 112 |
self.assertIsInstance( |
| 113 |
list(SimpleItem.objects.annotate(Count("feature")).only("name")), list |
| 114 |
) |
| 115 |
|
| 116 |
def test_ticket_23270(self): |
| 117 |
d = Derived.objects.create(text="foo", other_text="bar") |
| 118 |
with self.assertNumQueries(1): |
| 119 |
obj = Base.objects.select_related("derived").defer("text")[0] |
| 120 |
self.assertIsInstance(obj.derived, Derived) |
| 121 |
self.assertEqual("bar", obj.derived.other_text) |
| 122 |
self.assertNotIn("text", obj.__dict__) |
| 123 |
self.assertEqual(d.pk, obj.derived.base_ptr_id) |
| 124 |
|
| 125 |
def test_only_and_defer_usage_on_proxy_models(self): |
| 126 |
# Regression for #15790 - only() broken for proxy models |
| 127 |
proxy = Proxy.objects.create(name="proxy", value=42) |
| 128 |
|
| 129 |
msg = "QuerySet.only() return bogus results with proxy models" |
| 130 |
dp = Proxy.objects.only("other_value").get(pk=proxy.pk) |
| 131 |
self.assertEqual(dp.name, proxy.name, msg=msg) |
| 132 |
self.assertEqual(dp.value, proxy.value, msg=msg) |
| 133 |
|
| 134 |
# also test things with .defer() |
| 135 |
msg = "QuerySet.defer() return bogus results with proxy models" |
| 136 |
dp = Proxy.objects.defer("name", "text", "value").get(pk=proxy.pk) |
| 137 |
self.assertEqual(dp.name, proxy.name, msg=msg) |
| 138 |
self.assertEqual(dp.value, proxy.value, msg=msg) |
| 139 |
|
| 140 |
def test_resolve_columns(self): |
| 141 |
ResolveThis.objects.create(num=5.0, name="Foobar") |
| 142 |
qs = ResolveThis.objects.defer("num") |
| 143 |
self.assertEqual(1, qs.count()) |
| 144 |
self.assertEqual("Foobar", qs[0].name) |
| 145 |
|
| 146 |
def test_reverse_one_to_one_relations(self): |
| 147 |
# Refs #14694. Test reverse relations which are known unique (reverse |
| 148 |
# side has o2ofield or unique FK) - the o2o case |
| 149 |
item = Item.objects.create(name="first", value=42) |
| 150 |
o2o = OneToOneItem.objects.create(item=item, name="second") |
| 151 |
self.assertEqual(len(Item.objects.defer("one_to_one_item__name")), 1) |
| 152 |
self.assertEqual(len(Item.objects.select_related("one_to_one_item")), 1) |
| 153 |
self.assertEqual( |
| 154 |
len( |
| 155 |
Item.objects.select_related("one_to_one_item").defer( |
| 156 |
"one_to_one_item__name" |
| 157 |
) |
| 158 |
), |
| 159 |
1, |
| 160 |
) |
| 161 |
self.assertEqual( |
| 162 |
len(Item.objects.select_related("one_to_one_item").defer("value")), 1 |
| 163 |
) |
| 164 |
# Make sure that `only()` doesn't break when we pass in a unique relation, |
| 165 |
# rather than a field on the relation. |
| 166 |
self.assertEqual(len(Item.objects.only("one_to_one_item")), 1) |
| 167 |
with self.assertNumQueries(1): |
| 168 |
i = Item.objects.select_related("one_to_one_item")[0] |
| 169 |
self.assertEqual(i.one_to_one_item.pk, o2o.pk) |
| 170 |
self.assertEqual(i.one_to_one_item.name, "second") |
| 171 |
with self.assertNumQueries(1): |
| 172 |
i = Item.objects.select_related("one_to_one_item").defer( |
| 173 |
"value", "one_to_one_item__name" |
| 174 |
)[0] |
| 175 |
self.assertEqual(i.one_to_one_item.pk, o2o.pk) |
| 176 |
self.assertEqual(i.name, "first") |
| 177 |
with self.assertNumQueries(1): |
| 178 |
self.assertEqual(i.one_to_one_item.name, "second") |
| 179 |
with self.assertNumQueries(1): |
| 180 |
self.assertEqual(i.value, 42) |
| 181 |
with self.assertNumQueries(1): |
| 182 |
i = Item.objects.select_related("one_to_one_item").only( |
| 183 |
"name", "one_to_one_item__item" |
| 184 |
)[0] |
| 185 |
self.assertEqual(i.one_to_one_item.pk, o2o.pk) |
| 186 |
self.assertEqual(i.name, "first") |
| 187 |
with self.assertNumQueries(1): |
| 188 |
self.assertEqual(i.one_to_one_item.name, "second") |
| 189 |
with self.assertNumQueries(1): |
| 190 |
self.assertEqual(i.value, 42) |
| 191 |
|
| 192 |
def test_defer_with_select_related(self): |
| 193 |
item1 = Item.objects.create(name="first", value=47) |
| 194 |
item2 = Item.objects.create(name="second", value=42) |
| 195 |
simple = SimpleItem.objects.create(name="simple", value="23") |
| 196 |
ItemAndSimpleItem.objects.create(item=item1, simple=simple) |
| 197 |
|
| 198 |
obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get() |
| 199 |
self.assertEqual(obj.item, item1) |
| 200 |
self.assertEqual(obj.item_id, item1.id) |
| 201 |
|
| 202 |
obj.item = item2 |
| 203 |
obj.save() |
| 204 |
|
| 205 |
obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get() |
| 206 |
self.assertEqual(obj.item, item2) |
| 207 |
self.assertEqual(obj.item_id, item2.id) |
| 208 |
|
| 209 |
def test_proxy_model_defer_with_select_related(self): |
| 210 |
# Regression for #22050 |
| 211 |
item = Item.objects.create(name="first", value=47) |
| 212 |
RelatedItem.objects.create(item=item) |
| 213 |
# Defer fields with only() |
| 214 |
obj = ProxyRelated.objects.select_related().only("item__name")[0] |
| 215 |
with self.assertNumQueries(0): |
| 216 |
self.assertEqual(obj.item.name, "first") |
| 217 |
with self.assertNumQueries(1): |
| 218 |
self.assertEqual(obj.item.value, 47) |
| 219 |
|
| 220 |
def test_only_with_select_related(self): |
| 221 |
# Test for #17485. |
| 222 |
item = SimpleItem.objects.create(name="first", value=47) |
| 223 |
feature = Feature.objects.create(item=item) |
| 224 |
SpecialFeature.objects.create(feature=feature) |
| 225 |
|
| 226 |
qs = Feature.objects.only("item__name").select_related("item") |
| 227 |
self.assertEqual(len(qs), 1) |
| 228 |
|
| 229 |
qs = SpecialFeature.objects.only("feature__item__name").select_related( |
| 230 |
"feature__item" |
| 231 |
) |
| 232 |
self.assertEqual(len(qs), 1) |
| 233 |
|
| 234 |
def test_defer_annotate_select_related(self): |
| 235 |
location = Location.objects.create() |
| 236 |
Request.objects.create(location=location) |
| 237 |
self.assertIsInstance( |
| 238 |
list( |
| 239 |
Request.objects.annotate(Count("items")) |
| 240 |
.select_related("profile", "location") |
| 241 |
.only("profile", "location") |
| 242 |
), |
| 243 |
list, |
| 244 |
) |
| 245 |
self.assertIsInstance( |
| 246 |
list( |
| 247 |
Request.objects.annotate(Count("items")) |
| 248 |
.select_related("profile", "location") |
| 249 |
.only("profile__profile1", "location__location1") |
| 250 |
), |
| 251 |
list, |
| 252 |
) |
| 253 |
self.assertIsInstance( |
| 254 |
list( |
| 255 |
Request.objects.annotate(Count("items")) |
| 256 |
.select_related("profile", "location") |
| 257 |
.defer("request1", "request2", "request3", "request4") |
| 258 |
), |
| 259 |
list, |
| 260 |
) |
| 261 |
|
| 262 |
def test_common_model_different_mask(self): |
| 263 |
child = Child.objects.create(name="Child", value=42) |
| 264 |
second_child = Child.objects.create(name="Second", value=64) |
| 265 |
Leaf.objects.create(child=child, second_child=second_child) |
| 266 |
with self.assertNumQueries(1): |
| 267 |
leaf = ( |
| 268 |
Leaf.objects.select_related("child", "second_child") |
| 269 |
.defer("child__name", "second_child__value") |
| 270 |
.get() |
| 271 |
) |
| 272 |
self.assertEqual(leaf.child, child) |
| 273 |
self.assertEqual(leaf.second_child, second_child) |
| 274 |
self.assertEqual(leaf.child.get_deferred_fields(), {"name"}) |
| 275 |
self.assertEqual(leaf.second_child.get_deferred_fields(), {"value"}) |
| 276 |
with self.assertNumQueries(0): |
| 277 |
self.assertEqual(leaf.child.value, 42) |
| 278 |
self.assertEqual(leaf.second_child.name, "Second") |
| 279 |
with self.assertNumQueries(1): |
| 280 |
self.assertEqual(leaf.child.name, "Child") |
| 281 |
with self.assertNumQueries(1): |
| 282 |
self.assertEqual(leaf.second_child.value, 64) |
| 283 |
|
| 284 |
def test_defer_many_to_many_ignored(self): |
| 285 |
location = Location.objects.create() |
| 286 |
request = Request.objects.create(location=location) |
| 287 |
with self.assertNumQueries(1): |
| 288 |
self.assertEqual(Request.objects.defer("items").get(), request) |
| 289 |
|
| 290 |
def test_only_many_to_many_ignored(self): |
| 291 |
location = Location.objects.create() |
| 292 |
request = Request.objects.create(location=location) |
| 293 |
with self.assertNumQueries(1): |
| 294 |
self.assertEqual(Request.objects.only("items").get(), request) |
| 295 |
|
| 296 |
def test_defer_reverse_many_to_many_ignored(self): |
| 297 |
location = Location.objects.create() |
| 298 |
request = Request.objects.create(location=location) |
| 299 |
item = Item.objects.create(value=1) |
| 300 |
request.items.add(item) |
| 301 |
with self.assertNumQueries(1): |
| 302 |
self.assertEqual(Item.objects.defer("request").get(), item) |
| 303 |
|
| 304 |
def test_only_reverse_many_to_many_ignored(self): |
| 305 |
location = Location.objects.create() |
| 306 |
request = Request.objects.create(location=location) |
| 307 |
item = Item.objects.create(value=1) |
| 308 |
request.items.add(item) |
| 309 |
with self.assertNumQueries(1): |
| 310 |
self.assertEqual(Item.objects.only("request").get(), item) |
| 311 |
|
| 312 |
def test_self_referential_one_to_one(self): |
| 313 |
first = Item.objects.create(name="first", value=1) |
| 314 |
second = Item.objects.create(name="second", value=2, source=first) |
| 315 |
with self.assertNumQueries(1): |
| 316 |
deferred_first, deferred_second = ( |
| 317 |
Item.objects.select_related("source", "destination") |
| 318 |
.only("name", "source__name", "destination__value") |
| 319 |
.order_by("pk") |
| 320 |
) |
| 321 |
with self.assertNumQueries(0): |
| 322 |
self.assertEqual(deferred_first.name, first.name) |
| 323 |
self.assertEqual(deferred_second.name, second.name) |
| 324 |
self.assertEqual(deferred_second.source.name, first.name) |
| 325 |
self.assertEqual(deferred_first.destination.value, second.value) |
| 326 |
with self.assertNumQueries(1): |
| 327 |
self.assertEqual(deferred_first.value, first.value) |
| 328 |
with self.assertNumQueries(1): |
| 329 |
self.assertEqual(deferred_second.source.value, first.value) |
| 330 |
with self.assertNumQueries(1): |
| 331 |
self.assertEqual(deferred_first.destination.name, second.name) |
| 332 |
|
| 333 |
|
| 334 |
class DeferDeletionSignalsTests(TestCase): |
| 335 |
senders = [Item, Proxy] |
| 336 |
|
| 337 |
@classmethod |
| 338 |
def setUpTestData(cls): |
| 339 |
cls.item_pk = Item.objects.create(value=1).pk |
| 340 |
|
| 341 |
def setUp(self): |
| 342 |
self.pre_delete_senders = [] |
| 343 |
self.post_delete_senders = [] |
| 344 |
for sender in self.senders: |
| 345 |
models.signals.pre_delete.connect(self.pre_delete_receiver, sender) |
| 346 |
self.addCleanup( |
| 347 |
models.signals.pre_delete.disconnect, self.pre_delete_receiver, sender |
| 348 |
) |
| 349 |
models.signals.post_delete.connect(self.post_delete_receiver, sender) |
| 350 |
self.addCleanup( |
| 351 |
models.signals.post_delete.disconnect, self.post_delete_receiver, sender |
| 352 |
) |
| 353 |
|
| 354 |
def pre_delete_receiver(self, sender, **kwargs): |
| 355 |
self.pre_delete_senders.append(sender) |
| 356 |
|
| 357 |
def post_delete_receiver(self, sender, **kwargs): |
| 358 |
self.post_delete_senders.append(sender) |
| 359 |
|
| 360 |
def test_delete_defered_model(self): |
| 361 |
Item.objects.only("value").get(pk=self.item_pk).delete() |
| 362 |
self.assertEqual(self.pre_delete_senders, [Item]) |
| 363 |
self.assertEqual(self.post_delete_senders, [Item]) |
| 364 |
|
| 365 |
def test_delete_defered_proxy_model(self): |
| 366 |
Proxy.objects.only("value").get(pk=self.item_pk).delete() |
| 367 |
self.assertEqual(self.pre_delete_senders, [Proxy]) |
| 368 |
self.assertEqual(self.post_delete_senders, [Proxy]) |