Author: russellm
Date: 2010-05-28 06:15:36 -0500 (Fri, 28 May 2010)
New Revision: 13309
Added:
django/trunk/tests/modeltests/aggregation/tests.py
Modified:
django/trunk/django/test/testcases.py
django/trunk/docs/topics/testing.txt
django/trunk/tests/modeltests/aggregation/models.py
Log:
Fixed #13634 -- Migrated aggregation tests to use unittest. This removes a
flush, which speeds up the tests overall.
Modified: django/trunk/django/test/testcases.py
===================================================================
--- django/trunk/django/test/testcases.py 2010-05-28 09:52:24 UTC (rev
13308)
+++ django/trunk/django/test/testcases.py 2010-05-28 11:15:36 UTC (rev
13309)
@@ -466,6 +466,9 @@
msg_prefix + "Template '%s' was used unexpectedly in rendering"
" the response" % template_name)
+ def assertQuerysetEqual(self, qs, values, transform=repr):
+ return self.assertEqual(map(transform, qs), values)
+
def connections_support_transactions():
"""
Returns True if all connections support transactions. This is messy
Modified: django/trunk/docs/topics/testing.txt
===================================================================
--- django/trunk/docs/topics/testing.txt 2010-05-28 09:52:24 UTC (rev
13308)
+++ django/trunk/docs/topics/testing.txt 2010-05-28 11:15:36 UTC (rev
13309)
@@ -1248,6 +1248,19 @@
``target_status_code`` will be the url and status code for the final
point of the redirect chain.
+.. method:: TestCase.assertQuerysetEqual(response, qs, values, transform=repr)
+
+ Asserts that a queryset ``qs`` returns a particular list of values
``values``.
+
+ The comparison of the contents of ``qs`` and ``values`` is performed using
+ the function ``transform``; by default, this means that the ``repr()`` of
+ each value is compared. Any other callable can be used if ``repr()``
doesn't
+ provide a unique or helpful comparison.
+
+ The comparison is also ordering dependent. If ``qs`` doesn't provide an
+ implicit ordering, you will need to apply a ``order_by()`` clause to your
+ queryset to ensure that the test will pass reliably.
+
.. _topics-testing-email:
E-mail services
Modified: django/trunk/tests/modeltests/aggregation/models.py
===================================================================
--- django/trunk/tests/modeltests/aggregation/models.py 2010-05-28 09:52:24 UTC
(rev 13308)
+++ django/trunk/tests/modeltests/aggregation/models.py 2010-05-28 11:15:36 UTC
(rev 13309)
@@ -1,6 +1,7 @@
# coding: utf-8
from django.db import models
+
class Author(models.Model):
name = models.CharField(max_length=100)
age = models.IntegerField()
@@ -39,323 +40,3 @@
def __unicode__(self):
return self.name
-# Tests on 'aggregate'
-# Different backends and numbers.
-__test__ = {'API_TESTS': """
->>> from django.core import management
->>> from decimal import Decimal
->>> from datetime import date
-
-# 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)
-
-# Empty Call - request nothing, get nothing.
->>> Author.objects.all().aggregate()
-{}
-
->>> from django.db.models import Avg, Sum, Count, Max, Min
-
-# Single model aggregation
-#
-
-# Single aggregate
-# Average age of Authors
->>> Author.objects.all().aggregate(Avg('age'))
-{'age__avg': 37.4...}
-
-# Multiple aggregates
-# Average and Sum of Author ages
->>> Author.objects.all().aggregate(Sum('age'), Avg('age'))
-{'age__sum': 337, 'age__avg': 37.4...}
-
-# Aggreates interact with filters, and only
-# generate aggregate values for the filtered values
-# Sum of the age of those older than 29 years old
->>> Author.objects.all().filter(age__gt=29).aggregate(Sum('age'))
-{'age__sum': 254}
-
-# Depth-1 Joins
-#
-
-# On Relationships with self
-# Average age of the friends of each author
->>> Author.objects.all().aggregate(Avg('friends__age'))
-{'friends__age__avg': 34.07...}
-
-# On ManyToMany Relationships
-#
-
-# Forward
-# Average age of the Authors of Books with a rating of less than 4.5
->>> Book.objects.all().filter(rating__lt=4.5).aggregate(Avg('authors__age'))
-{'authors__age__avg': 38.2...}
-
-# Backward
-# Average rating of the Books whose Author's name contains the letter 'a'
->>>
Author.objects.all().filter(name__contains='a').aggregate(Avg('book__rating'))
-{'book__rating__avg': 4.0}
-
-# On OneToMany Relationships
-#
-
-# Forward
-# Sum of the number of awards of each Book's Publisher
->>> Book.objects.all().aggregate(Sum('publisher__num_awards'))
-{'publisher__num_awards__sum': 30}
-
-# Backward
-# Sum of the price of every Book that has a Publisher
->>> Publisher.objects.all().aggregate(Sum('book__price'))
-{'book__price__sum': Decimal("270.27")}
-
-# Multiple Joins
-#
-
-# Forward
->>> Store.objects.all().aggregate(Max('books__authors__age'))
-{'books__authors__age__max': 57}
-
-# Backward
-# Note that the very long default alias may be truncated
->>> Author.objects.all().aggregate(Min('book__publisher__num_awards'))
-{'book__publisher__num_award...': 1}
-
-# Aggregate outputs can also be aliased.
-
-# Average amazon.com Book rating
->>>
Store.objects.filter(name='Amazon.com').aggregate(amazon_mean=Avg('books__rating'))
-{'amazon_mean': 4.08...}
-
-# Tests on annotate()
-
-# An empty annotate call does nothing but return the same QuerySet
->>> Book.objects.all().annotate().order_by('pk')
-[<Book: The Definitive Guide to Django: Web Development Done Right>, <Book:
Sams Teach Yourself Django in 24 Hours>, <Book: Practical Django Projects>,
<Book: Python Web Development with Django>, <Book: Artificial Intelligence: A
Modern Approach>, <Book: Paradigms of Artificial Intelligence Programming: Case
Studies in Common Lisp>]
-
-# Annotate inserts the alias into the model object with the aggregated result
->>> books = Book.objects.all().annotate(mean_age=Avg('authors__age'))
->>> books.get(pk=1).name
-u'The Definitive Guide to Django: Web Development Done Right'
-
->>> books.get(pk=1).mean_age
-34.5
-
-# On ManyToMany Relationships
-
-# Forward
-# Average age of the Authors of each book with a rating less than 4.5
->>> books =
Book.objects.all().filter(rating__lt=4.5).annotate(Avg('authors__age'))
->>> sorted([(b.name, b.authors__age__avg) for b in books])
-[(u'Artificial Intelligence: A Modern Approach', 51.5), (u'Practical Django
Projects', 29.0), (u'Python Web Development with Django', 30.3...), (u'Sams
Teach Yourself Django in 24 Hours', 45.0)]
-
-# Count the number of authors of each book
->>> books = Book.objects.annotate(num_authors=Count('authors'))
->>> sorted([(b.name, b.num_authors) for b in books])
-[(u'Artificial Intelligence: A Modern Approach', 2), (u'Paradigms of
Artificial Intelligence Programming: Case Studies in Common Lisp', 1),
(u'Practical Django Projects', 1), (u'Python Web Development with Django', 3),
(u'Sams Teach Yourself Django in 24 Hours', 1), (u'The Definitive Guide to
Django: Web Development Done Right', 2)]
-
-# Backward
-# Average rating of the Books whose Author's names contains the letter 'a'
->>> authors =
Author.objects.all().filter(name__contains='a').annotate(Avg('book__rating'))
->>> sorted([(a.name, a.book__rating__avg) for a in authors])
-[(u'Adrian Holovaty', 4.5), (u'Brad Dayley', 3.0), (u'Jacob Kaplan-Moss',
4.5), (u'James Bennett', 4.0), (u'Paul Bissex', 4.0), (u'Stuart Russell', 4.0)]
-
-# Count the number of books written by each author
->>> authors = Author.objects.annotate(num_books=Count('book'))
->>> sorted([(a.name, a.num_books) for a in authors])
-[(u'Adrian Holovaty', 1), (u'Brad Dayley', 1), (u'Jacob Kaplan-Moss', 1),
(u'James Bennett', 1), (u'Jeffrey Forcier', 1), (u'Paul Bissex', 1), (u'Peter
Norvig', 2), (u'Stuart Russell', 1), (u'Wesley J. Chun', 1)]
-
-# On OneToMany Relationships
-
-# Forward
-# Annotate each book with the number of awards of each Book's Publisher
->>> books = Book.objects.all().annotate(Sum('publisher__num_awards'))
->>> sorted([(b.name, b.publisher__num_awards__sum) for b in books])
-[(u'Artificial Intelligence: A Modern Approach', 7), (u'Paradigms of
Artificial Intelligence Programming: Case Studies in Common Lisp', 9),
(u'Practical Django Projects', 3), (u'Python Web Development with Django', 7),
(u'Sams Teach Yourself Django in 24 Hours', 1), (u'The Definitive Guide to
Django: Web Development Done Right', 3)]
-
-# Backward
-# Annotate each publisher with the sum of the price of all books sold
->>> publishers = Publisher.objects.all().annotate(Sum('book__price'))
->>> sorted([(p.name, p.book__price__sum) for p in publishers])
-[(u'Apress', Decimal("59.69")), (u"Jonno's House of Books", None), (u'Morgan
Kaufmann', Decimal("75.00")), (u'Prentice Hall', Decimal("112.49")), (u'Sams',
Decimal("23.09"))]
-
-# Calls to values() are not commutative over annotate().
-
-# Calling values on a queryset that has annotations returns the output
-# as a dictionary
->>> [sorted(o.iteritems()) for o in
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values()]
-[[('contact_id', 1), ('id', 1), ('isbn', u'159059725'), ('mean_age', 34.5),
('name', u'The Definitive Guide to Django: Web Development Done Right'),
('pages', 447), ('price', Decimal("30...")), ('pubdate', datetime.date(2007,
12, 6)), ('publisher_id', 1), ('rating', 4.5)]]
-
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('pk',
'isbn', 'mean_age')
-[{'pk': 1, 'isbn': u'159059725', 'mean_age': 34.5}]
-
-# Calling values() with parameters reduces the output
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('name')
-[{'name': u'The Definitive Guide to Django: Web Development Done Right'}]
-
-# An empty values() call before annotating has the same effect as an
-# empty values() call after annotating
->>> [sorted(o.iteritems()) for o in
Book.objects.filter(pk=1).values().annotate(mean_age=Avg('authors__age'))]
-[[('contact_id', 1), ('id', 1), ('isbn', u'159059725'), ('mean_age', 34.5),
('name', u'The Definitive Guide to Django: Web Development Done Right'),
('pages', 447), ('price', Decimal("30...")), ('pubdate', datetime.date(2007,
12, 6)), ('publisher_id', 1), ('rating', 4.5)]]
-
-# Calling annotate() on a ValuesQuerySet annotates over the groups of
-# fields to be selected by the ValuesQuerySet.
-
-# Note that an extra parameter is added to each dictionary. This
-# parameter is a queryset representing the objects that have been
-# grouped to generate the annotation
-
->>>
Book.objects.all().values('rating').annotate(n_authors=Count('authors__id'),
mean_age=Avg('authors__age')).order_by('rating')
-[{'rating': 3.0, 'n_authors': 1, 'mean_age': 45.0}, {'rating': 4.0,
'n_authors': 6, 'mean_age': 37.1...}, {'rating': 4.5, 'n_authors': 2,
'mean_age': 34.5}, {'rating': 5.0, 'n_authors': 1, 'mean_age': 57.0}]
-
-# If a join doesn't match any objects, an aggregate returns None
->>> authors = Author.objects.all().annotate(Avg('friends__age')).order_by('id')
->>> len(authors)
-9
->>> sorted([(a.name, a.friends__age__avg) for a in authors])
-[(u'Adrian Holovaty', 32.0), (u'Brad Dayley', None), (u'Jacob Kaplan-Moss',
29.5), (u'James Bennett', 34.0), (u'Jeffrey Forcier', 27.0), (u'Paul Bissex',
31.0), (u'Peter Norvig', 46.0), (u'Stuart Russell', 57.0), (u'Wesley J. Chun',
33.6...)]
-
-
-# The Count aggregation function allows an extra parameter: distinct.
-# This restricts the count results to unique items
->>> Book.objects.all().aggregate(Count('rating'))
-{'rating__count': 6}
-
->>> Book.objects.all().aggregate(Count('rating', distinct=True))
-{'rating__count': 4}
-
-# Retreiving the grouped objects
-
-# When using Count you can also omit the primary key and refer only to
-# the related field name if you want to count all the related objects
-# and not a specific column
->>> explicit = list(Author.objects.annotate(Count('book__id')))
->>> implicit = list(Author.objects.annotate(Count('book')))
->>> explicit == implicit
-True
-
-# Ordering is allowed on aggregates
->>>
Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('oldest',
'rating')
-[{'rating': 4.5, 'oldest': 35}, {'rating': 3.0, 'oldest': 45}, {'rating': 4.0,
'oldest': 57}, {'rating': 5.0, 'oldest': 57}]
-
->>>
Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('-oldest',
'-rating')
-[{'rating': 5.0, 'oldest': 57}, {'rating': 4.0, 'oldest': 57}, {'rating': 3.0,
'oldest': 45}, {'rating': 4.5, 'oldest': 35}]
-
-# It is possible to aggregate over anotated values
->>>
Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Avg('num_authors'))
-{'num_authors__avg': 1.66...}
-
-# You can filter the results based on the aggregation alias.
-
-# Lets add a publisher to test the different possibilities for filtering
->>> p = Publisher(name='Expensive Publisher', num_awards=0)
->>> p.save()
->>> Book(name='ExpensiveBook1', pages=1, isbn='111', rating=3.5,
price=Decimal("1000"), publisher=p, contact_id=1,
pubdate=date(2008,12,1)).save()
->>> Book(name='ExpensiveBook2', pages=1, isbn='222', rating=4.0,
price=Decimal("1000"), publisher=p, contact_id=1,
pubdate=date(2008,12,2)).save()
->>> Book(name='ExpensiveBook3', pages=1, isbn='333', rating=4.5,
price=Decimal("35"), publisher=p, contact_id=1, pubdate=date(2008,12,3)).save()
-
-# Publishers that have:
-
-# (i) more than one book
->>>
Publisher.objects.annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
-[<Publisher: Apress>, <Publisher: Prentice Hall>, <Publisher: Expensive
Publisher>]
-
-# (ii) a book that cost less than 40
->>> Publisher.objects.filter(book__price__lt=Decimal("40.0")).order_by('pk')
-[<Publisher: Apress>, <Publisher: Apress>, <Publisher: Sams>, <Publisher:
Prentice Hall>, <Publisher: Expensive Publisher>]
-
-# (iii) more than one book and (at least) a book that cost less than 40
->>>
Publisher.objects.annotate(num_books=Count('book__id')).filter(num_books__gt=1,
book__price__lt=Decimal("40.0")).order_by('pk')
-[<Publisher: Apress>, <Publisher: Prentice Hall>, <Publisher: Expensive
Publisher>]
-
-# (iv) more than one book that costs less than $40
->>>
Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
-[<Publisher: Apress>]
-
-# Now a bit of testing on the different lookup types
-#
-
->>>
Publisher.objects.annotate(num_books=Count('book')).filter(num_books__range=[1,
3]).order_by('pk')
-[<Publisher: Apress>, <Publisher: Sams>, <Publisher: Prentice Hall>,
<Publisher: Morgan Kaufmann>, <Publisher: Expensive Publisher>]
-
->>>
Publisher.objects.annotate(num_books=Count('book')).filter(num_books__range=[1,
2]).order_by('pk')
-[<Publisher: Apress>, <Publisher: Sams>, <Publisher: Prentice Hall>,
<Publisher: Morgan Kaufmann>]
-
->>>
Publisher.objects.annotate(num_books=Count('book')).filter(num_books__in=[1,
3]).order_by('pk')
-[<Publisher: Sams>, <Publisher: Morgan Kaufmann>, <Publisher: Expensive
Publisher>]
-
->>>
Publisher.objects.annotate(num_books=Count('book')).filter(num_books__isnull=True)
-[]
-
->>> p.delete()
-
-# Does Author X have any friends? (or better, how many friends does author X
have)
->> Author.objects.filter(pk=1).aggregate(Count('friends__id'))
-{'friends__id__count': 2.0}
-
-# Give me a list of all Books with more than 1 authors
->>>
Book.objects.all().annotate(num_authors=Count('authors__name')).filter(num_authors__ge=2).order_by('pk')
-[<Book: The Definitive Guide to Django: Web Development Done Right>, <Book:
Artificial Intelligence: A Modern Approach>]
-
-# Give me a list of all Authors that have no friends
->>> Author.objects.all().annotate(num_friends=Count('friends__id',
distinct=True)).filter(num_friends=0).order_by('pk')
-[<Author: Brad Dayley>]
-
-# Give me a list of all publishers that have published more than 1 books
->>>
Publisher.objects.all().annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
-[<Publisher: Apress>, <Publisher: Prentice Hall>]
-
-# Give me a list of all publishers that have published more than 1 books that
cost less than 40
->>>
Publisher.objects.all().filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count('book__id')).filter(num_books__gt=1)
-[<Publisher: Apress>]
-
-# Give me a list of all Books that were written by X and one other author.
->>>
Book.objects.all().annotate(num_authors=Count('authors__id')).filter(authors__name__contains='Norvig',
num_authors__gt=1)
-[<Book: Artificial Intelligence: A Modern Approach>]
-
-# Give me the average rating of all Books that were written by X and one other
author.
-#(Aggregate over objects discovered using membership of the m2m set)
-
-# Adding an existing author to another book to test it the right way
->>> a = Author.objects.get(name__contains='Norvig')
->>> b = Book.objects.get(name__contains='Done Right')
->>> b.authors.add(a)
->>> b.save()
-
-# This should do it
->>>
Book.objects.all().annotate(num_authors=Count('authors__id')).filter(authors__name__contains='Norvig',
num_authors__gt=1).aggregate(Avg('rating'))
-{'rating__avg': 4.25}
->>> b.authors.remove(a)
-
-# Give me a list of all Authors that have published a book with at least one
other person
-# (Filters over a count generated on a related object)
-#
-# Cheating: [a for a in
Author.objects.all().annotate(num_coleagues=Count('book__authors__id'),
num_books=Count('book__id', distinct=True)) if a.num_coleagues - a.num_books >
0]
-# F-Syntax is required. Will be fixed after F objects are available
-
-# Aggregates also work on dates, times and datetimes
->>>
Publisher.objects.annotate(earliest_book=Min('book__pubdate')).exclude(earliest_book=None).order_by('earliest_book').values()
-[{'earliest_book': datetime.date(1991, 10, 15), 'num_awards': 9, 'id': 4,
'name': u'Morgan Kaufmann'}, {'earliest_book': datetime.date(1995, 1, 15),
'num_awards': 7, 'id': 3, 'name': u'Prentice Hall'}, {'earliest_book':
datetime.date(2007, 12, 6), 'num_awards': 3, 'id': 1, 'name': u'Apress'},
{'earliest_book': datetime.date(2008, 3, 3), 'num_awards': 1, 'id': 2, 'name':
u'Sams'}]
-
->>> Store.objects.aggregate(Max('friday_night_closing'),
Min("original_opening"))
-{'friday_night_closing__max': datetime.time(23, 59, 59),
'original_opening__min': datetime.datetime(1945, 4, 25, 16, 24, 14)}
-
-# values_list() can also be used
-
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('pk',
'isbn', 'mean_age')
-[(1, u'159059725', 34.5)]
-
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('isbn')
-[(u'159059725',)]
-
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('mean_age')
-[(34.5,)]
-
->>>
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('mean_age',
flat=True)
-[34.5]
-
->>> qs =
Book.objects.values_list('price').annotate(count=Count('price')).order_by('-count',
'price')
->>> list(qs) == [(Decimal('29.69'), 2), (Decimal('23.09'), 1), (Decimal('30'),
1), (Decimal('75'), 1), (Decimal('82.8'), 1)]
-True
-
-"""}
Added: django/trunk/tests/modeltests/aggregation/tests.py
===================================================================
--- django/trunk/tests/modeltests/aggregation/tests.py
(rev 0)
+++ django/trunk/tests/modeltests/aggregation/tests.py 2010-05-28 11:15:36 UTC
(rev 13309)
@@ -0,0 +1,578 @@
+import datetime
+from decimal import Decimal
+
+from django.db.models import Avg, Sum, Count, Max, Min
+from django.test import TestCase
+
+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"]
+
+ def test_empty_aggregate(self):
+ self.assertEqual(Author.objects.all().aggregate(), {})
+
+ def test_single_aggregate(self):
+ vals = Author.objects.aggregate(Avg("age"))
+ self.assertEqual(vals, {"age__avg": Approximate(37.4, places=1)})
+
+ def test_multiple_aggregates(self):
+ vals = Author.objects.aggregate(Sum("age"), Avg("age"))
+ self.assertEqual(vals, {"age__sum": 337, "age__avg": Approximate(37.4,
places=1)})
+
+ def test_filter_aggregate(self):
+ vals = Author.objects.filter(age__gt=29).aggregate(Sum("age"))
+ self.assertEqual(len(vals), 1)
+ self.assertEqual(vals["age__sum"], 254)
+
+ def test_related_aggregate(self):
+ vals = Author.objects.aggregate(Avg("friends__age"))
+ self.assertEqual(len(vals), 1)
+ self.assertAlmostEqual(vals["friends__age__avg"], 34.07, places=2)
+
+ vals =
Book.objects.filter(rating__lt=4.5).aggregate(Avg("authors__age"))
+ self.assertEqual(len(vals), 1)
+ self.assertAlmostEqual(vals["authors__age__avg"], 38.2857, places=2)
+
+ vals =
Author.objects.all().filter(name__contains="a").aggregate(Avg("book__rating"))
+ self.assertEqual(len(vals), 1)
+ self.assertEqual(vals["book__rating__avg"], 4.0)
+
+ vals = Book.objects.aggregate(Sum("publisher__num_awards"))
+ self.assertEqual(len(vals), 1)
+ self.assertEquals(vals["publisher__num_awards__sum"], 30)
+
+ vals = Publisher.objects.aggregate(Sum("book__price"))
+ self.assertEqual(len(vals), 1)
+ self.assertEqual(vals["book__price__sum"], Decimal("270.27"))
+
+ def test_aggregate_multi_join(self):
+ vals = Store.objects.aggregate(Max("books__authors__age"))
+ self.assertEqual(len(vals), 1)
+ self.assertEqual(vals["books__authors__age__max"], 57)
+
+ vals = Author.objects.aggregate(Min("book__publisher__num_awards"))
+ self.assertEqual(len(vals), 1)
+ self.assertEqual(vals["book__publisher__num_awards__min"], 1)
+
+ def test_aggregate_alias(self):
+ vals =
Store.objects.filter(name="Amazon.com").aggregate(amazon_mean=Avg("books__rating"))
+ self.assertEqual(len(vals), 1)
+ self.assertAlmostEqual(vals["amazon_mean"], 4.08, places=2)
+
+ def test_annotate_basic(self):
+ self.assertQuerysetEqual(
+ Book.objects.annotate().order_by('pk'), [
+ "The Definitive Guide to Django: Web Development Done Right",
+ "Sams Teach Yourself Django in 24 Hours",
+ "Practical Django Projects",
+ "Python Web Development with Django",
+ "Artificial Intelligence: A Modern Approach",
+ "Paradigms of Artificial Intelligence Programming: Case
Studies in Common Lisp"
+ ],
+ lambda b: b.name
+ )
+
+ books = Book.objects.annotate(mean_age=Avg("authors__age"))
+ b = books.get(pk=1)
+ self.assertEqual(
+ b.name,
+ u'The Definitive Guide to Django: Web Development Done Right'
+ )
+ self.assertEqual(b.mean_age, 34.5)
+
+ def test_annotate_m2m(self):
+ books =
Book.objects.filter(rating__lt=4.5).annotate(Avg("authors__age")).order_by("name")
+ self.assertQuerysetEqual(
+ books, [
+ (u'Artificial Intelligence: A Modern Approach', 51.5),
+ (u'Practical Django Projects', 29.0),
+ (u'Python Web Development with Django', Approximate(30.3,
places=1)),
+ (u'Sams Teach Yourself Django in 24 Hours', 45.0)
+ ],
+ lambda b: (b.name, b.authors__age__avg),
+ )
+
+ books =
Book.objects.annotate(num_authors=Count("authors")).order_by("name")
+ self.assertQuerysetEqual(
+ books, [
+ (u'Artificial Intelligence: A Modern Approach', 2),
+ (u'Paradigms of Artificial Intelligence Programming: Case
Studies in Common Lisp', 1),
+ (u'Practical Django Projects', 1),
+ (u'Python Web Development with Django', 3),
+ (u'Sams Teach Yourself Django in 24 Hours', 1),
+ (u'The Definitive Guide to Django: Web Development Done
Right', 2)
+ ],
+ lambda b: (b.name, b.num_authors)
+ )
+
+ def test_backwards_m2m_annotate(self):
+ authors =
Author.objects.filter(name__contains="a").annotate(Avg("book__rating")).order_by("name")
+ self.assertQuerysetEqual(
+ authors, [
+ (u'Adrian Holovaty', 4.5),
+ (u'Brad Dayley', 3.0),
+ (u'Jacob Kaplan-Moss', 4.5),
+ (u'James Bennett', 4.0),
+ (u'Paul Bissex', 4.0),
+ (u'Stuart Russell', 4.0)
+ ],
+ lambda a: (a.name, a.book__rating__avg)
+ )
+
+ authors =
Author.objects.annotate(num_books=Count("book")).order_by("name")
+ self.assertQuerysetEqual(
+ authors, [
+ (u'Adrian Holovaty', 1),
+ (u'Brad Dayley', 1),
+ (u'Jacob Kaplan-Moss', 1),
+ (u'James Bennett', 1),
+ (u'Jeffrey Forcier', 1),
+ (u'Paul Bissex', 1),
+ (u'Peter Norvig', 2),
+ (u'Stuart Russell', 1),
+ (u'Wesley J. Chun', 1)
+ ],
+ lambda a: (a.name, a.num_books)
+ )
+
+ def test_reverse_fkey_annotate(self):
+ books =
Book.objects.annotate(Sum("publisher__num_awards")).order_by("name")
+ self.assertQuerysetEqual(
+ books, [
+ (u'Artificial Intelligence: A Modern Approach', 7),
+ (u'Paradigms of Artificial Intelligence Programming: Case
Studies in Common Lisp', 9),
+ (u'Practical Django Projects', 3),
+ (u'Python Web Development with Django', 7),
+ (u'Sams Teach Yourself Django in 24 Hours', 1),
+ (u'The Definitive Guide to Django: Web Development Done
Right', 3)
+ ],
+ lambda b: (b.name, b.publisher__num_awards__sum)
+ )
+
+ publishers =
Publisher.objects.annotate(Sum("book__price")).order_by("name")
+ self.assertQuerysetEqual(
+ publishers, [
+ (u'Apress', Decimal("59.69")),
+ (u"Jonno's House of Books", None),
+ (u'Morgan Kaufmann', Decimal("75.00")),
+ (u'Prentice Hall', Decimal("112.49")),
+ (u'Sams', Decimal("23.09"))
+ ],
+ lambda p: (p.name, p.book__price__sum)
+ )
+
+ def test_annotate_values(self):
+ books =
list(Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values())
+ self.assertEqual(
+ books, [
+ {
+ "contact_id": 1,
+ "id": 1,
+ "isbn": "159059725",
+ "mean_age": 34.5,
+ "name": "The Definitive Guide to Django: Web Development
Done Right",
+ "pages": 447,
+ "price": Approximate(Decimal("30")),
+ "pubdate": datetime.date(2007, 12, 6),
+ "publisher_id": 1,
+ "rating": 4.5,
+ }
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('pk',
'isbn', 'mean_age')
+ self.assertEqual(
+ list(books), [
+ {
+ "pk": 1,
+ "isbn": "159059725",
+ "mean_age": 34.5,
+ }
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values("name")
+ self.assertEqual(
+ list(books), [
+ {
+ "name": "The Definitive Guide to Django: Web Development
Done Right"
+ }
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).values().annotate(mean_age=Avg('authors__age'))
+ self.assertEqual(
+ list(books), [
+ {
+ "contact_id": 1,
+ "id": 1,
+ "isbn": "159059725",
+ "mean_age": 34.5,
+ "name": "The Definitive Guide to Django: Web Development
Done Right",
+ "pages": 447,
+ "price": Approximate(Decimal("30")),
+ "pubdate": datetime.date(2007, 12, 6),
+ "publisher_id": 1,
+ "rating": 4.5,
+ }
+ ]
+ )
+
+ books =
Book.objects.values("rating").annotate(n_authors=Count("authors__id"),
mean_age=Avg("authors__age")).order_by("rating")
+ self.assertEqual(
+ list(books), [
+ {
+ "rating": 3.0,
+ "n_authors": 1,
+ "mean_age": 45.0,
+ },
+ {
+ "rating": 4.0,
+ "n_authors": 6,
+ "mean_age": Approximate(37.16, places=1)
+ },
+ {
+ "rating": 4.5,
+ "n_authors": 2,
+ "mean_age": 34.5,
+ },
+ {
+ "rating": 5.0,
+ "n_authors": 1,
+ "mean_age": 57.0,
+ }
+ ]
+ )
+
+ authors = Author.objects.annotate(Avg("friends__age")).order_by("name")
+ self.assertEqual(len(authors), 9)
+ self.assertQuerysetEqual(
+ authors, [
+ (u'Adrian Holovaty', 32.0),
+ (u'Brad Dayley', None),
+ (u'Jacob Kaplan-Moss', 29.5),
+ (u'James Bennett', 34.0),
+ (u'Jeffrey Forcier', 27.0),
+ (u'Paul Bissex', 31.0),
+ (u'Peter Norvig', 46.0),
+ (u'Stuart Russell', 57.0),
+ (u'Wesley J. Chun', Approximate(33.66, places=1))
+ ],
+ lambda a: (a.name, a.friends__age__avg)
+ )
+
+ def test_count(self):
+ vals = Book.objects.aggregate(Count("rating"))
+ self.assertEqual(vals, {"rating__count": 6})
+
+ vals = Book.objects.aggregate(Count("rating", distinct=True))
+ self.assertEqual(vals, {"rating__count": 4})
+
+ def test_fkey_aggregate(self):
+ explicit = list(Author.objects.annotate(Count('book__id')))
+ implicit = list(Author.objects.annotate(Count('book')))
+ self.assertEqual(explicit, implicit)
+
+ def test_annotate_ordering(self):
+ books =
Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('oldest',
'rating')
+ self.assertEqual(
+ list(books), [
+ {
+ "rating": 4.5,
+ "oldest": 35,
+ },
+ {
+ "rating": 3.0,
+ "oldest": 45
+ },
+ {
+ "rating": 4.0,
+ "oldest": 57,
+ },
+ {
+ "rating": 5.0,
+ "oldest": 57,
+ }
+ ]
+ )
+
+ books =
Book.objects.values("rating").annotate(oldest=Max("authors__age")).order_by("-oldest",
"-rating")
+ self.assertEqual(
+ list(books), [
+ {
+ "rating": 5.0,
+ "oldest": 57,
+ },
+ {
+ "rating": 4.0,
+ "oldest": 57,
+ },
+ {
+ "rating": 3.0,
+ "oldest": 45,
+ },
+ {
+ "rating": 4.5,
+ "oldest": 35,
+ }
+ ]
+ )
+
+ def test_aggregate_annotation(self):
+ vals =
Book.objects.annotate(num_authors=Count("authors__id")).aggregate(Avg("num_authors"))
+ self.assertEqual(vals, {"num_authors__avg": Approximate(1.66,
places=1)})
+
+ def test_filtering(self):
+ p = Publisher.objects.create(name='Expensive Publisher', num_awards=0)
+ Book.objects.create(
+ name='ExpensiveBook1',
+ pages=1,
+ isbn='111',
+ rating=3.5,
+ price=Decimal("1000"),
+ publisher=p,
+ contact_id=1,
+ pubdate=datetime.date(2008,12,1)
+ )
+ Book.objects.create(
+ name='ExpensiveBook2',
+ pages=1,
+ isbn='222',
+ rating=4.0,
+ price=Decimal("1000"),
+ publisher=p,
+ contact_id=1,
+ pubdate=datetime.date(2008,12,2)
+ )
+ Book.objects.create(
+ name='ExpensiveBook3',
+ pages=1,
+ isbn='333',
+ rating=4.5,
+ price=Decimal("35"),
+ publisher=p,
+ contact_id=1,
+ pubdate=datetime.date(2008,12,3)
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Prentice Hall",
+ "Expensive Publisher",
+ ],
+ lambda p: p.name,
+ )
+
+ publishers =
Publisher.objects.filter(book__price__lt=Decimal("40.0")).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Apress",
+ "Sams",
+ "Prentice Hall",
+ "Expensive Publisher",
+ ],
+ lambda p: p.name
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1,
book__price__lt=Decimal("40.0")).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Prentice Hall",
+ "Expensive Publisher",
+ ],
+ lambda p: p.name,
+ )
+
+ publishers =
Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ ],
+ lambda p: p.name
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book")).filter(num_books__range=[1,
3]).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Sams",
+ "Prentice Hall",
+ "Morgan Kaufmann",
+ "Expensive Publisher",
+ ],
+ lambda p: p.name
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book")).filter(num_books__range=[1,
2]).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Sams",
+ "Prentice Hall",
+ "Morgan Kaufmann",
+ ],
+ lambda p: p.name
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book")).filter(num_books__in=[1,
3]).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Sams",
+ "Morgan Kaufmann",
+ "Expensive Publisher",
+ ],
+ lambda p: p.name,
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book")).filter(num_books__isnull=True)
+ self.assertEqual(len(publishers), 0)
+
+ def test_annotation(self):
+ vals = Author.objects.filter(pk=1).aggregate(Count("friends__id"))
+ self.assertEqual(vals, {"friends__id__count": 2})
+
+ books =
Book.objects.annotate(num_authors=Count("authors__name")).filter(num_authors__ge=2).order_by("pk")
+ self.assertQuerysetEqual(
+ books, [
+ "The Definitive Guide to Django: Web Development Done Right",
+ "Artificial Intelligence: A Modern Approach",
+ ],
+ lambda b: b.name
+ )
+
+ authors = Author.objects.annotate(num_friends=Count("friends__id",
distinct=True)).filter(num_friends=0).order_by("pk")
+ self.assertQuerysetEqual(
+ authors, [
+ "Brad Dayley",
+ ],
+ lambda a: a.name
+ )
+
+ publishers =
Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ "Prentice Hall",
+ ],
+ lambda p: p.name
+ )
+
+ publishers =
Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count("book__id")).filter(num_books__gt=1)
+ self.assertQuerysetEqual(
+ publishers, [
+ "Apress",
+ ],
+ lambda p: p.name
+ )
+
+ books =
Book.objects.annotate(num_authors=Count("authors__id")).filter(authors__name__contains="Norvig",
num_authors__gt=1)
+ self.assertQuerysetEqual(
+ books, [
+ "Artificial Intelligence: A Modern Approach",
+ ],
+ lambda b: b.name
+ )
+
+ def test_more_aggregation(self):
+ a = Author.objects.get(name__contains='Norvig')
+ b = Book.objects.get(name__contains='Done Right')
+ b.authors.add(a)
+ b.save()
+
+ vals =
Book.objects.annotate(num_authors=Count("authors__id")).filter(authors__name__contains="Norvig",
num_authors__gt=1).aggregate(Avg("rating"))
+ self.assertEqual(vals, {"rating__avg": 4.25})
+
+ def test_even_more_aggregate(self):
+ publishers =
Publisher.objects.annotate(earliest_book=Min("book__pubdate")).exclude(earliest_book=None).order_by("earliest_book").values()
+ self.assertEqual(
+ list(publishers), [
+ {
+ 'earliest_book': datetime.date(1991, 10, 15),
+ 'num_awards': 9,
+ 'id': 4,
+ 'name': u'Morgan Kaufmann'
+ },
+ {
+ 'earliest_book': datetime.date(1995, 1, 15),
+ 'num_awards': 7,
+ 'id': 3,
+ 'name': u'Prentice Hall'
+ },
+ {
+ 'earliest_book': datetime.date(2007, 12, 6),
+ 'num_awards': 3,
+ 'id': 1,
+ 'name': u'Apress'
+ },
+ {
+ 'earliest_book': datetime.date(2008, 3, 3),
+ 'num_awards': 1,
+ 'id': 2,
+ 'name': u'Sams'
+ }
+ ]
+ )
+
+ vals = Store.objects.aggregate(Max("friday_night_closing"),
Min("original_opening"))
+ self.assertEqual(
+ vals,
+ {
+ "friday_night_closing__max": datetime.time(23, 59, 59),
+ "original_opening__min": datetime.datetime(1945, 4, 25, 16,
24, 14),
+ }
+ )
+
+ def test_annotate_values_list(self):
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("pk",
"isbn", "mean_age")
+ self.assertEqual(
+ list(books), [
+ (1, "159059725", 34.5),
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("isbn")
+ self.assertEqual(
+ list(books), [
+ ('159059725',)
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("mean_age")
+ self.assertEqual(
+ list(books), [
+ (34.5,)
+ ]
+ )
+
+ books =
Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("mean_age",
flat=True)
+ self.assertEqual(list(books), [34.5])
+
+ books =
Book.objects.values_list("price").annotate(count=Count("price")).order_by("-count",
"price")
+ self.assertEqual(
+ list(books), [
+ (Decimal("29.69"), 2),
+ (Decimal('23.09'), 1),
+ (Decimal('30'), 1),
+ (Decimal('75'), 1),
+ (Decimal('82.8'), 1),
+ ]
+ )
--
You received this message because you are subscribed to the Google Groups
"Django updates" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/django-updates?hl=en.
