Tagairt sampla samhailLink to this heading#

Luchtú samhail a shaincheapadhLink to this heading#

classmethod Model.from_db(db, field_names, values)Link to this definition#

Is féidir an modh ``from_db () ``a úsáid chun cruthú sampla samhail a shaincheapadh agus tú ag luchtú ón mbunachar sonraí.

Tá an ailias bunachar sonraí don bhunachar sonraí ón argóint db` a luchtaítear an tsamhail uaidh, tá field_names` ainmneacha na réimsí luchtaithe go léir, agus tá luacha` na luachanna luchtaithe do gach réimse in field_names`. Tá na field_names san ord céanna leis na luacha`. Má tá réimsí uile an tsamhail i láthair, ansin ráthaítear go mbeidh luacha san ord a bhfuil __init__ () `ag súil leo. Is é sin, is féidir an sampla a chruthú le ``cls (*luachanna) `. Má chuirtear aon réimsí ar iarchur, ní bheidh siad le feiceáil in field_names`. Sa chás sin, sannadh luach Django.db.Models.Deferred do gach ceann de na réimsí atá in easnamh.

Chomh maith leis an tsamhail nua a chruthú, ní mór don modh from_db () ``na bratacha ```adding agus db a shocrú sa instanse nua 's:attr: `~Model. tréith _state.

Seo thíos sampla a thaispeánann conas luachanna tosaigh réimsí a luchtaítear ón mbunachar sonraí a thaifeadadh:

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)

Taispeánann an sampla thuas cur chun feidhme iomlán from_db () `chun soiléiriú a dhéanamh ar an gcaoi a ndéantar é sin. Sa chás seo bheadh sé in ann glao ``super () ``a úsáid sa mhodh ``from_db ().

Eochracha bunscoile uathoibríochLink to this heading#

Má tá samhail ag: class: ~django.db.models.autofield - eochair phríomh-mhéadaithe uathoibríoch - ansin ríomhfar agus sábhálfar an luach uathoibríoch sin mar thréith ar do réad an chéad uair a ghlaonn tú ar save () `:

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

Níl aon bhealach ann a insint cad é luach aitheantais sula nglaonn tú ar ``save () ``, toisc go ríomh do bhunachar sonraí an luach sin, ní ag Django.

Ar mhaithe le áisiúlacht, tá: class: ~django.db.models.autofield ag gach samhail darb ainm id` de réir réamhshocraithe mura sonraíonn tú go sainráite primary_key=true ar réimse i do mhúnla. Féach an doiciméadú le haghaidh: class: ~django.db.models.autofield le haghaidh tuilleadh sonraí.

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

Cad a tharlaíonn nuair a shábháil tú?Link to this heading#

Nuair a shábhálann tú réad, déanann Django na céimeanna seo a leanas:

1. Easaigh comhartha réamh-shábháil. Seoltar an comhartha: Data: ~django.db.models.signals.pre_save, rud a ligeann d'aon fheidhmeanna a éisteann don chomhartha sin rud éigin a dhéanamh.

2. Réamhphróiseáil na sonraí. Glaítear ar gach réimse:: ~django.db.models.field.pre_save modh chun aon mhodhnú uathoibrithe sonraí a theastaíonn a dhéanamh. Mar shampla, athraíonn na réimsí dáta/ama ``pre_save () ``chun cur i bhfeidhmiú:attr: ~django.db.models.datefield.auto_now_add agus:attr: ~django.db.models.datefield.auto_now.

3. Ullmhaigh na sonraí don bhunachar sonraí. Iarrtar ar gach réimse:meth: ~django.db.models.field.get_db_prep_save modh a luach reatha a sholáthar i gcineál sonraí is féidir a scríobh chuig an mbunachar sonraí.

   Ní theastaíonn ullmhú sonraí ó chuid is mó de na réimsí. Tá cineálacha sonraí simplí, mar shampla sláimhreacha agus teaghráin, 'réidh le scríobh' mar réad Python. Mar sin féin, is minic a éilíonn roinnt modhnú ó chineálacha sonraí níos cast

   Mar shampla, úsáideann réimsí: :class: ~django.db.Models.DateField réad Python datetime chun sonraí a stóráil. Ní stóráilíonn bunachair sonraí rudaí datetime, mar sin caithfear an luach réimse a thiontú ina teaghrán dáta comhlíontach ISO lena chur isteach sa bhunachar sonraí.

4. Cuir na sonraí isteach sa bhunachar sonraí. Tá na sonraí réamhphróiseáilte, ullmhaithe comhdhéanta i ráiteas SQL lena chur isteach sa bhunachar sonraí.

5. Easaigh comhartha iar-shábháil. Seoltar an comhartha: Data: ~django.db.models.signals.post_save, rud a ligeann d'aon fheidhmeanna a éisteann don chomhartha sin rud éigin a dhéanamh.

Conas a bhfuil a fhios ag Django UPDATE vs INSERTLink to this heading#

B'fhéidir gur thug tú faoi deara go n-úsáideann rudaí bunachar sonraí Django an modh céanna save () `chun rudaí a chruthú agus a athrú. Déanann Django achoimrí ar an ngá chun ráitis SQL ``INSERT nó UPDATE a úsáid. Go sonrach, nuair a ghlaonn tú ar save () ``agus nuair a shainmhíníonn príomh-thréith an réad** a:attr: `~django.db.models.field.default nó: attr: ~django.db.models.field.db_default, leanann Django an algartam seo:

• If the object's primary key attribute is set to anything except None, Django executes an UPDATE.

• Más rud é príomh-thréith eochair an réad* socraithe nó mura ndearna an UPDATE` rud ar bith a nuashonrú (m.sh. má tá eochair phríomhúil socraithe ar luach nach bhfuil sa bhunachar sonraí ann), déanann Django INSERT a fhorghníomhú.

Má shainmhíníonn príomhthréith an réada a:attr: ~django.db.models.field.default nó: attr: ~django.db.models.field.db_default ansin déanann Django UPDATE a fhorghníomhú más samhail samhail atá ann agus socraítear eochair phríomhúil ar luach atá ann sa bhunachar sonraí. Seachas sin, déanann Django INSERT a fhorghníomhú.

Is é an ceann a thugann anseo ná gur chóir duit a bheith cúramach gan luach príomh-eochair a shonrú go sainráite agus rudaí nua á shábháil, mura féidir leat a ráthú nach bhfuil an luach príomh-eochair neamhúsáidte. Le haghaidh tuilleadh eolais faoin nuans seo, féach `Luachanna uathoibríoch-phríomhúil a shonrú go sainráite `_ thuas agus `INSERT nó UPDATE`a chur i bhfeidhm `_ thíos.

I Django 1.5 agus níos luaithe, rinne Django SELECT nuair a shocraíodh an príomh-thréith eochair. Má aimsigh an SELECT sraith, ansin rinne Django UPDATE, ar shlí eile rinne sé INSERT. Mar thoradh ar an sean-algartam bíonn ceist amháin eile sa chás UPDATE. Tá roinnt cásanna annamh ann nach dtuairiscíonn an bunachar sonraí gur nuashonraíodh sraith fiú má tá sraith sa bhunachar sonraí do phríomhluach an réada. Sampla is ea an truicear PostgreSQL ON UPDATE a fhilleann NULL. I gcásanna den sórt sin is féidir filleadh ar an sean-algartam tríd an rogha: attr: ~django.db.models.options.select_on_save a shocrú go True.

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

tréithe a nuashonrú bunaithe ar réimsí atá annLink to this heading#

Uaireanta beidh ort tasc uimhrithíochta simplí a dhéanamh ar réimse, mar shampla an luach reatha a mhéadú nó a laghdú. Bealach amháin chun é seo a bhaint amach is ea an uimhríocht a dhéanamh i Python mar:

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

Más é 10 an seanluach number_sold a aisghabhadh ón mbunachar sonraí, ansin scríobhfar luach 11 ar ais chuig an mbunachar sonraí.

Is féidir an próiseas a dhéanamh láidir, :ref: <avoiding-race-conditions-using-f>riocht rása a sheachaint, chomh maith le beagán níos gasta tríd an nuashonrú a chur in iúl i gcoibhneas leis an luach réimse bunaidh, seachas mar shannadh follasach de luach nua. Soláthraíonn Django: class: Abairtí F <django.db.models.F>`chun nuashonrú coibhneasta den chineál seo a dhéanamh. Ag baint úsáide as: aicme: `Abairtí F <django.db.models.F>, cuirtear an sampla roimhe seo in iúl mar:

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

<topics-db-queries-update>Le haghaidh tuilleadh sonraí, féach an doiciméadú ar:class: F abairtí <django.db.models.F>`agus a n:ref: `úsáid i gceisteanna nuashonraithe.

Sonraítear na réimsí atá le sábháilLink to this heading#

Má chuirtear save () ``ar liosta ainmneacha réimse in argóint eochairfhocal ``update_fields, ní dhéanfar ach na réimsí ainmnithe ar an liosta sin a nuashonrú. D'fhéadfadh sé seo a bheith inmhianaithe más mian leat ach réimse amháin nó cúpla réimse a nuashonrú ar réad. Beidh leas beag feidhmíochta ann as cosc a chur ar na réimsí samhlacha go léir a nuashonrú sa bhunachar sonraí. Mar shampla:

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

Is féidir leis an argóint update_fields` a bheith ina aon athraitheacha ina bhfuil teaghráin. Sceapfaidh athraitheach folamh update_fields an sábháil. Déanfaidh luach ``None ``nuashonrú ar gach réimse.

Má shonrófar update_fields, cuirfear iallach ar nuashonrú.

When saving a model fetched through deferred model loading (only() or defer()) only the fields loaded from the DB will get updated. In effect there is an automatic update_fields in this case. If you assign or change any deferred field value, the field will be added to the updated fields.

``__str__ () `Link to this heading#

Model.__str__()Link to this definition#

Glaítear ar an modh __str__ () ``aon uair a ghlaonn tú ``str () ar réad. Úsáideann Django ``str (obj) ``i roinnt áiteanna. Go háirithe, rud a thaispeáint ar shuíomh riaracháin Django agus mar an luach a cuireadh isteach i dteimpléad nuair a thaispeánann sé réad. Dá bhrí sin, ba cheart duit léiriú deas, inléite don duine ar an tsamhail a thabhairt ar ais i gcónaí ón modh ``__str__ () ``.

Mar shampla:

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}"

``__eq__ () `Link to this heading#

Model.__eq__()Link to this definition#

Sainmhínítear an modh comhionannais ionas go measfar cásanna a bhfuil an príomh-luach céanna agus an aicme coincréite céanna cothrom acu, ach amháin nach bhfuil cásanna a bhfuil príomh-phríomhluach “None” comhionann le haon rud seachas iad féin. Maidir le samhlacha seachfhreastalaí, sainmhínítear rang coincréite mar an chéad thuismitheoir neamh-seachfhreastalaí an tsamhail; i gcás gach samhail eile níl ann ach aicme

Mar shampla:

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)

``__hash__ () ``Link to this heading#

Model.__hash__()Link to this definition#

Tá an modh __hash__ () ``bunaithe ar phríomhluach an cháis. Tá sé go héifeachtach ``hash (obj.pk) ``. Mura bhfuil príomhluach ag an gcás ansin ardófar ``TypeError (ar shlí eile chuirfeadh an modh ``__hash__ () ``luachanna difriúla ar ais roimh agus tar éis an cás a shábháil, ach athródh an: meth: ~ réad. Tá toirmiscthe ar luach __hash__ de shampla i Python.

``get_absolute_url () `Link to this heading#

Model.get_absolute_url()Link to this definition#

Sainmhínigh modh ``get_absolute_url () ``chun a insint do Django conas an URL canónach do réad a ríomh. Maidir le glaonna, ba cheart go bhfeicfeadh an modh seo sreang ar ais is féidir a úsáid chun tagairt a dhéanamh don réad thar HTTP.

Mar shampla:

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

While this code is correct and simple, it may not be the most portable way to write this kind of method. The reverse() function is usually the best approach.

Mar shampla:

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

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

Tá áit amháin a úsáideann Django ``get_absolute_url () ``san aip riaracháin. Má shainmhíníonn réad an modh seo, beidh nasc “Amharc ar an láithreán” ag an leathanach eagarthóireachta réada a léimfidh tú go díreach chuig dearcadh poiblí an réada, mar a thugann ``get_absolute_url () ``.

Ar an gcaoi chéanna, úsáideann cúpla giotán eile de Django, mar shampla an: doc: creat beatha syndication ``get_absolute_url () ``nuair </ref/contrib/syndication> a shainmhínítear é. Má tá sé ciallmhar do chásanna do mhúnla go bhfuil URL uathúil ag gach ceann acu, ba cheart duit ``get_absolute_url () `a shainiú.

It's good practice to use get_absolute_url() in templates, instead of hardcoding your objects' URLs. For example, this template code is bad:

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

Tá an cód teimpléad seo i bhfad níos fearr:

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

Is é an loighic anseo ná má athraíonn tú struchtúr URL do chuid rudaí, fiú le haghaidh rud beag cosúil le earráid litrithe a cheartú, nach dteastaíonn uait gach áit a d'fhéadfaí an URL a chruthú a rianú. Sonraigh é uair amháin, i `get_absolute_url () ``agus glaoigh do chód eile go léir ar an áit amháin sin.

_stáitLink to this heading#

Model._stateLink to this definition#

Tagraíonn an tréith _state ``do réad ``ModelState a rianaíonn saolré an tsamhail shampla.

Tá dhá thréith ag an réad ModelState: Adding, bratach atá True mura sábháladh an tsamhail chuig an mbunachar sonraí go fóill, agus db`, teaghrán a thagraíonn don ainm bunachar sonraí a luchtadh uaidh nó a shábháiltear leis.

Tá Adding=true` agus db=none ag cásanna nua-ionchasacha, ós rud é nach bhfuil siad fós le sábháil. Beidh Adding=False` agus db socraithe ar ainm an bhunachar sonraí gaolmhar ar chásanna a gheobhaidh ó QuerySet.

_is_pk_set()Link to this heading#

Model._is_pk_set()Link to this definition#

The _is_pk_set() method returns whether the model instance's pk is set. It abstracts the model's primary key definition, ensuring consistent behavior regardless of the specific pk configuration.