장고 쿼리셋을 정복해보자.

🙋‍♀️ QuerySet API reference

해당 튜토리얼을 진행하는데 사용되는 모델은 아래와 같이 정의된다.
Blog, Author, Entry 3개의 필드로 구성되어있다.

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

    def __str__(self):
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=200)
    email = models.EmailField()

    def __str__(self):
        return self.name

class Entry(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Author)
    number_of_comments = models.IntegerField()
    number_of_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):
        return self.headline

🧪 쿼리셋은 언제 평가 되는가?

장고 쿼리셋은 바로 데이터베이스에 쿼리문을 날리지 않는다.
다음과 같은 연산을 할 때 실제 데이터베이스에 쿼리문을 날리게 된다.

• Iteration
• Slicing
• Pickling/ Cashing
• repr()
• len()
• list()
• bool()

💽 Queryset API

🚀 Queryset 객체를 리턴하는 메소드

filter()

• filter(**kwargs)

키워드 인수로 넘겨준 조건에 맞는 쿼리셋을 반환한다.

In [7]: Blog.objects.filter(id=1)
Out[7]: <QuerySet [<Blog: hi>]>

조건을 두가지를 줘서 AND 연산을 만들 수 있다.

In [16]: Blog.objects.filter(id=1, name="hi")
Out[16]: <QuerySet [<Blog: hi>]>

• sql 쿼리문

mysql> select * from blogs_blog where id=1 and name="hi";
+----+------+---------+
| id | name | tagline |
+----+------+---------+
|  1 | hi   | hello   |
+----+------+---------+

exclude()

• exclude(**kwargs)

키워드 인수로 넘겨준 조건에 맞지'않은' 쿼리셋을 반환한다.

In [10]: Blog.objects.all()
Out[10]: <QuerySet [<Blog: hi>, <Blog: hello>]>

In [12]: Blog.objects.exclude(id=1)
Out[12]: <QuerySet [<Blog: hello>]>

조건을 두가지를 줘서 AND 연산을 만들 수 있다.

In [18]: Blog.objects.exclude(id=1, name="hi")
Out[18]: <QuerySet [<Blog: hello>]>

• sql 쿼리문

mysql> select * from blogs_blog where not (id=1) and not (name="hi");
+----+-------+---------+
| id | name  | tagline |
+----+-------+---------+
|  2 | hello | world   |
+----+-------+---------+

annotate()

• annotate(*args, **kwargs)

.annotate()의 각 인수는 QuerySet의 각 객체에 추가 될 주석이다. 주석들은 단순한 값, 모델의 필드에 대한 참조, QuerySet의 각 객체와 관련된 집계(averages, sums 등)이다.
새로운 요소를 데이터 쿼리에 추가하고 해당 요소를 따로 출력해볼 수 있도록 해주는 것인데, 데이터가 몇 개 존재하는지를 .count()라는 함수를 이용해서 annotate해주고 이를 __count로 접근할 수 있다.

쉽게 말해서 .annotate()는 필드 하나를 만들고 거기에 '어떤 내용' 을 채우게 만드는 것이다. 엑셀에서 컬럼 하나를 만드는 것과 같다고 보면 된다. 내용에는 1. 다른 필드의 값을 그대로 복사하거나, 2. 다른 필드의 값들을 조합한 값을 넣을 수 있다.
출처

추가 사용법 정리 링크: 어노테이트 기능

sql의 GroupBy 기능과 같다고 생각하면 된다.

order_by()

• order_by(*fields)

쿼리셋에 oreder_by메소드의 인자로 넣어준 필드를 기준으로 정렬한다.

In [35]: Blog.objects.all()
Out[35]: <QuerySet [<Blog: hi>, <Blog: hello>, <Blog: bro>, <Blog: why?>]>

In [33]: Blog.objects.all().order_by('id')
Out[33]: <QuerySet [<Blog: hi>, <Blog: hello>, <Blog: bro>, <Blog: why?>]>

In [34]: Blog.objects.all().order_by('-id')
Out[34]: <QuerySet [<Blog: why?>, <Blog: bro>, <Blog: hello>, <Blog: hi>]>

order_by('필드'): 오름차순
order_by('-필드'): 내림차순

• sql 쿼리문

mysql> select * from blogs_blog order by id ASC;
+----+-------+---------+
| id | name  | tagline |
+----+-------+---------+
|  1 | hi    | hello   |
|  2 | hello | world   |
|  3 | bro   | hello   |
|  4 | why?  | hello   |
+----+-------+---------+

mysql> select * from blogs_blog order by id DESC;
+----+-------+---------+
| id | name  | tagline |
+----+-------+---------+
|  4 | why?  | hello   |
|  3 | bro   | hello   |
|  2 | hello | world   |
|  1 | hi    | hello   |
+----+-------+---------+

values()

• values(*fields, **expressions)

쿼리셋 결과를 딕셔너리 형태로 반환합니다.

In [63]: a
Out[63]: <QuerySet [{'id': 1, 'name': 'hi', 'tagline': 'hello'}, {'id': 2, 'name': 'hello', 'tagline': 'world'}, {'id': 3, 'name': 'bro', 'tagline': 'hello'}, {'id': 4, 'name': 'why?', 'tagline': 'hello'}, {'id': 5, 'name': 'hi', 'tagline': 'what?'}]>

In [64]: a[0]
Out[64]: {'id': 1, 'name': 'hi', 'tagline': 'hello'}

values_list()

• values_list(*fields, flat=False, named=False)

쿼리셋의 값을 튜플 형태로 반환한다.

In [65]: Blog.objects.all().values_list()
Out[66]: <QuerySet [(1, 'hi', 'hello'), (2, 'hello', 'world'), (3, 'bro', 'hello'), (4, 'why?', 'hello'), (5, 'hi', 'what?')]>

In [68]: Blog.objects.all().values_list('name')
Out[69]: <QuerySet [('hi',), ('hello',), ('bro',), ('why?',), ('hi',)]>

In [70]: Blog.objects.all().values_list('id','name')
Out[71]: <QuerySet [(1, 'hi'), (2, 'hello'), (3, 'bro'), (4, 'why?'), (5, 'hi')]>

union()

쿼리셋을 합칠 때 사용한다.

In [72]: a = Blog.objects.filter(id=1)

In [73]: a
Out[73]: <QuerySet [<Blog: hi>]>

In [74]: b = Blog.objects.filter(id=2)

In [75]: b
Out[75]: <QuerySet [<Blog: hello>]>

In [76]: result = a.union(b)

In [77]: result
Out[77]: <QuerySet [<Blog: hi>, <Blog: hello>]>

select_related()

• select_related(*fields)

sql의 조인문 역할을 한다.
slecected_related를 활용하면 데이터베이스를 적게 건드린다.

# 데이터 베이스를 건드린다.
e = Entry.objects.get(id=5)

# 또 건드린다. 
b = e.blog

select_related 사용

# 데이터 베이스를 건드린다.
e = Entry.objects.select_related('blog').get(id=5)

# 데이터베이스를 안건드린다. 
b = e.blog

• sql 쿼리문

mysql> select b.*, e.* from blogs_blog as b join blogs_entry as e on b.id = e.id;
+----+-------+---------+----+----------+-----------------+------------+------------+--------------------+---------------------+--------+---------+
| id | name  | tagline | id | headline | body_text       | pub_date   | mod_date   | number_of_comments | number_of_pingbacks | rating | blog_id |
+----+-------+---------+----+----------+-----------------+------------+------------+--------------------+---------------------+--------+---------+
|  1 | hi    | hello   |  1 | lalala   | 안녕하세요      | 2021-08-14 | 2021-08-14 |                  1 |                   1 |      1 |       1 |
|  2 | hello | world   |  2 | lhahaha  | ji hello        | 2021-08-14 | 2021-08-14 |                  1 |                   3 |      2 |       2 |
+----+-------+---------+----+----------+-----------------+------------+------------+--------------------+---------------------+--------+---------+
2 rows in set (0.00 sec)