Ensure we only create the same index once

Author: OskarPersson

sql_server/pyodbc/schema.py

@@ -5,14 +5,22 @@
     BaseDatabaseSchemaEditor, logger, _is_relevant_relation, _related_non_m2m_objects,
 )
 from django.db.backends.ddl_references import (
-    Statement,
+    Columns, IndexName, Statement as DjStatement, Table,
 )
 from django.db.models import Index
 from django.db.models.fields import AutoField, BigAutoField
 from django.db.transaction import TransactionManagementError
 from django.utils.encoding import force_text
 
 
+class Statement(DjStatement):
+    def __hash__(self):
+        return hash((self.template, str(self.parts['name'])))
+
+    def __eq__(self, other):
+        return self.template == other.template and str(self.parts['name']) == str(other.parts['name'])
+
+
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     _sql_check_constraint = " CONSTRAINT %(name)s CHECK (%(check)s)"
@@ -174,16 +182,51 @@ def _alter_many_to_many(self, model, old_field, new_field, strict):
 
         return super()._alter_many_to_many(model, old_field, new_field, strict)
 
+    def _db_table_constraint_names(self, db_table, column_names=None, unique=None,
+                                   primary_key=None, index=None, foreign_key=None,
+                                   check=None, type_=None, exclude=None):
+        """Return all constraint names matching the columns and conditions."""
+        if column_names is not None:
+            column_names = [
+                self.connection.introspection.identifier_converter(name)
+                for name in column_names
+            ]
+        with self.connection.cursor() as cursor:
+            constraints = self.connection.introspection.get_constraints(cursor, db_table)
+        result = []
+        for name, infodict in constraints.items():
+            if column_names is None or column_names == infodict['columns']:
+                if unique is not None and infodict['unique'] != unique:
+                    continue
+                if primary_key is not None and infodict['primary_key'] != primary_key:
+                    continue
+                if index is not None and infodict['index'] != index:
+                    continue
+                if check is not None and infodict['check'] != check:
+                    continue
+                if foreign_key is not None and not infodict['foreign_key']:
+                    continue
+                if type_ is not None and infodict['type'] != type_:
+                    continue
+                if not exclude or name not in exclude:
+                    result.append(name)
+        return result
+
+    def _db_table_delete_constraint_sql(self, template, db_table, name):
+        return Statement(
+            template,
+            table=Table(db_table, self.quote_name),
+            name=self.quote_name(name),
+        )
+
     def alter_db_table(self, model, old_db_table, new_db_table):
-        index_names = self._constraint_names(model, index=True)
+        index_names = self._db_table_constraint_names(old_db_table, index=True)
         for index_name in index_names:
-            self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
+            self.execute(self._db_table_delete_constraint_sql(self.sql_delete_index, old_db_table, index_name))
 
-        model._meta.db_table = old_db_table
-        index_names = self._constraint_names(model, index=True)
+        index_names = self._db_table_constraint_names(new_db_table, index=True)
         for index_name in index_names:
-            self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
-        model._meta.db_table = new_db_table
+            self.execute(self._db_table_delete_constraint_sql(self.sql_delete_index, new_db_table, index_name))
 
         return super().alter_db_table(model, old_db_table, new_db_table)
 
@@ -627,6 +670,61 @@ def add_field(self, model, field):
         if self.connection.features.connection_persists_old_columns:
             self.connection.close()
 
+    def _create_unique_sql(self, model, columns, name=None, condition=None):
+        def create_unique_name(*args, **kwargs):
+            return self.quote_name(self._create_index_name(*args, **kwargs))
+
+        table = Table(model._meta.db_table, self.quote_name)
+        if name is None:
+            name = IndexName(model._meta.db_table, columns, '_uniq', create_unique_name)
+        else:
+            name = self.quote_name(name)
+        columns = Columns(table, columns, self.quote_name)
+        if condition:
+            return Statement(
+                self.sql_create_unique_index,
+                table=table,
+                name=name,
+                columns=columns,
+                condition=' WHERE ' + condition,
+            ) if self.connection.features.supports_partial_indexes else None
+        else:
+            return Statement(
+                self.sql_create_unique,
+                table=table,
+                name=name,
+                columns=columns,
+            )
+
+    def _create_index_sql(self, model, fields, *, name=None, suffix='', using='',
+                          db_tablespace=None, col_suffixes=(), sql=None, opclasses=(),
+                          condition=None):
+        """
+        Return the SQL statement to create the index for one or several fields.
+        `sql` can be specified if the syntax differs from the standard (GIS
+        indexes, ...).
+        """
+        tablespace_sql = self._get_index_tablespace_sql(model, fields, db_tablespace=db_tablespace)
+        columns = [field.column for field in fields]
+        sql_create_index = sql or self.sql_create_index
+        table = model._meta.db_table
+
+        def create_index_name(*args, **kwargs):
+            nonlocal name
+            if name is None:
+                name = self._create_index_name(*args, **kwargs)
+            return self.quote_name(name)
+
+        return Statement(
+            sql_create_index,
+            table=Table(table, self.quote_name),
+            name=IndexName(table, columns, suffix, create_index_name),
+            using=using,
+            columns=self._index_columns(table, columns, col_suffixes, opclasses),
+            extra=tablespace_sql,
+            condition=(' WHERE ' + condition) if condition else '',
+        )
+
     def create_model(self, model):
         """
         Takes a model and creates a table for it in the database.
@@ -684,6 +782,13 @@ def create_model(self, model):
                 if autoinc_sql:
                     self.deferred_sql.extend(autoinc_sql)
 
+        # Add any unique_togethers (always deferred, as some fields might be
+        # created afterwards, like geometry fields with some backends)
+        for fields in model._meta.unique_together:
+            columns = [model._meta.get_field(field).column for field in fields]
+            condition = ' AND '.join(["[%s] IS NOT NULL" % col for col in columns])
+            self.deferred_sql.append(self._create_unique_sql(model, columns, condition=condition))
+
         # Make the table
         sql = self.sql_create_table % {
             "table": self.quote_name(model._meta.db_table),
@@ -698,6 +803,7 @@ def create_model(self, model):
 
         # Add any field index and index_together's (deferred as SQLite3 _remake_table needs it)
         self.deferred_sql.extend(self._model_indexes_sql(model))
+        self.deferred_sql = list(set(self.deferred_sql))
 
         # Make M2M tables
         for field in model._meta.local_many_to_many: