1 import copy

     2 

     3 from django.db.models.query import QuerySet, EmptyQuerySet, insert_query

     4 from django.dispatch import dispatcher

     5 from django.db.models import signals

     6 from django.db.models.fields import FieldDoesNotExist

     7 

     8 def ensure_default_manager(sender):

     9     cls = sender

    10     if not getattr(cls, '_default_manager', None) and not cls._meta.abstract:

    11         # Create the default manager, if needed.

    12         try:

    13             cls._meta.get_field('objects')

    14             raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__

    15         except FieldDoesNotExist:

    16             pass

    17         cls.add_to_class('objects', Manager())

    18 

    19 dispatcher.connect(ensure_default_manager, signal=signals.class_prepared)

    20 

    21 class Manager(object):

    22     # Tracks each time a Manager instance is created. Used to retain order.

    23     creation_counter = 0

    24 

    25     def __init__(self):

    26         super(Manager, self).__init__()

    27         # Increase the creation counter, and save our local copy.

    28         self.creation_counter = Manager.creation_counter

    29         Manager.creation_counter += 1

    30         self.model = None

    31 

    32     def contribute_to_class(self, model, name):

    33         # TODO: Use weakref because of possible memory leak / circular reference.

    34         self.model = model

    35         setattr(model, name, ManagerDescriptor(self))

    36         if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:

    37             model._default_manager = self

    38 

    39     def _copy_to_model(self, model):

    40         """

    41         Makes a copy of the manager and assigns it to 'model', which should be

    42         a child of the existing model (used when inheriting a manager from an

    43         abstract base class).

    44         """

    45         assert issubclass(model, self.model)

    46         mgr = copy.copy(self)

    47         mgr.model = model

    48         return mgr

    49 

    50     #######################

    51     # PROXIES TO QUERYSET #

    52     #######################

    53 

    54     def get_empty_query_set(self):

    55         return EmptyQuerySet(self.model)

    56 

    57     def get_query_set(self):

    58         """Returns a new QuerySet object.  Subclasses can override this method

    59         to easily customize the behavior of the Manager.

    60         """

    61         return QuerySet(self.model)

    62 

    63     def none(self):

    64         return self.get_empty_query_set()

    65 

    66     def all(self):

    67         return self.get_query_set()

    68 

    69     def count(self):

    70         return self.get_query_set().count()

    71 

    72     def dates(self, *args, **kwargs):

    73         return self.get_query_set().dates(*args, **kwargs)

    74 

    75     def distinct(self, *args, **kwargs):

    76         return self.get_query_set().distinct(*args, **kwargs)

    77 

    78     def extra(self, *args, **kwargs):

    79         return self.get_query_set().extra(*args, **kwargs)

    80 

    81     def get(self, *args, **kwargs):

    82         return self.get_query_set().get(*args, **kwargs)

    83 

    84     def get_or_create(self, **kwargs):

    85         return self.get_query_set().get_or_create(**kwargs)

    86 

    87     def create(self, **kwargs):

    88         return self.get_query_set().create(**kwargs)

    89 

    90     def filter(self, *args, **kwargs):

    91         return self.get_query_set().filter(*args, **kwargs)

    92 

    93     def complex_filter(self, *args, **kwargs):

    94         return self.get_query_set().complex_filter(*args, **kwargs)

    95 

    96     def exclude(self, *args, **kwargs):

    97         return self.get_query_set().exclude(*args, **kwargs)

    98 

    99     def in_bulk(self, *args, **kwargs):

   100         return self.get_query_set().in_bulk(*args, **kwargs)

   101 

   102     def iterator(self, *args, **kwargs):

   103         return self.get_query_set().iterator(*args, **kwargs)

   104 

   105     def latest(self, *args, **kwargs):

   106         return self.get_query_set().latest(*args, **kwargs)

   107 

   108     def order_by(self, *args, **kwargs):

   109         return self.get_query_set().order_by(*args, **kwargs)

   110 

   111     def select_related(self, *args, **kwargs):

   112         return self.get_query_set().select_related(*args, **kwargs)

   113 

   114     def values(self, *args, **kwargs):

   115         return self.get_query_set().values(*args, **kwargs)

   116 

   117     def values_list(self, *args, **kwargs):

   118         return self.get_query_set().values_list(*args, **kwargs)

   119 

   120     def update(self, *args, **kwargs):

   121         return self.get_query_set().update(*args, **kwargs)

   122 

   123     def reverse(self, *args, **kwargs):

   124         return self.get_query_set().reverse(*args, **kwargs)

   125 

   126     def _insert(self, values, **kwargs):

   127         return insert_query(self.model, values, **kwargs)

   128 

   129     def _update(self, values, **kwargs):

   130         return self.get_query_set()._update(values, **kwargs)

   131 

   132 class ManagerDescriptor(object):

   133     # This class ensures managers aren't accessible via model instances.

   134     # For example, Poll.objects works, but poll_obj.objects raises AttributeError.

   135     def __init__(self, manager):

   136         self.manager = manager

   137 

   138     def __get__(self, instance, type=None):

   139         if instance != None:

   140             raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__

   141         return self.manager

   142 

   143 class EmptyManager(Manager):

   144     def get_query_set(self):

   145         return self.get_empty_query_set()