Django框架学习-Model进阶用法

• • Model进阶用法
    • 回顾
    • 访问外键
    • 访问多对多关系
    • 更改数据库结构
      • 当处理数据库结构改变时，需要注意到几点：
      • 增加字段
        • 首先在开发环境中：
        • 再到产品环境中：
      • 删除字段
      • 删除多对多字段
      • 删除model
    • Manager管理器
      • 给管理器添加新的方法
      • 修改返回的QuerySet
    • Model的方法
    • 执行自定义SQL语句

Model进阶用法

回顾

Django中的model层主要和数据库进行交互，使用数据库API对数据库进行增删改查的操作。

下面将介绍关于model层更深入的用法。

 

下面是之前创建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

进行简单查询操作 文章来自http://absoso.com/saishituijian/2012090833.html

但是有一点我们没有进行介绍，那就是有关外键和多对多字段的查询。

访问外键

因为对于一本书来说，只有一个出版商，而对于一个出版商来说，可以出很多书，这是一个

一对多的关系。因为代码中在Book类中定义了和Publisher的一对多的关系，而Publiser没

有定义和Book。所以，从"一"中查询"多"的有所不同：

book_set是一个QuerySet类型，也可进行filter，slice操作。Django中支持一对多关系中，从

"一"的属性访问"多"属性+"_set"，来获得相应的"多属性"的记录信息，返回的是QuerySet类型。

访问多对多关系

和访问外键相似，因为在Book类中定义和Author的多对多的关系，所以直接操作的是QuerySet的值，

对于书和作者的多对多的关系，可以进行filter等操作，操作如下：

而在Author类中没有定义和Book的关系，也需要_set进行操作：

更改数据库结构

之前介绍过可以使用python manage.py syncdb去根据model定义创建数据库中不存在的表。

但它对model中的字段的改变或者是删除操作都不会同步到数据库中，只能手动去更改数据库的

结构。在MySQL数据中，你就需要ALTER操作。

当处理数据库结构改变时，需要注意到几点：

1. 当model中含有数据库表中没有的字段时，比如在model中添加了某个字段，没有对数据库表进行

相应的改变，Django会在你第一次使用API访问该表时会报错。

 

 

2. 当数据库表中含有model中没有的字段时，比如在model中删除了某个字段，没有对数据库表进行

相应的改变时，Django可以正常运行。

 

 

3. 当数据库中含有没有和model对应的表时，比如删除了某个model，没有对数据库进行相应的改变时，

Django可以正常运行。

 

 

所以在改变model和数据库的时候，注意按照正确的顺序，以免报错。

增加字段

当你在准备在表和model中加入新的字段的时候，参考上面的第2点，为了不报错，策略就是

先在数据库中进行表结构更改，再在你的model代码中进行更改。

 

 

然而当你先使用SQL语句对数据库表进行操作的时候，最好采用和sync命令时Django对数据库

进行的一样的操作，这样可以保证你的SQL和Django的SQL操作的一致性。查看Django的创建

表时的SQL的命令是python manage.py sqlall [app name]。但如果先在model中加新的字段，

用命令去查看Django的SQL语句，Django在运行的时候又会报错。怎样去解决这一矛盾问题呢？

 

解决这一矛盾的方法就是你需要使用的是开发服务器和产品服务器，两个环境。

 

首先在开发环境中：

1. 在model中加入新的字段

2. 运行python manage.py sqlall，查看Django的SQL语句，确认新字段在SQL的定义写法

3. 按照第2步查看到的定义写法，对数据库进行Alter table的操作。

4. 运行python manage.py shell，导入重新定义的model，确认各种API操作不报错。

 

再到产品环境中：

1. 首先按照上面的查看到的SQL对数据库进行Alter table操作。

2. 再在你的model中加入新的字段

3. 重启server，让代码生效。

 

 

比如我们现在向Book类中进行更改。

1. 在model中新加入一个num_pages的属性：

class Book(models.Model) :
    title  = models.CharField(max_length = 100)
    authors  = models.ManyToManyField(Author)
    publisher  = models.ForeignKey(Publisher)
    publication_date  = models.DateField(blank = True, null = True)
    num_pages  = models.IntegerField(blank = True, null = True)

     def __unicode__( self) :
         return  self.title

 

2.运行python manage.py sqlall books, 查看Django的SQL语句

 

3.改变数据库表结构

因为在model中设定的num_pages属性是可以为NULL，如果你在添加NOT NULL的字段时，

你需要遵循的步骤是：

a. 首先创建可以为NULL的字段

b. 修改字段的默认值为某非空值

c. 最后再修改字段的属性为NOT NULL

 

4. 运行python manage.py shell，验证Django的数据库操作正确。

无报错，说明添加字段正确。

删除字段

比添加字段简单，步骤是：

1. 首先从model中删除一个字段，并重启服务器

2. 再在数据库表中删除该字段

mysql>ALTER TABLE book DROP COLUMN num_pages;

 

需要注意的是，如果先在数据库中删除字段的话，Django会报错。

删除多对多字段

步骤和删除一般的字段有所不同：

1. 从model删除该字段，并重启server

2. 从数据库中删除多对多的那张关系表

mysql>DROP TABLE books_book_authors;

 

 

对于多对多的关系，一般在数据库设计中，就会使用一张针对多对多关系的表，来

减少数据冗余问题，Django也会根据这个原则，创建这张有关系表：

删除model

步骤和删除一般字段一样：

1. 删除model.py文件，并重启server

2. 删除数据库表，要注意的需要先删除和该表的外键关系字段

mysql>DROP TABLE books_book;

Manager管理器

管理器是Django查询数据库时会使用到的一个特别的对象，在Book.objects.all()语法中，

objects就是管理器，每一个model至少有一个管理器，而且，你也可以创建自己的管理器来

自定义你的数据库访问操作。一方面可以增加额外的管理器方法，另一方面可以根据你的需求来

修改管理器返回的QuerySet。

给管理器添加新的方法

这是一种"表级别"的操作，下面我们给之前的Book类增加一个方法title_count()，它根据关键字，

返回标题中包括这个关键字的书的个数。

class BookManager(models.Manager) :
     def title_count( self, keyword) :
         return  self. filter(title__icontains =keyword).count()

class Book(models.Model) :
    title  = models.CharField(max_length = 100)
    authors  = models.ManyToManyField(Author)
    publisher  = models.ForeignKey(Publisher)
    publication_date  = models.DateField()
    num_pages  = models.IntegerField(blank = True, null = True)

     #可以直接赋值替换掉默认的objects管理器，也可以定义一个新的管理器变量
    #调用时，直接使用这个新变量就可以了，一旦定义了新的管理器，默认管理器
    #需要显示声明出来才可以使用
     # objects = models.Manger()
    objects  = BookManager()

     def __unicode__( self) :
         return  self.title

结果为：

上面的代码可以看到，创建自定义的Manager的步骤：

1. 继承models.Manager，定义新的管理器方法，在方法中使用self，也就是manager本身来

进行操作

2. 把自定义的管理器对象赋值给objects属性来代替默认的管理器。

 

 

为什么不直接创建个title_count函数来实现这个功能呢？

因为创建管理器类，可以更好地进行封装功能和重用代码。

修改返回的QuerySet

Book.objects.all()返回的是所有记录对象，可以重写Manager.get_query_set()方法，它返回的是

你自定义的QuerySet，你之后的filter,slice等操作都是基于这个自定义的QuerySet。

from django.db  import models

class RogerBookManager(models.Manager) :
     def get_query_set( self) :
         #调用父类的方法，在原来返回的QuerySet的基础上返回新的QuerySet
         return super(RogerBookManager,  self).get_query_set(). filter(title__icontains = 'python')

class Book(models.Model) :
    title  = models.CharField(max_length = 100)
    author  = models.CharField(max_length = 50)

     #objects默认管理器需要显示声明，才能使用
    objects  = models.Manager()  # 默认的管理器
    roger_objects  = DahlBookManager()  # 自定义的管理器，用新变量

结果为：

你可以为model定义多个不同的管理器来返回不同的QuerySet，不过要注意一点的是Django

会把你 第一个定义的管理器当作是默认的管理器，也就是代码行中最上面定义的管理器。Django

有些其它的功能会使用到默认的管理器，为了能让它正常的工作，一种比较好的做法就是把原始默认

的管理器放在第一个定义。

 

Model的方法

和管理器的"表级别"操作相比，model的方法更像是"记录级别"的操作，不过，model的主要设计是用来

用"表级别"操作的，"记录级别"的操作往往是用来表示记录的状态的，是那些没有放在数据库表中，但是也

有意义的数据。举例说明：

from django.db  import models

class Person(models.Model) :
    first_name  = models.CharField(max_length = 50)
    last_name  = models.CharField(max_length = 50)
    birth_date  = models.DateField()
    address  = models.CharField(max_length = 100)
    city  = models.CharField(max_length = 50)

     # 用来判读是否在baby boomer出生，可以不用放在数据库表中
     def baby_boomer_status( self) :
         "Returns the person's baby-boomer status."
         import datetime
         if datetime.date( 1945,  8,  1)  <=  self.birth_date  <= datetime.date( 1964,  12,  31) :
             return  "Baby boomer"
         if  self.birth_date  < datetime.date( 1945,  8,  1) :
             return  "Pre-boomer"
         return  "Post-boomer"

     # 用来返回全名，这个可以不被插入到数据库表中
     def get_full_name( self) :
         "Returns the person's full name."
         return u '%s %s'  % ( self.first_name,  self.last_name)

运行结果：

>> > p  = Person.objects.get(first_name = 'Barack', last_name = 'Obama')
>> > p.birth_date
datetime.date( 1961,  8,  4)
>> > p.baby_boomer_status()
'Baby boomer'
>> > p.get_full_name()
u 'Barack Obama'

执行自定义SQL语句

如果你想执行自定义的SQL语句查询，可以使用django.db.connection对象：

可以使用SQL对数据库中所有的表进行操作，而不用引用特定的model类。

需要注意的是execute()函数使用的SQL语句需要 使用到%s这样的格式符，而

不是直接写在里面。

 

 

这样的操作比较自由，比较好的做法是把它放在自定义管理器中：

from django.db  import connection, models

class PythonBookManager(models.Manager) :
     def books_titles_after_publication( self, date_string) :
        cursor  = connection.cursor()
        cursor.execute( "" "
            SELECT title
            FROM books_book
            WHERE publication_date > %s" "", [date_string])
         #fetchall()返回的是元组的列表
         return [row[ 0]  for row  in cursor.fetchall()]

class Book(models.Model) :
    title  = models.CharField(max_length = 100)
    authors  = models.ManyToManyField(Author)
    publisher  = models.ForeignKey(Publisher)
    publication_date  = models.DateField(blank = True, null = True)
    num_pages  = models.IntegerField(blank = True, null = True)

    objects  = models.Manager()
    python_objects  = PythonBookManager()

运行结果：