Django ORM (Querysets)
In this chapter you'll learn how Django connects to the database and stores data in it. Let's dive in!
What is a QuerySet?
A QuerySet is, in essence, a list of objects of a given Model. QuerySets allow you to read the data from the database, filter it and order it.
It's easiest to learn by example. Let's try this, shall we?
Django shell
Open up your local console (not on PythonAnywhere) and type this command:
The effect should be like this:
You're now in Django's interactive console. It's just like the Python prompt, but with some additional Django magic. :) You can use all the Python commands here too.
All objects
Let's try to display all of our posts first. You can do that with the following command:
Oops! An error showed up. It tells us that there is no Post. It's correct – we forgot to import it first!
We import the model Post
from blog.models
. Let's try displaying all posts again:
This is a list of the posts we created earlier! We created these posts using the Django admin interface. But now we want to create new posts using Python, so how do we do that?
Create object
This is how you create a new Post object in database:
But we have one missing ingredient here: me
. We need to pass an instance of User
model as an author. How do we do that?
Let's import User model first:
What users do we have in our database? Try this:
This is the superuser we created earlier! Let's get an instance of the user now (adjust this line to use your own username):
As you can see, we now get
a User
with a username
that equals 'ola'. Neat!
Now we can finally create our post:
Hurray! Wanna check if it worked?
There it is, one more post in the list!
Add more posts
You can now have a little fun and add more posts to see how it works. Add two or three more and then go ahead to the next part.
Filter objects
A big part of QuerySets is the ability to filter them. Let's say we want to find all posts that user ola authored. We will use filter
instead of all
in Post.objects.all()
. In parentheses we state what condition(s) a blog post needs to meet to end up in our queryset. In our case, the condition is that author
should be equal to me
. The way to write it in Django is author=me
. Now our piece of code looks like this:
Or maybe we want to see all the posts that contain the word 'title' in the title
field?
Note There are two underscore characters (
_
) betweentitle
andcontains
. Django's ORM uses this rule to separate field names ("title") and operations or filters ("contains"). If you use only one underscore, you'll get an error like "FieldError: Cannot resolve keyword title_contains".
You can also get a list of all published posts. We do this by filtering all the posts that have published_date
set in the past:
Unfortunately, the post we added from the Python console is not published yet. But we can change that! First get an instance of a post we want to publish:
And then publish it with our publish
method:
Now try to get list of published posts again (press the up arrow key three times and hit enter
):
Ordering objects
QuerySets also allow you to order the list of objects. Let's try to order them by created_date
field:
We can also reverse the ordering by adding -
at the beginning:
Complex queries through method-chaining
As you saw, some methods on Post.objects
return a QuerySet. The same methods can in turn also be called on a QuerySet, and will then return a new QuerySet. Thus, you can combine their effect by chaining them together:
This is really powerful and lets you write quite complex queries.
Cool! You're now ready for the next part! To close the shell, type this:
```python >>> exit() $ ```
Last updated