| # This is a dummy for code-completion purposes. |
| |
| def __unicode__(self): |
| """ |
| Return "app_label.model_label.manager_name". |
| """ |
| |
| 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). |
| """ |
| |
| |
| def _db(self): |
| """ |
| |
| """ |
| |
| |
| def _get_queryset_methods(cls, queryset_class): |
| """ |
| |
| """ |
| |
| |
| def _hints(self): |
| """ |
| dict() -> new empty dictionary |
| dict(mapping) -> new dictionary initialized from a mapping object's |
| (key, value) pairs |
| dict(iterable) -> new dictionary initialized as if via: |
| d = {} |
| for k, v in iterable: |
| d[k] = v |
| dict(**kwargs) -> new dictionary initialized with the name=value pairs |
| in the keyword argument list. For example: dict(one=1, two=2) |
| """ |
| |
| |
| def _inherited(self): |
| """ |
| |
| """ |
| |
| |
| def _insert(self, *args, **kwargs): |
| """ |
| Inserts a new record for the given model. This provides an interface to |
| the InsertQuery class and is how Model.save() is implemented. |
| """ |
| |
| |
| def _queryset_class(self): |
| """ |
| Represents a lazy database lookup for a set of objects. |
| """ |
| |
| |
| def _set_creation_counter(self): |
| """ |
| Sets the creation counter value for this instance and increments the |
| class-level copy. |
| """ |
| |
| |
| def _update(self, *args, **kwargs): |
| """ |
| A version of update that accepts field objects instead of field names. |
| Used primarily for model saving and not intended for use by general |
| code (it requires too much poking around at model internals to be |
| useful at that level). |
| """ |
| |
| |
| def aggregate(self, *args, **kwargs): |
| """ |
| Returns a dictionary containing the calculations (aggregation) |
| over the current queryset |
| |
| If args is present the expression is passed as a kwarg using |
| the Aggregate object's default alias. |
| """ |
| |
| |
| def all(self): |
| """ |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def annotate(self, *args, **kwargs): |
| """ |
| Return a query set in which the returned objects have been annotated |
| with data aggregated from related fields. |
| """ |
| |
| |
| def bulk_create(self, *args, **kwargs): |
| """ |
| Inserts each of the instances into the database. This does *not* call |
| save() on each of the instances, does not send any pre/post save |
| signals, and does not set the primary key attribute if it is an |
| autoincrement field. |
| """ |
| |
| |
| def check(self, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def complex_filter(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance with filter_obj added to the filters. |
| |
| filter_obj can be a Q object (or anything with an add_to_query() |
| method) or a dictionary of keyword lookup arguments. |
| |
| This exists to support framework features such as 'limit_choices_to', |
| and usually it will be more natural to use other methods. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def contribute_to_class(self, model, name): |
| """ |
| |
| """ |
| |
| |
| def count(self, *args, **kwargs): |
| """ |
| Performs a SELECT COUNT() and returns the number of records as an |
| integer. |
| |
| If the QuerySet is already fully cached this simply returns the length |
| of the cached results set to avoid multiple SELECT COUNT(*) calls. |
| """ |
| |
| |
| def create(self, *args, **kwargs): |
| """ |
| Creates a new object with the given kwargs, saving it to the database |
| and returning the created object. |
| """ |
| |
| |
| def creation_counter(self): |
| """ |
| |
| """ |
| |
| |
| def dates(self, *args, **kwargs): |
| """ |
| Returns a list of date objects representing all available dates for |
| the given field_name, scoped to 'kind'. |
| """ |
| |
| |
| def datetimes(self, *args, **kwargs): |
| """ |
| Returns a list of datetime objects representing all available |
| datetimes for the given field_name, scoped to 'kind'. |
| """ |
| |
| |
| def db(self): |
| """ |
| |
| """ |
| |
| |
| def db_manager(self, using=None, hints=None): |
| """ |
| |
| """ |
| |
| |
| def defer(self, *args, **kwargs): |
| """ |
| Defers the loading of data for certain fields until they are accessed. |
| The set of fields to defer is added to any existing set of deferred |
| fields. The only exception to this is if None is passed in as the only |
| parameter, in which case all deferrals are removed (None acts as a |
| reset option). |
| """ |
| |
| |
| def distinct(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance that will select only distinct results. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def earliest(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def exclude(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance with NOT (args) ANDed to the existing |
| set. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def exists(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def extra(self, *args, **kwargs): |
| """ |
| Adds extra SQL fragments to the query. |
| """ |
| |
| |
| def filter(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance with the args ANDed to the existing |
| set. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def first(self, *args, **kwargs): |
| """ |
| Returns the first object of a query, returns None if no match is found. |
| """ |
| |
| |
| def from_queryset(cls, queryset_class, class_name=None): |
| """ |
| |
| """ |
| |
| |
| def get(self, *args, **kwargs): |
| """ |
| Performs the query and returns a single object matching the given |
| keyword arguments. |
| """ |
| |
| |
| def get_or_create(self, *args, **kwargs): |
| """ |
| Looks up an object with the given kwargs, creating one if necessary. |
| Returns a tuple of (object, created), where created is a boolean |
| specifying whether an object was created. |
| """ |
| |
| |
| def get_queryset(self): |
| """ |
| Returns a new QuerySet object. Subclasses can override this method to |
| easily customize the behavior of the Manager. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def in_bulk(self, *args, **kwargs): |
| """ |
| Returns a dictionary mapping each of the given IDs to the object with |
| that ID. |
| """ |
| |
| |
| def iterator(self, *args, **kwargs): |
| """ |
| An iterator over the results from applying this QuerySet to the |
| database. |
| """ |
| |
| |
| def last(self, *args, **kwargs): |
| """ |
| Returns the last object of a query, returns None if no match is found. |
| """ |
| |
| |
| def latest(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def model(self): |
| """ |
| MyModel(id) |
| """ |
| |
| |
| def none(self, *args, **kwargs): |
| """ |
| Returns an empty QuerySet. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def only(self, *args, **kwargs): |
| """ |
| Essentially, the opposite of defer. Only the fields passed into this |
| method and that are not already specified as deferred are loaded |
| immediately when the queryset is evaluated. |
| """ |
| |
| |
| def order_by(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance with the ordering changed. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def prefetch_related(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance that will prefetch the specified |
| Many-To-One and Many-To-Many related objects when the QuerySet is |
| evaluated. |
| |
| When prefetch_related() is called more than once, the list of lookups to |
| prefetch is appended to. If prefetch_related(None) is called, the list |
| is cleared. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def raw(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def reverse(self, *args, **kwargs): |
| """ |
| Reverses the ordering of the QuerySet. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def select_for_update(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance that will select objects with a |
| FOR UPDATE lock. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def select_related(self, *args, **kwargs): |
| """ |
| Returns a new QuerySet instance that will select related objects. |
| |
| If fields are specified, they must be ForeignKey fields and only those |
| related objects are included in the selection. |
| |
| If select_related(None) is called, the list is cleared. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def update(self, *args, **kwargs): |
| """ |
| Updates all elements in the current QuerySet, setting all the given |
| fields to the appropriate values. |
| """ |
| |
| |
| def update_or_create(self, *args, **kwargs): |
| """ |
| Looks up an object with the given kwargs, updating one with defaults |
| if it exists, otherwise creates a new one. |
| Returns a tuple (object, created), where created is a boolean |
| specifying whether an object was created. |
| """ |
| |
| |
| def using(self, *args, **kwargs): |
| """ |
| Selects which database this QuerySet should execute its query against. |
| |
| @rtype: django.db.models.query.QuerySet |
| """ |
| |
| |
| def values(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
| |
| def values_list(self, *args, **kwargs): |
| """ |
| |
| """ |
| |
