在關系數據庫中設置表與表之間的關系
Many-to-one的關系
定義一個多對一的關系，用django.db.models.ForeignKey。像用其他字段類型意向方便。ForeignKey有一個必須的參數：此類關聯的model
from diango.db import models
class Manufacturer(models.Model):
pass
class Car(model.Model):
manufacturer = models.ForeignKey(Manufacturer,on_delete=models.CASCADE)
>>>
一個與自身有多對一關系的對象
models.ForeignKey('self', on_delete=models.CASCADE)
可以通過Abstract base class與多個子類建立多對一關系
products/models.py
from django.db import models
class AbstractCar(models.Model):
manufacturer = models.ForeignKey('Maufacturer',on_delete=models.CASCADE)
class Meta:
abstract = True
production/models.py
from django.db import models
from products.models import AbstractCar
class Manufacturer(models.Model):
pass
class Car(AbstractCar):
pass
class BENSCar(AbstractCar):
pass
>>>Car.manufacturer will point to `production.Manufacturer` here.
ForeignKey還接受一些其他的參數，用于定義關系。
- ForeignKey.on_delete
當一個被引用的對象被刪除的時候，Django會通過on_delete的參數模仿SQL的相關的操作
.CASCADE 當被引用的對象被刪除的時候，此引用對象也要一并執行刪除的操作
.PROTECT 禁止刪除并產生一個異常(ProtectedError)
.SET_NULL 把外鍵設置為null，規劃時此字段要設置可接受null
.SET_DEFAULT 把外鍵設置為默認值，規劃是此字段要設置一個默認值
設置其他值 采用一個方法的形式 callable
from django.conf import settings
from django.contrib.auth import get_user_model from django.db import models
def get_sentinel_user():
return get_user_model().objects.get_or_create(username='deleted')[0]
class MyModel(models.Model): user = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.SET(get_sentinel_user), )
.DO_NOTHING 什么也不做
- ForeignKey.limit_choices_to
限制字段可供選擇的范圍。參數是字典的形式或者一個Q對象
staff_member = models.ForeignKey(User,on_delete=models.CASCADE,limit_choices_to={'is_staff':True},)
限制了staff_member只有User的is_staff的字段可以作為外鍵關聯的記錄
- ForeignKey.related_name
關聯對象反向引用描述符
當一張表的多個字段指向同一張表時，會出錯。系統無法知道，通過另外一張表，訪問XXX_set屬性訪問到的是哪個屬性。這時，我們就需要為每個字段定義一個related_name屬性，另外一張表訪問這個表時，就會根據related_name的值來得到各個屬性了。
Many-to-many
定義一個Many-to-many關系使用ManyToManyField。ManyToManyField有一個比傳參數。
from django.db import models
class Topping(models):
pass
class Pizza(models.Model):
topping = models.ManyToManyField(Topping)
However, sometimes you may need to associate data with the relationship between two models.
用兩個模型的關系模型將此二者的數據聯系起來
例如：音樂家和音樂樂團之間的關系。他們是多對多的關系，但是關于這個會員資格的一些信息需要一個額外的數據模型來解釋。Django允許指定一個model來管理這種關系，設置一些字段在這個中間模型里。
from django.db import models
class Person(models.Model):
name = models.CharField(max_length=128)
def __str__(self):
return self.name
class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(Person,through='Membership')
def __str__(self):
return self.name
class Membership(models.Model):
person = models.ForeignKey(Person,on_delete=models.CASCADE)
group = models.ForeignKey(Group,on_detele=models.CASCADE)
date_joined = models.DateField()
invite_reason = models.CharField(max_length=64)
>>>其中Membership就是中間model。中間model中ForeignKey把兩個有關聯的model聯系起來
>>> 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()
<QuerySet [<Person: Ringo Starr>]>
>>> ringo.group_set.all()
<QuerySet [<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()
<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>]>
在有中間model的多對多的關系中，往常的add(),create(),set()不起作用
>>> # The following statements will not work
>>> beatles.members.add(john)
>>> beatles.members.create(name="George Harrison")
>>> beatles.members.set([john, paul, ringo, george])
只能通過創建中間Model的實例的方式添加新的關系
在查詢的時候，與普通的Many-to-Many的關系一樣
# 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))
<QuerySet [<Person: Ringo Starr]>
>>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)
>>> ringos_membership.date_joined
datetime.date(1962, 8, 16)
>>> ringos_membership.invite_reason
'Needed a new drummer.'
One-to-one relationships
用OneToOneField來定義一個一對一的關系，需要傳遞一個把綁定的model
from django.db import models
class Place(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_length=80)
def __str__(self):
return "%s the place" % self.name
class Restaurant(model.Model):
place = models.OneToOneField(Place,on_delete=models.CASCADE,primary_key=True,)
serves_hot_dogs = models.BooleanField(default=False)
serves_pizza = models.BooleanField(default=False)
def __str__(self):
return "%s the restaurant"% self.place.name
class Waiter(models.Model):
restaurant = models.ForeignKey(Restaurant,on_delete=models.CASCADE)
name = models.CharField(max_length=50)
def __str__(self):
return "%s the waiter at %s"%(self.name,self,restaurant)
p1 = Place(name='Demon Dogs',address='994 W. Fullerton')
p1.save()
p2=Place(name='Ace Hardware',address='1013 N. Ashland')
p2.save()
r = Restaurant(place=p1,serves_hot_dogs=True,serves_pizza=False)
r.save()
------
r.place
<Place: Demon Dogs the place>
p1.restaurant #由于p1與r關聯起來了，可以通過p1.resaurant的方式找到p1關聯的resaurant。
<Restaurant: Demon Dogs the restaurant>
添加一個Waiter
w = r.waiter_set.create(name='Joe')
