Django Database API

最近在和朋友一起学习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

需遵循如下步骤：
1. 创建一个类的实例
2. 在这个实例上调用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>]>

获得满足过滤条件的部分对象

1. filter 返回满足条件的对象集合
2. 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>]>

上述例子中可以看出：
1. 由于filter() exclude()均返回QuerySet()，因此可以链式调用
2. 参数形式为field__lookuptype=filter_value，类似SQL语句中WHERE后面的写法。
3. 关于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）

限制返回的对象数量

1. 返回前2个对象

>>> Blog.objects.all()[:2]
<QuerySet [<Blog: Beatles Blog>, <Blog: Sue Blog>]>

1. 返回第2个到第3个对象

>>> Blog.objects.all()[1:3]
<QuerySet [<Blog: Sue Blog>, <Blog: Compter Science>]>

1. 返回第三个对象

>>> 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>]>

对象的外键

当我们通过对象的外键是否符合某个条件来查找对象时，有以下几种方式：
1. 上文提到的一种方式

>>> Entry.objects.filter(blog__name__contains="Sue")
<QuerySet [<Entry: Beatles' first song>]>

1. 如果可以获得外键实例，可直接判断是否相等

>>> b = Blog.objects.all().get(pk=2)
>>> Entry.objects.filter(blog=b)
<QuerySet [<Entry: Beatles' first song>]>

1. 如果知道外键的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对象可以做更加复杂的匹配，可以封装多个过滤条件。
1. 封装单个过滤条件

>>> Blog.objects.all().filter(Q(name__startswith="Beatles"))
<QuerySet [<Blog: Beatles Blog>, <Blog: Beatles Blog>]>

1. 与 或 非

Q(question__startswith="WHO") | ~Q(question__startswith="WHAT")

1. 多个过滤条件

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="[email protected]")
>>> a2 = Author.objects.create(name="Bob", email="[email protected]")

使用add()为authors字段添加一个实例

>>> entry.authors.add(a1, a2)
>>> Entry.objects.all()[0].authors.get(id=1)
<Author: Sue>

需要注意的是：
1. add()方法后，不需要save()
2. 这里使用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})

我们需要注意的是：
1. 返回结果显示，此次删除操作删除了7个对象，3个Blog实例，1个Entry实例，3个Entry_authors中的对象。
2. 默认情况下， delete()遵循级联删除的规则，即以被删除对象为外键的对象同时被删除。我们可以通过在定义model时添加on_delete参数来指定级联规则

删除指定对象

我们可以配合使用get() filter()等获得指定对象或包含指定对象集的QuerySet，然后调用delete()

SQL

最后，我们也可以使用原生的SQL在访问数据库。