执行查询
一旦你建立好数据模型,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)