1 files changed, 92 insertions, 0 deletions
diff --git a/utils/cache.py b/utils/cache.py
new file mode 100644
index 00000000..bc1cb1af
--- /dev/null
+++ b/utils/cache.py
@@ -0,0 +1,92 @@
+"""Utilities for working with Django Models."""
+import itertools
+
+from django.contrib.contenttypes.models import ContentType
+
+from lanai.utils.lists import flatten
+
+def fetch_model_dict(model, ids, fields=None):
+    """
+    Fetches a dict of model details for model instances with the given
+    ids, keyed by their id.
+
+    If a fields list is given, a dict of details will be retrieved for
+    each model, otherwise complete model instances will be retrieved.
+
+    Any fields list given shouldn't contain the primary key attribute for
+    the model, as this can be determined from its Options.
+    """
+    if fields is None:
+        return model._default_manager.in_bulk(ids)
+    else:
+        id_attr = model._meta.pk.attname
+        return dict((obj[id_attr], obj) for obj
+            in model._default_manager.filter(id__in=ids).values(
+                *itertools.chain((id_attr,), fields)))
+
+def populate_foreign_key_caches(model, objects_to_populate, fields=None):
+    """
+    Populates caches for the given related Model in instances of objects
+    which have a ForeignKey relationship to it, specified as a list of
+    (object list, related attribute name list) two-tuples.
+
+    If a list of field names is given, only the given fields will be
+    looked up and related object caches will be populated with a dict of
+    the specified fields. Otherwise, complete model instances will be
+    retrieved.
+    """
+    # Get all related object ids for the appropriate fields
+    related_object_ids = []
+    for objects, attrs in objects_to_populate:
+        related_object_ids.append(tuple(tuple(getattr(obj, '%s_id' % attr)
+                                              for attr in attrs)
+                                  for obj in objects))
+    unique_ids = tuple(set(pk for pk in flatten(related_object_ids) if pk))
+    related_objects = fetch_model_dict(model, unique_ids, fields)
+
+    # Fill related object caches
+    for (objects, attrs), related_ids in itertools.izip(objects_to_populate,
+                                                        related_object_ids):
+        for obj, related_ids_for_obj in itertools.izip(objects,
+                                                       related_ids):
+            for attr, related_object in itertools.izip(attrs, (related_objects.get(pk, None)
+                                                               for pk in related_ids_for_obj)):
+                setattr(obj, '_%s_cache' % attr, related_object)
+
+def populate_content_object_caches(generic_related_objects, model_fields=None):
+    """
+    Retrieves ``ContentType`` and content objects for the given list of
+    items which use a generic relation, grouping the retrieval of content
+    objects by model to reduce the number of queries executed.
+
+    This results in ``number_of_content_types + 1`` queries rather than
+    the ``number_of_generic_reL_objects * 2`` queries you'd get by
+    iterating over the list and accessing each item's object attribute.
+
+    If a dict mapping model classes to field names is given, only the
+    given fields will be looked up for each model specified and the
+    object cache will be populated with a dict of the specified fields.
+    Otherwise, complete model instances will be retrieved.
+    """
+    if model_fields is None:
+        model_fields = {}
+
+    # Group content object ids by their content type ids
+    ids_by_content_type = {}
+    for obj in generic_related_objects:
+        ids_by_content_type.setdefault(obj.content_type_id,
+                                       []).append(obj.object_id)
+
+    # Retrieve content types and content objects in bulk
+    content_types = ContentType.objects.in_bulk(ids_by_content_type.keys())
+    for content_type_id, ids in ids_by_content_type.iteritems():
+        model = content_types[content_type_id].model_class()
+        objects[content_type_id] = fetch_model_dict(
+            model, tuple(set(ids)), model_fields.get(model, None))
+
+    # Set content types and content objects in the appropriate cache
+    # attributes, so accessing the 'content_type' and 'object' attributes
+    # on each object won't result in further database hits.
+    for obj in generic_related_objects:
+        obj._object_cache = objects[obj.content_type_id][obj.object_id]
+        obj._content_type_cache = content_types[obj.content_type_id]