Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Fixed #13895 -- Refactored aggregation_regress doctests. Thanks to Al…

…ex Gaynor for the patch.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@13614 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 1bf25e9bc6df6c2ae4c0b10fb839e101471e8373 1 parent c2e3ba3
Russell Keith-Magee freakboy3742 authored
1  django/test/__init__.py
View
@@ -4,3 +4,4 @@
from django.test.client import Client
from django.test.testcases import TestCase, TransactionTestCase
+from django.test.utils import Approximate
19 django/test/utils.py
View
@@ -1,4 +1,6 @@
-import sys, time, os
+import sys
+import time
+import os
from django.conf import settings
from django.core import mail
from django.core.mail.backends import locmem
@@ -6,6 +8,21 @@
from django.template import Template
from django.utils.translation import deactivate
+
+class Approximate(object):
+ def __init__(self, val, places=7):
+ self.val = val
+ self.places = places
+
+ def __repr__(self):
+ return repr(self.val)
+
+ def __eq__(self, other):
+ if self.val == other:
+ return True
+ return round(abs(self.val-other), self.places) == 0
+
+
class ContextList(list):
"""A wrapper that provides direct key access to context items contained
in a list of context objects.
15 tests/modeltests/aggregation/tests.py
View
@@ -2,24 +2,11 @@
from decimal import Decimal
from django.db.models import Avg, Sum, Count, Max, Min
-from django.test import TestCase
+from django.test import TestCase, Approximate
from models import Author, Publisher, Book, Store
-class Approximate(object):
- def __init__(self, val, places=7):
- self.val = val
- self.places = places
-
- def __repr__(self):
- return repr(self.val)
-
- def __eq__(self, other):
- if self.val == other:
- return True
- return round(abs(self.val-other), self.places) == 0
-
class BaseAggregateTestCase(TestCase):
fixtures = ["initial_data.json"]
323 tests/regressiontests/aggregation_regress/models.py
View
@@ -4,6 +4,7 @@
from django.db import connection, models, DEFAULT_DB_ALIAS
from django.conf import settings
+
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
@@ -12,6 +13,7 @@ class Author(models.Model):
def __unicode__(self):
return self.name
+
class Publisher(models.Model):
name = models.CharField(max_length=255)
num_awards = models.IntegerField()
@@ -19,6 +21,7 @@ class Publisher(models.Model):
def __unicode__(self):
return self.name
+
class Book(models.Model):
isbn = models.CharField(max_length=9)
name = models.CharField(max_length=255)
@@ -36,6 +39,7 @@ class Meta:
def __unicode__(self):
return self.name
+
class Store(models.Model):
name = models.CharField(max_length=255)
books = models.ManyToManyField(Book)
@@ -45,334 +49,21 @@ class Store(models.Model):
def __unicode__(self):
return self.name
+
class Entries(models.Model):
EntryID = models.AutoField(primary_key=True, db_column='Entry ID')
Entry = models.CharField(unique=True, max_length=50)
Exclude = models.BooleanField()
+
class Clues(models.Model):
ID = models.AutoField(primary_key=True)
EntryID = models.ForeignKey(Entries, verbose_name='Entry', db_column = 'Entry ID')
Clue = models.CharField(max_length=150)
+
class HardbackBook(Book):
weight = models.FloatField()
def __unicode__(self):
return "%s (hardback): %s" % (self.name, self.weight)
-
-__test__ = {'API_TESTS': """
->>> from django.core import management
->>> from django.db.models import get_app, F
-
-# Reset the database representation of this app.
-# This will return the database to a clean initial state.
->>> management.call_command('flush', verbosity=0, interactive=False)
-
->>> from django.db.models import Avg, Sum, Count, Max, Min, StdDev, Variance
-
-# Ordering requests are ignored
->>> Author.objects.all().order_by('name').aggregate(Avg('age'))
-{'age__avg': 37.4...}
-
-# Implicit ordering is also ignored
->>> Book.objects.all().aggregate(Sum('pages'))
-{'pages__sum': 3703}
-
-# Baseline results
->>> Book.objects.all().aggregate(Sum('pages'), Avg('pages'))
-{'pages__sum': 3703, 'pages__avg': 617.1...}
-
-# Empty values query doesn't affect grouping or results
->>> Book.objects.all().values().aggregate(Sum('pages'), Avg('pages'))
-{'pages__sum': 3703, 'pages__avg': 617.1...}
-
-# Aggregate overrides extra selected column
->>> Book.objects.all().extra(select={'price_per_page' : 'price / pages'}).aggregate(Sum('pages'))
-{'pages__sum': 3703}
-
-# Annotations get combined with extra select clauses
->>> sorted((k,v) for k,v in Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2).__dict__.items() if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# Order of the annotate/extra in the query doesn't matter
->>> sorted((k,v) for k,v in Book.objects.all().extra(select={'manufacture_cost' : 'price * .5'}).annotate(mean_auth_age=Avg('authors__age')).get(pk=2).__dict__.items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# Values queries can be combined with annotate and extra
->>> sorted((k,v) for k,v in Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).values().get(pk=2).items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# The order of the (empty) values, annotate and extra clauses doesn't matter
->>> sorted((k,v) for k,v in Book.objects.all().values().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2).items()if k != '_state')
-[('contact_id', 3), ('id', 2), ('isbn', u'067232959'), ('manufacture_cost', ...11.545...), ('mean_auth_age', 45.0), ('name', u'Sams Teach Yourself Django in 24 Hours'), ('pages', 528), ('price', Decimal("23.09")), ('pubdate', datetime.date(2008, 3, 3)), ('publisher_id', 2), ('rating', 3.0)]
-
-# If the annotation precedes the values clause, it won't be included
-# unless it is explicitly named
->>> sorted(Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name').get(pk=1).items())
-[('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
->>> sorted(Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name','mean_auth_age').get(pk=1).items())
-[('mean_auth_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
-# If an annotation isn't included in the values, it can still be used in a filter
->>> Book.objects.annotate(n_authors=Count('authors')).values('name').filter(n_authors__gt=2)
-[{'name': u'Python Web Development with Django'}]
-
-# The annotations are added to values output if values() precedes annotate()
->>> sorted(Book.objects.all().values('name').annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).get(pk=1).items())
-[('mean_auth_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right')]
-
-# Check that all of the objects are getting counted (allow_nulls) and that values respects the amount of objects
->>> len(Author.objects.all().annotate(Avg('friends__age')).values())
-9
-
-# Check that consecutive calls to annotate accumulate in the query
->>> Book.objects.values('price').annotate(oldest=Max('authors__age')).order_by('oldest', 'price').annotate(Max('publisher__num_awards'))
-[{'price': Decimal("30..."), 'oldest': 35, 'publisher__num_awards__max': 3}, {'price': Decimal("29.69"), 'oldest': 37, 'publisher__num_awards__max': 7}, {'price': Decimal("23.09"), 'oldest': 45, 'publisher__num_awards__max': 1}, {'price': Decimal("75..."), 'oldest': 57, 'publisher__num_awards__max': 9}, {'price': Decimal("82.8..."), 'oldest': 57, 'publisher__num_awards__max': 7}]
-
-# Aggregates can be composed over annotations.
-# The return type is derived from the composed aggregate
->>> Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('pages'), Max('price'), Sum('num_authors'), Avg('num_authors'))
-{'num_authors__sum': 10, 'num_authors__avg': 1.66..., 'pages__max': 1132, 'price__max': Decimal("82.80")}
-
-# Bad field requests in aggregates are caught and reported
->>> Book.objects.all().aggregate(num_authors=Count('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store
-
->>> Book.objects.all().annotate(num_authors=Count('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store
-
->>> Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('foo'))
-Traceback (most recent call last):
-...
-FieldError: Cannot resolve keyword 'foo' into field. Choices are: authors, contact, hardbackbook, id, isbn, name, pages, price, pubdate, publisher, rating, store, num_authors
-
-# Old-style count aggregations can be mixed with new-style
->>> Book.objects.annotate(num_authors=Count('authors')).count()
-6
-
-# Non-ordinal, non-computed Aggregates over annotations correctly inherit
-# the annotation's internal type if the annotation is ordinal or computed
->>> Book.objects.annotate(num_authors=Count('authors')).aggregate(Max('num_authors'))
-{'num_authors__max': 3}
-
->>> Publisher.objects.annotate(avg_price=Avg('book__price')).aggregate(Max('avg_price'))
-{'avg_price__max': 75.0...}
-
-# Aliases are quoted to protected aliases that might be reserved names
->>> Book.objects.aggregate(number=Max('pages'), select=Max('pages'))
-{'number': 1132, 'select': 1132}
-
-# Regression for #10064: select_related() plays nice with aggregates
->>> sorted(Book.objects.select_related('publisher').annotate(num_authors=Count('authors')).values()[0].iteritems())
-[('contact_id', 8), ('id', 5), ('isbn', u'013790395'), ('name', u'Artificial Intelligence: A Modern Approach'), ('num_authors', 2), ('pages', 1132), ('price', Decimal("82.8...")), ('pubdate', datetime.date(1995, 1, 15)), ('publisher_id', 3), ('rating', 4.0)]
-
-# Regression for #10010: exclude on an aggregate field is correctly negated
->>> len(Book.objects.annotate(num_authors=Count('authors')))
-6
->>> len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=2))
-1
->>> len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__gt=2))
-5
-
->>> len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__lt=3).exclude(num_authors__lt=2))
-2
->>> len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__lt=2).filter(num_authors__lt=3))
-2
-
-# Aggregates can be used with F() expressions
-# ... where the F() is pushed into the HAVING clause
->>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9}, {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}]
-
->>> Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 2, 'name': u'Apress', 'num_awards': 3}, {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0}, {'num_books': 1, 'name': u'Sams', 'num_awards': 1}]
-
-# ... and where the F() references an aggregate
->>> Publisher.objects.annotate(num_books=Count('book')).filter(num_awards__gt=2*F('num_books')).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9}, {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}]
-
->>> Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
-[{'num_books': 2, 'name': u'Apress', 'num_awards': 3}, {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0}, {'num_books': 1, 'name': u'Sams', 'num_awards': 1}]
-
-# Tests on fields with non-default table and column names.
->>> Clues.objects.values('EntryID__Entry').annotate(Appearances=Count('EntryID'), Distinct_Clues=Count('Clue', distinct=True))
-[]
-
->>> Entries.objects.annotate(clue_count=Count('clues__ID'))
-[]
-
-# Regression for #10089: Check handling of empty result sets with aggregates
->>> Book.objects.filter(id__in=[]).count()
-0
-
->>> Book.objects.filter(id__in=[]).aggregate(num_authors=Count('authors'), avg_authors=Avg('authors'), max_authors=Max('authors'), max_price=Max('price'), max_rating=Max('rating'))
-{'max_authors': None, 'max_rating': None, 'num_authors': 0, 'avg_authors': None, 'max_price': None}
-
->>> list(Publisher.objects.filter(pk=5).annotate(num_authors=Count('book__authors'), avg_authors=Avg('book__authors'), max_authors=Max('book__authors'), max_price=Max('book__price'), max_rating=Max('book__rating')).values()) == [{'max_authors': None, 'name': u"Jonno's House of Books", 'num_awards': 0, 'max_price': None, 'num_authors': 0, 'max_rating': None, 'id': 5, 'avg_authors': None}]
-True
-
-# Regression for #10113 - Fields mentioned in order_by() must be included in the GROUP BY.
-# This only becomes a problem when the order_by introduces a new join.
->>> Book.objects.annotate(num_authors=Count('authors')).order_by('publisher__name', 'name')
-[<Book: Practical Django Projects>, <Book: The Definitive Guide to Django: Web Development Done Right>, <Book: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp>, <Book: Artificial Intelligence: A Modern Approach>, <Book: Python Web Development with Django>, <Book: Sams Teach Yourself Django in 24 Hours>]
-
-# Regression for #10127 - Empty select_related() works with annotate
->>> books = Book.objects.all().filter(rating__lt=4.5).select_related().annotate(Avg('authors__age'))
->>> sorted([(b.name, b.authors__age__avg, b.publisher.name, b.contact.name) for b in books])
-[(u'Artificial Intelligence: A Modern Approach', 51.5, u'Prentice Hall', u'Peter Norvig'), (u'Practical Django Projects', 29.0, u'Apress', u'James Bennett'), (u'Python Web Development with Django', 30.3..., u'Prentice Hall', u'Jeffrey Forcier'), (u'Sams Teach Yourself Django in 24 Hours', 45.0, u'Sams', u'Brad Dayley')]
-
-# Regression for #10132 - If the values() clause only mentioned extra(select=) columns, those columns are used for grouping
->>> Book.objects.extra(select={'pub':'publisher_id'}).values('pub').annotate(Count('id')).order_by('pub')
-[{'pub': 1, 'id__count': 2}, {'pub': 2, 'id__count': 1}, {'pub': 3, 'id__count': 2}, {'pub': 4, 'id__count': 1}]
-
->>> Book.objects.extra(select={'pub':'publisher_id','foo':'pages'}).values('pub').annotate(Count('id')).order_by('pub')
-[{'pub': 1, 'id__count': 2}, {'pub': 2, 'id__count': 1}, {'pub': 3, 'id__count': 2}, {'pub': 4, 'id__count': 1}]
-
-# Regression for #10182 - Queries with aggregate calls are correctly realiased when used in a subquery
->>> ids = Book.objects.filter(pages__gt=100).annotate(n_authors=Count('authors')).filter(n_authors__gt=2).order_by('n_authors')
->>> Book.objects.filter(id__in=ids)
-[<Book: Python Web Development with Django>]
-
-# Regression for #10197 -- Queries with aggregates can be pickled.
-# First check that pickling is possible at all. No crash = success
->>> qs = Book.objects.annotate(num_authors=Count('authors'))
->>> out = pickle.dumps(qs)
-
-# Then check that the round trip works.
->>> query = qs.query.get_compiler(qs.db).as_sql()[0]
->>> select_fields = qs.query.select_fields
->>> query2 = pickle.loads(pickle.dumps(qs))
->>> query2.query.get_compiler(query2.db).as_sql()[0] == query
-True
->>> query2.query.select_fields = select_fields
-
-# Regression for #10199 - Aggregate calls clone the original query so the original query can still be used
->>> books = Book.objects.all()
->>> _ = books.aggregate(Avg('authors__age'))
->>> books.all()
-[<Book: Artificial Intelligence: A Modern Approach>, <Book: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp>, <Book: Practical Django Projects>, <Book: Python Web Development with Django>, <Book: Sams Teach Yourself Django in 24 Hours>, <Book: The Definitive Guide to Django: Web Development Done Right>]
-
-# Regression for #10248 - Annotations work with DateQuerySets
->>> Book.objects.annotate(num_authors=Count('authors')).filter(num_authors=2).dates('pubdate', 'day')
-[datetime.datetime(1995, 1, 15, 0, 0), datetime.datetime(2007, 12, 6, 0, 0)]
-
-# Regression for #10290 - extra selects with parameters can be used for
-# grouping.
->>> qs = Book.objects.all().annotate(mean_auth_age=Avg('authors__age')).extra(select={'sheets' : '(pages + %s) / %s'}, select_params=[1, 2]).order_by('sheets').values('sheets')
->>> [int(x['sheets']) for x in qs]
-[150, 175, 224, 264, 473, 566]
-
-# Regression for 10425 - annotations don't get in the way of a count() clause
->>> Book.objects.values('publisher').annotate(Count('publisher')).count()
-4
-
->>> Book.objects.annotate(Count('publisher')).values('publisher').count()
-6
-
->>> publishers = Publisher.objects.filter(id__in=(1,2))
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
->>> publishers = publishers.annotate(n_books=models.Count('book'))
->>> publishers[0].n_books
-2
-
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
->>> books = Book.objects.filter(publisher__in=publishers)
->>> books
-[<Book: Practical Django Projects>, <Book: Sams Teach Yourself Django in 24 Hours>, <Book: The Definitive Guide to Django: Web Development Done Right>]
-
->>> publishers
-[<Publisher: Apress>, <Publisher: Sams>]
-
-
-# Regression for 10666 - inherited fields work with annotations and aggregations
->>> HardbackBook.objects.aggregate(n_pages=Sum('book_ptr__pages'))
-{'n_pages': 2078}
-
->>> HardbackBook.objects.aggregate(n_pages=Sum('pages'))
-{'n_pages': 2078}
-
->>> HardbackBook.objects.annotate(n_authors=Count('book_ptr__authors')).values('name','n_authors')
-[{'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'}, {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}]
-
->>> HardbackBook.objects.annotate(n_authors=Count('authors')).values('name','n_authors')
-[{'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'}, {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}]
-
-# Regression for #10766 - Shouldn't be able to reference an aggregate fields in an an aggregate() call.
->>> Book.objects.all().annotate(mean_age=Avg('authors__age')).annotate(Avg('mean_age'))
-Traceback (most recent call last):
-...
-FieldError: Cannot compute Avg('mean_age'): 'mean_age' is an aggregate
-
-"""
-}
-
-def run_stddev_tests():
- """Check to see if StdDev/Variance tests should be run.
-
- Stddev and Variance are not guaranteed to be available for SQLite, and
- are not available for PostgreSQL before 8.2.
- """
- if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] == 'django.db.backends.sqlite3':
- return False
-
- class StdDevPop(object):
- sql_function = 'STDDEV_POP'
-
- try:
- connection.ops.check_aggregate_support(StdDevPop())
- except:
- return False
- return True
-
-if run_stddev_tests():
- __test__['API_TESTS'] += """
->>> Book.objects.aggregate(StdDev('pages'))
-{'pages__stddev': 311.46...}
-
->>> Book.objects.aggregate(StdDev('rating'))
-{'rating__stddev': 0.60...}
-
->>> Book.objects.aggregate(StdDev('price'))
-{'price__stddev': 24.16...}
-
-
->>> Book.objects.aggregate(StdDev('pages', sample=True))
-{'pages__stddev': 341.19...}
-
->>> Book.objects.aggregate(StdDev('rating', sample=True))
-{'rating__stddev': 0.66...}
-
->>> Book.objects.aggregate(StdDev('price', sample=True))
-{'price__stddev': 26.46...}
-
-
->>> Book.objects.aggregate(Variance('pages'))
-{'pages__variance': 97010.80...}
-
->>> Book.objects.aggregate(Variance('rating'))
-{'rating__variance': 0.36...}
-
->>> Book.objects.aggregate(Variance('price'))
-{'price__variance': 583.77...}
-
-
->>> Book.objects.aggregate(Variance('pages', sample=True))
-{'pages__variance': 116412.96...}
-
->>> Book.objects.aggregate(Variance('rating', sample=True))
-{'rating__variance': 0.44...}
-
->>> Book.objects.aggregate(Variance('price', sample=True))
-{'price__variance': 700.53...}
-
-"""
614 tests/regressiontests/aggregation_regress/tests.py
View
@@ -1,12 +1,38 @@
+import datetime
+from decimal import Decimal
+
+from django.core.exceptions import FieldError
from django.conf import settings
-from django.test import TestCase
+from django.test import TestCase, Approximate
from django.db import DEFAULT_DB_ALIAS
-from django.db.models import Count, Max
+from django.db.models import Count, Max, Avg, Sum, F
from regressiontests.aggregation_regress.models import *
+def run_stddev_tests():
+ """Check to see if StdDev/Variance tests should be run.
+
+ Stddev and Variance are not guaranteed to be available for SQLite, and
+ are not available for PostgreSQL before 8.2.
+ """
+ if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] == 'django.db.backends.sqlite3':
+ return False
+
+ class StdDevPop(object):
+ sql_function = 'STDDEV_POP'
+
+ try:
+ connection.ops.check_aggregate_support(StdDevPop())
+ except:
+ return False
+ return True
+
+
class AggregationTests(TestCase):
+ def assertObjectAttrs(self, obj, **kwargs):
+ for attr, value in kwargs.iteritems():
+ self.assertEqual(getattr(obj, attr), value)
def test_aggregates_in_where_clause(self):
"""
@@ -70,3 +96,587 @@ def test_annotate_with_extra(self):
}).annotate(total_books=Count('book'))
# force execution of the query
list(qs)
+
+ def test_aggregate(self):
+ # Ordering requests are ignored
+ self.assertEqual(
+ Author.objects.order_by("name").aggregate(Avg("age")),
+ {"age__avg": Approximate(37.444, places=1)}
+ )
+
+ # Implicit ordering is also ignored
+ self.assertEqual(
+ Book.objects.aggregate(Sum("pages")),
+ {"pages__sum": 3703},
+ )
+
+ # Baseline results
+ self.assertEqual(
+ Book.objects.aggregate(Sum('pages'), Avg('pages')),
+ {'pages__sum': 3703, 'pages__avg': Approximate(617.166, places=2)}
+ )
+
+ # Empty values query doesn't affect grouping or results
+ self.assertEqual(
+ Book.objects.values().aggregate(Sum('pages'), Avg('pages')),
+ {'pages__sum': 3703, 'pages__avg': Approximate(617.166, places=2)}
+ )
+
+ # Aggregate overrides extra selected column
+ self.assertEqual(
+ Book.objects.extra(select={'price_per_page' : 'price / pages'}).aggregate(Sum('pages')),
+ {'pages__sum': 3703}
+ )
+
+ def test_annotation(self):
+ # Annotations get combined with extra select clauses
+ obj = Book.objects.annotate(mean_auth_age=Avg("authors__age")).extra(select={"manufacture_cost": "price * .5"}).get(pk=2)
+ self.assertObjectAttrs(obj,
+ contact_id=3,
+ id=2,
+ isbn=u'067232959',
+ manufacture_cost=11.545,
+ mean_auth_age=45.0,
+ name='Sams Teach Yourself Django in 24 Hours',
+ pages=528,
+ price=Decimal("23.09"),
+ pubdate=datetime.date(2008, 3, 3),
+ publisher_id=2,
+ rating=3.0
+ )
+
+ # Order of the annotate/extra in the query doesn't matter
+ obj = Book.objects.extra(select={'manufacture_cost' : 'price * .5'}).annotate(mean_auth_age=Avg('authors__age')).get(pk=2)
+ self.assertObjectAttrs(obj,
+ contact_id=3,
+ id=2,
+ isbn=u'067232959',
+ manufacture_cost=11.545,
+ mean_auth_age=45.0,
+ name=u'Sams Teach Yourself Django in 24 Hours',
+ pages=528,
+ price=Decimal("23.09"),
+ pubdate=datetime.date(2008, 3, 3),
+ publisher_id=2,
+ rating=3.0
+ )
+
+ # Values queries can be combined with annotate and extra
+ obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).values().get(pk=2)
+ self.assertEqual(obj, {
+ "contact_id": 3,
+ "id": 2,
+ "isbn": u"067232959",
+ "manufacture_cost": 11.545,
+ "mean_auth_age": 45.0,
+ "name": u"Sams Teach Yourself Django in 24 Hours",
+ "pages": 528,
+ "price": Decimal("23.09"),
+ "pubdate": datetime.date(2008, 3, 3),
+ "publisher_id": 2,
+ "rating": 3.0,
+ })
+
+ # The order of the (empty) values, annotate and extra clauses doesn't
+ # matter
+ obj = Book.objects.values().annotate(mean_auth_age=Avg('authors__age')).extra(select={'manufacture_cost' : 'price * .5'}).get(pk=2)
+ self.assertEqual(obj, {
+ 'contact_id': 3,
+ 'id': 2,
+ 'isbn': u'067232959',
+ 'manufacture_cost': 11.545,
+ 'mean_auth_age': 45.0,
+ 'name': u'Sams Teach Yourself Django in 24 Hours',
+ 'pages': 528,
+ 'price': Decimal("23.09"),
+ 'pubdate': datetime.date(2008, 3, 3),
+ 'publisher_id': 2,
+ 'rating': 3.0
+ })
+
+ # If the annotation precedes the values clause, it won't be included
+ # unless it is explicitly named
+ obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name').get(pk=1)
+ self.assertEqual(obj, {
+ "name": u'The Definitive Guide to Django: Web Development Done Right',
+ })
+
+ obj = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).values('name','mean_auth_age').get(pk=1)
+ self.assertEqual(obj, {
+ 'mean_auth_age': 34.5,
+ 'name': u'The Definitive Guide to Django: Web Development Done Right',
+ })
+
+ # If an annotation isn't included in the values, it can still be used
+ # in a filter
+ qs = Book.objects.annotate(n_authors=Count('authors')).values('name').filter(n_authors__gt=2)
+ self.assertQuerysetEqual(
+ qs, [
+ {"name": u'Python Web Development with Django'}
+ ],
+ lambda b: b,
+ )
+
+ # The annotations are added to values output if values() precedes
+ # annotate()
+ obj = Book.objects.values('name').annotate(mean_auth_age=Avg('authors__age')).extra(select={'price_per_page' : 'price / pages'}).get(pk=1)
+ self.assertEqual(obj, {
+ 'mean_auth_age': 34.5,
+ 'name': u'The Definitive Guide to Django: Web Development Done Right',
+ })
+
+ # Check that all of the objects are getting counted (allow_nulls) and
+ # that values respects the amount of objects
+ self.assertEqual(
+ len(Author.objects.annotate(Avg('friends__age')).values()),
+ 9
+ )
+
+ # Check that consecutive calls to annotate accumulate in the query
+ qs = Book.objects.values('price').annotate(oldest=Max('authors__age')).order_by('oldest', 'price').annotate(Max('publisher__num_awards'))
+ self.assertQuerysetEqual(
+ qs, [
+ {'price': Decimal("30"), 'oldest': 35, 'publisher__num_awards__max': 3},
+ {'price': Decimal("29.69"), 'oldest': 37, 'publisher__num_awards__max': 7},
+ {'price': Decimal("23.09"), 'oldest': 45, 'publisher__num_awards__max': 1},
+ {'price': Decimal("75"), 'oldest': 57, 'publisher__num_awards__max': 9},
+ {'price': Decimal("82.8"), 'oldest': 57, 'publisher__num_awards__max': 7}
+ ],
+ lambda b: b,
+ )
+
+ def test_aggrate_annotation(self):
+ # Aggregates can be composed over annotations.
+ # The return type is derived from the composed aggregate
+ vals = Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('pages'), Max('price'), Sum('num_authors'), Avg('num_authors'))
+ self.assertEqual(vals, {
+ 'num_authors__sum': 10,
+ 'num_authors__avg': Approximate(1.666, places=2),
+ 'pages__max': 1132,
+ 'price__max': Decimal("82.80")
+ })
+
+ def test_field_error(self):
+ # Bad field requests in aggregates are caught and reported
+ self.assertRaises(
+ FieldError,
+ lambda: Book.objects.all().aggregate(num_authors=Count('foo'))
+ )
+
+ self.assertRaises(
+ FieldError,
+ lambda: Book.objects.all().annotate(num_authors=Count('foo'))
+ )
+
+ self.assertRaises(
+ FieldError,
+ lambda: Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Max('foo'))
+ )
+
+ def test_more(self):
+ # Old-style count aggregations can be mixed with new-style
+ self.assertEqual(
+ Book.objects.annotate(num_authors=Count('authors')).count(),
+ 6
+ )
+
+ # Non-ordinal, non-computed Aggregates over annotations correctly
+ # inherit the annotation's internal type if the annotation is ordinal
+ # or computed
+ vals = Book.objects.annotate(num_authors=Count('authors')).aggregate(Max('num_authors'))
+ self.assertEqual(
+ vals,
+ {'num_authors__max': 3}
+ )
+
+ vals = Publisher.objects.annotate(avg_price=Avg('book__price')).aggregate(Max('avg_price'))
+ self.assertEqual(
+ vals,
+ {'avg_price__max': 75.0}
+ )
+
+ # Aliases are quoted to protected aliases that might be reserved names
+ vals = Book.objects.aggregate(number=Max('pages'), select=Max('pages'))
+ self.assertEqual(
+ vals,
+ {'number': 1132, 'select': 1132}
+ )
+
+ # Regression for #10064: select_related() plays nice with aggregates
+ obj = Book.objects.select_related('publisher').annotate(num_authors=Count('authors')).values()[0]
+ self.assertEqual(obj, {
+ 'contact_id': 8,
+ 'id': 5,
+ 'isbn': u'013790395',
+ 'name': u'Artificial Intelligence: A Modern Approach',
+ 'num_authors': 2,
+ 'pages': 1132,
+ 'price': Decimal("82.8"),
+ 'pubdate': datetime.date(1995, 1, 15),
+ 'publisher_id': 3,
+ 'rating': 4.0,
+ })
+
+ # Regression for #10010: exclude on an aggregate field is correctly
+ # negated
+ self.assertEqual(
+ len(Book.objects.annotate(num_authors=Count('authors'))),
+ 6
+ )
+ self.assertEqual(
+ len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=2)),
+ 1
+ )
+ self.assertEqual(
+ len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__gt=2)),
+ 5
+ )
+
+ self.assertEqual(
+ len(Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__lt=3).exclude(num_authors__lt=2)),
+ 2
+ )
+ self.assertEqual(
+ len(Book.objects.annotate(num_authors=Count('authors')).exclude(num_authors__lt=2).filter(num_authors__lt=3)),
+ 2
+ )
+
+ def test_aggregate_fexpr(self):
+ # Aggregates can be used with F() expressions
+ # ... where the F() is pushed into the HAVING clause
+ qs = Publisher.objects.annotate(num_books=Count('book')).filter(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+ self.assertQuerysetEqual(
+ qs, [
+ {'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9},
+ {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}
+ ],
+ lambda p: p,
+ )
+
+ qs = Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+ self.assertQuerysetEqual(
+ qs, [
+ {'num_books': 2, 'name': u'Apress', 'num_awards': 3},
+ {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0},
+ {'num_books': 1, 'name': u'Sams', 'num_awards': 1}
+ ],
+ lambda p: p,
+ )
+
+ # ... and where the F() references an aggregate
+ qs = Publisher.objects.annotate(num_books=Count('book')).filter(num_awards__gt=2*F('num_books')).order_by('name').values('name','num_books','num_awards')
+ self.assertQuerysetEqual(
+ qs, [
+ {'num_books': 1, 'name': u'Morgan Kaufmann', 'num_awards': 9},
+ {'num_books': 2, 'name': u'Prentice Hall', 'num_awards': 7}
+ ],
+ lambda p: p,
+ )
+
+ qs = Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards')/2).order_by('name').values('name','num_books','num_awards')
+ self.assertQuerysetEqual(
+ qs, [
+ {'num_books': 2, 'name': u'Apress', 'num_awards': 3},
+ {'num_books': 0, 'name': u"Jonno's House of Books", 'num_awards': 0},
+ {'num_books': 1, 'name': u'Sams', 'num_awards': 1}
+ ],
+ lambda p: p,
+ )
+
+ def test_db_col_table(self):
+ # Tests on fields with non-default table and column names.
+ qs = Clues.objects.values('EntryID__Entry').annotate(Appearances=Count('EntryID'), Distinct_Clues=Count('Clue', distinct=True))
+ self.assertQuerysetEqual(qs, [])
+
+ qs = Entries.objects.annotate(clue_count=Count('clues__ID'))
+ self.assertQuerysetEqual(qs, [])
+
+ def test_empty(self):
+ # Regression for #10089: Check handling of empty result sets with
+ # aggregates
+ self.assertEqual(
+ Book.objects.filter(id__in=[]).count(),
+ 0
+ )
+
+ vals = Book.objects.filter(id__in=[]).aggregate(num_authors=Count('authors'), avg_authors=Avg('authors'), max_authors=Max('authors'), max_price=Max('price'), max_rating=Max('rating'))
+ self.assertEqual(
+ vals,
+ {'max_authors': None, 'max_rating': None, 'num_authors': 0, 'avg_authors': None, 'max_price': None}
+ )
+
+ qs = Publisher.objects.filter(pk=5).annotate(num_authors=Count('book__authors'), avg_authors=Avg('book__authors'), max_authors=Max('book__authors'), max_price=Max('book__price'), max_rating=Max('book__rating')).values()
+ self.assertQuerysetEqual(
+ qs, [
+ {'max_authors': None, 'name': u"Jonno's House of Books", 'num_awards': 0, 'max_price': None, 'num_authors': 0, 'max_rating': None, 'id': 5, 'avg_authors': None}
+ ],
+ lambda p: p
+ )
+
+ def test_more_more(self):
+ # Regression for #10113 - Fields mentioned in order_by() must be
+ # included in the GROUP BY. This only becomes a problem when the
+ # order_by introduces a new join.
+ self.assertQuerysetEqual(
+ Book.objects.annotate(num_authors=Count('authors')).order_by('publisher__name', 'name'), [
+ "Practical Django Projects",
+ "The Definitive Guide to Django: Web Development Done Right",
+ "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp",
+ "Artificial Intelligence: A Modern Approach",
+ "Python Web Development with Django",
+ "Sams Teach Yourself Django in 24 Hours",
+ ],
+ lambda b: b.name
+ )
+
+ # Regression for #10127 - Empty select_related() works with annotate
+ qs = Book.objects.filter(rating__lt=4.5).select_related().annotate(Avg('authors__age'))
+ self.assertQuerysetEqual(
+ qs, [
+ (u'Artificial Intelligence: A Modern Approach', 51.5, u'Prentice Hall', u'Peter Norvig'),
+ (u'Practical Django Projects', 29.0, u'Apress', u'James Bennett'),
+ (u'Python Web Development with Django', Approximate(30.333, places=2), u'Prentice Hall', u'Jeffrey Forcier'),
+ (u'Sams Teach Yourself Django in 24 Hours', 45.0, u'Sams', u'Brad Dayley')
+ ],
+ lambda b: (b.name, b.authors__age__avg, b.publisher.name, b.contact.name)
+ )
+
+ # Regression for #10132 - If the values() clause only mentioned extra
+ # (select=) columns, those columns are used for grouping
+ qs = Book.objects.extra(select={'pub':'publisher_id'}).values('pub').annotate(Count('id')).order_by('pub')
+ self.assertQuerysetEqual(
+ qs, [
+ {'pub': 1, 'id__count': 2},
+ {'pub': 2, 'id__count': 1},
+ {'pub': 3, 'id__count': 2},
+ {'pub': 4, 'id__count': 1}
+ ],
+ lambda b: b
+ )
+
+ qs = Book.objects.extra(select={'pub':'publisher_id', 'foo':'pages'}).values('pub').annotate(Count('id')).order_by('pub')
+ self.assertQuerysetEqual(
+ qs, [
+ {'pub': 1, 'id__count': 2},
+ {'pub': 2, 'id__count': 1},
+ {'pub': 3, 'id__count': 2},
+ {'pub': 4, 'id__count': 1}
+ ],
+ lambda b: b
+ )
+
+ # Regression for #10182 - Queries with aggregate calls are correctly
+ # realiased when used in a subquery
+ ids = Book.objects.filter(pages__gt=100).annotate(n_authors=Count('authors')).filter(n_authors__gt=2).order_by('n_authors')
+ self.assertQuerysetEqual(
+ Book.objects.filter(id__in=ids), [
+ "Python Web Development with Django",
+ ],
+ lambda b: b.name
+ )
+
+ def test_pickle(self):
+ # Regression for #10197 -- Queries with aggregates can be pickled.
+ # First check that pickling is possible at all. No crash = success
+ qs = Book.objects.annotate(num_authors=Count('authors'))
+ out = pickle.dumps(qs)
+
+ # Then check that the round trip works.
+ query = qs.query.get_compiler(qs.db).as_sql()[0]
+ qs2 = pickle.loads(pickle.dumps(qs))
+ self.assertEqual(
+ qs2.query.get_compiler(qs2.db).as_sql()[0],
+ query,
+ )
+
+ def test_more_more_more(self):
+ # Regression for #10199 - Aggregate calls clone the original query so
+ # the original query can still be used
+ books = Book.objects.all()
+ books.aggregate(Avg("authors__age"))
+ self.assertQuerysetEqual(
+ books.all(), [
+ u'Artificial Intelligence: A Modern Approach',
+ u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp',
+ u'Practical Django Projects',
+ u'Python Web Development with Django',
+ u'Sams Teach Yourself Django in 24 Hours',
+ u'The Definitive Guide to Django: Web Development Done Right'
+ ],
+ lambda b: b.name
+ )
+
+ # Regression for #10248 - Annotations work with DateQuerySets
+ qs = Book.objects.annotate(num_authors=Count('authors')).filter(num_authors=2).dates('pubdate', 'day')
+ self.assertQuerysetEqual(
+ qs, [
+ datetime.datetime(1995, 1, 15, 0, 0),
+ datetime.datetime(2007, 12, 6, 0, 0)
+ ],
+ lambda b: b
+ )
+
+ # Regression for #10290 - extra selects with parameters can be used for
+ # grouping.
+ qs = Book.objects.annotate(mean_auth_age=Avg('authors__age')).extra(select={'sheets' : '(pages + %s) / %s'}, select_params=[1, 2]).order_by('sheets').values('sheets')
+ self.assertQuerysetEqual(
+ qs, [
+ 150,
+ 175,
+ 224,
+ 264,
+ 473,
+ 566
+ ],
+ lambda b: int(b["sheets"])
+ )
+
+ # Regression for 10425 - annotations don't get in the way of a count()
+ # clause
+ self.assertEqual(
+ Book.objects.values('publisher').annotate(Count('publisher')).count(),
+ 4
+ )
+ self.assertEqual(
+ Book.objects.annotate(Count('publisher')).values('publisher').count(),
+ 6
+ )
+
+ publishers = Publisher.objects.filter(id__in=[1, 2])
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Sams"
+ ],
+ lambda p: p.name
+ )
+
+ publishers = publishers.annotate(n_books=Count("book"))
+ self.assertEqual(
+ publishers[0].n_books,
+ 2
+ )
+
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Sams",
+ ],
+ lambda p: p.name
+ )
+
+ books = Book.objects.filter(publisher__in=publishers)
+ self.assertQuerysetEqual(
+ books, [
+ "Practical Django Projects",
+ "Sams Teach Yourself Django in 24 Hours",
+ "The Definitive Guide to Django: Web Development Done Right",
+ ],
+ lambda b: b.name
+ )
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Sams",
+ ],
+ lambda p: p.name
+ )
+
+ # Regression for 10666 - inherited fields work with annotations and
+ # aggregations
+ self.assertEqual(
+ HardbackBook.objects.aggregate(n_pages=Sum('book_ptr__pages')),
+ {'n_pages': 2078}
+ )
+
+ self.assertEqual(
+ HardbackBook.objects.aggregate(n_pages=Sum('pages')),
+ {'n_pages': 2078},
+ )
+
+ qs = HardbackBook.objects.annotate(n_authors=Count('book_ptr__authors')).values('name', 'n_authors')
+ self.assertQuerysetEqual(
+ qs, [
+ {'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'},
+ {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}
+ ],
+ lambda h: h
+ )
+
+ qs = HardbackBook.objects.annotate(n_authors=Count('authors')).values('name', 'n_authors')
+ self.assertQuerysetEqual(
+ qs, [
+ {'n_authors': 2, 'name': u'Artificial Intelligence: A Modern Approach'},
+ {'n_authors': 1, 'name': u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp'}
+ ],
+ lambda h: h,
+ )
+
+ # Regression for #10766 - Shouldn't be able to reference an aggregate
+ # fields in an an aggregate() call.
+ self.assertRaises(
+ FieldError,
+ lambda: Book.objects.annotate(mean_age=Avg('authors__age')).annotate(Avg('mean_age'))
+ )
+
+ if run_stddev_tests():
+ def test_stddev(self):
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('pages')),
+ {'pages__stddev': 311.46}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('rating')),
+ {'rating__stddev': 0.60}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('price')),
+ {'price__stddev': 24.16}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('pages', sample=True)),
+ {'pages__stddev': 341.19}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('rating', sample=True)),
+ {'rating__stddev': 0.66}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(StdDev('price', sample=True)),
+ {'price__stddev': 26.46}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('pages')),
+ {'pages__variance': 97010.80}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('rating')),
+ {'rating__variance': 0.36}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('price')),
+ {'price__variance': 583.77}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('pages', sample=True)),
+ {'pages__variance': 116412.96}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('rating', sample=True)),
+ {'rating__variance': 0.44}
+ )
+
+ self.assertEqual(
+ Book.objects.aggregate(Variance('price', sample=True)),
+ {'price__variance': 700.53}
+ )
Please sign in to comment.
Something went wrong with that request. Please try again.