get_object(**kwargs)

Returns the object matching the given lookup parameters, which should be in the format described in "Field lookups" below. 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.

get_list(**kwargs)

Returns a list of objects matching the given lookup parameters, which should be in the format described in "Field lookups" below. If no objects match the given parameters, it returns an empty list. get_list() will always return a list.

get_iterator(**kwargs)

Just like get_list(), except it returns an iterator instead of a list. This is more efficient for large result sets. This example shows the difference:

# get_list() loads all objects into memory.
for obj in foos.get_list():
    print repr(obj)

# get_iterator() only loads a number of objects into memory at a time.
for obj in foos.get_iterator():
    print repr(obj)

get_count(**kwargs)

Returns an integer representing the number of objects in the database matching the given lookup parameters, which should be in the format described in "Field lookups" below. get_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.

get_values(**kwargs)

Just like get_list(), except it returns a list of dictionaries instead of model-instance objects.

It accepts an optional parameter, fields, which should be a list or tuple of field names. If you don't specify fields, each dictionary in the list returned by get_values() will have a key and value for each field in the database table. If you specify fields, each dictionary will have only the field keys/values for the fields you specify. Here's an example, using the Poll model defined above:

>>> from datetime import datetime
>>> p1 = polls.Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = polls.Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> polls.get_list()
[What's up?, What's your name?]
>>> polls.get_values()
[{'id': 1, 'slug': 'whatsup', 'question': "What's up?", 'pub_date': datetime.datetime(2005, 2, 20), 'expire_date': datetime.datetime(2005, 3, 20)},
 {'id': 2, 'slug': 'name', 'question': "What's your name?", 'pub_date': datetime.datetime(2005, 3, 20), 'expire_date': datetime.datetime(2005, 4, 20)}]
>>> polls.get_values(fields=['id', 'slug'])
[{'id': 1, 'slug': 'whatsup'}, {'id': 2, 'slug': 'name'}]

Use get_values() when you know you're only going to need a couple of field values 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.

get_values_iterator(**kwargs)

Just like get_values(), except it returns an iterator instead of a list. See the section on get_iterator() above.

get_in_bulk(id_list, **kwargs)

Takes a list of IDs and returns a dictionary mapping each ID to an instance of the object with the given ID. Also takes optional keyword lookup arguments, which should be in the format described in "Field lookups" below. Here's an example, using the Poll model defined above:

>>> from datetime import datetime
>>> p1 = polls.Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = polls.Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> polls.get_list()
[What's up?, What's your name?]
>>> polls.get_in_bulk([1])
{1: What's up?}
>>> polls.get_in_bulk([1, 2])
{1: What's up?, 2: What's your name?}

OR lookups

New in Django development version.

By default, multiple lookups are "AND"ed together. If you'd like to use OR statements in your queries, use the complex lookup type.

complex takes an expression of clauses, each of which is an instance of django.core.meta.Q. Q takes an arbitrary number of keyword arguments in the standard Django lookup format. And you can use Python's "and" (&) and "or" (|) operators to combine Q instances. For example:

from django.core.meta import Q
polls.get_object(complex=(Q(question__startswith='Who') | Q(question__startswith='What')))

The | symbol signifies an "OR", so this (roughly) translates into:

SELECT * FROM polls
WHERE question LIKE 'Who%' OR question LIKE 'What%';

You can use & and | operators together, and use parenthetical grouping. Example:

polls.get_object(complex=(Q(question__startswith='Who') & (Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6))))

This roughly translates into:

SELECT * FROM polls
WHERE question LIKE 'Who%'
    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06');

See the OR lookups examples page for more examples.

One-to-one relations

Each object in a one-to-one relationship will have a get_relatedobjectname() method. For example:

class Place(meta.Model):
    # ...

class Restaurant(meta.Model):
    # ...
    the_place = meta.OneToOneField(places.Place)

In the above example, each Place will have a get_restaurant() method, and each Restaurant will have a get_the_place() method.

Many-to-one relations

In each many-to-one relationship, the related object will have a get_relatedobject() method, and the related-to object will have get_relatedobject(), get_relatedobject_list(), and get_relatedobject_count() methods (the same as the module-level get_object(), get_list(), and get_count() methods).

In the poll example above, here are the available choice methods on a Poll object p:

p.get_choice()
p.get_choice_list()
p.get_choice_count()

And a Choice object c has the following method:

c.get_poll()

Many-to-many relations

Many-to-many relations result in the same set of methods as Many-to-one relations, except that the get_relatedobject_list() function on the related object will return a list of instances instead of a single instance. So, if the relationship between Poll and Choice was many-to-many, choice.get_poll_list() would return a list.

Relationships across applications

If a relation spans applications -- if Place was had a ManyToOne relation to a geo.City object, for example -- the name of the other application will be added to the method, i.e. place.get_geo_city() and city.get_places_place_list().

Selecting related objects

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 = choices.get_object(id__exact=5, select_related=True)

Then subsequent calls to c.get_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(meta.Model):
    # ...

class Choice(meta.Model):
    # ...
    poll = meta.ForeignKey(Poll)

class SingleVote(meta.Model):
    # ...
    choice = meta.ForeignKey(Choice)

then a call to singlevotes.get_object(id__exact=4, select_related=True) will cache the related choice and the related poll:

>>> sv = singlevotes.get_object(id__exact=4, select_related=True)
>>> c = sv.get_choice()        # Doesn't hit the database.
>>> p = c.get_poll()           # Doesn't hit the database.

>>> sv = singlevotes.get_object(id__exact=4) # Note no "select_related".
>>> c = sv.get_choice()        # Hits the database.
>>> p = c.get_poll()           # Hits the database.

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:

polls.get_list(
    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:

polls.get_list(question__startswith='Who', 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);

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_.

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.

get_FOO_list(kind, **kwargs)

For every DateField and DateTimeField, the model module will have a get_FOO_list() function, where FOO is the name of the field. This returns a list of datetime.datetime objects representing all available dates of the given scope, as defined by the kind argument. 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.

Additional, optional keyword arguments, in the format described in "Field lookups" above, are also accepted.

Here's an example, using the Poll model defined above:

>>> from datetime import datetime
>>> p1 = polls.Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = polls.Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> polls.get_pub_date_list('year')
[datetime.datetime(2005, 1, 1)]
>>> polls.get_pub_date_list('month')
[datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
>>> polls.get_pub_date_list('day')
[datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
>>> polls.get_pub_date_list('day', question__contains='name')
[datetime.datetime(2005, 3, 20)]

get_FOO_list() also accepts an optional keyword argument order, which should be either "ASC" or "DESC". This specifies how to order the results. Default is "ASC".