Django--Managers

Manager

概念：

1.Manager是Django中的数据模型，可以通过manager进行对数据库的查询操作。可以看其结构它本身是一个空的类，其主要的功能来自于BaseManager，QuerySet。

2.在Django中的模型类中每个模型类中至少存在一个Manager。

3.默认情况下Django为每一个模型类添加了Manager其名称为objects。为了区别每个模型类你可以对每个模型类进行重新命名。方法如下，就是将对manage的类属性进行重新的赋值。

class Manager(BaseManager.from_queryset(QuerySet)):
    pass

class BaseManager

class BaseManager:
    # To retain order, track each time a Manager instance is created.
    creation_counter = 0

    # Set to True for the 'objects' managers that are automatically created.
    auto_created = False

    #: If set to True the manager will be serialized into migrations and will
    #: thus be available in e.g. RunPython operations.
    use_in_migrations = False

    def __new__(cls, *args, **kwargs):
        # Capture the arguments to make returning them trivial.
        obj = super().__new__(cls)
        obj._constructor_args = (args, kwargs)
        return obj

    def __init__(self):
        super().__init__()
        self._set_creation_counter()
        self.model = None
        self.name = None
        self._db = None
        self._hints = {}

    def __str__(self):
        """Return "app_label.model_label.manager_name"."""
        return '%s.%s' % (self.model._meta.label, self.name)

    def deconstruct(self):
        """
        Return a 5-tuple of the form (as_manager (True), manager_class,
        queryset_class, args, kwargs).

        Raise a ValueError if the manager is dynamically generated.
        """
        qs_class = self._queryset_class
        if getattr(self, '_built_with_as_manager', False):
            # using MyQuerySet.as_manager()
            return (
                True,  # as_manager
                None,  # manager_class
                '%s.%s' % (qs_class.__module__, qs_class.__name__),  # qs_class
                None,  # args
                None,  # kwargs
            )
        else:
            module_name = self.__module__
            name = self.__class__.__name__
            # Make sure it's actually there and not an inner class
            module = import_module(module_name)
            if not hasattr(module, name):
                raise ValueError(
                    "Could not find manager %s in %s.
"
                    "Please note that you need to inherit from managers you "
                    "dynamically generated with 'from_queryset()'."
                    % (name, module_name)
                )
            return (
                False,  # as_manager
                '%s.%s' % (module_name, name),  # manager_class
                None,  # qs_class
                self._constructor_args[0],  # args
                self._constructor_args[1],  # kwargs
            )

    def check(self, **kwargs):
        return []

    @classmethod
    def _get_queryset_methods(cls, queryset_class):
        def create_method(name, method):
            def manager_method(self, *args, **kwargs):
                return getattr(self.get_queryset(), name)(*args, **kwargs)
            manager_method.__name__ = method.__name__
            manager_method.__doc__ = method.__doc__
            return manager_method

        new_methods = {}
        for name, method in inspect.getmembers(queryset_class, predicate=inspect.isfunction):
            # Only copy missing methods.
            if hasattr(cls, name):
                continue
            # Only copy public methods or methods with the attribute `queryset_only=False`.
            queryset_only = getattr(method, 'queryset_only', None)
            if queryset_only or (queryset_only is None and name.startswith('_')):
                continue
            # Copy the method onto the manager.
            new_methods[name] = create_method(name, method)
        return new_methods

    @classmethod
    def from_queryset(cls, queryset_class, class_name=None):
        if class_name is None:
            class_name = '%sFrom%s' % (cls.__name__, queryset_class.__name__)
        class_dict = {
            '_queryset_class': queryset_class,
        }
        class_dict.update(cls._get_queryset_methods(queryset_class))
        return type(class_name, (cls,), class_dict)

    def contribute_to_class(self, model, name):
        if not self.name:
            self.name = name
        self.model = model

        setattr(model, name, ManagerDescriptor(self))

        model._meta.add_manager(self)

    def _set_creation_counter(self):
        """
        Set the creation counter value for this instance and increment the
        class-level copy.
        """
        self.creation_counter = BaseManager.creation_counter
        BaseManager.creation_counter += 1

    def db_manager(self, using=None, hints=None):
        obj = copy.copy(self)
        obj._db = using or self._db
        obj._hints = hints or self._hints
        return obj

    @property
    def db(self):
        return self._db or router.db_for_read(self.model, **self._hints)

    #######################
    # PROXIES TO QUERYSET #
    #######################

    def get_queryset(self):
        """
        Return a new QuerySet object. Subclasses can override this method to
        customize the behavior of the Manager.
        """
        return self._queryset_class(model=self.model, using=self._db, hints=self._hints)

    def all(self):
        # We can't proxy this method through the `QuerySet` like we do for the
        # rest of the `QuerySet` methods. This is because `QuerySet.all()`
        # works by creating a "copy" of the current queryset and in making said
        # copy, all the cached `prefetch_related` lookups are lost. See the
        # implementation of `RelatedManager.get_queryset()` for a better
        # understanding of how this comes into play.
        return self.get_queryset()

    def __eq__(self, other):
        return (
            isinstance(other, self.__class__) and
            self._constructor_args == other._constructor_args
        )

    def __hash__(self):
        return id(self)

View Code

class QuerySet

   1 class QuerySet:
   2     """Represent a lazy database lookup for a set of objects."""
   3 
   4     def __init__(self, model=None, query=None, using=None, hints=None):
   5         self.model = model
   6         self._db = using
   7         self._hints = hints or {}
   8         self.query = query or sql.Query(self.model)
   9         self._result_cache = None
  10         self._sticky_filter = False
  11         self._for_write = False
  12         self._prefetch_related_lookups = ()
  13         self._prefetch_done = False
  14         self._known_related_objects = {}  # {rel_field: {pk: rel_obj}}
  15         self._iterable_class = ModelIterable
  16         self._fields = None
  17 
  18     def as_manager(cls):
  19         # Address the circular dependency between `Queryset` and `Manager`.
  20         from django.db.models.manager import Manager
  21         manager = Manager.from_queryset(cls)()
  22         manager._built_with_as_manager = True
  23         return manager
  24     as_manager.queryset_only = True
  25     as_manager = classmethod(as_manager)
  26 
  27     ########################
  28     # PYTHON MAGIC METHODS #
  29     ########################
  30 
  31     def __deepcopy__(self, memo):
  32         """Don't populate the QuerySet's cache."""
  33         obj = self.__class__()
  34         for k, v in self.__dict__.items():
  35             if k == '_result_cache':
  36                 obj.__dict__[k] = None
  37             else:
  38                 obj.__dict__[k] = copy.deepcopy(v, memo)
  39         return obj
  40 
  41     def __getstate__(self):
  42         # Force the cache to be fully populated.
  43         self._fetch_all()
  44         obj_dict = self.__dict__.copy()
  45         obj_dict[DJANGO_VERSION_PICKLE_KEY] = get_version()
  46         return obj_dict
  47 
  48     def __setstate__(self, state):
  49         msg = None
  50         pickled_version = state.get(DJANGO_VERSION_PICKLE_KEY)
  51         if pickled_version:
  52             current_version = get_version()
  53             if current_version != pickled_version:
  54                 msg = (
  55                     "Pickled queryset instance's Django version %s does not "
  56                     "match the current version %s." % (pickled_version, current_version)
  57                 )
  58         else:
  59             msg = "Pickled queryset instance's Django version is not specified."
  60 
  61         if msg:
  62             warnings.warn(msg, RuntimeWarning, stacklevel=2)
  63 
  64         self.__dict__.update(state)
  65 
  66     def __repr__(self):
  67         data = list(self[:REPR_OUTPUT_SIZE + 1])
  68         if len(data) > REPR_OUTPUT_SIZE:
  69             data[-1] = "...(remaining elements truncated)..."
  70         return '<%s %r>' % (self.__class__.__name__, data)
  71 
  72     def __len__(self):
  73         self._fetch_all()
  74         return len(self._result_cache)
  75 
  76     def __iter__(self):
  77         """
  78         The queryset iterator protocol uses three nested iterators in the
  79         default case:
  80             1. sql.compiler:execute_sql()
  81                - Returns 100 rows at time (constants.GET_ITERATOR_CHUNK_SIZE)
  82                  using cursor.fetchmany(). This part is responsible for
  83                  doing some column masking, and returning the rows in chunks.
  84             2. sql.compiler.results_iter()
  85                - Returns one row at time. At this point the rows are still just
  86                  tuples. In some cases the return values are converted to
  87                  Python values at this location.
  88             3. self.iterator()
  89                - Responsible for turning the rows into model objects.
  90         """
  91         self._fetch_all()
  92         return iter(self._result_cache)
  93 
  94     def __bool__(self):
  95         self._fetch_all()
  96         return bool(self._result_cache)
  97 
  98     def __getitem__(self, k):
  99         """Retrieve an item or slice from the set of results."""
 100         if not isinstance(k, (int, slice)):
 101             raise TypeError
 102         assert ((not isinstance(k, slice) and (k >= 0)) or
 103                 (isinstance(k, slice) and (k.start is None or k.start >= 0) and
 104                  (k.stop is None or k.stop >= 0))), 
 105             "Negative indexing is not supported."
 106 
 107         if self._result_cache is not None:
 108             return self._result_cache[k]
 109 
 110         if isinstance(k, slice):
 111             qs = self._chain()
 112             if k.start is not None:
 113                 start = int(k.start)
 114             else:
 115                 start = None
 116             if k.stop is not None:
 117                 stop = int(k.stop)
 118             else:
 119                 stop = None
 120             qs.query.set_limits(start, stop)
 121             return list(qs)[::k.step] if k.step else qs
 122 
 123         qs = self._chain()
 124         qs.query.set_limits(k, k + 1)
 125         qs._fetch_all()
 126         return qs._result_cache[0]
 127 
 128     def __and__(self, other):
 129         self._merge_sanity_check(other)
 130         if isinstance(other, EmptyQuerySet):
 131             return other
 132         if isinstance(self, EmptyQuerySet):
 133             return self
 134         combined = self._chain()
 135         combined._merge_known_related_objects(other)
 136         combined.query.combine(other.query, sql.AND)
 137         return combined
 138 
 139     def __or__(self, other):
 140         self._merge_sanity_check(other)
 141         if isinstance(self, EmptyQuerySet):
 142             return other
 143         if isinstance(other, EmptyQuerySet):
 144             return self
 145         combined = self._chain()
 146         combined._merge_known_related_objects(other)
 147         combined.query.combine(other.query, sql.OR)
 148         return combined
 149 
 150     ####################################
 151     # METHODS THAT DO DATABASE QUERIES #
 152     ####################################
 153 
 154     def _iterator(self, use_chunked_fetch, chunk_size):
 155         yield from self._iterable_class(self, chunked_fetch=use_chunked_fetch, chunk_size=chunk_size)
 156 
 157     def iterator(self, chunk_size=2000):
 158         """
 159         An iterator over the results from applying this QuerySet to the
 160         database.
 161         """
 162         if chunk_size <= 0:
 163             raise ValueError('Chunk size must be strictly positive.')
 164         use_chunked_fetch = not connections[self.db].settings_dict.get('DISABLE_SERVER_SIDE_CURSORS')
 165         return self._iterator(use_chunked_fetch, chunk_size)
 166 
 167     def aggregate(self, *args, **kwargs):
 168         """
 169         Return a dictionary containing the calculations (aggregation)
 170         over the current queryset.
 171 
 172         If args is present the expression is passed as a kwarg using
 173         the Aggregate object's default alias.
 174         """
 175         if self.query.distinct_fields:
 176             raise NotImplementedError("aggregate() + distinct(fields) not implemented.")
 177         self._validate_values_are_expressions(args + tuple(kwargs.values()), method_name='aggregate')
 178         for arg in args:
 179             # The default_alias property raises TypeError if default_alias
 180             # can't be set automatically or AttributeError if it isn't an
 181             # attribute.
 182             try:
 183                 arg.default_alias
 184             except (AttributeError, TypeError):
 185                 raise TypeError("Complex aggregates require an alias")
 186             kwargs[arg.default_alias] = arg
 187 
 188         query = self.query.chain()
 189         for (alias, aggregate_expr) in kwargs.items():
 190             query.add_annotation(aggregate_expr, alias, is_summary=True)
 191             if not query.annotations[alias].contains_aggregate:
 192                 raise TypeError("%s is not an aggregate expression" % alias)
 193         return query.get_aggregation(self.db, kwargs)
 194 
 195     def count(self):
 196         """
 197         Perform a SELECT COUNT() and return the number of records as an
 198         integer.
 199 
 200         If the QuerySet is already fully cached, return the length of the
 201         cached results set to avoid multiple SELECT COUNT(*) calls.
 202         """
 203         if self._result_cache is not None:
 204             return len(self._result_cache)
 205 
 206         return self.query.get_count(using=self.db)
 207 
 208     def get(self, *args, **kwargs):
 209         """
 210         Perform the query and return a single object matching the given
 211         keyword arguments.
 212         """
 213         clone = self.filter(*args, **kwargs)
 214         if self.query.can_filter() and not self.query.distinct_fields:
 215             clone = clone.order_by()
 216         num = len(clone)
 217         if num == 1:
 218             return clone._result_cache[0]
 219         if not num:
 220             raise self.model.DoesNotExist(
 221                 "%s matching query does not exist." %
 222                 self.model._meta.object_name
 223             )
 224         raise self.model.MultipleObjectsReturned(
 225             "get() returned more than one %s -- it returned %s!" %
 226             (self.model._meta.object_name, num)
 227         )
 228 
 229     def create(self, **kwargs):
 230         """
 231         Create a new object with the given kwargs, saving it to the database
 232         and returning the created object.
 233         """
 234         obj = self.model(**kwargs)
 235         self._for_write = True
 236         obj.save(force_insert=True, using=self.db)
 237         return obj
 238 
 239     def _populate_pk_values(self, objs):
 240         for obj in objs:
 241             if obj.pk is None:
 242                 obj.pk = obj._meta.pk.get_pk_value_on_save(obj)
 243 
 244     def bulk_create(self, objs, batch_size=None):
 245         """
 246         Insert each of the instances into the database. Do *not* call
 247         save() on each of the instances, do not send any pre/post_save
 248         signals, and do not set the primary key attribute if it is an
 249         autoincrement field (except if features.can_return_ids_from_bulk_insert=True).
 250         Multi-table models are not supported.
 251         """
 252         # When you bulk insert you don't get the primary keys back (if it's an
 253         # autoincrement, except if can_return_ids_from_bulk_insert=True), so
 254         # you can't insert into the child tables which references this. There
 255         # are two workarounds:
 256         # 1) This could be implemented if you didn't have an autoincrement pk
 257         # 2) You could do it by doing O(n) normal inserts into the parent
 258         #    tables to get the primary keys back and then doing a single bulk
 259         #    insert into the childmost table.
 260         # We currently set the primary keys on the objects when using
 261         # PostgreSQL via the RETURNING ID clause. It should be possible for
 262         # Oracle as well, but the semantics for  extracting the primary keys is
 263         # trickier so it's not done yet.
 264         assert batch_size is None or batch_size > 0
 265         # Check that the parents share the same concrete model with the our
 266         # model to detect the inheritance pattern ConcreteGrandParent ->
 267         # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy
 268         # would not identify that case as involving multiple tables.
 269         for parent in self.model._meta.get_parent_list():
 270             if parent._meta.concrete_model is not self.model._meta.concrete_model:
 271                 raise ValueError("Can't bulk create a multi-table inherited model")
 272         if not objs:
 273             return objs
 274         self._for_write = True
 275         connection = connections[self.db]
 276         fields = self.model._meta.concrete_fields
 277         objs = list(objs)
 278         self._populate_pk_values(objs)
 279         with transaction.atomic(using=self.db, savepoint=False):
 280             objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
 281             if objs_with_pk:
 282                 self._batched_insert(objs_with_pk, fields, batch_size)
 283             if objs_without_pk:
 284                 fields = [f for f in fields if not isinstance(f, AutoField)]
 285                 ids = self._batched_insert(objs_without_pk, fields, batch_size)
 286                 if connection.features.can_return_ids_from_bulk_insert:
 287                     assert len(ids) == len(objs_without_pk)
 288                 for obj_without_pk, pk in zip(objs_without_pk, ids):
 289                     obj_without_pk.pk = pk
 290                     obj_without_pk._state.adding = False
 291                     obj_without_pk._state.db = self.db
 292 
 293         return objs
 294 
 295     def get_or_create(self, defaults=None, **kwargs):
 296         """
 297         Look up an object with the given kwargs, creating one if necessary.
 298         Return a tuple of (object, created), where created is a boolean
 299         specifying whether an object was created.
 300         """
 301         lookup, params = self._extract_model_params(defaults, **kwargs)
 302         # The get() needs to be targeted at the write database in order
 303         # to avoid potential transaction consistency problems.
 304         self._for_write = True
 305         try:
 306             return self.get(**lookup), False
 307         except self.model.DoesNotExist:
 308             return self._create_object_from_params(lookup, params)
 309 
 310     def update_or_create(self, defaults=None, **kwargs):
 311         """
 312         Look up an object with the given kwargs, updating one with defaults
 313         if it exists, otherwise create a new one.
 314         Return a tuple (object, created), where created is a boolean
 315         specifying whether an object was created.
 316         """
 317         defaults = defaults or {}
 318         lookup, params = self._extract_model_params(defaults, **kwargs)
 319         self._for_write = True
 320         with transaction.atomic(using=self.db):
 321             try:
 322                 obj = self.select_for_update().get(**lookup)
 323             except self.model.DoesNotExist:
 324                 obj, created = self._create_object_from_params(lookup, params)
 325                 if created:
 326                     return obj, created
 327             for k, v in defaults.items():
 328                 setattr(obj, k, v() if callable(v) else v)
 329             obj.save(using=self.db)
 330         return obj, False
 331 
 332     def _create_object_from_params(self, lookup, params):
 333         """
 334         Try to create an object using passed params. Used by get_or_create()
 335         and update_or_create().
 336         """
 337         try:
 338             with transaction.atomic(using=self.db):
 339                 params = {k: v() if callable(v) else v for k, v in params.items()}
 340                 obj = self.create(**params)
 341             return obj, True
 342         except IntegrityError as e:
 343             try:
 344                 return self.get(**lookup), False
 345             except self.model.DoesNotExist:
 346                 pass
 347             raise e
 348 
 349     def _extract_model_params(self, defaults, **kwargs):
 350         """
 351         Prepare `lookup` (kwargs that are valid model attributes), `params`
 352         (for creating a model instance) based on given kwargs; for use by
 353         get_or_create() and update_or_create().
 354         """
 355         defaults = defaults or {}
 356         lookup = kwargs.copy()
 357         for f in self.model._meta.fields:
 358             if f.attname in lookup:
 359                 lookup[f.name] = lookup.pop(f.attname)
 360         params = {k: v for k, v in kwargs.items() if LOOKUP_SEP not in k}
 361         params.update(defaults)
 362         property_names = self.model._meta._property_names
 363         invalid_params = []
 364         for param in params:
 365             try:
 366                 self.model._meta.get_field(param)
 367             except exceptions.FieldDoesNotExist:
 368                 # It's okay to use a model's property if it has a setter.
 369                 if not (param in property_names and getattr(self.model, param).fset):
 370                     invalid_params.append(param)
 371         if invalid_params:
 372             raise exceptions.FieldError(
 373                 "Invalid field name(s) for model %s: '%s'." % (
 374                     self.model._meta.object_name,
 375                     "', '".join(sorted(invalid_params)),
 376                 ))
 377         return lookup, params
 378 
 379     def _earliest_or_latest(self, *fields, field_name=None):
 380         """
 381         Return the latest object, according to the model's
 382         'get_latest_by' option or optional given field_name.
 383         """
 384         if fields and field_name is not None:
 385             raise ValueError('Cannot use both positional arguments and the field_name keyword argument.')
 386 
 387         order_by = None
 388         if field_name is not None:
 389             warnings.warn(
 390                 'The field_name keyword argument to earliest() and latest() '
 391                 'is deprecated in favor of passing positional arguments.',
 392                 RemovedInDjango30Warning,
 393             )
 394             order_by = (field_name,)
 395         elif fields:
 396             order_by = fields
 397         else:
 398             order_by = getattr(self.model._meta, 'get_latest_by')
 399             if order_by and not isinstance(order_by, (tuple, list)):
 400                 order_by = (order_by,)
 401         if order_by is None:
 402             raise ValueError(
 403                 "earliest() and latest() require either fields as positional "
 404                 "arguments or 'get_latest_by' in the model's Meta."
 405             )
 406 
 407         assert self.query.can_filter(), 
 408             "Cannot change a query once a slice has been taken."
 409         obj = self._chain()
 410         obj.query.set_limits(high=1)
 411         obj.query.clear_ordering(force_empty=True)
 412         obj.query.add_ordering(*order_by)
 413         return obj.get()
 414 
 415     def earliest(self, *fields, field_name=None):
 416         return self._earliest_or_latest(*fields, field_name=field_name)
 417 
 418     def latest(self, *fields, field_name=None):
 419         return self.reverse()._earliest_or_latest(*fields, field_name=field_name)
 420 
 421     def first(self):
 422         """Return the first object of a query or None if no match is found."""
 423         for obj in (self if self.ordered else self.order_by('pk'))[:1]:
 424             return obj
 425 
 426     def last(self):
 427         """Return the last object of a query or None if no match is found."""
 428         for obj in (self.reverse() if self.ordered else self.order_by('-pk'))[:1]:
 429             return obj
 430 
 431     def in_bulk(self, id_list=None, *, field_name='pk'):
 432         """
 433         Return a dictionary mapping each of the given IDs to the object with
 434         that ID. If `id_list` isn't provided, evaluate the entire QuerySet.
 435         """
 436         assert self.query.can_filter(), 
 437             "Cannot use 'limit' or 'offset' with in_bulk"
 438         if field_name != 'pk' and not self.model._meta.get_field(field_name).unique:
 439             raise ValueError("in_bulk()'s field_name must be a unique field but %r isn't." % field_name)
 440         if id_list is not None:
 441             if not id_list:
 442                 return {}
 443             filter_key = '{}__in'.format(field_name)
 444             batch_size = connections[self.db].features.max_query_params
 445             id_list = tuple(id_list)
 446             # If the database has a limit on the number of query parameters
 447             # (e.g. SQLite), retrieve objects in batches if necessary.
 448             if batch_size and batch_size < len(id_list):
 449                 qs = ()
 450                 for offset in range(0, len(id_list), batch_size):
 451                     batch = id_list[offset:offset + batch_size]
 452                     qs += tuple(self.filter(**{filter_key: batch}).order_by())
 453             else:
 454                 qs = self.filter(**{filter_key: id_list}).order_by()
 455         else:
 456             qs = self._chain()
 457         return {getattr(obj, field_name): obj for obj in qs}
 458 
 459     def delete(self):
 460         """Delete the records in the current QuerySet."""
 461         assert self.query.can_filter(), 
 462             "Cannot use 'limit' or 'offset' with delete."
 463 
 464         if self._fields is not None:
 465             raise TypeError("Cannot call delete() after .values() or .values_list()")
 466 
 467         del_query = self._chain()
 468 
 469         # The delete is actually 2 queries - one to find related objects,
 470         # and one to delete. Make sure that the discovery of related
 471         # objects is performed on the same database as the deletion.
 472         del_query._for_write = True
 473 
 474         # Disable non-supported fields.
 475         del_query.query.select_for_update = False
 476         del_query.query.select_related = False
 477         del_query.query.clear_ordering(force_empty=True)
 478 
 479         collector = Collector(using=del_query.db)
 480         collector.collect(del_query)
 481         deleted, _rows_count = collector.delete()
 482 
 483         # Clear the result cache, in case this QuerySet gets reused.
 484         self._result_cache = None
 485         return deleted, _rows_count
 486 
 487     delete.alters_data = True
 488     delete.queryset_only = True
 489 
 490     def _raw_delete(self, using):
 491         """
 492         Delete objects found from the given queryset in single direct SQL
 493         query. No signals are sent and there is no protection for cascades.
 494         """
 495         return sql.DeleteQuery(self.model).delete_qs(self, using)
 496     _raw_delete.alters_data = True
 497 
 498     def update(self, **kwargs):
 499         """
 500         Update all elements in the current QuerySet, setting all the given
 501         fields to the appropriate values.
 502         """
 503         assert self.query.can_filter(), 
 504             "Cannot update a query once a slice has been taken."
 505         self._for_write = True
 506         query = self.query.chain(sql.UpdateQuery)
 507         query.add_update_values(kwargs)
 508         # Clear any annotations so that they won't be present in subqueries.
 509         query._annotations = None
 510         with transaction.atomic(using=self.db, savepoint=False):
 511             rows = query.get_compiler(self.db).execute_sql(CURSOR)
 512         self._result_cache = None
 513         return rows
 514     update.alters_data = True
 515 
 516     def _update(self, values):
 517         """
 518         A version of update() that accepts field objects instead of field names.
 519         Used primarily for model saving and not intended for use by general
 520         code (it requires too much poking around at model internals to be
 521         useful at that level).
 522         """
 523         assert self.query.can_filter(), 
 524             "Cannot update a query once a slice has been taken."
 525         query = self.query.chain(sql.UpdateQuery)
 526         query.add_update_fields(values)
 527         self._result_cache = None
 528         return query.get_compiler(self.db).execute_sql(CURSOR)
 529     _update.alters_data = True
 530     _update.queryset_only = False
 531 
 532     def exists(self):
 533         if self._result_cache is None:
 534             return self.query.has_results(using=self.db)
 535         return bool(self._result_cache)
 536 
 537     def _prefetch_related_objects(self):
 538         # This method can only be called once the result cache has been filled.
 539         prefetch_related_objects(self._result_cache, *self._prefetch_related_lookups)
 540         self._prefetch_done = True
 541 
 542     ##################################################
 543     # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
 544     ##################################################
 545 
 546     def raw(self, raw_query, params=None, translations=None, using=None):
 547         if using is None:
 548             using = self.db
 549         return RawQuerySet(raw_query, model=self.model, params=params, translations=translations, using=using)
 550 
 551     def _values(self, *fields, **expressions):
 552         clone = self._chain()
 553         if expressions:
 554             clone = clone.annotate(**expressions)
 555         clone._fields = fields
 556         clone.query.set_values(fields)
 557         return clone
 558 
 559     def values(self, *fields, **expressions):
 560         fields += tuple(expressions)
 561         clone = self._values(*fields, **expressions)
 562         clone._iterable_class = ValuesIterable
 563         return clone
 564 
 565     def values_list(self, *fields, flat=False, named=False):
 566         if flat and named:
 567             raise TypeError("'flat' and 'named' can't be used together.")
 568         if flat and len(fields) > 1:
 569             raise TypeError("'flat' is not valid when values_list is called with more than one field.")
 570 
 571         field_names = {f for f in fields if not hasattr(f, 'resolve_expression')}
 572         _fields = []
 573         expressions = {}
 574         counter = 1
 575         for field in fields:
 576             if hasattr(field, 'resolve_expression'):
 577                 field_id_prefix = getattr(field, 'default_alias', field.__class__.__name__.lower())
 578                 while True:
 579                     field_id = field_id_prefix + str(counter)
 580                     counter += 1
 581                     if field_id not in field_names:
 582                         break
 583                 expressions[field_id] = field
 584                 _fields.append(field_id)
 585             else:
 586                 _fields.append(field)
 587 
 588         clone = self._values(*_fields, **expressions)
 589         clone._iterable_class = (
 590             NamedValuesListIterable if named
 591             else FlatValuesListIterable if flat
 592             else ValuesListIterable
 593         )
 594         return clone
 595 
 596     def dates(self, field_name, kind, order='ASC'):
 597         """
 598         Return a list of date objects representing all available dates for
 599         the given field_name, scoped to 'kind'.
 600         """
 601         assert kind in ("year", "month", "day"), 
 602             "'kind' must be one of 'year', 'month' or 'day'."
 603         assert order in ('ASC', 'DESC'), 
 604             "'order' must be either 'ASC' or 'DESC'."
 605         return self.annotate(
 606             datefield=Trunc(field_name, kind, output_field=DateField()),
 607             plain_field=F(field_name)
 608         ).values_list(
 609             'datefield', flat=True
 610         ).distinct().filter(plain_field__isnull=False).order_by(('-' if order == 'DESC' else '') + 'datefield')
 611 
 612     def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
 613         """
 614         Return a list of datetime objects representing all available
 615         datetimes for the given field_name, scoped to 'kind'.
 616         """
 617         assert kind in ("year", "month", "day", "hour", "minute", "second"), 
 618             "'kind' must be one of 'year', 'month', 'day', 'hour', 'minute' or 'second'."
 619         assert order in ('ASC', 'DESC'), 
 620             "'order' must be either 'ASC' or 'DESC'."
 621         if settings.USE_TZ:
 622             if tzinfo is None:
 623                 tzinfo = timezone.get_current_timezone()
 624         else:
 625             tzinfo = None
 626         return self.annotate(
 627             datetimefield=Trunc(field_name, kind, output_field=DateTimeField(), tzinfo=tzinfo),
 628             plain_field=F(field_name)
 629         ).values_list(
 630             'datetimefield', flat=True
 631         ).distinct().filter(plain_field__isnull=False).order_by(('-' if order == 'DESC' else '') + 'datetimefield')
 632 
 633     def none(self):
 634         """Return an empty QuerySet."""
 635         clone = self._chain()
 636         clone.query.set_empty()
 637         return clone
 638 
 639     ##################################################################
 640     # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
 641     ##################################################################
 642 
 643     def all(self):
 644         """
 645         Return a new QuerySet that is a copy of the current one. This allows a
 646         QuerySet to proxy for a model manager in some cases.
 647         """
 648         return self._chain()
 649 
 650     def filter(self, *args, **kwargs):
 651         """
 652         Return a new QuerySet instance with the args ANDed to the existing
 653         set.
 654         """
 655         return self._filter_or_exclude(False, *args, **kwargs)
 656 
 657     def exclude(self, *args, **kwargs):
 658         """
 659         Return a new QuerySet instance with NOT (args) ANDed to the existing
 660         set.
 661         """
 662         return self._filter_or_exclude(True, *args, **kwargs)
 663 
 664     def _filter_or_exclude(self, negate, *args, **kwargs):
 665         if args or kwargs:
 666             assert self.query.can_filter(), 
 667                 "Cannot filter a query once a slice has been taken."
 668 
 669         clone = self._chain()
 670         if negate:
 671             clone.query.add_q(~Q(*args, **kwargs))
 672         else:
 673             clone.query.add_q(Q(*args, **kwargs))
 674         return clone
 675 
 676     def complex_filter(self, filter_obj):
 677         """
 678         Return a new QuerySet instance with filter_obj added to the filters.
 679 
 680         filter_obj can be a Q object or a dictionary of keyword lookup
 681         arguments.
 682 
 683         This exists to support framework features such as 'limit_choices_to',
 684         and usually it will be more natural to use other methods.
 685         """
 686         if isinstance(filter_obj, Q):
 687             clone = self._chain()
 688             clone.query.add_q(filter_obj)
 689             return clone
 690         else:
 691             return self._filter_or_exclude(None, **filter_obj)
 692 
 693     def _combinator_query(self, combinator, *other_qs, all=False):
 694         # Clone the query to inherit the select list and everything
 695         clone = self._chain()
 696         # Clear limits and ordering so they can be reapplied
 697         clone.query.clear_ordering(True)
 698         clone.query.clear_limits()
 699         clone.query.combined_queries = (self.query,) + tuple(qs.query for qs in other_qs)
 700         clone.query.combinator = combinator
 701         clone.query.combinator_all = all
 702         return clone
 703 
 704     def union(self, *other_qs, all=False):
 705         # If the query is an EmptyQuerySet, combine all nonempty querysets.
 706         if isinstance(self, EmptyQuerySet):
 707             qs = [q for q in other_qs if not isinstance(q, EmptyQuerySet)]
 708             return qs[0]._combinator_query('union', *qs[1:], all=all) if qs else self
 709         return self._combinator_query('union', *other_qs, all=all)
 710 
 711     def intersection(self, *other_qs):
 712         # If any query is an EmptyQuerySet, return it.
 713         if isinstance(self, EmptyQuerySet):
 714             return self
 715         for other in other_qs:
 716             if isinstance(other, EmptyQuerySet):
 717                 return other
 718         return self._combinator_query('intersection', *other_qs)
 719 
 720     def difference(self, *other_qs):
 721         # If the query is an EmptyQuerySet, return it.
 722         if isinstance(self, EmptyQuerySet):
 723             return self
 724         return self._combinator_query('difference', *other_qs)
 725 
 726     def select_for_update(self, nowait=False, skip_locked=False, of=()):
 727         """
 728         Return a new QuerySet instance that will select objects with a
 729         FOR UPDATE lock.
 730         """
 731         if nowait and skip_locked:
 732             raise ValueError('The nowait option cannot be used with skip_locked.')
 733         obj = self._chain()
 734         obj._for_write = True
 735         obj.query.select_for_update = True
 736         obj.query.select_for_update_nowait = nowait
 737         obj.query.select_for_update_skip_locked = skip_locked
 738         obj.query.select_for_update_of = of
 739         return obj
 740 
 741     def select_related(self, *fields):
 742         """
 743         Return a new QuerySet instance that will select related objects.
 744 
 745         If fields are specified, they must be ForeignKey fields and only those
 746         related objects are included in the selection.
 747 
 748         If select_related(None) is called, clear the list.
 749         """
 750 
 751         if self._fields is not None:
 752             raise TypeError("Cannot call select_related() after .values() or .values_list()")
 753 
 754         obj = self._chain()
 755         if fields == (None,):
 756             obj.query.select_related = False
 757         elif fields:
 758             obj.query.add_select_related(fields)
 759         else:
 760             obj.query.select_related = True
 761         return obj
 762 
 763     def prefetch_related(self, *lookups):
 764         """
 765         Return a new QuerySet instance that will prefetch the specified
 766         Many-To-One and Many-To-Many related objects when the QuerySet is
 767         evaluated.
 768 
 769         When prefetch_related() is called more than once, append to the list of
 770         prefetch lookups. If prefetch_related(None) is called, clear the list.
 771         """
 772         clone = self._chain()
 773         if lookups == (None,):
 774             clone._prefetch_related_lookups = ()
 775         else:
 776             for lookup in lookups:
 777                 if isinstance(lookup, Prefetch):
 778                     lookup = lookup.prefetch_to
 779                 lookup = lookup.split(LOOKUP_SEP, 1)[0]
 780                 if lookup in self.query._filtered_relations:
 781                     raise ValueError('prefetch_related() is not supported with FilteredRelation.')
 782             clone._prefetch_related_lookups = clone._prefetch_related_lookups + lookups
 783         return clone
 784 
 785     def annotate(self, *args, **kwargs):
 786         """
 787         Return a query set in which the returned objects have been annotated
 788         with extra data or aggregations.
 789         """
 790         self._validate_values_are_expressions(args + tuple(kwargs.values()), method_name='annotate')
 791         annotations = OrderedDict()  # To preserve ordering of args
 792         for arg in args:
 793             # The default_alias property may raise a TypeError.
 794             try:
 795                 if arg.default_alias in kwargs:
 796                     raise ValueError("The named annotation '%s' conflicts with the "
 797                                      "default name for another annotation."
 798                                      % arg.default_alias)
 799             except TypeError:
 800                 raise TypeError("Complex annotations require an alias")
 801             annotations[arg.default_alias] = arg
 802         annotations.update(kwargs)
 803 
 804         clone = self._chain()
 805         names = self._fields
 806         if names is None:
 807             names = {f.name for f in self.model._meta.get_fields()}
 808 
 809         for alias, annotation in annotations.items():
 810             if alias in names:
 811                 raise ValueError("The annotation '%s' conflicts with a field on "
 812                                  "the model." % alias)
 813             if isinstance(annotation, FilteredRelation):
 814                 clone.query.add_filtered_relation(annotation, alias)
 815             else:
 816                 clone.query.add_annotation(annotation, alias, is_summary=False)
 817 
 818         for alias, annotation in clone.query.annotations.items():
 819             if alias in annotations and annotation.contains_aggregate:
 820                 if clone._fields is None:
 821                     clone.query.group_by = True
 822                 else:
 823                     clone.query.set_group_by()
 824                 break
 825 
 826         return clone
 827 
 828     def order_by(self, *field_names):
 829         """Return a new QuerySet instance with the ordering changed."""
 830         assert self.query.can_filter(), 
 831             "Cannot reorder a query once a slice has been taken."
 832         obj = self._chain()
 833         obj.query.clear_ordering(force_empty=False)
 834         obj.query.add_ordering(*field_names)
 835         return obj
 836 
 837     def distinct(self, *field_names):
 838         """
 839         Return a new QuerySet instance that will select only distinct results.
 840         """
 841         assert self.query.can_filter(), 
 842             "Cannot create distinct fields once a slice has been taken."
 843         obj = self._chain()
 844         obj.query.add_distinct_fields(*field_names)
 845         return obj
 846 
 847     def extra(self, select=None, where=None, params=None, tables=None,
 848               order_by=None, select_params=None):
 849         """Add extra SQL fragments to the query."""
 850         assert self.query.can_filter(), 
 851             "Cannot change a query once a slice has been taken"
 852         clone = self._chain()
 853         clone.query.add_extra(select, select_params, where, params, tables, order_by)
 854         return clone
 855 
 856     def reverse(self):
 857         """Reverse the ordering of the QuerySet."""
 858         if not self.query.can_filter():
 859             raise TypeError('Cannot reverse a query once a slice has been taken.')
 860         clone = self._chain()
 861         clone.query.standard_ordering = not clone.query.standard_ordering
 862         return clone
 863 
 864     def defer(self, *fields):
 865         """
 866         Defer the loading of data for certain fields until they are accessed.
 867         Add the set of deferred fields to any existing set of deferred fields.
 868         The only exception to this is if None is passed in as the only
 869         parameter, in which case removal all deferrals.
 870         """
 871         if self._fields is not None:
 872             raise TypeError("Cannot call defer() after .values() or .values_list()")
 873         clone = self._chain()
 874         if fields == (None,):
 875             clone.query.clear_deferred_loading()
 876         else:
 877             clone.query.add_deferred_loading(fields)
 878         return clone
 879 
 880     def only(self, *fields):
 881         """
 882         Essentially, the opposite of defer(). Only the fields passed into this
 883         method and that are not already specified as deferred are loaded
 884         immediately when the queryset is evaluated.
 885         """
 886         if self._fields is not None:
 887             raise TypeError("Cannot call only() after .values() or .values_list()")
 888         if fields == (None,):
 889             # Can only pass None to defer(), not only(), as the rest option.
 890             # That won't stop people trying to do this, so let's be explicit.
 891             raise TypeError("Cannot pass None as an argument to only().")
 892         for field in fields:
 893             field = field.split(LOOKUP_SEP, 1)[0]
 894             if field in self.query._filtered_relations:
 895                 raise ValueError('only() is not supported with FilteredRelation.')
 896         clone = self._chain()
 897         clone.query.add_immediate_loading(fields)
 898         return clone
 899 
 900     def using(self, alias):
 901         """Select which database this QuerySet should execute against."""
 902         clone = self._chain()
 903         clone._db = alias
 904         return clone
 905 
 906     ###################################
 907     # PUBLIC INTROSPECTION ATTRIBUTES #
 908     ###################################
 909 
 910     @property
 911     def ordered(self):
 912         """
 913         Return True if the QuerySet is ordered -- i.e. has an order_by()
 914         clause or a default ordering on the model.
 915         """
 916         if self.query.extra_order_by or self.query.order_by:
 917             return True
 918         elif self.query.default_ordering and self.query.get_meta().ordering:
 919             return True
 920         else:
 921             return False
 922 
 923     @property
 924     def db(self):
 925         """Return the database used if this query is executed now."""
 926         if self._for_write:
 927             return self._db or router.db_for_write(self.model, **self._hints)
 928         return self._db or router.db_for_read(self.model, **self._hints)
 929 
 930     ###################
 931     # PRIVATE METHODS #
 932     ###################
 933 
 934     def _insert(self, objs, fields, return_id=False, raw=False, using=None):
 935         """
 936         Insert a new record for the given model. This provides an interface to
 937         the InsertQuery class and is how Model.save() is implemented.
 938         """
 939         self._for_write = True
 940         if using is None:
 941             using = self.db
 942         query = sql.InsertQuery(self.model)
 943         query.insert_values(fields, objs, raw=raw)
 944         return query.get_compiler(using=using).execute_sql(return_id)
 945     _insert.alters_data = True
 946     _insert.queryset_only = False
 947 
 948     def _batched_insert(self, objs, fields, batch_size):
 949         """
 950         A helper method for bulk_create() to insert the bulk one batch at a
 951         time. Insert recursively a batch from the front of the bulk and then
 952         _batched_insert() the remaining objects again.
 953         """
 954         if not objs:
 955             return
 956         ops = connections[self.db].ops
 957         batch_size = (batch_size or max(ops.bulk_batch_size(fields, objs), 1))
 958         inserted_ids = []
 959         for item in [objs[i:i + batch_size] for i in range(0, len(objs), batch_size)]:
 960             if connections[self.db].features.can_return_ids_from_bulk_insert:
 961                 inserted_id = self._insert(item, fields=fields, using=self.db, return_id=True)
 962                 if isinstance(inserted_id, list):
 963                     inserted_ids.extend(inserted_id)
 964                 else:
 965                     inserted_ids.append(inserted_id)
 966             else:
 967                 self._insert(item, fields=fields, using=self.db)
 968         return inserted_ids
 969 
 970     def _chain(self, **kwargs):
 971         """
 972         Return a copy of the current QuerySet that's ready for another
 973         operation.
 974         """
 975         obj = self._clone()
 976         if obj._sticky_filter:
 977             obj.query.filter_is_sticky = True
 978             obj._sticky_filter = False
 979         obj.__dict__.update(kwargs)
 980         return obj
 981 
 982     def _clone(self):
 983         """
 984         Return a copy of the current QuerySet. A lightweight alternative
 985         to deepcopy().
 986         """
 987         c = self.__class__(model=self.model, query=self.query.chain(), using=self._db, hints=self._hints)
 988         c._sticky_filter = self._sticky_filter
 989         c._for_write = self._for_write
 990         c._prefetch_related_lookups = self._prefetch_related_lookups[:]
 991         c._known_related_objects = self._known_related_objects
 992         c._iterable_class = self._iterable_class
 993         c._fields = self._fields
 994         return c
 995 
 996     def _fetch_all(self):
 997         if self._result_cache is None:
 998             self._result_cache = list(self._iterable_class(self))
 999         if self._prefetch_related_lookups and not self._prefetch_done:
1000             self._prefetch_related_objects()
1001 
1002     def _next_is_sticky(self):
1003         """
1004         Indicate that the next filter call and the one following that should
1005         be treated as a single filter. This is only important when it comes to
1006         determining when to reuse tables for many-to-many filters. Required so
1007         that we can filter naturally on the results of related managers.
1008 
1009         This doesn't return a clone of the current QuerySet (it returns
1010         "self"). The method is only used internally and should be immediately
1011         followed by a filter() that does create a clone.
1012         """
1013         self._sticky_filter = True
1014         return self
1015 
1016     def _merge_sanity_check(self, other):
1017         """Check that two QuerySet classes may be merged."""
1018         if self._fields is not None and (
1019                 set(self.query.values_select) != set(other.query.values_select) or
1020                 set(self.query.extra_select) != set(other.query.extra_select) or
1021                 set(self.query.annotation_select) != set(other.query.annotation_select)):
1022             raise TypeError(
1023                 "Merging '%s' classes must involve the same values in each case."
1024                 % self.__class__.__name__
1025             )
1026 
1027     def _merge_known_related_objects(self, other):
1028         """
1029         Keep track of all known related objects from either QuerySet instance.
1030         """
1031         for field, objects in other._known_related_objects.items():
1032             self._known_related_objects.setdefault(field, {}).update(objects)
1033 
1034     def resolve_expression(self, *args, **kwargs):
1035         if self._fields and len(self._fields) > 1:
1036             # values() queryset can only be used as nested queries
1037             # if they are set up to select only a single field.
1038             raise TypeError('Cannot use multi-field values as a filter value.')
1039         query = self.query.resolve_expression(*args, **kwargs)
1040         query._db = self._db
1041         return query
1042     resolve_expression.queryset_only = True
1043 
1044     def _add_hints(self, **hints):
1045         """
1046         Update hinting information for use by routers. Add new key/values or
1047         overwrite existing key/values.
1048         """
1049         self._hints.update(hints)
1050 
1051     def _has_filters(self):
1052         """
1053         Check if this QuerySet has any filtering going on. This isn't
1054         equivalent with checking if all objects are present in results, for
1055         example, qs[1:]._has_filters() -> False.
1056         """
1057         return self.query.has_filters()
1058 
1059     @staticmethod
1060     def _validate_values_are_expressions(values, method_name):
1061         invalid_args = sorted(str(arg) for arg in values if not hasattr(arg, 'resolve_expression'))
1062         if invalid_args:
1063             raise TypeError(
1064                 'QuerySet.%s() received non-expression(s): %s.' % (
1065                     method_name,
1066                     ', '.join(invalid_args),
1067                 )
1068             )
1069 
1070 
1071 class InstanceCheckMeta(type):
1072     def __instancecheck__(self, instance):
1073         return isinstance(instance, QuerySet) and instance.query.is_empty()
1074 
1075 
1076 class EmptyQuerySet(metaclass=InstanceCheckMeta):
1077     """
1078     Marker class to checking if a queryset is empty by .none():
1079         isinstance(qs.none(), EmptyQuerySet) -> True
1080     """
1081 
1082     def __init__(self, *args, **kwargs):
1083         raise TypeError("EmptyQuerySet can't be instantiated")
1084 
1085 
1086 class RawQuerySet:
1087     """
1088     Provide an iterator which converts the results of raw SQL queries into
1089     annotated model instances.
1090     """
1091     def __init__(self, raw_query, model=None, query=None, params=None,
1092                  translations=None, using=None, hints=None):
1093         self.raw_query = raw_query
1094         self.model = model
1095         self._db = using
1096         self._hints = hints or {}
1097         self.query = query or sql.RawQuery(sql=raw_query, using=self.db, params=params)
1098         self.params = params or ()
1099         self.translations = translations or {}
1100 
1101     def resolve_model_init_order(self):
1102         """Resolve the init field names and value positions."""
1103         converter = connections[self.db].introspection.column_name_converter
1104         model_init_fields = [f for f in self.model._meta.fields if converter(f.column) in self.columns]
1105         annotation_fields = [(column, pos) for pos, column in enumerate(self.columns)
1106                              if column not in self.model_fields]
1107         model_init_order = [self.columns.index(converter(f.column)) for f in model_init_fields]
1108         model_init_names = [f.attname for f in model_init_fields]
1109         return model_init_names, model_init_order, annotation_fields
1110 
1111     def __iter__(self):
1112         # Cache some things for performance reasons outside the loop.
1113         db = self.db
1114         compiler = connections[db].ops.compiler('SQLCompiler')(
1115             self.query, connections[db], db
1116         )
1117 
1118         query = iter(self.query)
1119 
1120         try:
1121             model_init_names, model_init_pos, annotation_fields = self.resolve_model_init_order()
1122             if self.model._meta.pk.attname not in model_init_names:
1123                 raise InvalidQuery('Raw query must include the primary key')
1124             model_cls = self.model
1125             fields = [self.model_fields.get(c) for c in self.columns]
1126             converters = compiler.get_converters([
1127                 f.get_col(f.model._meta.db_table) if f else None for f in fields
1128             ])
1129             if converters:
1130                 query = compiler.apply_converters(query, converters)
1131             for values in query:
1132                 # Associate fields to values
1133                 model_init_values = [values[pos] for pos in model_init_pos]
1134                 instance = model_cls.from_db(db, model_init_names, model_init_values)
1135                 if annotation_fields:
1136                     for column, pos in annotation_fields:
1137                         setattr(instance, column, values[pos])
1138                 yield instance
1139         finally:
1140             # Done iterating the Query. If it has its own cursor, close it.
1141             if hasattr(self.query, 'cursor') and self.query.cursor:
1142                 self.query.cursor.close()
1143 
1144     def __repr__(self):
1145         return "<%s: %s>" % (self.__class__.__name__, self.query)
1146 
1147     def __getitem__(self, k):
1148         return list(self)[k]
1149 
1150     @property
1151     def db(self):
1152         """Return the database used if this query is executed now."""
1153         return self._db or router.db_for_read(self.model, **self._hints)
1154 
1155     def using(self, alias):
1156         """Select the database this RawQuerySet should execute against."""
1157         return RawQuerySet(
1158             self.raw_query, model=self.model,
1159             query=self.query.chain(using=alias),
1160             params=self.params, translations=self.translations,
1161             using=alias,
1162         )
1163 
1164     @cached_property
1165     def columns(self):
1166         """
1167         A list of model field names in the order they'll appear in the
1168         query results.
1169         """
1170         columns = self.query.get_columns()
1171         # Adjust any column names which don't match field names
1172         for (query_name, model_name) in self.translations.items():
1173             # Ignore translations for nonexistent column names
1174             try:
1175                 index = columns.index(query_name)
1176             except ValueError:
1177                 pass
1178             else:
1179                 columns[index] = model_name
1180         return columns
1181 
1182     @cached_property
1183     def model_fields(self):
1184         """A dict mapping column names to model field names."""
1185         converter = connections[self.db].introspection.table_name_converter
1186         model_fields = {}
1187         for field in self.model._meta.fields:
1188             name, column = field.get_attname_column()
1189             model_fields[converter(column)] = field
1190         return model_fields
1191 
1192 
1193 class Prefetch:
1194     def __init__(self, lookup, queryset=None, to_attr=None):
1195         # `prefetch_through` is the path we traverse to perform the prefetch.
1196         self.prefetch_through = lookup
1197         # `prefetch_to` is the path to the attribute that stores the result.
1198         self.prefetch_to = lookup
1199         if queryset is not None and not issubclass(queryset._iterable_class, ModelIterable):
1200             raise ValueError('Prefetch querysets cannot use values().')
1201         if to_attr:
1202             self.prefetch_to = LOOKUP_SEP.join(lookup.split(LOOKUP_SEP)[:-1] + [to_attr])
1203 
1204         self.queryset = queryset
1205         self.to_attr = to_attr
1206 
1207     def __getstate__(self):
1208         obj_dict = self.__dict__.copy()
1209         if self.queryset is not None:
1210             # Prevent the QuerySet from being evaluated
1211             obj_dict['queryset'] = self.queryset._chain(
1212                 _result_cache=[],
1213                 _prefetch_done=True,
1214             )
1215         return obj_dict
1216 
1217     def add_prefix(self, prefix):
1218         self.prefetch_through = prefix + LOOKUP_SEP + self.prefetch_through
1219         self.prefetch_to = prefix + LOOKUP_SEP + self.prefetch_to
1220 
1221     def get_current_prefetch_to(self, level):
1222         return LOOKUP_SEP.join(self.prefetch_to.split(LOOKUP_SEP)[:level + 1])
1223 
1224     def get_current_to_attr(self, level):
1225         parts = self.prefetch_to.split(LOOKUP_SEP)
1226         to_attr = parts[level]
1227         as_attr = self.to_attr and level == len(parts) - 1
1228         return to_attr, as_attr
1229 
1230     def get_current_queryset(self, level):
1231         if self.get_current_prefetch_to(level) == self.prefetch_to:
1232             return self.queryset
1233         return None
1234 
1235     def __eq__(self, other):
1236         if isinstance(other, Prefetch):
1237             return self.prefetch_to == other.prefetch_to
1238         return False
1239 
1240     def __hash__(self):
1241         return hash(self.__class__) ^ hash(self.prefetch_to)
1242 
1243 
1244 def normalize_prefetch_lookups(lookups, prefix=None):
1245     """Normalize lookups into Prefetch objects."""
1246     ret = []
1247     for lookup in lookups:
1248         if not isinstance(lookup, Prefetch):
1249             lookup = Prefetch(lookup)
1250         if prefix:
1251             lookup.add_prefix(prefix)
1252         ret.append(lookup)
1253     return ret
1254 
1255 
1256 def prefetch_related_objects(model_instances, *related_lookups):
1257     """
1258     Populate prefetched object caches for a list of model instances based on
1259     the lookups/Prefetch instances given.
1260     """
1261     if len(model_instances) == 0:
1262         return  # nothing to do
1263 
1264     # We need to be able to dynamically add to the list of prefetch_related
1265     # lookups that we look up (see below).  So we need some book keeping to
1266     # ensure we don't do duplicate work.
1267     done_queries = {}    # dictionary of things like 'foo__bar': [results]
1268 
1269     auto_lookups = set()  # we add to this as we go through.
1270     followed_descriptors = set()  # recursion protection
1271 
1272     all_lookups = normalize_prefetch_lookups(reversed(related_lookups))
1273     while all_lookups:
1274         lookup = all_lookups.pop()
1275         if lookup.prefetch_to in done_queries:
1276             if lookup.queryset:
1277                 raise ValueError("'%s' lookup was already seen with a different queryset. "
1278                                  "You may need to adjust the ordering of your lookups." % lookup.prefetch_to)
1279 
1280             continue
1281 
1282         # Top level, the list of objects to decorate is the result cache
1283         # from the primary QuerySet. It won't be for deeper levels.
1284         obj_list = model_instances
1285 
1286         through_attrs = lookup.prefetch_through.split(LOOKUP_SEP)
1287         for level, through_attr in enumerate(through_attrs):
1288             # Prepare main instances
1289             if len(obj_list) == 0:
1290                 break
1291 
1292             prefetch_to = lookup.get_current_prefetch_to(level)
1293             if prefetch_to in done_queries:
1294                 # Skip any prefetching, and any object preparation
1295                 obj_list = done_queries[prefetch_to]
1296                 continue
1297 
1298             # Prepare objects:
1299             good_objects = True
1300             for obj in obj_list:
1301                 # Since prefetching can re-use instances, it is possible to have
1302                 # the same instance multiple times in obj_list, so obj might
1303                 # already be prepared.
1304                 if not hasattr(obj, '_prefetched_objects_cache'):
1305                     try:
1306                         obj._prefetched_objects_cache = {}
1307                     except (AttributeError, TypeError):
1308                         # Must be an immutable object from
1309                         # values_list(flat=True), for example (TypeError) or
1310                         # a QuerySet subclass that isn't returning Model
1311                         # instances (AttributeError), either in Django or a 3rd
1312                         # party. prefetch_related() doesn't make sense, so quit.
1313                         good_objects = False
1314                         break
1315             if not good_objects:
1316                 break
1317 
1318             # Descend down tree
1319 
1320             # We assume that objects retrieved are homogeneous (which is the premise
1321             # of prefetch_related), so what applies to first object applies to all.
1322             first_obj = obj_list[0]
1323             to_attr = lookup.get_current_to_attr(level)[0]
1324             prefetcher, descriptor, attr_found, is_fetched = get_prefetcher(first_obj, through_attr, to_attr)
1325 
1326             if not attr_found:
1327                 raise AttributeError("Cannot find '%s' on %s object, '%s' is an invalid "
1328                                      "parameter to prefetch_related()" %
1329                                      (through_attr, first_obj.__class__.__name__, lookup.prefetch_through))
1330 
1331             if level == len(through_attrs) - 1 and prefetcher is None:
1332                 # Last one, this *must* resolve to something that supports
1333                 # prefetching, otherwise there is no point adding it and the
1334                 # developer asking for it has made a mistake.
1335                 raise ValueError("'%s' does not resolve to an item that supports "
1336                                  "prefetching - this is an invalid parameter to "
1337                                  "prefetch_related()." % lookup.prefetch_through)
1338 
1339             if prefetcher is not None and not is_fetched:
1340                 obj_list, additional_lookups = prefetch_one_level(obj_list, prefetcher, lookup, level)
1341                 # We need to ensure we don't keep adding lookups from the
1342                 # same relationships to stop infinite recursion. So, if we
1343                 # are already on an automatically added lookup, don't add
1344                 # the new lookups from relationships we've seen already.
1345                 if not (lookup in auto_lookups and descriptor in followed_descriptors):
1346                     done_queries[prefetch_to] = obj_list
1347                     new_lookups = normalize_prefetch_lookups(reversed(additional_lookups), prefetch_to)
1348                     auto_lookups.update(new_lookups)
1349                     all_lookups.extend(new_lookups)
1350                 followed_descriptors.add(descriptor)
1351             else:
1352                 # Either a singly related object that has already been fetched
1353                 # (e.g. via select_related), or hopefully some other property
1354                 # that doesn't support prefetching but needs to be traversed.
1355 
1356                 # We replace the current list of parent objects with the list
1357                 # of related objects, filtering out empty or missing values so
1358                 # that we can continue with nullable or reverse relations.
1359                 new_obj_list = []
1360                 for obj in obj_list:
1361                     if through_attr in getattr(obj, '_prefetched_objects_cache', ()):
1362                         # If related objects have been prefetched, use the
1363                         # cache rather than the object's through_attr.
1364                         new_obj = list(obj._prefetched_objects_cache.get(through_attr))
1365                     else:
1366                         try:
1367                             new_obj = getattr(obj, through_attr)
1368                         except exceptions.ObjectDoesNotExist:
1369                             continue
1370                     if new_obj is None:
1371                         continue
1372                     # We special-case `list` rather than something more generic
1373                     # like `Iterable` because we don't want to accidentally match
1374                     # user models that define __iter__.
1375                     if isinstance(new_obj, list):
1376                         new_obj_list.extend(new_obj)
1377                     else:
1378                         new_obj_list.append(new_obj)
1379                 obj_list = new_obj_list
1380 
1381 
1382 def get_prefetcher(instance, through_attr, to_attr):
1383     """
1384     For the attribute 'through_attr' on the given instance, find
1385     an object that has a get_prefetch_queryset().
1386     Return a 4 tuple containing:
1387     (the object with get_prefetch_queryset (or None),
1388      the descriptor object representing this relationship (or None),
1389      a boolean that is False if the attribute was not found at all,
1390      a boolean that is True if the attribute has already been fetched)
1391     """
1392     prefetcher = None
1393     is_fetched = False
1394 
1395     # For singly related objects, we have to avoid getting the attribute
1396     # from the object, as this will trigger the query. So we first try
1397     # on the class, in order to get the descriptor object.
1398     rel_obj_descriptor = getattr(instance.__class__, through_attr, None)
1399     if rel_obj_descriptor is None:
1400         attr_found = hasattr(instance, through_attr)
1401     else:
1402         attr_found = True
1403         if rel_obj_descriptor:
1404             # singly related object, descriptor object has the
1405             # get_prefetch_queryset() method.
1406             if hasattr(rel_obj_descriptor, 'get_prefetch_queryset'):
1407                 prefetcher = rel_obj_descriptor
1408                 if rel_obj_descriptor.is_cached(instance):
1409                     is_fetched = True
1410             else:
1411                 # descriptor doesn't support prefetching, so we go ahead and get
1412                 # the attribute on the instance rather than the class to
1413                 # support many related managers
1414                 rel_obj = getattr(instance, through_attr)
1415                 if hasattr(rel_obj, 'get_prefetch_queryset'):
1416                     prefetcher = rel_obj
1417                 if through_attr != to_attr:
1418                     # Special case cached_property instances because hasattr
1419                     # triggers attribute computation and assignment.
1420                     if isinstance(getattr(instance.__class__, to_attr, None), cached_property):
1421                         is_fetched = to_attr in instance.__dict__
1422                     else:
1423                         is_fetched = hasattr(instance, to_attr)
1424                 else:
1425                     is_fetched = through_attr in instance._prefetched_objects_cache
1426     return prefetcher, rel_obj_descriptor, attr_found, is_fetched
1427 
1428 
1429 def prefetch_one_level(instances, prefetcher, lookup, level):
1430     """
1431     Helper function for prefetch_related_objects().
1432 
1433     Run prefetches on all instances using the prefetcher object,
1434     assigning results to relevant caches in instance.
1435 
1436     Return the prefetched objects along with any additional prefetches that
1437     must be done due to prefetch_related lookups found from default managers.
1438     """
1439     # prefetcher must have a method get_prefetch_queryset() which takes a list
1440     # of instances, and returns a tuple:
1441 
1442     # (queryset of instances of self.model that are related to passed in instances,
1443     #  callable that gets value to be matched for returned instances,
1444     #  callable that gets value to be matched for passed in instances,
1445     #  boolean that is True for singly related objects,
1446     #  cache or field name to assign to,
1447     #  boolean that is True when the previous argument is a cache name vs a field name).
1448 
1449     # The 'values to be matched' must be hashable as they will be used
1450     # in a dictionary.
1451 
1452     rel_qs, rel_obj_attr, instance_attr, single, cache_name, is_descriptor = (
1453         prefetcher.get_prefetch_queryset(instances, lookup.get_current_queryset(level)))
1454     # We have to handle the possibility that the QuerySet we just got back
1455     # contains some prefetch_related lookups. We don't want to trigger the
1456     # prefetch_related functionality by evaluating the query. Rather, we need
1457     # to merge in the prefetch_related lookups.
1458     # Copy the lookups in case it is a Prefetch object which could be reused
1459     # later (happens in nested prefetch_related).
1460     additional_lookups = [
1461         copy.copy(additional_lookup) for additional_lookup
1462         in getattr(rel_qs, '_prefetch_related_lookups', ())
1463     ]
1464     if additional_lookups:
1465         # Don't need to clone because the manager should have given us a fresh
1466         # instance, so we access an internal instead of using public interface
1467         # for performance reasons.
1468         rel_qs._prefetch_related_lookups = ()
1469 
1470     all_related_objects = list(rel_qs)
1471 
1472     rel_obj_cache = {}
1473     for rel_obj in all_related_objects:
1474         rel_attr_val = rel_obj_attr(rel_obj)
1475         rel_obj_cache.setdefault(rel_attr_val, []).append(rel_obj)
1476 
1477     to_attr, as_attr = lookup.get_current_to_attr(level)
1478     # Make sure `to_attr` does not conflict with a field.
1479     if as_attr and instances:
1480         # We assume that objects retrieved are homogeneous (which is the premise
1481         # of prefetch_related), so what applies to first object applies to all.
1482         model = instances[0].__class__
1483         try:
1484             model._meta.get_field(to_attr)
1485         except exceptions.FieldDoesNotExist:
1486             pass
1487         else:
1488             msg = 'to_attr={} conflicts with a field on the {} model.'
1489             raise ValueError(msg.format(to_attr, model.__name__))
1490 
1491     # Whether or not we're prefetching the last part of the lookup.
1492     leaf = len(lookup.prefetch_through.split(LOOKUP_SEP)) - 1 == level
1493 
1494     for obj in instances:
1495         instance_attr_val = instance_attr(obj)
1496         vals = rel_obj_cache.get(instance_attr_val, [])
1497 
1498         if single:
1499             val = vals[0] if vals else None
1500             if as_attr:
1501                 # A to_attr has been given for the prefetch.
1502                 setattr(obj, to_attr, val)
1503             elif is_descriptor:
1504                 # cache_name points to a field name in obj.
1505                 # This field is a descriptor for a related object.
1506                 setattr(obj, cache_name, val)
1507             else:
1508                 # No to_attr has been given for this prefetch operation and the
1509                 # cache_name does not point to a descriptor. Store the value of
1510                 # the field in the object's field cache.
1511                 obj._state.fields_cache[cache_name] = val
1512         else:
1513             if as_attr:
1514                 setattr(obj, to_attr, vals)
1515             else:
1516                 manager = getattr(obj, to_attr)
1517                 if leaf and lookup.queryset is not None:
1518                     qs = manager._apply_rel_filters(lookup.queryset)
1519                 else:
1520                     qs = manager.get_queryset()
1521                 qs._result_cache = vals
1522                 # We don't want the individual qs doing prefetch_related now,
1523                 # since we have merged this into the current work.
1524                 qs._prefetch_done = True
1525                 obj._prefetched_objects_cache[cache_name] = qs
1526     return all_related_objects, additional_lookups

View Code

自定义管理器：

修改Manager的初始的QuerySet

在默认的情况下QuerySet返回的是整个模型类中的所有对象。例如在shell下进行测试

>>> from queryset_demo.models import *
>>> Blog.objects.all()
<QuerySet [<Blog: change_new_name>, <Blog: create_test>, <Blog: Cheddar Talk>, <Blog: blog_3>, <Blog: Tom>, <Blog: new>, <Blog: new>]>
#想要获取所有书的书名
>>> for blg in Blog.objects.all():
...     print(blg.name)
... 
# 原谅所有的数据并没有太正规
change_new_name
create_test
Cheddar Talk
blog_3
Tom
new
new

通过自定义Manager管理器的方式试得返回的QuerySet为所有博客的名字

step-1在models.py文件中

class Blog_name(models.Manager):
    def get_queryset(self):
        return super().get_queryset().values_list('name',flat=True)



class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    objects = models.Manager() # 默认的管理器
    get_blog_name = Blog_name() # 自定义管理器

    def __str__(self):
        return self.name

step-2在shell环境下测试

>>> from queryset_demo.models import *
>>> Blog.objects.all()
<QuerySet [<Blog: change_new_name>, <Blog: create_test>, <Blog: Cheddar Talk>, <Blog: blog_3>, <Blog: Tom>, <Blog: new>, <Blog: new>]>
>>> Blog.get_blog_name.all()
<QuerySet ['change_new_name', 'create_test', 'Cheddar Talk', 'blog_3', 'Tom', 'new', 'new']>

总结在 get_queryset(self)方法中返回的是一个查询集，所以我们在使用的时候可以在这个基础上使用QuerySet的Api返回我们想要的结果。