mirror of
https://github.com/django/django.git
synced 2025-10-31 09:41:08 +00:00
Refs #33476 -- Reformatted code with Black.
This commit is contained in:
django-bot
committed by
Mariusz Felisiak
Mariusz Felisiak
parent
f68fa8b45d
commit
9c19aff7c7
@@ -6,12 +6,14 @@ from django.db import models
|
||||
|
||||
|
||||
class RevisionableModel(models.Model):
|
||||
base = models.ForeignKey('self', models.SET_NULL, null=True)
|
||||
base = models.ForeignKey("self", models.SET_NULL, null=True)
|
||||
title = models.CharField(blank=True, max_length=255)
|
||||
when = models.DateTimeField(default=datetime.datetime.now)
|
||||
|
||||
def save(self, *args, force_insert=None, force_update=None, **kwargs):
|
||||
super().save(*args, force_insert=force_insert, force_update=force_update, **kwargs)
|
||||
super().save(
|
||||
*args, force_insert=force_insert, force_update=force_update, **kwargs
|
||||
)
|
||||
if not self.base:
|
||||
self.base = self
|
||||
super().save(*args, **kwargs)
|
||||
@@ -33,4 +35,4 @@ class TestObject(models.Model):
|
||||
third = models.CharField(max_length=20)
|
||||
|
||||
def __str__(self):
|
||||
return 'TestObject: %s,%s,%s' % (self.first, self.second, self.third)
|
||||
return "TestObject: %s,%s,%s" % (self.first, self.second, self.third)
|
||||
|
||||
@@ -7,13 +7,10 @@ from .models import Order, RevisionableModel, TestObject
|
||||
|
||||
|
||||
class ExtraRegressTests(TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpTestData(cls):
|
||||
cls.u = User.objects.create_user(
|
||||
username="fred",
|
||||
password="secret",
|
||||
email="fred@example.com"
|
||||
username="fred", password="secret", email="fred@example.com"
|
||||
)
|
||||
|
||||
def test_regression_7314_7372(self):
|
||||
@@ -21,8 +18,7 @@ class ExtraRegressTests(TestCase):
|
||||
Regression tests for #7314 and #7372
|
||||
"""
|
||||
rm = RevisionableModel.objects.create(
|
||||
title='First Revision',
|
||||
when=datetime.datetime(2008, 9, 28, 10, 30, 0)
|
||||
title="First Revision", when=datetime.datetime(2008, 9, 28, 10, 30, 0)
|
||||
)
|
||||
self.assertEqual(rm.pk, rm.base.pk)
|
||||
|
||||
@@ -31,53 +27,60 @@ class ExtraRegressTests(TestCase):
|
||||
rm.when = datetime.datetime(2008, 9, 28, 14, 25, 0)
|
||||
rm2.save()
|
||||
|
||||
self.assertEqual(rm2.title, 'Second Revision')
|
||||
self.assertEqual(rm2.base.title, 'First Revision')
|
||||
self.assertEqual(rm2.title, "Second Revision")
|
||||
self.assertEqual(rm2.base.title, "First Revision")
|
||||
|
||||
self.assertNotEqual(rm2.pk, rm.pk)
|
||||
self.assertEqual(rm2.base.pk, rm.pk)
|
||||
|
||||
# Queryset to match most recent revision:
|
||||
qs = RevisionableModel.objects.extra(
|
||||
where=["%(table)s.id IN (SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)" % {
|
||||
'table': RevisionableModel._meta.db_table,
|
||||
}]
|
||||
where=[
|
||||
"%(table)s.id IN (SELECT MAX(rev.id) FROM %(table)s rev GROUP BY rev.base_id)"
|
||||
% {
|
||||
"table": RevisionableModel._meta.db_table,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
self.assertQuerysetEqual(
|
||||
qs, [('Second Revision', 'First Revision')],
|
||||
transform=lambda r: (r.title, r.base.title)
|
||||
qs,
|
||||
[("Second Revision", "First Revision")],
|
||||
transform=lambda r: (r.title, r.base.title),
|
||||
)
|
||||
|
||||
# Queryset to search for string in title:
|
||||
qs2 = RevisionableModel.objects.filter(title__contains="Revision")
|
||||
self.assertQuerysetEqual(
|
||||
qs2, [
|
||||
('First Revision', 'First Revision'),
|
||||
('Second Revision', 'First Revision'),
|
||||
qs2,
|
||||
[
|
||||
("First Revision", "First Revision"),
|
||||
("Second Revision", "First Revision"),
|
||||
],
|
||||
transform=lambda r: (r.title, r.base.title),
|
||||
ordered=False
|
||||
ordered=False,
|
||||
)
|
||||
|
||||
# Following queryset should return the most recent revision:
|
||||
self.assertQuerysetEqual(
|
||||
qs & qs2,
|
||||
[('Second Revision', 'First Revision')],
|
||||
[("Second Revision", "First Revision")],
|
||||
transform=lambda r: (r.title, r.base.title),
|
||||
ordered=False
|
||||
ordered=False,
|
||||
)
|
||||
|
||||
def test_extra_stay_tied(self):
|
||||
# Extra select parameters should stay tied to their corresponding
|
||||
# select portions. Applies when portions are updated or otherwise
|
||||
# moved around.
|
||||
qs = User.objects.extra(select={'alpha': '%s', 'beta': "2", 'gamma': '%s'}, select_params=(1, 3))
|
||||
qs = User.objects.extra(
|
||||
select={"alpha": "%s", "beta": "2", "gamma": "%s"}, select_params=(1, 3)
|
||||
)
|
||||
qs = qs.extra(select={"beta": 4})
|
||||
qs = qs.extra(select={"alpha": "%s"}, select_params=[5])
|
||||
self.assertEqual(
|
||||
list(qs.filter(id=self.u.id).values('alpha', 'beta', 'gamma')),
|
||||
[{'alpha': 5, 'beta': 4, 'gamma': 3}]
|
||||
list(qs.filter(id=self.u.id).values("alpha", "beta", "gamma")),
|
||||
[{"alpha": 5, "beta": 4, "gamma": 3}],
|
||||
)
|
||||
|
||||
def test_regression_7957(self):
|
||||
@@ -87,17 +90,21 @@ class ExtraRegressTests(TestCase):
|
||||
internal dictionary must remain sorted.
|
||||
"""
|
||||
self.assertEqual(
|
||||
(User.objects
|
||||
.extra(select={"alpha": "%s"}, select_params=(1,))
|
||||
.extra(select={"beta": "%s"}, select_params=(2,))[0].alpha),
|
||||
1
|
||||
(
|
||||
User.objects.extra(select={"alpha": "%s"}, select_params=(1,))
|
||||
.extra(select={"beta": "%s"}, select_params=(2,))[0]
|
||||
.alpha
|
||||
),
|
||||
1,
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
(User.objects
|
||||
.extra(select={"beta": "%s"}, select_params=(1,))
|
||||
.extra(select={"alpha": "%s"}, select_params=(2,))[0].alpha),
|
||||
2
|
||||
(
|
||||
User.objects.extra(select={"beta": "%s"}, select_params=(1,))
|
||||
.extra(select={"alpha": "%s"}, select_params=(2,))[0]
|
||||
.alpha
|
||||
),
|
||||
2,
|
||||
)
|
||||
|
||||
def test_regression_7961(self):
|
||||
@@ -107,9 +114,12 @@ class ExtraRegressTests(TestCase):
|
||||
query as well.
|
||||
"""
|
||||
self.assertEqual(
|
||||
list(User.objects.extra(select={"alpha": "%s"}, select_params=(-6,))
|
||||
.filter(id=self.u.id).values_list('id', flat=True)),
|
||||
[self.u.id]
|
||||
list(
|
||||
User.objects.extra(select={"alpha": "%s"}, select_params=(-6,))
|
||||
.filter(id=self.u.id)
|
||||
.values_list("id", flat=True)
|
||||
),
|
||||
[self.u.id],
|
||||
)
|
||||
|
||||
def test_regression_8063(self):
|
||||
@@ -117,7 +127,7 @@ class ExtraRegressTests(TestCase):
|
||||
Regression test for #8063: limiting a query shouldn't discard any
|
||||
extra() bits.
|
||||
"""
|
||||
qs = User.objects.all().extra(where=['id=%s'], params=[self.u.id])
|
||||
qs = User.objects.all().extra(where=["id=%s"], params=[self.u.id])
|
||||
self.assertSequenceEqual(qs, [self.u])
|
||||
self.assertSequenceEqual(qs[:1], [self.u])
|
||||
|
||||
@@ -129,10 +139,12 @@ class ExtraRegressTests(TestCase):
|
||||
should still be present because of the extra() call.
|
||||
"""
|
||||
self.assertQuerysetEqual(
|
||||
(Order.objects
|
||||
.extra(where=["username=%s"], params=["fred"], tables=["auth_user"])
|
||||
.order_by('created_by')),
|
||||
[]
|
||||
(
|
||||
Order.objects.extra(
|
||||
where=["username=%s"], params=["fred"], tables=["auth_user"]
|
||||
).order_by("created_by")
|
||||
),
|
||||
[],
|
||||
)
|
||||
|
||||
def test_regression_8819(self):
|
||||
@@ -141,15 +153,21 @@ class ExtraRegressTests(TestCase):
|
||||
should be available to extra(order_by=...).
|
||||
"""
|
||||
self.assertSequenceEqual(
|
||||
User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}).distinct(),
|
||||
User.objects.filter(pk=self.u.id)
|
||||
.extra(select={"extra_field": 1})
|
||||
.distinct(),
|
||||
[self.u],
|
||||
)
|
||||
self.assertSequenceEqual(
|
||||
User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']),
|
||||
User.objects.filter(pk=self.u.id).extra(
|
||||
select={"extra_field": 1}, order_by=["extra_field"]
|
||||
),
|
||||
[self.u],
|
||||
)
|
||||
self.assertSequenceEqual(
|
||||
User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']).distinct(),
|
||||
User.objects.filter(pk=self.u.id)
|
||||
.extra(select={"extra_field": 1}, order_by=["extra_field"])
|
||||
.distinct(),
|
||||
[self.u],
|
||||
)
|
||||
|
||||
@@ -160,12 +178,13 @@ class ExtraRegressTests(TestCase):
|
||||
the result and cause incorrect SQL to be produced otherwise.
|
||||
"""
|
||||
RevisionableModel.objects.create(
|
||||
title='First Revision',
|
||||
when=datetime.datetime(2008, 9, 28, 10, 30, 0)
|
||||
title="First Revision", when=datetime.datetime(2008, 9, 28, 10, 30, 0)
|
||||
)
|
||||
|
||||
self.assertSequenceEqual(
|
||||
RevisionableModel.objects.extra(select={"the_answer": 'id'}).datetimes('when', 'month'),
|
||||
RevisionableModel.objects.extra(select={"the_answer": "id"}).datetimes(
|
||||
"when", "month"
|
||||
),
|
||||
[datetime.datetime(2008, 9, 1, 0, 0)],
|
||||
)
|
||||
|
||||
@@ -174,179 +193,193 @@ class ExtraRegressTests(TestCase):
|
||||
Regression test for #10256... If there is a values() clause, Extra
|
||||
columns are only returned if they are explicitly mentioned.
|
||||
"""
|
||||
obj = TestObject(first='first', second='second', third='third')
|
||||
obj = TestObject(first="first", second="second", third="third")
|
||||
obj.save()
|
||||
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values()
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values()
|
||||
),
|
||||
[{
|
||||
'bar': 'second', 'third': 'third', 'second': 'second', 'whiz': 'third', 'foo': 'first',
|
||||
'id': obj.pk, 'first': 'first'
|
||||
}]
|
||||
[
|
||||
{
|
||||
"bar": "second",
|
||||
"third": "third",
|
||||
"second": "second",
|
||||
"whiz": "third",
|
||||
"foo": "first",
|
||||
"id": obj.pk,
|
||||
"first": "first",
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
# Extra clauses after an empty values clause are still included
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.values()
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
TestObject.objects.values().extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
)
|
||||
),
|
||||
[{
|
||||
'bar': 'second', 'third': 'third', 'second': 'second', 'whiz': 'third', 'foo': 'first',
|
||||
'id': obj.pk, 'first': 'first'
|
||||
}]
|
||||
[
|
||||
{
|
||||
"bar": "second",
|
||||
"third": "third",
|
||||
"second": "second",
|
||||
"whiz": "third",
|
||||
"foo": "first",
|
||||
"id": obj.pk,
|
||||
"first": "first",
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
# Extra columns are ignored if not mentioned in the values() clause
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values('first', 'second')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values("first", "second")
|
||||
),
|
||||
[{'second': 'second', 'first': 'first'}]
|
||||
[{"second": "second", "first": "first"}],
|
||||
)
|
||||
|
||||
# Extra columns after a non-empty values() clause are ignored
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.values('first', 'second')
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
TestObject.objects.values("first", "second").extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
)
|
||||
),
|
||||
[{'second': 'second', 'first': 'first'}]
|
||||
[{"second": "second", "first": "first"}],
|
||||
)
|
||||
|
||||
# Extra columns can be partially returned
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values('first', 'second', 'foo')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values("first", "second", "foo")
|
||||
),
|
||||
[{'second': 'second', 'foo': 'first', 'first': 'first'}]
|
||||
[{"second": "second", "foo": "first", "first": "first"}],
|
||||
)
|
||||
|
||||
# Also works if only extra columns are included
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values('foo', 'whiz')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values("foo", "whiz")
|
||||
),
|
||||
[{'foo': 'first', 'whiz': 'third'}]
|
||||
[{"foo": "first", "whiz": "third"}],
|
||||
)
|
||||
|
||||
# Values list works the same way
|
||||
# All columns are returned for an empty values_list()
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list()
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list()
|
||||
),
|
||||
[('first', 'second', 'third', obj.pk, 'first', 'second', 'third')]
|
||||
[("first", "second", "third", obj.pk, "first", "second", "third")],
|
||||
)
|
||||
|
||||
# Extra columns after an empty values_list() are still included
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.values_list()
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
TestObject.objects.values_list().extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
)
|
||||
),
|
||||
[('first', 'second', 'third', obj.pk, 'first', 'second', 'third')]
|
||||
[("first", "second", "third", obj.pk, "first", "second", "third")],
|
||||
)
|
||||
|
||||
# Extra columns ignored completely if not mentioned in values_list()
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('first', 'second')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("first", "second")
|
||||
),
|
||||
[('first', 'second')]
|
||||
[("first", "second")],
|
||||
)
|
||||
|
||||
# Extra columns after a non-empty values_list() clause are ignored completely
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.values_list('first', 'second')
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
TestObject.objects.values_list("first", "second").extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
)
|
||||
),
|
||||
[('first', 'second')]
|
||||
[("first", "second")],
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('second', flat=True)
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("second", flat=True)
|
||||
),
|
||||
['second']
|
||||
["second"],
|
||||
)
|
||||
|
||||
# Only the extra columns specified in the values_list() are returned
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('first', 'second', 'whiz')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("first", "second", "whiz")
|
||||
),
|
||||
[('first', 'second', 'third')]
|
||||
[("first", "second", "third")],
|
||||
)
|
||||
|
||||
# ...also works if only extra columns are included
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('foo', 'whiz')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("foo", "whiz")
|
||||
),
|
||||
[('first', 'third')]
|
||||
[("first", "third")],
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('whiz', flat=True)
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("whiz", flat=True)
|
||||
),
|
||||
['third']
|
||||
["third"],
|
||||
)
|
||||
|
||||
# ... and values are returned in the order they are specified
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('whiz', 'foo')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("whiz", "foo")
|
||||
),
|
||||
[('third', 'first')]
|
||||
[("third", "first")],
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('first', 'id')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("first", "id")
|
||||
),
|
||||
[('first', obj.pk)]
|
||||
[("first", obj.pk)],
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
list(
|
||||
TestObject.objects
|
||||
.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'})
|
||||
.values_list('whiz', 'first', 'bar', 'id')
|
||||
TestObject.objects.extra(
|
||||
select={"foo": "first", "bar": "second", "whiz": "third"}
|
||||
).values_list("whiz", "first", "bar", "id")
|
||||
),
|
||||
[('third', 'first', 'second', obj.pk)]
|
||||
[("third", "first", "second", obj.pk)],
|
||||
)
|
||||
|
||||
def test_regression_10847(self):
|
||||
@@ -356,35 +389,36 @@ class ExtraRegressTests(TestCase):
|
||||
producing correct output without requiring full evaluation and
|
||||
execution of the inner query.
|
||||
"""
|
||||
obj = TestObject(first='first', second='second', third='third')
|
||||
obj = TestObject(first="first", second="second", third="third")
|
||||
obj.save()
|
||||
|
||||
self.assertEqual(
|
||||
list(TestObject.objects.extra(select={'extra': 1}).values('pk')),
|
||||
[{'pk': obj.pk}]
|
||||
list(TestObject.objects.extra(select={"extra": 1}).values("pk")),
|
||||
[{"pk": obj.pk}],
|
||||
)
|
||||
|
||||
self.assertSequenceEqual(
|
||||
TestObject.objects.filter(
|
||||
pk__in=TestObject.objects.extra(select={'extra': 1}).values('pk')
|
||||
pk__in=TestObject.objects.extra(select={"extra": 1}).values("pk")
|
||||
),
|
||||
[obj],
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
list(TestObject.objects.values('pk').extra(select={'extra': 1})),
|
||||
[{'pk': obj.pk}]
|
||||
list(TestObject.objects.values("pk").extra(select={"extra": 1})),
|
||||
[{"pk": obj.pk}],
|
||||
)
|
||||
|
||||
self.assertSequenceEqual(
|
||||
TestObject.objects.filter(
|
||||
pk__in=TestObject.objects.values('pk').extra(select={'extra': 1})
|
||||
pk__in=TestObject.objects.values("pk").extra(select={"extra": 1})
|
||||
),
|
||||
[obj],
|
||||
)
|
||||
|
||||
self.assertSequenceEqual(
|
||||
TestObject.objects.filter(pk=obj.pk) | TestObject.objects.extra(where=["id > %s"], params=[obj.pk]),
|
||||
TestObject.objects.filter(pk=obj.pk)
|
||||
| TestObject.objects.extra(where=["id > %s"], params=[obj.pk]),
|
||||
[obj],
|
||||
)
|
||||
|
||||
@@ -394,20 +428,20 @@ class ExtraRegressTests(TestCase):
|
||||
contain OR operations.
|
||||
"""
|
||||
# Test Case 1: should appear in queryset.
|
||||
t1 = TestObject.objects.create(first='a', second='a', third='a')
|
||||
t1 = TestObject.objects.create(first="a", second="a", third="a")
|
||||
# Test Case 2: should appear in queryset.
|
||||
t2 = TestObject.objects.create(first='b', second='a', third='a')
|
||||
t2 = TestObject.objects.create(first="b", second="a", third="a")
|
||||
# Test Case 3: should not appear in queryset, bug case.
|
||||
t = TestObject(first='a', second='a', third='b')
|
||||
t = TestObject(first="a", second="a", third="b")
|
||||
t.save()
|
||||
# Test Case 4: should not appear in queryset.
|
||||
t = TestObject(first='b', second='a', third='b')
|
||||
t = TestObject(first="b", second="a", third="b")
|
||||
t.save()
|
||||
# Test Case 5: should not appear in queryset.
|
||||
t = TestObject(first='b', second='b', third='a')
|
||||
t = TestObject(first="b", second="b", third="a")
|
||||
t.save()
|
||||
# Test Case 6: should not appear in queryset, bug case.
|
||||
t = TestObject(first='a', second='b', third='b')
|
||||
t = TestObject(first="a", second="b", third="b")
|
||||
t.save()
|
||||
|
||||
self.assertCountEqual(
|
||||
@@ -418,14 +452,18 @@ class ExtraRegressTests(TestCase):
|
||||
)
|
||||
|
||||
def test_extra_values_distinct_ordering(self):
|
||||
t1 = TestObject.objects.create(first='a', second='a', third='a')
|
||||
t2 = TestObject.objects.create(first='a', second='b', third='b')
|
||||
qs = TestObject.objects.extra(
|
||||
select={'second_extra': 'second'}
|
||||
).values_list('id', flat=True).distinct()
|
||||
self.assertSequenceEqual(qs.order_by('second_extra'), [t1.pk, t2.pk])
|
||||
self.assertSequenceEqual(qs.order_by('-second_extra'), [t2.pk, t1.pk])
|
||||
t1 = TestObject.objects.create(first="a", second="a", third="a")
|
||||
t2 = TestObject.objects.create(first="a", second="b", third="b")
|
||||
qs = (
|
||||
TestObject.objects.extra(select={"second_extra": "second"})
|
||||
.values_list("id", flat=True)
|
||||
.distinct()
|
||||
)
|
||||
self.assertSequenceEqual(qs.order_by("second_extra"), [t1.pk, t2.pk])
|
||||
self.assertSequenceEqual(qs.order_by("-second_extra"), [t2.pk, t1.pk])
|
||||
# Note: the extra ordering must appear in select clause, so we get two
|
||||
# non-distinct results here (this is on purpose, see #7070).
|
||||
# Extra select doesn't appear in result values.
|
||||
self.assertSequenceEqual(qs.order_by('-second_extra').values_list('first'), [('a',), ('a',)])
|
||||
self.assertSequenceEqual(
|
||||
qs.order_by("-second_extra").values_list("first"), [("a",), ("a",)]
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user