SamhlaLink to this heading#

Cineálacha réimseLink to this heading#

Ba chóir go mbeadh gach réimse i do mhúnla mar shampla den rang oiriúna:class: ~Django.db.Models.Field. Úsáideann Django na cineálacha ranga allamuigh chun cúpla rud a chinneadh:

• An cineál colún, a insíonn don bhunachar sonraí cén cineál sonraí atá le stóráil (m.sh. INTEGER, VARCHAR`, TEXT`).

• </ref/forms/widgets> <input type="text"><select>An réamhshocraithe HTML:doc: giuirléid le húsáid agus réimse foirme á rindreáil (m.sh. , , ``).

• Na ceanglais bailíochtaithe íosta, a úsáidtear i riarachán Django agus i bhfoirmeacha a ghintear go huathoibríoch.

<model-field-types>Loingíonn Django le mórán cineálacha réimse ionsuite; is féidir leat an liosta iomlán a fháil in:ref: tagairt réimse samhail `. Is féidir leat do réimsí féin a scríobh go héasca mura ndéanann cinn ionsuite Django an cleas; féach: doc: `/howto/custom-model-fields.

Roghanna réimseLink to this heading#

<model-field-types>Glacann gach réimse sraith áirithe d'argóintí réimsiúnacha (doiciméadaithe in:ref: tagairt réimse samhail `). Mar shampla, éilíonn :class: `~django.db.models.charfield (agus a fho-aicmí) a:attr: ~django.db.models.charfield.max_Length argóint a shonraíonn méid an réimse bunachar sonraí VARCHAR a úsáidtear chun na sonraí a stóráil.

Tá sraith argóintí coitianta ar fáil do gach cineál réimse freisin. Tá gach ceann roghnach. Mínítear iad go hiomlán in:ref: tagairt <common-model-field-options>, ach seo achoimre tapa ar na cinn is minice a úsáidtear:

null

Má tá True, stóráilfidh Django luachanna folmha mar NULL sa bhunachar sonraí. Is é “False” réamhshocraithe.

blank

Má tá “Fíor”, ceadaítear don réimse a bheith bán. Is é “False” réamhshocraithe.

Tabhair faoi deara go bhfuil sé seo difriúil ná: attr: ~Field.null. :attr: ~Field.null a bhaineann le bunachar sonraí amháin, áit a bhaineann le bailíochtú: attr: ~Field.blank. Má tá réimse ag: attr: Blank=true <Field.blank>, ceadóidh bailíochtú foirm luach folamh a iontráil. Má tá réimse ag: attr: Blank=false <Field.blank>, beidh an réimse ag teastáil.

choices

A: Téarma: seicheamh de thúpaí 2-luach, a: term: maping, an:ref: cineál áireamha, nó inghlaonta (nach bhfuil súil ag aon argóintí agus a thugann <field-choices-enum-types>aon cheann de na formáidí roimhe seo ar ais), le húsáid mar roghanna don réimse seo. Má thugtar é seo, is bosca roghnaithe é an giuirléid fhoirme réamhshocraithe in ionad an réimse téacs caighdeánach agus teorannfaidh sé roghanna leis na roghanna a thugtar.

Breathnaíonn liosta roghanna mar seo:

Code

YEAR_IN_SCHOOL_CHOICES = [
    ("FR", "Freshman"),
    ("SO", "Sophomore"),
    ("JR", "Junior"),
    ("SR", "Senior"),
    ("GR", "Graduate"),
]

Is é an chéad ghné i ngach tuple an luach a stóráilfear sa bhunachar sonraí. Taispeántar an dara gné ag giuirléid fhoirme an réimse.

Mar gheall ar shampla samhail, is féidir rochtain a fháil ar an luach taispeána do réimse le roghnaí ag baint úsáide as an modh: meth: ~django.db.models.model.get_foo_display. Mar shampla:

Code

from django.db import models


class Person(models.Model):
    SHIRT_SIZES = {
        "S": "Small",
        "M": "Medium",
        "L": "Large",
    }
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)

Python console

>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

Is féidir leat ranganna áireamh a úsáid freisin chun “roghanna” a shainiú ar bhealach gonta:

Code

from django.db import models


class Runner(models.Model):
    MedalType = models.TextChoices("MedalType", "GOLD SILVER BRONZE")
    name = models.CharField(max_length=60)
    medal = models.CharField(blank=True, choices=MedalType, max_length=10)

<field-choices>Tá samplaí breise ar fáil in:ref: `tagairt réimse samhail `.

default

An luach réamhshocraithe don réimse. Is féidir leis seo a bheith ina luach nó ina réad inghlaonta. Má tá sé inghlaoch, glaofar air gach uair a chruthaítear réad nua.

db_default

An luach réamhshocraithe ríofa bunachar sonraí don réimse. Is féidir leis seo a bheith ina luach litriúil nó ina fheidhm bunachar sonraí.

Má tá db_default` agus:attr: Field.default araon socraithe, tabharfaidh default tosaíocht agus cásanna á chruthú i gcód Python. Socrófar db_default fós ag leibhéal an bhunachar sonraí agus úsáidfear é agus sraitheanna á chur isteach lasmuigh den ORM nó nuair a chuirtear réimse nua i imirce.

help_text

Téacs breise “cabhrach” le taispeáint leis an ngiuirléid fhoirme. Tá sé úsáideach le haghaidh doiciméadú fiú mura n-úsáidtear do réimse ar fhoirm.

primary_key

Má tá True, is é an réimse seo an príomh-eochair don tsamhail.

If you don't specify primary_key=True for any fields in your model, Django will automatically add a field to hold the primary key, so you don't need to set primary_key=True on any of your fields unless you want to override the default primary-key behavior. For more, see Príomhréimsí uathoibríoch.

Tá an príomhréimse léite amháin. Má athraíonn tú luach an phríomh-eochair ar réad atá ann cheana agus ansin é a shábháil, cruthófar réad nua in éineacht leis an seancheann. Mar shampla:

Code

from django.db import models


class Fruit(models.Model):
    name = models.CharField(max_length=100, primary_key=True)

Python console

>>> fruit = Fruit.objects.create(name="Apple")
>>> fruit.name = "Pear"
>>> fruit.save()
>>> Fruit.objects.values_list("name", flat=True)
<QuerySet ['Apple', 'Pear']>

unique

Má tá “Fíor”, caithfidh an réimse seo a bheith uathúil ar fud an tábla.

Arís, níl iad seo ach tuairiscí gairid ar na roghanna réimse is coitianta. <common-model-field-options>Is féidir sonraí iomlána a fháil in:ref: `tagairt rogha réimse samhail choiteann `.

Príomhréimsí uathoibríochLink to this heading#

<django.apps.AppConfig.default_auto_field>De réir réamhshocraithe, tugann Django eochair phríomh-mhéadaithe uathoibríoch do gach samhail leis an gcineál a shonraítear in aghaidh an aip in:attr: appconfig.default_AUTO_FIELD nó ar fud an domhain sa socrú:: DEFAULT_AUTO_FIELD. Mar shampla:

id = models.BigAutoField(primary_key=True)

<Field.primary_key>Más mian leat eochair phríomhúil saincheaptha a shonrú, sonraigh: attr: primary_key=True `ar cheann de do réimsí. Má fheiceann Django go bhfuil tú socraithe go sainráite: attr: `Field.primary_key, ní chuirfidh sé an colún id` uathoibríoch leis.

Éilíonn gach samhail réimse amháin go díreach: attr: `primary_key=True <Field.primary_key>`(dearbhaithe go sainráite nó cuireadh leis go huathoibríoch).

Ainmneacha réimse VerboseLink to this heading#

Glacann gach cineál réimse, ach amháin dó:class: ~django.db.models.foreignKey, :class: ~django.db.models.manyToManyField agus:class: ~django.db.models.onetoonefield, argóint roghnach an chéad phoist - ainm fhíorúil. Mura dtugtar an t-ainm fhíorúil, cruthóidh Django é go huathoibríoch ag baint úsáide as ainm tréith an réimse, ag athrú béim go spásanna.

Sa sampla seo, is é ``"céadainm an duine” ``an t-ainm fhíoróideach:

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

Sa sampla seo, is é "céadainm" an t-ainm eolach:

first_name = models.CharField(max_length=30)

ForeignKey, ManyToManyField and OneToOneField require the first argument to be a model class, so use the verbose_name keyword argument:

poll = models.ForeignKey(
    Poll,
    on_delete=models.CASCADE,
    verbose_name="the related poll",
)
sites = models.ManyToManyField(Site, verbose_name="list of sites")
place = models.OneToOneField(
    Place,
    on_delete=models.CASCADE,
    verbose_name="related place",
)

Ní hé an coinbhinsiún chun an chéad litir den: attr: ~field.verbose_name a chaipitliú. Déanfaidh Django caipitliú go huathoibríoch an chéad litir nuair is gá dó.

CaidrimhLink to this heading#

Is léir go bhfuil cumhacht na mbunachar sonraí coibhneasta ná táblaí a bhaineann lena chéile. Cuireann Django bealaí ar fáil chun na trí chineál caidrimh bunachar sonraí is coitianta a shainiú: go leor le duine, go leor agus duine le duine.

from django.db import models


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


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

class Car(models.Model):
    company_that_makes_it = models.ForeignKey(
        Manufacturer,
        on_delete=models.CASCADE,
    )
    # ...

from django.db import models


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


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

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_delete=models.CASCADE)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=["person", "group"], name="unique_person_group"
            )
        ]

>>> 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>]>

>>> beatles.members.add(john, through_defaults={"date_joined": date(1960, 8, 1)})
>>> beatles.members.create(
...     name="George Harrison", through_defaults={"date_joined": date(1960, 8, 1)}
... )
>>> beatles.members.set(
...     [john, paul, ringo, george], through_defaults={"date_joined": date(1960, 8, 1)}
... )

>>> Membership.objects.create(
...     person=ringo,
...     group=beatles,
...     date_joined=date(1968, 9, 4),
...     invite_reason="You've been gone for a month and we miss you.",
... )
>>> beatles.members.all()
<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>, <Person: Ringo Starr>]>
>>> # This deletes both of the intermediate model instances for Ringo Starr
>>> beatles.members.remove(ringo)
>>> beatles.members.all()
<QuerySet [<Person: Paul McCartney>]>

>>> # Beatles have broken up
>>> beatles.members.clear()
>>> # Note that this deletes the intermediate model instances
>>> Membership.objects.all()
<QuerySet []>

# Find all the groups with a member whose name starts with 'Paul'
>>> Group.objects.filter(members__name__startswith="Paul")
<QuerySet [<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)
... )
<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.'

>>> ringos_membership = ringo.membership_set.get(group=beatles)
>>> ringos_membership.date_joined
datetime.date(1962, 8, 16)
>>> ringos_membership.invite_reason
'Needed a new drummer.'

Múnlaí ar fud comhaidLink to this heading#

Tá sé go hiomlán ceart go leor samhail a cheangal le ceann amháin ó aip eile. Chun seo a dhéanamh, iompórtáil an tsamhail ghaolmhar ag barr an chomhaid ina bhfuil do mhúnla sainmhínithe. Ansin, déan tagairt don rang samhail eile cibé áit is gá. Mar shampla:

from django.db import models
from geography.models import ZipCode


class Restaurant(models.Model):
    # ...
    zip_code = models.ForeignKey(
        ZipCode,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )

Alternatively, you can use a lazy reference to the related model, specified as a string in the format "app_label.ModelName". This does not require the related model to be imported. For example:

from django.db import models


class Restaurant(models.Model):
    # ...
    zip_code = models.ForeignKey(
        "geography.ZipCode",
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )

See lazy relationships for more details.

Srianta ainm réimseLink to this heading#

Cuireann Django roinnt srianta ar ainmneacha réimse samhail:

1. Ní féidir ainm réimse a bheith ina fhocal áirithe Python, toisc go mbeadh earráid comhréireachta Python mar thoradh air sin. Mar shampla:

   Text

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

2. Ní féidir níos mó ná béim amháin i ndiaidh a chéile i ainm réimse, mar gheall ar an mbealach a oibríonn comhréir cuardaigh ceisteanna Django. Mar shampla:

   Code

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

3. Ní féidir le hainm réimse deireadh a chur le béim, ar chúiseanna comhchosúla.

4. A field name cannot be check, as this would override the check framework's Model.check() method.

Is féidir na teorainneacha seo a oibriú timpeall, áfach, toisc nach gá go gcaithfidh d'ainm réimse d'ainm colún bunachar sonraí a mheaitseáil. Féach an roghna:attr: ~Field.db_Column.

Ceadaítear focail fhorchoimeádta SQL, mar shampla join`, ``, ```nó ``roghnaigh, ** mar ainmneacha réimse samhail, toisc go n-éalaíonn Django gach ainm tábla bunachar sonraí agus ainmneacha colún i ngach ceist bhunúsach SQL. Úsáideann sé comhréir luachana d'inneall bunachar sonraí áirithe.

cineálacha réimse saincheapthaLink to this heading#

Mura féidir ceann de na réimsí samhlacha atá ann cheana a úsáid chun do chuspóirí a fheistiú, nó más mian leat leas a bhaint as roinnt cineálacha colún bunachar sonraí nach bhfuil chomh coitianta, is féidir leat do rang réimse féin a chruthú. Cuirtear clúdach iomlán ar do réimsí féin a chruthú ar fáil in:doc: /howto/custom-model-fields.

Modhanna samhail réamhshainithe a shárúLink to this heading#

Tá sraith eile de:ref: modhanna samhail <model-instance-methods>`a chuimsíonn dornán iompar bunachar sonraí a bheidh uait a shaincheapadh. Go háirithe is minic a bheidh tú ag iarraidh an bealach a athrú: meth: `~Model.save agus:meth: ~Model.delete obair.

Tá saor ort na modhanna seo (agus aon mhodh samhail eile) a shárú chun iompar a athrú.

Cás úsáide clasaiceach chun na modhanna ionsuite a shárú ná más mian leat rud éigin a tharlóidh aon uair a shábhálann tú réad. Mar shampla (féach: meth: ~Model.save le haghaidh doiciméadú ar na paraiméadair a ghlacann sé leis):

from django.db import models


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

    def save(self, **kwargs):
        do_something()
        super().save(**kwargs)  # Call the "real" save() method.
        do_something_else()

Is féidir leat cosc a chur ar shábháil freisin:

from django.db import models


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

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

Tá sé tábhachtach cuimhneamh ar an modh sáraicme a ghlaoch - sin an gnó sin ``super () .save (** kwargs) `- chun a chinntiú go sábhálfar an réad sa bhunachar sonraí fós. Má dhéanann tú dearmad glaoch ar an modh sáraicme, ní tharlóidh an t-iompar réamhshocraithe agus ní dhéanfar teagmháil leis an mbunachar sonraí.

Tá sé tábhachtach freisin go dtéann tú tríd na hargóintí is féidir a chur ar aghaidh chuig an modh samhail - sin an rud a dhéanann an giotán **kwargs `. Leathnóidh Django, ó am go ham, cumais modhanna samhail ionsuite, ag cur argóintí eochairfhocal nua leis. Má úsáideann tú ``**kwargs ``i do shainmhínithe ar mhodh, ráthaítear duit go dtacóidh do chód leis na hargóintí sin go huathoibríoch nuair a chuirtear iad leis.

Más mian leat luach réimse a nuashonrú sa modh:meth: ~Model.save, b'fhéidir gur mhaith leat an réimse seo a chur leis an argóint eochairfhocal update_fields. Cinnteoidh sé seo go sábhálfar an réimse nuair a shonraítear update_fields. Mar shampla:

from django.db import models
from django.utils.text import slugify


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

    def save(self, **kwargs):
        self.slug = slugify(self.name)
        if (
            update_fields := kwargs.get("update_fields")
        ) is not None and "name" in update_fields:
            kwargs["update_fields"] = {"slug"}.union(update_fields)
        super().save(**kwargs)

Féach: ref: ref-models-update-fields le haghaidh tuilleadh sonraí.

SQL saincheaptha a fheidhmiúLink to this heading#

Patrún coitianta eile is ea ráitis SQL saincheaptha a scríobh i modhanna samhail agus modhanna leibhéal modúl. Le haghaidh tuilleadh sonraí maidir le SQL amh a úsáid, féach an doiciméadú ar:doc: using</topics/db/sql> raw SQL.

Aicmí bonn teibíLink to this heading#

Tá ranganna bonn teibí úsáideach nuair is mian leat roinnt faisnéise coitianta a chur i roinnt samhlacha eile. <meta-options>Scríobhann tú do rang bonn agus cuireann tú abstract=True sa rang:ref: `Meta `. Ní úsáidfear an tsamhail seo ansin chun aon tábla bunachar sonraí a chruthú. Ina áit sin, nuair a úsáidtear é mar bhunrang do mhúnlaí eile, cuirfear a réimsí le réimsí ranga an linbh.

Sampla:

from django.db import models


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)

Beidh trí réimse ag an tsamhail Mac Léinn ``: `ainm, aois ``agus ``grúpa_baile`. Ní féidir an tsamhail `CommonInfo ``a úsáid mar ghnáthmhúnla Django, ós rud é gur aicme bonn teibí é. Ní ghineann sé tábla bunachar sonraí ná ní bhfuil bainisteoir aige, agus ní féidir é a thionscnamh nó a shábháil go díreach.

Is féidir réimsí oidhreachta ó ranganna bonn teibí a shárú le réimse nó luach eile, nó iad a bhaint le None.

Maidir le go leor úsáidí, beidh an cineál seo oidhreachta samhail go díreach mar a theastaíonn uait. Soláthraíonn sé bealach chun faisnéis choiteann a bhaint amach ag leibhéal Python, agus ní chruthaíonn sé ach tábla bunachar sonraí amháin in aghaidh an tsamhail linbh ag leibhéal an bhunachar sonraí.

from django.db import models


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


class Student(CommonInfo):
    # ...
    class Meta(CommonInfo.Meta):
        db_table = "student_info"

from django.db import models


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

    class Meta:
        abstract = True
        ordering = ["name"]


class Unmanaged(models.Model):
    class Meta:
        abstract = True
        managed = False


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

    class Meta(CommonInfo.Meta, Unmanaged.Meta):
        pass

from django.db import models


class Base(models.Model):
    m2m = models.ManyToManyField(
        OtherModel,
        related_name="%(app_label)s_%(class)s_related",
        related_query_name="%(app_label)s_%(class)ss",
    )

    class Meta:
        abstract = True


class ChildA(Base):
    pass


class ChildB(Base):
    pass

from common.models import Base


class ChildB(Base):
    pass

Oidhreacht il-táblaLink to this heading#

Is é an dara cineál oidhreachta samhail a thacaíonn Django ná nuair a bhíonn gach samhail san ordlathas ina samhail leis féin. Freagraíonn gach samhail dá tábla bunachar sonraí féin agus is féidir é a fhiosrú agus a chruthú ina n-aonar. Tugann an caidreamh oidhreachta naisc isteach idir samhail an linbh agus gach ceann dá thuismitheoirí (trí:class: ~django.db.models.onetoonefield) a chruthaítear go huathoibríoch. Mar shampla:

from django.db import models


class 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)

Beidh na réimsí go léir de Áite ar fáil i Bialain freisin, cé go mbeidh na sonraí ina gcónaí i dtábla bunachar sonraí difriúil. Mar sin is féidir iad seo a dhéanamh:

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

Má tá Áite agat atá ina Bialain freisin, is féidir leat teacht ón réad Áite go dtí an réad Bialainne tríd an leagan beaga den ainm samhail a úsáid:

>>> p = Place.objects.get(id=12)
# If p is a Restaurant object, this will give the child class:
>>> p.restaurant
<Restaurant: ...>

Mar sin féin, mura raibh p` sa sampla thuas*ní* ina Bialann ``(cruthaíodh é go díreach mar réad ``Plac` nó gur tuismitheoir aicme éigin eile é), d'ardódh tagairt do p.restaurant` eisceacht Restaurant.doesNotExist.

Breathnaítear go huathoibríoch: class: ~django.db.models.onetoonefield ar Restaurant a nascann é le Plac mar seo:

place_ptr = models.OneToOneField(
    Place,
    on_delete=models.CASCADE,
    parent_link=True,
    primary_key=True,
)

<django.db.models.OneToOneField.parent_link>Is féidir leat an réimse sin a shárú trí do chuid féin a dhearbhú:: ~django.db.models.onetoonefield le: attr: Parent_link=True `ar ``Restaurant`.

class ChildModel(ParentModel):
    # ...
    class Meta:
        # Remove parent's ordering effect
        ordering = []

class Supplier(Place):
    customers = models.ManyToManyField(Place)

Reverse query name for 'Supplier.customers' clashes with reverse query
name for 'Supplier.place_ptr'.

HINT: Add or change a related_name argument to the definition for
'Supplier.customers' or 'Supplier.place_ptr'.

Múnlaí proxyLink to this heading#

Nuair a úsáidtear: ref: oidhreacht il-tábla <multi-table-inheritance>, cruthaítear tábla bunachar sonraí nua do gach fo-aicme de mhúnla. Is é seo de ghnáth an t-iompar atá ag teastáil, ós rud é go dteastaíonn áit ón bhfo-rang chun aon réimsí sonraí breise nach bhfuil i láthair ar an rang bonn a stóráil. Uaireanta, áfach, ní theastaíonn uait ach iompar Python samhail a athrú - b'fhéidir an bainisteoir réamhshocraithe a athrú, nó modh nua a chur leis.

Seo a bhfuil oidhreacht samhail seachfhreastalaí ann: * proxy* a chruthú don tsamhail bhunaidh. Is féidir leat cásanna den tsamhail seachfhreastalaí a chruthú, a scriosadh agus a nuashonrú agus sábhálfar na sonraí go léir amhail is dá mbeadh an tsamhail bhunaidh (neamh-sheachadaithe) á úsáid agat. Is í an difríocht ná gur féidir leat rudaí mar ordú an tsamhail réamhshocraithe nó an bainisteoir réamhshocraithe sa seachfhreastalaí a athrú, gan an bunaidh a athrú.

Fógraítear samhlacha seachfhreastalaí cosúil le gn Deir tú le Django gur samhail seachfhreastalaí é trí:attr: ~django.db.models.options.proxy tréith an aicme Meta a shocrú go True.

Mar shampla, cuir i gcás gur mhaith leat modh a chur leis an tsamhail ``Person`. Is féidir leat é a dhéanamh mar seo:

from django.db import models


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


class MyPerson(Person):
    class Meta:
        proxy = True

    def do_something(self):
        # ...
        pass

Feidhmíonn an rang MyPerson` ar an tábla bunachar sonraí céanna leis an rang Person a thuismitheoir. Go háirithe, beidh aon chásanna nua de Person inrochtana freisin trí My Person, agus a mhalairt:

>>> p = Person.objects.create(first_name="foobar")
>>> MyPerson.objects.get(first_name="foobar")
<MyPerson: foobar>

D'fhéadfá samhail seachfhreastalaí a úsáid freisin chun ordú réamhshocraithe difriúil ar mhúnla a shainiú. B'fhéidir nach mbeadh tú ag iarraidh an tsamhail Person` a ordú i gcónaí, ach ordú go rialta de réir an tréith ``last_name nuair a úsáideann tú an seachfhreastalaí:

class OrderedPerson(Person):
    class Meta:
        ordering = ["last_name"]
        proxy = True

Anois ní bheidh gnáth-cheisteanna Person` neamh-ordaithe agus ordófar ceisteanna ``OrderedPerson ag last_name.

<meta-and-multi-table-inheritance>Oifreann samhlacha seachfhreastalaí tréithe Meta: ref: `ar an mbealach céanna le samhlacha rialta `.

from django.db import models


class NewManager(models.Manager):
    # ...
    pass


class MyPerson(Person):
    objects = NewManager()

    class Meta:
        proxy = True

# Create an abstract class for the new manager.
class ExtraManagers(models.Model):
    secondary = NewManager()

    class Meta:
        abstract = True


class MyPerson(Person, ExtraManagers):
    class Meta:
        proxy = True

Oidhreacht iolrachLink to this heading#

Díreach mar atá le fo-aicmiú Python, is féidir go mhúnla Django oidhreacht ó mhúnlaí ilthuismitheoirí. Coinnigh i gcuimhne go bhfuil feidhm ag gnáthrialacha réitigh ainm Python. Is é an ché <meta-options>ad rang bonn a bhfuil ainm áirithe (e.g.:ref: Meta `) le feiceáil ann an ceann a úsá <meta-options>idtear; mar shampla, ciallaíonn sé seo má tá aicme a:ref: `Meta i iliomad tuismitheoirí, ní bheidh ach an chéad cheann le húsáid, agus déanfar neamhaird ar gach duine eile.

Go ginearálta, ní bheidh ort oidhreacht a dhéanamh ó iliomad tuismitheoirí. Is é an príomhchás úsáide ina bhfuil sé seo úsáideach ná do ranganna “measctha isteach”: réimse nó modh breise ar leith a chur le gach rang a thugann an meascán in oidhreacht. Déan iarracht d'ordlathais oidhreachta a choinneáil chomh simplí agus chomh simplí agus is féidir ionas nach mbeidh ort streachailt a dhéanamh chun oibriú amach cá as a bhfuil píosa faisnéise áirithe ag teacht.

Tabhair faoi deara go n-ardóidh earráid ag oidhreacht ó iolracha samhlacha a bhfuil príomhréimse coitianta “id” acu. Chun oidhreacht iolrach a úsáid i gceart, is féidir leat explicit:class: ~django.db.models.autofield a úsáid sna bunmhúnlaí:

class Article(models.Model):
    article_id = models.AutoField(primary_key=True)
    ...


class Book(models.Model):
    book_id = models.AutoField(primary_key=True)
    ...


class BookReview(Book, Article):
    pass

Nó bain úsáid as sinsear coiteann chun an: class: ~django.db.models.autofield a shealbhú. Éilíonn sé seo úsáid a bhaint as explicit:class: ~django.db.models.onetoonefield ó gach samhail tuismitheora go dtí an sinsear coiteann chun coimhlint idir na réimsí a ghineann agus a oidhreann an leanbh go huathoibríoch a sheachaint:

class Piece(models.Model):
    pass


class Article(Piece):
    article_piece = models.OneToOneField(
        Piece, on_delete=models.CASCADE, parent_link=True
    )
    ...


class Book(Piece):
    book_piece = models.OneToOneField(Piece, on_delete=models.CASCADE, parent_link=True)
    ...


class BookReview(Book, Article):
    pass

Ní cheadaítear ainm réimse “i bhfolach”Link to this heading#

I ngnáthoidhreacht aicme Python, ceadaítear do rang linbh aon tréith ón rang tuismitheora a shárú. I Django, ní cheadaítear é seo de ghnáth do réimsí samhlacha. Má tá réimse ar a dtugtar údar ag rang bun-mhúnla neamh-teibí, ní féidir leat réimse samhail eile a chruthú nó tréith ar a dtugtar údar a shainiú in aon aicme a fhaigheann oidhreacht ón rang bonn sin.

Ní bhaineann an srian seo le réimsí samhlacha a oidhreacht ó mhúnla teibí. Féadfar réimsí den sórt sin a shárú le réimse nó luach eile, nó iad a bhaint trí “field_name = None” a shocrú.

Bíonn deacrachtaí i réimsí ar nós cásanna nua a thionscnamh (ag sonrú cén réimse atá á thionscnamh i Samhail. __init__`) agus sraitheadh. Is gnéithe iad seo nach gá le gnáthoidhreacht aicme Python déileáil leo ar an mbealach céanna, mar sin níl an difríocht idir oidhreacht mhúnla Django agus oidhreacht aicme Python treallach.

Ní bhaineann an srian seo ach le tréithe arba:class: ~django.db.models.field cásanna. Is féidir gnáthtréithe Python a shárú más mian leat. Ní bhaineann sé ach le hainm na tréithe mar a fheiceann Python é: má tá ainm an cholún bunachar sonraí á shonrú agat de láimh, is féidir leat an t-ainm colún céanna a bheith le feiceáil i samhail leanbh agus sinsear le haghaidh oidhreachta il-tábla (is colúin iad i dhá thábla bunachar sonraí éagsúla).

Ardóidh Django a:exc: ~django.core.exceptions.fielderror má sháraigh tú aon réimse samhail in aon mhúnla sinsear.

Tabhair faoi deara, mar gheall ar an mbealach a réitítear réimsí le linn sainmhínithe ranga, réitear réimsí samhail a oidhreacht ó iliomad samhlacha teibí tuismitheoirí i ord doimhneach- Tá sé seo i gcodarsnacht le Python MRO caighdeánach, a réitear ar leithead ar dtús i gcásanna oidhreachta cruth diamaint. Ní théann an difríocht seo ach ar ordlathais chasta samhlacha, ar cheart duit iarracht a dhéanamh (de réir na comhairle thuas) a sheachaint.