---
title: "Tagairt réimse múnla"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/ref/models/fields/
canonical: https://djangodocs.dev/ga/6.0/ref/models/fields/
---
# Tagairt réimse múnla

Tá na tagairtí API go léir sa doiciméad seo de:class: Field lena n-áirítear na [roghanna réimse](#field-options) agus [cineálacha réimse](#field-types) a thairgeann Django.

> **See also**
>
> Mura ndéanann na réimsí ionsuite an cleas, is féidir leat triail a bhaint aith:pypi: django-localflavor ([documentation](#documentation) \< <https://django-localflavor.readthedocs.io/>\>), ina bhfuil píosaí éagsúla cód atá úsáideach do thíortha agus cultúir áirithe.
>
> Chomh maith leis sin, is féidir leat go héasca: doc: scríobh do réimsí samhail saincheaptha féin. \</howto/custom-model-fields\>

> **Note**
>
> Sainmhínítear réimsí in:mod: django.db.models.fields, ach ar mhaithe le háisiúlacht déantar iad a allmhairiú chuig: mod: django.db.models. Is é an coinbhinsiún caighdeánach ná ó samhlacha allmhairiúcháin django.db a úsáid agus tagairt a dhéanamh do réimsí mar samhlacha. \<Foo\>Réimse \`.

## Roghanna réimse

Tá na hargóintí seo a leanas ar fáil do gach cineál réimse. Tá gach ceann roghnach.

### `Null`

#### `Field.null`

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

Avoid using [`null`](#django.db.models.Field.null) on string-based fields such as
[`CharField`](#django.db.models.CharField) and [`TextField`](#django.db.models.TextField). The Django convention is to use an
empty string, not `NULL`, as the "no data" state for string-based fields. If
a string-based field has `null=False`, empty strings can still be saved for
"no data". If a string-based field has `null=True`, that means it has two
possible values for "no data": `NULL`, and the empty string. In most cases,
it's redundant to have two possible values for "no data". One exception is when
a [`CharField`](#django.db.models.CharField) has both `unique=True` and `blank=True` set. In this
situation, `null=True` is required to avoid unique constraint violations when
saving multiple objects with blank values.

Maidir le réimsí sreanga-bhunaithe agus neamh-shreanga-bhunaithe araon, beidh ort `Blank = True` a shocrú más mian leat luachanna folmha a cheadú i bhfoirmeacha, mar ní théann an paraiméadar: attr: ~field.null ach ar stóráil bunachar sonraí (féach: attr: ~field.blank).

> **Note**
>
> Agus cúltaca bunachar sonraí Oracle á úsáid agat, stóráilfear an luach `NULL` chun an teaghrán folamh a léiriú beag beann ar an tréith seo.

### `blank`

#### `Field.blank`

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

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

> **Luachanna atá in easnamh a**
>
> Is féidir `Blank=True` a úsáid le réimsí a bhfuil Null=False\`, ach beidh gá aige seo: meth: ~django.db.models.model.clean a chur i bhfeidhm ar an tsamhail d'fhonn aon luachanna atá in easnamh a sholáthar go clárach.

### `roghnaí`

#### `Field.choices`

Mapáil nó athraitheach san fhormáid a thuairiscítear thíos le húsáid mar roghanna don réimse seo. Má thugtar roghanna, déantar iad a fhorfhe \<validating-objects\>idhmiú trí:ref: bailíochtú samhail agus is bosca roghnaithe is é an giuirléid fhoirme réamhshocraithe leis na roghanna seo in ionad an réimse téacs caighdeánach.

Má thugtar mapáil, is é an príomhghné an luach iarbhír atá le socrú ar an tsamhail, agus is é an dara gné an t-ainm inléite don duine. Mar shampla:

```
YEAR_IN_SCHOOL_CHOICES = {
    "FR": "Freshman",
    "SO": "Sophomore",
    "JR": "Junior",
    "SR": "Senior",
    "GR": "Graduate",
}
```

Is féidir leat: téarma a rith freisin: seicheamh ina bhfuil athrá de dhá mhír díreach (m.sh. `[(A1, B1), (A2, B2),...]`). Is é an chéad eilimint i ngach tuple an luach iarbhír atá le socrú ar an tsamhail, agus is é an dara gné an t-ainm inléite le duine. Mar shampla:

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

Is féidir “roghanna” a shainiú freisin mar ghlaoiteoir nach bhfuil ag súil le haon argóintí agus nach bhfilleann aon cheann de na formáidí a thuairiscítear thuas. Mar shampla:

```
def get_currencies():
    return {i: i for i in settings.CURRENCIES}

class Expense(models.Model):
    amount = models.DecimalField(max_digits=10, decimal_places=2)
    currency = models.CharField(max_length=3, choices=get_currencies)
```

Is féidir go mbeadh sé áisiúil go háirithe le haghaidh “roghanna” a rith nuair is iad, mar shampla, na roghanna seo a leanas:

- toradh oibríochtaí I/O-cheangailte (a d'fhéadfaí a choscáil), mar shampla tábla a cheistiú sa bhunachar sonraí céanna nó sa bhunachar sonraí seachtrach, nó rochtain a fháil ar na roghanna ó chomhad statach.
- liosta atá cobhsaí den chuid is mó ach a d'fhéadfadh athrú ó am go ham nó ó thionscadal go tionscadal. Is iad samplaí sa chatagóir seo aipeanna tríú páirtí a úsáid a sholáthraíonn fardal aitheanta luachanna, mar shampla airgeadraí, tíortha, teangacha, criosanna ama, srl.

Go ginearálta, is fearr roghanna a shainiú taobh istigh de rang samhail, agus tairiseach ainmnithe go cuí a shainiú do gach luach:

```
from django.db import models

class Student(models.Model):
    FRESHMAN = "FR"
    SOPHOMORE = "SO"
    JUNIOR = "JR"
    SENIOR = "SR"
    GRADUATE = "GR"
    YEAR_IN_SCHOOL_CHOICES = {
        FRESHMAN: "Freshman",
        SOPHOMORE: "Sophomore",
        JUNIOR: "Junior",
        SENIOR: "Senior",
        GRADUATE: "Graduate",
    }
    year_in_school = models.CharField(
        max_length=2,
        choices=YEAR_IN_SCHOOL_CHOICES,
        default=FRESHMAN,
    )

    def is_upperclass(self):
        return self.year_in_school in {self.JUNIOR, self.SENIOR}
```

Cé gur féidir leat liosta roghanna a shainiú lasmuigh de rang samhail agus tagairt a dhéanamh dó, coinníonn na roghanna agus ainmneacha do gach rogha laistigh den rang samhail an fhaisnéis sin go léir leis an rang a úsáideann í, agus cabhraíonn sé leis na roghanna a thagairt (m.sh., oibreoidh `Student.sophomore` áit ar bith a allmhairigh an tsamhail `Student`).

Is féidir leat na roghanna atá ar fáil a bhailiú i ngrúpaí ainmnithe is féidir iad a úsáid chun críocha eagraíochtúla:

```
MEDIA_CHOICES = {
    "Audio": {
        "vinyl": "Vinyl",
        "cd": "CD",
    },
    "Video": {
        "vhs": "VHS Tape",
        "dvd": "DVD",
    },
    "unknown": "Unknown",
}
```

Is é eochair na mapála an t-ainm atá le cur i bhfeidhm ar an ngrúpa agus is é an luach na roghanna taobh istigh den ghrúpa sin, comhdhéanta de luach an réimse agus ainm inléite don duine le haghaidh rogha. Is féidir roghanna grúpáilte a chomhcheangal le roghanna neamhghrúpáilte laistigh de mhapáil amháin (mar shampla an rogha "neamhfhiosna"\` sa sampla seo).

Is féidir leat seicheamh a úsáid freisin, m.sh. liosta de 2-tuples:

```
MEDIA_CHOICES = [
    (
        "Audio",
        (
            ("vinyl", "Vinyl"),
            ("cd", "CD"),
        ),
    ),
    (
        "Video",
        (
            ("vhs", "VHS Tape"),
            ("dvd", "DVD"),
        ),
    ),
    ("unknown", "Unknown"),
]
```

Tabhair faoi deara gur féidir le roghanna a bheith ina réad seicheamh ar bith - ní gá gur liosta nó tuple. Ligeann sé seo duit roghanna a thógáil go dinim Ach má aimsíonn tú féin ag hacáil: attr: ~field.choices a bheith dinimiciúil, is dócha go mbeidh tú níos fearr tábla bunachar sonraí ceart a úsáid le a:class: ForeignKey. :attr: Tá ~Field.choices i gceist le haghaidh sonraí statacha nach n-athraíonn mórán, más riamh.

> **Note**
>
> Cruthaítear imirce nua gach uair a athraíonn ord na “roghanna”.

I gcás gach réimse samhail a bhfuil: attr: ~ field.choices tacar aige, normalóidh Django na roghanna le liosta de 2-tuples agus cuirfidh sé modh chun an t-ainm inléite don duine a aisghabháil do luach reatha an réimse. Féach: Meth: ~django.db.models.model.get\_foo\_display sa cháipéisíocht API bunachar sonraí.

Unless:attr: Blank = Fal \<Field.blank\>se \`socraítear ar an réimse in éineacht le a:attr: \`~field.default ansin déanfar lipéad ina bhfuil `” ---------"` a rinneadh leis an mbosca roghnaithe. Chun an t-iompar seo a shárú, cuir tuple le `roghnaí` ina bhfuil `None`; m.sh. `(Níl aon, 'Do String Le Taispeán')`. De rogha air sin, is féidir leat teaghrán folamh a úsáid in ionad `None` nuair a bhíonn ciall leis seo - mar shampla ar a:class: ~django.db.models.charfield.

#### Cineálacha áireamh

Ina theannta sin, soláthraíonn Django cineálacha áireamh ar féidir leat a fho-aicmiú chun roghanna a shainiú ar bhealach gonta:

```
from django.utils.translation import gettext_lazy as _

class Student(models.Model):
    class YearInSchool(models.TextChoices):
        FRESHMAN = "FR", _("Freshman")
        SOPHOMORE = "SO", _("Sophomore")
        JUNIOR = "JR", _("Junior")
        SENIOR = "SR", _("Senior")
        GRADUATE = "GR", _("Graduate")

    year_in_school = models.CharField(
        max_length=2,
        choices=YearInSchool,
        default=YearInSchool.FRESHMAN,
    )

    def is_upperclass(self):
        return self.year_in_school in {
            self.YearInSchool.JUNIOR,
            self.YearInSchool.SENIOR,
        }
```

Oibríonn siad seo cosúil le:mod: enum ó leabharlann caighdeánach Python, ach le roinnt modhnuithe:

- Is cúpla argóintí iad luachanna ball Enum le húsáid agus an cineál sonraí coincréite á thógáil. Tacaíonn Django le luach sreangán breise a chur le deireadh an tuple seo le húsáid mar an t-ainm inléite don duine, nó “lipéad”. Is féidir leis an lipéad\` a bheith ina shreang leisciúil inaistrithe. Dá bhrí sin, i bhformhór na gcásanna, is é an luach ball ná `(luach, lipéad)` 2-tuple. Féach thíos le haghaidh: ref: sampla de roghanna fo-aicmiúcháin \<field-choices-enum-subclassing\>\`ag baint úsáide as cineál sonraí níos casta. \<field-choices-enum-auto-label\>Mura gcuirtear tuple ar fáil, nó mura bhfuil teaghrán (leisciúil) an mír deireanach, is é an \`lipéad\`: ref: ghintear go huathoibríoch ó ainm an chomhalta.
- Cuirtear maoin .label\` leis na luachanna, chun an t-ainm inléite don duine a thabhairt ar ais.
- Cuirtear roinnt airíonna saincheaptha leis na haicmí áireamh -- .choices\`, .labels\`, .values\`, agus .ainmne\` \- chun go mbeidh sé níos éasca rochtain a fháil ar liostaí de na codanna ar leithligh sin den áireamh.

  > **Warning**
  >
  > Ní féidir na hainmneacha maoine seo a úsáid mar ainmneacha ball mar go mbeadh siad ag coinbhleacht.
- The use of [`enum.unique()`](https://docs.python.org/3/library/enum.html#enum.unique) is enforced to ensure that values cannot be
  defined multiple times. This is unlikely to be expected in choices for a
  field.

Tabhair faoi deara go n-oibríonn úsáid `YearinSchool.Senior`, YearinSchool \['SENIOR'\] \`, nó \`\`YearinSchool ('SR') \`\`chun rochtain a fháil nó cuardach ar na baill mar a bhíothas ag súil leis, mar a dhéanann na hairíonna \`.name\` agus `.value` ar na baill.

Mura gá duit na hainmneacha inléite don duine a aistriú, is féidir leat iad a thabhairt chun cinn ó ainm an chomhalta (spásanna a chur in ionad béim agus cás teidil a úsáid):

```pycon
>>> class Vehicle(models.TextChoices):
...     CAR = "C"
...     TRUCK = "T"
...     JET_SKI = "J"
...
>>> Vehicle.JET_SKI.label
'Jet Ski'
```

Ós rud é go bhfuil an cás ina gcaithfidh na luachanna enum a bheith ina shláimhreacha thar a bheith coitianta, soláthraíonn Django aicme IntegerChoices\`. Mar shampla:

```
class Card(models.Model):
    class Suit(models.IntegerChoices):
        DIAMOND = 1
        SPADE = 2
        HEART = 3
        CLUB = 4

    suit = models.IntegerField(choices=Suit)
```

Is féidir freisin úsáid a bhaint as an [Enum Functional API](#enum-functional-api) leis an rabhadh go ngintear lipéid go huathoibr\< <https://docs.python.org/3/howto/enum.html#functional-api>\> íoch mar a leagtar béim thuas:

```pycon
>>> MedalType = models.TextChoices("MedalType", "GOLD SILVER BRONZE")
>>> MedalType.choices
[('GOLD', 'Gold'), ('SILVER', 'Silver'), ('BRONZE', 'Bronze')]
>>> Place = models.IntegerChoices("Place", "FIRST SECOND THIRD")
>>> Place.choices
[(1, 'First'), (2, 'Second'), (3, 'Third')]
```

Má theastaíonn tacaíocht uait do chineál sonraí coincréite seachas `int` nó `str`, is féidir leat fo-aicme Roghanna agus an cineál sonraí coincréite riachtanach, e.g.:class: ~datetime.date le húsáid le:class: ~django.db.models.datefield:

```
class MoonLandings(datetime.date, models.Choices):
    APOLLO_11 = 1969, 7, 20, "Apollo 11 (Eagle)"
    APOLLO_12 = 1969, 11, 19, "Apollo 12 (Intrepid)"
    APOLLO_14 = 1971, 2, 5, "Apollo 14 (Antares)"
    APOLLO_15 = 1971, 7, 30, "Apollo 15 (Falcon)"
    APOLLO_16 = 1972, 4, 21, "Apollo 16 (Orion)"
    APOLLO_17 = 1972, 12, 11, "Apollo 17 (Challenger)"
```

Tá roinnt rabhaidh breise le bheith ar an eolas faoi:

- \<field-choices-named-groups\>Ní thacaíonn cineálacha áirim:ref: grúpaí ainmnithe .
- Toisc go n-éilíonn áireamh le cineál sonraí coincréite go léir an cineál a mheaitseáil, ní féidir an lipéad: ref: blank \<field-choices-blank-label\>\`a bhaint amach trí bhall a chruthú le luach \`\`None\`. Ina áit sin, socraigh an tréith `__empty__` ar an rang:

  ```
  class Answer(models.IntegerChoices):
      NO = 0, _("No")
      YES = 1, _("Yes")

      __empty__ = _("(Unknown)")
  ```

### `db_column`

#### `Field.db_column`

Ainm an cholún bunachar sonraí le húsáid don réimse seo. Mura dtugtar é seo, úsáidfidh Django ainm an réimse.

Más focal fhorchoimeádaithe SQL é ainm do cholún bunachar sonraí, nó má tá carachtair nach gceadaítear in ainmneacha athróg Python - go háirithe, an bhreith - tá sin ceart go leor. Luann Django ainmneacha colún agus tábla taobh thiar de na radhairc.

### db\_comment \`\`

#### `Field.db_comment`

An trácht ar an gcolún bunachar sonraí le húsáid don réimse seo. Tá sé úsáideach chun réimsí a dhoiciméadú do dhaoine aonair a bhfuil rochtain dhíreach acu ar bhunachar sonraí nach bhfuil ag féachaint ar do chód Django. Mar shampla:

```
pub_date = models.DateTimeField(
    db_comment="Date and time when the article was published",
)
```

### `db_default`

#### `Field.db_default`

An luach réamhshocraithe ríofa bunachar sonraí don réimse seo. Is féidir leis seo a bheith ina luach litriúil nó ina fheidhm bunachar sonraí, mar shampla:class: ~Django.db.Models.Functions.Now:

```
created = models.DateTimeField(db_default=Now())
```

Is féidir nathanna níos casta a úsáid, chomh fada agus a dhéantar iad ó litríochtaí agus feidhmeanna bunachar sonraí:

```
month_due = models.DateField(
    db_default=TruncMonth(
        Now() + timedelta(days=90),
        output_field=models.DateField(),
    )
)
```

Ní féidir le réamhshocraithe bunachar sonraí réimsí nó samhlacha eile tagairt a dhéanamh. Mar shampla, tá sé seo neamhbhailí:

```
end = models.IntegerField(db_default=F("start") + 50)
```

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

Má tá db\_default\` i réimse gan tacar `default` agus nach sanntar aon luach don réimse, cuirtear réad `databasedefault` ar ais mar luach an réimse ar chásanna samhail neamhshábháilte. Is é an bunachar sonraí a chinneann an luach iarbhír don réimse nuair a shábháiltear an tsamhail samhail.

### `db_index`

#### `Field.db_index`

Má tá `True`, cruthófar innéacs bunachar sonraí don réimse seo.

> **Úsáid an rogha: attr: ~Options.indexes ina ionad.**
>
> \<Options.indexes\>Nuair is féidir, bain úsáid as an roghna:attr: Meta.Indexes \`ina ionad. I mbeagnach gach cás, soláthraíonn :attr: \`~Options.indexes níos mó feidhmiúlachta ná db\_index \`. D'fhéadfadh go mbeadh db\_index a dhíchur sa todhchaí.

### `db_tablespace`

#### `Field.db_tablespace`

Ainm an:doc: database tablespace le húsáid le haghaidh innéacs an réimse seo \</topics/db/tablespaces\>, má tá an réimse seo innéacsaithe. Is é an réamhshocrú an socrú tionscadla:setting: DEFAULT\_INDEX\_TABLESPACE, má tá sé socraithe, nó an:attr: ~OPTIONS.DB\_TABLESPACE den tsamhail, más ann. Mura dtacaíonn an cúltaca le spásanna tábla le haghaidh innéacsanna, déantar neamhaird ar an rogha seo.

### `réamhshocraithe`

#### `Field.default`

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

Ní féidir leis an réamhshocrú a bheith ina réad inathraithe (sampla samhail, `liost`, set\`, srl.), Mar a úsáidfeadh tagairt don sampla céanna den réad sin mar an luach réamhshocraithe i ngach cás samhail nua. Ina áit sin, fillte an réamhshocrú atá ag teastáil i nglaoch inghlaonta Mar shampla, más mian leat réamhshocraithe `dict` a shonrú fao:class: ~django.db.models.jsonField, bain úsáid as feidhm:

```
def contact_default():
    return {"email": "to1@example.com"}

contact_info = JSONField("ContactInfo", default=contact_default)
```

\<migration-serializing\>Ní féidir `lambda`s a úsáid le haghaidh roghanna réimse cosúil le `default` toisc nach féidir leo a bheith: ref: sraith ag imirce . Féach an doiciméadú sin le haghaidh rabhaidh eile.

Maidir le réimsí cosúil:class: ForeignKey a léarscáil chuig cásanna samhail, ba chóir go mbeadh réamhshocraithe mar luach an réimse a thagraíonn siad (`pk` unless:attr: ~ForeignKey.to\_field socraítear) in ionad cásanna samhail.

Úsáidtear an luach réamhshocraithe nuair a chruthaítear cásanna samhail nua agus nach gcuirtear luach ar fáil don réimse. Nuair is príomh-eochair é an réimse, úsáidtear an réamhshocrú freisin nuair a shocraítear an réimse go `None`.

Is féidir an luach réamhshocraithe a shocrú freisin ag leibhéal an bhunachar sonraí le: attr: Field.db\_default.

### `Eagarthóireach`

#### `Field.editable`

If `False`, the field will not be displayed in the admin or any other
[`ModelForm`](/ga/6.0/topics/forms/modelforms/#django.forms.ModelForm). It will also be skipped during [model
validation](/ga/6.0/ref/models/instances/#validating-objects). Default is `True`.

### `teachtaireachtaí earráid`

#### `Field.error_messages`

Ligeann an argóint `error_messages` duit na teachtaireachtaí réamhshocraithe a ardóidh an réimse a shárú. Pas isteach i bhfoclóir le heochracha a mheaitseálann leis na teachtaireachtaí earráide is mian leat a shárú.

I measc na heochracha teachtaireachta earráide tá `null`, blank\`, invalid\`, invalid\_choice\`, `unique`, agus `unique_for_date`. Sonraítear eochracha teachtaireachta earráide breise do gach réimse sa chuid [Cineálacha réimsea](#field-types) thíos.

Is minic nach n-iomadaíonn na teachtaireachtaí earráide seo chuig foirmeacha. Féach:ref: breithnitheachtaireachtaí maidir le samhail-earráidí teachtaireachtaí .

### `téacs_cabhrach`

#### `Field.help_text`

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

Tabhair faoi deara nach bhfuil an luach seo\* ag éalú HTML i bhfoirmeacha a ghintear go huathoibríoch. Ligeann sé seo duit HTML a áireamh in:attr: ~field.help\_text más mian leat. Mar shampla:

```
help_text = "Please use the following format: <em>YYYY-MM-DD</em>."
```

Nó is féidir leat gnáthtéacs agus: func: django.utils.html.escape a úsáid chun éalú aon charachtair speisialta HTML. Cinntigh go n-éalaíonn tú aon téacs cabhrach a d'fhéadfadh teacht ó úsáideoirí neamhiontaofa chun ionsaí scripteála tras-láithreáin a sheachaint.

### `eochair_phríomh`

#### `Field.primary_key`

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

If you don't specify `primary_key=True` for any field in your model and have
not defined a composite primary key, Django will automatically add a field to
hold the primary key. So, you don't need to set `primary_key=True` on any of
your fields unless you want to override the default primary-key behavior. The
type of auto-created primary key fields can be specified per app in
[`AppConfig.default_auto_field`](/ga/6.0/ref/applications/#django.apps.AppConfig.default_auto_field)
or globally in the [`DEFAULT_AUTO_FIELD`](/ga/6.0/ref/settings/#std-setting-DEFAULT_AUTO_FIELD) setting. For more, see
[Príomhréimsí uathoibríoch](/ga/6.0/topics/db/models/#automatic-primary-key-fields).

`primary_key=True` implies [`null=False`](#django.db.models.Field.null) and
[`unique=True`](#django.db.models.Field.unique). Only one field per model can set
`primary_key=True`. Composite primary keys must be defined using
[`CompositePrimaryKey`](#django.db.models.CompositePrimaryKey) instead of setting this flag to `True` for all
fields to maintain this invariant.

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

\<django.db.models.Model.delete\>Socraítear an príomhréimse go `None` nuai:meth: scriosadh réad.

> **Changed in Django 5.2**
>
> The `CompositePrimaryKey` field was added.

### `uath`

#### `Field.unique`

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

Cuirtear é seo i bhfeidhm ag leibhéal an bhunachar sonraí agus trí bhailíochtú samhail Má dhéanann tú iarracht samhail a shábháil le luach dúbailte i réimse a:attr: ~Field.Unique, ardófar a:exc: Django.db.IntegrityError ag an modh samhail 's:meth: ~django.db.models.model.save.

Tá an rogha seo bailí ar gach cineál réimse seachas: class: ManyTomanyField agus:class: OneToOneField.

Tabhair faoi deara go bhfuil `unique` `True`, ní gá duit:attr: ~field.db\_index a shonrú, mar tugann `unique` le tuiscint go gcruthófar innéacs.

### uath\_dáta\`

#### `Field.unique_for_date`

Socraigh é seo ar ainm a: class: DateField nó:class: DateTimeField chun a cheangal go mbeidh an réimse seo uathúil do luach an réimse dáta.

Mar shampla, má tá réimse `title` agat a bhfuil ```unique_for_date="pub_date” ``, ansin ní cheadódh Django dhá thaifead a iontráil leis an ``title``` agus `pub_date` céanna.

Tabhair faoi deara má shocraíonn tú é seo chun díriú ar a: class: DateTimeField, ní dhéanfar ach an chuid dáta den réimse a mheas. \<default-current-time-zone\>Thairis sin, nuair a bhíonn: socrú: USE\_TZ `True`, déanfar an seiceáil san: ref: crios ama reatha ag an am a shábháiltear an réad.

This is enforced by [`Model.validate_unique()`](/ga/6.0/ref/models/instances/#django.db.models.Model.validate_unique) during model validation
but not at the database level. If any [`unique_for_date`](#django.db.models.Field.unique_for_date) constraint
involves fields that are not part of a [`ModelForm`](/ga/6.0/topics/forms/modelforms/#django.forms.ModelForm) (for
example, if one of the fields is listed in `exclude` or has
[`editable=False`](#django.db.models.Field.editable)), [`Model.validate_unique()`](/ga/6.0/ref/models/instances/#django.db.models.Model.validate_unique) will
skip validation for that particular constraint.

### `uach_ar feadh míosa`

#### `Field.unique_for_month`

Cosúil le: attr: ~field.unique\_for\_date, ach éilíonn sé go mbeadh an réimse uathúil maidir leis an mí.

### `Unique_doir_bliana`

#### `Field.unique_for_year`

Cosúil le: attr: ~Field.Unique\_for\_Date agus:attr: ~Field.Unique\_for\_Month.

### `ainm_verbose`

#### `Field.verbose_name`

Ainm inléite don duine don réimse. Mura dtugtar an t-ainm fhíorúil, cruthóidh Django é go huathoibríoch ag baint úsáide as ainm tréith an réimse, ag athrú béim go spásanna. \<verbose-field-names\>Féach:ref: Ainmneacha réimse verbose .

### bailíochtóirí \`\`

#### `Field.validators`

Liosta de na bailíochtóirí le reáchtáil don réimse seo. Féach na:doc: doiciméadú bailíochtóir le haghaidh tuilleadh eolais. \</ref/validators\>

## Cineálacha réimse

### `Autofield`

#### `class AutoField(**options)`

An:class: Integerfield a mhéadaíonn go huathoibríoch de réir ID atá ar fáil. De ghnáth ní bheidh ort é seo a úsáid go díreach; cuirfear príomhréimse go huathoibríoch le do mhúnla mura sonraíonn tú a mhalairt. Féach: tagairt: uathoibrí-phríomh-eochair-réimsí .

### `BigAutofield`

#### `class BigAutoField(**options)`

Sláimhir 64-giotán, cosúil leis an:class: Autofield ach amháin go bhfuil sé ráthaithe go n-oirfidh sé uimhreacha ó `1` go 9223372036854775807\`.

### `BigIntegerfield`

#### `class BigIntegerField(**options)`

Sláimhir 64-giotán, cosúil leis an:class: IntegerField ach amháin go bhfuil sé ráthaithe go n-oirfidh sé uimhreacha ó ```-9223372036854775808` go ``9223372036854775807```. Is é a: class: ~django.forms.numberInput an giuirléid foirme réamhshocraithe don réimse seo.

### `Binaryfield`

#### `class BinaryField(max_length=None, **options)`

Réimse chun sonraí dénártha amh a stóráil. Is féidir é a shannt:class: bytes, :class: bytearray, nó:class: memoryview.

De réir réamhshocraithe, socraíonn `BinaryField`: attr: ~Field.editable go `False`, sa chás sin ní féidir é a áireamh in a:class: ~Django.Forms.ModelForm.

#### `BinaryField.max_length`

Roghnach. An fad uasta (i mbeátaí) an réimse. Cuirtear an fad uasta i bhailíochtú Django i bhfeidhm ag baint úsáidea:class: ~django.core.validators.maxLengthValidator.

> **Mí-úsáid Binaryfield**
>
> Cé go bhféadfá smaoineamh ar chomhaid a stóráil sa bhunachar sonraí, smaoinigh gur droch-dhearadh é i 99% de na cásanna. Ní h\* é an réimse seo ina athsholáthar do láimhseáil proper:doc: \</howto/static-files/index\> comhaid stataithe'.

### `Booleanfield`

#### `class BooleanField(**options)`

Réimse fíor-bhréagach.

\<Field.null\>Is é an giuirléid foirme réamhshocraithe don réimse seo ná: class: ~django.forms.checkboxInput, nó:class: ~django.forms.nullBooleanSelect if: attr: Null=True .

Is é luach réamhshocraithe `BooleanField` `None` nuair nach sainmhínítear: attr: Field.default.

### `CompositePrimaryKey`

> **New in Django 5.2**

#### `class CompositePrimaryKey(*field_names, **options)`

A virtual field used for defining a composite primary key.

This field must be defined as the model's `pk` attribute. If present, Django
will create the underlying model table with a composite primary key.

The `*field_names` argument is a list of positional field names that compose
the primary key.

See [Composite primary keys](/ga/6.0/topics/composite-primary-key/) for more details.

### `Charfield`

#### `class CharField(max_length=None, **options)`

Réimse teaghráin, le haghaidh teaghráin beag go mórmhéide.

Le haghaidh méideanna móra téacs, bain úsáid as: class: ~django.db.models.textfield.

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.textInput.

[`CharField`](#django.db.models.CharField) has the following extra arguments:

#### `CharField.max_length`

The maximum length (in characters) of the field. The `max_length`
is enforced at the database level and in Django's validation using
[`MaxLengthValidator`](/ga/6.0/ref/validators/#django.core.validators.MaxLengthValidator). It's required for all
database backends included with Django except PostgreSQL and SQLite, which
supports unlimited `VARCHAR` columns.

> **Note**
>
> Má tá iarratas á scríobh agat a chaithfidh a bheith iniompartha chuig cúltaca iolracha bunachar sonraí, ba chóir duit a bheith ar an eolas go bhfuil srianta ar max\_length \`\`do roinnt cúltaca. Féach go dt:doc: \`nótaí cúltaca bunachar sonraí le haghaidh sonraí \</ref/databases\>.

> **Changed in Django 5.2**
>
> Support for unlimited `VARCHAR` columns was added on SQLite.

#### `CharField.db_collation`

Roghnach. Ainm bailithe bunachar sonraí an réimse.

> **Note**
>
> Níl ainmneacha coláireachta caighdeánaithe. Dá bhrí sin, ní bheidh sé seo iniompartha ar fud iomadúla cúltaca bunachar sonraí.

> **Oracle**
>
> Ní thacaíonn Oracle le comparáidí ach amháin nuair a dhéantar an paraiméadar tionscnaimh bunachar sonraí `MAX_STRING_SIZE` socraithe go EXTENDED\`.

### `Dáta réimse`

#### `class DateField(auto_now=False, auto_now_add=False, **options)`

Dáta, a léirítear i Python le sampla `datetime.date`. Tá cúpla argóint roghnach breise aige:

#### `DateField.auto_now`

Socraigh an réimse go huathoibríoch anois gach uair a shábháiltear an réad. Úsáideach le haghaidh stampaí ama “modhnaithe deireanach”. Tabhair faoi deara go n-úsáidtear an dáta reatha i gcónaí\*; ní luach réamhshocraithe é amháin ar féidir leat a shárú.

\<django.db.models.Model.save\>Ní dhéantar an réimse a nuashonrú go huathoibríoch ach nuair a ghlaoitear: meth: Model.save () . Ní nuashonraítear an réim \<django.db.models.query.QuerySet.update\>se agus nuashonruithe á dhéanamh ar réimsí eile ar bhealaí eile mar: meth: QuerySet.update () , cé gur féidir leat luach saincheaptha don réimse a shonrú i nuashonrú mar sin.

#### `DateField.auto_now_add`

Socraigh an réimse go huathoibríoch go dtí anois nuair a chruthaítear an réad Úsáideach chun stampaí ama a chruthú. Tabhair faoi deara go n-úsáidtear an dáta reatha i gcónaí\*; ní luach réamhshocraithe é amháin ar féidir leat a shárú. Mar sin fiú má shocraíonn tú luach don réimse seo agus an réad á chruthú agat, déanfar neamhaird air. Más mian leat a bheith in ann an réimse seo a mhodhnú, socraigh an méid seo a leanas in ionad `auto_now_add=true`:

- Le haghaidh: aicme: dátefield: `default=date.today` \- ó:meth: datetime.date.today
- Le haghaidh: aicme: DateTimeField: `default=timezone.now` \- ó:func: django.utils.timezone.now

Is é a: class: ~django.forms.DateInput an giuirléid foirme réamhshocraithe don réimse seo. Cuireann an riarachán féilire JavaScript leis, agus aicearra do “Inniu”. Cuimsíonn sé eochair teachtaireachta earráide breise `invalid_date`.

Tá na roghanna `auto_now_add`, auto\_now\`, agus `default` go comhpháirteach. Beidh earráid mar thoradh ar aon teaglaim de na roghanna seo.

> **Note**
>
> Mar a chuirtear i bhfeidhm faoi láthair, beidh `auto_now` nó auto\_now\_add\` nó `auto_now_add` a shocrú go `True` beidh `Editable=False` agus `blank=True` socraithe sa réimse.

> **Note**
>
> \<default-current-time-zone\>Úsáidfidh na roghanna `auto_now` agus `auto_now_add` an dáta i gcónaí sa :ref: crios ama réamhshocraitheo ag nóiméad an chruthaithe nó nuashonraithe. Má theastaíonn rud éigin difriúil uait, b'fhéidir gur mhaith leat smaoineamh ar do réamhshocrú inghlaonta féin nó save () \`\`a shárú in ionad \`\`auto\_now\` nó auto\_now\_add\` a úsáid; nó `DateTimefield` a úsáid in ionad Date\`field\` agus cinneadh conas an tiontú a láimhseáil ó dáta go dtí seo ag am taispeána.

> **Warning**
>
> Úsáid i gcónaí:class: DateField le sampla `datetime.date`.
>
> Má tá sampla `datetime.datetime` agat, moltar é a thiontú go datetime.date\` ar dtús. \<default-current-time-zone\>Mura ndéanann tú, logálfaidh :class: DateField an datetime.datetime\` go dtí an:ref: réamhshocraithe ama 'agus é a thiontú go sampla \`\`datetime.date\`, ag baint a chomhpháirt ama. Tá sé seo fíor maidir le stóráil agus comparáid araon.

> **Warning**
>
> On PostgreSQL and MySQL, arithmetic operations on a `DateField` with a
> [`timedelta`](https://docs.python.org/3/library/datetime.html#datetime.timedelta) return a `datetime` instead of a `date`.
> This occurs because Python's `timedelta` is converted to SQL
> `INTERVAL`, and the SQL operation `date +/- interval` returns a
> `timestamp` on these databases.
>
> To ensure a `date` result, use one of the following approaches. Either
> explicitly cast the result to a date:
>
> ```
> import datetime
> from django.db.models import DateField, F
> from django.db.models.functions import Cast
>
> qs = MyModel.objects.annotate(
>     previous_day=Cast(
>         F("date_field") - datetime.timedelta(days=1),
>         output_field=DateField(),
>     )
> )
> ```
>
> Or on PostgreSQL only, use integer arithmetic to represent days:
>
> ```
> from django.db.models import DateField, ExpressionWrapper, F
>
> qs = MyModel.objects.annotate(
>     previous_day=ExpressionWrapper(
>         F("date_field") - 1,  # Subtract 1 day as integer
>         output_field=DateField(),
>     )
> )
> ```

### `DataTimeField`

#### `class DateTimeField(auto_now=False, auto_now_add=False, **options)`

Dáta agus am, a léirítear i Python le sampla `datetime.datetime`. Glacann sé na hargóintí breise céanna amha:class: DateField.

Is é an giuirléid foirme réamhshocraithe don réimse seo ná aonair: class: ~django.forms.DateTimeInput. Úsáideann an riarachán dhá ghuirléidí leithligh: class: ~django.forms.textInput le aicearraí JavaScript.

> **Warning**
>
> Úsáid i gcónaí:class: DateTimeField le sampla `datetime.datetime`.
>
> Má tá sampla `datetime.date` agat, moltar é a thiontú go datetime.datetime\` ar dtús. \<default-current-time-zone\>Mura ndéanann tú, úsáidfidh :class: DateTimeField meán oíche san :ref: crios ama réamhshocraithe \`don chomhpháirt ama. Tá sé seo fíor maidir le stóráil agus comparáid araon. Chun comparáid a dhéanamh idir an chuid dáta de a:class: \`DateTimeField le sampla `datetime.date`, bain úsáid as an cuardach: lookup: \`dáta.

### `Decimalfield`

#### `class DecimalField(max_digits=None, decimal_places=None, **options)`

Uimhir deachúil cruinneas seasta, arna léiriú i Python ag a: class: ~decimal.decimal sampla. Bailíonn sé an t-ionchur ag baint úsáid:class: ~django.core.validators.decimalValidator.

An bhfuil na hargóintí\*\* riachtana\*\* seo a leanas:

#### `DecimalField.max_digits`

An líon uasta na ndigit a cheadaítear san uimhir. Tabhair faoi deara go gcaithfidh an uimhir seo a bheith níos mó ná nó cothrom le `deach_places`.

#### `DecimalField.decimal_places`

Líon na n-áiteanna deachúil le stóráil leis an uimhir.

Mar shampla, chun uimhreacha a stóráil suas go dtí `999.99` le réiteach de 2 áit deachúil, bheadh úsáid agat:

```
models.DecimalField(..., max_digits=5, decimal_places=2)
```

Agus uimhreacha a stóráil suas le thart ar aon billiún le réiteach de 10 n-áit deachúil:

```
models.DecimalField(..., max_digits=19, decimal_places=10)
```

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.numberInput nuai:attr: ~django.forms.field.localize `False` nó:class: ~django.forms.textInput ar shlí eile.

> **Note**
>
> \<floatfield\_vs\_decimalfield\>Le haghaidh tuilleadh faisnéise faoi na difríochtaí idir na haicm:class: FloatField agus:class: DecimalField, féach le do thoil: FloatField vs DecimalField. Ba chóir duit a bheith ar an eolas freisin fao:ref: Teorainneacha SQLite \<sqlite-decimal-handling\>\`na réimsí deachúil.

### `Réimse tréimhseach`

#### `class DurationField(**options)`

Réimse chun tréimhsí ama a stóráil - múnlaithe i Python ag: class: ~python:datetime.timedelta. Nuair a úsáidtear é ar PostgreSQL, is é “interval” an cineál sonraí a úsáidtear agus ar Oracle is é an cineál sonraí INTERVAL DAY (9) GO SECOND (6) . Seachas sin úsáidtear “bigint” de mhicreasoicind.

> **Note**
>
> Oibríonn uimhríocht le `DurationField` i bhformhór na gcásanna. Mar sin féin, ar gach bunachar sonraí seachas PostgreSQL, ní oibreoidh comparáid idir luach ```DurationField` agus uimhrithíocht ar chásanna ``DateTimeField``` mar a bhíothas ag súil leis.

### `Réimse ríomhphost`

#### `class EmailField(max_length=254, **options)`

A: aicme: Charfield a sheiceálann gur seoladh ríomhphoist bailí é an luach ag baint úsáid:class: ~django.core.validators.emailValidator.

### `FileField`

#### `class FileField(upload_to='', storage=None, max_length=100, **options)`

Réimse uaslódála comhad.

> **Note**
>
> Ní thacaítear leis an argóint primary\_key\` agus ardóidh sé earráid má úsáidtear é.

Tá na hargóintí roghnacha seo a leanas ann

#### `FileField.upload_to`

Soláthraíonn an tréith seo bealach chun an eolaire uaslódála agus ainm an chomhaid a shocrú, agus is féidir é a shocrú ar dhá bhealach. \<django.core.files.storage.Storage.save\>Sa dá chás, cuirtear an luach ar aghaidh chuig an modh:: Storage.save () .

Má shonraíonn tú luach teaghrán nó a:class: ~pathlib.path, féadfaidh formáidiú: func: ~time.strftime a bheith ann, a chuirfear dát/am an uaslódála comhad in ionad (ionas nach líonfaidh comhaid uaslódáilte an eolaire tugtha suas). Mar shampla:

```
class MyModel(models.Model):
    # file will be uploaded to MEDIA_ROOT/uploads
    upload = models.FileField(upload_to="uploads/")
    # or...
    # file will be saved to MEDIA_ROOT/uploads/2015/01/30
    upload = models.FileField(upload_to="uploads/%Y/%m/%d/")
```

Má tá an réamhshocraithe:class: ~django.core.files.storage.filesystemStorage á úsáid agat, cuirfear an luach teaghrán i gceangal le do chonair:: MEDIA\_ROOT chun an suíomh a fhoirmiú ar an gcóras comhaid áitiúil ina stóráilfear comhaid uaslódáilte. Má tá stóráil dhifriúil á úsáid agat, seiceáil doiciméadú an stórála sin chun a fheiceáil conas a láimhseálann sé upload\_\`.

D'fhéadfadh go mbeadh `upload_to` inghlaonta freisin, mar shampla feidhm. Glaofar air seo chun an cosán uaslódála a fháil, lena n-áirítear ainm an chomhaid. Caithfidh an glaoch seo glacadh le dhá argóint agus cosán i stíl Unix a thabhairt ar ais (le slashes ar aghaidh) le dul chuig an gcóras stórála. Is iad an dá argóint:

| Argóint | Cur síos |
| --- | --- |
| `Instance` | Sampla den tsamhail ina bhfuil an FileField\` sainmhínithe. Níos sonrach, is é seo an cás áirithe ina bhfuil an comhad reatha á gceangal.<br><br>I bhformhór na gcásanna, ní shábháiltear an réad seo ar an mbunachar sonraí go fóill, mar sin má úsáideann sé an réamhshocraithe Autofield\`, *b'fhéidir nach mbeidh luach aige fós dá phríomhréimse*. |
| ainm comhad \`\` | An t-ainm comhaid a tugadh don chomhad ar dtús. Féadfar nó nach féidir é seo a chur san áireamh agus an cosán ceann scríbe deiridh á chinneadh. |

Mar shampla:

```
def user_directory_path(instance, filename):
    # file will be uploaded to MEDIA_ROOT/user_<id>/<filename>
    return "user_{0}/{1}".format(instance.user.id, filename)

class MyModel(models.Model):
    upload = models.FileField(upload_to=user_directory_path)
```

#### `FileField.storage`

Rud stórála, nó inghlaoch a thugann réad stórála ar ais. Láimhseálann sé seo stóráil agus aisghabháil do chuid comhad. Féach: doc: /topics/files le haghaidh sonraí maidir le conas an réad seo a sholáthar.

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.clearaableFileInput.

Tógann sé cúpla céim ag baint úsáide as a: class: FileField nó an:class: ImageField (féach thíos) i samhail:

1. I do chomhad socruithe, beidh ort :setting:'MEDIA\_ROOT' a shainmhíniú mar an cosán iomlán chuig eolaire inar mhaith leat Django chun comhaid uaslódáilte a stóráil. (Le haghaidh feidhmíochta, ní stóráiltear na comhaid seo sa bhunachar sonraí.) Sainmhínigh :setting:'MEDIA\_URL' mar bhun-URL poiblí an eolaire sin. Cinntigh go bhfuil an chomhadlann seo inscríofa ag cuntas úsáideora an fhreastalaí gréasáin.
2. Cuir an:class: FileField nó:class: ImageField le do mhúnla, ag sainmhíniú an roghna:attr: ~filefield.upload\_to chun fo-eolaire de:setting: MEDIA\_ROOT a shonrú le húsáid le haghaidh comhaid uaslódáilte.
3. Is é gach rud a stóráilfear i do bhunachar sonraí ná cosán chuig an gcomhad (i gcoibhneas le:socrú: MEDIA\_ROOT). Is dócha go mbeidh tú ag iarraidh an tréith áisiúlach:attr: ~django.db.models.fields.files.fieldfile.url a sholáthraíonn Django a úsáid. Mar shampla, má thugtar `mug_shot` ar do: class: ImageField, is féidir leat an cosán iomlán chuig d'íomhá a fháil i dteimpléad le `{{object.mug_shot.url}}`.

Mar shampla, abair go bhfuil do: setting: MEDIA\_ROOT socraithe go `'/home/media'`, agus:attr: ~filefield.upload\_to socraithe go `'Photos/%y/%M/%D'`. Is é an `'%Y/%M/%D'` cuid de:attr: ~filefield.upload\_to í:func: ~time.strftime formáidiú; `'%Y'` an bhliain ceithre dhigit, `%m'` an mhí dhá dhigit agus `'%d'` an lá dhá dhigit. Má uaslódálann tú comhad ar 15 Eanáir, 2007, sábhálfar é san eolaire `/home/media/photos/2007/01/15`.

Más mian leat ainm comhaid ar dhiosca an chomhaid uaslódáilte, nó méid an chomhaid a aisghabháil, d'fhéadfá na tréithe: attr: ~django.core.files.name agus:attr: ~django.core.file.size a úsáid faoi seach; le haghaidh tuilleadh faisnéise ar na tréithe agus na modhanna atá ar fáil, féach rang:class: ~django.core.files.file agus an treoir ábhair: doc: /topics/files.

> **Note**
>
> Sábháiltear an comhad mar chuid den tsamhail a shábháil sa bhunachar sonraí, mar sin ní féidir brath ar an ainm comhaid iarbhír a úsáidtear ar dhiosca go dtí go ndéanfar an tsamhail a shábháil.

Is féidir URL coibhneasta an chomhaid uaslódáilte a fháil trí thréith: attr: ~django.db.models.fields.files.fieldfile.url. Go hinmheánach, glaonn sé seo modh:meth: ~django.core.files.storage.url an aicme bunlying:class: ~django.core.files.storage.storage.

Tabhair faoi deara, gach uair a dhéileálann tú le comhaid uaslódáilte, ba chóir duit aird mhór a thabhairt ar an áit a bhfuil tú ag uaslódáil iad agus cén cineál comhaid iad, chun poill slándála a sheachaint \* Bailíochnaigh gach comhad uaslódáil\* ionas go mbeidh tú cinnte gurb iad na comhaid mar a cheapann tú go bhfuil siad. Mar shampla, má ligeann tú do dall do dhuine comhaid a uaslódáil, gan bailíochtú, chuig eolaire atá laistigh de fhréamh doiciméad do fhreastalaí gréasáin, ansin d'fhéadfadh duine éigin script CGI nó PHP a uaslódáil agus an script sin a fhorghníomhú trí chuairt a thabhairt ar a URL ar do shuíomh. Ná lig sin.

Tabhair faoi deara freisin gur féidir le fiú comhad HTML uaslódáilte, ós rud é gur féidir leis an mbrabhsálaí é a fhorghníomhú (cé nach leis an bhfreastalaí), bagairtí slándála a bheith comhionann le hionsaithe XSS nó CSRF.

[`FileField`](#django.db.models.FileField) instances are created in your database as `varchar`
columns with a default max length of 100 characters. As with other fields, you
can change the maximum length using the [`max_length`](#django.db.models.CharField.max_length) argument.

#### `FileField` agus `Fieldfile`

#### `class FieldFile`

Nuair a bhíonn rochtain agat ar a:class: ~django.db.models.filefield ar mhúnla, tugtar sampla duit:class: FieldFile mar sheachfhreastalaí chun rochtain a fháil ar an gcomhad bunúsach.

\<django.core.files.storage.Storage.open\>Scáthaíonn API de:class: Fieldfile an réad atá f:class: ~django.core.files.file, le príomhdhifríocht amháin: *Ní gá go bhfuil an réad atá fillte ag an rang timpeall réad comhaid ionsuite Python.* Ina áit sin, is fillteán é timpeall toradh an modh:attr: Storage.open () \`, a d'fhéadfadh a bheith a:class: \`Djan.~Djan.Go.Core.Files.File réad, nó d'fhéadfadh sé a bheith ina chur i bhfeidhm stórála saincheaptha ar an API: class: ~django.core.files.file.

Chomh maith leis an API a oidhreacht ó:class: ~django.core.files.file mar ```read () ``agus ``write ()```, , :class: \`FieldFile tá roinnt modhanna is féidir a úsáid chun idirghníomhú leis an gcomhad bunúsach:

> **Warning**
>
> Dhá mhodh den rang seo, :meth: ~Fieldfile.save agus:meth: ~Fieldfile.delete, réamhshocraithe chun réad samhail an `FieldFile` gaolmhar a shábháil sa bhunachar sonraí.

#### `FieldFile.name`

Ainm an chomhaid lena n-áirítear an cosán coibhneasta ó fhréamh na:class: ~django.core.files.storage den chomhcheangail:class: ~django.db.models.filefield.

#### `FieldFile.path`

Maoin léite amháin chun rochtain a fháil ar chonair chóras comhaid áitiúil an chomhaid trí ghlaoch ar an modh: :meth: ~django.core.files.storage.path den aicme bunlying:class: ~django.core.files.storage.storage.

#### `FieldFile.size`

\<django.core.files.storage.Storage.size\>Toradh an mhodh bunús:attr: Storage.size () .

#### `FieldFile.url`

Maoin léite amháin chun rochtain a fháil ar URL choibhneasta an chomhaid trí ghlaoch ar an modh: :meth: ~django.core.files.storage.url den aicme bunlying:class: ~django.core.files.storage.storage.

#### `FieldFile.open(mode='rb')`

Osclaíonn nó athosclaíonn sé an comhad a bhaineann leis an gcás seo sa mod\` sonraithe. Murab ionann agus an modh caighdeánach Python open () , ní thugann sé tuairiscóir comhad ar ais.

Ós rud é go n-osclaítear an comhad bunúsach intuigthe agus é ag teacht air, b'fhéidir nach mbeadh sé gan ghá an modh seo a ghlaoch ach amháin an pointí a athshocrú chuig an gcomhad bunúsach nó an mod a athrú.

#### `FieldFile.close()`

Iompraíonn sé cosúil leis an modh caighdeánach Python file.close () agus dúnann sé an comhad a bhaineann leis an gcás seo.

#### `FieldFile.save(name, content, save=True)`

Tógann an modh seo ainm comhaid agus ábhar comhaid agus cuireann sé iad chuig an rang stórála don réimse, ansin comhcheanglaíonn sé an comhad stóráilte leis an réimse samhail. Más mian leat sonraí comhaid a cheangal de láimh le:class: ~django.db.models.filefield cásanna ar do mhúnla, úsáidtear an modh save () chun na sonraí comhaid sin a leanúint.

Takes two required arguments: `name` which is the name of the file, and
`content` which is an object containing the file's contents. The
optional `save` argument controls whether or not the model instance is
saved after the file associated with this field has been altered. Defaults to
`True`.

Tabhair faoi deara gur chóir go mbeadh an argóint `content` mar shampla de:class: django.core.files.file, ní réad comhad ionsuite Python. Is féidir leat a:class: ~django.core.files.file a thógáil ó réad comhaid Python atá ann cheana mar seo:

```
from django.core.files import File

# Open an existing file using Python's built-in open()
f = open("/path/to/hello.world")
myfile = File(f)
```

Nó is féidir leat ceann a thógáil ó shreang Python mar seo:

```
from django.core.files.base import ContentFile

myfile = ContentFile("hello world")
```

Le haghaidh tuilleadh faisnéise, féach:doc: /topics/files.

#### `FieldFile.delete(save=True)`

Scriosann sé an comhad a bhaineann leis an gcás seo agus glanann sé gach tréith ar an réimse. Nóta: Dúnfaidh an modh seo an comhad má tharlaíonn sé a bheith oscailte nuair a ghlaofar delete () .

Rialaíonn an argóint roghnach `sábháil` cibé an sábhálfar an tsamhail nó nach bhfuil an tsamhail tar éis an comhad a bhaineann leis an réimse seo a scriosadh. Réamhshocraithe go `True`.

Tabhair faoi deara nach scriostar comhaid ghaolmhara nuair a scriostar samhail. Más gá duit comhaid dílleachta a ghlanadh, beidh ort é a láimhseáil tú féin (mar shampla, le ordú bainistíochta saincheaptha is féidir a reáchtáil de láimh nó a sceidealú le rith go tréimhsiúil trí e.g. cron).

### `FilePathfield`

#### `class FilePathField(path='', match=None, recursive=False, allow_files=True, allow_folders=False, max_length=100, **options)`

A: aicme: Charfield a bhfuil a roghanna teoranta do na hainmneacha comhaid in eolaire áirithe ar an gcóras comhaid. Tá roinnt argóintí speisialta aige, agus is gá an chéad cheann díú\*\*:

#### `FilePathField.path`

Riachtanach. An cosán iomlán chórais chomhaid chuig eolaire as ba chóir go bhfaighidh seo:class: FilePathfield a roghanna. Sampla: `” /home/images"`.

D'fhéadfadh go mbeadh `path` inghlaonta freisin, mar shampla feidhm chun an cosán a shocrú go dinimiciúil ag an am rith. Sampla:

```
import os
from django.conf import settings
from django.db import models

def images_path():
    return os.path.join(settings.LOCAL_FILE_DIR, "images")

class MyModel(models.Model):
    file = models.FilePathField(path=images_path)
```

#### `FilePathField.match`

Roghnach. Léiriú rialta, mar shreang, a úsáidfidh: class: FilePathfield chun ainmneacha comhaid a scagadh. Tabhair faoi deara go gcuirfear an regex i bhfeidhm ar an mbunainm comhaid, ní ar an gcosán iomlán. Sampla: `"foo.*\ .txt$"`, a mheaitseálfaidh comhad ar a dtugtar `foo23.txt` ach ní `bar.txt` nó `foo23.png`.

#### `FilePathField.recursive`

Roghnach. Ceachtar `Fíor` nó `Bréag`. Is é “False” réamhshocraithe. Sonraíonn sé an gcaithfear gach fo-eolaire de:attr: ~FilePathfield.path a chur san áireamh

#### `FilePathField.allow_files`

Optional. Either `True` or `False`. Default is `True`. Specifies
whether files in the specified location should be included. Either this or
[`allow_folders`](#django.db.models.FilePathField.allow_folders) must be `True`.

#### `FilePathField.allow_folders`

Optional. Either `True` or `False`. Default is `False`. Specifies
whether folders in the specified location should be included. Either this
or [`allow_files`](#django.db.models.FilePathField.allow_files) must be `True`.

Is é an gotcha féideartha amháin go mbaineann: attr: ~FilePathfield.match leis an mbunainm comhaid, ní leis an gcosán iomlán. Mar sin, an sampla seo:

```
FilePathField(path="/home/images", match="foo.*", recursive=True)
```

... meaitseálfaidh sé `/home/images/foo.png` ach ní `/home/images/foo/bar.png` toisc go mbaineann an:attr: ~FilePathfield.match leis an mbunainm comhaid (`foo.png` agus `bar.png`).

[`FilePathField`](#django.db.models.FilePathField) instances are created in your database as `varchar`
columns with a default max length of 100 characters. As with other fields, you
can change the maximum length using the [`max_length`](#django.db.models.CharField.max_length) argument.

### Floatfield \`\`

#### `class FloatField(**options)`

Uimhir phointe snámh a léirítear i Python le sampla snám\`.

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.numberInput nuai:attr: ~django.forms.field.localize `False` nó:class: ~django.forms.textInput ar shlí eile.

> **Floatfield vs Decimalfield**
>
> Uaireanta déantar an rang: class: Floatfield a mheascadh suas leis an aicme:class: Decimalfield. Cé go léiríonn siad beirt fíor-uimhreacha, léiríonn siad na huimhreacha sin ar bheal Úsáideann `Floatfield` cineál `float` Python go hinmheánach, agus úsáideann `Decimalfield` cineál `Decimal` Python. Le haghaidh faisnéise faoin difríocht idir an dá cheann, féach doiciméadú Python don mhodúl:mod: decimal.

### Réimse Ginithe \`\`

#### `class GeneratedField(* (Keyword-only parameters separator (PEP 3102)), expression, output_field, db_persist, **kwargs)`

Réimse a ríomhtar i gcónaí bunaithe ar réimsí eile sa tsamhail. Déanann an bunachar sonraí féin an réimse seo a bhainistiú agus a nuashonrú. Úsáideann sé an comhréir SQL `GENERATED ALWAYS`.

Tá dhá chineál colún ginte ann: stóráilte agus fíorúil. Déantar colún a ghintear stóráilte a ríomh nuair a dhéantar é a scríobh (cuireadh isteach nó nuashonraithe) agus tá sé á stóráil amhail is dá mba cholún rialta é. Níl aon stóráil ag colún fíorúil a ghintear agus ríomhtar é nuair a léitear é. Dá bhrí sin, tá colún ginte fíorúil cosúil le radharc agus tá colún ginte stóráilte cosúil le radharc ábhartha.

#### `GeneratedField.expression`

An: aicme: Expression a úsáideann an bunachar sonraí chun luach an réimse a shocrú go huathoibríoch gach uair a athraítear an tsamhail.

Ba chóir go mbeadh na nathanna cinntiúcháin agus gan ach réimsí tagartha laistigh den tsamhail (sa tábla bunachar sonraí céanna). Ní féidir le réimsí ginte tagairt a dhéanamh do réimsí ginte eile Is féidir le cúltaca bunachar sonraí srianta breise a fhorchur.

#### `GeneratedField.output_field`

Sampla réimse samhail chun cineál sonraí an réimse a shainiú.

#### `GeneratedField.db_persist`

Cinneann sé an chóir go n-áitigh an cholún bunachar sonraí stóráil amhail is dá mba cholún fíor é. Má tá “False”, feidhmíonn an colún mar cholún fíorúil agus ní áitigh sé spás stórála bunachar sonraí.

Ní thacaíonn PostgreSQL ach le colúin leanúnacha. Ní thacaíonn Oracle ach colúin fíorúla

> **Teoranta bunachar sonraí**
>
> Tá go leor srianta sonrach le bunachar sonraí ar réimsí ginte nach ndéanann Django bailíochtú agus féadfaidh an bunachar sonraí earráid a ardú m.sh. Éilíonn PostgreSQL feidhmeanna agus oibreoirí dá dtagraítear i gcolún ginte a mharcáil mar “IMMUTABLE”.
>
> Ba chóir duit seiceáil i gcónaí go dtacaítear le `expression` ar do bhunachar sonraí. Amharc ar [MariaDB](https://mariadb.com/kb/en/generated-columns/#expression-support), [MySQL](https://dev.mysql.com/doc/refman/en/create-table-generated-columns.html), [Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-TABLE.html#GUID-F9CE0CC3-13AE-4744-A43C-EAC7A71AAAB6__BABIIGBD), [PostgreSQL](https://www.postgresql.org/docs/current/ddl-generated-columns.html), nó [SQLite](https://www.sqlite.org/gencol.html#limitations) docs.

> **Changed in Django 6.0**
>
> `GeneratedField`s are now automatically refreshed from the database on
> backends that support it (SQLite, PostgreSQL, and Oracle) and marked as
> deferred otherwise.

### `GenericipAddressField`

#### `class GenericIPAddressField(protocol='both', unpack_ipv4=False, **options)`

Seoladh IPv4 nó IPv6, i bhformáid teaghrán (m.sh. `192.0.2.30` nó `2a 02:42 fe: :4`). Is é an giuirléid foirme réamhshocraithe don réimse seo a: class: ~django.forms.textInput.

Leanann normalú an seoladh IPv6: rfc: 4291 #section -2.2 alt 2.2, lena n-áirítear úsáid a bhaint as an bhformáid IPv4 a mholtar i mír 3 den chuid sin, cosúil le `: :ffff:192.0.2.0`. Mar shampla, bheadh `2001:0:: 0:01` normalaithe go `2001: :1`, agus `: :ffff:0a0a0a` go\`\`: :ffff:10.10.10\`\`. Déantar gach carachtar a thiontú go litreacha beaga.

#### `GenericIPAddressField.protocol`

Teoraíonn sé ionchuir bailí don phrótacal sonraithe. Is iad na luachanna a nglactar leo ná `'beach'` (réamhshocraithe), `'IPv4'` nó `` `IPv6' ``. Tá an meaitseáil neamh-íogair.

#### `GenericIPAddressField.unpack_ipv4`

Díphacáil seoltaí mapáilte IPv4 mar `:: ffff: 192.0.2.1`. Má tá an rogha seo cumasaithe déanfaí an seoladh sin a dhíphacáil go ```192.0.2.1 ``. Tá réamhshocrú díchumasaithe. Ní féidir é a úsáid ach amháin nuair a shocraítear ``prótacol``` go beach'.

Má cheadaíonn tú luachanna bána, caithfidh tú luachanna neall a cheadú ós rud é go ndéantar luachanna bána a stóráil mar null.

### `ImageField`

#### `class ImageField(upload_to=None, height_field=None, width_field=None, max_length=100, **options)`

Oidhreann sé gach tréith agus modh ó:class: FileField, ach bailíonn sé freisin gur íomhá bailí é an réad uaslódáilte.

Chomh maith leis na tréithe speisialta atá ar fáil dó:class: FileField, tá tréithe `` `airde `` agus `leithead` ag: Class: \`ImageField freisin.

Chun fiosrú ar na tréithe sin a éascú, tá na hargóintí roghnacha seo a leanas ag :class: ImageField:

#### `ImageField.height_field`

Ainm réimse samhail a dhéantar go huathoibríoch le airde na híomhá gach uair a shocraítear réad íomhá.

#### `ImageField.width_field`

Ainm réimse samhail a dhéantar go huathoibríoch le leithead na híomhá gach uair a shocraítear réad íomhá.

Éilíonn an leabharlanna:pypi: pillow.

[`ImageField`](#django.db.models.ImageField) instances are created in your database as `varchar`
columns with a default max length of 100 characters. As with other fields, you
can change the maximum length using the [`max_length`](#django.db.models.CharField.max_length) argument.

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.clearaableFileInput.

### `Réimse iomlána`

#### `class IntegerField(**options)`

An integer. Values are only allowed between certain (database-dependent)
points. Values from `-2147483648` to `2147483647` are compatible in all
databases supported by Django.

Úsáideann sé: aicme: ~django.core.validators.minvalueValidator agus:class: ~django.core.validators.maxvalueValidator chun an t-ionchur a bhailíochtú bunaithe ar na luachanna a thacaíonn an bunachar sonraí réamhshocraithe.

Is é an giuirléid foirme réamhshocraithe don réimse seo a:class: ~django.forms.numberInput nuai:attr: ~django.forms.field.localize `False` nó:class: ~django.forms.textInput ar shlí eile.

### `Jsonfield`

#### `class JSONField(encoder=None, decoder=None, **options)`

Réimse chun sonraí ionchódaithe JSON a stóráil. I Python léirítear na sonraí ina bhformáid dúchasach Python: foclóirí, liostaí, teaghráin, uimhreacha, booleans agus None .

\<sqlite-json1\>Tacaítear le `JSONField` ar MariaDB, MySQL, Oracle, PostgreSQL, agus SQLite (leis an síneadh: ref: JSON1 cumasaithe ).

#### `JSONField.encoder`

An optional [`json.JSONEncoder`](https://docs.python.org/3/library/json.html#json.JSONEncoder) subclass to serialize data types
not supported by the standard JSON serializer (e.g. `datetime.datetime`
or [`UUID`](https://docs.python.org/3/library/uuid.html#uuid.UUID)). For example, you can use the
[`DjangoJSONEncoder`](/ga/6.0/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder) class.

Réamhshocraithe go `JSON.JSONEncoder`.

#### `JSONField.decoder`

An optional [`json.JSONDecoder`](https://docs.python.org/3/library/json.html#json.JSONDecoder) subclass to deserialize the value
retrieved from the database. The value will be in the format chosen by the
custom encoder (most often a string). Your deserialization may need to
account for the fact that you can't be certain of the input type. For
example, you run the risk of returning a `datetime` that was actually a
string that just happened to be in the same format chosen for
`datetime`s.

Réamhshocraithe go `JSON.JSONDecoder`.

Chun `Jsonfield` a cheistiú sa bhunachar sonraí, féach:ref: querying-jsonfield.

> **Luach réamhshocraithe**
>
> If you give the field a [`default`](#django.db.models.Field.default), ensure
> it's a callable such as the [`dict`](https://docs.python.org/3/library/stdtypes.html#dict) class or a function that
> returns a fresh object each time. Incorrectly using a mutable object like
> `default={}` or `default=[]` creates a mutable default that is shared
> between all instances.

> **Innéacsú**
>
> [`Index`](/ga/6.0/ref/models/indexes/#django.db.models.Index) and [`Field.db_index`](#django.db.models.Field.db_index) both create a
> B-tree index, which isn't particularly helpful when querying `JSONField`.
> On PostgreSQL only, you can use
> [`GinIndex`](/ga/6.0/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GinIndex) that is better suited.

> **Úsáideoirí PostgreSQL**
>
> Tá dhá chineál sonraí bunaithe ar JSON dúchasacha ag PostgreSQL: `json` agus `jsonb`. Is é an difríocht is mó eatarthu ná conas a stóráiltear iad agus conas is féidir iad a fhiosrú. Stóráiltear réimse json\` PostgreSQL mar léiriú teaghrán bunaidh an JSON agus caithfear é a dhíchódú ar an eitilt nuair a fhiosraítear é bunaithe ar eochracha. Stóráiltear an réimse jsonb\` bunaithe ar struchtúr iarbhír an JSON a cheadaíonn innéacsú. Is costas beag breise é an trádáil ar scríobh chuig an réimse `jsonb`. Úsáideann `jsonfield` `jsonb`.

> **Úsáideoirí Oracle**
>
> Oracle Database does not support storing JSON scalar values. Only JSON
> objects and arrays (represented in Python using [`dict`](https://docs.python.org/3/library/stdtypes.html#dict) and
> [`list`](https://docs.python.org/3/library/stdtypes.html#list)) are supported.

### `PositiveBigIntegerField`

#### `class PositiveBigIntegerField(**options)`

Like a [`PositiveIntegerField`](#django.db.models.PositiveIntegerField), but only allows values under a certain
(database-dependent) point. Values from `0` to `9223372036854775807` are
compatible in all databases supported by Django.

### Réimse Dearfach Iomlán \`\`

#### `class PositiveIntegerField(**options)`

Like an [`IntegerField`](#django.db.models.IntegerField), but must be either positive or zero (`0`).
Values are only allowed under a certain (database-dependent) point. Values from
`0` to `2147483647` are compatible in all databases supported by Django.
The value `0` is accepted for backward compatibility reasons.

### `PositivesmallIntéarréimh`

#### `class PositiveSmallIntegerField(**options)`

Like a [`PositiveIntegerField`](#django.db.models.PositiveIntegerField), but only allows values under a certain
(database-dependent) point. Values from `0` to `32767` are compatible in
all databases supported by Django.

### `Slugfield`

#### `class SlugField(max_length=50, **options)`

[Slug](/ga/6.0/glossary/#term-slug) is a newspaper term. A slug is a short label for something,
containing only letters, numbers, underscores or hyphens. They're generally
used in URLs.

Cosúil le CharField, is féidir leat: attr: ~charfield.MAX\_LENGTH a shonrú (léigh an nóta faoi iniomparthacht bunachar sonraí agus:attr: ~charfield.MAX\_LENGTH sa chuid sin freisin). Más: Attr: ~Charfield.max\_Length nach sonraítear, úsáidfidh Django fad réamhshocraithe de 50.

Tugann sé le tuiscint socrú: attr: Field.db\_index go `True`.

It is often useful to automatically prepopulate a SlugField based on the value
of some other value. You can do this automatically in the admin using
[`prepopulated_fields`](/ga/6.0/ref/contrib/admin/#django.contrib.admin.ModelAdmin.prepopulated_fields).

Úsáideann sé: aicme: ~django.core.validators.validate\_slug nó:class: ~django.core.validators.validate\_unicode\_slug le haghaidh bailíochtaithe.

#### `SlugField.allow_unicode`

Má tá `True`, glacann an réimse litreacha Unicode i dteannta litreacha ASCII. Réamhshocraithe go `False`.

### `SmallAutofield`

#### `class SmallAutoField(**options)`

Like an [`AutoField`](#django.db.models.AutoField), but only allows values under a certain
(database-dependent) limit. Values from `1` to `32767` are compatible in
all databases supported by Django.

### `SmallIntegerField`

#### `class SmallIntegerField(**options)`

Like an [`IntegerField`](#django.db.models.IntegerField), but only allows values under a certain
(database-dependent) point. Values from `-32768` to `32767` are compatible
in all databases supported by Django.

### `Réimse téacs`

#### `class TextField(**options)`

Réimse mór téacs. Is é a: class: ~django.forms.textarea an giuirléid foirme réamhshocraithe don réimse seo.

Má shonraíonn tú tréith max\_length , léireofar é sa ghuirléid: class: ~django.forms.textarea den réimse foirme uathghinithe. Ní chuirtear i bhfeidhm é, áfach, ag leibhéal an tsamhail nó bunachar sonraí. Úsáid a:class: Charfield chuige sin.

#### `TextField.db_collation`

Roghnach. Ainm bailithe bunachar sonraí an réimse.

> **Note**
>
> Níl ainmneacha coláireachta caighdeánaithe. Dá bhrí sin, ní bheidh sé seo iniompartha ar fud iomadúla cúltaca bunachar sonraí.

> **Oracle**
>
> Ní thacaíonn Oracle le comparáidí do `Textfield`.

### Réimse ama \`\`

#### `class TimeField(auto_now=False, auto_now_add=False, **options)`

Am, a léirítear i Python le sampla `datetime.time`. Glacann sé leis na roghanna uathoibríoch céanna mar: class: DateField.

Is é an giuirléid foirme réamhshocraithe don réimse seo a: class: ~django.forms.timeinput. Cuireann an riarachán roinnt aicearraí JavaScript leis.

### `Urlfield`

#### `class URLField(max_length=200, **options)`

A: Class: Charfield le haghaidh URL, bailíochtaithe ar:class: ~django.core.validators.urlValidator.

Is é an giuirléid foirme réamhshocraithe don réimse seo a: class: ~django.forms.urlinput.

Cosúil le gach fo-aicm:class: Charfield, glacann: class: URLField an argóint roghnaí:attr: ~charfield.MAX\_LENGTH. Mura sonraíonn tú: attr: ~charfield.max\_Length, úsáidtear réamhshocrú 200.

### `Uuidfield`

#### `class UUIDField(**options)`

Réimse chun aitheantóirí uathúla a stóráil. Úsáideann Python's:class: ~Python: uuid.uuid aicme. Nuair a úsáidtear é ar PostgreSQL agus MariaDB 10.7+, stóráilíonn sé seo i gcineál sonraí `uuid`, ar shlí eile i char (32) .

Is rogha eile maith iad aitheantóirí uathúla go huilíoch seach:class: Autofield for:attr: ~field.primary\_key. Ní ghinfidh an bunachar sonraí an UUID duit, mar sin moltar a úsáid:attr: ~field.default:

```
import uuid
from django.db import models

class MyUUIDModel(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    # other fields
```

Tabhair faoi deara go gcuirtear glaoch inghlaonta (agus na lúibíní fágtha) chuig `default`, ní sampla de UUID .

> **Cuardaigh ar PostgreSQL agus MariaDB 10.7+**
>
> Úsáid:lookup: iexact, :lookup: contains, :lookup: icontains, :lookup: startswith, :lookup: istartswith, :lookup: endswith, nó:lookup: iendswith ní oibríonn cuardaigh iendswith ar PostgreSQL le haghaidh luachanna gan bhreithíní, mar gheall ar PostgreSQL Stóráilíonn L agus MariaDB 10.7+ iad i gcineál sonraí uuid frithphéadaithe.

## Réimsí caidrimh

Sainmhíníonn Django sraith réimsí freisin a léiríonn caidreamh.

### `ForeignKey`

#### `class ForeignKey(to, on_delete, **options)`

Caidreamh go leor le duine. Éilíonn dhá argóint seasaimh: an rang lena mbaineann an tsamhail agus an rogha: attr: ~ForeignKey.on\_delete:

```
from django.db import models

class Manufacturer(models.Model):
    name = models.TextField()

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

Is féidir leis an gcéad argóint seasaimh a bheith ina aicme samhail nithiúil nó a:ref: tagairt leisciúil \<lazy-relationships\>\`d'aicme samhail. :ref: Tacaítear le caidrimh ath \<recursive-relationships\>shlánacha , áit a bhfuil caidreamh ag samhail leis féin, freisin.

Féach: attr: ForeignKey.on\_delete le haghaidh sonraí faoin dara argóint seasmhach.

A database index is automatically created on the `ForeignKey`. You can
disable this by setting [`db_index`](#django.db.models.Field.db_index) to `False`. You may want to
avoid the overhead of an index if you are creating a foreign key for
consistency rather than joins, or if you will be creating an alternative index
like a partial or multiple column index.

#### Ionadaíocht Bunachar Sonraí

Taobh thiar de na radhairc, cuireann Django `"_id"` leis an ainm réimse chun a ainm colún bunachar sonraí a chruthú. Sa sampla thuas, beidh colún `manufacturer_id` sa tábla bunachar sonraí don tsamhail `Car`. Is féidir leat é seo a athrú go sainráite trí:attr: ~field.db\_column a shonrú, áfach, níor cheart go mbeadh ar do chód déileáil le hainm an cholúin bunachar sonraí riamh (mura scríobhann tú SQL saincheaptha). Déileálfaidh tú i gcónaí le hainmneacha réimse do réad samhail.

#### Argóintí

[`ForeignKey`](#django.db.models.ForeignKey) accepts other arguments that define the details of how the
relation works.

#### `ForeignKey.on_delete`

Nuair a scriostar réad dá dtagraíonn a:class: ForeignKey, déanfaidh Django aithris ar iompar an srianta SQL a shonraítear leis an argóint: attr: on\_delete. Mar shampla, má tá nullable:class: ForeignKey agat agus má theastaíonn uait go mbeadh sé a shocrú null nuair a scriostar an réad tagartha:

```
user = models.ForeignKey(
    User,
    models.SET_NULL,
    blank=True,
    null=True,
)
```

Ní chruthaíonn `on_delete` srian SQL sa bhunachar sonraí. \<21961\>Tacaíocht do roghanna cascadh ar leibhéal bunachar sonraí: ticéad: féadfar a chur i bhfeidhm níos déanaí .

Tá na luachanna féideartha le haghaidh: attr: ~ForeignKey.on\_delete le fáil in:mod: django.db.models:

- #### `CASCADE`

  Cascade deletes. Django emulates the behavior of the SQL constraint `ON
  DELETE CASCADE` and also deletes the object containing the
  [`ForeignKey`](#django.db.models.ForeignKey).

  [`Model.delete()`](/ga/6.0/ref/models/instances/#django.db.models.Model.delete) isn't called on related models, but the
  [`pre_delete`](/ga/6.0/ref/signals/#django.db.models.signals.pre_delete) and
  [`post_delete`](/ga/6.0/ref/signals/#django.db.models.signals.post_delete) signals are sent for all
  deleted objects.
- #### `PROTECT`

  Cosc a chur ar scriosadh an réad tagartha trí:exc: ~django.db.models.protectedError, fo-aicme de:exc: Django.db.IntegrityError a ardú.
- #### `RESTRICT`

  Cosc a chur ar an réad tagartha a scriosadh trí:exc: ~django.db.models.restrictedError (fo-aicme de:exc: Django.db.IntegrityError). Gan amhlai:ATTR: PROTECT, ceadaítear an réad tagartha a scriosadh má thagann sé tagairt freisin do réad difriúil atá á scriosadh san oibríocht chéanna, ach trí chaidreamh a:attr: CASCADE.

  Smaoinigh ar an tacar samhlacha seo:

  ```
  class Artist(models.Model):
      name = models.CharField(max_length=10)

  class Album(models.Model):
      artist = models.ForeignKey(Artist, on_delete=models.CASCADE)

  class Song(models.Model):
      artist = models.ForeignKey(Artist, on_delete=models.CASCADE)
      album = models.ForeignKey(Album, on_delete=models.RESTRICT)
  ```

  Is féidir ```Ealaíontóir` a scriosadh fiú má thugann sé sin le tuiscint ``Album``` a scriosadh dá dtagraítear `` `Amhrána ``, toisc go dtagraíonn `Amhrána` freisin do `Ealaíontóir` féin trí chaidreamh cascáideach. Mar shampla:

  ```pycon
  >>> artist_one = Artist.objects.create(name="artist one")
  >>> artist_two = Artist.objects.create(name="artist two")
  >>> album_one = Album.objects.create(artist=artist_one)
  >>> album_two = Album.objects.create(artist=artist_two)
  >>> song_one = Song.objects.create(artist=artist_one, album=album_one)
  >>> song_two = Song.objects.create(artist=artist_one, album=album_two)
  >>> album_one.delete()
  # Raises RestrictedError.
  >>> artist_two.delete()
  # Raises RestrictedError.
  >>> artist_one.delete()
  (4, {'Song': 2, 'Album': 1, 'Artist': 1})
  ```
- #### `SET_NULL`

  Socraigh an:class: ForeignKey null; ní féidir é seo ach amháin má tá: attr: ~field.null `True`.
- #### `SET_DEFAULT`

  Socraigh an:class: ForeignKey go dtí a luach réamhshocraithe; ní mór réamhshocrú don: class: ForeignKey a shocrú.
- #### `SET()`

  Set the [`ForeignKey`](#django.db.models.ForeignKey) to the value passed to
  [`SET()`](#django.db.models.SET), or if a callable is passed in,
  the result of calling it. In most cases, passing a callable will be
  necessary to avoid executing queries at the time your `models.py` is
  imported:

  ```
  from django.conf import settings
  from django.contrib.auth import get_user_model
  from django.db import models

  def get_sentinel_user():
      return get_user_model().objects.get_or_create(username="deleted")[0]

  class MyModel(models.Model):
      user = models.ForeignKey(
          settings.AUTH_USER_MODEL,
          on_delete=models.SET(get_sentinel_user),
      )
  ```
- #### `DO_NOTHING`

  Ní ghlac aon ghníomhaíocht. Má chuireann do chúltaca bunachar sonraí sláine tagartha i bhfeidhm, beidh sé seo ina chúis le: exc: ~django.db.IntegrityError mura gcuireann tú srian SQL ON DELETE\` de láimh le réimse an bhunachar sonraí.

#### `ForeignKey.limit_choices_to`

Socraíonn sé teorainn do na roghanna atá ar fáil don réimse seo nuair a dhéantar an réimse seo a léiriú ag baint úsáide as `Modelfhoirme` nó an riarachán (de réir réamhshocraithe, tá gach rud sa tacar fiosrúcháin ar fáil le roghnú). Is féidir foclóir, a:class: ~django.db.models.q réad, nó réad inghlaonta ar ais foclóir nó: class: ~django.db.models.q a úsáid.

Mar shampla:

```
staff_member = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    limit_choices_to={"is_staff": True},
)
```

causes the corresponding field on the `ModelForm` to list only `User`
instances that have `is_staff=True`. This may be helpful in the Django
admin.

Is féidir leis an bhfoirm inghlaonta a bheith cabhrach, mar shampla, nuair a úsáidtear é i gcomhar le modúl Python `datetime` chun roghanna a theorannú de réir raon dáta. Mar shampla:

```
def limit_pub_date_choices():
    return {"pub_date__lte": datetime.date.today()}

limit_choices_to = limit_pub_date_choices
```

Más é nó má fhilleann `limit_choices_to` a:class: Q object \`, atá \<django.db.models.Q\>úsáideach d':ref: \`ceisteanna casta, an \<complex-lookups-with-q\>sin ní bheidh éifeacht aige ach ar na roghanna atá ar fáil sa admin nuair nach bhfuil an réimse liostaithe in:attr: ~django.contrib.admin.modeladmin.raw\_id\_fields sa ModelAdmin\` don tsamhail.

> **Note**
>
> Má úsáidtear glaoch le haghaidh `limit_choices_to`, cuirfear glaoch air gach uair a chuirfear foirm nua isteach. Féadfar é a ghairm freisin nuair a bhailítear samhail, mar shampla ag orduithe bainistíochta nó leis an riarachán. Tógann an riarachán ceisteanna chun a ionchuir foirme a bhailíochtú i gcásanna imeall éagsúla arís agus arís eile, mar sin tá an fhéidearthacht ann go bhféadfaí do ghlaoch a ghlaoch arís agus arís eile.

#### `ForeignKey.related_name`

An t-ainm le húsáid don ghaol ón réad gaolmhar ar ais leis an gceann seo. Is é an luach réamhshocraithe freisin le haghaidh: attr: related\_query\_name (an t-ainm le húsáid le haghaidh ainm an scagaire droim ón spriocmhúnla). Féach an doiciméadú: ref: rudaí gaolmhara \<backwards-related-objects\>\`le haghaidh míniú iomlán agus sampla. \<abstract-related-name\>Tabhair faoi deara go gcaithfidh tú an luach seo a shocrú agus caidreamh á sainmhíniú ar:ref: \`samhlacha teibí \<abstract-base-classes\>; agus nuair a dhéanann tú amh:ref: tá roinnt comhréireachta speisialta ar fáil.

Más fearr leat gan Django caidreamh cúil a chruthú, socraigh `related_name` go `+'` nó deireadh leis le `'+'`. Mar shampla, cinnteoidh sé seo nach mbeidh gaol cúil ag an tsamhail Úsáideoir leis an tsamhail seo:

```
user = models.ForeignKey(
    User,
    on_delete=models.CASCADE,
    related_name="+",
)
```

#### `ForeignKey.related_query_name`

An t-ainm le húsáid le haghaidh ainm an scagaire droim ón spriocmhúnla. Déanann sé réamhshocraithe go luach de:attr: related\_name nó:attr: ~django.db.models.options.default\_related\_name má tá sé socraithe, ar shlí eile réamhshocraíonn sé ainm an tsamhail:

```
# Declare the ForeignKey with related_query_name
class Tag(models.Model):
    article = models.ForeignKey(
        Article,
        on_delete=models.CASCADE,
        related_name="tags",
        related_query_name="tag",
    )
    name = models.CharField(max_length=255)

# That's now the name of the reverse filter
Article.objects.filter(tag__name="important")
```

\<abstract-related-name\>Mar shampla: attr: related\_name, tacaíonn `related_query_name` le lipéad aip agus idirphostáil aicme via: ref: roinnt comhréireachta speisialta .

#### `ForeignKey.to_field`

An réimse ar an réad gaolmhar a bhfuil an gaol leis. De réir réamhshocraithe, úsáideann Django príomh-eochair an réad gaolmhar. Má thagann tú tagairt do réimse difriúil, caithfidh `Unique=True` a bheith ag an réimse sin.

#### `ForeignKey.db_constraint`

Rialaíonn cibé acu ba chóir srian a chruthú sa bhunachar sonraí don eochair eachtrach seo nó nach bhfuil. Is é “True” an réamhshocraithe, agus is cinnte gurb é sin an rud a theastaíonn uait; is féidir go mbeadh sé an-dona do shláine sonraí é seo a shocrú go False. É sin ráite, seo roinnt cásanna inar mbeadh tú ag iarraidh é seo a dhéanamh:

- Tá sonraí oidhreachta agat nach bhfuil bailí.
- Tá tú ag scriosadh do bhunachar sonraí.

Má tá sé seo socraithe ar `False`, ardóidh rochtain a fháil ar réad gaolmhar nach bhfuil ann a eisceacht DoesNotExist\`.

#### `ForeignKey.swappable`

Rialaíonn sé imoibriú an chreat imirce má tá seo:class: ForeignKey ag díriú ar mhúnla inmhalartaithe. Más é `True` \- an réamhshocrú - ansin má tá an:class: ForeignKey ag pointe ar mhúnla a mheaitseálann luach reatha `settings.auth_user_model` (nó socrú samhail inmhalartaithe eile) stóráilfear an caidreamh san imirce ag úsáid tagairt don socrú, ní don tsamhail go díreach.

Ní theastaíonn uait ach é seo a shárú le bheith “False” má tá tú cinnte gur chóir do mhúnla díriú i gcónaí i dtreo an tsamhail atá malartaithe isteach - mar shampla, más samhail phróifíle é atá deartha go sonrach do do mhúnla úsáideora saincheaptha.

Setting it to `False` does not mean you can reference a swappable model
even if it is swapped out - `False` means that the migrations made
with this [`ForeignKey`](#django.db.models.ForeignKey) will always reference the exact model you
specify (so it will fail hard if the user tries to run with a `User`
model you don't support, for example).

Má tá amhras ort, fág ar a réamhshocrú `True`.

### `ManyTomanyField`

#### `class ManyToManyField(to, **options)`

Caidreamh go leor le go leor. \<recursive-relationships\>\<lazy-relationships\>Éilíonn argóint seasmhach: an rang lena mbaineann an tsamhail, a oibríonn go díreach mar an gcéanna agus a dhéanann sé le haghaidh: class: ForeignKey, lena n-áirítear: ref: recursive agus:ref: caidrimh leisciúil.

Is féidir rudaí gaolmhara a chur leis, a bhaint nó a chruthú leis an réimse d's:class: ~Django.db.Models.Fields.Related.RelatedManager.

#### Ionadaíocht Bunachar Sonraí

Taobh thiar de na radhairc, cruthaíonn Django tábla ceangail idirghabhálaí chun an caidreamh go leor a léiriú. De réir réamhshocraithe, gintear an t-ainm tábla seo ag baint úsáide as ainm an réimse go leor agus ainm an tábla don tsamhail ina bhfuil sé. Ós rud é nach dtacaíonn roinnt bunachair sonraí le hainmneacha tábla os cionn fad áirithe, gearrfar na hainmneacha tábla seo go huathoibríoch agus úsáidfear hash uathúlachta, m.sh. `author_books_9cdf`. Is féidir leat ainm an tábla ceangail a sholáthar de láimh ag baint úsáide as an rogha: attr: ~ManyTomanyField.db\_Table.

#### Argóintí

[`ManyToManyField`](#django.db.models.ManyToManyField) accepts an extra set of arguments -- all optional --
that control how the relationship functions.

#### `ManyToManyField.related_name`

Mar an gcéanna len:attr: ForeignKey.Related\_Name.

#### `ManyToManyField.related_query_name`

Mar an gcéanna len:attr: ForeignKey.Related\_Query\_Nam.

#### `ManyToManyField.limit_choices_to`

Mar an gcéanna len:attr: ForeignKey.limit\_Choices\_to.

#### `ManyToManyField.symmetrical`

Ní úsáidtear ach sa mhíniú ar ManyTomanyFields ar fhéin. Smaoinigh ar an tsamhail seo a leanas:

```
from django.db import models

class Person(models.Model):
    friends = models.ManyToManyField("self")
```

Nuair a phróiseálann Django an tsamhail seo, aithníonn sé go bhfuil a: class: ManyTomanyField air féin, agus mar thoradh air sin, ní chuireann sé tréith ```person_set` leis an rang ``Person```. Ina áit sin, glactar leis go bhfuil an: class: ManyTomanyField siméadrach - is é sin, más mise do chara, ansin is tú mo chara.

Mura dteastaíonn sioméadracht uait i gcaidrimh go leor le ```féin ``, socraigh: attr: `~ManyTomanyField.symmetrical` go ``False```. Cuirfidh sé seo iallach ar Django an tuairisceoir don chaidreamh droim a chur leis, ag ligean caidrimh: class: ManyTomanyField a bheith neamh-shiméadrach.

#### `ManyToManyField.through`

Ghinfidh Django tábla go huathoibríoch chun caidrimh go leor a bhainistiú. Mar sin féin, más mian leat an tábla idirghabhála a shonrú de láimh, is féidir leat an rogha: attr: ~ManyTomanyField.through a úsáid chun an tsamhail Django a léiríonn an tábla idirmheánach a theastaíonn uait a úsáid a shonrú.

The `through` model can be specified using either the model class
directly or a [lazy reference](#lazy-relationships) to the model
class.

\<intermediary-manytomany\>Is é an úsáid is coitianta don rogha seo nuair is mian leat: ref: sonraí breise a cheangal le caidreamh go leor .

> **Note**
>
> Ní féidir le caidrimh athshlánacha a úsáideann samhail idirghabhálaí ainmneacha na rochtana droim a chinneadh, mar bheadh siad mar an gcéanna Ní mór duit a: attr: ~ForeignKey.related\_name a shocrú le ceann acu ar a laghad. Más fearr leat gan Django caidreamh cúil a chruthú, socraigh `related_name` go `+'`.

> **Foreign key order in intermediary models**
>
> When defining an asymmetric many-to-many relationship from a model to
> itself using an intermediary model without defining
> [`through_fields`](#django.db.models.ManyToManyField.through_fields), the first foreign key in the intermediary model
> will be treated as representing the source side of the
> `ManyToManyField`, and the second as the target side. For example:
>
> ```
> from django.db import models
>
>
> class Manufacturer(models.Model):
>     name = models.CharField(max_length=255)
>     clients = models.ManyToManyField(
>         "self", symmetrical=False, related_name="suppliers", through="Supply"
>     )
>
>
> class Supply(models.Model):
>     supplier = models.ForeignKey(
>         Manufacturer, models.CASCADE, related_name="supplies_given"
>     )
>     client = models.ForeignKey(
>         Manufacturer, models.CASCADE, related_name="supplies_received"
>     )
>     product = models.CharField(max_length=255)
> ```
>
> Here, the `Manufacturer` model defines the many-to-many relationship
> with `clients` in its role as a supplier. Therefore, the `supplier`
> foreign key (the source) must come before the `client` foreign key
> (the target) in the intermediary `Supply` model.
>
> Specifying [`through_fields=("supplier", "client")`](#django.db.models.ManyToManyField.through_fields) on the `ManyToManyField` makes the
> order of foreign keys on the `through` model irrelevant.

If you don't specify an explicit `through` model, there is still an
implicit `through` model class you can use to directly access the table
created to hold the association. It has three fields to link the models, a
primary key and two foreign keys. There is a unique constraint on the two
foreign keys.

Má tá na samhlacha foinse agus spriocmhúnlaí difriúil, gintear na réimsí seo a leanas

- `id`: príomh-eochair an chaidrimh.
- `<containing_model>_id`: id\` an tsamhail a dhearbhaíonn an `ManyTomanyField`.
- `<other_model>_id`: id\` an tsamhail a thugann an ManyTomanyField in iúl dó.

Má phointíonn an `ManyTomanyField` ón samhail chéanna agus chuig an tsamhail chéanna, gintear na réimsí seo a leanas:

- `id`: príomh-eochair an chaidrimh.
- `from_ <model>_id`: `id` an cháis a thugann pointe ar an tsamhail (ie an tsamhail foinse).
- `to_ <model>_id`: `id` an cháis a dtugann an caidreamh in iúl (ie an spriocshamhail).

Is féidir an rang seo a úsáid chun taifid ghaolmhara a cheistiú do shampla samhail ar leith cosúil le gnáthmhúnla:

```
Model.m2mfield.through.objects.all()
```

#### `ManyToManyField.through_fields`

Ní úsáidtear ach nuair a shonraítear samhail idirghabhála saincheaptha De ghnáth cinnfidh Django cé na réimsí den tsamhail idirghabhálaí le húsáid d'fhonn caidreamh go leor a bhunú go huathoibríoch. Mar sin féin, smaoinigh ar na samhlacha seo a leanas:

```
from django.db import models

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

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(
        Person,
        through="Membership",
        through_fields=("group", "person"),
    )

class Membership(models.Model):
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    inviter = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
        related_name="membership_invites",
    )
    invite_reason = models.CharField(max_length=64)
```

Tá dhá eochracha eachtracha ag Ballraíocht \`\`\`Person\` (`pearsa` agus `cuireadh`), rud a fhágann go bhfuil an caidreamh débhríoch agus ní féidir le Django a fhios cén ceann atá le húsáid. Sa chás seo, ní mór duit a shonrú go sainráite na heochracha eachtracha ba chóir do Django a úsáid ag baint úsáide as through\_fields \`, mar atá sa sampla thuas.

Glacann `through_fields` le 2 tuple `('field1', 'field2')`, áit a bhfuil field1\` ainm an eochair eachtrach don mhúnla an:class: ManyTomanyfield sainmhínítear ar (`grúpa` sa chás seo), agus `field2` ainm an eochair eachtrach don spriocmhúnla (duine sa chás seo).

Nuair a bhíonn níos mó ná eochair eachtrach amháin agat ar mhúnla idirghabhála le haon (nó fiú an dá cheann) de na samhlacha atá rannpháirteach i gcaidreamh go leor, ní mór duit\* `through_fields` a shonrú. Baineann sé seo freisin le:ref: caidrimh athfhillteach \<recursive-relationships\>\`nuair a úsáidtear samhail idirghabhálaí agus go bhfuil níos mó ná dhá eochair eachtracha don tsamhail, nó ba mhaith leat a shonrú go sainráite cé na beirt Django ba chóir a úsáid.

#### `ManyToManyField.db_table`

Ainm an tábla le cruthú chun na sonraí go leor a stóráil. Mura gcuirtear é seo ar fáil, glacfaidh Django le ainm réamhshocraithe bunaithe ar ainmneacha: an tábla don tsamhail a shainmhíníonn an caidreamh agus ainm an réimse féin.

#### `ManyToManyField.db_constraint`

Rialuithe cibé acu ba chóir srianta a chruthú sa bhunachar sonraí do na heochracha eachtracha sa tábla idirghabhála nó nach bhfuil Is é “True” an réamhshocraithe, agus is cinnte gurb é sin an rud a theastaíonn uait; is féidir go mbeadh sé an-dona do shláine sonraí é seo a shocrú go False. É sin ráite, seo roinnt cásanna inar mbeadh tú ag iarraidh é seo a dhéanamh:

- Tá sonraí oidhreachta agat nach bhfuil bailí.
- Tá tú ag scriosadh do bhunachar sonraí.

Is earráid é `db_restricint` agus through a rith araon.

#### `ManyToManyField.swappable`

Rialaíonn sé imoibriú an chreat imirce má tá seo:class: ManyTomanyField ag díriú ar mhúnla inmhalartaithe. Más é `True` \- an réamhshocrú - ansin má tá an:class: ManyTomanyField ag pointe ar mhúnla a mheaitseálann luach reatha `settings.auth_user_model` (nó socrú samhail inmhalartaithe eile) stóráilfear an caidreamh san imirce ag úsáid tagairt don socrú, ní don tsamhail go díreach.

Ní theastaíonn uait ach é seo a shárú le bheith “False” má tá tú cinnte gur chóir do mhúnla díriú i gcónaí i dtreo an tsamhail atá malartaithe isteach - mar shampla, más samhail phróifíle é atá deartha go sonrach do do mhúnla úsáideora saincheaptha.

Má tá amhras ort, fág ar a réamhshocrú `True`.

[`ManyToManyField`](#django.db.models.ManyToManyField) does not support [`validators`](#django.db.models.Field.validators).

[`null`](#django.db.models.Field.null) has no effect since there is no way to require a
relationship at the database level.

### `Onetoonefield`

#### `class OneToOneField(to, on_delete, parent_link=False, **options)`

Caidreamh duine le duine. Go coincheapúil, tá sé seo cosúil le a:class: ForeignKey le: attr: Unique=True \<Field.unique\>, ach cuirfidh an taobh “droim” den chaidreamh rud amháin ar ais go díreach.

Tá sé seo is úsáideach mar phríomh-eochair mhúnla a “leathnaíonn” samhail eile ar bhealach éigin; :ref: cuirtear il-tábla-oidhreacht 'i bhfeidhm trí ghaol intuigthe duine le duine a chur ón tsamhail linbh leis an tsamhail tuismitheora, mar shampla.

Teastaíonn argóint seasmhach amháin: an rang lena mbeidh baint ag an tsamhail. \<recursive-relationships\>\<lazy-relationships\>Oibríonn sé seo díreach mar an gcéanna agus a dhéanann sé le haghaidh: class: ForeignKey, lena n-áirítear na roghanna go léir maidir le caidrimh: ref: recursive \`agus:ref: \`leisciúil.

Mura sonraíonn tú argóint: attr: ~ForeignKey.related\_name don OneTooneField\`, úsáidfidh Django ainm beaga an tsamhail reatha mar luach réamhshocraithe.

Leis an sampla seo a leanas:

```
from django.conf import settings
from django.db import models

class MySpecialUser(models.Model):
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
    )
    supervisor = models.OneToOneField(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name="supervisor_of",
    )
```

beidh na tréithe seo a leanas ag do mhúnla Úsáideora mar thoradh air:

```pycon
>>> user = User.objects.get(pk=1)
>>> hasattr(user, "myspecialuser")
True
>>> hasattr(user, "supervisor_of")
True
```

Ardaítear eisceacht `RelateDObjectDoesNotExist` nuair a bhíonn rochtain ar an gcaidreamh droim mura bhfuil iontráil sa tábla gaolmhar ann. Is fo-aicme é seo den eisceacht spriocmhúnla 's:exc: Model.doesNotExist \<django.db.models.Model.DoesNotExist\>\`agus is féidir rochtain a fháil air mar thréith den rochtain ar ais. Mar shampla, mura bhfuil maoirseoir ag úsáideoir ainmnithe ag \`MySpecialUser\`:

```
try:
    user.supervisor_of
except User.supervisor_of.RelatedObjectDoesNotExist:
    pass
```

Ina theannta sin, glacann `OneTooneField` leis na hargóintí breise go léir a nglacaí:class: ForeignKey, móide argóint bhreise amháin:

#### `OneToOneField.parent_link`

Nuair a úsáidtear `True` agus nuair a úsáidtear i samhail a fhaigheann oidhreacht ó théarma eile: samhail coincréit, le fios gur chóir an réimse seo a úsáid mar nasc ar ais leis an rang tuismitheora, seachas an OneToonefield breise a chruthófaí go hiontach de ghnáth trí fho-aicmiú.

Féach: Doc: Caidrimh duine le Duain le haghaidh samplaí úsáide de OneToonefield\`. \</topics/db/examples/one\_to\_one\>

### Caidrimh leisciúil

Ligeann caidrimh leisciúla tagairt a dhéanamh do mhúnlaí dá n-ainmneacha (mar teaghráin) nó caidrimh athfhillteach Is féidir teaghráin a úsáid mar an chéad argóint in aon réimse caidrimh chun samhlacha a thagairt go leisciúil. \<relative-relationships\>\<absolute-relationships\>Is féidir tagairt leisciúil a bheith fiú:ref: recursive \<recursive-relationships\>, :ref: coibhneasta nó: ref: absolute .

#### Athfhillteach

Chun caidreamh a shainiú ina dtagraíonn samhail dó féin, bain úsáid as `"féin"` mar an chéad argóint den réimse caidrimh:

```
from django.db import models

class Manufacturer(models.Model):
    name = models.TextField()
    suppliers = models.ManyToManyField("self", symmetrical=False)
```

Nuair a úsáidtear é in an:ref: samhail teibí \<abstract-base-classes\>, réitíonn an caidreamh athfhillteach ionas go dtagraíonn gach fo-aicme coincréite dó féin.

#### Coibhneasta

Nuair is gá caidreamh a chruthú le samhail nár sainmhíníodh go fóill, is féidir tagairt a dhéanamh dá ainm seachas an réad samhail féin:

```
from django.db import models

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

class Manufacturer(models.Model):
    name = models.TextField()
    suppliers = models.ManyToManyField("self", symmetrical=False)
```

Réitear caidrimh a shainmhínítear ar an mbe \<abstract-base-classes\>alach seo ar:ref: samhlacha teibí \`nuair a dhéantar an tsamhail a fho-aicmiú mar mhúnla coincréite agus nach bhfuil siad coibhneasta le \`\`app\_label\` an tsamhail teibí:

*`táirgí/samhlach.py`*

```python
from django.db import models

class AbstractCar(models.Model):
    manufacturer = models.ForeignKey("Manufacturer", on_delete=models.CASCADE)

    class Meta:
        abstract = True
```

*`táirgeacht/samhlach.py`*

```python
from django.db import models
from products.models import AbstractCar

class Manufacturer(models.Model):
    name = models.TextField()

class Car(AbstractCar):
    pass
```

Sa sampla seo, réiteoidh an caidreamh `Car.Manufacturer` go `Production.Manufacturer`, mar a thugann sé in iúl don tsamhail choincréite atá sainmhínithe laistigh den chomhad production/models.py\`.

> **Múnlaí in-athúsáidte le tagairtí**
>
> Ligeann tagairtí coibhneasta samhlacha teibí in-athúsáidte a chruthú le caidrimh ar féidir leo réiteach ar chur i bhfeidhm éagsúla na samhlacha tagartha i bhfo-aicmí éagsúla

#### Iomlán

Sonraíonn tagairtí iomlána samhail ag baint úsáide as a `app_label` agus ainm ranga, rud a cheadaíonn tagairtí samhail ar fud feidhmchláir éagsúla. Is féidir leis an gcineál caidrimh leisciúil seo cabhrú le allmhairí ciorclach

Mar shampla, má shainmhínítear an tsamhail ```Monaróir ``in iarratas eile ar a dtugtar ``thirdpartyapp```, is féidir tagairt a thabhairt dó mar:

```
class Car(models.Model):
    manufacturer = models.ForeignKey(
        "thirdpartyapp.Manufacturer",
        on_delete=models.CASCADE,
    )
```

\<abstract-base-classes\>Léiríonn tagairtí iomlána ar an tsamhail chéanna i gcónaí, fiú nuair a úsáidtear iad in an:ref: samhail teibí .

## Tagairt API réimse

#### `class Field`

Is aicme teibí é `Field` a léiríonn colún tábla bunachar sonraí. Úsáideann Django réimsí chun an tábla bunachar sonraí a chruthú (:meth: db\_type), chun cineálacha Python a mhapáil go bunachar sonraí (:meth: get\_prep\_value) agus a mhalairt (:meth: from\_db\_value).

\<django.db.models.query.QuerySet\>Mar sin is píosa bunúsach é réimse in APIs éagsúla Django, go háirithe, :class: models \<django.db.models.Model\>\`agus:class: \`querysets.

I samhlacha, cuirtear réimse mar thréith aicme agus léiríonn sé colún tábla áirithe, féach:doc: /topics/db/models. Tá tréithe aige mar: attr: null agus:attr: unique, agus modhanna a úsáideann Django chun luach an réimse a mhapáil go luachanna sonracha bunachar sonraí.

Is fo-aicme é Field\` de:class: ~django.db.models.lookups.registerlookupmixin agus dá bhrí sin is féidir an bheath:class: ~django.db.Models.transform agus:class: ~Django.db.Models.lookup a chlárú air le húsáid in `QuerySet`s (m.sh. fi eld\_ainm\_\_exact="foo"). Gach: ref: cláraítear cuardaigh ionsuite \<field-lookups\>\`de réir réamhshocraithe.

Is cur i bhfeidhm ar ```Field` iad na réimsí ionsuite go léir atá ag Django, mar shampla:class: `Charfield`. Má theastaíonn réimse saincheaptha uait, is féidir leat aon cheann de na réimsí ionsuite a fho-aicmiú nó ``Réimse``` a scríobh ón tús. I gceachtar cás, féach:doc: /howto/custom-model-fields.

#### `description`

Tuairisc fhíorúil ar an réimse, m.sh. don iarratas:mod: django.contrib.admindocs.

Is féidir leis an tuairisc a bheith ar an bhfoirm:

```
description = _("String (up to %(max_length)s)")
```

ina ndéantar na hargóintí idirphóilte ó `__dict__` an réimse.

#### `descriptor_class`

A class implementing the [descriptor protocol](https://docs.python.org/3/reference/datamodel.html#descriptors)
that is instantiated and assigned to the model instance attribute. The
constructor must accept a single argument, the `Field` instance.
Overriding this class attribute allows for customizing the get and set
behavior.

Chun `Réimse` a mhapáil go cineál sonrach don bhunachar sonraí, nochtann Django roinnt modhanna:

#### `get_internal_type()`

Tugann sreang ar ais ag ainmniú an réimse seo chun críocha cúltaca sonracha. De réir réamhshocraithe, filleann sé ainm an ranga ar ais.

Féach: tagairt: cineálacha ionsuite i réimse a aithris le húsáid i réimsí saincheaptha.

#### `db_type(connection)`

Tugann an cineál sonraí colún bunachar sonraí ar ais don: aicme: Réimse, agus an nasc\` á gcur san áireamh.

Féach: ref: saincheapach-bunachar sonraí cineálach le húsáid i réimsí saincheaptha.

#### `rel_db_type(connection)`

Tugann an cineál sonraí colún bunachar sonraí ar fáil do réimsí amhail `ForeignKey` agus `OneTooneField` a thugann pointe chuir:class: Field, agus an nasc\` á gcur san áireamh.

Féach: ref: saincheapach-bunachar sonraí cineálach le húsáid i réimsí saincheaptha.

Tá trí phríomhchás ann ina gcaithfidh Django idirghníomhú le cúltaca bunachar sonraí agus réimsí:

- nuair a fhiosraíonn sé an bunachar sonraí (luach Python -\> luach cúltaca bunachar sonraí)
- nuair a luchtaíonn sé sonraí ón mbunachar sonraí (luach cúltaca bunachar sonraí -\> luach Python)
- nuair a shábhálann sé ar an mbunachar sonraí (luach Python -\> luach cúltaca bunachar sonraí)

Agus tú ag fiosrú, úsáidtear :meth: get\_db\_prep\_value agus:meth: get\_prep\_value:

#### `get_prep_value(value)`

Is é “luach” luach reatha tréith an tsamhail, agus ba cheart don mhodh sonraí a thabhairt ar ais i bhformáid atá ullmhaithe le húsáid mar pharaiméadar i bhfiosrúchán.

Féach:ref: tiontaire-python-objects-go-fiosrúcháin luacha' le húsáid.

#### `get_db_prep_value(value, connection, prepared=False)`

Converts `value` to a backend-specific value. By default it returns
`value` if `prepared=True`, and [`get_prep_value(value)`](#django.db.models.Field.get_prep_value) otherwise.

Féach:ref: luachanna fiosrúcháin a thiontú go luachanna bunachar sonraí le húsáid.

Agus sonraí á luchtú, úsáidtear: meth: from\_db\_value:

#### `from_db_value(value, expression, connection)`

Athraíonn sé luach mar a thug an bunachar sonraí ar ais go réad Python. Is é an cúil de:meth: get\_prep\_value.

Ní úsáidtear an modh seo don chuid is mó de na réimsí ionsuite mar go bhfilleann cúltaca an bunachar sonraí an cineál ceart Python cheana féin, nó déanann an cúltaca féin an tiontú.

Tá `léirithe` mar an gcéanna le `féin`.

Féach: Ref: luachanna tiontai-go-réadanna python le húsáid.

> **Note**
>
> Ar chúiseanna feidhmíochta, ní chuirtear from\_db\_value\` i bhfeidhm mar no-op ar réimsí nach dteastaíonn é (gach réimse Django). Dá bhrí sin ní féidir leat glaoch ar `super` i do shainmhíniú.

Agus tú ag sábháil, úsáidtear :meth: pre\_save agus:meth: get\_db\_prep\_save:

#### `get_db_prep_save(value, connection)`

Mar an gcéanna leis an: meth: get\_db\_prep\_value, ach tugtar air nuair a chaithfear luach an réimse a shábháil\* sa bhunachar sonraí. De réir réamhshocraithe tuairisceáin: meth: get\_db\_prep\_value.

#### `pre_save(model_instance, add)`

Modh ar a dtugtar roimh: meth: get\_db\_prep\_save chun an luach a ullmhú sula ndéantar é a shábháil (m.sh. le haghaidh: attr: Datefield.auto\_now).

Is é `model_instance` an cás leis an réimse seo agus `add` cibé an bhfuil an cás á shábháil sa bhunachar sonraí den chéad uair.

Ba chóir dó luach na tréithe cuí a thabhairt ar ais ó model\_instance\` don réimse seo. Tá ainm na tréithe in `self.attname` (bunaítear é seo ar:class: ~django.db.models.field).

Féach: tagairt: luachanna réamhphróiseálaí-roimh shábháilte' le húsáid.

Is minic a fhaigheann réimsí a luachanna mar chineál difriúil, ó shraitheadh nó ó fhoirmeacha.

#### `to_python(value)`

Athraíonn sé an luach isteach sa réad ceart Python. Feidhmíonn sé mar chúlghair:meth: value\_to\_string, agus tugtar air freisin in:meth: ~django.db.models.model.clean.

Féach: Ref: luachanna tiontai-go-réadanna python le húsáid.

Chomh maith le sábháil ar an mbunachar sonraí, ní mór don réimse a bheith ar an eolas freisin conas a luach a shraitheadh:

#### `value_from_object(obj)`

Tugann luach an réimse ar ais don shampla samhail ar leith.

Is minic a úsáideann an modh seo ó:meth: value\_to\_string.

#### `value_to_string(obj)`

Athraíonn sé `obj` go sreang. Úsáidtear chun luach an réimse a shraitheadh.

Féach: ref: tiontai-samhail-réim-to-sraitheoireach le húsáid.

Nuair a úsáidtear: aicme: foirmeacha samhail \<django.forms.ModelForm\>, ní mór go mbeadh a fhios ag an Réimse cén réimse foirme ba chóir a léiriú leis:

#### `formfield(form_class=None, choices_form_class=None, **kwargs)`

Tugann sé an réamhshocraithe:class: Django.Forms.Field den réimse seo ar ais chó:class: ~Django.Forms.ModelForm.

If [`formfield()`](#django.db.models.Field.formfield) is overridden to return `None`, this
field is excluded from the [`ModelForm`](/ga/6.0/topics/forms/modelforms/#django.forms.ModelForm).

De réir réamhshocraithe, má tá `form_class` agus `choices_form_class` ```None ``araon, úsáideann sé: class: `~django.forms.charfield`. Mura bhfuil: attr: `~django.db.models.field.choices` agus ``choices_form_class``` sonraithe sa réimse, úsáideann se:class: ~django.forms.typedChoiceField.

Féach: tagairt: sonraitheach-foirm-réimse-for-mhúnla-réimse le húsáid.

#### `deconstruct()`

Filleann sé 4-tuple le go leor faisnéise chun an réimse a athchruthú:

1. Ainm an réimse ar an tsamhail.
2. Conair allmhairithe an réimse (m.sh. `"Django.db.Models.IntegerField"`). Ba chóir gurb é seo an leagan is iniompartha, mar sin b'fhéidir go mbeadh níos lú sonrach níos fearr.
3. Liosta de na hargóintí seasaimh.
4. Argóintí eochairfhocal.

Caithfear an modh seo a chur le réimsí roimh 1.7 chun a chuid sonraí a aistriú ag baint úsáide:doc: /topics/imirceas.

## Cuardaigh a chlárú agus a fháil

\<lookup-registration-api\>Cuireann `Field` an API cláraithe cuardaithe:ref: cuardach i bhfeidhm. Is féidir an API a úsáid chun na cuardaigh atá ar fáil do rang allamuigh agus a chásanna a shaincheapadh, agus conas a bhfaightear cuardaigh ó réimse.

# Tagairt tréithe réimse

Tá roinnt tréithe i ngach cás Field\` a cheadaíonn a iompar a inmheasachaint. Úsáid na tréithe seo in ionad seiceálacha isinstance nuair is gá duit cód a scríobh atá ag brath ar fheidhmiúlacht réimse. Is féidir na tréithe seo a úsáid in éineacht leis an múnla:ref: Samhail. \_meta API \<model-meta-field-api\>\`chun cuardach do chineálacha réimse ar leith a chúngú. Ba chóir go gcuirfeadh réimsí samhail saincheaptha na bratacha

## Tréithe do réimsí

#### `Field.auto_created`

Bratach Boolean a thugann le fios an cruthaíodh an réimse go huathoibríoch, mar shampla an Onetoonefield\` a úsáideann oidhreacht mhúnla.

#### `Field.concrete`

Bratach Boolean a léiríonn an bhfuil colún bunachar sonraí a bhaineann leis an réimse.

#### `Field.hidden`

\<django.db.models.options.Options.get\_fields\>Bratach Boolean a léiríonn an bhfuil réimse i bhfolach agus nár chóir é a thabhairt ar ais ag: meth: Options.get\_fields () \`de réir réamhshocraithe. Sampla is ea an réimse droim le haghaidh a:class: \`~django.db.models.foreignKey le `related_name` a thosaíonn le `` `+' ``.

#### `Field.is_relation`

Bratach Boolean a thugann le fios an bhfuil tagairtí do mhúnla amháin nó níos mó eile i réimse maidir lena fheidhmiúlacht (m.sh. ForeignKey\`, ManyTomanyField\`, OnetooneField\`, srl.).

#### `Field.model`

Tugann sé an tsamhail ar a bhfuil an réimse sainmhínithe ar ais. Má shainmhínítear réimse ar sháraicme de mhúnla, tagróidh samhail don sáraicme, ní do rang an cháis.

## Tréithe do réimsí le caidreamh

Úsáidtear na tréithe seo chun ceist a dhéanamh ar chardánacht agus sonraí eile gaol. \<Field.is\_relation\>Tá na tréithe seo i láthair ar gach réimse; áfach, ní bheidh ach luachanna boolean acu (seachas None ) más cineál caidrimh é an réimse (:attr: field.is\_relations = True ).

#### `Field.many_to_many`

Bratach Boolean atá `Fíor-` má tá gaol go leor ag an réimse; `Fréag` ar shlí eile. Is é `ManyTomanyField` an t-aon réimse atá san áireamh le Django ina bhfuil sé seo `True`.

#### `Field.many_to_one`

Bratach Boolean atá `True` má tá gaol go leor le duine ag an réimse, mar shampla `ForeignKey`; `Fréag` ar shlí eile.

#### `Field.one_to_many`

Bratach Boolean atá “Fíor” má tá gaol duine le go leor ag an réimse, mar shampla `GinearicRelation` nó cúl `ForeignKey`; `Fréag` ar shlí eile.

#### `Field.one_to_one`

Bratach Boolean atá `True` má tá gaol duine le duine ag an réimse, mar shampla `OneTooneField`; `False` eile.

#### `Field.related_model`

Pointí leis an tsamhail a bhaineann an réimse leis. Mar shampla, `Údar` i ForeignKey (Author, on\_delete=Models.Cascade) \`. Is é “None” i gcónaí an model\_gaolmhar \`\`do \`GenericForeignKey\`.