Changeset 8851

Timestamp:

09/02/08 04:04:54 (3 months ago)

Author:

mtredinnick

Message:

Fixed #7154 -- Inherit all model managers from abstract base classes.
Also added documentation describing how manager inheritance works (and when
manager aren't inherited). Based on some patches from sebastian_noack and
emulbreh.

Files:

• django/trunk/django/db/models/base.py (modified) (3 diffs)
• django/trunk/django/db/models/manager.py (modified) (3 diffs)
• django/trunk/django/db/models/options.py (modified) (1 diff)
• django/trunk/docs/topics/db/managers.txt (modified) (1 diff)
• django/trunk/tests/regressiontests/managers_regress (added)
• django/trunk/tests/regressiontests/managers_regress/__init__.py (added)
• django/trunk/tests/regressiontests/managers_regress/models.py (added)

django/trunk/django/db/models/base.py

@@ -68 +68 @@
-                    new_class._meta.get_latest_by = base_meta.get_latest_by
-
-        old_default_mgr = None
-        if getattr(new_class, '_default_manager', None):
-            # We have a parent who set the default manager.
-            if new_class._default_manager.model._meta.abstract:
-                old_default_mgr = new_class._default_manager
-            new_class._default_manager = None
-
@@ -112 +108 @@
-                    new_class.add_to_class(field.name, copy.deepcopy(field))
-
+            # Inherit managers from the abstract base classes.
+            base_managers = base._meta.abstract_managers
+            base_managers.sort()
+            for _, mgr_name, manager in base_managers:
+                val = getattr(new_class, mgr_name, None)
+                if not val or val is manager:
+                    new_manager = manager._copy_to_model(new_class)
+                    new_class.add_to_class(mgr_name, new_manager)
-        if abstract:
-            # Abstract base models can't be instantiated and don't appear in
@@ -120 +124 @@
-            return new_class
-
-        if old_default_mgr and not new_class._default_manager:
-            new_class._default_manager = old_default_mgr._copy_to_model(new_class)
-        new_class._prepare()
-        register_models(new_class._meta.app_label, new_class)

django/trunk/django/db/models/manager.py

@@ -24 +24 @@
-    def __init__(self):
-        super(Manager, self).__init__()
-
-
-
+
-        self.model = None
+        self._inherited = False
-
-    def contribute_to_class(self, model, name):
@@ -35 +34 @@
-        if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:
-            model._default_manager = self
+        if model._meta.abstract or self._inherited:
+            model._meta.abstract_managers.append((self.creation_counter, name,
+                    self))
+
+    def _set_creation_counter(self):
+        """
+        Sets the creation counter value for this instance and increments the
+        class-level copy.
+        """
+        self.creation_counter = Manager.creation_counter
+        Manager.creation_counter += 1
-
-    def _copy_to_model(self, model):
@@ -44 +54 @@
-        assert issubclass(model, self.model)
-        mgr = copy.copy(self)
+        mgr._set_creation_counter()
-        mgr.model = model
+        mgr._inherited = True
-        return mgr
-

django/trunk/django/db/models/options.py

@@ -45 +45 @@
-        self.parents = SortedDict()
-        self.duplicate_targets = {}
+        # Managers that have been inherited from abstract base classes. These
+        # are passed onto any children.
+        self.abstract_managers = []
-
-    def contribute_to_class(self, cls, name):

django/trunk/docs/topics/db/managers.txt

@@ -190 +190 @@
-
-        ...
+
+Custom managers and model inheritance
+-------------------------------------
+
+Class inheritance and model managers aren't quite a perfect match for each
+other. Managers are often specific to the classes they are defined on and
+inheriting them in subclasses isn't necessarily a good idea. Also, because the
+first manager declared is the *default manager*, it is important to allow that
+to be controlled. So here's how Django handles custom managers and
+:ref:`model inheritance <model-inheritance>`:
+
+    1. Managers defined on non-abstract base classes are *not* inherited by
+       child classes. If you want to reuse a manager from a non-abstract base,
+       redeclare it explicitly on the child class. These sorts of managers are
+       likely to be fairly specific to the class they are defined on, so
+       inheriting them can often lead to unexpected results (particularly as
+       far as the default manager goes). Therefore, they aren't passed onto
+       child classes.
+
+    2. Managers from abstract base classes are always inherited by the child
+       class, using Python's normal name resolution order (names on the child
+       class override all others; then come names on the first parent class,
+       and so on). Abstract base classes are designed to capture information
+       and behaviour that is common to their child classes. Defining common
+       managers is an appropriate part of this common information.
+
+    3. The default manager on a class is either the first manager declared on
+       the class, if that exists, or the default manager of the first abstract
+       base class in the parent hierarchy, if that exists. If no default
+       manager is explicitly declared, Django's normal default manager is
+       used.
+