Refs #22608 -- Optimized migration optimizer

Moved list constants instantiation into optimizer's __init__.

django/db/migrations/optimizer.py

@@ -15,65 +15,18 @@ class MigrationOptimizer(object):
     nothing.
     """
 
-    def optimize(self, operations, app_label=None):
-        """
-        Main optimization entry point. Pass in a list of Operation instances,
-        get out a new list of Operation instances.
-
-        Unfortunately, due to the scope of the optimization (two combinable
-        operations might be separated by several hundred others), this can't be
-        done as a peephole optimization with checks/output implemented on
-        the Operations themselves; instead, the optimizer looks at each
-        individual operation and scans forwards in the list to see if there
-        are any matches, stopping at boundaries - operations which can't
-        be optimized over (RunSQL, operations on the same field/model, etc.)
-
-        The inner loop is run until the starting list is the same as the result
-        list, and then the result is returned. This means that operation
-        optimization must be stable and always return an equal or shorter list.
-
-        The app_label argument is optional, but if you pass it you'll get more
-        efficient optimization.
-        """
-        # Internal tracking variable for test assertions about # of loops
-        self._iterations = 0
-        while True:
-            result = self.optimize_inner(operations, app_label)
-            self._iterations += 1
-            if result == operations:
-                return result
-            operations = result
-
-    def optimize_inner(self, operations, app_label=None):
-        """
-        Inner optimization loop.
-        """
-        new_operations = []
-        for i, operation in enumerate(operations):
-            # Compare it to each operation after it
-            for j, other in enumerate(operations[i + 1:]):
-                result = self.reduce(operation, other, operations[i + 1:i + j + 1])
-                if result is not None:
-                    # Optimize! Add result, then remaining others, then return
-                    new_operations.extend(result)
-                    new_operations.extend(operations[i + 1:i + 1 + j])
-                    new_operations.extend(operations[i + j + 2:])
-                    return new_operations
-                if not self.can_optimize_through(operation, other, app_label):
-                    new_operations.append(operation)
-                    break
-            else:
-                new_operations.append(operation)
-        return new_operations
-
-    #### REDUCTION ####
-
-    def reduce(self, operation, other, in_between=None):
-        """
-        Either returns a list of zero, one or two operations,
-        or None, meaning this pair cannot be optimized.
-        """
-        submethods = [
+    def __init__(self):
+        self.model_level_operations = (
+            migrations.CreateModel,
+            migrations.AlterModelTable,
+            migrations.AlterUniqueTogether,
+            migrations.AlterIndexTogether,
+        )
+        self.field_level_operations = (
+            migrations.AddField,
+            migrations.AlterField,
+        )
+        self.reduce_methods = [
             (
                 migrations.CreateModel,
                 migrations.DeleteModel,
@@ -155,7 +108,66 @@ def reduce(self, operation, other, in_between=None):
                 self.reduce_rename_field_self,
             ),
         ]
-        for ia, ib, om in submethods:
+
+    def optimize(self, operations, app_label=None):
+        """
+        Main optimization entry point. Pass in a list of Operation instances,
+        get out a new list of Operation instances.
+
+        Unfortunately, due to the scope of the optimization (two combinable
+        operations might be separated by several hundred others), this can't be
+        done as a peephole optimization with checks/output implemented on
+        the Operations themselves; instead, the optimizer looks at each
+        individual operation and scans forwards in the list to see if there
+        are any matches, stopping at boundaries - operations which can't
+        be optimized over (RunSQL, operations on the same field/model, etc.)
+
+        The inner loop is run until the starting list is the same as the result
+        list, and then the result is returned. This means that operation
+        optimization must be stable and always return an equal or shorter list.
+
+        The app_label argument is optional, but if you pass it you'll get more
+        efficient optimization.
+        """
+        # Internal tracking variable for test assertions about # of loops
+        self._iterations = 0
+        while True:
+            result = self.optimize_inner(operations, app_label)
+            self._iterations += 1
+            if result == operations:
+                return result
+            operations = result
+
+    def optimize_inner(self, operations, app_label=None):
+        """
+        Inner optimization loop.
+        """
+        new_operations = []
+        for i, operation in enumerate(operations):
+            # Compare it to each operation after it
+            for j, other in enumerate(operations[i + 1:]):
+                result = self.reduce(operation, other, operations[i + 1:i + j + 1])
+                if result is not None:
+                    # Optimize! Add result, then remaining others, then return
+                    new_operations.extend(result)
+                    new_operations.extend(operations[i + 1:i + 1 + j])
+                    new_operations.extend(operations[i + j + 2:])
+                    return new_operations
+                if not self.can_optimize_through(operation, other, app_label):
+                    new_operations.append(operation)
+                    break
+            else:
+                new_operations.append(operation)
+        return new_operations
+
+    # REDUCTION
+
+    def reduce(self, operation, other, in_between=None):
+        """
+        Either returns a list of zero, one or two operations,
+        or None, meaning this pair cannot be optimized.
+        """
+        for ia, ib, om in self.reduce_methods:
             if isinstance(operation, ia) and isinstance(other, ib):
                 return om(operation, other, in_between or [])
         return None
@@ -336,32 +348,22 @@ def reduce_rename_field_self(self, operation, other, in_between):
                 ),
             ]
 
-    #### THROUGH CHECKS ####
+    # THROUGH CHECKS
 
     def can_optimize_through(self, operation, other, app_label=None):
         """
         Returns True if it's possible to optimize 'operation' with something
         the other side of 'other'. This is possible if, for example, they
         affect different models.
         """
-        MODEL_LEVEL_OPERATIONS = (
-            migrations.CreateModel,
-            migrations.AlterModelTable,
-            migrations.AlterUniqueTogether,
-            migrations.AlterIndexTogether,
-        )
-        FIELD_LEVEL_OPERATIONS = (
-            migrations.AddField,
-            migrations.AlterField,
-        )
         # If it's a model level operation, let it through if there's
         # nothing that looks like a reference to us in 'other'.
-        if isinstance(operation, MODEL_LEVEL_OPERATIONS):
+        if isinstance(operation, self.model_level_operations):
             if not other.references_model(operation.name, app_label):
                 return True
         # If it's field level, only let it through things that don't reference
         # the field (which includes not referencing the model)
-        if isinstance(operation, FIELD_LEVEL_OPERATIONS):
+        if isinstance(operation, self.field_level_operations):
             if not other.references_field(operation.model_name, operation.name, app_label):
                 return True
         return False