Ticket #5805: index_together.diff

django/db/backends/creation.py

@@ -133 +133 @@
                     (qn(r_table), qn(truncate_name(r_name, self.connection.ops.max_name_length())),
                     qn(r_col), qn(table), qn(col),
                     self.connection.ops.deferrable_sql()))
             del pending_references[model]
         return final_output
 
     def sql_indexes_for_model(self, model, style):
         "Returns the CREATE INDEX SQL statements for a single model"
+        from django.db.backends.util import truncate_name
+
         if not model._meta.managed or model._meta.proxy:
             return []
+
+        opts = model._meta
+        qn = self.connection.ops.quote_name
         output = []
+
         for f in model._meta.local_fields:
             output.extend(self.sql_indexes_for_field(model, f, style))
+
+        for field_constraints in opts.index_together:
+            i_name = '%s_%s' % (opts.db_table, self._digest(field_constraints))
+
+            output.append(
+                style.SQL_KEYWORD('CREATE INDEX') + ' ' +
+                style.SQL_TABLE(qn(truncate_name(i_name, self.connection.ops.max_name_length()))) + ' ' +
+                style.SQL_KEYWORD('ON') + ' ' +
+                style.SQL_TABLE(qn(opts.db_table)) + ' ' +
+                "(%s);" % ", ".join([style.SQL_FIELD(qn(opts.get_field(f).column)) for f in field_constraints])
+            )
+
         return output
 
     def sql_indexes_for_field(self, model, f, style):
         "Return the CREATE INDEX SQL statements for a single model field"
         from django.db.backends.util import truncate_name
 
         if f.db_index and not f.unique:
             qn = self.connection.ops.quote_name

django/db/models/options.py

@@ -12 +12 @@
 from django.utils.datastructures import SortedDict
 
 # Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
 get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip()
 
 DEFAULT_NAMES = ('verbose_name', 'verbose_name_plural', 'db_table', 'ordering',
                  'unique_together', 'permissions', 'get_latest_by',
                  'order_with_respect_to', 'app_label', 'db_tablespace',
-                 'abstract', 'managed', 'proxy', 'auto_created')
+                 'abstract', 'managed', 'proxy', 'auto_created', 'index_together')
 
 class Options(object):
     def __init__(self, meta, app_label=None):
         self.local_fields, self.local_many_to_many = [], []
         self.virtual_fields = []
         self.module_name, self.verbose_name = None, None
         self.verbose_name_plural = None
         self.db_table = ''
         self.ordering = []
         self.unique_together =  []
+        self.index_together =  []
         self.permissions =  []
         self.object_name, self.app_label = None, app_label
         self.get_latest_by = None
         self.order_with_respect_to = None
         self.db_tablespace = settings.DEFAULT_TABLESPACE
         self.admin = None
         self.meta = meta
         self.pk = None
@@ -75 +76 @@
                 if name.startswith('_'):
                     del meta_attrs[name]
             for attr_name in DEFAULT_NAMES:
                 if attr_name in meta_attrs:
                     setattr(self, attr_name, meta_attrs.pop(attr_name))
                 elif hasattr(self.meta, attr_name):
                     setattr(self, attr_name, getattr(self.meta, attr_name))
 
-            # unique_together can be either a tuple of tuples, or a single
+            # unique_together and index_together can be either a tuple of tuples, or a single
             # tuple of two strings. Normalize it to a tuple of tuples, so that
             # calling code can uniformly expect that.
             ut = meta_attrs.pop('unique_together', self.unique_together)
             if ut and not isinstance(ut[0], (tuple, list)):
                 ut = (ut,)
             self.unique_together = ut
 
+            it = meta_attrs.pop('index_together', self.index_together)
+            if it and not isinstance(it[0], (tuple, list)):
+                it = (it,)
+            self.index_together = it
+
             # verbose_name_plural is a special case because it uses a 's'
             # by default.
             if self.verbose_name_plural is None:
                 self.verbose_name_plural = string_concat(self.verbose_name, 's')
 
             # Any leftover attributes must be invalid.
             if meta_attrs != {}:
                 raise TypeError("'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()))

docs/ref/models/options.txt

@@ -242 +242 @@
     appropriate ``UNIQUE`` statements are included in the ``CREATE TABLE``
     statement).
 
     For convenience, unique_together can be a single list when dealing with a single
     set of fields::
 
         unique_together = ("driver", "restaurant")
 
+``index_together``
+-------------------
+
+.. versionadded:: 1.4
+
+.. attribute:: Options.index_together
+
+    Sets of field names that, taken together, will be indexed::
+
+        index_together = (("driver", "restaurant"),)
+
+    This is a list of lists of fields that will indexed together. (i.e., the
+    appropriate ``CREATE INDEX`` statements will be created for this table.
+
+    For convenience, index_together can be a single list when dealing with a single
+    set of fields::
+
+        index_together = ("driver", "restaurant")
+
 ``verbose_name``
 ----------------
 
 .. attribute:: Options.verbose_name
 
     A human-readable name for the object, singular::
 
         verbose_name = "pizza"

tests/modeltests/basic/models.py

@@ -8 +8 @@
 
 
 class Article(models.Model):
     headline = models.CharField(max_length=100, default='Default headline')
     pub_date = models.DateTimeField()
 
     class Meta:
         ordering = ('pub_date','headline')
+        index_together = ('headline', 'pub_date')
 
     def __unicode__(self):
         return self.headline

tests/modeltests/get_or_create/models.py

@@ -9 +9 @@
 from django.db import models
 
 
 class Person(models.Model):
     first_name = models.CharField(max_length=100)
     last_name = models.CharField(max_length=100)
     birthday = models.DateField()
 
+    class Meta:
+        index_together = (('first_name', 'last_name'), ('first_name', 'birthday'))
+
     def __unicode__(self):
         return u'%s %s' % (self.first_name, self.last_name)
 
 class ManualPrimaryKeyTest(models.Model):
     id = models.IntegerField(primary_key=True)
     data = models.CharField(max_length=100)