Debian Codegraph @

model_utils/managers.py

raw
1 from __future__ import annotations
2
3 import warnings
4 from typing import TYPE_CHECKING, Any, Generic, Sequence, TypeVar, cast, overload
5
6 from django.core.exceptions import ObjectDoesNotExist
7 from django.db import connection, models
8 from django.db.models.constants import LOOKUP_SEP
9 from django.db.models.fields.related import OneToOneField, OneToOneRel
10 from django.db.models.query import ModelIterable, QuerySet
11 from django.db.models.sql.datastructures import Join
12
13 ModelT = TypeVar('ModelT', bound=models.Model, covariant=True)
14
15 if TYPE_CHECKING:
16 from collections.abc import Iterator
17
18 from django.db.models.query import BaseIterable
19
20
21 def _iter_inheritance_queryset(queryset: QuerySet[ModelT]) -> Iterator[ModelT]:
22 iter: ModelIterable[ModelT] = ModelIterable(queryset)
23 if hasattr(queryset, 'subclasses'):
24 assert hasattr(queryset, '_get_sub_obj_recurse')
25 extras = tuple(queryset.query.extra.keys())
26 # sort the subclass names longest first,
27 # so with 'a' and 'a__b' it goes as deep as possible
28 subclasses = sorted(queryset.subclasses, key=len, reverse=True)
29 for obj in iter:
30 sub_obj = None
31 for s in subclasses:
32 sub_obj = queryset._get_sub_obj_recurse(obj, s)
33 if sub_obj:
34 break
35 if not sub_obj:
36 sub_obj = obj
37
38 if hasattr(queryset, '_annotated'):
39 for k in queryset._annotated:
40 setattr(sub_obj, k, getattr(obj, k))
41
42 for k in extras:
43 setattr(sub_obj, k, getattr(obj, k))
44
45 yield sub_obj
46 else:
47 yield from iter
48
49
50 if TYPE_CHECKING:
51 class InheritanceIterable(ModelIterable[ModelT]):
52 queryset: QuerySet[ModelT]
53
54 def __init__(self, queryset: QuerySet[ModelT], *args: Any, **kwargs: Any):
55 ...
56
57 def __iter__(self) -> Iterator[ModelT]:
58 ...
59
60 else:
61 class InheritanceIterable(ModelIterable):
62 def __iter__(self):
63 return _iter_inheritance_queryset(self.queryset)
64
65
66 class InheritanceQuerySetMixin(Generic[ModelT]):
67
68 model: type[ModelT]
69 subclasses: Sequence[str]
70
71 def __init__(self, *args: object, **kwargs: object):
72 super().__init__(*args, **kwargs)
73 self._iterable_class: type[BaseIterable[ModelT]] = InheritanceIterable
74
75 def select_subclasses(self, *subclasses: str | type[models.Model]) -> InheritanceQuerySet[ModelT]:
76 model: type[ModelT] = self.model
77 calculated_subclasses = self._get_subclasses_recurse(model)
78 # if none were passed in, we can just short circuit and select all
79 if not subclasses:
80 selected_subclasses = calculated_subclasses
81 else:
82 verified_subclasses: list[str] = []
83 for subclass in subclasses:
84 # special case for passing in the same model as the queryset
85 # is bound against. Rather than raise an error later, we know
86 # we can allow this through.
87 if subclass is model:
88 continue
89
90 if not isinstance(subclass, str):
91 subclass = self._get_ancestors_path(subclass)
92
93 if subclass in calculated_subclasses:
94 verified_subclasses.append(subclass)
95 else:
96 raise ValueError(
97 '{!r} is not in the discovered subclasses, tried: {}'.format(
98 subclass, ', '.join(calculated_subclasses))
99 )
100 selected_subclasses = verified_subclasses
101
102 new_qs = cast('InheritanceQuerySet[ModelT]', self)
103 if selected_subclasses:
104 new_qs = new_qs.select_related(*selected_subclasses)
105 new_qs.subclasses = selected_subclasses
106 return new_qs
107
108 def _chain(self, **kwargs: object) -> InheritanceQuerySet[ModelT]:
109 update = {}
110 for name in ['subclasses', '_annotated']:
111 if hasattr(self, name):
112 update[name] = getattr(self, name)
113
114 # django-stubs doesn't include this private API.
115 chained = super()._chain(**kwargs) # type: ignore[misc]
116 chained.__dict__.update(update)
117 return chained
118
119 def _clone(self) -> InheritanceQuerySet[ModelT]:
120 # django-stubs doesn't include this private API.
121 qs = super()._clone() # type: ignore[misc]
122 for name in ['subclasses', '_annotated']:
123 if hasattr(self, name):
124 setattr(qs, name, getattr(self, name))
125 return qs
126
127 def annotate(self, *args: Any, **kwargs: Any) -> InheritanceQuerySet[ModelT]:
128 qset = cast(QuerySet[ModelT], super()).annotate(*args, **kwargs)
129 qset._annotated = [a.default_alias for a in args] + list(kwargs.keys())
130 return qset
131
132 def _get_subclasses_recurse(self, model: type[models.Model]) -> list[str]:
133 """
134 Given a Model class, find all related objects, exploring children
135 recursively, returning a `list` of strings representing the
136 relations for select_related
137 """
138 related_objects = [
139 f for f in model._meta.get_fields()
140 if isinstance(f, OneToOneRel)]
141
142 rels = [
143 rel for rel in related_objects
144 if isinstance(rel.field, OneToOneField)
145 and issubclass(rel.field.model, model)
146 and model is not rel.field.model
147 and rel.parent_link
148 ]
149
150 subclasses = []
151
152 for rel in rels:
153 for subclass in self._get_subclasses_recurse(rel.field.model):
154 subclasses.append(rel.get_accessor_name() + LOOKUP_SEP + subclass)
155 subclasses.append(rel.get_accessor_name())
156 return subclasses
157
158 def _get_ancestors_path(self, model: type[models.Model]) -> str:
159 """
160 Serves as an opposite to _get_subclasses_recurse, instead walking from
161 the Model class up the Model's ancestry and constructing the desired
162 select_related string backwards.
163 """
164 if not issubclass(model, self.model):
165 raise ValueError(
166 f"{model!r} is not a subclass of {self.model!r}")
167
168 ancestry: list[str] = []
169 # should be a OneToOneField or None
170 parent_link = model._meta.get_ancestor_link(self.model)
171
172 while parent_link is not None:
173 related = parent_link.remote_field
174 ancestry.insert(0, related.get_accessor_name())
175
176 parent_model = related.model
177 parent_link = parent_model._meta.get_ancestor_link(self.model)
178
179 return LOOKUP_SEP.join(ancestry)
180
181 def _get_sub_obj_recurse(self, obj: models.Model, s: str) -> ModelT | None:
182 rel, _, s = s.partition(LOOKUP_SEP)
183
184 try:
185 node = getattr(obj, rel)
186 except ObjectDoesNotExist:
187 return None
188 if s:
189 child = self._get_sub_obj_recurse(node, s)
190 return child
191 else:
192 return node
193
194 def get_subclass(self, *args: object, **kwargs: object) -> ModelT:
195 return self.select_subclasses().get(*args, **kwargs)
196
197
198 # Defining the 'model' attribute using a generic type triggers a bug in mypy:
199 # https://github.com/python/mypy/issues/9031
200 class InheritanceQuerySet(InheritanceQuerySetMixin[ModelT], QuerySet[ModelT]): # type: ignore[misc]
201 def instance_of(self, *models: type[ModelT]) -> InheritanceQuerySet[ModelT]:
202 """
203 Fetch only objects that are instances of the provided model(s).
204 """
205 # If we aren't already selecting the subclasses, we need
206 # to in order to get this to work.
207
208 # How can we tell if we are not selecting subclasses?
209
210 # Is it safe to just apply .select_subclasses(*models)?
211
212 # Due to https://code.djangoproject.com/ticket/16572, we
213 # can't really do this for anything other than children (ie,
214 # no grandchildren+).
215 where_queries = []
216 for model in models:
217 where_queries.append('(' + ' AND '.join([
218 '"{}"."{}" IS NOT NULL'.format(
219 model._meta.db_table,
220 field.column,
221 ) for field in model._meta.parents.values()
222 ]) + ')')
223
224 return cast(
225 'InheritanceQuerySet[ModelT]',
226 self.select_subclasses(*models).extra(where=[' OR '.join(where_queries)])
227 )
228
229
230 class InheritanceManagerMixin(Generic[ModelT]):
231 _queryset_class = InheritanceQuerySet
232
233 if TYPE_CHECKING:
234 from collections.abc import Sequence
235
236 def none(self) -> InheritanceQuerySet[ModelT]:
237 ...
238
239 def all(self) -> InheritanceQuerySet[ModelT]:
240 ...
241
242 def filter(self, *args: Any, **kwargs: Any) -> InheritanceQuerySet[ModelT]:
243 ...
244
245 def exclude(self, *args: Any, **kwargs: Any) -> InheritanceQuerySet[ModelT]:
246 ...
247
248 def complex_filter(self, filter_obj: Any) -> InheritanceQuerySet[ModelT]:
249 ...
250
251 def union(self, *other_qs: Any, all: bool = ...) -> InheritanceQuerySet[ModelT]:
252 ...
253
254 def intersection(self, *other_qs: Any) -> InheritanceQuerySet[ModelT]:
255 ...
256
257 def difference(self, *other_qs: Any) -> InheritanceQuerySet[ModelT]:
258 ...
259
260 def select_for_update(
261 self, nowait: bool = ..., skip_locked: bool = ..., of: Sequence[str] = ..., no_key: bool = ...
262 ) -> InheritanceQuerySet[ModelT]:
263 ...
264
265 def select_related(self, *fields: Any) -> InheritanceQuerySet[ModelT]:
266 ...
267
268 def prefetch_related(self, *lookups: Any) -> InheritanceQuerySet[ModelT]:
269 ...
270
271 def annotate(self, *args: Any, **kwargs: Any) -> InheritanceQuerySet[ModelT]:
272 ...
273
274 def alias(self, *args: Any, **kwargs: Any) -> InheritanceQuerySet[ModelT]:
275 ...
276
277 def order_by(self, *field_names: Any) -> InheritanceQuerySet[ModelT]:
278 ...
279
280 def distinct(self, *field_names: Any) -> InheritanceQuerySet[ModelT]:
281 ...
282
283 def extra(
284 self,
285 select: dict[str, Any] | None = ...,
286 where: list[str] | None = ...,
287 params: list[Any] | None = ...,
288 tables: list[str] | None = ...,
289 order_by: Sequence[str] | None = ...,
290 select_params: Sequence[Any] | None = ...,
291 ) -> InheritanceQuerySet[Any]:
292 ...
293
294 def reverse(self) -> InheritanceQuerySet[ModelT]:
295 ...
296
297 def defer(self, *fields: Any) -> InheritanceQuerySet[ModelT]:
298 ...
299
300 def only(self, *fields: Any) -> InheritanceQuerySet[ModelT]:
301 ...
302
303 def using(self, alias: str | None) -> InheritanceQuerySet[ModelT]:
304 ...
305
306 def get_queryset(self) -> InheritanceQuerySet[ModelT]:
307 model: type[ModelT] = self.model # type: ignore[attr-defined]
308 return self._queryset_class(model)
309
310 def select_subclasses(
311 self, *subclasses: str | type[models.Model]
312 ) -> InheritanceQuerySet[ModelT]:
313 return self.get_queryset().select_subclasses(*subclasses)
314
315 def get_subclass(self, *args: object, **kwargs: object) -> ModelT:
316 return self.get_queryset().get_subclass(*args, **kwargs)
317
318 def instance_of(self, *models: type[ModelT]) -> InheritanceQuerySet[ModelT]:
319 return self.get_queryset().instance_of(*models)
320
321
322 class InheritanceManager(InheritanceManagerMixin[ModelT], models.Manager[ModelT]):
323 pass
324
325
326 class QueryManagerMixin(Generic[ModelT]):
327
328 @overload
329 def __init__(self, *args: models.Q):
330 ...
331
332 @overload
333 def __init__(self, **kwargs: object):
334 ...
335
336 def __init__(self, *args: models.Q, **kwargs: object):
337 if args:
338 self._q = args[0]
339 else:
340 self._q = models.Q(**kwargs)
341 self._order_by: tuple[Any, ...] | None = None
342 super().__init__()
343
344 def order_by(self, *args: Any) -> QueryManager[ModelT]:
345 self._order_by = args
346 return cast('QueryManager[ModelT]', self)
347
348 def get_queryset(self) -> QuerySet[ModelT]:
349 qs = super().get_queryset() # type: ignore[misc]
350 qs = qs.filter(self._q)
351 if self._order_by is not None:
352 return qs.order_by(*self._order_by)
353 return qs
354
355
356 class QueryManager(QueryManagerMixin[ModelT], models.Manager[ModelT]): # type: ignore[misc]
357 pass
358
359
360 class SoftDeletableQuerySetMixin(Generic[ModelT]):
361 """
362 QuerySet for SoftDeletableModel. Instead of removing instance sets
363 its ``is_removed`` field to True.
364 """
365
366 def delete(self) -> tuple[int, dict[str, int]]:
367 """
368 Soft delete objects from queryset (set their ``is_removed``
369 field to True)
370 """
371 model: type[ModelT] = self.model # type: ignore[attr-defined]
372 number_of_deleted_objects = cast(QuerySet[ModelT], self).update(is_removed=True)
373 return number_of_deleted_objects, {model._meta.label: number_of_deleted_objects}
374
375
376 class SoftDeletableQuerySet(SoftDeletableQuerySetMixin[ModelT], QuerySet[ModelT]):
377 pass
378
379
380 class SoftDeletableManagerMixin(Generic[ModelT]):
381 """
382 Manager that limits the queryset by default to show only not removed
383 instances of model.
384 """
385 _queryset_class = SoftDeletableQuerySet
386
387 _db: str | None
388
389 def __init__(
390 self,
391 *args: object,
392 _emit_deprecation_warnings: bool = False,
393 **kwargs: object
394 ):
395 self.emit_deprecation_warnings = _emit_deprecation_warnings
396 super().__init__(*args, **kwargs)
397
398 def get_queryset(self) -> SoftDeletableQuerySet[ModelT]:
399 """
400 Return queryset limited to not removed entries.
401 """
402
403 model: type[ModelT] = self.model # type: ignore[attr-defined]
404
405 if self.emit_deprecation_warnings:
406 warning_message = (
407 "{0}.objects model manager will include soft-deleted objects in an "
408 "upcoming release; please use {0}.available_objects to continue "
409 "excluding soft-deleted objects. See "
410 "https://django-model-utils.readthedocs.io/en/stable/models.html"
411 "#softdeletablemodel for more information."
412 ).format(model.__class__.__name__)
413 warnings.warn(warning_message, DeprecationWarning)
414
415 return self._queryset_class(
416 model=model,
417 using=self._db,
418 **({'hints': self._hints} if hasattr(self, '_hints') else {})
419 ).filter(is_removed=False)
420
421
422 class SoftDeletableManager(SoftDeletableManagerMixin[ModelT], models.Manager[ModelT]):
423 pass
424
425
426 class JoinQueryset(models.QuerySet[Any]):
427
428 def join(self, qs: QuerySet[Any] | None = None) -> QuerySet[Any]:
429 '''
430 Join one queryset together with another using a temporary table. If
431 no queryset is used, it will use the current queryset and join that
432 to itself.
433
434 `Join` either uses the current queryset and effectively does a self-join to
435 create a new limited queryset OR it uses a queryset given by the user.
436
437 The model of a given queryset needs to contain a valid foreign key to
438 the current queryset to perform a join. A new queryset is then created.
439 '''
440 to_field = 'id'
441
442 if qs:
443 fks = [
444 fk for fk in qs.model._meta.fields
445 if getattr(fk, 'related_model', None) == self.model
446 ]
447 fk = fks[0] if fks else None
448 model_set = f'{self.model.__name__.lower()}_set'
449 key = fk or getattr(qs.model, model_set, None)
450
451 if not key:
452 raise ValueError('QuerySet is not related to current model')
453
454 try:
455 fk_column = key.column
456 except AttributeError:
457 fk_column = 'id'
458 to_field = key.field.column
459
460 qs = qs.only(fk_column)
461 # if we give a qs we need to keep the model qs to not lose anything
462 new_qs = self
463 else:
464 fk_column = 'id'
465 qs = self.only(fk_column)
466 new_qs = self.model._default_manager.all()
467
468 TABLE_NAME = 'temp_stuff'
469 query, params = qs.query.sql_with_params()
470 sql = '''
471 DROP TABLE IF EXISTS {table_name};
472 DROP INDEX IF EXISTS {table_name}_id;
473 CREATE TEMPORARY TABLE {table_name} AS {query};
474 CREATE INDEX {table_name}_{fk_column} ON {table_name} ({fk_column});
475 '''.format(table_name=TABLE_NAME, fk_column=fk_column, query=str(query))
476
477 with connection.cursor() as cursor:
478 cursor.execute(sql, params)
479
480 class TempModel(models.Model):
481 temp_key = models.ForeignKey(
482 self.model,
483 on_delete=models.DO_NOTHING,
484 db_column=fk_column,
485 to_field=to_field
486 )
487
488 class Meta:
489 managed = False
490 db_table = TABLE_NAME
491
492 conn = Join(
493 table_name=TempModel._meta.db_table,
494 parent_alias=new_qs.query.get_initial_alias(),
495 table_alias=None,
496 join_type='INNER JOIN',
497 join_field=self.model.tempmodel_set.rel,
498 nullable=False
499 )
500 new_qs.query.join(conn, reuse=None)
501 return new_qs
502
503
504 if not TYPE_CHECKING:
505 # Hide deprecated API during type checking, to encourage switch to
506 # 'JoinQueryset.as_manager()', which is supported by the mypy plugin
507 # of django-stubs.
508
509 class JoinManagerMixin:
510 """
511 Manager that adds a method join. This method allows you to join two
512 querysets together.
513 """
514
515 def get_queryset(self):
516 warnings.warn(
517 "JoinManager and JoinManagerMixin are deprecated. "
518 "Please use 'JoinQueryset.as_manager()' instead.",
519 DeprecationWarning
520 )
521 return self._queryset_class(model=self.model, using=self._db)
522
523 class JoinManager(JoinManagerMixin):
524 pass