Debian Codegraph @

django/contrib/contenttypes/fields.py

raw
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