djangodocs

Django 6.0
Gaeilge
Documentation contents

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 agus cineálacha réimse a thairgeann Django.

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 on string-based fields such as CharField and 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 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).

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.

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:

Code
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:

Code
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:

Code
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:

Code
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:

Code
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:

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

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:

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

  • The use of 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):

Python console
>>> 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:

Code
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 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:

Python console
>>> 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:

Code
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:

    Code
    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:

Code
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:

Code
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í:

Code
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í:

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

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:

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


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

<migration-serializing>Ní féidir lambdas 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. It will also be skipped during model validation. 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 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:

Code
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 or globally in the DEFAULT_AUTO_FIELD setting. For more, see Príomhréimsí uathoibríoch.

primary_key=True implies null=False and unique=True. Only one field per model can set primary_key=True. Composite primary keys must be defined using 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.

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() during model validation but not at the database level. If any unique_for_date constraint involves fields that are not part of a ModelForm (for example, if one of the fields is listed in exclude or has editable=False), 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.

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

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 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 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. It's required for all database backends included with Django except PostgreSQL and SQLite, which supports unlimited VARCHAR columns.

CharField.db_collation

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

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.

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.

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:

Code
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:

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

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.

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.

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:

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

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:

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

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

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:

Code
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:

Code
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:

Code
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 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 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:

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

``Réimse Ginithe ``

class GeneratedField(*, 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

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 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 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 subclass to serialize data types not supported by the standard JSON serializer (e.g. datetime.datetime or UUID). For example, you can use the DjangoJSONEncoder class.

Réamhshocraithe go JSON.JSONEncoder.

JSONField.decoder

An optional 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 datetimes.

Réamhshocraithe go JSON.JSONDecoder.

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

PositiveBigIntegerField

class PositiveBigIntegerField(**options)

Like a 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, 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, 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 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.

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

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

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

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:

Code
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 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 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:

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

    Model.delete() isn't called on related models, but the pre_delete and 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:

    Code
    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:

    Python console
    >>> 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 to the value passed to 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:

    Code
    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:

Code
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:

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

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:

Code
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:

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

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

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:

Code
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:

Code
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 does not support validators.

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:

Code
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:

Python console
>>> 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`:

Code
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:

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:

Code
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:

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

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:

Code
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 QuerySets (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:

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

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() is overridden to return None, this field is excluded from the 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`.

View as Markdown Edit this page on GitHub Official version