Django book2 模型 学习笔记

Djanjo采用模型的优点:
1 自省（运行时自动识别数据库）会导致过载和有数据完整性问题
2 把数据模型用代码的方式表述来让你可以容易对它们进行版本控制。 这样，你可以很容易了解数据层 的变
  动情况。
3  SQL只能描述特定类型的数据字段。 例如，大多数数据库都没有专用的字段类型来描述Email地址
  而用Django的模型可以做到这一点。 好处就是高级的数据类型带来更高的效率和更好的代码复用
  
4  SQL还有在不同数据库平台的兼容性问题。 发布Web应用的时候，使用Python模块描述数据库结构信息可
  以避免为MySQL, PostgreSQL, and SQLite编写不同的CREATE TABLE。


要解决的问题:
  Python代码和数据库表的同步问题。 如果你修改了一个Django模型， 你要自己来修改数据库来保证和模型同步
  
  
一 创建MSSQL数据库 bookdb
   建立project
   django-admin.py startproject mysite
   
二 配置settings.py的DATABASES配置
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
            'NAME': 'bookdb',                      # Or path to database file if using sqlite3.
            'USER': 'root',                      # Not used with sqlite3.
            'PASSWORD': '423423',                  # Not used with sqlite3.
            'HOST': 'localhost',                      # Set to empty string for localhost. Not used with sqlite3.
            'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
        }
    }
    一旦在输入了那些设置并保存之后应当测试一下你的配置。 我们可以在`` depot`` 项目目录下执行`
    python manage.py shell 
    来进行测试。(是以正确Django配置启用Python交互解释器的一种方法。 这个方法在这里是很有必要的，
    因为Django需要知道加载 哪个配置文件来获取数据库连接信息。）
    输入下面这些命令来测试你的数据库配置：
    >>> from django.db import connection
    >>> cursor = connection.cursor()
三 创建模型


1 在项目中创建一个app
    系统对app有一个约定： 如果你使用了Django的数据库层（模型），你 必须创建一个Django app。
    模型必须存放在apps中。 因此，为了开始建造 我们的模型，我们必须创建一个新的app    
    python manage.py startapp books
    
2 创建module.py:


   1)首先要注意的事是每个数据模型都是 django.db.models.Model 的子
   类。它的父类 Model 包含了所有必要的和数据库交互的方法，并提供了一个简洁漂亮的定义数据库字段的语
   法。
   
   2)每个模型相当于单个数据库表，每个属性也是这个表中的一个字段。 属性名就是字段名，它的类型（例如
     CharField ）相当于数据库的字段类型 （例如 varchar ）
     
   3)“每个数据库表对应一个类”这条规则的例外情况是多对多关系。 在我们的范例模型中， Book 有一个
    多对多字段 叫做 authors 。 该字段表明一本书籍有一个或多个作者，但 Book 数据库表却并没有 authors 字
    段。 相反，Django创建了一个额外的表（多对多连接表）来处理书籍和作者之间的映射关系
    
  ###自定义表属性相关
  4)我们并没有显式地为这些模型定义任何主键。 除非你单独指明，否则Django会自动为每
   个模型生成一个自增长的整数主键字段每个Django模型都要求有单独的主键。id
   
  5)默认的字段名与属性名相同，可以通过字段的db_column属性自定义，如
      where = models.CharField(max_length=400, db_column='place')
  6)除了ID字段，其他字段默认不建立索引，可以通过字段的db_index属性自定义，如
     publish_date= models.DateField(db_index=True)
  7）自定义ID
     如果不指定ID，默认创建一个类型为IntegerField的id字段，可以通过字段的primary_key属性指定自己的ID字段。如：
     key = models.IntegerField(primary_key=True)
  8)自定义表名 
    默认的表名是appName_modelName，在Model类的Meta中可以通过db_table属性改变默认的表名。
        
  9） 自定义表空间
    对于索引字段，默认在settings的DEFAULT_INDEX_TABLESPACE设定的表空间中建立索引，可以通过字段的db_tablespace属性指定，如
         publish_date= models.DateField(db_index=True,db_tablespace='another_tbs')
    对于Model类，通过Meta中的db_tablespace属性指定特定的表空间。


  10）自定义关联关系
       1）外键默认关联到对方的主键字段，可以通过外键的to_field指定关联到的字段，如
              to_model = models.ForeighKey(ToModel,to_field='key')
       2)对于many-to-many关联，Django会创建一个关联表，默认表名是两个表名通过下划线连接起来。
        可以通过ManyToManyField的db_table指定关联表的表名。  
       3）对于many-to-many关联，如果不想使用Django创建的关联表，可以通过ManyToManyField的through属性指定到一个已存在的Model类。 
    
3 模型安装(生成数据库表）
 完成这些代码之后，现在让我们来在数据库中创建这些表。 要完成该项工作，
 1)第一步是在 Django 项目中 激活这些模型。 将 books app 添加到配置文件的已安装应用列表中即可完成此步骤。
 
 2)验证模型的有效性：validate 命令检查你的模型的语法和逻辑是否正确。
  python manage.py validate
  
 3）运行下面的命令来生成 CREATE TABLE 语句
    python manage.py sqlall books
    
    sqlall 命令并没有在数据库中真正创建数据表，只是把SQL语句段打印出来，这样你可以看到Django究竟会做
   些什么。 如果你想这么做的话，你可以把那些SQL语句复制到你的数据库客户端执行，或者通过Unix管道直接
   进行操作（例如，`` python manager.py sqlall books | psql mydb`` ）。
   
4）Django提供了一种更为简易的提交SQL语句至数据库的方法： `` syncdb`` 命令
    python manage.py syncdb
    
    执行这个命令后，将看到类似以下的内容：
    Creating table books_publisher
    Creating table books_author
    Creating table books_book
    Installing index for books.Book model
    syncdb 命令是同步你的模型到数据库的一个简单方法。 它会根据 INSTALLED_APPS 里设置的app来检查数据库， 
    如果表不存在，它就会创建它。 需要注意的是， syncdb 并 不能将模型的修改或删除同步到数据库；
    如果你修改或删除了一个模型，并想把它提交到数据库，syncdb并不会做出任何处理。
   
    如果你再次运行 python manage.py syncdb ，什么也没发生，因为你没有添加新的表，运行python manage.py syncdb总是安全的，因为它不会重复执行SQL语句。
    如果你有兴趣，花点时间用你的SQL客户端登录进数据库服务器看看刚才Django创建的数据表。 你可以手动启
    动命令行客户端（例如，执行PostgreSQL的`` psql`` 命令），也可以执行 `` python manage.py dbshell`` ，
    这个命令将依据`` DATABASE_SERVER`` 的里设置自动检测使用哪种命令行客户端。
    
5）基本数据访问
    python manage.py shell 并输入
    下面的内容试试看：
    >>> from books.models import Publisher
    >>> p1 = Publisher(name='Apress', address='2855 Telegraph Avenue',
    ...     city='Berkeley', state_province='CA', country='U.S.A.',
    ...     website='http://www.apress.com/')
    >>> p1.save()
    >>> p2 = Publisher(name="O'Reilly", address='10 Fawcett St.',
    ...     city='Cambridge', state_province='MA', country='U.S.A.',
    ...     website='http://www.oreilly.com/')
    >>> p2.save()
    >>> publisher_list = Publisher.objects.all()
    >>> publisher_list
    [<Publisher: Publisher object>, <Publisher: Publisher object>]
    
    这短短几行代码干了不少的事。 这里简单的说一下：
    1）首先，导入Publisher模型类， 通过这个类我们可以与包含 出版社 的数据表进行交互。
    2）接着，创建一个`` Publisher`` 类的实例并设置了字段`` name, address`` 等的值。
    3）调用该对象的 save() 方法，将对象保存到数据库中。 Django 会在后台执行一条 INSERT 语句。
    4）最后，使用`` Publisher.objects`` 属性从数据库取出出版商的信息，这个属性可以认为是包含出版商的记
    录集。 这个属性有许多方法， 这里先介绍调用`` Publisher.objects.all()`` 方法获取数据库中`` Publisher``
    类的所有对象。这个操作的幕后，Django执行了一条SQL `` SELECT`` 语句。
    
    这里有一个值得注意的地方，在这个例子可能并未清晰地展示。 当你使用Django modle API创建对象时
    Django并未将对象保存至数据库内，除非你调用`` save()`` 方法：
    
   如果需要一步完成对象的创建与存储至数据库，就使用`` objects.create()`` 方法


6）添加模块的字符串表现
为Publisher 对象添加一个方法 __unicode__() 。 __unicode__() 方法告
诉Python如何将对象以unicode的方式显示出来。 
为以上三个模型添加__unicode__()方法后，就可以看到效
果了：


 为了让我们的修改生效，先退出Python Shell，然后再次运行 python manage.py shell 进入。（这是保证代码
修改生效的最简单方法。）现在`` Publisher``对象列表容易理解多了。
>>> from books.models import Publisher
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Apress>, <Publisher: O'Reilly>]


请确保你的每一个模型里都包含 __unicode__() 方法，这不只是为了交互时方便，也是因为 Django会在其他
一些地方用 __unicode__() 来显示对象。
最后， __unicode__() 也是一个很好的例子来演示我们怎么添加 行为 到模型里。 Django的模型不只是为对象
定义了数据库表的结构，还定义了对象的行为。 __unicode__() 就是一个例子来演示模型知道怎么显示它们自
己。


四 模型操作（一般在view.py进行）
1 插入数据
    先使用一些关键参数创建对象实例，如下：
    >>> p = Publisher(name='Apress',
    ...         address='2855 Telegraph Ave.',
    ...         city='Berkeley',
    ...         state_province='CA',
    ...         country='U.S.A.',
                website='http://www.apress.com/')
    >>> p.save()  
    


            
    因为 Publisher 模型有一个自动增加的主键 id ，所以第
    并把它赋值给这个对象实例：
    >>> p.id
    52    # this will differ based on your own data     


2 查询数据
    1）filter:获取列表
    你可以传递多个参数到 filter() 来缩小选取范围：    
    >>> Publisher.objects.filter(country="U.S.A.", state_province="CA")
    [<Publisher: Apress>]


    在 name 和 contains 之间有双下划线。和Python一样，Django也使用双下划线来表明会进行一些魔术般的
    操作。这里，contains部分会被Django翻译成LIKE语句：
    >>> Publisher.objects.filter(name__contains="press")
    [<Publisher: Apress>]


    其他的一些查找类型有：icontains(大小写无关的LIKE),startswith和endswith, 还有range(SQLBETWEEN查
    询）。
    
    2）get:获取单个对象
    上面的例子中`` filter()`` 函数返回一个记录集，这个记录集是一个列表。 相对列表来说，有些时候我们更需要
    获取单个的对象， `` get()`` 方法就是在此时使用的：(一般是主键作为查询)
    >>> Publisher.objects.get(name="Apress")
    <Publisher: Apress>
    这样，就返回了单个对象，而不是列表（更准确的说，QuerySet)。 所以，如果结果是多个对象，会导致抛出
    异常：
    
    3）数据排序
    如果需要以多个字段为标准进行排序（第二个字段会在第一个字段的值相同的情况下被使用到），使用多个参
    数就可以了，如下：
    >>> Publisher.objects.order_by("state_province", "address")
     [<Publisher: Apress>, <Publisher: O'Reilly>]
    我们还可以指定逆向排序，在前面加一个减号 ‐ 前缀：
    >>> Publisher.objects.order_by("-name")
    [<Publisher: O'Reilly>, <Publisher: Apress>]
    
    缺省排序
    
    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 Meta:
        ordering = ['name']
    现在，让我们来接触一个新的概念。 class Meta，内嵌于 Publisher 这个类的定义中（如果 class Publisher
    是顶格的，那么 class Meta 在它之下要缩进4个空格－－按 Python 的传统 ）。你可以在任意一个 模型 类中
    使用 Meta 类，来设置一些与特定模型相关的选项。 在 附录B 中有 Meta 中所有可选项的完整参考，现在，我
    关注 ordering 这个选项就够了。 如果你设置了这个选项，那么除非你检索时特意额外地使用了 order_by()，
    否则，当你使用 Django 的数据库 API 去检索时，Publisher对象的相关返回值默认地都会按 name 字段排序。
    
    4）我们已经知道如何对数据进行过滤和排序。 当然，通常我们需要同时进行过滤和排序查询的操作。 因此，你可
    以简单地写成这种“链式”的形式：
    >>> Publisher.objects.filter(country="U.S.A.").order_by("-name")
    [<Publisher: O'Reilly>, <Publisher: Apress>]
    
    5）限制返回的数据 
    另一个常用的需求就是取出固定数目的记录。 想象一下你有成千上万的出版商在你的数据库里， 但是你只想显
    示第一个。 你可以使用标准的Python列表裁剪语句：
    >>> Publisher.objects.order_by('name')[0]
    <Publisher: Apress>
    
    类似的，你可以用Python的range-slicing语法来取
    >>> Publisher.objects.order_by('name')[0:2]
    
3 更新数据
    我们可以看到Django的save()方法更新了不仅仅是name列的值，还有更新了所有的列。 若
    name以外的列有可能会被其他的进程所改动的情况下，只更改name列显然是更加明智的。 更改某一指定的
    列，我们可以调用结果集（QuerySet）对象的update()方法： 示例如下：
    >>> Publisher.objects.filter(id=4).update(name='Apress Publishing')
    
    与之等同的SQL语句变得更高效，并且不会引起竞态条件。
    UPDATE books_publisher
    SET name = 'Apress Publishing'
    WHERE id = 52;
    update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录。 以下示例演示如何
    将所有Publisher的country字段值由’U.S.A’更改为’USA’：
    >>> Publisher.objects.all().update(country='USA')
    2
    update()方法会返回一个整型数值，表示受影响的记录条数。 在上面的例子中，这个值是2。
4 删除数据


    >>> Publisher.objects.filter(name='Apress Publishing').delete()
    >>> Publisher.objects.filter(country='USA').delete()
    >>> Publisher.objects.all().delete()
    >>> Publisher.objects.all()
    []
    删除数据时要谨慎！ 为了预防误删除掉某一个表内的所有数据，Django要求在删除表内所有数据时显示使用
    all()。
    
    
    
    
    
    
 五 数据模型高级进阶
 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
        
1 访问外键(Foreign Key)值
    当你获取一个ForeignKey 字段时,你会得到相关的数据模型对象。 例如:
    >>> b = Book.objects.get(id=1)
    >>> b.publisher
    <Publisher: Apress Publishing>
    >>> b.publisher.website
    u'http://www.apress.com/'
    
    对于用`` ForeignKey`` 来定义的关系来说，在关系的另一端也能反向的追溯回来，
    。通过一个`` publisher`` 对象，直接获取 books ，用 publisher.book_set.all() ，如
    
    >>> p = Publisher.objects.get(name='O\'Reilly')
    >>> p.book_set.all()
    [<Book: The Django Book>, <Book: Dive Into Python>, ...]
    
    实际上，book_set 只是一个 QuerySet（参考第5章的介绍），所以它可以像QuerySet一样,能实现数据过滤和分
    切，例如：
    >>> p = Publisher.objects.get(name='Apress Publishing')
    >>> p.book_set.filter(name__icontains='django')
    [<Book: The Django Book>, <Book: Pro Django>]
    属性名称book_set是由模型名称的小写(如book)加_set组成的。 
    
2  访问多对多值(Many-to-Many Values)
    多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。 
    >>> b = Book.objects.get(id=1)
    >>> b.authors.all()
    [<Author: Apress Holovaty>] 
    >>> b.authors.filter(first_name='Apress')
    [<Author: Adrian Holovaty>]
    >>> b.authors.filter(first_name='Adam')
    []
    反向查询也可以。 要查看一个作者的所有书籍,使用author.book_set ,就如这样:
    >>> a = Author.objects.get(first_name='Apress', last_name='Holovaty')
    >>> a.book_set.all()
    [<Book: The Django Book>]
    这里,就像使用 ForeignKey字段一样，属性名book_set是在数据模型(model)名后追加_set。


                             
3 更改数据库模式(Database Schema)
    在我们在第5章介绍 syncdb 这个命令时, 我们注意到 syncdb仅仅创建数据库里还没有的表，它 并不 对你数据模
    型的修改进行同步,也不处理数据模型的删除。 如果你新增或修改数据模型里的字段,或是删除了一个数据模型，
    你需要手动在数据库里进行相应的修改。


    当处理模型修改的时候，将Django的数据库层的工作流程铭记于心是很重要的。
    1）如果模型包含一个未曾在数据库里建立的字段，Django会报出错信息。 当你第一次用Django的数据库
      API请求表中不存在的字段时会导致错误（就是说，它会在运行时出错，而不是编译时）。
    2） Django不关心数据库表中是否存在未在模型中定义的列。
    3）Django不关心数据库中是否存在未被模型表示的表格。
    
    改变模型的模式架构意味着需要按照顺序更改Python代码和数据库。
    
    A 添加字段
    
        当要向一个产品设置表(或者说是model)添加一个字段的时候，要使用的技巧是利用Django不关心表里是否包
        含model里所没有的列的特性。 策略就是现在数据库里加入字段，然后同步Django的模型以包含新字段。
        
        首先，进入开发环境(也就是说，不是在发布环境里)：
        1.  在你的模型里添加字段。
        2.  运行 manage.py sqlall [yourapp] 来测试模型新的 CREATE TABLE 语句。 注意为新字段的列定义。
        3.  开启你的数据库的交互命令界面(比如, psql 或mysql , 或者可以使用 manage.py dbshell )。 执行
        ALTER TABLE 语句来添加新列。
        4.  使用Python的manage.py shell，通过导入模型和选中表单(例如， MyModel.objects.all()[:5] )来验证
        新的字段是否被正确的添加 ,如果一切顺利,所有的语句都不会报错。
        然后在你的产品服务器上再实施一遍这些步骤。
        1.  启动数据库的交互界面。
        2.  执行在开发环境步骤中，第三步的ALTER TABLE语句。
        3.  将新的字段加入到模型中。 如果你使用了某种版本控制工具，并且在第一步中，已经提交了你在开发环境
        上的修改，现在，可以在生产环境中更新你的代码了（例如，如果你使用Subversion，执行svn update。
        4.  重新启动Web server，使修改生效。
        
            让我们实践下，比如添加一个num_pages字段到第五章中Book模型。首先，我们会把开发环境中的模型改成
            如下形式：
            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)
                def __unicode__(self):
                    return self.title
            (注意 阅读第六章的“设置可选字段”以及本章下面的“添加非空列”小节以了解我们在这里添
            加blank=True和null=True的原因。)
            然后，我们运行命令manage.py sqlall books 来查看CREATE TABLE语句。 语句的具体内容取决与你所使用
            的数据库， 大概是这个样子：
            CREATE TABLE "books_book" (
                "id" serial NOT NULL PRIMARY KEY,
                "title" varchar(100) NOT NULL,
                "publisher_id" integer NOT NULL REFERENCES "books_publisher" ("id"),
                "publication_date" date NOT NULL,
                "num_pages" integer NULL
            );
            新加的字段被这样表示：
            "num_pages" integer NULL
            接下来，我们要在开发环境上运行数据库客户端，如果是PostgreSQL，运行 psql,，然后，我执行如下语句。
            ALTER TABLE books_book ADD COLUMN num_pages integer NULL;
            添加 NULL 字段
            
           
            >>> from mysite.books.models import Book
            >>> Book.objects.all()[:5]
            如果没有异常发生，我们将切换到生产服务器，然后在生产环境的数据库中执行命令ALTER TABLE 然后我们更新
            生产环境中的模型，最后重启web服务器。
    B 删除字段
        删除字段，然后重新启动你的web服务器。
        用以下命令从数据库中删除字段：
        ALTER TABLE books_book DROP COLUMN num_pages;


    C  删除多对多关联字段
        从你的模型中删除ManyToManyField，然后重启web服务器。
        用下面的命令从数据库删除关联表：
        DROP TABLE books_book_authors;
    
    D  删除模型
   
        从文件中删除你想要删除的模型，然后重启web 服务器models.py
        然后用以下命令从数据库中删除表：
        DROP TABLE books_book;
        当你需要从数据库中删除任何有依赖的表时要注意（也就是任何与表books_book有外键的表 ）。




4 Managers
    在语句Book.objects.all()中，objects是一个特殊的属性，需要通过它查询数据库。在第5章，我们只是简要地说这是模块的manager 。
    模块manager是一个对象，Django模块通过它进行数据库查询。 
    每个Django模块至少有一个manager，你可以创建自定义manager以定制数据库访问。
    下面是你创建自定义manager的两个原因： 增加额外的manager方法，和/或修改manager返回的初始QuerySet。


    1）增加额外的Manager方法
        增加额外的manager方法是为模块添加表级功能的首选办法。 （至于行级功能，也就是只作用于模型对象实例
        的函数，一会儿将在本章后面解释。）
        例如,我们为Book模型定义了一个title_count()方法，它需要一个关键字，返回包含这个关键字的书的数量。


        # models.py
        from django.db import models
        # ... Author and Publisher models here ...
        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 = BookManager()
            def __unicode__(self):
                return self.title
                
        有了这个manager，我们现在可以这样做：
        >>> Book.objects.title_count('Django')
        4


        下面是编码该注意的一些地方：
        A 我们建立了一个BookManager类，它继承了django.db.models.Manager。这个类只有一个title_count()方法，用来做统计。 
        注意，这个方法使用了self.filter()，此处self指manager本身。


        B 我们把BookManager()赋值给模型的objects属性。 它将取代模型的默认manager（objects）如果我们
        没有特别定义，它将会被自动创建。 我们把它命名为objects，这是为了与自动创建的manager保持一致。


        C 为什么我们要添加一个title_count()方法呢?是为了将经常使用的查询进行封装，这样我们就不必重复编码了。
        
    2)修改初始Manager QuerySets
        
        manager的基本QuerySet返回系统中的所有对象。 例如,`` Book.objects.all()`` 返回数据库book中的所有书本。
        我们可以通过覆盖Manager.get_query_set()方法来重写manager的基本QuerySet。 get_query_set()按照你的要求返回一个QuerySet。
        例如,下面的模型有两个manager。一个返回所有对像，另一个只返回作者标题The Django Book的书。
        
        class BookManager(models.Manager):
            def title_count(self, keyword):
                return self.filter(title__icontains=keyword).count()
                
        class DahlBookManager(models.Manager):
            def get_query_set(self):
                return super(DahlBookManager, self).get_query_set().filter(title='The Django Book')
                
        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 = BookManager()
            dahl_objects = DahlBookManager()
            def __unicode__(self):
                return self.title
            
        在这个示例模型中,Book.objects.all()返回了数据库中的所有书本,而Book.dahl_objects.all()只返回了一本. 
        注意我们明确地将objects设置成manager的实例，因为如果我们不这么做，那么唯一可用的manager就将是dah1_objects。
        当然,由于get_query_set()返回的是一个QuerySet对象，所以我们可以使用filter()，exclude()和其他一切
        QuerySet的方法。 像这些语法都是正确的：


        Book.dahl_objects.all()
        Book.dahl_objects.filter(title='The Django Book')
        Book.dahl_objects.count()


        这个例子也指出了其他有趣的技术： 在同一个模型中使用多个manager。
        只要你愿意，你可以为你的模型添加多个manager()实例。 
        这是一个为模型添加通用滤器的简单方法。
        class MaleManager(models.Manager):
            def get_query_set(self):
                return super(MaleManager, self).get_query_set().filter(sex='M')
        class FemaleManager(models.Manager):
            def get_query_set(self):
                return super(FemaleManager, self).get_query_set().filter(sex='F')
        class Person(models.Model):
            first_name = models.CharField(max_length=50)
            last_name = models.CharField(max_length=50)
            sex = models.CharField(max_length=1, choices=(('M', 'Male'), ('F', 'Female')))
            people = models.Manager()
            men = MaleManager()
            women = FemaleManager()
        这个例子允许你执行`` Person.men.all()`` ，`` Person.women.all()`` ，`` Person.people.all()`` 查询，生成你
        想要的结果。
        
        如果你使用自定义的Manager对象，请注意，Django遇到的第一个Manager(以它在模型中被定义的位置为准)
        会有一个特殊状态。 Django将会把第一个Manager 定义为默认Manager ，Django的许多部分(但是不包括
        admin应用)将会明确地为模型使用这个manager。
        结论是，你应该小心地选择你的默认manager。因为覆盖get_query_set() 了，你可能接受到一个无用的返回对像，你必须避免这种情况。




5 模型方法


    为了给你的对像添加一个行级功能，那就定义一个自定义方法。 
    有鉴于manager经常被用来用一些整表操作（table-wide），模型方法应该只对特殊模型实例起作用。
    这是一项在模型的一个地方集中业务逻辑的技术。
    
    from django.contrib.localflavor.us.models import USStateField
    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)
        state = USStateField() # Yes, this is U.S.‐centric...
        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 "Post‐boomer"
        def is_midwestern(self):
            "Returns True if this person is from the Midwest."
            return self.state in ('IL', 'WI', 'MI', 'IN', 'OH', 'IA', 'MO')
        def _get_full_name(self):
            "Returns the person's full name."
            return u'%s %s' % (self.first_name, self.last_name)
        full_name = property(_get_full_name)
        
    例子中的最后一个方法是一个property。 想了解更多关于属性的信息请访
    问http://www.python.org/download/releases/2.2/descrintro/#property
    
    这是用法的实例：
    >>> 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.is_midwestern()
    True
    >>> p.full_name  # Note this isn't a method ‐‐ it's treated as an attribute
    u'Barack Obama'




6 执行原始SQL查询


    有时候你会发现Django数据库API带给你的也只有这么多，那你可以为你的数据库写一些自定义SQL查询。 
    你可以通过导入django.db.connection对像来轻松实现，它代表当前数据库连接。 
    要使用它，需要通过connection.cursor()得到一个游标对像。 然后，使用cursor.execute(sql, [params])来执行SQL语句，使
    用cursor.fetchone()或者cursor.fetchall()来返回记录集。
  
    connection和cursor几乎实现了标准Python DB-API，
    你可以访问` http://www.python.org/peps/pep-0249.html <http://www.python.org/peps/pep-0249.html>`__来获取更多信息。 
    如果你对Python DB-API不熟悉，请注意在cursor.execute() 的SQL语句中使用`` “%s”`` ，而不要在SQL内直接添加参数。 如果你使
    用这项技术，数据库基础库将会自动添加引号，同时在必要的情况下转意你的参数。
    
    不要把你的视图代码和django.db.connection语句混杂在一起，
    把它们放在自定义模型或者自定义manager法中是个不错的主意。 比如，上面的例子可以被整合成一个自定义manager方法，就像这样：
    from django.db import connection, models
    def get_first_name(self, last_name):
        cursor = connection.cursor()
        cursor.execute("""
            SELECT DISTINCT first_name
            FROM books_author
            WHERE last_name = %s""", [last_name])
        return [cursor.fetchone()]
        
        
    然后这样使用:
    >>> Author.objects.get_first_name('Holovaty') 
    [(u'Apress',)]
    
7 与遗留数据库整合
    Django的数据库层从Python代码生成SQL schemas—但是对于遗留数据库，你已经拥有SQL schemas. 
    这种情况,你需要为已经存在的数据表创建model. 为此,Django自带了一个可以通过读取您的数据表结构来生成
    model的工具. 该辅助工具称为inspectdb,你可以通过执行manage.py inspectdb来调用它.


    使用 inspectdb
    python manage.py inspectdb
    inspectdb工具自省你配置文件指向的数据库，针对每一个表生成一个Django模型，然后将这些Python模型的
    代码显示在系统的标准输出里面。
    下面是一个从头开始的针对一个典型的遗留数据库的整合过程。 两个前提条件是安装了Django和一个传统数
    据库。


    1 通过运行django-admin.py startproject mysite (这里 mysite 是你的项目的名字)建立一个Django项目。
    
    2 编辑项目中的配置文件, mysite/settings.py ,告诉Django你的数据库连接参数和数据库名。 
    
    3 通过运行 python mysite/manage.py startapp myapp (这里 myapp 是你的应用的名字)创建一个Django应
    用。 这里我们使用myapp 做为应用名。
    
    4 运行命令 python mysite/manage.py inspectdb。这将检查DATABASE_NAME 数据库中所有的表并打印出为每
    张表生成的模型类。 看一看输出结果以了解inspectdb能做些什么。
    
    5 将标准shell的输出重定向，保存输出到你的应用的 models.py 文件里：
    python mysite/manage.py inspectdb > mysite/myapp/models.py
    
    6 编辑 mysite/myapp/models.py 文件以清理生成的 models 并且做一些必要的自定义。 
    
    清理生成的Models
    
        如你可能会预料到的，数据库自省不是完美的，你需要对产生的模型代码做些许清理。 这里提醒一点关于处理生成 models 的要点:
        
        1) 数据库的每一个表都会被转化为一个model类 (也就是说，数据库的表和model 类之间是一对一的映射)。
        这意味着你需要为多对多连接的表，重构其models 为 ManyToManyField 的对象。


        2)所生成的每一个model中的每个字段都拥有自己的属性，包括id主键字段。 但是，请注意，如果某个model
        没有主键的话，那么Django会自动为其增加一个id主键字段。 这样一来，你也许希望移除这样的代码行。
        id = models.IntegerField(primary_key=True)
        这样做并不是仅仅因为这些行是冗余的，而且如果当你的应用需要向这些表中增加新记录时，这些行会导
        致某些问题。
        
        3)每一个字段类型，如CharField、DateField， 是通过查找数据库列类型如VARCHAR,DATE来确定的。如果
        inspectdb无法把某个数据库字段映射到model字段上，它会使用TextField字段进行代替，并且会在所生成
        model字段后面加入Python注释“该字段类型是猜的”。 对这要当心，如果必要的话，更改字段类型。
        
        4)如果你的数据库中的某个字段在Django中找不到合适的对应物，你可以放心的略过它。
        Django模型层不要求必须导入你数据库表中的每个列。
        
        5)如果数据库中某个列的名字是Python的保留字（比如pass、class或者for等），inspectdb会在每个属性名
        后附加上_field，并将db_column属性设置为真实的字段名（也就是pass,class或者for等）。
        例如，某张表中包含一个INT类型的列，其列名为for，那么所生成的model将会包含如下所示的一个字段：
        for_field = models.IntegerField(db_column='for')
        inspectdb 会在该字段后加注 ‘字段重命名，因为它是一个Python保留字’ 。
        
        6)如果数据库中某张表引用了其他表（正如大多数数据库系统所做的那样），你需要适当的修改所生成model
        的顺序，以使得这种引用能够正确映射。 
        例如，model Book拥有一个针对于model Author的外键，那么后
        者应该先于前者被定义。如果你想创建一个指向尚未定义的model的关系，那么可以使用包含model名的字
        符串，而不是model对象本身。
        
        7)对于PostgreSQL,MySQL和SQLite数据库系统，inspectdb能够自动检测出主键关系。 也就是说，它会在合
        适的位置插入primary_key=True。
        而对于其他数据库系统，你必须为每一个model中至少一个字段插入这样的语句，
        因为Django的model要求必须拥有一个primary_key=True的字段。
        
        8)外键检测仅对PostgreSQL，还有MySQL表中的某些特定类型生效。
        至于其他数据库，外键字段将在假定其为INT列的情况下被自动生成为IntegerField。
        
    

    附录：利用MYSQL数据库的实验结果

Microsoft Windows XP [版本 5.1.2600]
(C) 版权所有 1985-2001 Microsoft Corp.


E:\ChromeDown\depot>E:\ChromeDown\depot>cd E:\CODE_SVN\pysrc


E:\CODE_SVN\pysrc>django-admin.py startproject mysite
E:\CODE_SVN\pysrc\mysite>python manage.py shell
Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from django.db import connection
>>> cursor = connection.cursor()
>>> exit()


E:\CODE_SVN\pysrc\mysite>python manage.py startapp books
E:\CODE_SVN\pysrc\mysite>python manage.py validate
0 errors found
E:\CODE_SVN\pysrc\mysite>python manage.py sqlall books
BEGIN;
CREATE TABLE `books_publisher` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(30) NOT NULL,
    `address` varchar(50) NOT NULL,
    `city` varchar(60) NOT NULL,
    `state_province` varchar(30) NOT NULL,
    `country` varchar(50) NOT NULL,
    `website` varchar(200) NOT NULL
)
;
CREATE TABLE `books_author` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `first_name` varchar(30) NOT NULL,
    `last_name` varchar(40) NOT NULL,
    `email` varchar(75) NOT NULL
)
;
CREATE TABLE `books_book_authors` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `book_id` integer NOT NULL,
    `author_id` integer NOT NULL,
    UNIQUE (`book_id`, `author_id`)
)
;
ALTER TABLE `books_book_authors` ADD CONSTRAINT `author_id_refs_id_9e7e386` FOREIGN KEY (`author_id`) REFERENCES `books_author` (`id`);
CREATE TABLE `books_book` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `title` varchar(100) NOT NULL,
    `publisher_id` integer NOT NULL,
    `publication_date` date NOT NULL
)
;
ALTER TABLE `books_book` ADD CONSTRAINT `publisher_id_refs_id_3a4d8b45` FOREIGN KEY (`publisher_id`) REFERENCES `books_publisher` (`id`);
ALTER TABLE `books_book_authors` ADD CONSTRAINT `book_id_refs_id_30430d9e` FOREIGN KEY (`book_id`) REFERENCES `books_book` (`id`);
CREATE INDEX `books_book_22dd9c39` ON `books_book` (`publisher_id`);
COMMIT;


E:\CODE_SVN\pysrc\mysite>python manage.py  syncdb
Creating tables ...
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_user_permissions
Creating table auth_user_groups
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table books_publisher
Creating table books_author
Creating table books_book_authors
Creating table books_book


You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): no
Installing custom SQL ...
Installing indexes ...
No fixtures found.






E:\CODE_SVN\pysrc\mysite>python manage.py  shell
Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from books.models import Publisher
>>> p1 = Publisher(name='Apress', address='2855 Telegraph Avenue',city='Berkeley', state_province='CA', country='U.S.A.',website='http://www.apress.com/')
>>> p1.save()
>>> p2 = Publisher(name="O'Reilly", address='10 Fawcett St.',
... city='Cambridge', state_province='MA', country='U.S.A.',
... website='http://www.oreilly.com/')
>>> >>> p2.save()
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Publisher object>, <Publisher: Publisher object>]
>>> exit()










E:\CODE_SVN\pysrc\mysite>python manage.py  shell
Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from books.models import Publisher
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Apress>, <Publisher: O'Reilly>]


>>> Publisher.objects.filter(country="U.S.A.", state_province="CA")
[<Publisher: Apress>]


>>> Publisher.objects.get(name="Apress")
<Publisher: Apress>


>>> Publisher.objects.order_by("state_province", "address")
[<Publisher: Apress>, <Publisher: O'Reilly>]


>>> Publisher.objects.order_by("-name")
[<Publisher: O'Reilly>, <Publisher: Apress>]


>>> Publisher.objects.filter(country="U.S.A.").order_by("-name")
[<Publisher: O'Reilly>, <Publisher: Apress>]


>>> Publisher.objects.order_by('name')[0:2]
[<Publisher: Apress>, <Publisher: O'Reilly>]


>>> Publisher.objects.order_by('name')[0]
<Publisher: Apress>




>>> Publisher.objects.filter(id=4).update(name='Apress Publishing')
1L
>>> Publisher.objects.all().update(country='USA')
2L


>>> Publisher.objects.filter(name='Apress Publishing').delete()
>>> Publisher.objects.all()
[<Publisher: O'Reilly>]












>>> from books.models import Publisher
>>> from books.models import Author
>>> p=Author(first_name='Apress', last_name='Holovaty',email='Apress@sina.com')
>>> p.save()
>>> p.id
1L
>>> p1 = Author(first_name='Jacob', last_name='Kaplan-Moss',email='Jacob@sina.com')
>>> p1.save()
>>> p1.id
2L
>>> Author.objects.all()
[<Author: Apress Holovaty>, <Author: Jacob Kaplan-Moss>]


>>> from books.models import Book
>>> p1=Publisher.objects.get(id=2) 
>>> a1=Author.objects.get(first_name='Apress')  
>>> b1=Book(title='The Django Book',publisher=p1,publication_date='2010-5-5')  
>>> b1.save()  
>>> b1.authors.add(a1)  
>>> b1.save()


>>> p1=Publisher.objects.get(id=2) 
>>> a1=Author.objects.get(first_name='Jacob')   
>>> b1=Book(title='Dive into Python',publisher=p1,publication_date='2010-5-5')  
>>> b1.save()  
>>> b1.authors.add(a1)  
>>> b1.save()  


>>> b = Book.objects.get(id=1)
>>> b.publisher
<Publisher: O'Reilly>


>>> p = Publisher.objects.get(name='O\'Reilly')
>>> p.book_set.all()
[<Book: The Django Book>, <Book: Dive into Python>]


>>> b = Book.objects.get(id=1)
>>> b.authors.all()
[<Author: Apress Holovaty>]


>>> b.authors.filter(first_name='Adrian')
[]
>>> b.authors.filter(first_name='Apress')
[<Author: Apress Holovaty>]


>>> a = Author.objects.get(first_name='Apress', last_name='Holovaty')
>>> a.book_set.all()
[<Book: The Django Book>]
>>> exit()






E:\CODE_SVN\pysrc\mysite>python manage.py shell
Python 2.7.6 (default, Nov 10 2013, 19:24:18) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from books.models import Author
>>> Author.objects.get_first_name('Apress') 
[None]
>>> Author.objects.get_first_name('Holovaty') 
[(u'Apress',)]
>>>