Django 1.0 中文文档-----模型语法

编写模型

 

一个模型是单独的明确的数据源，他包括必要的字段和数据存储行为，通常一个模型对应数据库里的一个表。

 

基本上：

• 每个模型都是django.db.models.Model的一个子类
• 每个模型属性都描述了一个数据库的字段
• django提供了一套自动的数据库操作API

例子

 

这个例子定义了一个Person，有first_name 和 last_name 两个字段

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

 

Person 将会创建一个数据库表，如：

 

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

 

 

一些注意

• 表名默认自动命名为myapp_person，当然这个也可以由我们自己自定义
• ID字段是自动添加的主键字段，这个也可以自定义覆盖
• 生成的SQL脚本会根据使用的数据库不通而有所不同

使用模型

 

定义好模型后，我们需要告诉DJANGO使用他，在settings.py的INSTALLED_APPS 加入

 

 

INSTALLED_APPS = (
    #...
    'mysite.myapp',
    #...
)

 

然后执行命令

 

 

 manage.py syncdb.

 

字段

 

这是模型中最重要的部分,字段是定义为属性类

 

 

class Musician(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    instrument = models.CharField(max_length=100)

class Album(models.Model):
    artist = models.ForeignKey(Musician)
    name = models.CharField(max_length=100)
    release_date = models.DateField()
    num_stars = models.IntegerField()

 

字段类型

 

每个模型里的字段都要实例化一个合适的字段类，django通过字段类确定一些信息

 

• 数据库字段类型 
• Django管理接口组件
• 最小值验证

Django提供了很多字段类型

 

字段选项

 

每个字段都有一些参数，例如CharField  需要  max_length 来指定数据库VARCHAR 列的字段长度

 

null

允许为空.

blank

允许为空白

choices

          选择集合，如下

         

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)

 

 

default

默认值

help_text

在表单字段下显示的关于本字段的说明信息（管理接口） 

primary_key

主键

  unique

  唯一约束

 

自动递增主键

 

每个模型默认有 id = models.AutoField(primary_key=True)

详细字段名

first_name = models.CharField("Person's first name", max_length=30)

如果是ForeignKey, ManyToManyField OneToOneField 这类字段的标签

 

sites = models.ManyToManyField(Site, verbose_name="list of sites")

 

 

关系

 

关系数据库功能在于建立表间关系，Django提供了三种字段类型建立关系，many-to-one, many-to-many 和 one-to-one

 

many-to-one（多对一） 关系

 

要定义一个多对一关系，使用ForeignKey. 使用方法和其他字段使用方式一样。

ForeignKey 需要一个定位参数，即要关联的类。

例如一个Car模型有一个Manufacturer，很多个Car出自一个Manufacturer，那么使用如下方式定义

 

 

 

class Manufacturer(models.Model):
    # ...

class Car(models.Model):
    manufacturer = models.ForeignKey(Manufacturer)
    # ...

 

Many-to-many（多对多） 关系

 

要定义一个多对一关系，使用ManyToManyField.使用方法和其他字段使用方式一样。

ManyToManyField需要一个定位参数，即要关联的类。

 

例如，pizza包含多种配料，一种配料用于多种PIZZA，可以如下表现：

 

class Topping(models.Model):
    # ...

class Pizza(models.Model):
    # ...
    toppings = models.ManyToManyField(Topping)

 

和ForeignKey一样也可以建立递归关系。

上面代码里topping建议用复数形势。

ManyToManyField也支持其他参数选项，定义描述关系。

 

额外的many-to-many字段关系

 

当你只处理简单的多对多关系时，如混合并匹配pizzas和配料，你需要一个标准的ManyToManyField 。然而，有时你可能关联两个模型之间的数据。

 

举个例子追踪一个乐队音乐家的归属，有一个人和组的多对多关系，你可以用ManyToManyField 描述，然而，有好多会员（Membership）详细资料需要采集，如加入乐队的时间。在这些情况下，Django允许你指定模型控制多对多关系，你可以为中间模型分配额外字段，使用through 参数指向一个中介，我们这个例子代码如下：

 

class Person(models.Model):
    name = models.CharField(max_length=128)

    def __unicode__(self):
        return self.name

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

    def __unicode__(self):
        return self.name

class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

 

中间模型有一些约束

 

• 中间模型必须包含一个且只有一个外键关联指定目标模型(中间模型多对多字段的模型,这里是person)，否则会报错。
• 中间模型必须包含一个且只有一个外键关联指定源模型(这里是Group模型)，否者会报错。
• 通过中间模型，自身多对多关系是例外的。在这种情况下，两个外键相同的模式是允许的，但他们将被视为两个（不同的）双方的多对多关系。
• 当定义多对多关系时，用中间模型你必须用symmetrical=False

现在你已经建立好了多对多关系使用中间模型， 你开始创建多对多关系，建立实例

 

>>> ringo = Person.objects.create(name="Ringo Starr")
>>> paul = Person.objects.create(name="Paul McCartney")
>>> beatles = Group.objects.create(name="The Beatles")
>>> m1 = Membership(person=ringo, group=beatles,
...     date_joined=date(1962, 8, 16),
...     invite_reason= "Needed a new drummer.")
>>> m1.save()
>>> beatles.members.all()
[<Person: Ringo Starr>]
>>> ringo.group_set.all()
[<Group: The Beatles>]
>>> m2 = Membership.objects.create(person=paul, group=beatles,
...     date_joined=date(1960, 8, 1),
...     invite_reason= "Wanted to form a band.")
>>> beatles.members.all()
[<Person: Ringo Starr>, <Person: Paul McCartney>]

 

和通常的多对多字段不同，你不能使用add, create, 或 assignment 创建关系

 

# 这样不行
>>> beatles.members.add(john)
# 这样也不行
>>> beatles.members.create(name="George Harrison")
# 这样不行
>>> beatles.members = [john, paul, ringo, george]

 为什么呢？你不能在Person 和 Group 之间创建关系，你需要指定所有详细资料给Membership 来建立关系，add, create 和assignment不能提供额外的信息，所以当用中间模型的多对多关系时他们不能被使用

 

remove 方法也是不能用的，clear来代替删除方法。

 

 

# Beatles have broken up
>>> beatles.members.clear()

 

一旦你确定了中间模型的多对多关系，你可以关系查询。

 

 

# Find all the groups with a member whose name starts with 'Paul'
>>> Groups.objects.filter(members__name__startswith='Paul')
[<Group: The Beatles>]

 

使用中间模型，你可以使用他的属性来查询

 

# Find all the members of the Beatles that joined after 1 Jan 1961
>>> Person.objects.filter(
...     group__name='The Beatles',
...     membership__date_joined__gt=date(1961,1,1))
[<Person: Ringo Starr]

 

一对一关系

 

要定义一个多对一关系，使用OneToOneField. 使用方法和其他字段使用方式一样。

OneToOneField 需要一个定位参数，即要关联的类。

 

举个例子，如果你要建立一个地点数据库，你需要建立漂亮标准的资料，如地址电话等，然后如果你要建立一个餐馆数据库在地区之上，你需要替换重复的字段，和地点建立一对一关系 

 

 

模型跨文件

 

模型的关联可以跨两个应用程序之间，可以在顶部输入其他模型，例如：

 

from mysite.geography.models import ZipCode

class Restaurant(models.Model):
    # ...
    zip_code = models.ForeignKey(ZipCode)

 

字段名字规则

 

django字段有两个命名规则：

 

   1.字段名字不能是python语言的预定义关键字，如‘pass’，否者会编译出错

     

class Example(models.Model):
    pass = models.IntegerField() # 'pass' is a reserved word!

 

   2.字段名不能包含多于一个连着的下划线，这是避免和django的查询语法规则冲突。

   

class Example(models.Model):
    foo__bar = models.IntegerField() # 'foo__bar' has two underscores!

 

 

 

自定义字段类型

 

在新的django 1.0版本，我们可以自己定义模型的字段类型，这个可以详细参考自定义字段类型文档部分。

 

元选项

 

通过内部类的方式给你的模型提供元数据。

 

class Ox(models.Model):
    horn_length = models.IntegerField()

    class Meta:
        ordering = ["horn_length"]
        verbose_name_plural = "oxen"

 

模型元数据不是字段，像指令选项（排序），数据表名，可读的单数复数，这些参数不是必要的。

 

模型方法

 

可一个为模型添加自定义方法，让模型有逻辑功能是比较有价值的，例如下面模型有些自定的方法：

 

from django.contrib.localflavor.us.models import USStateField

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 America-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 "Pre-boomer"
        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 '%s %s' % (self.first_name, self.last_name)
    full_name = property(_get_full_name)

 

最后一个方法被设置成了属性，关于属性的特性说明可查看相关资料。

 

你也可以覆盖默认的一些方法

 

__unicode__()  unicode方式返回字符

get_absolute_url() 获取觉得链接

 

 

覆盖预定义的模型方法

 

有时候我们需要重新实现模型的一些方法 如save() 和 delete()

 

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def save(self, force_insert=False, force_update=False):
        do_something()
        super(Blog, self).save(force_insert, force_update) # Call the "real" save() method.
        do_something_else()

 

 

也可以这样

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def save(self, force_insert=False, force_update=False):
        if self.name == "Yoko Ono's blog":
            return # Yoko shall never have her own blog!
        else:
            super(Blog, self).save(force_insert, force_update) # Call the "real" save() method.

 

执行自定义SQL

 

当需要执行自定义SQL时，可以如下方式：

def my_custom_sql(self):
    from django.db import connection
    cursor = connection.cursor()
    cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])
    row = cursor.fetchone()
    return row

 

模型的继承

 

django的模型继承和python的标准类的继承是一样的，如果多个模型有同样部分，可以将共同的部分作为父类继承。

 

抽象类 

 

当你想将一些共用信息加入到一些模型里时抽象类就显得很重要了，你编写一个基本类并设置abstract=True，这样这个模型就不会被创建成表 

 

class CommonInfo(models.Model):
    name = models.CharField(max_length=100)
    age = models.PositiveIntegerField()

    class Meta:
        abstract = True

class Student(CommonInfo):
    home_group = models.CharField(max_length=5)

 

元继承 

 

class CommonInfo(models.Model):
    ...
    class Meta:
        abstract = True
        ordering = ['name']

class Student(CommonInfo):
    ...
    class Meta(CommonInfo.Meta):
        db_table = 'student_info'

 

注意related_name 

 

如果你在用ForeignKey 或 ManyToManyField,时使用了related_name属性，你需要提供一个唯一的reverse name

 

class Base(models.Model):
    m2m = models.ManyToMany(OtherModel, related_name="%(class)s_related")

    class Meta:
        abstract = True

class ChildA(Base):
    pass

class ChildB(Base):
    pass

 

 

多表继承

 

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField()
    serves_pizza = models.BooleanField()

 

 

>>> Place.objects.filter(name="Bob's Cafe")
>>> Restaurant.objects.filter(name="Bob's Cafe")

>>> p = Place.objects.filter(name="Bob's Cafe")
# If Bob's Cafe is a Restaurant object, this will give the child class:
>>> p.restaurant
<Restaurant: ...>