| 1 |
import functools |
| 2 |
import itertools |
| 3 |
import warnings |
| 4 |
from collections import defaultdict |
| 5 |
|
| 6 |
from asgiref.sync import sync_to_async |
| 7 |
|
| 8 |
from django.contrib.contenttypes.models import ContentType |
| 9 |
from django.core import checks |
| 10 |
from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist |
| 11 |
from django.db import DEFAULT_DB_ALIAS, models, router, transaction |
| 12 |
from django.db.models import DO_NOTHING, ForeignObject, ForeignObjectRel |
| 13 |
from django.db.models.base import ModelBase, make_foreign_order_accessors |
| 14 |
from django.db.models.fields import Field |
| 15 |
from django.db.models.fields.mixins import FieldCacheMixin |
| 16 |
from django.db.models.fields.related import ( |
| 17 |
ReverseManyToOneDescriptor, |
| 18 |
lazy_related_operation, |
| 19 |
) |
| 20 |
from django.db.models.query_utils import PathInfo |
| 21 |
from django.db.models.sql import AND |
| 22 |
from django.db.models.sql.where import WhereNode |
| 23 |
from django.db.models.utils import AltersData |
| 24 |
from django.utils.deprecation import RemovedInDjango60Warning |
| 25 |
from django.utils.functional import cached_property |
| 26 |
|
| 27 |
|
| 28 |
class GenericForeignKey(FieldCacheMixin, Field): |
| 29 |
""" |
| 30 |
Provide a generic many-to-one relation through the ``content_type`` and |
| 31 |
``object_id`` fields. |
| 32 |
|
| 33 |
This class also doubles as an accessor to the related object (similar to |
| 34 |
ForwardManyToOneDescriptor) by adding itself as a model attribute. |
| 35 |
""" |
| 36 |
|
| 37 |
many_to_many = False |
| 38 |
many_to_one = True |
| 39 |
one_to_many = False |
| 40 |
one_to_one = False |
| 41 |
|
| 42 |
def __init__( |
| 43 |
self, ct_field="content_type", fk_field="object_id", for_concrete_model=True |
| 44 |
): |
| 45 |
super().__init__(editable=False) |
| 46 |
self.ct_field = ct_field |
| 47 |
self.fk_field = fk_field |
| 48 |
self.for_concrete_model = for_concrete_model |
| 49 |
self.is_relation = True |
| 50 |
|
| 51 |
def contribute_to_class(self, cls, name, **kwargs): |
| 52 |
super().contribute_to_class(cls, name, private_only=True, **kwargs) |
| 53 |
# GenericForeignKey is its own descriptor. |
| 54 |
setattr(cls, self.attname, self) |
| 55 |
|
| 56 |
def get_attname_column(self): |
| 57 |
attname, column = super().get_attname_column() |
| 58 |
return attname, None |
| 59 |
|
| 60 |
def get_filter_kwargs_for_object(self, obj): |
| 61 |
"""See corresponding method on Field""" |
| 62 |
return { |
| 63 |
self.fk_field: getattr(obj, self.fk_field), |
| 64 |
self.ct_field: getattr(obj, self.ct_field), |
| 65 |
} |
| 66 |
|
| 67 |
def get_forward_related_filter(self, obj): |
| 68 |
"""See corresponding method on RelatedField""" |
| 69 |
return { |
| 70 |
self.fk_field: obj.pk, |
| 71 |
self.ct_field: ContentType.objects.get_for_model(obj).pk, |
| 72 |
} |
| 73 |
|
| 74 |
def check(self, **kwargs): |
| 75 |
return [ |
| 76 |
*self._check_field_name(), |
| 77 |
*self._check_object_id_field(), |
| 78 |
*self._check_content_type_field(), |
| 79 |
] |
| 80 |
|
| 81 |
def _check_object_id_field(self): |
| 82 |
try: |
| 83 |
self.model._meta.get_field(self.fk_field) |
| 84 |
except FieldDoesNotExist: |
| 85 |
return [ |
| 86 |
checks.Error( |
| 87 |
"The GenericForeignKey object ID references the " |
| 88 |
"nonexistent field '%s'." % self.fk_field, |
| 89 |
obj=self, |
| 90 |
id="contenttypes.E001", |
| 91 |
) |
| 92 |
] |
| 93 |
else: |
| 94 |
return [] |
| 95 |
|
| 96 |
def _check_content_type_field(self): |
| 97 |
""" |
| 98 |
Check if field named `field_name` in model `model` exists and is a |
| 99 |
valid content_type field (is a ForeignKey to ContentType). |
| 100 |
""" |
| 101 |
try: |
| 102 |
field = self.model._meta.get_field(self.ct_field) |
| 103 |
except FieldDoesNotExist: |
| 104 |
return [ |
| 105 |
checks.Error( |
| 106 |
"The GenericForeignKey content type references the " |
| 107 |
"nonexistent field '%s.%s'." |
| 108 |
% (self.model._meta.object_name, self.ct_field), |
| 109 |
obj=self, |
| 110 |
id="contenttypes.E002", |
| 111 |
) |
| 112 |
] |
| 113 |
else: |
| 114 |
if not isinstance(field, models.ForeignKey): |
| 115 |
return [ |
| 116 |
checks.Error( |
| 117 |
"'%s.%s' is not a ForeignKey." |
| 118 |
% (self.model._meta.object_name, self.ct_field), |
| 119 |
hint=( |
| 120 |
"GenericForeignKeys must use a ForeignKey to " |
| 121 |
"'contenttypes.ContentType' as the 'content_type' field." |
| 122 |
), |
| 123 |
obj=self, |
| 124 |
id="contenttypes.E003", |
| 125 |
) |
| 126 |
] |
| 127 |
elif field.remote_field.model != ContentType: |
| 128 |
return [ |
| 129 |
checks.Error( |
| 130 |
"'%s.%s' is not a ForeignKey to 'contenttypes.ContentType'." |
| 131 |
% (self.model._meta.object_name, self.ct_field), |
| 132 |
hint=( |
| 133 |
"GenericForeignKeys must use a ForeignKey to " |
| 134 |
"'contenttypes.ContentType' as the 'content_type' field." |
| 135 |
), |
| 136 |
obj=self, |
| 137 |
id="contenttypes.E004", |
| 138 |
) |
| 139 |
] |
| 140 |
else: |
| 141 |
return [] |
| 142 |
|
| 143 |
@cached_property |
| 144 |
def cache_name(self): |
| 145 |
return self.name |
| 146 |
|
| 147 |
def get_content_type(self, obj=None, id=None, using=None, model=None): |
| 148 |
if obj is not None: |
| 149 |
return ContentType.objects.db_manager(obj._state.db).get_for_model( |
| 150 |
obj, for_concrete_model=self.for_concrete_model |
| 151 |
) |
| 152 |
elif id is not None: |
| 153 |
return ContentType.objects.db_manager(using).get_for_id(id) |
| 154 |
elif model is not None: |
| 155 |
return ContentType.objects.db_manager(using).get_for_model( |
| 156 |
model, for_concrete_model=self.for_concrete_model |
| 157 |
) |
| 158 |
else: |
| 159 |
# This should never happen. I love comments like this, don't you? |
| 160 |
raise Exception("Impossible arguments to GFK.get_content_type!") |
| 161 |
|
| 162 |
def get_prefetch_queryset(self, instances, queryset=None): |
| 163 |
warnings.warn( |
| 164 |
"get_prefetch_queryset() is deprecated. Use get_prefetch_querysets() " |
| 165 |
"instead.", |
| 166 |
RemovedInDjango60Warning, |
| 167 |
stacklevel=2, |
| 168 |
) |
| 169 |
if queryset is None: |
| 170 |
return self.get_prefetch_querysets(instances) |
| 171 |
return self.get_prefetch_querysets(instances, [queryset]) |
| 172 |
|
| 173 |
def get_prefetch_querysets(self, instances, querysets=None): |
| 174 |
custom_queryset_dict = {} |
| 175 |
if querysets is not None: |
| 176 |
for queryset in querysets: |
| 177 |
ct_id = self.get_content_type( |
| 178 |
model=queryset.query.model, using=queryset.db |
| 179 |
).pk |
| 180 |
if ct_id in custom_queryset_dict: |
| 181 |
raise ValueError( |
| 182 |
"Only one queryset is allowed for each content type." |
| 183 |
) |
| 184 |
custom_queryset_dict[ct_id] = queryset |
| 185 |
|
| 186 |
# For efficiency, group the instances by content type and then do one |
| 187 |
# query per model |
| 188 |
fk_dict = defaultdict(set) |
| 189 |
# We need one instance for each group in order to get the right db: |
| 190 |
instance_dict = {} |
| 191 |
ct_attname = self.model._meta.get_field(self.ct_field).attname |
| 192 |
for instance in instances: |
| 193 |
# We avoid looking for values if either ct_id or fkey value is None |
| 194 |
ct_id = getattr(instance, ct_attname) |
| 195 |
if ct_id is not None: |
| 196 |
fk_val = getattr(instance, self.fk_field) |
| 197 |
if fk_val is not None: |
| 198 |
fk_dict[ct_id].add(fk_val) |
| 199 |
instance_dict[ct_id] = instance |
| 200 |
|
| 201 |
ret_val = [] |
| 202 |
for ct_id, fkeys in fk_dict.items(): |
| 203 |
if ct_id in custom_queryset_dict: |
| 204 |
# Return values from the custom queryset, if provided. |
| 205 |
ret_val.extend(custom_queryset_dict[ct_id].filter(pk__in=fkeys)) |
| 206 |
else: |
| 207 |
instance = instance_dict[ct_id] |
| 208 |
ct = self.get_content_type(id=ct_id, using=instance._state.db) |
| 209 |
ret_val.extend(ct.get_all_objects_for_this_type(pk__in=fkeys)) |
| 210 |
|
| 211 |
# For doing the join in Python, we have to match both the FK val and the |
| 212 |
# content type, so we use a callable that returns a (fk, class) pair. |
| 213 |
def gfk_key(obj): |
| 214 |
ct_id = getattr(obj, ct_attname) |
| 215 |
if ct_id is None: |
| 216 |
return None |
| 217 |
else: |
| 218 |
model = self.get_content_type( |
| 219 |
id=ct_id, using=obj._state.db |
| 220 |
).model_class() |
| 221 |
return ( |
| 222 |
model._meta.pk.get_prep_value(getattr(obj, self.fk_field)), |
| 223 |
model, |
| 224 |
) |
| 225 |
|
| 226 |
return ( |
| 227 |
ret_val, |
| 228 |
lambda obj: (obj.pk, obj.__class__), |
| 229 |
gfk_key, |
| 230 |
True, |
| 231 |
self.name, |
| 232 |
False, |
| 233 |
) |
| 234 |
|
| 235 |
def __get__(self, instance, cls=None): |
| 236 |
if instance is None: |
| 237 |
return self |
| 238 |
|
| 239 |
# Don't use getattr(instance, self.ct_field) here because that might |
| 240 |
# reload the same ContentType over and over (#5570). Instead, get the |
| 241 |
# content type ID here, and later when the actual instance is needed, |
| 242 |
# use ContentType.objects.get_for_id(), which has a global cache. |
| 243 |
f = self.model._meta.get_field(self.ct_field) |
| 244 |
ct_id = getattr(instance, f.attname, None) |
| 245 |
pk_val = getattr(instance, self.fk_field) |
| 246 |
|
| 247 |
rel_obj = self.get_cached_value(instance, default=None) |
| 248 |
if rel_obj is None and self.is_cached(instance): |
| 249 |
return rel_obj |
| 250 |
if rel_obj is not None: |
| 251 |
ct_match = ( |
| 252 |
ct_id == self.get_content_type(obj=rel_obj, using=instance._state.db).id |
| 253 |
) |
| 254 |
pk_match = ct_match and rel_obj._meta.pk.to_python(pk_val) == rel_obj.pk |
| 255 |
if pk_match: |
| 256 |
return rel_obj |
| 257 |
else: |
| 258 |
rel_obj = None |
| 259 |
if ct_id is not None: |
| 260 |
ct = self.get_content_type(id=ct_id, using=instance._state.db) |
| 261 |
try: |
| 262 |
rel_obj = ct.get_object_for_this_type( |
| 263 |
using=instance._state.db, pk=pk_val |
| 264 |
) |
| 265 |
except ObjectDoesNotExist: |
| 266 |
pass |
| 267 |
self.set_cached_value(instance, rel_obj) |
| 268 |
return rel_obj |
| 269 |
|
| 270 |
def __set__(self, instance, value): |
| 271 |
ct = None |
| 272 |
fk = None |
| 273 |
if value is not None: |
| 274 |
ct = self.get_content_type(obj=value) |
| 275 |
fk = value.pk |
| 276 |
|
| 277 |
setattr(instance, self.ct_field, ct) |
| 278 |
setattr(instance, self.fk_field, fk) |
| 279 |
self.set_cached_value(instance, value) |
| 280 |
|
| 281 |
|
| 282 |
class GenericRel(ForeignObjectRel): |
| 283 |
""" |
| 284 |
Used by GenericRelation to store information about the relation. |
| 285 |
""" |
| 286 |
|
| 287 |
def __init__( |
| 288 |
self, |
| 289 |
field, |
| 290 |
to, |
| 291 |
related_name=None, |
| 292 |
related_query_name=None, |
| 293 |
limit_choices_to=None, |
| 294 |
): |
| 295 |
super().__init__( |
| 296 |
field, |
| 297 |
to, |
| 298 |
related_name=related_query_name or "+", |
| 299 |
related_query_name=related_query_name, |
| 300 |
limit_choices_to=limit_choices_to, |
| 301 |
on_delete=DO_NOTHING, |
| 302 |
) |
| 303 |
|
| 304 |
|
| 305 |
class GenericRelation(ForeignObject): |
| 306 |
""" |
| 307 |
Provide a reverse to a relation created by a GenericForeignKey. |
| 308 |
""" |
| 309 |
|
| 310 |
# Field flags |
| 311 |
auto_created = False |
| 312 |
empty_strings_allowed = False |
| 313 |
|
| 314 |
many_to_many = False |
| 315 |
many_to_one = False |
| 316 |
one_to_many = True |
| 317 |
one_to_one = False |
| 318 |
|
| 319 |
rel_class = GenericRel |
| 320 |
|
| 321 |
mti_inherited = False |
| 322 |
|
| 323 |
def __init__( |
| 324 |
self, |
| 325 |
to, |
| 326 |
object_id_field="object_id", |
| 327 |
content_type_field="content_type", |
| 328 |
for_concrete_model=True, |
| 329 |
related_query_name=None, |
| 330 |
limit_choices_to=None, |
| 331 |
**kwargs, |
| 332 |
): |
| 333 |
kwargs["rel"] = self.rel_class( |
| 334 |
self, |
| 335 |
to, |
| 336 |
related_query_name=related_query_name, |
| 337 |
limit_choices_to=limit_choices_to, |
| 338 |
) |
| 339 |
|
| 340 |
# Reverse relations are always nullable (Django can't enforce that a |
| 341 |
# foreign key on the related model points to this model). |
| 342 |
kwargs["null"] = True |
| 343 |
kwargs["blank"] = True |
| 344 |
kwargs["on_delete"] = models.CASCADE |
| 345 |
kwargs["editable"] = False |
| 346 |
kwargs["serialize"] = False |
| 347 |
|
| 348 |
# This construct is somewhat of an abuse of ForeignObject. This field |
| 349 |
# represents a relation from pk to object_id field. But, this relation |
| 350 |
# isn't direct, the join is generated reverse along foreign key. So, |
| 351 |
# the from_field is object_id field, to_field is pk because of the |
| 352 |
# reverse join. |
| 353 |
super().__init__(to, from_fields=[object_id_field], to_fields=[], **kwargs) |
| 354 |
|
| 355 |
self.object_id_field_name = object_id_field |
| 356 |
self.content_type_field_name = content_type_field |
| 357 |
self.for_concrete_model = for_concrete_model |
| 358 |
|
| 359 |
def check(self, **kwargs): |
| 360 |
return [ |
| 361 |
*super().check(**kwargs), |
| 362 |
*self._check_generic_foreign_key_existence(), |
| 363 |
] |
| 364 |
|
| 365 |
def _is_matching_generic_foreign_key(self, field): |
| 366 |
""" |
| 367 |
Return True if field is a GenericForeignKey whose content type and |
| 368 |
object id fields correspond to the equivalent attributes on this |
| 369 |
GenericRelation. |
| 370 |
""" |
| 371 |
return ( |
| 372 |
isinstance(field, GenericForeignKey) |
| 373 |
and field.ct_field == self.content_type_field_name |
| 374 |
and field.fk_field == self.object_id_field_name |
| 375 |
) |
| 376 |
|
| 377 |
def _check_generic_foreign_key_existence(self): |
| 378 |
target = self.remote_field.model |
| 379 |
if isinstance(target, ModelBase): |
| 380 |
fields = target._meta.private_fields |
| 381 |
if any(self._is_matching_generic_foreign_key(field) for field in fields): |
| 382 |
return [] |
| 383 |
else: |
| 384 |
return [ |
| 385 |
checks.Error( |
| 386 |
"The GenericRelation defines a relation with the model " |
| 387 |
"'%s', but that model does not have a GenericForeignKey." |
| 388 |
% target._meta.label, |
| 389 |
obj=self, |
| 390 |
id="contenttypes.E004", |
| 391 |
) |
| 392 |
] |
| 393 |
else: |
| 394 |
return [] |
| 395 |
|
| 396 |
def resolve_related_fields(self): |
| 397 |
self.to_fields = [self.model._meta.pk.name] |
| 398 |
return [ |
| 399 |
( |
| 400 |
self.remote_field.model._meta.get_field(self.object_id_field_name), |
| 401 |
self.model._meta.pk, |
| 402 |
) |
| 403 |
] |
| 404 |
|
| 405 |
def get_local_related_value(self, instance): |
| 406 |
return self.get_instance_value_for_fields(instance, self.foreign_related_fields) |
| 407 |
|
| 408 |
def get_foreign_related_value(self, instance): |
| 409 |
# We (possibly) need to convert object IDs to the type of the |
| 410 |
# instances' PK in order to match up instances during prefetching. |
| 411 |
return tuple( |
| 412 |
foreign_field.to_python(val) |
| 413 |
for foreign_field, val in zip( |
| 414 |
self.foreign_related_fields, |
| 415 |
self.get_instance_value_for_fields(instance, self.local_related_fields), |
| 416 |
) |
| 417 |
) |
| 418 |
|
| 419 |
def _get_path_info_with_parent(self, filtered_relation): |
| 420 |
""" |
| 421 |
Return the path that joins the current model through any parent models. |
| 422 |
The idea is that if you have a GFK defined on a parent model then we |
| 423 |
need to join the parent model first, then the child model. |
| 424 |
""" |
| 425 |
# With an inheritance chain ChildTag -> Tag and Tag defines the |
| 426 |
# GenericForeignKey, and a TaggedItem model has a GenericRelation to |
| 427 |
# ChildTag, then we need to generate a join from TaggedItem to Tag |
| 428 |
# (as Tag.object_id == TaggedItem.pk), and another join from Tag to |
| 429 |
# ChildTag (as that is where the relation is to). Do this by first |
| 430 |
# generating a join to the parent model, then generating joins to the |
| 431 |
# child models. |
| 432 |
path = [] |
| 433 |
opts = self.remote_field.model._meta.concrete_model._meta |
| 434 |
parent_opts = opts.get_field(self.object_id_field_name).model._meta |
| 435 |
target = parent_opts.pk |
| 436 |
path.append( |
| 437 |
PathInfo( |
| 438 |
from_opts=self.model._meta, |
| 439 |
to_opts=parent_opts, |
| 440 |
target_fields=(target,), |
| 441 |
join_field=self.remote_field, |
| 442 |
m2m=True, |
| 443 |
direct=False, |
| 444 |
filtered_relation=filtered_relation, |
| 445 |
) |
| 446 |
) |
| 447 |
# Collect joins needed for the parent -> child chain. This is easiest |
| 448 |
# to do if we collect joins for the child -> parent chain and then |
| 449 |
# reverse the direction (call to reverse() and use of |
| 450 |
# field.remote_field.get_path_info()). |
| 451 |
parent_field_chain = [] |
| 452 |
while parent_opts != opts: |
| 453 |
field = opts.get_ancestor_link(parent_opts.model) |
| 454 |
parent_field_chain.append(field) |
| 455 |
opts = field.remote_field.model._meta |
| 456 |
parent_field_chain.reverse() |
| 457 |
for field in parent_field_chain: |
| 458 |
path.extend(field.remote_field.path_infos) |
| 459 |
return path |
| 460 |
|
| 461 |
def get_path_info(self, filtered_relation=None): |
| 462 |
opts = self.remote_field.model._meta |
| 463 |
object_id_field = opts.get_field(self.object_id_field_name) |
| 464 |
if object_id_field.model != opts.model: |
| 465 |
return self._get_path_info_with_parent(filtered_relation) |
| 466 |
else: |
| 467 |
target = opts.pk |
| 468 |
return [ |
| 469 |
PathInfo( |
| 470 |
from_opts=self.model._meta, |
| 471 |
to_opts=opts, |
| 472 |
target_fields=(target,), |
| 473 |
join_field=self.remote_field, |
| 474 |
m2m=True, |
| 475 |
direct=False, |
| 476 |
filtered_relation=filtered_relation, |
| 477 |
) |
| 478 |
] |
| 479 |
|
| 480 |
def get_reverse_path_info(self, filtered_relation=None): |
| 481 |
opts = self.model._meta |
| 482 |
from_opts = self.remote_field.model._meta |
| 483 |
return [ |
| 484 |
PathInfo( |
| 485 |
from_opts=from_opts, |
| 486 |
to_opts=opts, |
| 487 |
target_fields=(opts.pk,), |
| 488 |
join_field=self, |
| 489 |
m2m=False, |
| 490 |
direct=False, |
| 491 |
filtered_relation=filtered_relation, |
| 492 |
) |
| 493 |
] |
| 494 |
|
| 495 |
def value_to_string(self, obj): |
| 496 |
qs = getattr(obj, self.name).all() |
| 497 |
return str([instance.pk for instance in qs]) |
| 498 |
|
| 499 |
def contribute_to_class(self, cls, name, **kwargs): |
| 500 |
kwargs["private_only"] = True |
| 501 |
super().contribute_to_class(cls, name, **kwargs) |
| 502 |
self.model = cls |
| 503 |
# Disable the reverse relation for fields inherited by subclasses of a |
| 504 |
# model in multi-table inheritance. The reverse relation points to the |
| 505 |
# field of the base model. |
| 506 |
if self.mti_inherited: |
| 507 |
self.remote_field.related_name = "+" |
| 508 |
self.remote_field.related_query_name = None |
| 509 |
setattr(cls, self.name, ReverseGenericManyToOneDescriptor(self.remote_field)) |
| 510 |
|
| 511 |
# Add get_RELATED_order() and set_RELATED_order() to the model this |
| 512 |
# field belongs to, if the model on the other end of this relation |
| 513 |
# is ordered with respect to its corresponding GenericForeignKey. |
| 514 |
if not cls._meta.abstract: |
| 515 |
|
| 516 |
def make_generic_foreign_order_accessors(related_model, model): |
| 517 |
if self._is_matching_generic_foreign_key( |
| 518 |
model._meta.order_with_respect_to |
| 519 |
): |
| 520 |
make_foreign_order_accessors(model, related_model) |
| 521 |
|
| 522 |
lazy_related_operation( |
| 523 |
make_generic_foreign_order_accessors, |
| 524 |
self.model, |
| 525 |
self.remote_field.model, |
| 526 |
) |
| 527 |
|
| 528 |
def set_attributes_from_rel(self): |
| 529 |
pass |
| 530 |
|
| 531 |
def get_internal_type(self): |
| 532 |
return "ManyToManyField" |
| 533 |
|
| 534 |
def get_content_type(self): |
| 535 |
""" |
| 536 |
Return the content type associated with this field's model. |
| 537 |
""" |
| 538 |
return ContentType.objects.get_for_model( |
| 539 |
self.model, for_concrete_model=self.for_concrete_model |
| 540 |
) |
| 541 |
|
| 542 |
def get_extra_restriction(self, alias, remote_alias): |
| 543 |
field = self.remote_field.model._meta.get_field(self.content_type_field_name) |
| 544 |
contenttype_pk = self.get_content_type().pk |
| 545 |
lookup = field.get_lookup("exact")(field.get_col(remote_alias), contenttype_pk) |
| 546 |
return WhereNode([lookup], connector=AND) |
| 547 |
|
| 548 |
def bulk_related_objects(self, objs, using=DEFAULT_DB_ALIAS): |
| 549 |
""" |
| 550 |
Return all objects related to ``objs`` via this ``GenericRelation``. |
| 551 |
""" |
| 552 |
return self.remote_field.model._base_manager.db_manager(using).filter( |
| 553 |
**{ |
| 554 |
"%s__pk" |
| 555 |
% self.content_type_field_name: ContentType.objects.db_manager(using) |
| 556 |
.get_for_model(self.model, for_concrete_model=self.for_concrete_model) |
| 557 |
.pk, |
| 558 |
"%s__in" % self.object_id_field_name: [obj.pk for obj in objs], |
| 559 |
} |
| 560 |
) |
| 561 |
|
| 562 |
|
| 563 |
class ReverseGenericManyToOneDescriptor(ReverseManyToOneDescriptor): |
| 564 |
""" |
| 565 |
Accessor to the related objects manager on the one-to-many relation created |
| 566 |
by GenericRelation. |
| 567 |
|
| 568 |
In the example:: |
| 569 |
|
| 570 |
class Post(Model): |
| 571 |
comments = GenericRelation(Comment) |
| 572 |
|
| 573 |
``post.comments`` is a ReverseGenericManyToOneDescriptor instance. |
| 574 |
""" |
| 575 |
|
| 576 |
@cached_property |
| 577 |
def related_manager_cls(self): |
| 578 |
return create_generic_related_manager( |
| 579 |
self.rel.model._default_manager.__class__, |
| 580 |
self.rel, |
| 581 |
) |
| 582 |
|
| 583 |
|
| 584 |
def create_generic_related_manager(superclass, rel): |
| 585 |
""" |
| 586 |
Factory function to create a manager that subclasses another manager |
| 587 |
(generally the default manager of a given model) and adds behaviors |
| 588 |
specific to generic relations. |
| 589 |
""" |
| 590 |
|
| 591 |
class GenericRelatedObjectManager(superclass, AltersData): |
| 592 |
def __init__(self, instance=None): |
| 593 |
super().__init__() |
| 594 |
|
| 595 |
self.instance = instance |
| 596 |
|
| 597 |
self.model = rel.model |
| 598 |
self.get_content_type = functools.partial( |
| 599 |
ContentType.objects.db_manager(instance._state.db).get_for_model, |
| 600 |
for_concrete_model=rel.field.for_concrete_model, |
| 601 |
) |
| 602 |
self.content_type = self.get_content_type(instance) |
| 603 |
self.content_type_field_name = rel.field.content_type_field_name |
| 604 |
self.object_id_field_name = rel.field.object_id_field_name |
| 605 |
self.prefetch_cache_name = rel.field.attname |
| 606 |
self.pk_val = instance.pk |
| 607 |
|
| 608 |
self.core_filters = { |
| 609 |
"%s__pk" % self.content_type_field_name: self.content_type.id, |
| 610 |
self.object_id_field_name: self.pk_val, |
| 611 |
} |
| 612 |
|
| 613 |
def __call__(self, *, manager): |
| 614 |
manager = getattr(self.model, manager) |
| 615 |
manager_class = create_generic_related_manager(manager.__class__, rel) |
| 616 |
return manager_class(instance=self.instance) |
| 617 |
|
| 618 |
do_not_call_in_templates = True |
| 619 |
|
| 620 |
def __str__(self): |
| 621 |
return repr(self) |
| 622 |
|
| 623 |
def _apply_rel_filters(self, queryset): |
| 624 |
""" |
| 625 |
Filter the queryset for the instance this manager is bound to. |
| 626 |
""" |
| 627 |
db = self._db or router.db_for_read(self.model, instance=self.instance) |
| 628 |
return queryset.using(db).filter(**self.core_filters) |
| 629 |
|
| 630 |
def _remove_prefetched_objects(self): |
| 631 |
try: |
| 632 |
self.instance._prefetched_objects_cache.pop(self.prefetch_cache_name) |
| 633 |
except (AttributeError, KeyError): |
| 634 |
pass # nothing to clear from cache |
| 635 |
|
| 636 |
def get_queryset(self): |
| 637 |
try: |
| 638 |
return self.instance._prefetched_objects_cache[self.prefetch_cache_name] |
| 639 |
except (AttributeError, KeyError): |
| 640 |
queryset = super().get_queryset() |
| 641 |
return self._apply_rel_filters(queryset) |
| 642 |
|
| 643 |
def get_prefetch_queryset(self, instances, queryset=None): |
| 644 |
warnings.warn( |
| 645 |
"get_prefetch_queryset() is deprecated. Use get_prefetch_querysets() " |
| 646 |
"instead.", |
| 647 |
RemovedInDjango60Warning, |
| 648 |
stacklevel=2, |
| 649 |
) |
| 650 |
if queryset is None: |
| 651 |
return self.get_prefetch_querysets(instances) |
| 652 |
return self.get_prefetch_querysets(instances, [queryset]) |
| 653 |
|
| 654 |
def get_prefetch_querysets(self, instances, querysets=None): |
| 655 |
if querysets and len(querysets) != 1: |
| 656 |
raise ValueError( |
| 657 |
"querysets argument of get_prefetch_querysets() should have a " |
| 658 |
"length of 1." |
| 659 |
) |
| 660 |
queryset = querysets[0] if querysets else super().get_queryset() |
| 661 |
queryset._add_hints(instance=instances[0]) |
| 662 |
queryset = queryset.using(queryset._db or self._db) |
| 663 |
# Group instances by content types. |
| 664 |
content_type_queries = [ |
| 665 |
models.Q.create( |
| 666 |
[ |
| 667 |
(f"{self.content_type_field_name}__pk", content_type_id), |
| 668 |
(f"{self.object_id_field_name}__in", {obj.pk for obj in objs}), |
| 669 |
] |
| 670 |
) |
| 671 |
for content_type_id, objs in itertools.groupby( |
| 672 |
sorted(instances, key=lambda obj: self.get_content_type(obj).pk), |
| 673 |
lambda obj: self.get_content_type(obj).pk, |
| 674 |
) |
| 675 |
] |
| 676 |
query = models.Q.create(content_type_queries, connector=models.Q.OR) |
| 677 |
# We (possibly) need to convert object IDs to the type of the |
| 678 |
# instances' PK in order to match up instances: |
| 679 |
object_id_converter = instances[0]._meta.pk.to_python |
| 680 |
content_type_id_field_name = "%s_id" % self.content_type_field_name |
| 681 |
return ( |
| 682 |
queryset.filter(query), |
| 683 |
lambda relobj: ( |
| 684 |
object_id_converter(getattr(relobj, self.object_id_field_name)), |
| 685 |
getattr(relobj, content_type_id_field_name), |
| 686 |
), |
| 687 |
lambda obj: (obj.pk, self.get_content_type(obj).pk), |
| 688 |
False, |
| 689 |
self.prefetch_cache_name, |
| 690 |
False, |
| 691 |
) |
| 692 |
|
| 693 |
def add(self, *objs, bulk=True): |
| 694 |
self._remove_prefetched_objects() |
| 695 |
db = router.db_for_write(self.model, instance=self.instance) |
| 696 |
|
| 697 |
def check_and_update_obj(obj): |
| 698 |
if not isinstance(obj, self.model): |
| 699 |
raise TypeError( |
| 700 |
"'%s' instance expected, got %r" |
| 701 |
% (self.model._meta.object_name, obj) |
| 702 |
) |
| 703 |
setattr(obj, self.content_type_field_name, self.content_type) |
| 704 |
setattr(obj, self.object_id_field_name, self.pk_val) |
| 705 |
|
| 706 |
if bulk: |
| 707 |
pks = [] |
| 708 |
for obj in objs: |
| 709 |
if obj._state.adding or obj._state.db != db: |
| 710 |
raise ValueError( |
| 711 |
"%r instance isn't saved. Use bulk=False or save " |
| 712 |
"the object first." % obj |
| 713 |
) |
| 714 |
check_and_update_obj(obj) |
| 715 |
pks.append(obj.pk) |
| 716 |
|
| 717 |
self.model._base_manager.using(db).filter(pk__in=pks).update( |
| 718 |
**{ |
| 719 |
self.content_type_field_name: self.content_type, |
| 720 |
self.object_id_field_name: self.pk_val, |
| 721 |
} |
| 722 |
) |
| 723 |
else: |
| 724 |
with transaction.atomic(using=db, savepoint=False): |
| 725 |
for obj in objs: |
| 726 |
check_and_update_obj(obj) |
| 727 |
obj.save() |
| 728 |
|
| 729 |
add.alters_data = True |
| 730 |
|
| 731 |
async def aadd(self, *objs, bulk=True): |
| 732 |
return await sync_to_async(self.add)(*objs, bulk=bulk) |
| 733 |
|
| 734 |
aadd.alters_data = True |
| 735 |
|
| 736 |
def remove(self, *objs, bulk=True): |
| 737 |
if not objs: |
| 738 |
return |
| 739 |
self._clear(self.filter(pk__in=[o.pk for o in objs]), bulk) |
| 740 |
|
| 741 |
remove.alters_data = True |
| 742 |
|
| 743 |
async def aremove(self, *objs, bulk=True): |
| 744 |
return await sync_to_async(self.remove)(*objs, bulk=bulk) |
| 745 |
|
| 746 |
aremove.alters_data = True |
| 747 |
|
| 748 |
def clear(self, *, bulk=True): |
| 749 |
self._clear(self, bulk) |
| 750 |
|
| 751 |
clear.alters_data = True |
| 752 |
|
| 753 |
async def aclear(self, *, bulk=True): |
| 754 |
return await sync_to_async(self.clear)(bulk=bulk) |
| 755 |
|
| 756 |
aclear.alters_data = True |
| 757 |
|
| 758 |
def _clear(self, queryset, bulk): |
| 759 |
self._remove_prefetched_objects() |
| 760 |
db = router.db_for_write(self.model, instance=self.instance) |
| 761 |
queryset = queryset.using(db) |
| 762 |
if bulk: |
| 763 |
# `QuerySet.delete()` creates its own atomic block which |
| 764 |
# contains the `pre_delete` and `post_delete` signal handlers. |
| 765 |
queryset.delete() |
| 766 |
else: |
| 767 |
with transaction.atomic(using=db, savepoint=False): |
| 768 |
for obj in queryset: |
| 769 |
obj.delete() |
| 770 |
|
| 771 |
_clear.alters_data = True |
| 772 |
|
| 773 |
def set(self, objs, *, bulk=True, clear=False): |
| 774 |
# Force evaluation of `objs` in case it's a queryset whose value |
| 775 |
# could be affected by `manager.clear()`. Refs #19816. |
| 776 |
objs = tuple(objs) |
| 777 |
|
| 778 |
db = router.db_for_write(self.model, instance=self.instance) |
| 779 |
with transaction.atomic(using=db, savepoint=False): |
| 780 |
if clear: |
| 781 |
self.clear() |
| 782 |
self.add(*objs, bulk=bulk) |
| 783 |
else: |
| 784 |
old_objs = set(self.using(db).all()) |
| 785 |
new_objs = [] |
| 786 |
for obj in objs: |
| 787 |
if obj in old_objs: |
| 788 |
old_objs.remove(obj) |
| 789 |
else: |
| 790 |
new_objs.append(obj) |
| 791 |
|
| 792 |
self.remove(*old_objs) |
| 793 |
self.add(*new_objs, bulk=bulk) |
| 794 |
|
| 795 |
set.alters_data = True |
| 796 |
|
| 797 |
async def aset(self, objs, *, bulk=True, clear=False): |
| 798 |
return await sync_to_async(self.set)(objs, bulk=bulk, clear=clear) |
| 799 |
|
| 800 |
aset.alters_data = True |
| 801 |
|
| 802 |
def create(self, **kwargs): |
| 803 |
self._remove_prefetched_objects() |
| 804 |
kwargs[self.content_type_field_name] = self.content_type |
| 805 |
kwargs[self.object_id_field_name] = self.pk_val |
| 806 |
db = router.db_for_write(self.model, instance=self.instance) |
| 807 |
return super().using(db).create(**kwargs) |
| 808 |
|
| 809 |
create.alters_data = True |
| 810 |
|
| 811 |
async def acreate(self, **kwargs): |
| 812 |
return await sync_to_async(self.create)(**kwargs) |
| 813 |
|
| 814 |
acreate.alters_data = True |
| 815 |
|
| 816 |
def get_or_create(self, **kwargs): |
| 817 |
kwargs[self.content_type_field_name] = self.content_type |
| 818 |
kwargs[self.object_id_field_name] = self.pk_val |
| 819 |
db = router.db_for_write(self.model, instance=self.instance) |
| 820 |
return super().using(db).get_or_create(**kwargs) |
| 821 |
|
| 822 |
get_or_create.alters_data = True |
| 823 |
|
| 824 |
async def aget_or_create(self, **kwargs): |
| 825 |
return await sync_to_async(self.get_or_create)(**kwargs) |
| 826 |
|
| 827 |
aget_or_create.alters_data = True |
| 828 |
|
| 829 |
def update_or_create(self, **kwargs): |
| 830 |
kwargs[self.content_type_field_name] = self.content_type |
| 831 |
kwargs[self.object_id_field_name] = self.pk_val |
| 832 |
db = router.db_for_write(self.model, instance=self.instance) |
| 833 |
return super().using(db).update_or_create(**kwargs) |
| 834 |
|
| 835 |
update_or_create.alters_data = True |
| 836 |
|
| 837 |
async def aupdate_or_create(self, **kwargs): |
| 838 |
return await sync_to_async(self.update_or_create)(**kwargs) |
| 839 |
|
| 840 |
aupdate_or_create.alters_data = True |
| 841 |
|
| 842 |
return GenericRelatedObjectManager |