python web开发——Django执行查询

执行查询

一旦你建立好数据模型，Django 会自动为你生成一套数据库抽象的API，可以让你创建、检索、更新和删除对象.

在整个文档（以及参考）中，我们将引用下面的模型，它构成一个博客应用：

#-*- coding:utf-8-*-
from django.db import models
class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def __str__(self):
        return self.name(self)  #__unicode__ on Pythjon 2
class Auther(models.Model):
    blog = models.ForeignKey(Blog)
    headline = models.CharField(max_length=50)
    email = models.EmailField()

    def __str__(self):
        return self.name
class Entry(models.Model):
    blog = models.ForeignKey(Blog)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Auther)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):
        return self.headline

创建对象

使用save()方法

>>> from blog.models import Blog
>>> b = Blog(name='Beatles Blog',tagline='All the latest Beatles news.')
>>> b.save()

获取对象

你可以从模型的管理器那里取得查询集。每个模型都至少有一个管理器，它默认命名为objects。通过模型类来直接访问它，像这样：

>>> Blog.objects
<django.db.models.manager.Manager object at ...>
>>> b = Blog(name='Foo',tagline='Bar')
>>> b.objects
Traceback:
    ...
AttributeError:"Manager isn`t accessible via Blog instances."

all()

方法返回了一个包含数据库表中所有记录查询集。

filter(kwargs)**

返回一个新的查询集，它包含满足查询参数的对象。

exclude(kwargs)**

返回一个新的查询集，它包含不满足查询参数的对象。

>>> all_entries = Entry.objects.all()
>>> Entry.objects.filter(pub_date__year=2018)

>>> Entry.objects.filter(
...     headline__startswith='What'
... ).exculde(
...     pub_date_gte=datetime.date.today()
... ).filter(
...     pub_date__gte=datetime(2018,1,2)
... )

通过get 获取一个单一的对象

>>> one_entry = Entry.objects.get(pk = 1)

限制查询集

>>> Entry.objects.all()[:5]
>>> Entry.objects.all()[5:10]
>>> Entry.objects.order_by('headline')[0]

字段查询

Entry.objects.filter(pub_date__lte='2018-01-01')
Entry.objects.filter(blog_id=4)

exact

>>> Entry.objects.get(headline__exact="Man bites dog")
SELECT ... WHERE deadline = 'Man bites dog';

大小写不敏感的匹配。所以，查询：

>>> Entry.objects.get(headline__iexact="beatles blog")
#将匹配标题为"Beatles Blog"、"beatles blog"甚至"BeAtlEs blOG"的Blog.

大小写敏感的包含关系测试。例如：

>>> Entry.objects.get(headline__contains="Lennon")
大体可以翻译成下面的SQL:
SELECT ... WHERE headline LIKE '%Lennon%';

注意，这将匹配’Today Lennon honored’ 但不能匹配’today lennon honored’。

还有一个大小写不敏感的版本，icontains。

startswith, endswith

分别表示以XXX开头和以XXX结尾。当然还有大小写不敏感的版本，叫做istartswith 和 iendswith。
大小写不敏感的匹配。所以，查询：

>>> Blog.objects.get(name__iexact="beatles blog")
将匹配标题为"Beatles Blog"、"beatles blog" 甚至"BeAtlES blOG" 的Blog。

大小写敏感的包含关系测试。例如：

Entry,objects.get(headline__cantians='Lennon')
大体可以翻译成下面的SQL:
SELECT ... WHERE headline LIKE '%Lennon%';

注意，这将匹配’Today Lennon honored’ 但不能匹配’today lennon honored’。

还有一个大小写不敏感的版本，icontains。

startswith, endswith

分别表示以XXX开头和以XXX结尾。当然还有大小写不敏感的版本，叫做istartswith 和 iendswith。

查询的快捷方式pk

为了方便，Django 提供一个查询快捷方式pk ，它表示“primary key” 的意思。

在Blog 模型示例中，主键是id 字段，所以下面三条语句是等同的：

>>> Blog.objects.get(id__exact=14) #Explicit form
>>> Blog.objects.get(id=14)#__exact is implied
>>> Blog.objects.get(pk=14)#pk implies id__exact

pk 的使用不仅限于__exact 查询 —— 任何查询类型都可以与pk 结合来完成一个模型上对主键的查询：

#Get blog entries with id 1,4,and 7
>>> Blog.obkects.filter(pk__in=[1,4,7])
#Get blog entries with id>14
>>> Blog.obkects.filter(pk__gt=14)

pk查询在join 中也可以工作。例如，下面三个语句是等同的：

>>> Entry,objects.filter(blog__id__exact=3)#Explicit form
>>> Entry,objects.filter(blog__id=3)#__exact is implied
>>> Entry,objects.filter(blog__pk=3)#__pk implies id__exact

使用Q 对象进行复杂的查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

Q 对象 (django.db.models.Q) 对象用于封装一组关键字参数。这些关键字参数就是上文“字段查询” 中所提及的那些。

例如，下面的Q 对象封装一个LIKE 查询：

from django.db.models import Q
Q(question__startswith='What')

Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

例如，下面的语句产生一个Q 对象，表示两个”question__startswith” 查询的“OR” ：

Q(question__startswith='Who')|Q(question__startswith='What')
它等同于下面的SQL WHERE 子句：
WHERE question LIKE 'Who%' OR question LIKE 'What%'

你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：

Q(question__startswith='Who')|~Q(pub_date__year=2018)

每个接受关键字参数的查询函数（例如filter()、exclude()、get()）都可以传递一个或多个Q 对象作为位置（不带名的）参数。如果一个查询函数有多个Q 对象参数，这些参数的逻辑关系为“AND”。例如：

Poll.objects.get(
    Q(question__startswith='Who'),
    Q(pub_date=date(2018,1,1))|Q(pub_date=date(2018,1,5))
)
...大体上可以翻译成这个SQL:
SELECT * from polls WHERE question LIKE 'Who%'
    AND (pub_date = '2018-01-01' OR pub_date = '2018-01-05')

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将”AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：

Poll.objects.get(
    Q(pub_date=date(2018,1,1))|Q(pub_date=date(2018,1,5))，
    question__startswith='Who'
)
...是一个合法的查询，等同于前面的例子，但是：
#INVALID QUERY
Poll.objects.get(
    question__startswith='Who',
    Q(pub_date=date(2018,1,1))|Q(pub_date=date(2018,1,5))
)
... 是不合法的。

比较对象

为了比较两个模型实例，只需要使用标准的Python 比较操作符，即双等于符号：==。在后台，它会比较两个模型主键的值。

利用上面的Entry 示例，下面两个语句是等同的：

>>> some_entry == other_entry
>>> some_entry.id == other_entry.id

如果模型的主键不叫id，也没有问题。比较将始终使用主键，无论它叫什么。例如，如果模型的主键字段叫做name，下面的两条语句是等同的：

>>> some_obj == other_obj
>>> some_obj.name == other_obj.name

删除对象

删除方法，为了方便，就取名为delete()。这个方法将立即删除对象且没有返回值。例如：

e.delete()

你还可以批量删除对象。每个查询集 都有一个delete() 方法，它将删除该查询集中的所有成员。

例如，下面的语句删除pub_date 为2005 的所有Entry 对象：

Entry.objects.filter(pub_date__year=2005).delete()

更新对象

>>> b = Blog.objects.get(pk=1)
#Change every Entry so that it belongs to this Blog.
>>> Entry.objects.all().update(blog=b)