Django ORM操作数据库常用API

昨天晚上，我们完成了一个简单的实例来对数据库表进行操作。今天，我们要熟悉更多的API，实现更复杂的功能。这一步完成了，我们对小型数据的操作问题也就不大了。

现在，我们还是参考django官方文档，来进行学习

1.构造数据表

把以下内容，拷贝到你的朋友charm中，然后执行migrate命令

class Blog(models.Model):

name = models.CharField(max_length=100)

tagline = models.TextField()

def __str__(self): # __unicode__ on Python 2

return self.name

class Author(models.Model):

name = models.CharField(max_length=200)

email = models.EmailField()

def __str__(self): # __unicode__ on Python 2

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(Author)

n_comments = models.IntegerField()

n_pingbacks = models.IntegerField()

rating = models.IntegerField()

def __str__(self): # __unicode__ on Python 2

return self.headline

2.创建对象

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

b.save()

这样，我们就把数据存进去了

同一个对象，保存之后重新赋值，就会执行修改操作

3.保存 ForeignKey 和 ManyToManyField 字段

现在，我们数据已经保存了，并已经建立了关联

在model中，Entry关联了外键Blog（ForeignKey）

所以在创建Entry的时候，要先获取一个Blog对象，给Entry赋值之后，才执行保存数据库的操作

entry = Entry(headline='test123', body_text='test123', pub_date=datetime.datetime.now(),

mod_date=datetime.datetime.now(), n_comments=123, n_pingbacks=456, rating=789)

cheese_blog = Blog.objects.get(name="Beatles Blog")

entry.blog = cheese_blog

entry.save()

现在处理ManyToManyField 的情况

存进去了，还得能取出来：

data = entry.authors.iterator()

直接访问属性，并把查询集转为可迭代

4.查询对象

all_entries = Entry.objects.all()

5.按条件查询

filter(**kwargs) 返回一个新的匹配查询参数后的QuerySet

exclude(**kwargs) 返回一个新的不匹配查询参数后的QuerySet

Entry.objects.filter(pub_date__year=2006)

q2 = q1.exclude(pub_date__gte=datetime.date.today())

6.链接查询

Entry.objects.filter(headline__startswith='What')

.exclude(pub_date__gte=datetime.now())

.filter(pub_date__gte=datetime(2005, 1, 1))

7.延迟查询

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

q = Entry.objects.filter(headline__startswith="What")

q = q.filter(pub_date__lte=datetime.now())

q = q.exclude(body_text__icontains="food")

8.检索单个对象

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

9.限制查询：分页/排序查询

Entry.objects.all()[:5]

Entry.objects.order_by('headline')[0:1].get()

10.字段查询

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

转换成SQL：

SELECT*FROMblog_entryWHEREpub_date <= '2006-01-01';

11.exact

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

转换成SQL:

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

12.iexact——忽略大小写

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

13.contains——包含查询，区分大小写

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

转换成SQL:

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

icontains 不区分大小写

startswith，endswith，istartswith，iendswith

前后模糊查询

14.连接查询

查询blog__name匹配的，返回Entry

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

查询entry__headline匹配的，返回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);

15.F对象，对字段进行操作。就像SQL中，A列+B列。F对象很少用

from django.db.models import F

Entry.objects.filter(n_pingbacks__lt=F('n_comments'))

列加减乘除都可以

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'))

16.like语句转义百分号

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

转义为：

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

17.删除

q = Entry.objects.filter(headline__startswith="What")

q.delete()

18.批量修改

Entry.objects.filter(pub_date__year=2007).update(headline='Everything is the same')

一次性修改所有的Entry的blog属性指向

b = Blog.objects.get(pk=1)

Entry.objects.all().update(blog=b)

update也可以使用F()

Entry.objects.update(headline=F('blog__name'))

19.One-to-many关系

e = Entry.objects.get(id=2)

print e.blog # Hits the database to retrieve the associated Blog

e = Entry.objects.select_related().get(id=2)

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() 清理所有关系对象

20.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

21.One-to-one关系

要在定义模型的时候设置

class EntryDetail(models.Model):

entry = models.OneToOneField(Entry)

details = models.TextField()

ed = EntryDetail.objects.get(id=2)

ed.entry # 返回 Entry 对象