Ticket #7154: 7154.copy-managers.r7787.diff

django/db/models/base.py

@@ -73 +73 @@
                 if not hasattr(meta, 'get_latest_by'):
                     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
-
         # Bail out early if we have already created this class.
         m = get_model(new_class._meta.app_label, name, False)
         if m is not None:
@@ -109 +102 @@
                     new_class.add_to_class(attr_name, field)
                 new_class._meta.parents[base] = field
             else:
-                # The abstract base class case.
+                # Copy fields from the abstract base class.
                 names = set([f.name for f in new_class._meta.local_fields + new_class._meta.many_to_many])
                 for field in base._meta.local_fields + base._meta.local_many_to_many:
                     if field.name in names:
@@ -117 +110 @@
                                 % (field.name, name, base.__name__))
                     new_class.add_to_class(field.name, copy.deepcopy(field))
 
+            # Copy managers from the base model.
+            for mgr_attr, mgr in base._meta.managers.iteritems():
+                if mgr_attr in new_class.__dict__:
+                    continue
+                new_class.add_to_class(mgr_attr, copy.copy(mgr))
+
         if abstract:
             # Abstract base models can't be instantiated and don't appear in
             # the list of models for an app. We do the final setup for them a
@@ -125 +124 @@
             new_class.Meta = attr_meta
             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/db/models/manager.py

@@ -31 +31 @@
 
     def contribute_to_class(self, model, name):
         # TODO: Use weakref because of possible memory leak / circular reference.
+        model._meta.managers[name] = self
+        if model._meta.abstract:
+            return
         self.model = model
         setattr(model, name, ManagerDescriptor(self))
-        if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:
-            model._default_manager = self
+        if not getattr(model, '_default_manager', None) or self.creation_counter <= model._default_manager.creation_counter:
+            # If the creation_counter is less than the creation_counter of
+            # the  default manager, it is defined before the given default
+            # manager, so we set the default manager, that when all managers
+            # were contributed to the model, the first defined is the
+            # default manager. 
 
-    def _copy_to_model(self, model):
-        """
-        Makes a copy of the manager and assigns it to 'model', which should be
-        a child of the existing model (used when inheriting a manager from an
-        abstract base class).
-        """
-        assert issubclass(model, self.model)
-        mgr = copy.copy(self)
-        mgr.model = model
-        return mgr
+            # If the creation_counter is equals the creation_counter of the
+            # default manager, it is the same manager in a derived model and
+            # we have to update it, because of its model attribute is
+            # incorrect now.
+            model._default_manager = self        
 
     #######################
     # PROXIES TO QUERYSET #

django/db/models/options.py

@@ -45 +45 @@
         self.abstract = False
         self.parents = SortedDict()
         self.duplicate_targets = {}
+        self.managers = {}
 
     def contribute_to_class(self, cls, name):
         from django.db import connection

tests/modeltests/custom_managers/models.py

@@ -44 +44 @@
 
 # An example of providing multiple custom managers.
 
+class SlowCarManager(models.Manager):
+    def get_query_set(self):
+        return super(SlowCarManager, self).get_query_set().filter(top_speed__lte=124)
+
+class MediumFastCarManager(models.Manager):
+    def get_query_set(self):
+        return super(MediumFastCarManager, self).get_query_set().filter(top_speed__range=(125, 149))
+
 class FastCarManager(models.Manager):
     def get_query_set(self):
-        return super(FastCarManager, self).get_query_set().filter(top_speed__gt=150)
+        return super(FastCarManager, self).get_query_set().filter(top_speed__range=(150, 174))
 
+class VeryFastCarManager(models.Manager):
+    def get_query_set(self):
+        return super(VeryFastCarManager, self).get_query_set().filter(top_speed__range=(175, 199))
+
+class ReallyFastCarManager(models.Manager):
+    def get_query_set(self):
+        return super(ReallyFastCarManager, self).get_query_set().filter(top_speed__gte=200)
+
 class Car(models.Model):
     name = models.CharField(max_length=10)
     mileage = models.IntegerField()
     top_speed = models.IntegerField(help_text="In miles per hour.")
+
+    # We need a large number of managers to see whether it is really the first
+    # defined, which becomes the default manager, due to python's dict internal.
     cars = models.Manager()
+    slow_cars = SlowCarManager()
+    medium_fast_cars = MediumFastCarManager()
     fast_cars = FastCarManager()
+    very_fast_cars = VeryFastCarManager()
+    really_fast_cars =  ReallyFastCarManager()
 
     def __unicode__(self):
         return self.name
@@ -90 +113 @@
 
 >>> Book.published_objects.all()
 [<Book: How to program>]
-
 >>> c1 = Car(name='Corvette', mileage=21, top_speed=180)
 >>> c1.save()
 >>> c2 = Car(name='Neon', mileage=31, top_speed=100)
 >>> c2.save()
 >>> Car.cars.order_by('name')
 [<Car: Corvette>, <Car: Neon>]
->>> Car.fast_cars.all()
+>>> Car.very_fast_cars.all()
 [<Car: Corvette>]
 
 # Each model class gets a "_default_manager" attribute, which is a reference
-# to the first manager defined in the class. In this case, it's "cars".
->>> Car._default_manager.order_by('name')
-[<Car: Corvette>, <Car: Neon>]
+# to the first manager defined in the class.
+>>> Car._default_manager
+<django.db.models.manager.Manager object at ...>
+
 """}

tests/modeltests/model_inheritance/models.py

@@ -18 +18 @@
 # Abstract base classes
 #
 
+class AdultManager(models.Manager):
+    def get_query_set(self):
+        return super(AdultManager, self).get_query_set().filter(age__gte=18)
+
+class Adult21Manager(models.Manager):
+    def get_query_set(self):
+        return super(Adult21Manager, self).get_query_set().filter(age__gte=21)
+
 class CommonInfo(models.Model):
     name = models.CharField(max_length=50)
     age = models.PositiveIntegerField()
 
+    objects = models.Manager()
+    adults = AdultManager()
+
     class Meta:
         abstract = True
         ordering = ['name']
@@ -30 +41 @@
         return u'%s %s' % (self.__class__.__name__, self.name)
 
 class Worker(CommonInfo):
+    adults = Adult21Manager()
+
     job = models.CharField(max_length=50)
 
 class Student(CommonInfo):
@@ -115 +128 @@
 
     def __unicode__(self):
         return u"%s the parking lot" % self.name
+        
+class A(models.Model):
+    a = models.IntegerField()
 
+    class Meta:
+        abstract = True
+
+class PositiveBManager(models.Manager):
+    def get_query_set(self):
+        return super(PositiveBManager, self).get_query_set().filter(b__gte=0)
+        
+class B(A):
+    b = models.IntegerField()
+    positive = PositiveBManager()
+
 __test__ = {'API_TESTS':"""
 # The Student and Worker models both have 'name' and 'age' fields on them and
 # inherit the __unicode__() method, just as with normal Python subclassing.
@@ -125 +152 @@
 
 >>> w = Worker(name='Fred', age=35, job='Quarry worker')
 >>> w.save()
->>> w2 = Worker(name='Barney', age=34, job='Quarry worker')
+>>> w2 = Worker(name='Barney', age=20, job='Quarry worker')
 >>> w2.save()
 >>> s = Student(name='Pebbles', age=5, school_class='1B')
 >>> s.save()
@@ -144 +171 @@
 >>> Student._meta.ordering
 []
 
+# The children inherit the custom managers from their parents, but children can
+# still override it.
+>>> Student(name='Bill', age=18, school_class='11A').save()
+>>> Student.adults.all()
+[<Student: Student Bill>]
+
+>>> Worker.adults.all()
+[<Worker: Worker Fred>]
+
 # However, the CommonInfo class cannot be used as a normal model (it doesn't
 # exist as a model).
 >>> CommonInfo.objects.all()
@@ -309 +345 @@
 3
 >>> settings.DEBUG = False
 
+>>> isinstance(B._default_manager, PositiveBManager)
+True
+
 """}