---
title: "Tagairt sampla samhail"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/ref/models/instances/
canonical: https://djangodocs.dev/ga/5.2/ref/models/instances/
---
# Tagairt sampla samhail

Déanann an doiciméad seo cur síos ar shonraí an API Samhail . Tógann sé ar an ábhar a chuirtear i láthair sna treoracha: doc: model agus:doc: ceisteanna bunachar sonraí \</topics/db/models\>, mar sin is dócha go mbeidh tú ag iarraidh na do\</topics/db/queries\> iciméid sin a léamh agus a thuiscint sula léann tú an ceann seo.

Le linn na tagartha seo úsáidfimid an:ref: samplacha samplaí blag \</topics/db/queries\> \<queryset-model-example\>\`a chuirtear i láthair in:doc: treoir fiosrúcháin bunachar sonraithe'.

## Cruthú rudaí

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

#### `class Model(**kwargs)`

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

> **Note**
>
> B'fhéidir go mbeadh mealladh ort an tsamhail a shaincheapadh tríd an modh `__init__` a shárú. Má dhéanann tú amhlaidh, áfach, bí cúramach gan an síniú glaonna a athrú mar d'fhéadfadh aon athrú cosc a chur ar an gcás samhail a shábháil. Ina theannta sin, d'fhéadfadh earráidí athshlánaithe gan teorainn a bheith mar thoradh ar agairt do réimsí samhail laistigh de `__init__` i gcúinsí áirithe. Seachas `__init__` a shárú, déan iarracht ceann de na cur chuige seo a úsáid:
>
> 1. Cuir modh ranga leis an rang samhail:
>
>    ```
>    from django.db import models
>
>
>    class Book(models.Model):
>        title = models.CharField(max_length=100)
>
>        @classmethod
>        def create(cls, title):
>            book = cls(title=title)
>            # do something with the book
>            return book
>
>
>    book = Book.create("Pride and Prejudice")
>    ```
> 2. Cuir modh leis ar bhainisteoir saincheaptha (is fearr de ghnáth):
>
>    ```
>    class BookManager(models.Manager):
>        def create_book(self, title):
>            book = self.create(title=title)
>            # do something with the book
>            return book
>
>
>    class Book(models.Model):
>        title = models.CharField(max_length=100)
>
>        objects = BookManager()
>
>
>    book = Book.objects.create_book("Pride and Prejudice")
>    ```

### Luchtú samhail a shaincheapadh

#### `classmethod Model.from_db(db, field_names, values)`

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 ()```.

## Rudaí athnuachana ón mbunachar

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

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

#### `Model.arefresh_from_db(using=None, fields=None, from_queryset=None)`

*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())
```

> **Changed in Django 5.1**
>
> Cuireadh an argóint `from_queryset` leis.

#### `Model.get_deferred_fields()`

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ú

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

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

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

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.

> **Conas earráidí bailíochtaithe réimsiúnta a ardú mura bhfuil na réimsí sin le feiceáil i Modelfhoirme**
>
> Ní féidir leat earráidí bailíochtaithe a ardú in Model.clean () \`\`do réimsí nach bhfuil le feiceáil i bhfoirm mhúnla (féadfaidh foirm a réimsí a theorannú ag baint úsáide as \`Meta.Fields\` nó Meta.Exclude\`). Ag déanamh amhlaidh, ardófar `Error lua` toisc nach mbeidh an earráid bailíochtaithe in ann a bheith bainteach leis an réimse eisiata.
>
> Chun oibriú timpeall ar an aincheist seo, ina ionad sin déan iarrthó:meth: model.clean\_fields () \<django.db.models.Model.clean\_fields\>\`mar a fhaigheann sé liosta na réimsí atá eisiata ó bhailíochtú. Mar shampla:
>
> ```
> class Article(models.Model):
>     ...
>
>     def clean_fields(self, exclude=None):
>         super().clean_fields(exclude=exclude)
>         if self.status == "draft" and self.pub_date is not None:
>             if exclude and "status" in exclude:
>                 raise ValidationError(
>                     _("Draft entries may not have a publication date.")
>                 )
>             else:
>                 raise ValidationError(
>                     {
>                         "status": _(
>                             "Set status to draft if there is not a publication date."
>                         ),
>                     }
>                 )
> ```

#### `Model.validate_unique(exclude=None)`

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

\<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áil

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

#### `Model.save(* (Keyword-only parameters separator (PEP 3102)), force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)`

#### `Model.asave(* (Keyword-only parameters separator (PEP 3102)), force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)`

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

> **Deprecated since Django 5.1**
>
> Deprecated since version 5.1: Tá tacaíocht d'argóintí seasaimh míchuige.

### Eochracha bunscoile uathoibríoch

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 () \`:

```pycon
>>> 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í.

#### An mhaoin `pk`

#### `Model.pk`

Regardless of whether you define a primary key field yourself, or let Django
supply one for you, each model will have a property called `pk`. It behaves
like a normal attribute on the model, but is actually an alias for whichever
field or fields compose the primary key for the model. You can read and set
this value, just as you would for any other attribute, and it will update the
correct fields in the model.

> **Changed in Django 5.2**
>
> Support for the primary key to be composed of multiple fields was added via
> `CompositePrimaryKey`.

#### Luachanna eochair uathoibríoch-phríomhúil

Má tá: class: ~django.db.models.autofield ag samhail ach ba mhaith leat aitheantas réad nua a shainiú go sainráite agus tú ag sábháil, sainmhínigh é go sainráite sula ndéantar é a shábháil, seachas brath ar shannadh uathoibríoch an ID:

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

Má shannann tú luachanna eochair uathoibríoch de láimh, déan cinnte nach n-úsáideann tú luach príomh-eochair atá ann cheana féin! Má chruthaíonn tú réad nua le luach príomh-eochair follasach atá ann cheana féin sa bhunachar sonraí, glacfaidh Django leis go bhfuil tú ag athrú an taifead atá ann cheana seachas ceann nua a chruthú.

Mar gheall ar an sampla bhlag `Cheddar Talk` thuas, chuirfeadh an sampla seo an taifead roimhe seo sa bhunachar sonraí:

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

Féach [Conas a bhfuil a fhios ag Django nuashonrú vs INSERT](#how-django-knows-to-update-vs-insert), thíos, ar an gcúis a tharlaíonn sé seo.

Tá luachanna eochair uathoibríoch a shonrú go sainráite úsáideach den chuid is mó le haghaidh rudaí sábhála móra, nuair a bhíonn tú muiníneach nach mbeidh imbhuailt eochair

Má tá PostgreSQL á úsáid agat, b'fhéidir go mbeadh gá an seicheamh a bhaineann leis an bpríomh-eochair a nuashonrú; féach:ref: manually-specied-autoincrement-pk.

### Cad a tharlaíonn nuair a shábháil tú?

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 INSERT

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

#### INSERT nó UPDATE a chur i bhfeidhm

I roinnt imthosca annamh, is gá a bheith in ann an modh: meth: ~Model.save () \`a chur i bhfeidhm chun SQL \`\`INSERT\` a dhéanamh agus gan titim siar chun `UPDATE` a dhéanamh. Nó a mhalairt: nuashonraigh, más féidir, ach ná cuir isteach sraith nua. Sna cásanna seo is féidir leat na paraiméadair `Force_insert=True` nó `Force_Update=True` a chur chuig an modh:meth: ~Model.save () . Is earráid é an dá pharaiméadar a rith: ní féidir leat nuashonraithe\* agus\* a chur isteach ag an am céanna!

Nuair a úsáidtear: ref: oidhreacht il-tábla \<multi-table-inheritance\>, is féidir freisin tuipéil de na tuismitheoirí a sholáthar do `force_insert` d'fhonn ráitis `INSERT` a chur i bhfeidhm do gach bonn. Mar shampla:

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

Is féidir leat ```force_insert= (Models.model,) ``a rith chun ráiteas ``INSERT``` a chur i bhfeidhm do gach tuismitheoir. De réir réamhshocraithe, ní chuireann `force_insert=True` ach sraith nua a chur isteach don tsamhail reatha.

Ba chóir go mbeadh sé an-annamh go mbeidh ort na paraiméadair seo a úsáid. Déanfaidh Django an rud ceart beagnach i gcónaí agus déanfaidh sé iarracht a shárú a bheidh mar thoradh ar earráidí atá deacair a rianú. Tá an ghné seo le haghaidh ardúsáide amháin.

Ag baint úsáide as `update_fields`, cuirfear iallach ar nuashonrú ar an gcéanna le `force_update`.

### tréithe a nuashonrú bunaithe ar réimsí atá ann

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:

```pycon
>>> 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:

```pycon
>>> 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áil

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

Nuair a shábháil samhail a fuarthas trí luchtú samhail iarchurtha (:meth: ~django.db.models.query.queryset.only () \`nó: meth: \`~django.db.models.query.queryset.defer ()) ní dhéanfar ach na réimsí luchtaithe ón DB a nuashonrú. I ndáiríre tá `update_fields` uathoibríoch sa chás seo. Má shannann tú nó má athraíonn tú aon luach réimse iarchurtha, cuirfear an réimse leis na réimsí nuashonraithe.

> **Field.pre_save () ``agus ``update_fields**
>
> Má chuirtear `update_fields` isteach, ní thugtar ach modhanna: meth: ~django.db.models.field.pre\_save de na modhanna `update_fields`. Mar shampla, ciallaíonn sé seo nach ndéanfar réimsí dáta/ama le auto\_now=true\` a nuashonrú mura gcuirtear iad san áireamh sna `update_fields`.

## Rudaí a scriosadh

#### `Model.delete(using=DEFAULT_DB_ALIAS, keep_parents=False)`

#### `Model.adelete(using=DEFAULT_DB_ALIAS, keep_parents=False)`

*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ála

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.

> **Ní féidir leat picíní a roinnt idir leaganacha**
>
> Níl picilí samhlacha bailí ach don leagan de Django a úsáideadh chun iad a ghiniúint. Má ghineann tú picle ag baint úsáide as leagan Django N, níl aon ráthaíocht ann go mbeidh picle inléite le leagan Django N+1. Níor chóir picilí a úsáid mar chuid de straitéis cartlainne fadtéarmach.
>
> Ós rud é go bhféadfadh sé a bheith deacair earráidí comhoiriúnachta picéil a dhiagnóisiú, mar shampla rudaí truaillithe go ciúin, ardaítear `RuntimeWarning` nuair a dhéanann tú iarracht samhail a dhíphiocadh i leagan Django atá difriúil ná an ceann inar piceáladh é.

## Modhanna samhail eile

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

### \_\_str\_\_ () \`

#### `Model.__str__()`

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\_\_ () \`

#### `Model.__eq__()`

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\_\_ () \`\`

#### `Model.__hash__()`

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 () \`

#### `Model.get_absolute_url()`

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

Cé go bhfuil an cód seo ceart agus simplí, b'fhéidir nach é an bealach is iniompartha chun modh den chineál seo a scríobh. Is gnách gurb é an fheidhm: Func: ~django.urls.reverse an cur chuige is fearr.

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

> **Warning**
>
> Ba chóir duit an URL a thógáil ó ionchur úsáideora neamhbhailíochtaithe a sheachaint, d'fhonn féidearthachtaí nasc nó nimhiú a atreorú a laghdú
>
> ```
> def get_absolute_url(self):
>     return "/%s/" % self.name
> ```
>
> Más é `self.name` `` `/example.com' `` filleann sé `` `'//example.com/' `` ar URL bailí scéime coibhneasta é ach ní an '/%2Fexample.com/'\` a bhfuil súil leis.

Is dea-chleachtas é get\_absolute\_url () a úsáid i dteimpléid, in ionad URLanna do chuid rudaí a chódú go crua. Mar shampla, tá an cód teimpléid seo dona:

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

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

```html+django
<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.

> **Note**
>
> Ní mór ach carachtair ASCII a bheith san teaghrán a fhilleann tú ó get\_absolute\_url () \`\`\*\*\*\* (a theastaíonn ag an sonraíocht URI, :rfc: \`3986 #section -2) agus ionchódaithe URL, más gá.
>
> Ba chóir go mbeadh cód agus teimpléid ag glaoch ar get\_absolute\_url () in ann an toradh a úsáid go díreach gan aon phróiseáil bhreise. B'fhéidir gur mhaith leat an fheidhm django.utils.encoding.iri\_to\_uri () a úsáid chun cabhrú leis seo má tá teaghráin á úsáid agat ina bhfuil carachtair lasmuigh den raon ASCII.

## Modhanna sampla breise

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

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

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

#### `Model.get_previous_by_FOO(**kwargs)`

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

> **Modhanna sampla breise a shárú**
>
> I bhformhór na gcásanna ba chóir go n-oibreodh ```get_foo_display () ``, `get_next_by_foo ()```, agus ```get_previous_by_foo () ``, agus ``get_previous_by_foo () `` `` `` Get_Previous_by_foo ()```. Ós rud é go gcuireann an metaclass iad leis, áfach, níl sé praiticiúil cuntas a thabhairt ar gach struchtúr oidhreachta féideartha. I gcásanna níos casta ba chóir duit Field.contribute\_to\_class () a shárú chun na modhanna a theastaíonn uait a shocrú.

## Tréithe eile

### `_stáit`

#### `Model._state`

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

#### `Model._is_pk_set()`

> **New in Django 5.2**

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.