最近在和朋友一起学习Django，首先简单学习一下它的Database API。
首先按照如下模型创建三个表：
from django.db import models
class Blog(models.Model):
name = models.CharField(max_length=100)
tagline = models.TextField()
def __str__(self):
return self.name
class Author(models.Model):
name = models.CharField(max_length=200)
email = models.EmailField()
def __str__(self):
return self.name
class Entry(models.Model):
blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
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.IntergerField()
n_pingbacks = models.IntegerField()
rating = models.IntegerField()
def __str__(self):
return self.headline
class EntryDetail(models.Model):
entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
details = models.TextField()
创建对象
这里的创建对象相当于在表格中INSERT一条记录。
save
需遵循如下步骤：
- 创建一个类的实例
- 在这个实例上调用
save()
>>> b1=Blog(name="Beatles Blog", tagline = "all the latest Beatles news.")
>>> b2=Blog(name="Sue Blog", tagline = "all latest news about Sue.")
>>> b3=Blog(name="Computer Science", tagline="Hello World!")
>>> b1.save()
>>> b2.save()
>>> b3.save()
create
调用Manager的create()（具体使用方法会在后面的文章中提到）
复制已有对象
将想复制的对象的pk设为None，然后save()即可。
>>> b = Blog.objects.all().get(pk=4)
>>> b.pk = None
>>> b.save()
需要注意的是， 这种方法并不会复制对象的ManyToManyField等属性，因此针对ManyToMany的情况，我们可以：
entry = Entry.objects.all()[0]
>>> old_authors = entry.authors.all()
>>> entry.pk = None
>>> entry.save()
>>> entry.authors.set(old_authors)
而OneToOne的情况，我们可以：
>>> EntryDetail.objects.create(entry=Entry.objects.all()[0], details="None")
<EntryDetail: EntryDetail object (1)>
>>> detail = EntryDetail.objects.all()[0]
>>> detail.pk=None
>>> detail.entry=Entry.objects.all()[1]
>>> detail.save()
查询对象
在Django中，每一个model都至少有一个Manager，默认有一个Manager叫objects（即objects是django.db.models.manager.Manager的实例），我们通过调用这个变量的方法可以获得一个包含对象集合的QuerySet
获得所有对象
>>> Blog.objects.all()
<QuerySet [<Blog: Beatles Blog>, <Blog: Sue Blog>, <Blog: Computer Science>]>
获得满足过滤条件的部分对象
-
filter返回满足条件的对象集合 -
exclude在所有对象的集合中排除满足条件的对象集合并返回
>>> Blog.objects.filter(name="Computer Science")
<QuerySet [<Blog: Computer Science>]>
>>> Blog.objects.exclude(pk=1)
<QuerySet [<Blog: Sue Blog>, <Blog: Compter Science>]>
>>> Blog.objects.exclude(pk=3).filter(name__startswith="Beatles")
<QuerySet [<Blog: Beatles Blog>]>
上述例子中可以看出：
- 由于
filter()exclude()均返回QuerySet()，因此可以链式调用 - 参数形式为
field__lookuptype=filter_value，类似SQL语句中WHERE后面的写法。 - 关于
name__startswith="Beatles"，后面会有讲解。
另外有一点需要注意，创建一个QuerySet不涉及任何数据库操作，只有在使用它的时候，才会去访问数据库。
>>> q = Blog.objects.filter(name="Computer Science")
>>> q = q.exclude(pk=1)
>>> print(q)
<QuerySet []>
前面两句都是在创建一个QuerySet，只有最后一句才使用了它，因此整段代码只有在最后一句才真正访问了数据库。
获得某一个对象
如果能够确定某种过滤条件能而且只能返回一个对象，我们可以使用get()
>>> Blog.objects.get(pk=1)
<Blog: Beatles Blog>
>>> Blog.objects.filter(pk=1)[0]
<Blog: Beatles Blog>
上述例子中，我们似乎可以看出get()与filter()+[0]可以做同一件事情，事实不是这样的，我们再举一个例子：
>>> Blog.objects.get(pk=4)
...
blog.models.DoesNotExist: Blog matching query does not exist.
>>> Blog.objects.get(name__endswith="Blog")
...
blog.models.MultipleObjectsReturned: get() returned more than one Blog -- it returned 2!
>>> Blog.objects.filter(pk=4)
<QuerySet []>
>>> Blog.objects.filter(pk=4)[0]
...
IndexError: list index out of range
可以看出get()更加严格，无论是找不到对象，可以返回的对象不止一个，均会报错（DoesNotExist MultipleObjectsReturned）
限制返回的对象数量
- 返回前2个对象
>>> Blog.objects.all()[:2]
<QuerySet [<Blog: Beatles Blog>, <Blog: Sue Blog>]>
- 返回第2个到第3个对象
>>> Blog.objects.all()[1:3]
<QuerySet [<Blog: Sue Blog>, <Blog: Compter Science>]>
- 返回第三个对象
>>> Blog.objects.all()[2]
<Blog: Compter Science>
更多查找条件
我们在写一个SQL语句时，WHERE部分不仅仅局限于=，比如：
WHERE pub_date <= '2018-02-19'
WHERE
那么如何在Django中表示更多的查找条件呢？我们使用上文提到过的如下形式：
field__lookuptype=filter_value
lte
>>> Entry.objects.filter(pub_date__lte='2006-01-01')
<QuerySet []>
exact
即相等
>>> Entry.objects.filter(body_text__exact="None")
<QuerySet [<Entry: Beatles' first song>]>
相当于
>>> Entry.objects.filter(body_text="None")
<QuerySet [<Entry: Beatles' first song>]>
iexact
在忽略大小写的情况下，是否相等。
>>> Entry.objects.filter(body_text__iexact="none")
<QuerySet [<Entry: Beatles' first song>]>
contains
字符串中是否包含给定字符串，相当于SQL语句中的LIKE
>>> Entry.objects.filter(body_text__contains="No")
<QuerySet [<Entry: Beatles' first song>]>
icontains
在忽略大小写的情况下，字符串中是否包含给定字符串。
startswith
字符串是否以给定字符串开头
endswith
字符串是否以给定字符串结尾
istartswith
在忽略大小写的情况下，字符串是否以给定字符串开头
endswith
在忽略大小写的情况下，字符串是否以给定字符串结尾
对象的属性的属性
当我们通过判断对象的属性的属性是否符合某个条件来查找对象时，不能使用.，应使用__
>>> Entry.objects.filter(blog__name__contains="Sue")
<QuerySet [<Entry: Beatles' first song>]>
对象的外键
当我们通过对象的外键是否符合某个条件来查找对象时，有以下几种方式：
- 上文提到的一种方式
>>> Entry.objects.filter(blog__name__contains="Sue")
<QuerySet [<Entry: Beatles' first song>]>
- 如果可以获得外键实例，可直接判断是否相等
>>> b = Blog.objects.all().get(pk=2)
>>> Entry.objects.filter(blog=b)
<QuerySet [<Entry: Beatles' first song>]>
- 如果知道外键的
id：
>>> Entry.objects.filter(blog_id=2)
<QuerySet [<Entry: Beatles' first song>]>
或者
>>> Entry.objects.filter(blog=2)
<QuerySet [<Entry: Beatles' first song>]>
或者
>>> Entry.objects.filter(blog=b.id)
<QuerySet [<Entry: Beatles' first song>]>
我们可以通过foreignkeyname_id的形式获得外键的id
Q对象
Q对象可以做更加复杂的匹配，可以封装多个过滤条件。
- 封装单个过滤条件
>>> Blog.objects.all().filter(Q(name__startswith="Beatles"))
<QuerySet [<Blog: Beatles Blog>, <Blog: Beatles Blog>]>
- 与 或 非
Q(question__startswith="WHO") | ~Q(question__startswith="WHAT")
- 多个过滤条件
Blog.objects.filter(Q(name__startswith("b")), Q(name__endswith("s")))
当往Q输入多个参数时，它们之间的关系为AND
更新对象
更新单个对象
更新普通字段
>>> b.name="Beatles' Blog"
>>> b.save()
更新外键
首先创建一个Entry对象：
entry = Entry(blog=b, headline="Beatles' first song", body_text="None",pub_date=datetime.now(),n_comments=4,n_pingbacks=4,rating=4,mod_date=datetime.now())
>>> entry.save()
修改entry的外键：
b = Blog.objects.all().get(pk=2)
>>> entry.blog = b
>>> entry.save()
>>> Entry.objects.all()[0].blog
<Blog: Sue Blog>
更新多对多字段
首先新建一个Author实例：
>>> a1 = Author.objects.create(name="Sue", email="158@qq.com")
>>> a2 = Author.objects.create(name="Bob", email="189@qq.com")
使用add()为authors字段添加一个实例
>>> entry.authors.add(a1, a2)
>>> Entry.objects.all()[0].authors.get(id=1)
<Author: Sue>
需要注意的是：
-
add()方法后，不需要save() - 这里使用
create()创建对象，它是Manager的一个方法。也不需要save()
更新多个对象
使用update()并配合filter() all()等，对一个对象集合进行更新操作。update()返回需要更新的对象数（也许不是发生改变的对象数，因为有的对象已经有了最新值）
>>> Entry.objects.filter(pub_date__year=2018).update(headline="Everything is the same.")
3
需要注意的是，使用这个方法只能更新外键或者没关系型字段
删除对象
使用delete()来删除的对象，为了避免误删除，Manager本身并没有暴露delete()方法。delete()返回删除的对象数量以及按照对象类型的分类汇总。
删除所有对象
>>> Blog.objects.all().delete()
(7, {'blog.Entry_authors': 3, 'blog.EntryDetail': 0, 'blog.Entry': 1, 'blog.Blog': 3})
我们需要注意的是：
- 返回结果显示，此次删除操作删除了7个对象，3个Blog实例，1个Entry实例，3个
Entry_authors中的对象。 - 默认情况下，
delete()遵循级联删除的规则，即以被删除对象为外键的对象同时被删除。我们可以通过在定义model时添加on_delete参数来指定级联规则
删除指定对象
我们可以配合使用get() filter()等获得指定对象或包含指定对象集的QuerySet，然后调用delete()
SQL
最后，我们也可以使用原生的SQL在访问数据库。
