python-django-ORM，常用查询方式

介绍django model 的一些常用查询方式

首先是一些文档性的帮助

__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

　　这里一个Entry关联一个blog和多个Authors

　　对对象的一些操作：

　　

增加：

　　通过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()

　　关于有外键的，可以直接通过参数列表或者赋值后save.

 cheese_blog = Blog.objects.get(name=”Cheddar Talk”)
 entry.blog = cheese_blog
 entry.save()

　　关于有多对多关系的，不能直接更新，需要model实例.多对多关系的成员名.add(model)。

joe = Author.objects.create(name=”Joe”)
entry.authors.add(joe)

查找：

　　检索所有对象：

　　

 all_entries = Entry.objects.all()

　　

　　检索特定的对象
　　　　使用以下两个方法：
　　　　fileter(**kwargs)
　　　　返回一个与参数匹配的QuerySet,相当于等于(=).
　　　　exclude(**kwargs)
　　　　返回一个与参数不匹配的QuerySet,相当于不等于(!=)。

　　QuerySet方法

　　　　

 # 这是查找前5个entry表里的数据
 Entry.objects.all()[:5]
 # 这是查找从第5个到第10个之间的数据。
 Entry.objects.all()[5:10]
 # 这是查询从第0个开始到第10个，步长为2的数据。
 Entry.objects.all()[:10:2]
 # 模糊查询
 Entry.objects.get(headline__contains=’Lennon’)  

　　接下来是一些ORM提供的比较酷的方法：

　　

 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.filter(pk__in=[1,4,7])
  # id in 1,4,7
  Blog.objects.filter(pk__gt=14)
  # id = 14

　　Q对象的复杂查询　

 Q(question__startswith=’Who’) | Q(question__startswith=’What’)

 Poll.objects.get(Q(question__startswith=’Who’),
         Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
         )

删除:

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

反向查询:

　　先展示一个model

　　

 from django.db import models

 class Publisher(models.Model):

     name = models.CharField(max_length=30)
     address = models.CharField(max_length=50)
     city = models.CharField(max_length=60)
     state_province = models.CharField(max_length=30)
     country = models.CharField(max_length=50)
     website = models.URLField()

     def __unicode__(self):
         return self.name

 class Author(models.Model):

     first_name = models.CharField(max_length=30)
     last_name = models.CharField(max_length=40)
     email = models.EmailField()

     def __unicode__(self):
         return u'%s %s' % (self.first_name, self.last_name)
 class Book(models.Model):

     title = models.CharField(max_length=100)
     authors = models.ManyToManyField(Author)
     publisher = models.ForeignKey(Publisher)
     publication_date = models.DateField()

     def __unicode__(self):
     return self.title

　　一个作者一本书和一个出版社，一本书可以被多个作者撰写，但是只属于一个出版社

　　反向查询方法：

　　

p = Publisher.objects.get(name='Apress Publishing')
p.book_set.filter(name__icontains='django')
# 属性名称book_set是由模型名称的小写 ( 如 book) 加_set组成的。
# 通过出版社，得到与它有外键关联的书籍名称叫django的书

　　访问多对多：

1 b = Book.objects.get(id=50)
 b.authors.all()