Tagairt sampla samhailLink to this heading#

Cruthú rudaíLink to this heading#

Chun sampla nua de mhúnla a chruthú, cuir isteach é cosúil le haon rang Python eile:

class Model(**kwargs)Link to this definition#

Is iad na hargóintí eochairfhocal ainmneacha na réimsí atá sainmhínithe agat ar do mhúnla. Tabhair faoi deara nach dteagmháil le do bhunachar sonraí ar bhealach ar bith a dhéanamh ar mhúnla; chuige sin, ní mór duit:meth: `~Model.save () `.

from django.db.models import DEFERRED


@classmethod
def from_db(cls, db, field_names, values):
    # Default implementation of from_db() (subject to change and could
    # be replaced with super()).
    if len(values) != len(cls._meta.concrete_fields):
        values = list(values)
        values.reverse()
        values = [
            values.pop() if f.attname in field_names else DEFERRED
            for f in cls._meta.concrete_fields
        ]
    instance = cls(*values)
    instance._state.adding = False
    instance._state.db = db
    # customization to store the original field values on the instance
    instance._loaded_values = dict(
        zip(field_names, (value for value in values if value is not DEFERRED))
    )
    return instance


def save(self, **kwargs):
    # Check how the current values differ from ._loaded_values. For example,
    # prevent changing the creator_id of the model. (This example doesn't
    # support cases where 'creator_id' is deferred).
    if not self._state.adding and (
        self.creator_id != self._loaded_values["creator_id"]
    ):
        raise ValueError("Updating the value of creator isn't allowed")
    super().save(**kwargs)

Rudaí athnuachana ón mbunacharLink to this heading#

Má scriosann tú réimse ó shampla samhail, déanann rochtain a fháil air an luach ón mbunachar sonraí a athluchtú arís:

>>> obj = MyModel.objects.first()
>>> del obj.field
>>> obj.field  # Loads the field from the database

Model.refresh_from_db(using=None, fields=None, from_queryset=None)Link to this definition#

Model.arefresh_from_db(using=None, fields=None, from_queryset=None)Link to this definition#

Asynchronous version: arefresh_from_db()

Más gá duit luachanna samhail a athluchtú ón mbunachar sonraí, is féidir leat an modh `fresh_from_db () `a úsáid. Nuair a ghlaofar an modh seo gan argóintí déantar an méid seo a leanas:

1. Déantar gach réimse neamh-iarchurtha den tsamhail a nuashonrú go dtí na luachanna atá i láthair sa bhunachar sonraí.

2. Déantar aon chaidreamh taisceáilte a ghlanadh ón gcás athluchtaithe.

Ní dhéantar ach réimsí den tsamhail a athluchtú ón mbunachar sonraí. Ní dhéantar luachanna eile atá ag brath ar bhunachar sonraí mar anótaí a athluchtú. Any:func: @cached_property<django.utils.functional.cached_property> ní ghlantar tréithe ach an oiread.

Tarlaíonn an t-athluchtú ón mbunachar sonraí ar luchtadh an cás uaidh, nó ón mbunachar sonraí réamhshocraithe mura luchtaíodh an cás ón mbunachar sonraí. Is féidir an argóint ``úsáid ``a úsáid chun an bunachar sonraí a úsáidtear le haghaidh athluchtaithe a chur i bhfeidhm.

Is féidir iallach a chur ar an tacar réimsí a luchtú tríd an argóint ``réimsí ``a úsáid.

Mar shampla, chun tástáil a dhéanamh go raibh an nuashonrú ag súil leis mar thoradh ar ghlao ``update () ``, d'fhéadfá tástáil cosúil leis seo a scríobh:

def test_update_result(self):
    obj = MyModel.objects.create(val=1)
    MyModel.objects.filter(pk=obj.pk).update(val=F("val") + 1)
    # At this point obj.val is still 1, but the value in the database
    # was updated to 2. The object's updated value needs to be reloaded
    # from the database.
    obj.refresh_from_db()
    self.assertEqual(obj.val, 2)

Tabhair faoi deara, nuair a bhíonn rochtain ar réimsí iarchurtha, go dtarlaíonn luach an réimse iarchurtha tríd an modh seo. Dá bhrí sin is féidir an bealach a tharlaíonn luchtú iarchurtha a shaincheapadh. Taispeánann an sampla thíos conas is féidir le réimsí uile an cháis a athluchtú nuair a dhéantar réimse iarchurtha a athluchtú:

class ExampleModel(models.Model):
    def refresh_from_db(self, using=None, fields=None, **kwargs):
        # fields contains the name of the deferred field to be
        # loaded.
        if fields is not None:
            fields = set(fields)
            deferred_fields = self.get_deferred_fields()
            # If any deferred field is going to be loaded
            if fields.intersection(deferred_fields):
                # then load all of them
                fields = fields.union(deferred_fields)
        super().refresh_from_db(using, fields, **kwargs)

Ceadaíonn an argóint from_queryset tacar ceisteanna difriúil a úsáid ná an ceann a cruthaíodh ó: attr: `~django.db.models.model. _bainisteoir bunaisteoir'. Tugann sé níos mó smachta duit ar an gcaoi a n-athluchtaítear an tsamhail. Mar shampla, nuair a úsáideann do mhúnla scriosadh bog is féidir leat ``fresh_from_db () ``a dhéanamh chun é seo a chur san áireamh:

obj.refresh_from_db(from_queryset=MyModel.active_objects.all())

Is féidir leat rudaí a bhaineann le taisce a ghlanfaí ar shlí eile ón gcás athluchtaithe:

obj.refresh_from_db(from_queryset=MyModel.objects.select_related("related_field"))

Is féidir leat an tsraith a ghlasáil go dtí deireadh an idirbheart sula ndéanfaidh tú luachanna samhail a athlódáil:

obj.refresh_from_db(from_queryset=MyModel.objects.select_for_update())

Model.get_deferred_fields()Link to this definition#

Modh cúntóra a thugann tacar ina bhfuil ainmneacha tréithe na réimsí sin go léir atá iarchurtha faoi láthair don tsamhail seo.

Rudaí a bhailíochtúLink to this heading#

Tá ceithre chéim i gceist le samhail a bhailíochtú:

1. Bailíochtú na réimsí samhail -:meth: `Model.clean_fields () `

2. Bailíochtú an tsamhail ina iomláine -:meth: `Model.clean () `

3. Bailíochtú uathúlacht an réimse -:meth: `Model.validate_unique () `

4. Bailíochtú na srianta -:meth: Model.validate_restricints

Déantar na ceithre chéim go léir nuair a ghlaonn tú ar mhodh samhail 's:meth: ~model.full_clean.

Nuair a úsáideann tú a:class: ~django.forms.modelform, déanfaidh an glao chuig:meth: ~django.forms.form.is_valid () `na céimeanna bailíochtaithe seo do na réimsí uile atá san áireamh ar an bhfoirm. Féach na:doc: `Modelform doiciméadach le haghaidh tuilleadh eolais. </topics/forms/modelforms> Níor chóir duit glaoch ar mhodh samhail's:meth: ~model.full_clean () `má tá sé ar intinn agat earráidí bailíochtaithe a láimhseáil tú féin, nó má tá réimsí eisiata agat ó:class: `~django.forms.ModelForm a dteastaíonn bailíochtú uathu.

Model.full_clean(exclude=None, validate_unique=True, validate_constraints=True)Link to this definition#

Glaonn an modh seo: meth: Model.clean_fields () `, :meth: `Model.clean (), :meth: Model.validate_unique () `(má tá ``validate_unique` True`), agus:meth: Model.validate_restrictions () (más rud é validate_restricints True`` E``) san ord sin agus ardaíonn a:exc: ~django.core.exceptions.validationError a bhfuil tréith message_dict ina bhfuil earráidí ó na ceithre chéim.

Is féidir an argóint roghnach eisiam a úsáid chun taca` d'ainmneacha réimse a sholáthar is féidir iad a eisiamh ó bhailíochtú agus glantachán. :class: ~django.forms.ModelForm úsáideann an argóint seo chun réimsí nach bhfuil i láthair ar d'fhoirm a eisiamh ó bheith bailíochtaithe ós rud é nach bhféadfadh an t-úsáideoir aon earráidí a ardaíodh a cheartú.

Tabhair faoi deara go nglaofar ``full_clean () ``ní go huathoibríoch nuair a ghlaonn tú ar do mhúnla 's:meth: `~model.save () `modh. Beidh ort glaoch air de láimh nuair is mian leat bailíochtú samhail aon-chéim a reáchtáil do do mhúnlaí féin a cruthaíodh de láimh. Mar shampla:

from django.core.exceptions import ValidationError

try:
    article.full_clean()
except ValidationError as e:
    # Do something based on the errors contained in e.message_dict.
    # Display them to a user, or handle them programmatically.
    pass

Is é an chéad chéim a dhéanann ``full_clean () ``gach réimse aonair a ghlanadh.

Model.clean_fields(exclude=None)Link to this definition#

Bailíochnóidh an modh seo gach réimse ar do mhúnla. Ligeann an argóint roghnach eisiam duit taca` d'ainmneacha réimse a sholáthar chun eisiamh ó bhailíochtú. Ardóidh sé a:exc: ~django.core.exceptions.validationError má theipeann ar aon réimsí bailíochtú.

Is é an dara céim a dhéanann ``full_clean () ``glaoch ar: meth: `Model.clean () `. Ba chóir an modh seo a athsholáthar chun bailíochtú saincheaptha a dhéanamh ar do mhúnla.

Model.clean()Link to this definition#

Ba chóir an modh seo a úsáid chun bailíochtú samhail saincheaptha a sholáthar, agus tréithe ar do mhúnla a mhodhnú más mian. Mar shampla, d'fhéadfá é a úsáid chun luach a sholáthar go huathoibríoch do réimse, nó chun bailíochtú a dhéanamh a éilíonn rochtain ar níos mó ná réimse amháin:

import datetime
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import gettext_lazy as _


class Article(models.Model):
    ...

    def clean(self):
        # Don't allow draft entries to have a pub_date.
        if self.status == "draft" and self.pub_date is not None:
            raise ValidationError(_("Draft entries may not have a publication date."))
        # Set the pub_date for published items if it hasn't been set already.
        if self.status == "published" and self.pub_date is None:
            self.pub_date = datetime.date.today()

Tabhair faoi deara, áfach, cosúil:meth: Model.full_clean () `, ní ghairmtear modh ``clean () ``samhail nuair a ghlaonn tú ar do mhúnla 's:meth: `~Model.save () modh.

Sa sampla thuas, rinneadh an eisceacht: exc: ~Django.Core.Exceptions.ValidationError arna ardú ag ``Model.clean () ``le sreang, mar sin stóráilfear é in eochair foclóir earráide speisialta, :data: ~Django.Core.Exceptions.non_field_errors. Úsáidtear an eochair seo le haghaidh earráidí atá ceangailte leis an tsamhail iomlán in ionad le réimse ar leith:

from django.core.exceptions import NON_FIELD_ERRORS, ValidationError

try:
    article.full_clean()
except ValidationError as e:
    non_field_errors = e.message_dict[NON_FIELD_ERRORS]

Chun eisceachtaí a shannadh do réimse ar leith, cuir ainmne:exc: ~django.core.exceptions.validationError le foclóir, áit a bhfuil na heochracha ainmneacha réimse. D'fhéadfaimis an sampla roimhe seo a nuashonrú chun an earráid a shannadh don réimse pub_date:

class Article(models.Model):
    ...

    def clean(self):
        # Don't allow draft entries to have a pub_date.
        if self.status == "draft" and self.pub_date is not None:
            raise ValidationError(
                {"pub_date": _("Draft entries may not have a publication date.")}
            )
        ...

Má bhraitheann tú earráidí i réimsí iolracha le linn ``Model.clean () ``, is féidir leat ainmneacha réimse mapála foclóra a chur ar earráidí freisin:

raise ValidationError(
    {
        "title": ValidationError(_("Missing title."), code="required"),
        "pub_date": ValidationError(_("Invalid date."), code="invalid"),
    }
)

Ansin, seiceálfaidh ``full_clean () ``srianta uathúla ar do mhúnla.

Model.validate_unique(exclude=None)Link to this definition#

<django.db.models.Options.unique_together>Tá an modh seo cosúil le:meth: ~Model.Clean_Fields, ach bailíochnaíonn sé srianta uathúlachta atá sainmhínithe trí:attr: .field.unique, :attr: .field.unique_for_date, :attr: .field.unique_for_year, nó r: Meta.unique_Together `ar do mhúnla in ionad luachanna réimse aonair. Ligeann an argóint roghnach ``eisiam` duit taca` d'ainmneacha réimse a sholáthar chun eisiamh ó bhailíochtú. Ardóidh sé a:exc: ~django.core.exceptions.validationError má theipeann ar aon réimsí bailíochtú.

<django.db.models.Options.constraints>:class: ~Django.db.Models.UniqueConstraintna sainmhínithe in:attr: Meta.Constraint bailíochtaí:meth: Model.validate_restricints.

Tabhair faoi deara má sholáthraíonn tú argóint exclude do validate_unique () `, ní sheiceálfar srian aon cheann:attr: ~django.db.models.options.unique_together a bhaineann le ceann de na réimsí a chuir tú ar fáil.

Faoi dheireadh, seiceálfaidh ``full_clean () ``aon srianta eile ar do mhúnla.

Model.validate_constraints(exclude=None)Link to this definition#

<django.db.models.Options.constraints>Bailíonn an modh seo na srianta go léir a shainmhínítear in:attr: Meta.Constraints `. Ligeann an argóint roghnach ``eisiam` duit taca` d'ainmneacha réimse a sholáthar chun eisiamh ó bhailíochtú. Ardóidh sé a:exc: ~django.core.exceptions.validationError má theipeann ar aon srianta ar bhailíochtú.

Rudaí a shábháilLink to this heading#

Chun réad a shábháil ar ais chuig an mbunachar sonraí, glaoigh ar save () `:

Model.save(*, force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)Link to this definition#

Model.asave(*, force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)Link to this definition#

Asynchronous version: asave()

Le haghaidh sonraí maidir le húsáid na hargóintí force_insert agus force_update, féach:ref: ref-models-force-insert. Is féidir sonraí faoin argóint update_fields a fháil sa ranna:ref: ref-models-update-fields.

Más mian leat iompar sábhála saincheaptha, is féidir leat an modh “save ()” seo a shárú. Féach: Ref: overriding-model-methods le haghaidh tuilleadh sonraí.

Tá roinnt caoilteachtaí ag an bpróiseas sábhála samhail freisin; féach na codanna thíos.

>>> b2 = Blog(name="Cheddar Talk", tagline="Thoughts on cheese.")
>>> b2.id  # Returns None, because b2 doesn't have an ID yet.
>>> b2.save()
>>> b2.id  # Returns the ID of your new object.

>>> b3 = Blog(id=3, name="Cheddar Talk", tagline="Thoughts on cheese.")
>>> b3.id  # Returns 3.
>>> b3.save()
>>> b3.id  # Returns 3.

b4 = Blog(id=3, name="Not Cheddar", tagline="Anything but cheese.")
b4.save()  # Overrides the previous blog with ID=3!

Restaurant(pk=1, name="Bob's Cafe").save(force_insert=(Place,))

Restaurant(pk=1, name="Bob's Cafe", rating=4).save(force_insert=(Place, Rating))

>>> product = Product.objects.get(name="Venezuelan Beaver Cheese")
>>> product.number_sold += 1
>>> product.save()

>>> from django.db.models import F
>>> product = Product.objects.get(name="Venezuelan Beaver Cheese")
>>> product.number_sold = F("number_sold") + 1
>>> product.save()

product.name = "Name changed again"
product.save(update_fields=["name"])

Rudaí a scriosadhLink to this heading#

Model.delete(using=DEFAULT_DB_ALIAS, keep_parents=False)Link to this definition#

Model.adelete(using=DEFAULT_DB_ALIAS, keep_parents=False)Link to this definition#

Leagan asincrón: ``adelete () ``

Eisíonn SQL DELETE don réad. Ní scriosann sé seo ach an réad sa bhunachar sonraí; beidh an cás Python ann fós agus beidh sonraí ann ina réimsí fós, ach amháin an príomh-eochair atá socraithe go None. Tugann an modh seo líon na rudaí scriosta agus foclóir le líon na scriosadh in aghaidh an chineál réada ar ais.

Le haghaidh tuilleadh sonraí, lena n-áirítear conas rudaí a scriosadh ar an mórchóir, féach:ref: topics-db-queries-delete.

Más mian leat iompar scriosta saincheaptha, is féidir leat an modh ``delete () ``a shárú. Féach: Ref: overriding-model-methods le haghaidh tuilleadh sonraí.

Uaireanta <multi-table-inheritance>le: ref: oidhreacht il-tábla b'fhéidir gur mhaith leat ach sonraí samhail linbh a scriosadh. Coinneoidh sonraí an tsamhail tuismitheora a shonrú keep_parents=True.

Rudaí piceálaLink to this heading#

Nuair a dhéanann tú: mod: pickle samhail, piciltear a staid reatha. Nuair a dhíphicfidh tú é, beidh an samhail samhail ann i láthair na huaire a piceáladh é, seachas na sonraí atá sa bhunachar sonraí faoi láthair.

Modhanna samhail eileLink to this heading#

Tá cuspóirí speisialta ag cúpla modh réad.

from django.db import models


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

    def __str__(self):
        return f"{self.first_name} {self.last_name}"

from django.db import models


class MyModel(models.Model):
    id = models.AutoField(primary_key=True)


class MyProxyModel(MyModel):
    class Meta:
        proxy = True


class MultitableInherited(MyModel):
    pass


# Primary keys compared
MyModel(id=1) == MyModel(id=1)
MyModel(id=1) != MyModel(id=2)
# Primary keys are None
MyModel(id=None) != MyModel(id=None)
# Same instance
instance = MyModel(id=None)
instance == instance
# Proxy model
MyModel(id=1) == MyProxyModel(id=1)
# Multi-table inheritance
MyModel(id=1) != MultitableInherited(id=1)

def get_absolute_url(self):
    return "/people/%i/" % self.id

def get_absolute_url(self):
    from django.urls import reverse

    return reverse("people-detail", kwargs={"pk": self.pk})

<!-- BAD template code. Avoid! -->
<a href="/people/{{ object.id }}/">{{ object.name }}</a>

<a href="{{ object.get_absolute_url }}">{{ object.name }}</a>

Modhanna sampla breiseLink to this heading#

Chomh maith le:meth: ~Model.save () `, :meth: `~Model.delete (), d'fhéadfadh go mbeadh cuid de na modhanna seo a leanas ag réad samhail:

Model.get_FOO_display()Link to this definition#

I gcás gach réimse a bhfuil: attr: ~django.db.models.field.choices tacar aige, beidh modh get_foo_display () ``ag an réad, áit a bhfuil `FOO ainm an réimse. Tugann an modh seo luach “inléite don duine” an réimse ar ais.

Mar shampla:

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=2, choices=SHIRT_SIZES)

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

Model.get_next_by_FOO(**kwargs)Link to this definition#

Model.get_previous_by_FOO(**kwargs)Link to this definition#

<django.db.models.Field.null>I gcás gach duine: ~Django.db.Models.DateField agus:class: ~Django.db.Models.DateTimeField nach bhfuil aith:attr: Null=True `, beidh modhanna ``Get_NEXT_BY_FOO () ``agus ``GET_PREVIOUS_BY_FOO ()` Is é ``ainm an réimse. Tugann sé seo an chéad rud eile agus roimhe seo ar ais maidir leis an réimse dáta, ag ardú:: exc: ~django.db.models.model.doesNotExist eisceacht nuair is cuí.

Déanfaidh an dá mhodh seo a gceisteanna ag baint úsáide as an mbainisteoir réamhshocraithe don tsamhail. <field-lookups>Más gá duit aithris a dhéanamh ar scagadh a úsáideann bainisteoir saincheaptha, nó más mian leat scagadh saincheaptha aonuaire a dhéanamh, glacann an dá mhodh le hargóintí eochairfhocal roghnacha freisin, ar chóir go mbeadh san fhormáid a thuairiscítear in:ref: Lookups allamui.

Tabhair faoi deara, i gcás luachanna dáta comhionanna, úsáidfidh na modhanna seo an príomh-eochair mar bhriseadh ceangail. Ráthaíonn sé seo nach ndéantar aon taifid a scipeáil nó a dhúbailt. Ciallaíonn sé sin freisin nach féidir leat na modhanna sin a úsáid ar rudaí neamhshábháilte.

Tréithe eileLink to this heading#