Debian Codegraph @

tests/queries/models.py

raw
1 """
2 Various complex queries that have been problematic in the past.
3 """
4
5 import datetime
6
7 from django.db import models
8 from django.db.models.functions import Now
9
10
11 class DumbCategory(models.Model):
12 pass
13
14
15 class ProxyCategory(DumbCategory):
16 class Meta:
17 proxy = True
18
19
20 class NamedCategory(DumbCategory):
21 name = models.CharField(max_length=10)
22
23 def __str__(self):
24 return self.name
25
26
27 class Tag(models.Model):
28 name = models.CharField(max_length=10)
29 parent = models.ForeignKey(
30 "self",
31 models.SET_NULL,
32 blank=True,
33 null=True,
34 related_name="children",
35 )
36 category = models.ForeignKey(
37 NamedCategory, models.SET_NULL, null=True, default=None
38 )
39
40 class Meta:
41 ordering = ["name"]
42
43 def __str__(self):
44 return self.name
45
46
47 class Note(models.Model):
48 note = models.CharField(max_length=100)
49 misc = models.CharField(max_length=25)
50 tag = models.ForeignKey(Tag, models.SET_NULL, blank=True, null=True)
51 negate = models.BooleanField(default=True)
52
53 class Meta:
54 ordering = ["note"]
55
56 def __str__(self):
57 return self.note
58
59
60 class Annotation(models.Model):
61 name = models.CharField(max_length=10)
62 tag = models.ForeignKey(Tag, models.CASCADE)
63 notes = models.ManyToManyField(Note)
64
65 def __str__(self):
66 return self.name
67
68
69 class DateTimePK(models.Model):
70 date = models.DateTimeField(primary_key=True, default=datetime.datetime.now)
71
72 class Meta:
73 ordering = ["date"]
74
75
76 class ExtraInfo(models.Model):
77 info = models.CharField(max_length=100)
78 note = models.ForeignKey(Note, models.CASCADE, null=True)
79 value = models.IntegerField(null=True)
80 date = models.ForeignKey(DateTimePK, models.SET_NULL, null=True)
81 filterable = models.BooleanField(default=True)
82
83 class Meta:
84 ordering = ["info"]
85
86 def __str__(self):
87 return self.info
88
89
90 class Author(models.Model):
91 name = models.CharField(max_length=10)
92 num = models.IntegerField(unique=True)
93 extra = models.ForeignKey(ExtraInfo, models.CASCADE)
94
95 class Meta:
96 ordering = ["name"]
97
98 def __str__(self):
99 return self.name
100
101
102 class Item(models.Model):
103 name = models.CharField(max_length=10)
104 created = models.DateTimeField()
105 modified = models.DateTimeField(blank=True, null=True)
106 tags = models.ManyToManyField(Tag, blank=True)
107 creator = models.ForeignKey(Author, models.CASCADE)
108 note = models.ForeignKey(Note, models.CASCADE)
109
110 class Meta:
111 ordering = ["-note", "name"]
112
113 def __str__(self):
114 return self.name
115
116
117 class Report(models.Model):
118 name = models.CharField(max_length=10)
119 creator = models.ForeignKey(Author, models.SET_NULL, to_field="num", null=True)
120
121 def __str__(self):
122 return self.name
123
124
125 class ReportComment(models.Model):
126 report = models.ForeignKey(Report, models.CASCADE)
127
128
129 class Ranking(models.Model):
130 rank = models.IntegerField()
131 author = models.ForeignKey(Author, models.CASCADE)
132
133 class Meta:
134 # A complex ordering specification. Should stress the system a bit.
135 ordering = ("author__extra__note", "author__name", "rank")
136
137 def __str__(self):
138 return "%d: %s" % (self.rank, self.author.name)
139
140
141 class Cover(models.Model):
142 title = models.CharField(max_length=50)
143 item = models.ForeignKey(Item, models.CASCADE)
144
145 class Meta:
146 ordering = ["item"]
147
148 def __str__(self):
149 return self.title
150
151
152 class Number(models.Model):
153 num = models.IntegerField()
154 other_num = models.IntegerField(null=True)
155 another_num = models.IntegerField(null=True)
156
157 def __str__(self):
158 return str(self.num)
159
160
161 # Symmetrical m2m field with a normal field using the reverse accessor name
162 # ("valid").
163
164
165 class Valid(models.Model):
166 valid = models.CharField(max_length=10)
167 parent = models.ManyToManyField("self")
168
169 class Meta:
170 ordering = ["valid"]
171
172
173 # Some funky cross-linked models for testing a couple of infinite recursion
174 # cases.
175
176
177 class X(models.Model):
178 y = models.ForeignKey("Y", models.CASCADE)
179
180
181 class Y(models.Model):
182 x1 = models.ForeignKey(X, models.CASCADE, related_name="y1")
183
184
185 # Some models with a cycle in the default ordering. This would be bad if we
186 # didn't catch the infinite loop.
187
188
189 class LoopX(models.Model):
190 y = models.ForeignKey("LoopY", models.CASCADE)
191
192 class Meta:
193 ordering = ["y"]
194
195
196 class LoopY(models.Model):
197 x = models.ForeignKey(LoopX, models.CASCADE)
198
199 class Meta:
200 ordering = ["x"]
201
202
203 class LoopZ(models.Model):
204 z = models.ForeignKey("self", models.CASCADE)
205
206 class Meta:
207 ordering = ["z"]
208
209
210 # A model and custom default manager combination.
211
212
213 class CustomManager(models.Manager):
214 def get_queryset(self):
215 qs = super().get_queryset()
216 return qs.filter(public=True, tag__name="t1")
217
218
219 class ManagedModel(models.Model):
220 data = models.CharField(max_length=10)
221 tag = models.ForeignKey(Tag, models.CASCADE)
222 public = models.BooleanField(default=True)
223
224 objects = CustomManager()
225 normal_manager = models.Manager()
226
227 def __str__(self):
228 return self.data
229
230
231 # An inter-related setup with multiple paths from Child to Detail.
232
233
234 class Detail(models.Model):
235 data = models.CharField(max_length=10)
236
237
238 class MemberManager(models.Manager):
239 def get_queryset(self):
240 return super().get_queryset().select_related("details")
241
242
243 class Member(models.Model):
244 name = models.CharField(max_length=10)
245 details = models.OneToOneField(Detail, models.CASCADE, primary_key=True)
246
247 objects = MemberManager()
248
249
250 class Child(models.Model):
251 person = models.OneToOneField(Member, models.CASCADE, primary_key=True)
252 parent = models.ForeignKey(Member, models.CASCADE, related_name="children")
253
254
255 # Custom primary keys interfered with ordering in the past.
256
257
258 class CustomPk(models.Model):
259 name = models.CharField(max_length=10, primary_key=True)
260 extra = models.CharField(max_length=10)
261
262 class Meta:
263 ordering = ["name", "extra"]
264
265
266 class Related(models.Model):
267 custom = models.ForeignKey(CustomPk, models.CASCADE, null=True)
268
269
270 class CustomPkTag(models.Model):
271 id = models.CharField(max_length=20, primary_key=True)
272 custom_pk = models.ManyToManyField(CustomPk)
273 tag = models.CharField(max_length=20)
274
275
276 # An inter-related setup with a model subclass that has a nullable
277 # path to another model, and a return path from that model.
278
279
280 class Celebrity(models.Model):
281 name = models.CharField("Name", max_length=20)
282 greatest_fan = models.ForeignKey("Fan", models.SET_NULL, null=True, unique=True)
283
284 def __str__(self):
285 return self.name
286
287
288 class TvChef(Celebrity):
289 pass
290
291
292 class Fan(models.Model):
293 fan_of = models.ForeignKey(Celebrity, models.CASCADE)
294
295
296 # Multiple foreign keys
297
298
299 class LeafA(models.Model):
300 data = models.CharField(max_length=10)
301
302 def __str__(self):
303 return self.data
304
305
306 class LeafB(models.Model):
307 data = models.CharField(max_length=10)
308
309
310 class Join(models.Model):
311 a = models.ForeignKey(LeafA, models.CASCADE)
312 b = models.ForeignKey(LeafB, models.CASCADE)
313
314
315 class ReservedName(models.Model):
316 name = models.CharField(max_length=20)
317 order = models.IntegerField()
318
319 def __str__(self):
320 return self.name
321
322
323 # A simpler shared-foreign-key setup that can expose some problems.
324
325
326 class SharedConnection(models.Model):
327 data = models.CharField(max_length=10)
328
329 def __str__(self):
330 return self.data
331
332
333 class PointerA(models.Model):
334 connection = models.ForeignKey(SharedConnection, models.CASCADE)
335
336
337 class PointerB(models.Model):
338 connection = models.ForeignKey(SharedConnection, models.CASCADE)
339
340
341 # Multi-layer ordering
342
343
344 class SingleObject(models.Model):
345 name = models.CharField(max_length=10)
346
347 class Meta:
348 ordering = ["name"]
349
350 def __str__(self):
351 return self.name
352
353
354 class RelatedObject(models.Model):
355 single = models.ForeignKey(SingleObject, models.SET_NULL, null=True)
356 f = models.IntegerField(null=True)
357
358 class Meta:
359 ordering = ["single"]
360
361
362 class Plaything(models.Model):
363 name = models.CharField(max_length=10)
364 others = models.ForeignKey(RelatedObject, models.SET_NULL, null=True)
365
366 class Meta:
367 ordering = ["others"]
368
369 def __str__(self):
370 return self.name
371
372
373 class Article(models.Model):
374 name = models.CharField(max_length=20)
375 created = models.DateTimeField()
376
377 def __str__(self):
378 return self.name
379
380
381 class Food(models.Model):
382 name = models.CharField(max_length=20, unique=True)
383
384 def __str__(self):
385 return self.name
386
387
388 class Eaten(models.Model):
389 food = models.ForeignKey(Food, models.SET_NULL, to_field="name", null=True)
390 meal = models.CharField(max_length=20)
391
392 def __str__(self):
393 return "%s at %s" % (self.food, self.meal)
394
395
396 class Node(models.Model):
397 num = models.IntegerField(unique=True)
398 parent = models.ForeignKey("self", models.SET_NULL, to_field="num", null=True)
399
400 def __str__(self):
401 return str(self.num)
402
403
404 # Bug #12252
405
406
407 class ObjectA(models.Model):
408 name = models.CharField(max_length=50)
409
410 def __str__(self):
411 return self.name
412
413 def __iter__(self):
414 # Ticket #23721
415 assert False, "type checking should happen without calling model __iter__"
416
417
418 class ProxyObjectA(ObjectA):
419 class Meta:
420 proxy = True
421
422
423 class ChildObjectA(ObjectA):
424 pass
425
426
427 class ObjectB(models.Model):
428 name = models.CharField(max_length=50)
429 objecta = models.ForeignKey(ObjectA, models.CASCADE)
430 num = models.PositiveIntegerField()
431
432 def __str__(self):
433 return self.name
434
435
436 class ProxyObjectB(ObjectB):
437 class Meta:
438 proxy = True
439
440
441 class ObjectC(models.Model):
442 name = models.CharField(max_length=50)
443 objecta = models.ForeignKey(ObjectA, models.SET_NULL, null=True)
444 objectb = models.ForeignKey(ObjectB, models.SET_NULL, null=True)
445 childobjecta = models.ForeignKey(
446 ChildObjectA, models.SET_NULL, null=True, related_name="ca_pk"
447 )
448
449 def __str__(self):
450 return self.name
451
452
453 class SimpleCategory(models.Model):
454 name = models.CharField(max_length=25)
455
456 def __str__(self):
457 return self.name
458
459
460 class SpecialCategory(SimpleCategory):
461 special_name = models.CharField(max_length=35)
462
463 def __str__(self):
464 return self.name + " " + self.special_name
465
466
467 class CategoryItem(models.Model):
468 category = models.ForeignKey(SimpleCategory, models.CASCADE)
469
470 def __str__(self):
471 return "category item: " + str(self.category)
472
473
474 class MixedCaseFieldCategoryItem(models.Model):
475 CaTeGoRy = models.ForeignKey(SimpleCategory, models.CASCADE)
476
477
478 class MixedCaseDbColumnCategoryItem(models.Model):
479 category = models.ForeignKey(
480 SimpleCategory, models.CASCADE, db_column="CaTeGoRy_Id"
481 )
482
483
484 class OneToOneCategory(models.Model):
485 new_name = models.CharField(max_length=15)
486 category = models.OneToOneField(SimpleCategory, models.CASCADE)
487
488 def __str__(self):
489 return "one2one " + self.new_name
490
491
492 class CategoryRelationship(models.Model):
493 first = models.ForeignKey(SimpleCategory, models.CASCADE, related_name="first_rel")
494 second = models.ForeignKey(
495 SimpleCategory, models.CASCADE, related_name="second_rel"
496 )
497
498
499 class CommonMixedCaseForeignKeys(models.Model):
500 category = models.ForeignKey(CategoryItem, models.CASCADE)
501 mixed_case_field_category = models.ForeignKey(
502 MixedCaseFieldCategoryItem, models.CASCADE
503 )
504 mixed_case_db_column_category = models.ForeignKey(
505 MixedCaseDbColumnCategoryItem, models.CASCADE
506 )
507
508
509 class NullableName(models.Model):
510 name = models.CharField(max_length=20, null=True)
511
512 class Meta:
513 ordering = ["id"]
514
515
516 class ModelD(models.Model):
517 name = models.TextField()
518
519
520 class ModelC(models.Model):
521 name = models.TextField()
522
523
524 class ModelB(models.Model):
525 name = models.TextField()
526 c = models.ForeignKey(ModelC, models.CASCADE)
527
528
529 class ModelA(models.Model):
530 name = models.TextField()
531 b = models.ForeignKey(ModelB, models.SET_NULL, null=True)
532 d = models.ForeignKey(ModelD, models.CASCADE)
533
534
535 class Job(models.Model):
536 name = models.CharField(max_length=20, unique=True)
537
538 def __str__(self):
539 return self.name
540
541
542 class JobResponsibilities(models.Model):
543 job = models.ForeignKey(Job, models.CASCADE, to_field="name")
544 responsibility = models.ForeignKey(
545 "Responsibility", models.CASCADE, to_field="description"
546 )
547
548
549 class Responsibility(models.Model):
550 description = models.CharField(max_length=20, unique=True)
551 jobs = models.ManyToManyField(
552 Job, through=JobResponsibilities, related_name="responsibilities"
553 )
554
555 def __str__(self):
556 return self.description
557
558
559 # Models for disjunction join promotion low level testing.
560
561
562 class FK1(models.Model):
563 f1 = models.TextField()
564 f2 = models.TextField()
565
566
567 class FK2(models.Model):
568 f1 = models.TextField()
569 f2 = models.TextField()
570
571
572 class FK3(models.Model):
573 f1 = models.TextField()
574 f2 = models.TextField()
575
576
577 class BaseA(models.Model):
578 a = models.ForeignKey(FK1, models.SET_NULL, null=True)
579 b = models.ForeignKey(FK2, models.SET_NULL, null=True)
580 c = models.ForeignKey(FK3, models.SET_NULL, null=True)
581
582
583 class Identifier(models.Model):
584 name = models.CharField(max_length=100)
585
586 def __str__(self):
587 return self.name
588
589
590 class Program(models.Model):
591 identifier = models.OneToOneField(Identifier, models.CASCADE)
592
593
594 class Channel(models.Model):
595 programs = models.ManyToManyField(Program)
596 identifier = models.OneToOneField(Identifier, models.CASCADE)
597
598
599 class Book(models.Model):
600 title = models.TextField()
601 chapter = models.ForeignKey("Chapter", models.CASCADE)
602
603
604 class Chapter(models.Model):
605 title = models.TextField()
606 paragraph = models.ForeignKey("Paragraph", models.CASCADE)
607
608
609 class Paragraph(models.Model):
610 text = models.TextField()
611 page = models.ManyToManyField("Page")
612
613
614 class Page(models.Model):
615 text = models.TextField()
616
617
618 class MyObject(models.Model):
619 parent = models.ForeignKey(
620 "self", models.SET_NULL, null=True, blank=True, related_name="children"
621 )
622 data = models.CharField(max_length=100)
623 created_at = models.DateTimeField(auto_now_add=True)
624
625
626 # Models for #17600 regressions
627
628
629 class Order(models.Model):
630 id = models.IntegerField(primary_key=True)
631 name = models.CharField(max_length=12, null=True, default="")
632
633 class Meta:
634 ordering = ("pk",)
635
636 def __str__(self):
637 return str(self.pk)
638
639
640 class OrderItem(models.Model):
641 order = models.ForeignKey(Order, models.CASCADE, related_name="items")
642 status = models.IntegerField()
643
644 class Meta:
645 ordering = ("pk",)
646
647 def __str__(self):
648 return str(self.pk)
649
650
651 class BaseUser(models.Model):
652 annotation = models.ForeignKey(Annotation, models.CASCADE, null=True, blank=True)
653
654
655 class Task(models.Model):
656 title = models.CharField(max_length=10)
657 owner = models.ForeignKey(BaseUser, models.CASCADE, related_name="owner")
658 creator = models.ForeignKey(BaseUser, models.CASCADE, related_name="creator")
659 note = models.ForeignKey(Note, on_delete=models.CASCADE, null=True, blank=True)
660
661 def __str__(self):
662 return self.title
663
664
665 class Staff(models.Model):
666 name = models.CharField(max_length=10)
667
668 def __str__(self):
669 return self.name
670
671
672 class StaffUser(BaseUser):
673 staff = models.OneToOneField(Staff, models.CASCADE, related_name="user")
674
675 def __str__(self):
676 return str(self.staff)
677
678
679 class Ticket21203Parent(models.Model):
680 parentid = models.AutoField(primary_key=True)
681 parent_bool = models.BooleanField(default=True)
682 created = models.DateTimeField(auto_now=True)
683
684
685 class Ticket21203Child(models.Model):
686 childid = models.AutoField(primary_key=True)
687 parent = models.ForeignKey(Ticket21203Parent, models.CASCADE)
688
689
690 class Person(models.Model):
691 name = models.CharField(max_length=128)
692
693
694 class Company(models.Model):
695 name = models.CharField(max_length=128)
696 employees = models.ManyToManyField(
697 Person, related_name="employers", through="Employment"
698 )
699
700 def __str__(self):
701 return self.name
702
703
704 class Employment(models.Model):
705 employer = models.ForeignKey(Company, models.CASCADE)
706 employee = models.ForeignKey(Person, models.CASCADE)
707 title = models.CharField(max_length=128)
708
709
710 class School(models.Model):
711 pass
712
713
714 class Student(models.Model):
715 school = models.ForeignKey(School, models.CASCADE)
716
717
718 class Classroom(models.Model):
719 name = models.CharField(max_length=20)
720 has_blackboard = models.BooleanField(null=True)
721 school = models.ForeignKey(School, models.CASCADE)
722 students = models.ManyToManyField(Student, related_name="classroom")
723
724
725 class Teacher(models.Model):
726 schools = models.ManyToManyField(School)
727 friends = models.ManyToManyField("self")
728
729
730 class Ticket23605AParent(models.Model):
731 pass
732
733
734 class Ticket23605A(Ticket23605AParent):
735 pass
736
737
738 class Ticket23605B(models.Model):
739 modela_fk = models.ForeignKey(Ticket23605A, models.CASCADE)
740 modelc_fk = models.ForeignKey("Ticket23605C", models.CASCADE)
741 field_b0 = models.IntegerField(null=True)
742 field_b1 = models.BooleanField(default=False)
743
744
745 class Ticket23605C(models.Model):
746 field_c0 = models.FloatField()
747
748
749 # db_table names have capital letters to ensure they are quoted in queries.
750 class Individual(models.Model):
751 alive = models.BooleanField()
752
753 class Meta:
754 db_table = "Individual"
755
756
757 class RelatedIndividual(models.Model):
758 related = models.ForeignKey(
759 Individual, models.CASCADE, related_name="related_individual"
760 )
761
762 class Meta:
763 db_table = "RelatedIndividual"
764
765
766 class CustomDbColumn(models.Model):
767 custom_column = models.IntegerField(db_column="custom_name", null=True)
768 ip_address = models.GenericIPAddressField(null=True)
769
770
771 class CreatedField(models.DateTimeField):
772 db_returning = True
773
774 def __init__(self, *args, **kwargs):
775 kwargs.setdefault("default", Now)
776 super().__init__(*args, **kwargs)
777
778
779 class ReturningModel(models.Model):
780 created = CreatedField(editable=False)
781
782
783 class NonIntegerPKReturningModel(models.Model):
784 created = CreatedField(editable=False, primary_key=True)
785
786
787 class JSONFieldNullable(models.Model):
788 json_field = models.JSONField(blank=True, null=True)
789
790 class Meta:
791 required_db_features = {"supports_json_field"}