django/tests/queries/models.py

"""
Various complex queries that have been problematic in the past.
"""
import datetime

from django.db import models
from django.db.models.functions import Now


class DumbCategory(models.Model):
    pass


class ProxyCategory(DumbCategory):
    class Meta:
        proxy = True


class NamedCategory(DumbCategory):
    name = models.CharField(max_length=10)

    def __str__(self):
        return self.name


class Tag(models.Model):
    name = models.CharField(max_length=10)
    parent = models.ForeignKey(
        "self",
        models.SET_NULL,
        blank=True,
        null=True,
        related_name="children",
    )
    category = models.ForeignKey(
        NamedCategory, models.SET_NULL, null=True, default=None
    )

    class Meta:
        ordering = ["name"]

    def __str__(self):
        return self.name


class Note(models.Model):
    note = models.CharField(max_length=100)
    misc = models.CharField(max_length=25)
    tag = models.ForeignKey(Tag, models.SET_NULL, blank=True, null=True)
    negate = models.BooleanField(default=True)

    class Meta:
        ordering = ["note"]

    def __str__(self):
        return self.note


class Annotation(models.Model):
    name = models.CharField(max_length=10)
    tag = models.ForeignKey(Tag, models.CASCADE)
    notes = models.ManyToManyField(Note)

    def __str__(self):
        return self.name


class DateTimePK(models.Model):
    date = models.DateTimeField(primary_key=True, default=datetime.datetime.now)


class ExtraInfo(models.Model):
    info = models.CharField(max_length=100)
    note = models.ForeignKey(Note, models.CASCADE, null=True)
    value = models.IntegerField(null=True)
    date = models.ForeignKey(DateTimePK, models.SET_NULL, null=True)
    filterable = models.BooleanField(default=True)

    class Meta:
        ordering = ["info"]

    def __str__(self):
        return self.info


class Author(models.Model):
    name = models.CharField(max_length=10)
    num = models.IntegerField(unique=True)
    extra = models.ForeignKey(ExtraInfo, models.CASCADE)

    class Meta:
        ordering = ["name"]

    def __str__(self):
        return self.name


class Item(models.Model):
    name = models.CharField(max_length=10)
    created = models.DateTimeField()
    modified = models.DateTimeField(blank=True, null=True)
    tags = models.ManyToManyField(Tag, blank=True)
    creator = models.ForeignKey(Author, models.CASCADE)
    note = models.ForeignKey(Note, models.CASCADE)

    class Meta:
        ordering = ["-note", "name"]

    def __str__(self):
        return self.name


class Report(models.Model):
    name = models.CharField(max_length=10)
    creator = models.ForeignKey(Author, models.SET_NULL, to_field="num", null=True)

    def __str__(self):
        return self.name


class ReportComment(models.Model):
    report = models.ForeignKey(Report, models.CASCADE)


class Ranking(models.Model):
    rank = models.IntegerField()
    author = models.ForeignKey(Author, models.CASCADE)

    class Meta:
        # A complex ordering specification. Should stress the system a bit.
        ordering = ("author__extra__note", "author__name", "rank")

    def __str__(self):
        return "%d: %s" % (self.rank, self.author.name)


class Cover(models.Model):
    title = models.CharField(max_length=50)
    item = models.ForeignKey(Item, models.CASCADE)

    class Meta:
        ordering = ["item"]

    def __str__(self):
        return self.title


class Number(models.Model):
    num = models.IntegerField()
    other_num = models.IntegerField(null=True)
    another_num = models.IntegerField(null=True)

    def __str__(self):
        return str(self.num)


# Symmetrical m2m field with a normal field using the reverse accessor name
# ("valid").


class Valid(models.Model):
    valid = models.CharField(max_length=10)
    parent = models.ManyToManyField("self")

    class Meta:
        ordering = ["valid"]


# Some funky cross-linked models for testing a couple of infinite recursion
# cases.


class X(models.Model):
    y = models.ForeignKey("Y", models.CASCADE)


class Y(models.Model):
    x1 = models.ForeignKey(X, models.CASCADE, related_name="y1")


# Some models with a cycle in the default ordering. This would be bad if we
# didn't catch the infinite loop.


class LoopX(models.Model):
    y = models.ForeignKey("LoopY", models.CASCADE)

    class Meta:
        ordering = ["y"]


class LoopY(models.Model):
    x = models.ForeignKey(LoopX, models.CASCADE)

    class Meta:
        ordering = ["x"]


class LoopZ(models.Model):
    z = models.ForeignKey("self", models.CASCADE)

    class Meta:
        ordering = ["z"]


# A model and custom default manager combination.


class CustomManager(models.Manager):
    def get_queryset(self):
        qs = super().get_queryset()
        return qs.filter(public=True, tag__name="t1")


class ManagedModel(models.Model):
    data = models.CharField(max_length=10)
    tag = models.ForeignKey(Tag, models.CASCADE)
    public = models.BooleanField(default=True)

    objects = CustomManager()
    normal_manager = models.Manager()

    def __str__(self):
        return self.data


# An inter-related setup with multiple paths from Child to Detail.


class Detail(models.Model):
    data = models.CharField(max_length=10)


class MemberManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().select_related("details")


class Member(models.Model):
    name = models.CharField(max_length=10)
    details = models.OneToOneField(Detail, models.CASCADE, primary_key=True)

    objects = MemberManager()


class Child(models.Model):
    person = models.OneToOneField(Member, models.CASCADE, primary_key=True)
    parent = models.ForeignKey(Member, models.CASCADE, related_name="children")


# Custom primary keys interfered with ordering in the past.


class CustomPk(models.Model):
    name = models.CharField(max_length=10, primary_key=True)
    extra = models.CharField(max_length=10)

    class Meta:
        ordering = ["name", "extra"]


class Related(models.Model):
    custom = models.ForeignKey(CustomPk, models.CASCADE, null=True)


class CustomPkTag(models.Model):
    id = models.CharField(max_length=20, primary_key=True)
    custom_pk = models.ManyToManyField(CustomPk)
    tag = models.CharField(max_length=20)


# An inter-related setup with a model subclass that has a nullable
# path to another model, and a return path from that model.


class Celebrity(models.Model):
    name = models.CharField("Name", max_length=20)
    greatest_fan = models.ForeignKey("Fan", models.SET_NULL, null=True, unique=True)

    def __str__(self):
        return self.name


class TvChef(Celebrity):
    pass


class Fan(models.Model):
    fan_of = models.ForeignKey(Celebrity, models.CASCADE)


# Multiple foreign keys


class LeafA(models.Model):
    data = models.CharField(max_length=10)

    def __str__(self):
        return self.data


class LeafB(models.Model):
    data = models.CharField(max_length=10)


class Join(models.Model):
    a = models.ForeignKey(LeafA, models.CASCADE)
    b = models.ForeignKey(LeafB, models.CASCADE)


class ReservedName(models.Model):
    name = models.CharField(max_length=20)
    order = models.IntegerField()

    def __str__(self):
        return self.name


# A simpler shared-foreign-key setup that can expose some problems.


class SharedConnection(models.Model):
    data = models.CharField(max_length=10)

    def __str__(self):
        return self.data


class PointerA(models.Model):
    connection = models.ForeignKey(SharedConnection, models.CASCADE)


class PointerB(models.Model):
    connection = models.ForeignKey(SharedConnection, models.CASCADE)


# Multi-layer ordering


class SingleObject(models.Model):
    name = models.CharField(max_length=10)

    class Meta:
        ordering = ["name"]

    def __str__(self):
        return self.name


class RelatedObject(models.Model):
    single = models.ForeignKey(SingleObject, models.SET_NULL, null=True)
    f = models.IntegerField(null=True)

    class Meta:
        ordering = ["single"]


class Plaything(models.Model):
    name = models.CharField(max_length=10)
    others = models.ForeignKey(RelatedObject, models.SET_NULL, null=True)

    class Meta:
        ordering = ["others"]

    def __str__(self):
        return self.name


class Article(models.Model):
    name = models.CharField(max_length=20)
    created = models.DateTimeField()

    def __str__(self):
        return self.name


class Food(models.Model):
    name = models.CharField(max_length=20, unique=True)

    def __str__(self):
        return self.name


class Eaten(models.Model):
    food = models.ForeignKey(Food, models.SET_NULL, to_field="name", null=True)
    meal = models.CharField(max_length=20)

    def __str__(self):
        return "%s at %s" % (self.food, self.meal)


class Node(models.Model):
    num = models.IntegerField(unique=True)
    parent = models.ForeignKey("self", models.SET_NULL, to_field="num", null=True)

    def __str__(self):
        return str(self.num)


# Bug #12252


class ObjectA(models.Model):
    name = models.CharField(max_length=50)

    def __str__(self):
        return self.name

    def __iter__(self):
        # Ticket #23721
        assert False, "type checking should happen without calling model __iter__"


class ProxyObjectA(ObjectA):
    class Meta:
        proxy = True


class ChildObjectA(ObjectA):
    pass


class ObjectB(models.Model):
    name = models.CharField(max_length=50)
    objecta = models.ForeignKey(ObjectA, models.CASCADE)
    num = models.PositiveIntegerField()

    def __str__(self):
        return self.name


class ProxyObjectB(ObjectB):
    class Meta:
        proxy = True


class ObjectC(models.Model):
    name = models.CharField(max_length=50)
    objecta = models.ForeignKey(ObjectA, models.SET_NULL, null=True)
    objectb = models.ForeignKey(ObjectB, models.SET_NULL, null=True)
    childobjecta = models.ForeignKey(
        ChildObjectA, models.SET_NULL, null=True, related_name="ca_pk"
    )

    def __str__(self):
        return self.name


class SimpleCategory(models.Model):
    name = models.CharField(max_length=25)

    def __str__(self):
        return self.name


class SpecialCategory(SimpleCategory):
    special_name = models.CharField(max_length=35)

    def __str__(self):
        return self.name + " " + self.special_name


class CategoryItem(models.Model):
    category = models.ForeignKey(SimpleCategory, models.CASCADE)

    def __str__(self):
        return "category item: " + str(self.category)


class MixedCaseFieldCategoryItem(models.Model):
    CaTeGoRy = models.ForeignKey(SimpleCategory, models.CASCADE)


class MixedCaseDbColumnCategoryItem(models.Model):
    category = models.ForeignKey(
        SimpleCategory, models.CASCADE, db_column="CaTeGoRy_Id"
    )


class OneToOneCategory(models.Model):
    new_name = models.CharField(max_length=15)
    category = models.OneToOneField(SimpleCategory, models.CASCADE)

    def __str__(self):
        return "one2one " + self.new_name


class CategoryRelationship(models.Model):
    first = models.ForeignKey(SimpleCategory, models.CASCADE, related_name="first_rel")
    second = models.ForeignKey(
        SimpleCategory, models.CASCADE, related_name="second_rel"
    )


class CommonMixedCaseForeignKeys(models.Model):
    category = models.ForeignKey(CategoryItem, models.CASCADE)
    mixed_case_field_category = models.ForeignKey(
        MixedCaseFieldCategoryItem, models.CASCADE
    )
    mixed_case_db_column_category = models.ForeignKey(
        MixedCaseDbColumnCategoryItem, models.CASCADE
    )


class NullableName(models.Model):
    name = models.CharField(max_length=20, null=True)

    class Meta:
        ordering = ["id"]


class ModelD(models.Model):
    name = models.TextField()


class ModelC(models.Model):
    name = models.TextField()


class ModelB(models.Model):
    name = models.TextField()
    c = models.ForeignKey(ModelC, models.CASCADE)


class ModelA(models.Model):
    name = models.TextField()
    b = models.ForeignKey(ModelB, models.SET_NULL, null=True)
    d = models.ForeignKey(ModelD, models.CASCADE)


class Job(models.Model):
    name = models.CharField(max_length=20, unique=True)

    def __str__(self):
        return self.name


class JobResponsibilities(models.Model):
    job = models.ForeignKey(Job, models.CASCADE, to_field="name")
    responsibility = models.ForeignKey(
        "Responsibility", models.CASCADE, to_field="description"
    )


class Responsibility(models.Model):
    description = models.CharField(max_length=20, unique=True)
    jobs = models.ManyToManyField(
        Job, through=JobResponsibilities, related_name="responsibilities"
    )

    def __str__(self):
        return self.description


# Models for disjunction join promotion low level testing.


class FK1(models.Model):
    f1 = models.TextField()
    f2 = models.TextField()


class FK2(models.Model):
    f1 = models.TextField()
    f2 = models.TextField()


class FK3(models.Model):
    f1 = models.TextField()
    f2 = models.TextField()


class BaseA(models.Model):
    a = models.ForeignKey(FK1, models.SET_NULL, null=True)
    b = models.ForeignKey(FK2, models.SET_NULL, null=True)
    c = models.ForeignKey(FK3, models.SET_NULL, null=True)


class Identifier(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name


class Program(models.Model):
    identifier = models.OneToOneField(Identifier, models.CASCADE)


class Channel(models.Model):
    programs = models.ManyToManyField(Program)
    identifier = models.OneToOneField(Identifier, models.CASCADE)


class Book(models.Model):
    title = models.TextField()
    chapter = models.ForeignKey("Chapter", models.CASCADE)


class Chapter(models.Model):
    title = models.TextField()
    paragraph = models.ForeignKey("Paragraph", models.CASCADE)


class Paragraph(models.Model):
    text = models.TextField()
    page = models.ManyToManyField("Page")


class Page(models.Model):
    text = models.TextField()


class MyObject(models.Model):
    parent = models.ForeignKey(
        "self", models.SET_NULL, null=True, blank=True, related_name="children"
    )
    data = models.CharField(max_length=100)
    created_at = models.DateTimeField(auto_now_add=True)


# Models for #17600 regressions


class Order(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=12, null=True, default="")

    class Meta:
        ordering = ("pk",)

    def __str__(self):
        return str(self.pk)


class OrderItem(models.Model):
    order = models.ForeignKey(Order, models.CASCADE, related_name="items")
    status = models.IntegerField()

    class Meta:
        ordering = ("pk",)

    def __str__(self):
        return str(self.pk)


class BaseUser(models.Model):
    annotation = models.ForeignKey(Annotation, models.CASCADE, null=True, blank=True)


class Task(models.Model):
    title = models.CharField(max_length=10)
    owner = models.ForeignKey(BaseUser, models.CASCADE, related_name="owner")
    creator = models.ForeignKey(BaseUser, models.CASCADE, related_name="creator")
    note = models.ForeignKey(Note, on_delete=models.CASCADE, null=True, blank=True)

    def __str__(self):
        return self.title


class Staff(models.Model):
    name = models.CharField(max_length=10)

    def __str__(self):
        return self.name


class StaffUser(BaseUser):
    staff = models.OneToOneField(Staff, models.CASCADE, related_name="user")

    def __str__(self):
        return str(self.staff)


class Ticket21203Parent(models.Model):
    parentid = models.AutoField(primary_key=True)
    parent_bool = models.BooleanField(default=True)
    created = models.DateTimeField(auto_now=True)


class Ticket21203Child(models.Model):
    childid = models.AutoField(primary_key=True)
    parent = models.ForeignKey(Ticket21203Parent, models.CASCADE)


class Person(models.Model):
    name = models.CharField(max_length=128)


class Company(models.Model):
    name = models.CharField(max_length=128)
    employees = models.ManyToManyField(
        Person, related_name="employers", through="Employment"
    )

    def __str__(self):
        return self.name


class Employment(models.Model):
    employer = models.ForeignKey(Company, models.CASCADE)
    employee = models.ForeignKey(Person, models.CASCADE)
    title = models.CharField(max_length=128)


class School(models.Model):
    pass


class Student(models.Model):
    school = models.ForeignKey(School, models.CASCADE)


class Classroom(models.Model):
    name = models.CharField(max_length=20)
    has_blackboard = models.BooleanField(null=True)
    school = models.ForeignKey(School, models.CASCADE)
    students = models.ManyToManyField(Student, related_name="classroom")


class Teacher(models.Model):
    schools = models.ManyToManyField(School)
    friends = models.ManyToManyField("self")


class Ticket23605AParent(models.Model):
    pass


class Ticket23605A(Ticket23605AParent):
    pass


class Ticket23605B(models.Model):
    modela_fk = models.ForeignKey(Ticket23605A, models.CASCADE)
    modelc_fk = models.ForeignKey("Ticket23605C", models.CASCADE)
    field_b0 = models.IntegerField(null=True)
    field_b1 = models.BooleanField(default=False)


class Ticket23605C(models.Model):
    field_c0 = models.FloatField()


# db_table names have capital letters to ensure they are quoted in queries.
class Individual(models.Model):
    alive = models.BooleanField()

    class Meta:
        db_table = "Individual"


class RelatedIndividual(models.Model):
    related = models.ForeignKey(
        Individual, models.CASCADE, related_name="related_individual"
    )

    class Meta:
        db_table = "RelatedIndividual"


class CustomDbColumn(models.Model):
    custom_column = models.IntegerField(db_column="custom_name", null=True)
    ip_address = models.GenericIPAddressField(null=True)


class CreatedField(models.DateTimeField):
    db_returning = True

    def __init__(self, *args, **kwargs):
        kwargs.setdefault("default", Now)
        super().__init__(*args, **kwargs)


class ReturningModel(models.Model):
    created = CreatedField(editable=False)


class NonIntegerPKReturningModel(models.Model):
    created = CreatedField(editable=False, primary_key=True)


class JSONFieldNullable(models.Model):
    json_field = models.JSONField(blank=True, null=True)

    class Meta:
        required_db_features = {"supports_json_field"}