Django ORM查询笔记

查找

示例模型

# blog.models
from django.db import models

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)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):
        return self.headline

字段查找Field lookups

字段查找和SQL的WHERE语句一样。你可以使用QuerySet的fiter()，exclude()和get()方法来指定关键字参数。
基本的查找关键字模板：field__lookuptype=value。
比如：
Entry.objects.filter(pub_date__lte="2018-11-18"
和下面的SQL语句一样：
SELECT * FROM blog_entry WHERE pubdate <= "2018-11-18"
在字段查找的指定字段必须是模型的字段名，但有一个例外，在ForeignKey中你可以指定字段名+_id。在这种情况下，值的参数默认是包含foreign模型的主键(默认id为主键，没有额外指定主键）。比如：
Entry.objects.filter(blog_id=4)

跨关系查找Lookups that span relationships

跨关系查找，就是使用字段（带ForeignKey的字段）的相关字段名，用双下划线来分隔，来跨关系查找。
比如查找所有的包含所有Blog对象的名字为"Beatles Blog"的Entry对象：

Entry.objects.filter(blog__name="beatles Blog")
# blog是Entry的一个字段， name是Blog的一个字段，通过blog字段来跨关系查找。

这个也能反向查找。使用模型名字的小写来翻转查找。
一个查询所有包含Entry对象的headline有“Lennon"的Blog对象：
Blog.object.filter(entry__headling__contain="lennon")

跨多关系的查找Spanning multi-valued relationships

每当你基于多对多字段ManytoManyField或者反转一个ForeignKey，你可能会对两种不同的过滤分类感兴趣。在Blog/Entry关系里（Blog和Entry是一种一对多的关系)，我们可能需要找到所有标题用"Lenon"和发布在2018的blog，或者标题用”Lenon"并且发布在2018年的blog（这尼玛有什么不同）

缓存和查询集Caching and QuerySet

每一个QuerySet包含缓存来减少数据库的访问。明白他是怎么运作的能让我们写出更有效的代码。
在最新建的QuerySet里，它的缓存是空的。当一个QuerySet第一次赋值，然后，进行一次数据库查询，Django保存查询的结果在QuerySet里面然后返回显示请求的结果。之后的QuerySet赋值再次使用缓存的结果。
要注意缓存的行为，用的不对的话，它可能会咬你。例如，下面的例子会产生两次QuerySet，对它们赋值，然后把它们扔了。

>>>print([e.headline for e in Entry.objects.all()]
>>>print([e.pubdate for e in Entry.objects.all()]

这意味这相同的数据库查询会执行两次，双倍你数据库的加载。
要避免这个问题，只要保存QuerySet然后再次使用它。

>>>queryset = Entry.objects.all()
>>>print([p.headline for p in queryset]) # 赋值queryset
>>>print([p.pubdate for p in queryset]) # 再次使用赋值的缓存

当QuerySet没有缓存

Querysets并不总是保存结果。当执行queryset的一部分的时候，会检查缓存，但是如果没有迁移(populated），之后的查询返回的结果不会缓存。特别的，这意味着使用切片限制queryset或者使用索引不会迁移缓存。
例如，在一个queryset对象重复的获取一定的索引每次都会查询数据库：

queryset = Entry.objects.all()
print(queryset[5]) # 查询数据库
print(queryset[5]) # 查询数据路

然而，如果整个queryset已经被执行，它会检查缓存：

>>>queryset = Entry.objects.all()
>>>[entry for entry in queryset] # 查询数据库
>>>print(queryset[5]) # 使用缓存
>>>print(queryset[5]) # 使用缓存

这是一些会赋值整个queryset然后迁移到缓存的操作：(弱引用?）

>>>[entry for entry in queryset]
>>>bool(queryset)
>>>entry in queryset
>>>list(queryset)

另外，打印queryset不会迁移缓存，这是因为调用repr()只会返回整个queryset的切片。

相关对象

每当你在模型里定义一种关系(ForeignKey,OneToOneField or ManyToManyField)，那个模型的实例会有一个方便的API去访问相关的对象。
比如，一个Entry对象e可以得到它关联的Blog对象通过访问它的blog属性：e.blog。
Django也为另一边关系的对象创造了API：从相关对象到模型之间的关系连接。例如，一个Blog对象b可以通过entry_set属性访问所有的相关对象Entry：b.entry_set.all().

一对多关系

向前
如果一个模型有ForeignKey，这个模型的实例可以通过简单的属性访问相关的(foreign)j对象。

>>>e = Entry.objects.get(id=2)
>>>e.blog # 返回相关的Blog对象

一对多关系的向前访问在相关对象第一次访问的时候缓存了。之后访问同一个对象实例在缓存中。

>>>e = Entry.objects.get(id=2)
>>>print(e.blog)  # 访问数据库来搜索相关的Blog
>>>pirnt(e.blog)  # 没有访问数据库

注意select_related()Query方法递归地提前迁移所有一对多关系缓存。

>>>e = Entry.objects.select_related().get(id=2)
>>>print(e.blog) # 没有访问数据库， 使用缓存
>>>print(e.blog) #　没有访问数据库，使用缓存

关系向后Following relationships "backward"

如果一个模型有ForeignKey，foreign-key模型的实例可以通过一个Manager来访问第一个模型的所有实例。默认情况下，这个Manager命名为FOO_set，FOO是源模型的小写名字。

>>> b = Blog.objects.get(id=1)
>>>b.entry_set.all() # 返回所有关于Blog的Entry对象
>>>b.entry_set.filter(headline__contains="Lenon")
# b.entry_set是一个返回Queryset的Manager

你可以通过在ForeignKey定义里设置related_name参数重载FOO_name名字。

使用自定义的反向管理Using a custom reverse manager

默认的用来反向关系的RelatedManager是defaultmanager的一个子类。所以你可以给给定的查询指定不同的管理器：(Pythonic)

from django.db import models
class Entry(models.Model):
    objects = models.Manager()  # 默认管理器
    entries = EntryManager()  # 自定义管理器
b = Blog.objects.get(id=1)
b.entry_set(manager="entries").all()

多对多关系Many-to-many relationships

和一对多一样，定义ManyToManyField的模型使用属性名来访问，而翻转模型使用名字小写加_set来访问。

一对一

在一对一关系里面，反转模型也可以通过Manager对象访问，不过Manager代表的是单个对象，而不是对象的集合。

class EntryDetail(models.Model):
    entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
    details = models.TextField()

e = Entry.objects.get(id=2)
e.entrydetail # 返回EntryDetail对象

出处：https://docs.djangoproject.com/en/2.1/topics/db/queries/