mirrors/django
1
0
Fork 0
mirror of https://github.com/django/django.git synced 2025-10-10 23:39:11 +00:00
Code Issues 32 Releases Wiki Activity
django/docs/db-api.txt

1141 lines
42 KiB
Plaintext
Raw Blame History

======================
Database API reference
======================
Once you've created your `data models`_, Django automatically gives you a
database-abstraction API that lets you create, retrieve, update and delete
objects. This document explains that API.
.. _`data models`: http://www.djangoproject.com/documentation/model_api/
Throughout this reference, we'll refer to the following Blog application::
class Blog(models.Model):
name = models.CharField(maxlength=100)
tagline = models.TextField()
def __repr__(self):
return self.name
class Author(models.Model):
name = models.CharField(maxlength=50)
email = models.URLField()
class __repr__(self):
return self.name
class Entry(models.Model):
blog = models.ForeignKey(Blog)
headline = models.CharField(maxlength=255)
body_text = models.TextField()
pub_date = models.DateTimeField()
authors = models.ManyToManyField(Author)
def __repr__(self):
return self.headline
Creating objects
================
To create an object, instantiate it using keyword arguments to the model class,
then call ``save()`` to save it to the database.
Example::
b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')
b.save()
This performs an ``INSERT`` SQL statement behind the scenes. Django doesn't hit
the database until you explicitly call ``save()``.
The ``save()`` method has no return value.
Auto-incrementing primary keys
------------------------------
If a model has an ``AutoField`` -- an auto-incrementing primary key -- then
that auto-incremented value will be calculated and saved as an attribute on
your object the first time you call ``save()``.
Example::
b2 = Blog(name='Cheddar Talk', tagline='Thoughts on cheese.')
b2.id # Returns None, because b doesn't have an ID yet.
b2.save()
b2.id # Returns the ID of your new object.
There's no way to tell what the value of an ID will be before you call
``save()``, because that value is calculated by your database, not by Django.
(For convenience, each model has an ``AutoField`` named ``id`` by default
unless you explicitly specify ``primary_key=True`` on a field. See the
`AutoField documentation`_.)
.. _AutoField documentation: TODO: Link
Explicitly specifying auto-primary-key values
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If a model has an ``AutoField`` but you want to define a new object's ID
explicitly when saving, just define it explicitly before saving, rather than
relying on the auto-assignment of the ID.
Example::
b3 = Blog(id=3, name='Cheddar Talk', tagline='Thoughts on cheese.')
b3.id # Returns 3.
b3.save()
b3.id # Returns 3.
If you assign auto-primary-key values manually, make sure not to use an
already-existing primary-key value! If you create a new object with an explicit
primary-key value that already exists in the database, Django will assume
you're changing the existing record rather than creating a new one.
Given the above ``'Cheddar Talk'`` blog example, this example would override
the previous record in the database::
b4 = Blog(id=3, name='Not Cheddar', tagline='Anything but cheese.')
b4.save() # Overrides the previous blog with ID=3!
See also "How Django knows to UPDATE vs. INSERT", below.
Explicitly specifying auto-primary-key values is mostly useful for bulk-saving
objects, when you're confident you won't have primary-key collision.
Saving changes to objects
=========================
To save changes to an object that's already in the database, use ``save()``.
Given a ``Blog`` instance ``b5`` that has already been saved to the database,
this example changes its name and updates its record in the database::
b5.name = 'New name'
b5.save()
This performs an ``UPDATE`` SQL statement behind the scenes. Django doesn't hit
the database until you explicitly call ``save()``.
The ``save()`` method has no return value.
How Django knows to UPDATE vs. INSERT
-------------------------------------
You may have noticed Django database objects use the same ``save()`` method
for creating and changing objects. Django abstracts the need to use ``INSERT``
or ``UPDATE`` SQL statements. Specifically, when you call ``save()``, Django
follows this algorithm:
* If the object's primary key attribute is set, Django executes a
``SELECT`` query to determine whether a record with the given primary key
already exists.
* If the record with the given primary key does already exist, Django
executes an ``UPDATE`` query.
* If the object's primary key attribute is *not* set, or if it's set but a
record doesn't exist, Django executes an ``INSERT``.
The one gotcha here is that you should be careful not to specify a primary-key
value explicitly when saving new objects, if you cannot guarantee the
primary-key value is unused. For more on this nuance, see
"Explicitly specifying auto-primary-key values" above.
Retrieving objects
==================
To retrieve objects from your database, you construct a ``QuerySet`` via a
``Manager``.
A ``QuerySet`` represents a collection of objects from your database. It can
have zero, one or many *filters* -- criteria that narrow down the collection
based on given parameters.
In SQL terms, a ``QuerySet`` equates to a ``SELECT`` statement, and a filter is
a limiting clause such as ``WHERE`` or ``LIMIT``.
You get a ``QuerySet`` by using your model's ``Manager``. Each model has at
least one ``Manager``, and it's called ``objects`` by default. Access it
directly via the model class, like so::
Blog.objects # <django.db.models.manager.Manager object at ...>
b = Blog(name='Foo', tagline='Bar')
b.objects # AttributeError: "Manager isn't accessible via Blog instances."
(``Managers`` are accessible only via model classes, rather than from model
instances, to enforce a separation between "table-level" operations and
"record-level" operations.)
The ``Manager`` is the main source of ``QuerySets`` for a model. It acts as a
"root" ``QuerySet`` that describes all objects in the model's database table.
For example, ``Blog.objects`` is the initial ``QuerySet`` that contains all
``Blog`` objects in the database.
Retrieving all objects
----------------------
The simplest way to retrieve objects from a table is to get all of them.
To do this, use the ``all()`` method on a ``Manager``.
Example::
all_entries = Entry.objects.all()
The ``all()`` method returns a ``QuerySet`` of all the objects in the database.
(If ``Entry.objects`` is a ``QuerySet``, why can't we just do ``Entry.objects``?
That's because ``Entry.objects``, the root ``QuerySet``, is a special case
that cannot be evaluated. The ``all()`` method returns a ``QuerySet`` that
*can* be evaluated.)
Filtering objects
-----------------
The root ``QuerySet`` provided by the ``Manager`` describes all objects in the
database table. Usually, though, you'll need to select only a subset of the
complete set of objects.
To create such a subset, you refine the initial ``QuerySet``, adding filter
conditions. The two most common ways to refine a ``QuerySet`` are:
``filter(**kwargs)``
Returns a new ``QuerySet`` containing objects that match the given lookup
parameters.
``exclude(**kwargs)``
Returns a new ``QuerySet`` containing objects that do *not* match the given
lookup parameters.
The lookup parameters (``**kwargs`` in the above function definitions) should
be in the format described in "Field lookups" below.
For example, to get a ``QuerySet`` of blog entries from the year 2006, use
``filter()`` like so::
Entry.objects.filter(pub_date__year=2006)
(Note we don't have to add an ``all()`` -- ``Entry.objects.all().filter(...)``.
That would still work, but you only need ``all()`` when you want all objects
from the root ``QuerySet``.)
Chaining filters
~~~~~~~~~~~~~~~~
The result of refining a ``QuerySet`` is itself a ``Query Set``, so it's
possible to chain refinements together. For example::
Entry.objects.filter(
headline__startswith='What').exclude(
pub_date__gte=datetime.now()).filter(
pub_date__gte=datetime(2005, 1, 1))
...takes the initial ``QuerySet`` of all entries in the database, adds a
filter, then an exclusion, then another filter. The final result is a
``QuerySet`` containing all entries with a headline that starts with "What",
that were published between January 1, 2005, and the current day.
Filtered QuerySets are unique
-----------------------------
Each time you refine a ``QuerySet``, you get a brand-new ``QuerySet`` that is
in no way bound to the previous ``QuerySet``. Each refinement creates a
separate and distinct ``QuerySet`` that can be stored, used and reused.
Example::
q1 = Entry.objects.filter(headline__startswith="What")
q2 = q1.exclude(pub_date__gte=datetime.now())
q3 = q1.filter(pub_date__gte=datetime.now())
These three ``QuerySets`` are separate. The first is a base ``QuerySet``
containing all entries that contain a headline starting with "What". The second
is a subset of the first, with an additional criteria that excludes records
whose ``pub_date`` is greater than now. The third is a subset of the first,
with an additional criteria that selects only the records whose ``pub_date`` is
greater than now. The initial ``QuerySet`` (``q1``) is unaffected by the
refinement process.
QuerySets are lazy
------------------
``QuerySets`` are lazy -- the act of creating a ``QuerySet`` doesn't involve
any database activity. You can stack filters together all day long, and Django
won't actually run the query until the ``QuerySet`` is *evaluated*.
When QuerySets are evaluated
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
You can evaluate a ``QuerySet`` in the following ways:
* **Iteration.** A ``QuerySet`` is iterable, and it executes its database
query the first time you iterate over it. For example, this will print
the headline of all entries in the database::
for e in Entry.objects.all():
print e.headline
* **Slicing.** A ``QuerySet`` can be sliced, using Python's array-slicing
syntax, and it executes its database query the first time you slice it.
Examples::
fifth_entry = Entry.objects.all()[4]
all_entries_but_the_first_two = Entry.objects.all()[2:]
every_second_entry = Entry.objects.all()[::2]
* **repr().** A ``QuerySet`` is evaluated when you call ``repr()`` on it.
This is for convenience in the Python interactive interpreter, so you can
immediately see your results.
* **len().** A ``QuerySet`` is evaluated when you call ``len()`` on it.
This, as you might expect, returns the length of the result list.
Note: *Don't* use ``len()`` on ``QuerySet``s if all you want to do is
determine the number of records in the set. It's much more efficient to
handle a count at the database level, using SQL's ``SELECT COUNT(*)``,
and Django provides a ``count()`` method for precisely this reason. See
``count()`` below.
* **list().** Force evaluation of a ``QuerySet`` by calling ``list()`` on
it. For example::
entry_list = list(Entry.objects.all())
Be warned, though, that this could have a large memory overhead, because
Django will load each element of the list into memory. In contrast,
iterating over a ``QuerySet`` will take advantage of your database to
load data and instantiate objects only as you need them.
Full list of QuerySet methods
-----------------------------
Django provides a range of ``QuerySet`` refinement methods that modify either
the types of results returned by the ``QuerySet`` or the way its SQL query is
executed.
filter(**kwargs)
~~~~~~~~~~~~~~~~
Returns a new ``QuerySet`` containing objects that match the given lookup
parameters.
The lookup parameters (``**kwargs``) should be in the format described in
"Field lookups" below. Multiple parameters are joined via ``AND`` in the
underlying SQL statement.
exclude(**kwargs)
~~~~~~~~~~~~~~~~~
Returns a new ``QuerySet`` containing objects that do *not* match the given
lookup parameters.
The lookup parameters (``**kwargs``) should be in the format described in
"Field lookups" below. Multiple parameters are joined via ``AND`` in the
underlying SQL statement, and the whole thing is enclosed in a ``NOT()``.
This example excludes all entries whose ``pub_date`` is the current date/time
AND whose ``headline`` is "Hello"::
Entry.objects.exclude(pub_date__gt=datetime.now(), headline='Hello')
This example excludes all entries whose ``pub_date`` is the current date/time
OR whose ``headline`` is "Hello"::
Entry.objects.exclude(pub_date__gt=datetime.now()).exclude(headline='Hello')
Note the second example is more restrictive.
order_by(*fields)
~~~~~~~~~~~~~~~~~
By default, results returned by a ``QuerySet`` are ordered by the ordering
tuple given by the ``ordering`` option in the model's ``Meta``. You can
override this on a per-``QuerySet`` basis by using the ``order_by`` method.
Example::
Entry.objects.filter(pub_date__year=2005).order_by('-pub_date', 'headline')
The result above will be ordered by ``pub_date`` descending, then by
``headline`` ascending. The negative sign in front of ``"-pub_date"`` indicates
*descending* order. Ascending order is implied. To order randomly, use ``"?"``,
like so::
Entry.objects.order_by('?')
To order by a field in a different table, add the other table's name and a dot,
like so::
Entry.objects.order_by('blogs_blog.name', 'headline')
There's no way to specify whether ordering should be case sensitive. With
respect to case-sensitivity, Django will order results however your database
backend normally orders them.
values(*fields)
---------------
Returns a ``ValuesQuerySet`` -- a ``QuerySet`` that evaluates to a list of
dictionaries instead of model-instance objects.
Each of those dictionaries represents an object, with the keys corresponding to
the attribute names of model objects.
This example compares the dictionaries of ``values()`` with the normal model
objects::
# This list contains a Blog object.
>>> Blog.objects.filter(name__startswith='Beatles')
[Beatles Blog]
# This list contains a dictionary.
>>> Blog.objects.filter(name__startswith='Beatles').values()
[{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]
``values()`` takes optional positional arguments, ``*fields``, which specify
field names to which the ``SELECT`` should be limited. If you specify the
fields, each dictionary will contain only the field keys/values for the fields
you specify. If you don't specify the fields, each dictionary will contain a
key and value for every field in the database table.
Example::
>>> Blog.objects.values()
[{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}],
>>> Blog.objects.values('id', 'name')
[{'id': 1, 'name': 'Beatles Blog'}]
A ``ValuesQuerySet`` is useful when you know you're only going to need values
from a small number of the available fields and you won't need the
functionality of a model instance object. It's more efficient to select only
the fields you need to use.
Finally, note a ``ValuesQuerySet`` is a subclass of ``QuerySet``, so it has all
methods of ``QuerySet``. You can call ``filter()`` on it, or ``order_by()``, or
whatever. Yes, that means these two calls are identical::
Blog.objects.values().order_by('id')
Blog.objects.order_by('id').values()
The people who made Django prefer to put all the SQL-affecting methods first,
followed (optionally) by any output-affecting methods (such as ``values()``),
but it doesn't really matter. This is your chance to really flaunt your
individualism.
distinct()
~~~~~~~~~~
The ``distinct()`` method returns a new ``QuerySet`` that uses
``SELECT DISTINCT`` in its SQL query. This eliminates duplicate rows from the
query results.
By default, a ``QuerySet`` will not eliminate duplicate rows. In practice, this
is rarely a problem, because simple queries such as ``Blog.objects.all()``
don't introduce the possibility of duplicate result rows.
However, if your query spans multiple tables, or you're using a
``ValuesQuerySet`` with a ``fields`` clause, it's possible to get duplicate
results when a ``QuerySet`` is evaluated. That's when you'd use ``distinct()``.
TODO: Left off here
``dates(field, kind, order='ASC')``
-----------------------------------
Returns a Date Query Set - a Query Set that evaluates to a list of
``datetime.datetime`` objects representing all available dates of a
particular kind within the contents of the Query Set.
``field`` should be the name of a ``DateField`` or ``DateTimeField`` of your
model.
``kind`` should be either ``"year"``, ``"month"`` or ``"day"``. Each
``datetime.datetime`` object in the result list is "truncated" to the given
``type``.
* ``"year"`` returns a list of all distinct year values for the field.
* ``"month"`` returns a list of all distinct year/month values for the field.
* ``"day"`` returns a list of all distinct year/month/day values for the field.
``order``, which defaults to ``'ASC'``, should be either ``"ASC"`` or ``"DESC"``.
This specifies how to order the results.
For example::
>>> Poll.objects.dates('pub_date', 'year')
[datetime.datetime(2005, 1, 1)]
>>> Poll.objects.dates('pub_date', 'month')
[datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
>>> Poll.objects.dates('pub_date', 'day')
[datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
>>> Poll.objects.dates('pub_date', 'day', order='DESC')
[datetime.datetime(2005, 3, 20), datetime.datetime(2005, 2, 20)]
>>> Poll.objects.filter(question__contains='name').dates('pub_date', 'day')
[datetime.datetime(2005, 3, 20)]
``select_related()``
--------------------
Relations are the bread and butter of databases, so there's an option to "follow"
all relationships and pre-fill them in a simple cache so that later calls to
objects with a one-to-many relationship don't have to hit the database. Do this by
passing ``select_related=True`` to a lookup. This results in (sometimes much) larger
queries, but it means that later use of relationships is much faster.
For example, using the Poll and Choice models from above, if you do the following::
c = Choice.objects.select_related().get(id=5)
Then subsequent calls to ``c.poll`` won't hit the database.
Note that ``select_related`` follows foreign keys as far as possible. If you have the
following models::
class Poll(models.Model):
# ...
class Choice(models.Model):
# ...
poll = models.ForeignKey(Poll)
class SingleVote(meta.Model):
# ...
choice = models.ForeignKey(Choice)
then a call to ``SingleVotes.objects.select_related().get(id=4)`` will
cache the related choice *and* the related poll::
>>> sv = SingleVotes.objects.select_related().get(id=4)
>>> c = sv.choice # Doesn't hit the database.
>>> p = c.poll # Doesn't hit the database.
>>> sv = SingleVotes.objects.get(id=4)
>>> c = sv.choice # Hits the database.
>>> p = c.poll # Hits the database.
``extra(params, select, where, tables)``
----------------------------------------
Sometimes, the Django query syntax by itself isn't quite enough. To cater for these
edge cases, Django provides the ``extra()`` Query Set modifier - a mechanism
for injecting specific clauses into the SQL generated by a Query Set.
Note that by definition these extra lookups may not be portable to different
database engines (because you're explicitly writing SQL code) and should be
avoided if possible.:
``params``
All the extra-SQL params described below may use standard Python string
formatting codes to indicate parameters that the database engine will
automatically quote. The ``params`` argument can contain any extra
parameters to be substituted.
``select``
The ``select`` keyword allows you to select extra fields. This should be a
dictionary mapping attribute names to a SQL clause to use to calculate that
attribute. For example::
Poll.objects.extra(
select={
'choice_count': 'SELECT COUNT(*) FROM choices WHERE poll_id = polls.id'
}
)
Each of the resulting ``Poll`` objects will have an extra attribute, ``choice_count``,
an integer count of associated ``Choice`` objects. Note that the parenthesis required by
most database engines around sub-selects are not required in Django's ``select``
clauses.
``where`` / ``tables``
If you need to explicitly pass extra ``WHERE`` clauses -- perhaps to perform
non-explicit joins -- use the ``where`` keyword. If you need to
join other tables into your query, you can pass their names to ``tables``.
``where`` and ``tables`` both take a list of strings. All ``where`` parameters
are "AND"ed to any other search criteria.
For example::
Poll.objects.filter(
question__startswith='Who').extra(where=['id IN (3, 4, 5, 20)'])
...translates (roughly) into the following SQL::
SELECT * FROM polls_polls WHERE question LIKE 'Who%' AND id IN (3, 4, 5, 20);
Caching and QuerySets
---------------------
Each ``QuerySet`` contains a cache, to minimize database access.
In a newly created ``QuerySet``, this cache is empty. The first time a
``QuerySet`` is evaluated -- and, hence, a database query happens -- Django
saves the query results in the ``QuerySet``'s cache and returns the results
that have been explicitly requested (e.g., the next element, if the
``QuerySet`` is being iterated over). Subsequent evaluations of the
``QuerySet`` reuse the cached results.
Keep this caching behavior in mind, because it may bite you if you don't use
your ``QuerySet``s correctly. For example, the following will create two
``QuerySet``s, evaluate them, and throw them away::
print [e.headline for e in Entry.objects.all()]
print [e.pub_date for e in Entry.objects.all()]
That means the same database query will be executed twice, effectively doubling
your database load. Also, there's a possibility the two lists may not include
the same database records, because an ``Entry`` may have been added or deleted
in the split second between the two requests.
To avoid this problem, simply save the ``QuerySet`` and reuse it::
queryset = Poll.objects.all()
print [p.headline for p in queryset] # Evaluate the query set.
print [p.pub_date for p in queryset] # Re-use the cache from the evaluation.
Deleting objects
================
Field lookups
=============
Basic field lookups take the form ``field__lookuptype`` (that's a
double-underscore). For example::
Poll.objects.filter(pub_date__lte=datetime.now())
translates (roughly) into the following SQL::
SELECT * FROM polls_poll WHERE pub_date <= NOW();
.. admonition:: How this is possible
Python has the ability to define functions that accept arbitrary name-value
arguments whose names and values are evaluated at run time. For more
information, see `Keyword Arguments`_ in the official Python tutorial.
The DB API supports the following lookup types:
=========== ==============================================================
Type Description
=========== ==============================================================
exact Exact match: ``Poll.objects.get(id__exact=14)`` returns all
polls with an ID of exactly 14.
iexact Case-insensitive exact match:
``Poll.objects.filter(slug__iexact="foo")`` matches a slug of
``foo``, ``FOO``, ``fOo``, etc.
contains Case-sensitive containment test:
``Poll.objects.filter(question__contains="spam")`` returns all polls
that contain "spam" in the question. (PostgreSQL and MySQL
only. SQLite doesn't support case-sensitive LIKE statements;
``contains`` will act like ``icontains`` for SQLite.)
icontains Case-insensitive containment test.
gt Greater than: ``Poll.objects.filter(id__gt=4)``.
gte Greater than or equal to.
lt Less than.
lte Less than or equal to.
in In a given list: ``Poll.objects.filter(id__in=[1, 3, 4])`` returns
a list of polls whose IDs are either 1, 3 or 4.
startswith Case-sensitive starts-with:
``Poll.objects.filter(question__startswith="Would")``. (PostgreSQL
and MySQL only. SQLite doesn't support case-sensitive LIKE
statements; ``startswith`` will act like ``istartswith`` for
SQLite.)
endswith Case-sensitive ends-with. (PostgreSQL and MySQL only.)
istartswith Case-insensitive starts-with.
iendswith Case-insensitive ends-with.
range Range test:
``Poll.objects.filter(pub_date__range=(start_date, end_date))``
returns all polls with a pub_date between ``start_date``
and ``end_date`` (inclusive).
year For date/datetime fields, exact year match:
``Poll.objects.count(pub_date__year=2005)``.
month For date/datetime fields, exact month match.
day For date/datetime fields, exact day match.
isnull True/False; does is IF NULL/IF NOT NULL lookup:
``Poll.objects.filter(expire_date__isnull=True)``.
=========== ==============================================================
If no lookup type is provided, a type of ``exact`` is assumed. The following
two statements are equivalent::
Poll.objects.get(id=14)
Poll.objects.get(id__exact=14)
Multiple lookup parameters are allowed. When separated by commans, the list of
lookup parameters will be "AND"ed together::
Poll.objects.filter(
pub_date__year=2005,
pub_date__month=1,
question__startswith="Would",
)
...retrieves all polls published in January 2005 that have a question starting
with "Would."
For convenience, there's a ``pk`` lookup type, which translates into
``(primary_key)``. In the polls example, these two statements are
equivalent::
Poll.objects.get(id__exact=3)
Poll.objects.get(pk=3)
``pk`` lookups also work across joins. In the polls example, these two
statements are equivalent::
Choice.objects.filter(poll__id=3)
Choice.objects.filter(poll__pk=3)
If you pass an invalid keyword argument, the function will raise ``TypeError``.
.. _`Keyword Arguments`: http://docs.python.org/tut/node6.html#SECTION006720000000000000000
OR lookups
==========
Keyword argument queries are "AND"ed together. If you have more
complex query requirements (for example, you need to include an ``OR``
statement in your query), you need to use ``Q`` objects.
A ``Q`` object (``django.db.models.Q``) is an object used to encapsulate a
collection of keyword arguments. These keyword arguments are specified in
the same way as keyword arguments to the basic lookup functions like get()
and filter(). For example::
Q(question__startswith='What')
is a ``Q`` object encapsulating a single ``LIKE`` query. ``Q`` objects can be
combined using the ``&`` and ``|`` operators. When an operator is used on two
``Q`` objects, it yields a new ``Q`` object. For example the statement::
Q(question__startswith='Who') | Q(question__startswith='What')
... yields a single ``Q`` object that represents the "OR" of two
"question__startswith" queries, equivalent to the SQL WHERE clause::
... WHERE question LIKE 'Who%' OR question LIKE 'What%'
You can compose statements of arbitrary complexity by combining ``Q`` objects
with the ``&`` and ``|`` operators. Parenthetical grouping can also be used.
One or more ``Q`` objects can then provided as arguments to the lookup
functions. If multiple ``Q`` object arguments are provided to a lookup
function, they will be "AND"ed together. For example::
Poll.objects.get(
Q(question__startswith='Who'),
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)
... roughly translates into the SQL::
SELECT * from polls WHERE question LIKE 'Who%'
AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')
If necessary, lookup functions can mix the use of ``Q`` objects and keyword
arguments. All arguments provided to a lookup function (be they keyword
argument or ``Q`` object) are "AND"ed together. However, if a ``Q`` object is
provided, it must precede the definition of any keyword arguments. For
example::
Poll.objects.get(
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
question__startswith='Who')
... would be a valid query, equivalent to the previous example; but::
# INVALID QUERY
Poll.objects.get(
question__startswith='Who',
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
... would not be valid.
A ``Q`` objects can also be provided to the ``complex`` keyword argument. For example::
Poll.objects.get(
complex=Q(question__startswith='Who') &
(Q(pub_date=date(2005, 5, 2)) |
Q(pub_date=date(2005, 5, 6))
)
)
See the `OR lookups examples page`_ for more examples.
.. _OR lookups examples page: http://www.djangoproject.com/documentation/models/or_lookups/
Specialist QuerySet evaluation
==============================
The following specialist functions can also be used to evaluate a Query Set.
Unlike iteration or slicing, these methods do not populate the cache; each
time one of these evaluation functions is used, the database will be queried.
``get(**kwargs)``
-----------------
Returns the object matching the given lookup parameters, which should be in
the format described in _`Field lookups`. Raises a module-level
``DoesNotExist`` exception if an object wasn't found for the given parameters.
Raises ``AssertionError`` if more than one object was found.
``count()``
-----------
Returns an integer representing the number of objects in the database matching
the Query Set. ``count()`` never raises exceptions.
Depending on which database you're using (e.g. PostgreSQL vs. MySQL), this may
return a long integer instead of a normal Python integer.
``in_bulk(id_list)``
--------------------
Takes a list of IDs and returns a dictionary mapping each ID to an instance of
the object with the given ID. For example::
>>> Poll.objects.in_bulk([1])
{1: What's up?}
>>> Poll.objects.in_bulk([1, 2])
{1: What's up?, 2: What's your name?}
>>> Poll.objects.in_bulk([])
{}
``latest(field_name=None)``
---------------------------
Returns the latest object, according to the model's 'get_latest_by'
Meta option, or using the field_name provided. For example::
>>> Poll.objects.latest()
What's up?
>>> Poll.objects.latest('expire_date')
What's your name?
Relationships (joins)
=====================
When you define a relationship in a model (i.e., a ForeignKey,
OneToOneField, or ManyToManyField), Django uses the name of the
relationship to add a descriptor_ on every instance of the model.
This descriptor behaves just like a normal attribute, providing
access to the related object or objects. For example,
``mychoice.poll`` will return the poll object associated with a specific
instance of ``Choice``.
.. _descriptor: http://users.rcn.com/python/download/Descriptor.htm
Django also adds a descriptor for the 'other' side of the relationship -
the link from the related model to the model that defines the relationship.
Since the related model has no explicit reference to the source model,
Django will automatically derive a name for this descriptor. The name that
Django chooses depends on the type of relation that is represented. However,
if the definition of the relation has a `related_name` parameter, Django
will use this name in preference to deriving a name.
There are two types of descriptor that can be employed: Single Object
Descriptors and Object Set Descriptors. The following table describes
when each descriptor type is employed. The local model is the model on
which the relation is defined; the related model is the model referred
to by the relation.
=============== ============= =============
Relation Type Local Model Related Model
=============== ============= =============
OneToOneField Single Object Single Object
ForeignKey Single Object Object Set
ManyToManyField Object Set Object Set
=============== ============= =============
Single object descriptor
------------------------
If the related object is a single object, the descriptor acts
just as if the related object were an attribute::
# Obtain the existing poll
old_poll = mychoice.poll
# Set a new poll
mychoice.poll = new_poll
# Save the change
mychoice.save()
Whenever a change is made to a Single Object Descriptor, save()
must be called to commit the change to the database.
If no `related_name` parameter is defined, Django will use the
lower case version of the source model name as the name for the
related descriptor. For example, if the ``Choice`` model had
a field::
coordinator = models.OneToOneField(User)
... instances of the model ``User`` would be able to call:
old_choice = myuser.choice
myuser.choice = new_choice
By default, relations do not allow values of None; if you attempt
to assign None to a Single Object Descriptor, an AttributeError
will be thrown. However, if the relation has 'null=True' set
(i.e., the database will allow NULLs for the relation), None can
be assigned and returned by the descriptor to represent empty
relations.
Access to Single Object Descriptors is cached. The first time
a descriptor on an instance is accessed, the database will be
queried, and the result stored. Subsequent attempts to access
the descriptor on the same instance will use the cached value.
Object set descriptor
---------------------
An Object Set Descriptor acts just like the Manager - as an initial Query
Set describing the set of objects related to an instance. As such, any
query refining technique (filter, exclude, etc) can be used on the Object
Set descriptor. This also means that Object Set Descriptor cannot be evaluated
directly - the ``all()`` method must be used to produce a Query Set that
can be evaluated.
If no ``related_name`` parameter is defined, Django will use the lower case
version of the source model name appended with `_set` as the name for the
related descriptor. For example, every ``Poll`` object has a ``choice_set``
descriptor.
The Object Set Descriptor has utility methods to add objects to the
related object set:
``add(obj1, obj2, ...)``
Add the specified objects to the related object set.
``create(\**kwargs)``
Create a new object, and put it in the related object set. See
_`Creating new objects`
The Object Set Descriptor may also have utility methods to remove objects
from the related object set:
``remove(obj1, obj2, ...)``
Remove the specified objects from the related object set.
``clear()``
Remove all objects from the related object set.
These two removal methods will not exist on ForeignKeys where ``Null=False``
(such as in the Poll example). This is to prevent database inconsistency - if
the related field cannot be set to None, then an object cannot be removed
from one relation without adding it to another.
The members of a related object set can be assigned from any iterable object.
For example::
mypoll.choice_set = [choice1, choice2]
If the ``clear()`` method is available, any pre-existing objects will be removed
from the Object Set before all objects in the iterable (in this case, a list)
are added to the choice set. If the ``clear()`` method is not available, all
objects in the iterable will be added without removing any existing elements.
Each of these operations on the Object Set Descriptor has immediate effect
on the database - every add, create and remove is immediately and
automatically saved to the database.
Relationships and queries
=========================
When composing a ``filter`` or ``exclude`` refinement, it may be necessary to
include conditions that span relationships. Relations can be followed as deep
as required - just add descriptor names, separated by double underscores, to
describe the full path to the query attribute. The query::
Foo.objects.filter(name1__name2__name3__attribute__lookup=value)
... is interpreted as 'get every Foo that has a name1 that has a name2 that
has a name3 that has an attribute with lookup matching value'. In the Poll
example::
Choice.objects.filter(poll__slug__startswith="eggs")
... describes the set of choices for which the related poll has a slug
attribute that starts with "eggs". Django automatically composes the joins
and conditions required for the SQL query.
Creating new objects
====================
Creating new objects (i.e. ``INSERT``) is done by creating new instances
of objects then calling save() on them::
>>> p = Poll(slug="eggs",
... question="How do you like your eggs?",
... pub_date=datetime.datetime.now(),
... expire_date=some_future_date)
>>> p.save()
Calling ``save()`` on an object with a primary key whose value is ``None``
signifies to Django that the object is new and should be inserted.
Related objects are created using the ``create()`` convenience function on
the descriptor Manager for relation::
>>> p.choice_set.create(choice="Over easy", votes=0)
>>> p.choice_set.create(choice="Scrambled", votes=0)
>>> p.choice_set.create(choice="Fertilized", votes=0)
>>> p.choice_set.create(choice="Poached", votes=0)
>>> p.choice_set.count()
4
Each of those ``create()`` methods is equivalent to (but much simpler than)::
>>> c = Choice(poll_id=p.id, choice="Over easy", votes=0)
>>> c.save()
Note that when using the `create()`` method, you do not give any value
for the ``id`` field, nor do you give a value for the field that stores
the relation (``poll_id`` in this case).
The ``create()`` method always returns the newly created object.
Deleting objects
================
The delete method, conveniently, is named ``delete()``. This method immediately
deletes the object and has no return value. Example::
>>> c.delete()
Objects can also be deleted in bulk. Every Query Set has a ``delete()`` method
that will delete all members of the query set. For example::
>>> Polls.objects.filter(pub_date__year=2005).delete()
would bulk delete all Polls with a year of 2005. Note that ``delete()`` is the
only Query Set method that is not exposed on the Manager itself.
This is a safety mechanism to prevent you from accidentally requesting
``Polls.objects.delete()``, and deleting *all* the polls.
If you *actually* want to delete all the objects, then you have to explicitly
request a complete query set::
Polls.objects.all().delete()
Comparing objects
=================
To compare two model objects, just use the standard Python comparison operator,
the double equals sign: ``==``. Behind the scenes, that compares the primary
key values of two models.
Using the ``Poll`` example above, the following two statements are equivalent::
some_poll == other_poll
some_poll.id == other_poll.id
If a model's primary key isn't called ID, no problem. Comparisons will always
use the primary key, whatever it's called. For example, if a model's primary
key field is called ``name``, these two statements are equivalent::
some_obj == other_obj
some_obj.name == other_obj.name
Extra instance methods
======================
In addition to ``save()``, ``delete()``, a model object might get any or all
of the following methods:
get_FOO_display()
-----------------
For every field that has ``choices`` set, the object will have a
``get_FOO_display()`` method, where ``FOO`` is the name of the field. This
method returns the "human-readable" value of the field. For example, in the
following model::
GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
)
class Person
name = meta.CharField(maxlength=20)
gender = meta.CharField(maxlength=1, choices=GENDER_CHOICES)
...each ``Person`` instance will have a ``get_gender_display()`` method. Example::
>>> p = Person(name='John', gender='M')
>>> p.save()
>>> p.gender
'M'
>>> p.get_gender_display()
'Male'
get_next_by_FOO(\**kwargs) and get_previous_by_FOO(\**kwargs)
-------------------------------------------------------------
For every ``DateField`` and ``DateTimeField`` that does not have ``null=True``,
the object will have ``get_next_by_FOO()`` and ``get_previous_by_FOO()``
methods, where ``FOO`` is the name of the field. This returns the next and
previous object with respect to the date field, raising the appropriate
``DoesNotExist`` exception when appropriate.
Both methods accept optional keyword arguments, which should be in the format
described in "Field lookups" above.
Note that in the case of identical date values, these methods will use the ID
as a fallback check. This guarantees that no records are skipped or duplicated.
For a full example, see the `lookup API sample model_`.
.. _lookup API sample model: http://www.djangoproject.com/documentation/models/lookup/
get_FOO_filename()
------------------
For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
where ``FOO`` is the name of the field. This returns the full filesystem path
to the file, according to your ``MEDIA_ROOT`` setting.
Note that ``ImageField`` is technically a subclass of ``FileField``, so every
model with an ``ImageField`` will also get this method.
get_FOO_url()
-------------
For every ``FileField``, the object will have a ``get_FOO_url()`` method,
where ``FOO`` is the name of the field. This returns the full URL to the file,
according to your ``MEDIA_URL`` setting. If the value is blank, this method
returns an empty string.
get_FOO_size()
--------------
For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
where ``FOO`` is the name of the field. This returns the size of the file, in
bytes. (Behind the scenes, it uses ``os.path.getsize``.)
save_FOO_file(filename, raw_contents)
-------------------------------------
For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
where ``FOO`` is the name of the field. This saves the given file to the
filesystem, using the given filename. If a file with the given filename already
exists, Django adds an underscore to the end of the filename (but before the
extension) until the filename is available.
get_FOO_height() and get_FOO_width()
------------------------------------
For every ``ImageField``, the object will have ``get_FOO_height()`` and
``get_FOO_width()`` methods, where ``FOO`` is the name of the field. This
returns the height (or width) of the image, as an integer, in pixels.
Reference in New Issue View Git Blame Copy Permalink