Django QuestSet API (官方文档)

2021-07-02 22:04

阅读:697

标签:重复   list()   object   一个   col   布尔   datetime   person   ber   

1、返回新查询集的方法

  (1)filter():滤指定条件的结果

Entry.objects.filter(pub_date__gt=datetime.date(2005, 1, 3), headline=Hello)
SQL语句:
SELECT ...
WHERE (pub_date > ‘2005-1-3‘ AND headline = ‘Hello‘)

  (2)exclude():排除指定条件的结果

Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline=Hello)
SQL语句:
SELECT ...
WHERE NOT (pub_date > ‘2005-1-3‘ AND headline = ‘Hello‘)

  (3)annotate():用提供的查询表达式列表注释QuerySet中的每个对象。表达式可以是一个简单的值,对模型(或任何相关模型)上的字段的引用,

或者是对与QuerySet中的对象相关的对象进行计算的聚合表达式(平均值、和等)。annotate()的每个参数都是一个注释,它将被

添加到返回的QuerySet中的每个对象中。

>>> from django.db.models import Count
>>> q = Blog.objects.annotate(Count(entry))
# The name of the first blog
>>> q[0].name
Blogasaurus
# The number of entries on the first blog
>>> q[0].entry__count
42
# 没有指定关键字参数,列和聚合函数的名字决定别名

>>> q = Blog.objects.annotate(number_of_entries=Count(entry))
# The number of entries on the first blog, using the name provided
>>> q[0].number_of_entries
42
# 指定关键字参数,聚合别名为关键字参数

  (4)order_by():指定字段排序

    默认升序,字段名前加负号降序,?代表随机排序(浪费时间与性能,主要看你用的后端)

Entry.objects.filter(pub_date__year=2005).order_by(-pub_date, headline)
# 先按照pub_date 降序排列,然后headline升序排列

    要按不同模型中的字段排序,使用与查询模型关系相同的语法。也就是说,字段名后面跟着双下划线(__),后面跟着新模型中的字段名,等等。

Entry.objects.order_by(blog__name, headline)

    如果您尝试按与另一个模型相关的字段排序,Django将在相关模型上使用默认的顺序,如果没有元数据,则使用相关模型的主键排序。指定排序。

    例如,由于博客模型没有指定默认的排序

Entry.objects.order_by(blog)

等同于

Entry.objects.order_by(blog__id)

    如果博客模型指定排序 ordering [‘name‘]

Entry.objects.order_by(blog__id)

    如果不希望对查询应用任何排序,甚至不希望对默认排序应用任何排序,那么可以不带参数地调用order_by()。

    可以通过检查QuerySet来判断查询是否有序。有序属性,如果查询集以任何方式被排序,则该属性为True。

    每个order_by()调用将清除以前的任何排序。例如,该查询将按pub_date排序,而不是按标题

Entry.objects.order_by("headline").order_by("-pub_date”)

   (5)reverse():排序后的结果顺序反转(必须是已经排好序的结果集)

    取出最后五个对象  

my_queryset.reverse()[:5]

    与序列的分片[-5:]不一样,分片首先看到的是倒数第五个,reverse首先看到的是最后一个。

    Django不支持这种访问模式(从末尾开始分段),因为在SQL中不可能有效地做到这一点。

  (6)dictinct():返回一个新的QuerySet,它在SQL查询中使用SELECT DISTINCT。这从查询结果中消除了重复的行。

Author.objects.distinct()

  (7)values():返回一个QuerySet,当作为迭代使用时,它返回字典而不是模型实例。这些字典中的每一个都代表一个对象,其键对应于模型对象的属性名。

        位置参数指定需要在select中查询的值。values()方法还接受可选的关键字参数,这些参数传递给annotate():

>>> Blog.objects.filter(name__startswith=Beatles).values()
id: 1, name: Beatles Blog, tagline: All the latest Beatles news.}]>
>>> Blog.objects.values(‘id‘, ‘name‘)
>>> from django.db.models.functions import Lower
>>> Blog.objects.values(lower_name=Lower(‘name‘))

    在values()子句中的其他参数之前应用values()子句中的聚合。如果需要按另一个值进行分组,则将其添加到前面的values()子句中。

>>> from django.db.models import Count
>>> Blog.objects.values(entry__authors, entries=Count(entry))
entry__authors: 1, entries: 20}, {entry__authors: 1, entries: 13}]>
>>> Blog.objects.values(entry__authors).annotate(entries=Count(entry))
entry__authors: 1, entries: 33}]>

    如果有一个名为foo的字段是ForeignKey,那么默认值()调用将返回一个名为foo_id的字典键,因为这是存储实际值的隐藏模型属性的名称(foo属性引用相关模型)。

    当您调用values()并传入字段名时,您可以传入foo或foo_id,您将得到相同的结果(dictionary键将匹配您传入的字段名)。

>>> Entry.objects.values()
blog_id: 1, headline: First Entry, ...}, ...]>

>>> Entry.objects.values(blog)
blog: 1}, ...]>

>>> Entry.objects.values(blog_id)
blog_id: 1}, ...]>

    最后,注意,您可以在values()调用之后调用filter()、order_by()等,这意味着这两个调用是相同的

Blog.objects.values().order_by(id)
Blog.objects.order_by(id).values()

  (8):value_list():返回元组而不是字典,如果只在单个字段中传递,也可以传递平面参数。如果为真,这将意味着返回的结果是单个值,

    而不是一个元组。多与两个字段是不要传递flat参数,一个例子应该可以使区别变得更清楚:

>>> Entry.objects.values_list(id).order_by(id)


>>> Entry.objects.values_list(id, flat=True).order_by(id)

    传递named=True,获得命名元组(Django 2.0新增)

>>> Entry.objects.values_list(id, headline, named=True)
First entry), ...]>

    从查询的结果集中获取指定条件的对象

>>> Entry.objects.values_list(headline, flat=True).get(pk=1)
First entry

   (9)none():创建一个空的查询集,EmptyQuerySet的子集

  (10)all():返回所有结果

  (11)union():两个结果集的并集

        intersection():两个结果集的交集

        difference():两个届国际的差集

  (12)selected_related():预先查询外键关系。查询略复杂,但是使用外键时不需要再次访问数据库

    select_related工作方式是创建SQL连接,并在SELECT语句中包含相关对象的字段。因此,select_related获取相同数据库查询中的相关对象。

    然而,为了避免由于跨“多”关系连接而导致更大的结果集,select_related仅限于单值关系——外键和一对一关系。

# Hits the database.
e = Entry.objects.get(id=5)

# Hits the database again to get the related Blog object.
b = e.blog


# Hits the database.
e = Entry.objects.select_related(blog).get(id=5)

# Doesn‘t hit the database, because e.blog has been prepopulated
# in the previous query.
b = e.blog

  (13)prefetch_releated():返回一个QuerySet,它将在单个批处理中为每个指定查找自动检索相关对象。  

    prefetch_related为每个关系执行单独的查找,并在Python中执行“连接”。这允许它预取多对多和多对一对象,这是不能使用select_related实现的,

    除了select_related支持的外键和一对一关系之外。它还支持GenericRelation和GenericForeignKey的预抓取,但是,它必须被限制为同构的结果集。

    例如,只在查询限制为一个ContentType时才支持GenericForeignKey引用的预抓取对象。具体请查阅Django官网。

  (14)defer():延迟加载

    在一些复杂的数据建模情况下,您的模型可能包含许多字段,其中一些可能包含许多数据(例如文本字段),或者需要昂贵的处理才能将它们转换为Python对象。

    如果在最初获取数据时不知道是否需要这些特定字段的情况下使用queryset的结果,那么可以告诉Django不要从数据库中检索它们。

    这是通过传递字段的名称来完成的,以便不加载以延迟()

Entry.objects.defer("headline", "body")

    如果您想清除延迟字段的集合,请将None作为参数传递给defer()

  (15)only():惟一的()方法或多或少与defer()相反。使用在检索模型时不应该延迟的字段调用它。如果您有一个模型,其中几乎所有字段都需要延迟,

    那么使用only()来指定补充字段集可以得到更简单的代码。无论何时调用only(),它都会替换要立即加载的字段集。因此,连续调用only()只会导致只考虑最后的字段

  (16)raw():获取原始SQL查询,执行它,并返回django.db.models.query。RawQuerySet实例。这个RawQuerySet实例可以像普通的QuerySet一样遍历,以提供对象实例。

2、返回新查询结果集的操作

  (1)AND(&)组合的查询集必须使用两个相同的模型

Model.objects.filter(x=1) & Model.objects.filter(y=2)
Model.objects.filter(x=1, y=2)
from django.db.models import Q
Model.objects.filter(Q(x=1) & Q(y=2))

SELECT ... WHERE x=1 AND y=2

  (2)OR(|)

Model.objects.filter(x=1) | Model.objects.filter(y=2)
from django.db.models import Q
Model.objects.filter(Q(x=1) | Q(y=2))

SELECT ... WHERE x=1 OR y=2

 3、不返回查询集的方法

  (1)get() :返回匹配给定查找参数的对象,查找参数的格式应与字段查找中描述的格式相同。

    返回一个以上对象时引起MUultipleObjectReturned异常

    返回为空时引起ObjectDoesNotExist异常

  (2)create():创建一个对象并保存,等价于实例化一个模型,载调用save方法

  (3)get_or_create(defaults=None,**kwargs):查找或创建,返回一个元组(对象,已创建),其中对象是检索的或已创建的对象,并创建一个布尔值,指定是否创建了新对象。

    传递给get_or_create()的任何关键字参数——除了一个可选的称为默认值的参数——将在get()调用中使用。如果找到一个对象,get_or_create()将返回该对象的一个元组,

    并返回False。如果找到多个对象,get_or_create()会引发返回的multipleobjectsreturn。如果没有找到对象,get_or_create()将实例化并保存一个新对象,返回新对象和True的元组。

obj, created = Person.objects.get_or_create(
    first_name=John,
    last_name=Lennon,
    defaults={birthday: date(1940, 10, 9)},
)

  (4)update_or_create(defaults=None,**kwargs):更新或创建。返回一个元组(对象,已创建),其中对象是已创建或更新的对象,并创建一个布尔值,指定是否创建了新对象

obj, created = Person.objects.update_or_create(
    first_name=John, last_name=Lennon,
    defaults={first_name: Bob},
)

  (5)count():返回一个整数,该整数表示数据库中与QuerySet匹配的对象的数量。

  (6)iterator(chunk_size=2000):放回一个迭代器,对于数据量大的结果集,显著地减少内存消耗。注意,在已经求值的QuerySet上使用iterator()将迫使它再次求值,重复查询。chunk_size参数控制

    从数据库驱动程序检索的批处理的大小。较大的批处理减少了与数据库驱动程序通信的开销,而内存消耗则略有增加。

  (7)latest():根据数据字段返回最新的结果,还可以根据几个字段选择最新的。例如,当两个条目有相同的pub_date时,选择最早的expire_date条目:

    earlist():返回最早的结果

Entry.objects.latest(pub_date, -expire_date)

  (8)first():返回由queryset匹配的第一个对象,如果没有匹配的对象,则返回None。如果QuerySet没有定义任何排序,那么QuerySet将由主键自动排序。

    last():返回最后一个结果。

  (9)aggregate():聚合查询,可以通过使用关键字参数指定聚合函数,您可以控制返回的聚合值的名称。

>>> from django.db.models import Count
>>> q = Blog.objects.aggregate(Count(entry))
{entry__count: 16}

q = Blog.objects.aggregate(number_of_entries=Count(‘entry‘))
{‘number_of_entries‘: 16}

  (10)exists():是否存在。如果QuerySet包含任何结果,返回True;如果不包含结果,返回False。尝试以尽可能简单和最快的方式执行查询,但它执行的查询与

    普通的QuerySet查询几乎相同。

  (11)update(**kwargs):更新对象,对指定的字段执行SQL update查询,并返回匹配的行数(如果某些行已经具有新值,则可能不等于更新的行数)。

    只能更新主表中的列,不能更新外键的表的列

  (12)delete():删除对象,对QuerySet中的所有行执行SQL delete查询,并返回被删除的对象数量和每个对象类型的删除数量字典。

Django QuestSet API (官方文档)

标签:重复   list()   object   一个   col   布尔   datetime   person   ber   

原文地址:https://www.cnblogs.com/SunQi-Tony/p/9911034.html


评论


亲,登录后才可以留言!