mirror of
https://github.com/django/django.git
synced 2024-12-29 12:36:08 +00:00
4771a1694b
This makes QuerySet.order_by() no longer ignore trailing transforms for models with Meta.ordering. As a consequence, FieldError is raised in such cases for non-existent fields. Thanks to Klaas van Schelven for the report and Mariusz Felisiak for the review and advice.
791 lines
18 KiB
Python
791 lines
18 KiB
Python
"""
|
|
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 Meta:
|
|
ordering = ["date"]
|
|
|
|
|
|
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"}
|