Generating aggregate data across generic relations

>>> Store.objects.annotate(min_price=Min('books__price'), max_price=Max('books__price'))

>>> Store.objects.aggregate(min_price=Min('books__price'), max_price=Max('books__price'))

class Entry(models.Model):
    ...
    comments = generic.GenericRelation(Comment) # reverse generic relation
    ...


Entry.objects.annotate(count=Count('comments')) # does not work!

from django.db.models import Count
from django.contrib.comments.models import Comment
from django.contrib.contenttypes.models import ContentType
from blog.models import Entry

ctype = ContentType.objects.get_for_model(Entry)
qs = Entry.objects.extra(select={
    'count': """
        SELECT COUNT(*) AS comment_count
        FROM django_comments
        WHERE
            content_type_id=%s AND
            object_pk=CAST(blog_entries.id as text)
        """
    },
    select_params=[ctype.pk],
    order_by=['-count'])

def generic_annotate(queryset, gfk_field, aggregate_field, aggregator=models.Sum, desc=True):
    ordering = desc and '-score' or 'score'
    content_type = ContentType.objects.get_for_model(queryset.model)

    # collect the params we'll be using
    params = (
        aggregator.name, # the function that's doing the aggregation
        aggregate_field, # the field containing the value to aggregate
        gfk_field.model._meta.db_table, # table holding gfk'd item info
        gfk_field.ct_field, # the content_type field on the GFK
        content_type.pk, # the content_type id we need to match
        gfk_field.fk_field, # the object_id field on the GFK
        queryset.model._meta.db_table, # the table and pk from the main
        queryset.model._meta.pk.name   # part of the query
    )

    queryset = queryset.extra(select={
        'score': """
            SELECT %s(%s) AS aggregate_score
            FROM %s
            WHERE
                %s_id=%s AND
                %s=%s.%s
        """ % params
    },
    order_by=[ordering])

    return queryset

>>> from misc import generic_annotate
>>> from blog.models import Entry
>>> from tagging.models import TaggedItem
>>> from django.db.models import Count
>>> qs = generic_annotate(Entry.objects.all(), TaggedItem.object, 'id', Count)
>>> qs[0].score
5L

>>> qs[1].score
4L

>>> qs[1].tags
u'databases django many-to-many python'

def generic_aggregate(queryset, gfk_field, aggregate_field, aggregator=models.Sum):
    content_type = ContentType.objects.get_for_model(queryset.model)

    queryset = queryset.values_list('pk') # just the pks
    sql = queryset.query.as_sql()[0] % queryset.query.as_sql()[1]

    # collect the params we'll be using
    params = (
        aggregator.name, # the function that's doing the aggregation
        aggregate_field, # the field containing the value to aggregate
        gfk_field.model._meta.db_table, # table holding gfk'd item info
        gfk_field.ct_field, # the content_type field on the GFK
        content_type.pk, # the content_type id we need to match
        gfk_field.fk_field, # the object_id field on the GFK
        sql
    )

    query = """
            SELECT %s(%s) AS aggregate_score
            FROM %s
            WHERE
                %s_id=%s AND
                %s IN (
                    %s
                )
        """ % params

    cursor = connection.cursor()
    cursor.execute(query)
    row = cursor.fetchone()

    return row[0]

>>> from misc import generic_aggregate
>>> from blog.models import Entry
>>> from tagging.models import TaggedItem
>>> from django.db.models import Count
>>> qs = generic_aggregate(Entry.objects.all(), TaggedItem.object, 'id', Count)
106L # the total number of times a tag was added to an entry