django mysql封装_django对数据库操作的封装

执行查询

一旦你建立好数据模型，Django 会自动为你生成一套数据库抽象的API，可以让你创建、检索、更新和删除对象。这篇文档阐述如何使用这些API。 关于模型查询所有选项的完整细节，请见数据模型参考。

在整个文档(以及参考)中，我们将引用下面的模型，它构成一个博客应用：from django.db import modelsclass Blog(models.Model):

name = models.CharField(max_length=100)

tagline = models.TextField()

def __str__(self):              # __unicode__ on Python 2

return self.nameclass Author(models.Model):

name = models.CharField(max_length=50)

email = models.EmailField()

def __str__(self):              # __unicode__ on Python 2

return self.nameclass 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

创建对象

Django 使用一种直观的方式把数据库表中的数据表示成Python 对象：一个模型类代表数据库中的一个表，一个模型类的实例代表这个数据库表中的一条特定的记录。

使用关键字参数实例化模型实例来创建一个对象，然后调用save() 把它保存到数据库中。

假设模型存放于文件mysite/blog/models.py中，下面是一个例子：>>> from blog.models import Blog>>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')>>> b.save()

上面的代码在背后执行了SQL 的INSERT 语句。在你显式调用save()之前，Django 不会访问数据库。

save() 方法没有返回值。

请参见

save()方法带有一些高级选项，它们没有在这里给出。完整的细节请见save() 文档。

如果你想只用一条语句创建并保存一个对象，使用create()方法。

保存对象的改动

要保存对数据库中已存在的对象的改动，请使用save()。

假设Blog 的一个实例b5 已经被保存在数据库中，下面这个例子将更改它的name 并且更新数据库中的记录：>>> b5.name = 'New name'>>> b5.save()

上面的代码在背后执行SQL 的UPDATE语句。在你显式调用save()之前，Django不会访问数据库。

保存ForeignKey和ManyToManyField字段

更新ForeignKey 字段的方式和保存普通字段相同 —— 只要把一个正确类型的对象赋值给该字段。下面的例子更新了Entry 类的实例entry 的blog 属性，假设Entry 和Blog 分别已经有一个正确的实例保存在数据库中(所以我们可以像下面这样获取它们)：>>> from blog.models import Entry>>> entry = Entry.objects.get(pk=1)>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")>>> entry.blog = cheese_blog>>> entry.save()

更新ManyToManyField 的方式有一些不同 —— 需要使用字段的add()方法来增加关联关系的一条记录。下面这个例子向entry 对象添加Author 类的实例joe：>>> from blog.models import Author>>> joe = Author.objects.create(name="Joe")>>> entry.authors.add(joe)

为了在一条语句中，向ManyToManyField添加多条记录，可以在调用add()方法时传入多个参数，像这样：>>> john = Author.objects.create(name="John")>>> paul = Author.objects.create(name="Paul")>>> george = Author.objects.create(name="George")>>> ringo = Author.objects.create(name="Ringo")>>> entry.authors.add(john, paul, george, ringo)

Django 将会在你赋值或添加错误类型的对象时报错。

获取对象

通过模型中的管理器构造一个查询集，来从你的数据库中获取对象。

查询集表示从数据库中取出来的对象的集合。它可以含有零个、一个或者多个过滤器。过滤器基于所给的参数限制查询的结果。 从SQL 的角度，查询集和SELECT 语句等价，过滤器是像WHERE 和LIMIT 一样的限制子句。

你可以从模型的管理器那里取得查询集。每个模型都至少有一个管理器，它默认命名为objects。通过模型类来直接访问它，像这样：>>> Blog.objects>>> b = Blog(name='Foo', tagline='Bar')>>> b.objectsTraceback:    ...AttributeError: "Manager isn't accessible via Blog instances."

注

管理器只可以通过模型的类访问，而不可以通过模型的实例访问，目的是为了强制区分“表级别”的操作和“记录级别”的操作。

对于一个模型来说，管理器是查询集的主要来源。例如，Blog.objects.all() 返回包含数据库中所有Blog 对象的一个查询集。

获取所有对象

获取一个表中所有对象的最简单的方式是全部获取。可以使用管理器的all() 方法：>>> all_entries = Entry.objects.all()

all()方法返回包含数据库中所有对象的一个查询集。

使用过滤器获取特定对象

all() 方法返回了一个包含数据库表中所有记录查询集。但在通常情况下，你往往想要获取的是完整数据集的一个子集。

要创建这样一个子集，你需要在原始的的查询集上增加一些过滤条件。两个最普遍的途径是：filter(**kwargs)

返回一个新的查询集，它包含满足查询参数的对象。

exclude(**kwargs)

返回一个新的查询集，它包含不满足查询参数的对象。

查询参数(上面函数定义中的**kwargs)需要满足特定的格式，下面字段查询一节中会提到。

举个例子，要获取年份为2006的所有文章的查询集，可以使用filter()方法：Entry.objects.filter(pub_date__year=2006)

利用默认的管理器，它相当于：Entry.objects.all().filter(pub_date__year=2006)

链式过滤

查询集的筛选结果本身还是查询集，所以可以将筛选语句链接在一起。像这样：>>> Entry.objects.filter(...     headline__startswith='What'... ).exclude(...     pub_date__gte=datetime.date.today()... ).filter(...     pub_date__gte=datetime(2005, 1, 30)... )

这个例子最开始获取数据库中所有对象的一个查询集，之后增加一个过滤器，然后又增加一个排除，再之后又是另外一个过滤器。最后的结果仍然是一个查询集，它包含标题以”What“开头、发布日期在2005年1月30日至当天之间的所有记录。

过滤后的查询集是独立的

每次你筛选一个查询集，得到的都是全新的另一个查询集，它和之前的查询集之间没有任何绑定关系。每次筛选都会创建一个独立的查询集，它可以被存储及反复使用。

例如：>>> q1 = Entry.objects.filter(headline__startswith="What")>>> q2 = q1.exclude(pub_date__gte=datetime.date.today())>>> q3 = q1.filter(pub_date__gte=datetime.date.today())

这三个查询集都是独立的。第一个是一个基础的查询集，包含所有标题以“What”开头的记录。第二个查询集是第一个的子集，它增加另外一个限制条件，排除pub_date 为今天和将来的记录。第三个查询集同样是第一个的子集，它增加另外一个限制条件，只选择pub_date 为今天或将来的记录。原始的查询集(q1)不会受到筛选过程的影响。

查询集是惰性执行的

查询集 是惰性执行的 —— 创建查询集不会带来任何数据库的访问。你可以将过滤器保持一整天，直到查询集 需要求值时，Django 才会真正运行这个查询。看下这个例子：>>> q = Entry.objects.filter(headline__startswith="What")>>> q = q.filter(pub_date__lte=datetime.date.today())>>> q = q.