表关系如下

图书和订单表假设是一对多关系。假设一个订单里只有一本图书，一本图书可以属于多个订单。
图书和作者假设是一对多关系，一本书只能属于一个作者，一个作者可以写多本书

class Author(models.Model):
    """作者模型"""
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    email = models.EmailField()

    class Meta:
        db_table = "author"


class Publisher(models.Model):
    """出版社模型"""
    name = models.CharField(max_length=300)

    class Meta:
        db_table = "publisher"

class Book(models.Model):
    """图书模型"""
    name = models.CharField(max_length=300)
    remark = models.CharField(max_length=300)
    pages = models.IntegerField()
    price = models.FloatField()
    rating = models.FloatField()
    author = models.ForeignKey(Author,on_delete=models.CASCADE)
    publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE)

    class Meta:
        db_table = "book"


class BookOrder(models.Model):
    """图书订单模型"""
    book = models.ForeignKey("Book",on_delete=models.CASCADE)
    price = models.FloatField()
    create_time = models.DateTimeField(auto_now_add=True,null=True)

    class Meta:
        db_table = "book_order"


book
+----+----------+-------+-------+--------+-----------+--------------+----------+
| id | name     | pages | price | rating | author_id | publisher_id | remark   |
+----+----------+-------+-------+--------+-----------+--------------+----------+
|  1 | 三国演义 |   987 |   107 |    4.8 |         3 |            1 | 三国演义 |
|  2 | 水浒传   |   967 |   107 |   4.83 |         4 |            1 | 水浒传   |
|  3 | 西游记   |  1004 |   105 |   4.85 |         2 |            2 | 西游记   |
|  4 | 红楼梦   |  1007 |   109 |    4.9 |         1 |            2 | 红楼梦   |
+----+----------+-------+-------+--------+-----------+--------------+----------+
book_order
+----+-------+---------+----------------------------+
| id | price | book_id | create_time                |
+----+-------+---------+----------------------------+
|  1 |    95 |       1 | 2019-06-17 07:10:02.053000 |
|  2 |    94 |       2 | 2020-06-17 07:10:02.053000 |
|  6 |    95 |       1 | 2020-06-23 22:11:33.000000 |
+----+-------+---------+----------------------------+
author
+----+--------+-----+------------+
| id | name   | age | email      |
+----+--------+-----+------------+
|  1 | 曹雪芹 |  35 | cxq@qq.com |
|  2 | 吴承恩 |  28 | wce@qq.com |
|  3 | 罗贯中 |  36 | lgz@qq.com |
|  4 | 施耐庵 |  46 | sna@qq.com |
+----+--------+-----+------------+

order_by()

根据字段排序

#根据图书价格升序
books = Book.objects.order_by("price")
#根据图书价格降序
books = Book.objects.order_by("-price")
#根据图书价格升序，如果价格一样再根据评分升序
books = Book.objects.order_by("price","rating")
#多个order_by只有最后一个生效，前面的都无效
books = Book.objects.order_by("price").order_by("rating")
>>>三国演义/107.0/4.8
   水浒传/107.0/4.83
   西游记/105.0/4.85
   红楼梦/109.0/4.9

=#根据图书销量排序
books = Book.objects.annotate(order_nums = Count("bookorder")).order_by("order_nums")
for book in books:
    print("%s/%s"%(book.name,book.order_nums))
print(connection.queries[-1])
>>>红楼梦/0
   西游记/0
   水浒传/1
   三国演义/2
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id`, COUNT(`book_order`.`id`) AS `order_nums` FROM `book` LEFT OUTER JOIN `book_order` ON (`book`.`id` = `book_order`.`book_id`) GROUP BY `book`.`id` ORDER BY `order_nums` ASC

values()

查找指定字段，返回的是QuerySet对象，QuerySet对象中的元素是字典

#查找图书表的id和名称
books = Book.objects.values("id","name")
print(type(books),books)
print(type(books[0]),books[0])
>>><class 'django.db.models.query.QuerySet'> <QuerySet [{'name': '三国演义', 'id': 1}, {'name': '水浒传', 'id': 2}, {'name': '西游记', 'id': 3}, {'name': '红楼梦', 'id': 4}]>
>>><class 'dict'> {'name': '三国演义', 'id': 1}

#反向查找订单表的售价示例
books = Book.objects.values("id","name","bookorder__price")
#books = Book.objects.values("id",test_name = F("name"),test_price = F("bookorder__price")) //借助F表达式可以自定义别名
print(books)
print(connection.queries[-1])
>>><QuerySet [{'id': 1, 'bookorder__price': 95.0, 'name': '三国演义'}, {'id': 2, 'bookorder__price': 94.0, 'name': '水浒传'}, {'id': 1, 'bookorder__price': 95.0, 'name': '三国演义'}, {'id': 3, 'bookorder__price': None, 'name': '西游记'}, {'id': 4, 'bookorder__price': None, 'name': '红楼梦'}]>
>>>SELECT `book`.`id`, `book`.`name`, `book_order`.`price` FROM `book` LEFT OUTER JOIN `book_order` ON (`book`.`id` = `book_order`.`book_id`) LIMIT 21

由于values返回的是QuerySet对象，因此可以在values后面链式使用QuerySet API，比如books = Book.objects.values("id","name").filter(name__icontains="三国")。
Book.objects.all()返回的QuerySet对象中的元素是模型对象，结构如下：

<QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>]>

使用聚合函数

#获取每本图书的销量
books = Book.objects.values("id","name",order_nums = Count("bookorder__id"))
print(books)
print(connection.queries[-1])
>>><QuerySet [{'name': '三国演义', 'id': 1, 'order_nums': 2}, {'name': '水浒传', 'id': 2, 'order_nums': 1}, {'name': '西游记', 'id': 3, 'order_nums': 0}, {'name': '红楼梦', 'id': 4, 'order_nums': 0}]>
>>>SELECT `book`.`id`, `book`.`name`, COUNT(`book_order`.`id`) AS `order_nums` FROM `book` LEFT OUTER JOIN `book_order` ON (`book`.`id` = `book_order`.`book_id`) GROUP BY `book`.`id` ORDER BY NULL LIMIT 21

values_list()

用法和values一样，只是返回的QuerySet对象中存储的不是字典，是字段值组成的元祖

#查找所有图书的id和name
books = Book.objects.values_list("id", "name")
print(type(books),books)
print(type(books[0]),books[0])
>>><class 'django.db.models.query.QuerySet'> <QuerySet [(1, '三国演义'), (2, '水浒传'), (3, '西游记'), (4, '红楼梦')]>
>>><class 'tuple'> (1, '三国演义')

#只查找一个字段示例
books = Book.objects.values_list("name")
print(type(books),books)
print(type(books[0]),books[0])
>>><class 'django.db.models.query.QuerySet'> <QuerySet [('三国演义',), ('水浒传',), ('西游记',), ('红楼梦',)]>
>>><class 'tuple'> ('三国演义',)

#flat = True用于只有一个字段，返回的QuerySet中元素是字符串，不是元祖。多个字段使用flat = True会报错
books = Book.objects.values_list("name",flat=True)
print(type(books),books)
print(type(books[0]),books[0])
>>><class 'django.db.models.query.QuerySet'> <QuerySet ['三国演义', '水浒传', '西游记', '红楼梦']>
>>><class 'str'> 三国演义

all()

返回QuerySet对象，元素是模型对象

#获取所有图书
books = Book.objects.all()
print(type(books),books)
>>><class 'django.db.models.query.QuerySet'> <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>]>

print(connection.queries[-1])
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` LIMIT 21

for book in books:
   print(book.name)
print(connection.queries[-1])
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

打印books或者循环books都会产生sql查询

为什么不直接用Book.objects获取

参考之前分析objects属性可知道，Book.objects对象对应的类拷贝了QuerySet类里面大部分方法，包括all()，打印结果如下：

books = Book.objects
print(type(books),books)
>>><class 'django.db.models.manager.Manager'> front.Book.objects

for book in books:
   print(book.name)
>>>TypeError: 'Manager' object is not iterable

django.db.models.manager.Manager对象不可迭代，所以无法遍历，而all()方法返回的QuerySet对象是可以迭代的。

select_related()

通过一次sql查询，避免多次sql查询，只能使用在一对多关系，多表的外键字段上(一个作者可以有多本书，书是多表，Book表的外键字段author可以使用)。对比如下：

#查询每本图书的作者姓名
books = Book.objects.all()
for book in books:
    print(book.author.name)#每次循环都会产生sql
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
   SELECT `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `author` WHERE `author`.`id` = 3
   SELECT `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `author` WHERE `author`.`id` = 4
   SELECT `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `author` WHERE `author`.`id` = 2
   SELECT `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `author` WHERE `author`.`id` = 1

#使用select_related
books = Book.objects.select_related("author")
for book in books:
    print(book.author.name)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id`, `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `book` INNER JOIN `author` ON (`book`.`author_id` = `author`.`id`)

prefetch_related()

可以用在多对多，一对多关系(一表和多表都能使用)

#普通写法----查询所有图书和订单信息，打印订单id
books = Book.objects.all() #查询所有图书
for book in books:
    orders = book.bookorder_set.all() #每次循环查询图书对应的订单
    for order in orders:
        print(order.id)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` = 1
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` = 2
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` = 3
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` = 4

#使用prefetch_related----反向查询，只要查询两次sql
books = Book.objects.prefetch_related("bookorder_set")
print(books.values())
>>><QuerySet [{'publisher_id': 1, 'price': 107.0, 'pages': 987, 'remark': '三国演义', 'rating': 4.8, 'author_id': 3, 'id': 1, 'name': '三国演义'}, {'publisher_id': 1, 'price': 107.0, 'pages': 967, 'remark': '水浒传', 'rating': 4.83, 'author_id': 4, 'id': 2, 'name': '水浒传'}, {'publisher_id': 2, 'price': 105.0, 'pages': 1004, 'remark': '西游记', 'rating': 4.85, 'author_id': 2, 'id': 3, 'name': '西游记'}, {'publisher_id': 2, 'price': 109.0, 'pages': 1007, 'remark': '红楼梦', 'rating': 4.9, 'author_id': 1, 'id': 4, 'name': '红楼梦'}]>

for book in books:
    orders = book.bookorder_set.all()
    for order in orders:
        print(order.id)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` IN (1, 2, 3, 4)

#使用prefetch_related----通过外键查询，需要查询两次sql
books = Book.objects.prefetch_related("author")
print(books.values())
>>><QuerySet [{'pages': 987, 'author_id': 3, 'name': '三国演义', 'price': 107.0, 'remark': '三国演义', 'id': 1, 'publisher_id': 1, 'rating': 4.8}, {'pages': 967, 'author_id': 4, 'name': '水浒传', 'price': 107.0, 'remark': '水浒传', 'id': 2, 'publisher_id': 1, 'rating': 4.83}, {'pages': 1004, 'author_id': 2, 'name': '西游记', 'price': 105.0, 'remark': '西游记', 'id': 3, 'publisher_id': 2, 'rating': 4.85}, {'pages': 1007, 'author_id': 1, 'name': '红楼梦', 'price': 109.0, 'remark': '红楼梦', 'id': 4, 'publisher_id': 2, 'rating': 4.9}]>

for book in books:
    print(book.author.name)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
   SELECT `author`.`id`, `author`.`name`, `author`.`age`, `author`.`email` FROM `author` WHERE `author`.`id` IN (1, 2, 3, 4)

bookorder_set是django自动生成，格式是：外键字段所在的模型类名小写_set。跟models中反向查询规则一样。
prefetch_related()也可以通过外键字段预查询，但是会产生两条sql，select_related()只会产生一条sql。
再看一个示例：

#查询所有图书和订单信息，并且订单价格大于94
#使用prefetch_related
books = Book.objects.prefetch_related("bookorder_set")
for book in books:
    orders = book.bookorder_set.filter(price__gt=94)
    for order in orders:
        print(order.id)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`', 'time': '0.001'}, {'sql': 'SELECT VERSION()', 'time': '0.000'}, {'sql': 'SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE `book_order`.`book_id` IN (1, 2, 3, 4)
SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE (`book_order`.`book_id` = 1 AND `book_order`.`price` > 94.0e0)
SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE (`book_order`.`book_id` = 2 AND `book_order`.`price` > 94.0e0)
SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE (`book_order`.`book_id` = 3 AND `book_order`.`price` > 94.0e0)
SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE (`book_order`.`book_id` = 4 AND `book_order`.`price` > 94.0e0)

book.bookorder_set.filter(price__gt=94)使得prefetch_related，只能写成book.bookorder_set.all()，修改如下：

prefetch = Prefetch("bookorder_set",queryset=BookOrder.objects.filter(price__gt=94))
books = Book.objects.prefetch_related(prefetch)
for book in books:
    orders = book.bookorder_set.all()
    for order in orders:
        print(order.id,book.name)
print(connection.queries)
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`
   SELECT `book_order`.`id`, `book_order`.`book_id`, `book_order`.`price`, `book_order`.`create_time` FROM `book_order` WHERE (`book_order`.`price` > 94.0e0 AND `book_order`.`book_id` IN (1, 2, 3, 4))

获取关联表字段其实跟普通写法一样，由于select_related()和prefetch_related()能实现预查询，减少了sql查询次数。

defer()

不查询指定字段，返回QuerySet对象，QuerySet对象里面的元素是模型对象。

#不查询查询price和pages字段
books = Book.objects.defer("price","pages")
print(type(books),books)
for book in books:
    print(book.name)
print(connection.queries)
>>><class 'django.db.models.query.QuerySet'> <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>]>
#print(type(books),books)产生的sql
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` LIMIT 21
#for book in books产生的sql
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

如果打印book.price会报错吗

books = Book.objects.defer("price","pages")
for book in books:
    print(book.price)
print(connection.queries)
#for book in books产生的sql
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book
#查询defer()过滤掉的字段，需要根据id重新生成sql查询
>>>SELECT `book`.`id`, `book`.`price` FROM `book` WHERE `book`.`id` = 1
   SELECT `book`.`id`, `book`.`price` FROM `book` WHERE `book`.`id` = 2
   SELECT `book`.`id`, `book`.`price` FROM `book` WHERE `book`.`id` = 3
   SELECT `book`.`id`, `book`.`price` FROM `book` WHERE `book`.`id` = 4

only()

查询指定字段，返回QuerySet对象，QuerySet对象里面的元素是模型对象。
用法和defer()一样，查询不存在的字段会根据id产生sql查询

get_or_create、bulk_create

get_or_create()获取对象，如果不存在创建.
bulk_create()批量创建对象

publisher = Publisher.objects.get_or_create(name="a出版社")
    publisher = Publisher.objects.bulk_create([
        Publisher(name = "b出版社"),
        Publisher(name = "c出版社")
    ])

count()

获取数据个数，比使用python的内置函数len()效率高，对比如下：

#使用len()获取
books = Book.objects.all()
print(len(books))
print(connection.queries[-1])
>>>4
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

#使用count()
counts = Book.objects.count()
print(counts)
print(connection.queries[-1])
>>>4
>>>SELECT COUNT(*) AS `__count` FROM `book`

len()函数是需要把获取到的所有数据放到内存，然后计算个数。
count()在数据库层面就已经计算出个数。

exists()

经常遇到判断满足条件的数据是否存在，比如判断是否有三国演义这边书

#效率比较低
isExists = Book.objects.filter(name="三国演义")
if isExists:
    print("存在")
print(connection.queries[-1])
>>>存在
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` WHERE `book`.`name` = '三国演义'

#和exists()效率一样
isExists = Book.objects.filter(name="三国演义").count()
if isExists:
    print("存在")
print(connection.queries[-1])
>>>存在
>>>SELECT COUNT(*) AS `__count` FROM `book` WHERE `book`.`name` = '三国演义'

#推荐使用exists()
isExists = Book.objects.filter(name="三国演义").exists()
if isExists:
    print("存在")
print(connection.queries[-1])
>>>存在
>>>SELECT (1) AS `a` FROM `book` WHERE `book`.`name` = '三国演义' LIMIT 1

distinct()

去除重复数据

books = Book.objects.filter(bookorder__price__gt=90).distinct()
for book in books:
    print(book.name)
print(connection.queries[-1])
>>>三国演义
   水浒传
>>>SELECT DISTINCT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` INNER JOIN `book_order` ON (`book`.`id` = `book_order`.`book_id`) WHERE `book_order`.`price` > 90.0e0'

从打印的sql可以看出，book表中每个字段如果都相同算重复数据。
但是如果加了order_by()结果会不一样：

books = Book.objects.filter(bookorder__price__gt=90).order_by('bookorder__price').distinct()
for book in books:
    print(book.id,book.name)
print(connection.queries[-1])
>>>1 三国演义
    2 水浒传
    1 三国演义
>>>SELECT DISTINCT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id`, `book_order`.`price` FROM `book` INNER JOIN `book_order` ON (`book`.`id` = `book_order`.`book_id`) WHERE `book_order`.`price` > 90.0e0 ORDER BY `book_order`.`price` ASC

order_by的字段会放到distinct中

QuerySet 切片

使用切片操作，在sql层面使用了offset、limit取需要的数据，避免把所有数据都取出来

#get_queryset()
books = Book.objects.get_queryset()[1:3]
for book in books:
    print(book.id,book.name)
print(connection.queries[-1])
>>>2 水浒传
   3 西游记
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` LIMIT 2 OFFSET 1

Book.objects.get_queryset()[1:3]可以替换成Book.objects.all()[1:3]，因为all()就是调用了get_queryset()

QuerySet操作什么时候会被翻译成sql

对QuerySet的操作并不会立即转换成sql语句，符合以下场景才会立即生成sql

1、打印QuerySet对象

books = Book.objects.all()
print(connection.queries)
print(books)
print(connection.queries)
>>>[]
>>><QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>]>
>>>ELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` LIMIT 21

2、迭代

books = Book.objects.all()
print(connection.queries)
for book in books:
    print(book)
print(connection.queries)
>>>[]
    Book object
    Book object
    Book object
    Book object
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

3、切片操作指定步长

books = Book.objects.all()[1:3]
print(connection.queries)
books = Book.objects.all()[1:3:1]
print(connection.queries)
>>>[]
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book` LIMIT 2 OFFSET 1

4、判断QuerySet对象是否存在

books = Book.objects.all()
print(connection.queries)
if books:
    print("有数据")
print(connection.queries)
>>>[]
>>>有数据
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

5、调用len()函数

books = Book.objects.all()
print(connection.queries)
len(books)
print(connection.queries)
>>>[]
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`

6、调用list()函数

books = Book.objects.all()
print(connection.queries)
list(books)
print(connection.queries)
>>>[]
>>>SELECT `book`.`id`, `book`.`name`, `book`.`remark`, `book`.`pages`, `book`.`price`, `book`.`rating`, `book`.`author_id`, `book`.`publisher_id` FROM `book`