diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 8b40edd..f736e27 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -16,7 +16,7 @@ from django.db import connection
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 from django.db.models.query_utils import select_related_descend
-from django.db.models.sql import aggregates
+from django.db.models.sql import aggregates as aggregates_module
 from django.db.models.sql.where import WhereNode, EverythingNode, AND, OR
 from django.core.exceptions import FieldError
 from datastructures import EmptyResultSet, Empty, MultiJoin
@@ -40,7 +40,8 @@ class BaseQuery(object):
 
     alias_prefix = 'T'
     query_terms = QUERY_TERMS
-
+    aggregates = aggregates_module
+    
     def __init__(self, model, connection, where=WhereNode):
         self.model = model
         self.connection = connection
@@ -198,13 +199,19 @@ class BaseQuery(object):
             obj._setup_query()
         return obj
 
+    def normalize(self, aggregate, value):
+        """
+        Returns a normalized Python object from the given aggregate object
+        and raw database value.
+        """
+        return self.connection.ops.db_aggregate_to_value(aggregate, value)
+
     def results_iter(self):
         """
         Returns an iterator over the results from executing this query.
         """
         resolve_columns = hasattr(self, 'resolve_columns')
         fields = None
-        normalize = self.connection.ops.db_aggregate_to_value
         for rows in self.execute_sql(MULTI):
             for row in rows:
                 if resolve_columns:
@@ -221,7 +228,7 @@ class BaseQuery(object):
                 if self.aggregate_select:
                     aggregate_start = len(self.extra_select.keys()) + len(self.select)
                     row = row[:aggregate_start] + tuple(
-                        normalize(aggregate, value)
+                        self.normalize(aggregate, value)
                         for (alias, aggregate), value
                         in zip(self.aggregate_select.items(), row[aggregate_start:])
                     )
@@ -263,10 +270,9 @@ class BaseQuery(object):
         query.select_related = False
         query.related_select_cols = []
         query.related_select_fields = []
-
-        normalize = self.connection.ops.db_aggregate_to_value
+        
         return dict(
-            (alias, normalize(aggregate, val))
+            (alias, self.normalize(aggregate, val))
             for (alias, aggregate), val
             in zip(query.aggregate_select.items(), query.execute_sql(SINGLE))
         )
@@ -1178,7 +1184,7 @@ class BaseQuery(object):
             aggregate_expr.lookup in self.aggregate_select.keys()):
             # Aggregate is over an annotation
             field_name = field_list[0]
-            aggregate = aggregate_expr.add_to_query(self, aggregates,
+            aggregate = aggregate_expr.add_to_query(self, self.aggregates,
                 col=field_name,
                 source=self.aggregate_select[field_name],
                 is_summary=is_summary)
@@ -1197,7 +1203,7 @@ class BaseQuery(object):
             for column_alias in join_list:
                 self.promote_alias(column_alias, unconditional=True)
 
-            aggregate = aggregate_expr.add_to_query(self, aggregates,
+            aggregate = aggregate_expr.add_to_query(self, self.aggregates,
                 col=(join_list[-1], col),
                 source=target,
                 is_summary=is_summary)
@@ -1211,7 +1217,7 @@ class BaseQuery(object):
                 col = (opts.db_table, field.column)
             else:
                 col = field_name
-            aggregate = aggregate_expr.add_to_query(self, aggregates,
+            aggregate = aggregate_expr.add_to_query(self, self.aggregates,
                 col=col,
                 source=field,
                 is_summary=is_summary)
@@ -1790,15 +1796,15 @@ class BaseQuery(object):
         """
         if not self.distinct:
             if not self.select:
-                count = aggregates.Count('*', is_summary=True)
+                count = self.aggregates.Count('*', is_summary=True)
             else:
                 assert len(self.select) == 1, \
                         "Cannot add count col with multiple cols in 'select': %r" % self.select
-                count = aggregates.Count(self.select[0])
+                count = self.aggregates.Count(self.select[0])
         else:
             opts = self.model._meta
             if not self.select:
-                count = aggregates.Count((self.join((None, opts.db_table, None, None)), opts.pk.column),
+                count = self.aggregates.Count((self.join((None, opts.db_table, None, None)), opts.pk.column),
                                          is_summary=True, distinct=True)
             else:
                 # Because of SQL portability issues, multi-column, distinct
@@ -1806,7 +1812,7 @@ class BaseQuery(object):
                 assert len(self.select) == 1, \
                         "Cannot add count col with multiple cols in 'select'."
 
-                count = aggregates.Count(self.select[0], distinct=True)
+                count = self.aggregates.Count(self.select[0], distinct=True)
             # Distinct handling is done in Count(), so don't do it at this
             # level.
             self.distinct = False