---
title: "Tagairt sampla samhail"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/models/instances/
canonical: https://djangodocs.dev/ga/6.1/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)`

The keyword arguments are the names of the fields you've defined on your model.
Note that instantiating a model in no way touches your database; for that, you
need to [`save()`](#django.db.models.Model.save).

> **Note**
>
> You may be tempted to customize the model by overriding the `__init__`
> method. If you do so, however, take care not to change the calling
> signature as any change may prevent the model instance from being saved.
> Additionally, referring to model fields within `__init__` may potentially
> result in infinite recursion errors in some circumstances. Rather than
> overriding `__init__`, try using one of these approaches:
>
> 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")
>    ```

> **Setting attributes does not convert types**
>
> Setting a model attribute does not convert the value to the field's Python
> type. That conversion happens when the model is [validated](#validating-objects). Although a field assigned a value of a different
> type (for example, a string assigned to a
> [`UUIDField`](/ga/6.1/ref/models/fields/#django.db.models.UUIDField)) may be converted when
> [`save()`](#django.db.models.Model.save) executes a query, the in-memory instance will keep the
> original value until it is [reloaded](#refreshing-objects).

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

When a deferred field is loaded on-demand for a single model instance, the
loading happens through this method. Thus it is possible to customize the way
this loading happens. The example below shows how one can reload all of the
instance's fields when a deferred field is loaded on-demand:

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

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. Validate the model fields - [`Model.clean_fields()`](#django.db.models.Model.clean_fields)
2. Validate the model as a whole - [`Model.clean()`](#django.db.models.Model.clean)
3. Validate the field uniqueness - [`Model.validate_unique()`](#django.db.models.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.

When you use a [`ModelForm`](/ga/6.1/topics/forms/modelforms/#django.forms.ModelForm), the call to
[`is_valid()`](/ga/6.1/ref/forms/api/#django.forms.Form.is_valid) will perform these validation steps for
all the fields that are included on the form. See the [ModelForm
documentation](/ga/6.1/topics/forms/modelforms/) for more information. You should only
need to call a model's [`full_clean()`](#django.db.models.Model.full_clean) method if you plan to handle
validation errors yourself, or if you have excluded fields from the
[`ModelForm`](/ga/6.1/topics/forms/modelforms/#django.forms.ModelForm) that require validation.

#### `Model.full_clean(exclude=None, validate_unique=True, validate_constraints=True)`

This method calls [`Model.clean_fields()`](#django.db.models.Model.clean_fields), [`Model.clean()`](#django.db.models.Model.clean),
[`Model.validate_unique()`](#django.db.models.Model.validate_unique) (if `validate_unique` is `True`),  and
[`Model.validate_constraints()`](#django.db.models.Model.validate_constraints) (if `validate_constraints` is `True`)
in that order and raises a [`ValidationError`](/ga/6.1/ref/exceptions/#django.core.exceptions.ValidationError) that
has a `message_dict` attribute containing errors from all four stages.

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

Note that `full_clean()` will *not* be called automatically when you call
your model's [`save()`](#django.db.models.Model.save) method. You'll need to call it manually
when you want to run one-step model validation for your own manually created
models. For example:

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

The second step `full_clean()` performs is to call [`Model.clean()`](#django.db.models.Model.clean).
This method should be overridden to perform custom validation on your model.

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

Note, however, that like [`Model.full_clean()`](#django.db.models.Model.full_clean), a model's `clean()`
method is not invoked when you call your model's [`save()`](#django.db.models.Model.save) method.

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.

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

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

In some rare circumstances, it's necessary to be able to force the
[`save()`](#django.db.models.Model.save) method to perform an SQL `INSERT` and not fall back to
doing an `UPDATE`. Or vice-versa: update, if possible, but not insert a new
row. In these cases you can pass the `force_insert=True` or
`force_update=True` parameters to the [`save()`](#django.db.models.Model.save) method.
Passing both parameters is an error: you cannot both insert *and* update at the
same time!

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.

> **Changed in Django 6.0**
>
> When a forced update does not affect any rows a
> [`NotUpdated`](/ga/6.1/ref/models/class/#django.db.models.Model.NotUpdated) exception is raised. On previous
> versions a generic [`django.db.DatabaseError`](/ga/6.1/ref/exceptions/#django.db.DatabaseError) was raised.

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

The process can be made robust, [avoiding a race condition](/ga/6.1/ref/models/expressions/#avoiding-race-conditions-using-f), as well as slightly faster by expressing
the update relative to the original field value, rather than as an explicit
assignment of a new value. Django provides [Nathanna \`\`F () \`\`](/ga/6.1/ref/models/expressions/#f-expressions) for performing
this kind of relative update. Using [Nathanna \`\`F () \`\`](/ga/6.1/ref/models/expressions/#f-expressions), the previous example
is expressed as:

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

For more details, see the documentation on [Nathanna \`\`F () \`\`](/ga/6.1/ref/models/expressions/#f-expressions) and their
[use in update queries](/ga/6.1/topics/db/queries/#topics-db-queries-update).

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

When saving a model fetched through deferred model loading
([`only()`](/ga/6.1/ref/models/querysets/#django.db.models.query.QuerySet.only) or
[`defer()`](/ga/6.1/ref/models/querysets/#django.db.models.query.QuerySet.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.

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

Issues an SQL `DELETE` for the object. This only deletes the object in the
database; the Python instance will still exist and will still have data in
its fields, except for the primary key set to `None`. This method returns the
number of objects deleted and a dictionary with the number of deletions per
object type. The return value will count instances from related models if
Django is emulating cascade behavior via Python [`on_delete`](/ga/6.1/ref/models/fields/#django.db.models.ForeignKey.on_delete)
variants. Otherwise, for database variants such as
[`DB_CASCADE`](/ga/6.1/ref/models/fields/#django.db.models.DB_CASCADE), the return value will report only
instances of the [`QuerySet`](/ga/6.1/ref/models/querysets/#django.db.models.query.QuerySet)'s model.

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

> **Changed in Django 6.1**
>
> Support for the `DB_*` variants of `on_delete` attribute was added.

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

The `__hash__()` method is based on the instance's primary key value. It
is effectively `hash(obj.pk)`. If the instance doesn't have a primary key
value then a `TypeError` will be raised (otherwise the `__hash__()`
method would return different values before and after the instance is
saved), but changing the [`__hash__()`](https://docs.python.org/3/reference/datamodel.html#object.__hash__) value of an instance is
forbidden in 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
```

While this code is correct and simple, it may not be the most portable way
to write this kind of method. The [`reverse()`](/ga/6.1/ref/urlresolvers/#django.urls.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ú.

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

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

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

In addition to [`save()`](#django.db.models.Model.save), [`delete()`](#django.db.models.Model.delete), a model object
might have some of the following methods:

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

The `ModelState` object has three attributes: `adding`, a flag which is
`True` if the model has not been saved to the database yet, `db`, a
string referring to the database alias the instance was loaded from or
saved to, and `fetch_mode`, the [fetch mode](/ga/6.1/topics/db/fetch-modes/) to be used in subsequent field fetches.

Newly instantiated instances have `adding=True` and `db=None`,
since they are yet to be saved, and `fetch_mode=models.FETCH_ONE`.
Instances fetched from a `QuerySet` will have `adding=False`, `db`
set to the alias of the associated database, and `fetch_mode` copied
from the queryset's fetch mode.

> **Changed in Django 6.1**
>
> The `fetch_mode` attribute was added.

### `_is_pk_set()`

#### `Model._is_pk_set()`

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. A
`DatabaseDefault` on an unsaved instance is considered unset.

> **Changed in Django 6.1**
>
> In earlier versions, `True` was returned for `DatabaseDefault`
> values.