Djangomodel

2019-11-14 17:35:31

字體：大中小

來源：轉載

供稿：網友

通常每個model都映射到一張單獨的表，自定義model的特點:
- 每個model都是一個繼承自django.db.models.Model的class
- 每個model的attribute代表一個表的列值
- model中只包含與表列對應的field
- django會自動生成訪問數據庫的api
示例代碼:
```
from django.db import modelsclass Person(models.Model):#models是module,CharField是class    first_name = models.CharField(max_length=30)    last_name = models.CharField(max_length=30)
```
- 自動創建數據庫表，表名默認為app name_model name,可以重命名
- 自動添加id字段作為主鍵,此行為也可以改寫,相當于執行了id=models.AutoField(PRimary_key=true),如果顯示指定了其他列為primary key,則不會自動添加id列
- 每個Model都要有一個primary_key=true的field
- 要通過manage.py migrate命令創建數據庫表
關于字段(field):
- 每個字段都是Field class的子類對象,Field class是抽象類
- django通過field的類型確定表列的類型
- 確定用于顯示field的html元素
- 有效性判斷
- 字段名不能是python保留字，不能帶‘--’
common filed arguments包括不限于:
- null:默認是false，如果是true,則在數據庫表中存儲null值
- blank:默認是false,如果true,則存放空值
- choices:可以作為field值的tuple
- default:field的默認值，可以是一個值也可以是一個callable object
- primary_key:如果是ture,這個field是model的primary key
- db_column:field對應的數據庫列名
- db_index:為這個field創建索引
- unique:如果是true，field的值必須是唯一的
- help_text:幫助信息

model之間的關系，也是表之間的關系

多對一:使用ForeignKey類，可以定義自身對自身的多對一關系

#多對一:ForeignKey類from django.db import modelsclass Manufacturer(models.Model):    # ...    passclass Car(models.Model):    manufacturer = models.ForeignKey(Manufacturer)    # ...

對對多:ManyToManyField class,可以定義自身對自身的多對多的關系

#多對多:ManyToManyField class,在Topping或者Pizza中定義均可from django.db import modelsclass Topping(models.Model):    # ...    passclass Pizza(models.Model):    # ...    toppings = models.ManyToManyField(Topping)

可以使用intermediate model管理多對多關系，指定其他field,示例代碼:

from django.db import modelsclass Person(models.Model):    name = models.CharField(max_length=128)    def __str__(self):                    return self.nameclass Group(models.Model):    name = models.CharField(max_length=128)    #through參數指向的就是intermediate class    members = models.ManyToManyField(Person, through='Membership')    def __str__(self):                     return self.nameclass Membership(models.Model):    person = models.ForeignKey(Person)    group = models.ForeignKey(Group)    #可以指定其他field 描述兩者之間的關系    date_joined = models.DateField()    invite_reason = models.CharField(max_length=64)

intermediate class的限制條件:
- 必須包含指向兩個關系類的foreignkey
- 自身指向自身的多對多關系，應該設置兩個指向同一model的foreignkey
- 自身指向自身的多對多關系，ManyToManyField.symmetrical必須為false

一對一:OneToOneField class,可以定義自身指向自身的一對一關系

自定義field type:需要繼承models.Field
Meta options:使用class Meta為model定義metadata,django已經定義了很多Meta option字段，如

ordering:排序字段
app_label: app name
db_table:model對應的數據庫表名
abstract指定該類為抽象類
managed:默認為true,django會為model創建數據庫表，為false則不會創建
proxy:指定proxy model

from django.db import modelsclass Ox(models.Model):    horn_length = models.IntegerField()    class Meta:        #排序字段         ordering = ["horn_length"]        verbose_name_plural = "oxen"        #指定存放model的database table        db_table="myOx"

Model常用的屬性和方法:
- Model.objects:數據庫查詢的接口，用于返回model instance
- get_absolute_url():生成對象的url,在admin site會使用到

重寫已定義Model方法，一定要調用基類的該方法，否則會改變默認行為，示例代碼:

from django.db import modelsclass Blog(models.Model):    name = models.CharField(max_length=100)    tagline = models.TextField()    def save(self, *args, **kwargs):        do_something()        #調用基類方法         super(Blog, self).save(*args, **kwargs) # Call the "real" save() method.        do_something_else()

執行自定義sql語句:語法為Manager.raw(raw_query,params=None,translations=None):

#兩者效果一樣Person.objects.raw('SELECT * FROM myapp_person')Person.objects.all()

定義抽象類:在Meta class中定義abstract=true,抽象類不能創建數據庫表，且抽象類中的字段名與其子類中的字段名不能相同。另外Meta class也可以繼承

from django.db import modelsclass CommonInfo(models.Model):    # ...    class Meta:        abstract = True        ordering = ['name']class Student(CommonInfo):    # django會自定把abstract設為false,所以Student不是抽象類    class Meta(CommonInfo.Meta):        db_table = 'student_info'

multi-table 繼承:子model與父model間通過隱式的OneToOneField關聯，每個model對應單獨的表。顯示的OneToOneField會占用ForeignKey或ManyToManyField默認的related_name值，如果在子類中還要使用ForeignKey或者ManyToManyField需要顯示指定related_name的值

from django.db import modelsclass Place(models.Model):    name = models.CharField(max_length=50)    address = models.CharField(max_length=80)class Restaurant(Place):    serves_hot_dogs = models.BooleanField(default=False)    serves_pizza = models.BooleanField(default=False)class Supplier(Place):    #需要顯示指定related_name參數    customers = models.ManyToManyField(Place,related_name='provider')

關于related_name以及relatd objects:如果在一個model中通過ForeignKey,OneToOneField或者ManyToManyField定義了relationship,relationship的另一端就是related objects.model可以直接訪問related model，related model通過related_name可以訪問model，related_name默認的名字是modelclassname_set,是一個Manager對象，示例代碼:

from django.db import modelsclass Blog(models.Model):    name = models.CharField(max_length=100)    tagline = models.TextField()    def __str__(self):                     return self.nameclass Entry(models.Model):       #blog 是related object    blog = models.ForeignKey(Blog)    headline = models.CharField(max_length=255)    body_text = models.TextField()    pub_date = models.DateField()    def __str__(self):                      return self.headlineb = Blog.objects.get(id=1)b.entry_set.all() # Returns all Entry objects related to Blog.# b.entry_set is a Manager that returns QuerySets.b.entry_set.filter(headline__contains='Lennon')b.entry_set.count()

要注意的問題:

抽象類中定義了relationship時，如果要顯示指定related_name，則抽象類的多個子類會都包含相同的related_name會導致錯誤，正確的方式是在related_name中包含‘%(app_label)s’和’%(class)s’,app_label會用app name替換，class用class name替換

from django.db import modelsclass Base(models.Model):    m2m = models.ManyToManyField(OtherModel, related_name="%(app_label)s_%(class)s_related")    class Meta:        abstract = Trueclass ChildA(Base):    passclass ChildB(Base):    pass#如果related_name指定了固定名字如"refer",那么m2m.refer無法確定是引用ChildA還是ChildB，如果
#Base類中隱式指定related_name,則不會有錯誤，ChildA中的related_name默認為childa_set,ChildB中
#related_name默認為childb_set

Proxy models:如果需要改變一個model的behavior，如添加新方法，改變默認的manager等，不需要添加新數據時可以使用proxy model.創建，刪除，更新model數據都同使用original model一樣會被保存。區別是在proxy model中改變默認的ordering,manager等則不會改變original model. original model的所有實例都可以在Proxy model中訪問，反之亦然。對于非抽象model類，proxy model只能繼承一個model,對于抽象model類，如果抽象類中沒有field則可以繼承任意多個model
```
from django.db import modelsclass Person(models.Model):    first_name = models.CharField(max_length=30)    last_name = models.CharField(max_length=30)class MyPerson(Person):    class Meta:        #定義proxy model的方法        proxy = True        ordering = ["last_name"]    def do_something(self):        # ...        pass #可以在proxy model中訪問original model實例，反之亦然 p = Person.objects.create(first_name="foobar") MyPerson.objects.get(first_name="foobar")
```
```
 
```