参考官方文档：
https://docs.djangoproject.com/en/dev/ref/models/querysets/
__exact 精确等于 like ‘aaa’
__iexact 精确等于 忽略大小写 ilike ‘aaa’
__contains 包含 like ‘%aaa%’
__icontains 包含 忽略大小写 ilike ‘%aaa%’，但是对于sqlite来说，contains的作用效果等同于icontains。
__gt 大于
__gte 大于等于
__lt 小于
__lte 小于等于
__in 存在于一个list范围内
__startswith 以…开头
__istartswith 以…开头 忽略大小写
__endswith 以…结尾
__iendswith 以…结尾，忽略大小写
__range 在…范围内
__year 日期字段的年份
__month 日期字段的月份
__day 日期字段的日
__isnull=True/False
__isnull=True 与 __exact=None的区别
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)
def __unicode__(self):
return self.headline
这是model，有blog，author，以及entry；其中entry分别与blog与author表关 联，entry与blog表是通过 外键(models.ForeignKey())相连，属于一对多的关系，即一个entry对应多个blog，entry与author是多对多的关系， 通过modles.ManyToManyField()实现。
一、插入数据库，用save()方法实现，如下：
>>> from mysite.blog.models import Blog
>>> b = Blog(name=’Beatles Blog’, tagline=’All the latest Beatles news.’)
>>> b.save()
二、更新数据库，也用save()方法实现，如下：
>> b5.name = ‘New name’
>> b5.save()
保存外键和多对多关系的字段，如下例子：
更新外键字段和普通的字段一样，只要指定一个对象的正确类型。
>>> cheese_blog = Blog.objects.get(name=”Cheddar Talk”)
>>> entry.blog = cheese_blog
>>> entry.save()
更新多对多字段时又一点不太一样，使用add()方法添加相关联的字段的值。
>> joe = Author.objects.create(name=”Joe”)
>> entry.authors.add(joe)
三、检索对象
>>> Blog.objects
>>> b = Blog(name=’Foo’, tagline=’Bar’)
>>> b.objects
Traceback:
…
AttributeError: “Manager isn’t accessible via Blog instances.”
1、检索所有的对象
>>> all_entries = Entry.objects.all()
使用all()方法返回数据库中的所有对象。
2、检索特定的对象
使用以下两个方法：
fileter(**kwargs)
返回一个与参数匹配的QuerySet,相当于等于(=).
exclude(**kwargs)
返回一个与参数不匹配的QuerySet,相当于不等于(!=)。
Entry.objects.filter(pub_date__year=2006)
不使用Entry.objects.all().filter(pub_date__year=2006),虽然也能运行，all()最好再获取所有的对象时使用。
上面的例子等同于的sql语句：
slect * from entry where pub_date_year=’2006′
链接过滤器：
>>> Entry.objects.filter(
… headline__startswith=’What’
… ).exclude(
… pub_date__gte=datetime.now()
… ).filter(
… pub_date__gte=datetime(2005, 1, 1)
… )
最后返回的QuerySet是headline like ‘What%’ and put_date2005-01-01
另外一种方法：
>> q1 = Entry.objects.filter(headline__startswith=”What”)
>> q2 = q1.exclude(pub_date__gte=datetime.now())
>> q3 = q1.filter(pub_date__gte=datetime.now())
这种方法的好处是可以对q1进行重用。
QuerySet是延迟加载
只在使用的时候才会去访问数据库，如下：
>>> 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时才会访问数据库。
其他的QuerySet方法
>>> Entry.objects.all()[:5]
这是查找前5个entry表里的数据
>>> Entry.objects.all()[5:10]
这是查找从第5个到第10个之间的数据。
>>> Entry.objects.all()[:10:2]
这是查询从第0个开始到第10个，步长为2的数据。
>>> Entry.objects.order_by(‘headline’)[0]
这是取按headline字段排序后的第一个对象。
>>> Entry.objects.order_by(‘headline’)[0:1].get()
这和上面的等同的。
>>> Entry.objects.filter(pub_date__lte=’2006-01-01′)
等同于SELECT * FROM blog_entry WHERE pub_date <= ’2006-01-01′; >>> Entry.objects.get(headline__exact=”Man bites dog”)
等同于SELECT … WHERE headline = ‘Man bites dog’;
>>> Blog.objects.get(id__exact=14) # Explicit form
>>> Blog.objects.get(id=14) # __exact is implied
这两种方式是等同的，都是查找id=14的对象。
>>> Blog.objects.get(name__iexact=”beatles blog”)
查找name=”beatles blog”的对象，不去饭大小写。
Entry.objects.get(headline__contains=’Lennon’)
等同于SELECT … WHERE headline LIKE ‘%Lennon%’;
startswith 等同于sql语句中的 name like ‘Lennon%’,
endswith等同于sql语句中的 name like ‘%Lennon’.
>>> Entry.objects.filter(blog__name__exact=’Beatles Blog’)
查找entry表中外键关系blog_name=’Beatles Blog’的Entry对象。
>>> Blog.objects.filter(entry__headline__contains=’Lennon’)
查找blog表中外键关系entry表中的headline字段中包含Lennon的blog数据。
Blog.objects.filter(entry__author__name=’Lennon’)
查找blog表中外键关系entry表中的author字段中包含Lennon的blog数据。
Blog.objects.filter(entry__author__name__isnull=True)
Blog.objects.filter(entry__author__isnull=False,entry__author__name__isnull=True)
查询的是author_name为null的值
Blog.objects.filter(entry__headline__contains=’Lennon’,entry__pub_date__year=2008)
Blog.objects.filter(entry__headline__contains=’Lennon’).filter( entry__pub_date__year=2008)
这两种查询在某些情况下是相同的，某些情况下是不同的。第一种是限制所有的blog数据的，而第二种情况则是第一个filter是
限制blog的，而第二个filter则是限制entry的
>>> 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
等同于select * from where id=14
# Get blogs entries with id 1, 4 and 7
>>> Blog.objects.filter(pk__in=[1,4,7])
等同于select * from where id in{1,4,7}
# Get all blog entries with id > 14
>>> Blog.objects.filter(pk__gt=14)
等同于select * from id>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
这三种情况是相同的
>>> Entry.objects.filter(headline__contains=’%’)
等同于SELECT … WHERE headline LIKE ‘%%%’;
Caching and QuerySets
>>> print [e.headline for e in Entry.objects.all()]
>>> print [e.pub_date for e in Entry.objects.all()]
应改写为：
>> 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.、
这样利用缓存，减少访问数据库的次数。
四、用Q对象实现复杂的查询
Q(question__startswith=’Who’) | Q(question__startswith=’What’)
等同于WHERE question LIKE ‘Who%’ OR question LIKE ‘What%’
Poll.objects.get(
Q(question__startswith=’Who’),
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)
等同于SELECT * from polls WHERE question LIKE ‘Who%’ AND (pub_date = ’2005-05-02′ OR pub_date = ’2005-05-06′)
Poll.objects.get(
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
question__startswith=’Who’)
等同于Poll.objects.get(question__startswith=’Who’, Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
五、比较对象
>>> some_entry == other_entry
>>> some_entry.id == other_entry.id
六、删除
Entry.objects.filter(pub_date__year=2005).delete()
b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()
Entry.objects.all().delete()
删除所有
七、一次更新多个值
# 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)
如果用save()方法，必须一个一个进行保存，需要对其就行遍历，如下：
for item in my_queryset:
item.save()
关联对象
one-to-many
>>> e = Entry.objects.get(id=2)
>>> e.blog # Returns the related Blog object.
>>> e = Entry.objects.get(id=2)
>>> e.blog = some_blog
>>> e.save()
>>> e = Entry.objects.get(id=2)
>>> e.blog = None
>>> e.save() # “UPDATE blog_entry SET blog_id = NULL …;”
>>> e = Entry.objects.get(id=2)
>>> print e.blog # Hits the database to retrieve the associated Blog.
>>> print e.blog # Doesn’t hit the database; uses cached version.
>>> e = Entry.objects.select_related().get(id=2)
>>> print e.blog # Doesn’t hit the database; uses cached version.
>>> print e.blog # Doesn’t hit the database; uses cached version
>>> b = Blog.objects.get(id=1)
>>> b.entry_set.all() # Returns all Entry objects related to 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() # Returns all Entry objects related to Blog.
# b.entries is a Manager that returns QuerySets.
>>> b.entries.filter(headline__contains=’Lennon’)
>>> b.entries.count()
You cannot access a reverse ForeignKey Manager from the class; it must be accessed from an instance:
>>> Blog.entry_set
add(obj1, obj2, …)
Adds the specified model objects to the related object set.
create(**kwargs)
Creates a new object, saves it and puts it in the related object set. Returns the newly created object.
remove(obj1, obj2, …)
Removes the specified model objects from the related object set.
clear()
Removes all objects from the related object set.
many-to-many类型：
e = Entry.objects.get(id=3)
e.authors.all() # Returns all Author objects for this Entry.
e.authors.count()
e.authors.filter(name__contains=’John’)
a = Author.objects.get(id=5)
a.entry_set.all() # Returns all Entry objects for this Author.
one-to-one 类型：
class EntryDetail(models.Model):
entry = models.OneToOneField(Entry)
details = models.TextField()
ed = EntryDetail.objects.get(id=2)
ed.entry # Returns the related Entry object
使用sql语句进行查询：
def my_custom_sql(self):
from django.db import connection
cursor = connection.cursor()
cursor.execute(“SELECT foo FROM bar WHERE baz = %s”, [self.baz])
row = cursor.fetchone()
return row
原文地址：http://www.woodpecker.org.cn/obp/django /django-faq/db-api.html
一旦 数据模型 创建完毕, 自然会有存取数据的需要.本文档介绍了由 models 衍生而来的数据库抽象API,及如何创建,得到及更新对象. 贯穿本参考, 我们都会引用下面的民意测验(Poll)应用程序: class Poll(models.Model): slug = models.SlugField(unique_for_month='pub_date') question = models.CharField(maxlength=255) pub_date = models.DateTimeField() expire_date = models.DateTimeField() def __repr__(self): return self.question class Meta: get_latest_by = 'pub_date' class Choice(models.Model): poll = models.ForeignKey(Poll, edit_inline=models.TABULAR, num_in_admin=10, min_num_in_admin=5) choice = models.CharField(maxlength=255, core=True) votes = models.IntegerField(editable=False, default=0) def __repr__(self): return self.choice 及下面的简单会话: >>> from datetime import datetime >>> p1 = Poll(slug='whatsup', question="What's up?", ... pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 4, 20)) >>> p1.save() >>> p2 = Poll(slug='name', question="What's your name?", ... pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 3, 25)) >>> p2.save() >>> Poll.objects.all() [What's up?, What's your name?] 查询如何运作Django 的数据查询基于构建结果集及对结果集进行取值. 结果集是独立于数据库的符合某个查询条件的一组数据对象的集合.这是一个惰性集合:在对该集合取值之前,无法知道该集合有哪些成员. 要生成一个满足你需求的结果集,首先要得到一个描述给定类型的所有对象的初始结果集.这个初始结果集可以通过一系列函数进行更精细的优化处理.当经过处理后的结果集符合你的要求时, 就可以对它进行取值操作(使用迭代操作,slicing操作,或一系列其它技术), 以得到一个你需要的对象或对象的列表. 获得初始结果集每个 Django model 都有一个与生俱来的管理器对象 objects, 管理器最重要的角色就是作为初始结果的来源. 一个管理器就是一个描述给定类型所有对象的特殊的初始结果集. Poll.objects 就是包含所有 Poll 对象的一个初始结果集. 它唯一特殊之处在于它不能被取值. 要克服此限制, 管理器对象有一个 all() 方法. 该方法生成一个 可以 被取值的初始结果集的拷贝: all_polls = Poll.objects.all() 参阅 Model API 的 Managers 小节以了解管理器的定位及创建细节. 优化定制结果集管理器提供的初始结果集描述了给定类型的所有对象.不过通常你只需要这个对象集合中的一小部分(一个子集). 要生这样一个结果集,你需要对初始结果集进行优化定制处理, 增加一些限制条件直到描述的子集满足你的需要.最常用的两个定制结果集的方法是:
参数格式在下面 “字段查询” 小节有描述. 这两个方法的返回值都是结果集对象,因此结果集可以进行链式处理: Poll.objects.filter( question__startswith="What").exclude( pub_date__gte=datetime.now()).filter( pub_date__gte=datetime(2005,1,1)) …以一个初始结果集作为参数, 然后进行过滤, 再进行排除, 再进行另一个过滤. 这样得到的最终结果就一个问题开头单词是 “What”, 发布日期在 2005年1月1日至今的所有民意测验的集合. 每个结果集都是一个独一无二的对象. 以上操作的每一步都生成了一个新的结果集: q1 = Poll.objects.filter(question__startswith="What") q2 = q1.exclude(pub_date__gte=datetime.now()) q3 = q1.filter(pub_date__gte=datetime.now()) 这三步生成了三个结果集; 一个初始结果集包含所有的以”What”开头的民意测验, 两个初始结果集的子集(一个排除条件,一个过滤条件).对原始结果集的改进过程并没有影响到原始的结果集. 值得注意的是结果集的创建根本没有访问数据库.只有当对结果集取值时才会访问数据库. 字段查询以 field__lookuptype (注意是双下线)形式进行基本的字段查询,举例来说: polls.objects.filter(pub_date__lte=datetime.now()) 该查询翻译成SQL就是: SELECT * FROM polls_polls WHERE pub_date <= NOW(); 实现细节 Python 能够在定义函数时接受任意的 name-value(names和values均可以在运行时通过计算得到)参数. 要了解更多信息,参阅官方 Python 教程中的 关键字参数 . DB API 支持下列查找类型:
如果未提供查找类型, 系统就认为查找类型是 exact . 下面两个语句是等价的: Poll.objects.get(id=14) Poll.objects.get(id__exact=14) 查询允许多个条件参数, 逗号分隔的多个条件参数会被 “AND” 起来使用: polls.objects.filter( pub_date__year=2005, pub_date__month=1, question__startswith="Would", ) …得到2005年1月公布的带有一个”Would”开头的问题的所有民意测验. 为了使用更加方便, 还提供有一个 pk 查找类型, 可以翻译成 (primary_key)__exact. 在这个民意测试的例子里, 下面两个语句是等价的.: polls.get_object(id__exact=3) polls.get_object(pk=3) pk 也可以通过连接进行查询. 在这个民意测试的例子里, 下面两个语句是等价的: choices.objects.filter(poll__id__exact=3) choices.objects.filter(poll__pk=3) 如果传递的关键字参数非法, 将引发 TypeError 异常. OR 查询关键字参数查询的各个条件都是 “AND” 关系. 如果你需要一个复杂的查询(举例来说,你需要一个 OR 语句), 你需要使用 Q 对象. Q 对象是 django.core.meta.Q 的实例, 用来装载一系列关键字参数. 这些关键字参数就象指定给 get() 和 filter() 函数的关键字参数一样. 举例来说: Q(question__startswith='What') Q 对象可以使用 & 和 | 运算符进行组合. 当两个Q对象进行 & 或 | 运算时,会生成一个新的Q对象.举例来说语句: Q(question__startswith='Who') | Q(question__startswith='What') … 生成一个新的 Q 对象表示这两个 “question__startswith” 查询条件的 “OR” 关系. 等同于下面的 SQL WHERE 子句: ... WHERE question LIKE 'Who%' OR question LIKE 'What%' 通过对多个 Q 对象的 & 和 | 运算你能得到任意复杂的查询语句. 也可以使用圆括号分组. 查询函数可以接受一个或多个 Q 对象作为参数.如果提供有多个 Q 对象参数, 它们将被 “AND” 到一起. 举例来说: polls.get_object( Q(question__startswith='Who'), Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6)) ) … 翻译成 SQL 就是这样: SELECT * from polls WHERE question LIKE 'Who%' AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') 如果需要,查询函数可以混合使用 Q 对象参数和关键字参数. 所有提供给查询函数的参数(不管是关键字参数还是Q对象)都被 “AND” 到一起. 如果提供了 Q 对象作为参数,它就必须在其它关键字参数(如果有的话)的前面. 举例来说: polls.get_object( Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6)), question__startswith='Who') … 这是一个合法的查询, 等价于前一个例子,不过: # INVALID QUERY polls.get_object( question__startswith='Who', Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6))) … 这个查询则不符合我们的规则,会引发异常. Q 对象也可以以 complex 关键字参数的形式使用. 举例来说: polls.get_object( complex=Q(question__startswith='Who') & (Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6)) ) ) 参阅 OR 查询示例 以阅读更多实例. 从结果集中取值只有通过取值操作才能得到结果集包含的对象.取值操作可以通过迭代,切片,或其它专门的函数来实现. 一个结果集就是一个可迭代对象.因此,可以通过一个循环来取出它的值: for p in Poll.objects.all(): print p 将使用 Poll 对象的 __repr__() 方法打印出所有的 Poll 对象. 一个结果集也可以被切片, 使用数组符号操作: fifth_poll = Poll.objects.all()[4] all_polls_but_the_first_two = Poll.objects.all()[2:] every_second_poll = Poll.objects.all()[::2] 结果集对象是惰性对象 – 也就是说,他们不是 真正的 包含他们表示对象的集合 (或列表). Python 的协议魔法让结果集看起来是一个可迭代,可切片的对象. 事实上在幕后, Django 使用了缓存技术.. 如果你真的需要一个列表, 你可以强制对一个惰性对象取值: querylist = list(Poll.objects.all()) 不过,最好不要这么做,尤其当一个结果集相当大时. 由于 Django 要创建每一个对象的内存表示,这将占用相当大的内存. 结果集及其缓存行为每个结果集都包含一个 cache. 对一个新创建的结果集来说, 缓存区是空的.当一个结果集第一次被取值, Django 会进行一次数据库查询,并将查询结果放入缓存中, 之后返回用户需要的数据. 后面的取值操作会使用缓存中的数据而不用再次访问数据库. 必须时刻记住:结果集具有缓存行为. 下面两行语句生成了两个临时的结果集,并进行了取值,之后舍弃: print [p for p in Poll.objects.all()] # Evaluate the Query Set print [p for p in Poll.objects.all()] # Evaluate the Query Set again 对一个小型的,低流量的站点来说,这不会造成严重问题.不过,对一个高访问量的站点来说,它双倍增加了数据库服务器的负担.另外,由于在两次操作之间可能有其它的用户增加或删除了投票,因此这两次操作得到结果可能并不相同. 要避免这个问题, 保存这个结果集并在后面重用该结果集: queryset = Poll.objects.all() print [p for p in queryset] # Evaluate the query set print [p for p in queryset] # Re-use the cache from the evaluation |
专门的结果集取值函数下面这些函数也可以用来从一个结果集中取值.不同于迭代及切片操作,这些方法不具有缓存行为.每次使用这些函数,都会访问数据库. get(**kwargs)以下文描述的 “字段查询” 格式返回匹配查找参数的对象.如果没有找到符合给定参数的对象,会引发一个模块级的DoesNotExist 异常. 如果找到不止一个对象,引发 AssertionError 异常. 关系 (连接)当你在 model 中定义了一个关系字段(也就是,一个ForeignKey, OneToOneField, 或 ManyToManyField). Django 使用关系字段的名字为 model 的每个实例添加一个 描述符. 在访问对象或关联对象时, 这个描述符就象一个常规属性. 举例来说, mychoice.poll 会返回 Choice 实例对象关联的 Poll 对象. 通过下面的关系,连接可以以非显式的方式进行: choices.objects.filter(poll__slug="eggs") 得到一个 Choice 对象列表, 这些对象关联的 Poll 对象的 slug 字段值为 eggs. 允许多级连接. 通过一个对象实例的便利函数(convenience functions)就可直接查询该对象的关联对象. 举例来说, 如果 p 是一个Poll 实例, p.choice_set() 将返回所有关联的 Choice 对象列表. 聪明的读者会注意到它等价于choices.objects.filter(poll__id=p.id), 只是更加清晰. 每一种关系类型会为关系中的每个对象自动创建一系列便利方法(类似 choice_set() 这样的方法).这些方法被双向创建, 这样被关联的对象就不需要明确的定义反向关系, 这一切都是自动完成的. One-to-one relationsone-to-one 关系中的每个对象拥有一个 get_relatedobjectname() 方法. 举例来说: class Place(meta.Model): # ... class Restaurant(meta.Model): # ... the_place = meta.OneToOneField(places.Place) 在上面的例子里, 每个 Place 会自动拥有一个 get_restaurant() 方法, 且每个 Restaurant 会自动拥有一个get_the_place() 方法. Many-to-one relations在 many-to-one 关系中, 关联对象(Many)会自动拥有一个 get_relatedobject() 方法. 被关联的对象(one)会自动拥有 get_relatedobject(), get_relatedobject_list(), 和 get_relatedobject_count() 方法 (功能与模块级的get_object(), filter(), 和 get_count() 相同). 在上面的民意测试例子里, 一个 Poll 对象 p 自动拥有下列方法: p.get_choice() p.get_choice_list() p.get_choice_count() Choice 对象 c 则自动拥有下面的方法: c.get_poll() 专门的结果集除 filter 和 exclude() 之外, Django 提供了一系列结果集处理方法, 修改结果的类型, 或修改 sql 查询在数据库执行的方式. order_by(*fields)根据 model 中提供 ordering tuple, 结果集会被自动排序. 不过, 排序也可以通过 order_by 方法显式的进行: Poll.objects.filter(pub_date__year=2005,
pub_date__month=1).order_by('-pub_date', 'question')
结果集将按降序排列 pub_date, 然后按升序排列 question.”-pub_date” 中的负号表示降序(递减).要取随机序,使用”?”, 象下面这样: Poll.objects.order_by=('?')
要按另一个表中的字段排序, 添加另一个表的名字和一个句点,象下面这样: Choice.objects.order_by=('Poll.pub_date', 'choice')
无法指定排序是否大小写敏感, 不管你的数据库后端如何排序, Django都会以大小写敏感的方式重新排序结果集.. (这样是不是会降低效率? 不能关掉这个特性么?) distinct()默认的, 一个结果集不会自动除去重复的行. 尤其当你进行跨关系查询时, 很容易出现重复的行. distinct() 返回一个除去了重复行的新的结果集,它等价于 SELECT DISTINCT SQL 语句. values(*fields)类似 filter(), 不过它返回一个字典的列表而不是 model 实例对象的列表. 它接受一个可选参数: fields, 这是一个字段名列表或tuple.如果你没有指定 fields, 每个字段都会返回.否则就只返回你指定的字段名和值.这里有一个例子,使用上面定义的 Poll model >>> from datetime import datetime
>>> p1 = Poll(slug='whatsup', question="What's up?",
... pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = Poll(slug='name', question="What's your name?",
... pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> Poll.objects.all()
[What's up?, What's your name?]
>>> Poll.objects.values()
[{'id': 1, 'slug': 'whatsup', 'question': "What's up?", 'pub_date': datetime.datetime(2005, 2, 20), 'expire_date': datetime.datetime(2005, 3, 20)},
{'id': 2, 'slug': 'name', 'question': "What's your name?", 'pub_date': datetime.datetime(2005, 3, 20), 'expire_date': datetime.datetime(2005, 4, 20)}]
>>> Poll.objects.values(fields=['id', 'slug'])
[{'id': 1, 'slug': 'whatsup'}, {'id': 2, 'slug': 'name'}]
当你知道你要取得哪些字段的值时并且你不需要那些 model实例对象的功能时,使用 values() 函数.它具有上佳的效率.. dates(field, kind, order=’ASC’)每个管理器拥有一个 dates() 方法, 它返回一个 datetime.datetime 对象的列表, 表示经过给定的过滤器(由 kind 参数定义)过滤后的所有可用的 dates . field 是 model 模块中的一个 DateField 或 DateTimeField 属性名. kind 是 "year", "month" 或 "day" 中的一个. 结果列表中的每个 datetime.datetime 对象被截短为给定的 type 形式.
order 只能是 "ASC" 或 "DESC", 默认值是 'ASC'. 它指定如何排序结果. 这里有一个例子, 使用上面定义的 Poll model >>> from datetime import datetime
>>> p1 = Poll(slug='whatsup', question="What's up?",
... pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = Poll(slug='name', question="What's your name?",
... pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> Poll.objects.dates('pub_date', 'year')
[datetime.datetime(2005, 1, 1)]
>>> Poll.objects.dates('pub_date', 'month')
[datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
>>> Poll.objects.dates('pub_date', 'day')
[datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
>>> Poll.objects.dates('pub_date', 'day', order='DESC')
[datetime.datetime(2005, 3, 20), datetime.datetime(2005, 2, 20)]
>>> Poll.objects.filter(question__contains='name').dates('pub_date', 'day')
[datetime.datetime(2005, 3, 20)]
select_related()关系是数据库的根本, select_related() 方法”追踪” 所有的关系对象, 并将它们预先存放到一个简单的缓存中.这样当需要调用一个具有一对多关系的对象时就不必再次访问数据库.要做到这一点, 只需对一个结果集使用select_related() 方法.这可能导致(某些时候相当)大的(有可能是不必要的)查询, 但这却意味着后续的关系使用会快很多.(俺的建议:对一个频繁变化的多用户数据库,不要使用该参数) 举例来说, 上面的 Poll 和 Choice models 中, 如果你这样做: c = Choice.objects.select_related().get(id=5) 那么后面的 c.poll() 将不用访问数据库. 注意这个 select_related 方法会尽可能远的追踪外键. 如果你有下面的 models: class Poll(models.Model): # ... class Choice(models.Model): # ... poll = models.ForeignKey(Poll) class SingleVote(meta.Model): # ... choice = models.ForeignKey(Choice) 那么调用 SingleVotes.objects.select_related().get(id=4) 会缓存相关的 choice 和 相关的 poll: >>> sv = SingleVotes.objects.select_related().get(id=4) >>> c = sv.choice # Doesn't hit the database. >>> p = c.poll # Doesn't hit the database. >>> sv = SingleVotes.objects.get(id=4) >>> c = sv.choice # Hits the database. >>> p = c.poll # Hits the database. extra(params, select, where, tables)有时候, Django 提供的查询语法不太够用. 为了满足这些边缘需求, Django 提供了 extra() 结果集修改器 – 一种提供额外查询参数的机制. 要注意这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),除非万不得已,尽量避免这样做: selectselect 关键字参数允许你选择特定的字段. 它是一个字典(属性名与 SQL 语句的映射). 举例来说: Poll.objects.extra(
select={
'choice_count': 'SELECT COUNT(*) FROM choices WHERE poll_id = polls.id'
}
)
每个返回的 ``Poll`` 对象会有一个额外的属性: ``choice_count``, 一个关联`` Choice`` 对象的整数. 注意大多数数据库引擎需要用括号将子查询括起来. Django 的 ``select`` 子句则不需要这个括号.
where 和 tables 都接受一个字符串列表作为它们的值.所有的 where 参数都被 “AND” 到其它的查询条件中. 举例来说: Poll.objects.filter( question__startswith='Who').extra(where=['id IN (3, 4, 5, 20)']) ...翻译成 SQL 语句就是:: SELECT * FROM polls_polls WHERE question LIKE 'Who%' AND id IN (3, 4, 5, 20); 改变对象一旦你使用任何上面介绍的方法从数据库中得到一个对象, 改变这个对象就是相当容易的一件事情了.直接操作这些对象的字段,然后调用 save() 方法保存它们: >>> p = Poll.objects.get(id__exact=15) >>> p.slug = "new_slug" >>> p.pub_date = datetime.datetime.now() >>> p.save() 创建对象通过创建一个新的实例并调用 save() 保存之,就可以创建一个新的数据记录(也就是 INSERT): >>> p = Poll(slug="eggs", ... question="How do you like your eggs?", ... pub_date=datetime.datetime.now(), ... expire_date=some_future_date) >>> p.save() 一个主键值为 None 的对象调用 save() 方法表示这是一个新记录,应该被插入到数据表中. 通过便利方法(convenience function)可以很容易的创建关联对象 (比如 Choices): >>> p.choice_set.create(choice="Over easy", votes=0) >>> p.choice_set.create(choice="Scrambled", votes=0) >>> p.choice_set.create(choice="Fertilized", votes=0) >>> p.choice_set.create(choice="Poached", votes=0) >>> p.choice_set.count() 4 这些 add_choice 方法于下面的函数等价(却更简单): >>> c = Choice(poll_id=p.id, choice="Over easy", votes=0) >>> c.save() 注意当使用这种 add_foo()` 方法时, 你不要给 id 字段提供任何值, 也不要给保存关系的字段提供任何值.(此处是poll_id ). 这类 add_FOO() 方法总是返回刚刚创建的对象. 删除对象如同你想象的一样,删除对象的方法是 delete(). 该方法立即删除该对象并返回 None.比如: >>> c.delete() 通过使用同样的查询条件(参数), get_object 和其它查询方法也可以用来批量删除对象. 比如: >>> Polls.objects.filter(pub_date__year=2005).delete() 此举将删除2005年的所有民意测验数据. 注意 delete() 是唯一一个管理器对象不能直接访问的结果集方法. 这提供了一种安全机制,可以避免发生意外事故: 否则 Poll.objects.delete(), 将删除 所有的 投票. 如果你 真的 想删除表中的所有数据,你只能这么做: Polls.objects.all().delete() 此举将从数据库中删除所有的 Poll 实例. 比较对象要比较两个 model 对象, 使用标准的 Python 比较运算符,即双等号: ==. (在幕后进行比较的是两个对象的 主键 的值). 仍然是上面的 Poll 例子, 下面两个语句是等价的: some_poll == other_poll some_poll.id == other_poll.id 如果一个 model 的主键名字不是 ID, 没问题, 比较总是发生在主键之间,不管它叫什么名字. 举例来说, 如果一个 model 的主键字段叫 name, 则下面这两个语句是等价的: some_obj == other_obj some_obj.name == other_obj.name 其它实例方法除了 save(), delete() 和所有的 add_* 及 get_* 关联对象方法之外,一个 model 对象可能还拥有下面的部分或全部方法: get_FOO_display()如果一个字段有 choices 选项集事, 这个对象将有一个 get_FOO_display() 方法.这里 FOO 是该字段的名字. 这个方法返回一个 “human-readable” 的字段值. 举例来说, 下面的model中: GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
)
class Person:
name = models.CharField(maxlength=20)
gender = models.CharField(maxlength=1, choices=GENDER_CHOICES)
…每个 Person 实例会拥有一个 get_gender_display() 的方法. 示例: >>> p = Person(name='John', gender='M') >>> p.save() >>> p.gender 'M' >>> p.get_gender_display() 'Male' get_next_by_FOO(**kwargs) 和 get_previous_by_FOO(**kwargs)不存在 null=True 的每个 DateField 和 DateTimeField 自动拥有 get_next_by_FOO() 和 get_previous_by_FOO() 方法, 此处的 FOO 是字段的名字. 它们分别返回该字段的上一个对象和下一个对象. 如果上一对象或下一对象不存在,则抛出 *DoesNotExist 异常. 这两个方法均接受可选关键字参数, 这些参数应该遵循上文中 “Field 查询” 中提到的格式. 注意如果遇到相同值的对象, 这些方法会使用 ID 字段进行检查. 这保证了没有一条记录会被跳过或重复记数.参阅lookup API sample model_ ,那里有一个完整的例子. get_FOO_filename()对一个 FileField 对象来说, 它自动拥有一个 get_FOO_filename() 方法. 这里 FOO 是字段名,它根据你的 MEDIA_ROOT设置返回一个完整的路径名称. 注意 ImageField 技术上是 FileField 的一个子类, 因此每个有 ImageField 的 model 自动拥有此方法. get_FOO_url()含有 FileField 字段的每个对象自动拥有一个 get_FOO_url() 方法,这里的 FOO 是字段的名字. 该方法根据你的MEDIA_URL 设置返回该文件的完整 URL ,如果 MEDIA_URL 设置为空, 该方法返回一个空的字符串. get_FOO_size()含有 FileField 字段的每个对象自动拥有一个 get_FOO_filename() 方法, 这里的 FOO 是字段的名字. 该方法返回文件的长度(字节数).(在后台, Django 使用 os.path.getsize.) |
转载请注明：爱开源 » Django 数据库操作