django orm查询方法详解

目录

1.1.1 生成查询

1.1.2 创建对象

1.1.3 保存修改的对象

1.1.4 保存 ForeignKey 和 ManyToManyField 字段

1.1.5 检索对象

1.1.6 检索所有的对象

1.1.7 过滤检索特定对象

1.1.8 链接过滤

1.1.9 过滤结果集是唯一

1.2.1 结果集是延迟的

1.2.2 其他的QuerySet方法

1.2.3 限制 QuerySets

1.2.4 字段查找

1.2.5 跨关系查询

1.2.6 过滤器可参考模型字段

1.2.7 缓存查询集

1.2.8 比较对象

1.2.9 删除对象

1.3.1 一次修改多个对象

1.3.2 关系对象

1.3.3 One-to-many关系

1.3.4 Many-to-many关系

1.3.5 One-to-one关系

1.1.1 生成查询 你创建完数据模型，django会自动提供给你数据库抽象的API，可以创建、获取、修改、删除对象，本篇文档讲解如何使用API。 我们参考下面模型，一个weblog：

#博客
class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def __unicode__(self):
        return self.name
#作者
class Author(models.Model):
    name = models.CharField(max_length=50)
    email = models.EmailField()

    def __unicode__(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.DateTimeField()
    authors = models.ManyToManyField(Author)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __unicode__(self):
        return self.headline

1.1.2 创建对象

用python对象描述数据库表的数据,django使用一个直观的系统，一个模型类描述一个数据表，一个类的实例描述表的一条详细记录。使用模型的save()方法将对象创建到数据库。

from mysite.blog.models import Blog

b = Blog(name=‘Beatles Blog‘, tagline=‘All the latest Beatles news.‘)
b.save()

只有执行save方法时，django才会执行sql把对象写入数据库。

1.1.3 保存修改的对象

保存修改仍然使用save()方法

b5.name = ‘New name‘
b5.save()

1.1.4 保存 ForeignKey 和 ManyToManyField 字段

cheese_blog = Blog.objects.get(name="Cheddar Talk")
entry.blog = cheese_blog #为 ManyToManyField 增加记录
entry.save()
joe = Author.objects.create(name="Joe")
entry.authors.add(joe) #为 ForeignKey 增加记录

1.1.5 检索对象 从数据库里检索对象，可以通过模型的Manage来建立QuerySet,一个QuerySet表现为一个数据库中对象的结合，他可以有0个一个或多个过滤条件，在SQL里QuerySet相当于select语句用where或limit过滤。你通过模型的Manage来获取QuerySet，每个模型至少有一个Manage

1.1.6 检索所有的对象

检索表中所有数据，最简单的方式是用all().

all_entries = Entry.objects.all()

1.1.7 过滤检索特定对象

检索过滤特定查询结果，有两个方法。 filter(**kwargs)   返回一个新的匹配查询参数后的QuerySet exclude(**kwargs) 返回一个新的不匹配查询参数后的QuerySet

Entry.objects.filter(pub_date__year=2006)

1.1.8 链接过滤

Entry.objects.filter(headline__startswith=‘What‘)
         .exclude(pub_date__gte=datetime.now())
         .filter(pub_date__gte=datetime(2005, 1, 1))

1.1.9 过滤结果集是唯一

每次你完成一个QuerySet，你获得一个全新的结果集，不包括前面的。每次完成的结果集是可以贮存，使用或复用
q1 = Entry.objects.filter(headline__startswith="What")
q2 = q1.exclude(pub_date__gte=datetime.now())
q3 = q1.filter(pub_date__gte=datetime.now())

三个QuerySets是分开的，第一个是headline以"What"单词开头的结果集，第二个是第一个的子集，即pub_date不大于现在的，第三个是第一个的子集 ，pub_date大于现在的

1.2.1 结果集是延迟的

QuerySets是延迟的，创建QuerySets不会触及到数据库操作，你可以多个过滤合并到一起，直到求值的时候django才会开始查询。如：

q = Entry.objects.filter(headline__startswith="What")
q = q.filter(pub_date__lte=datetime.now())
q = q.exclude(body_text__icontains="food")
print q

虽然看起来执行了三个过滤条件，实际上最后执行print q的时候，django才开始查询执行SQL到数据库。

1.2.2 其他的QuerySet方法 大多数情况你使用all()、filter()和exclude()

1.2.3 限制 QuerySets

使用python的数组限制语法限定QuerySet，如： 取前5个

Entry.objects.all()[:5]

取第五个到第十个

Entry.objects.all()[5:10]

一般的，限制QuerySet返回新的QuerySet，不会立即求值查询，除非你使用了"step"参数

Entry.objects.all()[:10:2]
Entry.objects.order_by(‘headline‘)[0]
Entry.objects.order_by(‘headline‘)[0:1].get()

1.2.4 字段查找

字段查找是指定SQL语句的WHERE条件从句，通过QuerySet的方法filter(), exclude()和get()指定查询关键字。 基本查询field__lookuptype=value 例如：

Entry.objects.filter(pub_date__lte=‘2006-01-01‘)

转换为SQL：

SELECT * FROM blog_entry WHERE pub_date <= ‘2006-01-01‘;

如果你传了无效的参数会抛异常

数据库API 支持一些查询类型，下面体验一下： a、exact

Entry.objects.get(headline__exact="Man bites dog")

等价于

SELECT ... WHERE headline = ‘Man bites dog‘;

如果查询没有提供双下划线，那么会默认 __exact=

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

b、iexact——忽略大小写

Blog.objects.get(name__iexact="beatles blog")

blog title会匹配 "Beatles Blog", "beatles blog", 甚至 "BeAtlES blOG".

c、contains——包含查询，区分大小写

Entry.objects.get(headline__contains=‘Lennon‘)

转化为SQL

SELECT ... WHERE headline LIKE ‘%Lennon%‘;

icontains 不区分大小写

startswith，endswith，istartswith，iendswith 前模糊匹配，后模糊匹配

1.2.5 跨关系查询

Entry.objects.filter(blog__name__exact=‘Beatles Blog‘)

这个可以跨越你想要的深度。

反向跨关系查询

Blog.objects.filter(entry__headline__contains=‘Lennon‘)

如果跨越多层关系查询，中间模型没有值，django会作为空对待不会发生异常。

Blog.objects.filter(entry__author__name=‘Lennon‘);
Blog.objects.filter(entry__author__name__isnull=True);
Blog.objects.filter(
entry__author__isnull=False,
entry__author__name__isnull=True);

1.2.6 过滤器可参考模型字段

目前给的例子里，我们建立了过滤，比照模型字段值和一个固定的值，但是如果我们想比较同一个模型里的一个指端和另一个字段的值，django提供F()——专门取对象中某列值的操作

from django.db.models import F
Entry.objects.filter(n_pingbacks__lt=F(‘n_comments‘))

注：n_pingbacks、n_comments为模型Entry属性

django支持加减乘除和模计算

Entry.objects.filter(n_pingbacks__lt=F(‘n_comments‘) * 2)
Entry.objects.filter(rating__lt=F(‘n_comments‘) + F(‘n_pingbacks‘))
Entry.objects.filter(author__name=F(‘blog__name‘))

主键查询捷径

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

不仅限于__exact 查询

# Get blogs entries with id 1, 4 and 7
Blog.objects.filter(pk__in=[1,4,7])

# Get all blog entries with id > 14
Blog.objects.filter(pk__gt=14)

跨越查询

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

like语句转义百分号

Entry.objects.filter(headline__contains=‘%‘)

转义为

SELECT ... WHERE headline LIKE ‘%\%%‘;

1.2.7 缓存查询集

每个QuerySet都包含一个缓存，以尽量减少对数据库的访问。理解他的工作原理很重要，可以写出最高效的代码。 在最新创建的QuerySet里，缓存是空的。在第一次QuerySet被取值，因此数据库查询发生，django把查询结果放入缓存，并返回给请求，随后的查询取值会复用缓存中的结果。 保持缓存的思想习惯，因为如果你不正确使用查询缓存会有麻烦。例如下面例子会创建两个QuerySet

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

这样意味着数据库查询会执行两次，实际两次数据库加载

为了避免这个问题，简单保存QuerySet复用

queryset = Poll.objects.all()
print [p.headline for p in queryset] # Evaluate the query set.
print [p.pub_date for p in queryset] # Re-use the cache from the evaluation.

1.2.8 比较对象

比较两个模型实例，使用python标准的运算符，两个等号==

some_entry == other_entry
some_entry.id == other_entry.id
some_obj == other_obj
some_obj.name == other_obj.name

1.2.9 删除对象

删除方法是很方便的，方法名为delete()，这个方法直接删除对象没有返回值

e.delete()

你也可以批量删除对象，每个QuerySet有一个delete()方法，能删除 QuerySet里所有对象

1.3.1 一次修改多个对象

有时候你想给QuerySet里所有对象的一个字段赋予特定值，你可以使用 update()方法 例如:

# Update all the headlines with pub_date in 2007.
Entry.objects.filter(pub_date__year=2007).update(headline=‘Everything is the same‘)

这个方法只能用于无关联字段和外键

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

update()方法不返回任何值，QuerySet不支持save方法，如果要执行save，可以如下：

for item in my_queryset:
item.save()

update也可以使用F()

# THIS WILL RAISE A FieldError
Entry.objects.update(headline=F(‘blog__name‘))

1.3.2 关系对象

当你在model里定义一个关系时，模型实例会有一个方便的API来访问关系对象。用本页上面的模型举个例子，一个Entry 对象可以得到blog对象，访问blog属性e.blog。 django也创建API来访问关系对象的另一边，一个blog对象访问Entry列表b.entry_set.all().

1.3.3 One-to-many关系

如果一个对象有ForeignKey，这个模型实例访问关系对象通过简单的属性

e = Entry.objects.get(id=2)
e.blog # Returns the related Blog object.

你可以凭借外键属性获取和赋值，修改外键值知道执行save()方法才会保存到数据库

e = Entry.objects.get(id=2)
e.blog = some_blog
e.save()

如果ForeignKey 设置了null=True 你可以赋值为None

e = Entry.objects.get(id=2)
print e.blog # Hits the database to retrieve the associated Blog.
print e.blog # 不会在向数据库取; 使用缓存中的值.

e = Entry.objects.select_related().get(id=2)
print e.blog # 不会在向数据库取; 使用缓存中的值.
print e.blog # 不会在向数据库取; 使用缓存中的值.

b = Blog.objects.get(id=1)
b.entry_set.all() # 返回所有blog的关联对象.

# b.entry_set is a Manager that returns QuerySets.
b.entry_set.filter(headline__contains=‘Lennon‘)
b.entry_set.count()

b = Blog.objects.get(id=1)
b.entries.all() # 返回所有blog的关联对象

# b.entries is a Manager that returns QuerySets.
b.entries.filter(headline__contains=‘Lennon‘)
b.entries.count()

add(obj1, obj2, ...) 增加多个关系对象 create(**kwargs) 建立新对象 remove(obj1, obj2, ...) 去除多个关系对象 clear() 清理所有关系对象

b = Blog.objects.get(id=1)
b.entry_set = [e1, e2]

1.3.4 Many-to-many关系

e = Entry.objects.get(id=3)
e.authors.all() # 返回Entry所有authors .
e.authors.count()
e.authors.filter(name__contains=‘John‘)

a = Author.objects.get(id=5)
a.entry_set.all() # 返回Author所有entry .

1.3.5 One-to-one关系

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

ed = EntryDetail.objects.get(id=2)
ed.entry # 返回 Entry 对象.
时间： 2024-10-27 17:11:18

django orm查询方法详解的相关文章

065：ORM查询条件详解-gt、gte、lt和lte

ORM查询条件详解-gt.gte.lt和lte: 1.gt:某个 field 的值要大于给定的值.示例代码如下: articles = Article.objects.filter(id__gt=3) 以上代码的意思是将所有 id 大于4的文章全部都找出来.将翻译成以下 SQL 语句: SELECT `article`.`id`, `article`.`title`, `article`.`content`, `article`.`category_id` FROM `article` WHER

Python - Django - ORM 查询方法

models.py: from django.db import models class Human(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=32) age = models.IntegerField() birthday = models.DateField(auto_now_add=True) 在数据库中添加几条数据 在 Python 脚本中调用 Dj

062：ORM查询条件详解-exact和iexact

查询操作: 查找是数据库操作中一个非常重要的技术.查询一般就是使用filter.exclude以及get三个方法来实现.我们可以在调用这些方法的时候传递不同的参数来实现查询需求.在 ORM 层面,这些查询条件都是使用 field + __ + condition 的方式来使用的.以下将那些常用的查询条件来一一解释. 查询条件exact和iexact: exact: 使用精确的 = 进行查找.如果提供的是一个 None ,那么在 SQL 层面就是被解释为 NULL .示例代码如下: article

数据库 查询方法详解 以学生老师信息表为例

create table Student--3rd再次执行 ( Sno int primary key not null,--学号主键 Sname varchar(50) not null,--学生姓名 Ssex varchar(50) not null,--学生性别 Sbirthday datetime,--出生年月 Class int--班级 ) truncate table Student--清空表格 insert into Student values(108,'曾华','男','197

Arrays 类的 binarySearch() 数组查询方法详解

Arrays类的binarySearch()方法,可以使用二分搜索法来搜索指定的数组,以获得指定对象.该方法返回要搜索元素的索引值.binarySearch()方法提供多种重载形式,用于满足各种类型数组的查找需要. 注意:使用 binarySearch() 方法前,必须先用 Arrays.sort() 方法排序,否则结果可能是非预期值 1)  binarySearch(Object[], Object key) a: 要搜索的数组 key:要搜索的值 如果key在数组中,则返回搜索值的索引:否则

060~061：ORM查询条件详解-准备工作（pycharm连接数据库）

准备工作,啥也不说了,直接上图说明: 1.每次创建APP和迁移数据库都要打开cmd窗口,有点麻烦:如下界面窗口可以直接使用: 2.pycharm连接MySQL数据库(其中遇到驱动问题:百度一下): 备注:直接打开数据库的表,如果要保存,使用如下按键:crtl + enter 原文地址:https://www.cnblogs.com/zheng-weimin/p/10228992.html

070：【Django数据库】ORM聚合函数详解-准备工作

ORM聚合函数详解-准备工作: 如果你用原生SQL,则可以使用聚合函数来提取数据.比如提取某个商品销售的数量,那么可以使用count,如果想要知道商品销售的平均价格,那么可以使用avg.聚合函数是通过aggregate方法来实现的.在讲解这些聚合函数的用法的时候,都是基于以下的模型对象来实现的. 创建如下models: from django.db import models class Author(models.Model): """作者模型""&qu

075： 【Django数据库】ORM聚合函数详解-Sum

ORM聚合函数详解-Sum: Sum :求指定对象的总和.比如要求图书的销售总额.那么可以使用以下代码实现: from djang.db.models import Sum result = Book.objects.annotate(total=Sum("bookstore__price")).values("name","total") 以上的代码 annotate 的意思是给 Book 表在查询的时候添加一个字段叫做 total ,这个字段

071：【Django数据库】ORM聚合函数详解-Avg

ORM聚合函数详解-Avg: Avg:求平均值.比如想要获取所有图书的价格平均值.那么可以使用以下代码实现: from django.db.models import Avg result = Book.objects.aggregate(Avg('price')) print(result) 以上的打印结果是: {"price__avg":23.0} 其中price__avg的结构是根据field__avg规则构成的.如果想要修改默认的名字,那么可以将Avg赋值给一个关键字参数.示例