Tagairt API ``QuerySet ``Link to this heading

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

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

Nuair a dhéantar meastóireacht a dhéanamh ar ``QuerySet`Link to this heading

Go hinmheánach, is féidir ``QuerySet` a thógáil, a scagadh, a sliseadh, agus a rith timpeall go ginearálta gan an bunachar sonraí a bhualadh i ndáiríre. Ní tharlaíonn aon ghníomhaíocht bunachar sonraí i ndáiríre go dtí go ndéanann tú rud éigin chun an tac

Is féidir leat QuerySet a mheas ar na bealaí seo a leanas:

Aiter. Tá QuerySet in-athraithe, agus déanann sé a cheist bunachar sonraí a fhorghníomhú an chéad uair a dhéanann tú athrá air. Mar shampla, priontóidh sé seo ceannlíne na n-iontrálacha go léir sa bhunachar sonraí:
Code
```
for e in Entry.objects.all():
    print(e.headline)
```
Nóta: Ná húsáid é seo más mian leat a dhéanamh ach a chinneadh an bhfuil toradh amháin ar a laghad ann. Tá sé níos éifeachtaí úsáid: meth: ~QuerySet.exists.
Athrú asincrónaí. Is féidir QuerySet a athrú freisin trí async for:
Code
```
async for e in Entry.objects.all():
    results.append(e)
```
Tá an taisce bunúsach céanna ag athraitheoirí sioncrónach agus asincrónach de QuerySets.
Sliseach. Mar a mhínítear in:ref: limiting-querysets, is féidir QuerySet a sliseadh, ag baint úsáide as comhréiteach slisnú eagair Python. Is gnách go bhfillfidh QuerySet neamh-mheasúnaithe `QuerySet ``eile gan mheasúnú, ach déanfaidh Django ceist an bhunachar sonraí a fhorghníomhú má úsáideann tú an paraiméadar “céim” de chomhréir sliseanna, agus cuirfidh sé liosta ar ais. Tugann sé liosta freisin ag sliseadh ``QuerySet a rinneadh meastóireacht air.

Tabhair faoi deara freisin cé go bhfilleann ``QuerySet` neamh-mheasúnaithe ```QuerySet ``eile neamh-mheasúnaithe, ní cheadaítear é a mhodhnú tuilleadh (m.sh., níos mó scagairí a chur leis, nó ordú a mhodhnú), ós rud é nach aistríonn sé go maith go SQL agus ní bheadh brí soiléir aige ach an oiread.
Piccling/Caching. Féach an chuid seo a leanas le haghaidh sonraí faoin méid a bhfuil i gceist le linn Picling QuerySets. Is é an rud tábhachtach chun críocha an chuid seo ná go léitear na torthaí ón mbunachar sonraí.
repr () . Déantar meastóireacht ar QuerySet nuair a ghlaonn tú ``repr () ``air. Tá sé seo ar mhaithe le háisiúlacht san ateangaire idirghníomhach Python, ionas gur féidir leat do thorthaí a fheiceáil láithreach agus an API á úsáid idirghníomhach.
len () . Déantar meastóireacht ar QuerySet nuair a ghlaonn tú `len () ``air. Tugann sé seo, mar a d'fhéadfá a bheith ag súil leis, fad an liosta torthaí ar ais.

Nóta: Mura gá duit ach líon na dtaifid sa tacar a chinneadh (agus mura dteastaíonn na rudaí iarbhír uait), tá sé i bhfad níos éifeachtaí comhaireamh a láimhseáil ag leibhéal an bhunachar sonraí ag baint úsáide as ``SELECT COUNT (*) SQL. Soláthraíonn Django modh a: meth: `~QuerySet.count ar an gcúis seo go beacht.
liosta () . Meastóireacht a chur i bhfeidhm ar QuerySet trí `liosta () ``a ghlaoch air. Mar shampla:
Code
```
entry_list = list(Entry.objects.all())
```
bool () . Trí thástáil a dhéanamh ar QuerySet i gcomhthéacs boolean, mar shampla bool () ``, `nó, nó `, and` nó ráiteas if, a úsáid, is cúis leis an bhfiosrú a fhorghníomhú. Má tá toradh amháin ar a laghad ann, is é an ``QuerySet True`, True`, ar shlí eile False. Mar shampla:
Code
```
if Entry.objects.filter(headline="Test"):
    print("There is at least one Entry with the headline Test")
```
Nóta: Mura dteastaíonn uait ach a chinneadh an bhfuil toradh amháin ar a laghad ann (agus nach dteastaíonn na rudaí iarbhír uait), tá sé níos éifeachtaí úsáid: meth: ~QuerySet.exists.

Picling `QuerySetsLink to this heading

Má tá tú: mod: pickle agus ``QuerySet ``, cuirfidh sé seo iallach ar na torthaí go léir a luchtú isteach i gcuimhne sula ndéantar piceáil. De ghnáth úsáidtear picling mar réamhtheoir do chaching agus nuair a dhéantar an tacar fiosrúcháin a athluchtú, ba mhaith leat go mbeadh na torthaí i láthair cheana féin agus réidh le húsáid (is féidir le léamh ón mbunachar sonraí roinnt ama a thógáil, ag ruaigeadh cuspóir na caching). Ciallaíonn sé seo nuair a dhíphicfidh tú ``QuerySet`, go bhfuil na torthaí ann i láthair na huaire gur piceáladh é, seachas na torthaí atá sa bhunachar sonraí faoi láthair.

Mura dteastaíonn uait ach an fhaisnéis riachtanach a phiocadh chun an QuerySet a athchruthú ón mbunachar sonraí níos déanaí, piceáil tréith `QuerySet den QuerySet`. Ansin is féidir leat an QuerySet bunaidh a athchruthú (gan aon torthaí luchtaithe) ag baint úsáide as cód éigin mar seo:

Python console

>>> import pickle
>>> query = pickle.loads(s)  # Assuming 's' is the pickled string.
>>> qs = MyModel.objects.all()
>>> qs.query = query  # Restore the original 'query'.

Is réad trédhearcach é an tréith fiosraithe. Léiríonn sé inmheánacha tógála na fiosrúcháin agus níl sé mar chuid den API poiblí. Mar sin féin, tá sé sábháilte (agus tacaítear go hiomlán) ábhar na tréithe a phiocadh agus a dhíphiocadh mar a thuairiscítear anseo.

Srianta ar ``QuerySet.values_List () ``

Má athchruthaíonn tú: meth: QuerySet.values_list ag baint úsáide as an tréith picilte `Query, déanfar é a thiontú u:meth: QuerySet.values:

Python console

>>> import pickle
>>> qs = Blog.objects.values_list("id", "name")
>>> qs
<QuerySet [(1, 'Beatles Blog')]>
>>> reloaded_qs = Blog.objects.all()
>>> reloaded_qs.query = pickle.loads(pickle.dumps(qs.query))
>>> reloaded_qs
<QuerySet [{'id': 1, 'name': 'Beatles Blog'}]>

API `QuerySet`Link to this heading

Seo an dearbhú foirmiúil ar ``QuerySet ``:

class QuerySet(model=None, query=None, using=None, hints=None)Link to this definition

<chaining-filters>De ghnáth nuair a bheidh tú ag idirghníomhú le QuerySet úsáidfidh tú é ag: ref: `scagairí slabhraí `. Chun an oibriú seo, cuireann an chuid is mó de na modhanna ``QuerySet ``ceisteanna nua ar ais. Clúdaítear na modhanna seo go mion níos déanaí sa chuid seo.

Tá na tréithe poiblí seo a leanas ag an rang QuerySet is féidir leat a úsáid le haghaidh ionbhreithniú:

orderedLink to this definition: True if the QuerySet is ordered — i.e. has an order_by() clause or a default ordering on the model. False otherwise.

dbLink to this definition: An bunachar sonraí a úsáidfear má dhéantar an cheist seo a fhorghníomhú anois.

Modhanna a thugann `QuerySet`s nua ar aisLink to this heading

Soláthraíonn Django raon modhanna mionscrúdaithe ``QuerySet ``a mhodhníonn na cineálacha torthaí a thugann an QuerySet ar ais nó an bealach a fhorghníomhaítear a cheist SQL.

``scagaire () ``Link to this heading

filter(*args, **kwargs)Link to this definition

Filleann sé QuerySet nua ina bhfuil rudaí a mheaitseálann leis na paraiméadair chuardaigh ar leith.

Ba chóir go mbeadh na paraiméadair chuardaigh (**kwargs `) san fhormáid a thuairiscítear i Cuardach allamui thíos. Ceanglaítear paraiméadair iolracha trí AND` sa ráiteas SQL bunúsach.

<django.db.models.Q>Más gá duit ceisteanna níos casta a fhorghníomhú (mar shampla, ceisteanna le ráitis OR`), is féidir leat:class: Q earraí `(``*args`) a úsáid.

``eisiamh () ``Link to this heading

exclude(*args, **kwargs)Link to this definition

Filleann sé QuerySet nua ina bhfuil rudaí nach meaitníon* leis na paraiméadair chuardaigh a thugtar.

Ba chóir go mbeadh na paraiméadair chuardaigh (**kwargs `) san fhormáid a thuairiscítear i Cuardach allamui thíos. Ceanglaítear paraiméadair iolracha trí AND` sa ráiteas SQL bunúsach, agus tá an rud iomlán faoi iúl i ``NOT () ``.

Ní chuimsíonn an sampla seo gach iontráil a bhfuil a “pub_date” níos déanaí ná 2005-1-3 AGUS a bhfuil “Dia duit” a ceannlíne `:

Code

Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline="Hello")

I dtéarmaí SQL, déanann sé meastóireacht ar:

SQL

SELECT ...
WHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello')

Ní chuimsíonn an sampla seo gach iontráil a bhfuil a “pub_date” níos déanaí ná 2005-1-3 NÓ a bhfuil a cheannteideal “Dia duit”:

Code

Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline="Hello")

I dtéarmaí SQL, déanann sé meastóireacht ar:

SQL

SELECT ...
WHERE NOT pub_date > '2005-1-3'
AND NOT headline = 'Hello'

Tabhair faoi deara go bhfuil an dara sampla níos sriantacha.

<django.db.models.Q>Más gá duit ceisteanna níos casta a fhorghníomhú (mar shampla, ceisteanna le ráitis OR`), is féidir leat:class: Q earraí `(``*args`) a úsáid.

``annotate () ``Link to this heading

annotate(*args, **kwargs)Link to this definition

Annotates each object in the QuerySet with the provided list of query expressions or Q objects. Each object can be annotated with:

a simple value, via Value();
a reference to a field on the model (or any related models), via F();
a boolean, via Q(); or
a result from an aggregate expression (averages, sums, etc.) computed over the objects that are related to the objects in the QuerySet.

Is anótáil é gach argóint le annotate () ``a chuirfear le gach rud sa `QuerySet a chuirtear ar ais.

Déantar cur síos ar na feidhmeanna comhiomlánaithe a sholáthraíonn Django i Feidhmeanna Comhiomlánacha thíos.

Úsáidfidh anótaí a shonraítear ag baint úsáide as argóintí eochairfhocal an eochairfhocal mar an alias don anótáil Beidh ainm ar argóintí gan ainm a ghintear dóibh bunaithe ar ainm na feidhme chomhiomlán agus ar an réimse samhail atá á chomhiomlánú. Ní féidir ach nathanna comhiomlána a thagraíonn réimse amháin a bheith ina argóintí gan ainm Caithfidh gach rud eile a bheith ina argóint eochairfhocal.

Mar shampla, má bhí tú ag ionramháil liosta blaganna, b'fhéidir gur mhaith leat a chinneadh cé mhéad iontráil a rinneadh i ngach blag:

Python console

>>> from django.db.models import Count
>>> q = Blog.objects.annotate(Count("entry"))
# The name of the first blog
>>> q[0].name
'Blogasaurus'
# The number of entries on the first blog
>>> q[0].entry__count
42

Ní shainmhíníonn an tsamhail Blag ``tréith `entry__count leis féin, ach trí argóint eochairfhocal a úsáid chun an fheidhm chomhiomlán a shonrú, is féidir leat ainm na nótaí a rialú:

Python console

>>> q = Blog.objects.annotate(number_of_entries=Count("entry"))
# The number of entries on the first blog, using the name provided
>>> q[0].number_of_entries
42

Le haghaidh plé domhain ar chomhiomlánú, féach:doc: `an treoir ábhair ar Chomhiomlán' </topics/db/aggregation>.

``alias () ``Link to this heading

alias(*args, **kwargs)Link to this definition

Mar an gcéanna len:meth: annotate, ach in ionad rudaí a anótáil sa QuerySet `, sábhálann sé an abairt lena n-athúsáid níos déanaí le modhanna QuerySet eile. Tá sé seo úsáideach nuair nach bhfuil toradh na léirithe féin ag teastáil ach úsáidtear é chun scagadh, ordú nó mar chuid de léiriú casta. Gan roghnú an luach neamhúsáidte cuirtear obair iomarcach ón mbunachar sonraí agus ba chóir go mbeadh feidhmíocht níos fearr

Mar shampla, más mian leat blaganna a fháil le níos mó ná 5 iontráil, ach nach bhfuil suim agat i líon cruinn na n-iontrálacha, d'fhéadfá é seo a dhéanamh:

Python console

>>> from django.db.models import Count
>>> blogs = Blog.objects.alias(entries=Count("entry")).filter(entries__gt=5)

Is féidir ``alias () ``a úsáid i gcomhar le:meth: annotate, :meth: eisiú, :meth: filter, :meth: ord_by, agus:meth: nuashonraithe. Chun léiriú ailíseach a úsáid le modhanna eile (e.g.:meth: comhiomlán), ní mór duit é a chur chun cinn go dtí anótáil:

Code

Blog.objects.alias(entries=Count("entry")).annotate(
    entries=F("entries"),
).aggregate(Sum("entries"))

Is féidir le: meth: filter agus:meth: order_by abairtí a ghlacadh go díreach, ach is minic nach dtarlaíonn tógáil agus úsáid abairtí san áit chéanna (mar shampla, cruthaíonn modh ``QuerySet ``abairtí, le húsáid níos déanaí i radhairc). Ligeann ``alias () ``abairtí casta a thógáil go hinchéimiúil, b'fhéidir go gcuimsíonn modhanna agus modúil iolracha, tagairt a dhéanamh do na codanna abairt de réir a n-ainmneacha agus ní úsáidtear ach: meth: annotate don toradh deiridh.

``ord_by () ``Link to this heading

order_by(*fields)Link to this definition

De réir réamhshocraithe, ordaítear na torthaí a chuirtear ar ais ag QuerySet tríd an tuple ordaithe a thugann an rogha ordú ``i `Meta an tsamhail. Is féidir leat é seo a shárú ar bhonn Per-QuerySet tríd an modh order_by a úsáid.

Sampla:

Code

Entry.objects.filter(pub_date__year=2005).order_by("-pub_date", "headline")

Ordófar an toradh thuas ag pub_date ``ag dul síos, ansin ag ``ceannlíne ag ardú. Léiríonn an comhartha diúltach os comhair ” -pub_date “ ordú* síos. Tá ord ardaitheach intuigthe. Chun ordú go randamach, bain úsáid as ``”?” ``, mar sin:

Code

Entry.objects.order_by("?")

Nóta: ``order_by ('?') D'fhéadfadh ceisteanna ``a bheith daor agus mall, ag brath ar an gcúltaca bunachar sonraí atá á úsáid agat.

Chun ordú de réir réimse i samhail dhifriúil, bain úsáid as an gcomhréir céanna agus nuair a bhíonn tú ag fiosrú ar fud caidrimh mhúnla. Is é sin, ainm an réimse, ina dhiaidh sin béim dúbailte (__`), agus ainm an réimse sa tsamhail nua ina dhiaidh sin, agus mar sin de do an oiread samhlacha agus is mian leat páirt a ghlacadh. Mar shampla:

Code

Entry.objects.order_by("blog__name", "headline")

<django.db.models.Options.ordering>Má dhéanann tú iarracht ordú de réir réimse a bhaineann le samhail eile, úsáidfidh Django an t-ordú réamhshocraithe ar an tsamhail ghaolmhar, nó ordú de réir phríomh-eochair an tsamhail ghaolmhar mura bhfuil aon: attr: Meta.Ordering `sonraithe. Mar shampla, ós rud é nach bhfuil aon ordú réamhshocraithe sonraithe sa tsamhail ``Blog`:

Code

Entry.objects.order_by("blog")

... comhionann le:

Code

Entry.objects.order_by("blog__id")

Dá mbeadh ordú = ['ainm'] ``ag `Blog, ansin bheadh an chéad tacar ceisteanna comhionann le:

Code

Entry.objects.order_by("blog__name")

Is féidir leat ordú freisin trí:doc: léirithe fiosraithe trí ghlaoch ar: meth: ~.Expression.asc nó</ref/models/expressions> :meth: ~.Expression.desc ar an abairt:

Code

Entry.objects.order_by(Coalesce("summary", "headline").desc())

Tá argóintí ag: meth: ~.Expression.asc agus:meth: ~.Expression.desc (nulls_first agus nulls_last) a rialaíonn an chaoi a ndéantar luachanna null a shórtáil.

Be cautious when ordering by fields in related models if you are also using distinct(). See the note in distinct() for an explanation of how related model ordering can change the expected results.

Note

Tá sé ceadaithe réimse illuachmhara a shonrú chun na torthaí a ordú trí (mar shampla, a:class: réimse ~django.db.models.manyToManyField, nó an gaol droim a: réimse a:class: ~Django.db.Models.ForeignKey).

Smaoinigh ar an gcás seo:

Code

class Event(Model):
    parent = models.ForeignKey(
        "self",
        on_delete=models.CASCADE,
        related_name="children",
    )
    date = models.DateField()


Event.objects.order_by("children__date")

Anseo, d'fhéadfadh go mbeadh sonraí iolracha ordaithe ann do gach Imeacht ``; cuirfear gach ``Imeacht le leana` iolracha ar ais go leor uaireanta isteach sa QuerySet nua a chruthaíonn order_by () ``. Is é sin le rá, d'fhéadfadh go n-úsáidtear ``order_by () ``ar an `QuerySet níos mó earraí a thabhairt ar ais ná mar a bhí tú ag obair orthu chun tús a chur leis - rud nach bhfuil súil leis ná úsáideach is dócha.

Mar sin, bí cúramach agus réimse illuachmhara á úsáid agat chun na torthaí a ordú. **Más féidir leat a bheith cinnte nach mbeidh ach píosa sonraí amháin ag ordú do gach ceann de na míreanna atá á ordú agat, níor cheart go mbeadh fadhbanna ag an gcur chuige seo. Mura bhfuil, déan cinnte gurb iad na torthaí an rud a bhfuil súil agat leo.

Níl aon bhealach ann chun a shonrú an chóir go mbeadh ordú íogair ó cháis. Maidir le cás-íogaireacht, ordóidh Django torthaí ach is gnách go n-ordóidh do chúlcheann bunachar sonraí iad.

Is féidir leat ordú trí réimse a thiontú go litreacha beaga le:class: ~django.db.models.functions.lower a bhaint amach ordú comhsheasmhach cás-chomhsheasmhach:

Code

Entry.objects.order_by(Lower("headline").desc())

If you don't want any ordering to be applied to a query, not even the default ordering, call order_by() with no parameters.

Is féidir leat a rá an bhfuil ceist ordaithe nó nach bhfuil tríd an tréith: attr: .querySet.Ordered a sheiceáil, a bheidh ina True má ordaíodh an QuerySet ar bhealach ar bith.

Glanfaidh gach glao order_by () ``aon ordú roimhe seo. Mar shampla, ordófar an cheist seo ag ``pub_date agus ní headline:

Code

Entry.objects.order_by("headline").order_by("pub_date")

``droim () `Link to this heading

reverse()Link to this definition

Úsáid an modh ``reverse () ``chun an t-ord ina gcuirtear eilimintí tacar fiosrúcháin ar ais a aisiompú. Athchógann glaoch ar ``reverse () ``an dara huair an t-ordú ar ais go dtí an gnáththreo.

Chun na cúig mhír “deireanach” a aisghabháil i tacar fiosrúcháin, d'fhéadfá seo a dhéanamh:

Code

my_queryset.reverse()[:5]

Tabhair faoi deara nach bhfuil sé seo mar an gcéanna le slisnú ó dheireadh seicheamh i Python. Tabharfaidh an sampla thuas an mír deireanach ar ais ar dtús, ansin an mír leathdheiridh agus mar sin de. Dá mbeadh seicheamh Python againn agus dá bhféachfaimis ar ``seq [-5:] ``, feicfimid an cúigiú mír deireanach ar dtús. Ní thacaíonn Django leis an modh rochtana sin (slisnú ón deireadh), toisc nach féidir é a dhéanamh go héifeachtúil i SQL.

Also, note that reverse() should generally only be called on a QuerySet which has a defined ordering (e.g., when querying against a model which defines a default ordering, or when using order_by()). If no such ordering is defined for a given QuerySet, calling reverse() on it has no real effect (the ordering was undefined prior to calling reverse(), and will remain undefined afterward).

``difriúil () ``Link to this heading

distinct(*fields)Link to this definition

Filleann QuerySet nua a úsáideann SELECT DISTINCT ina cheist SQL. Cuireann sé seo deireadh le sraitheanna dúblacha ó thorthaí na gce

De réir réamhshocraithe, ní chuirfidh QuerySet ``deireadh le sraitheanna dúblacha. Go praiticiúil, is annamh a bhíonn sé seo ina fhadhb, toisc nach dtugann ceisteanna simplí mar `Blog.Objects.all () `isteach an fhéidearthacht sraitheanna torthaí dúblacha. Mar sin féin, má chuimsíonn d'fhiosrúchán iolrthaí táblaí, is féidir torthaí dúblacha a fháil nuair a dhéantar “QuerySet” a mheas. Sin nuair a úsáideann tú ``difriúil () `.

Note

Tá aon réimsí a úsáidtear i nglao an:meth: order_by san áireamh sna colúin SQL SELECT. Uaireanta d'fhéadfadh torthaí gan choinne a bheith mar thoradh air seo nuair a úsáidtear iad i gcomhar le ``difriúil () ``. Má ordaíonn tú de réir réimsí ó mhúnla gaolmhar, cuirfear na réimsí sin leis na colúin roghnaithe agus féadfaidh siad a bheith cosúil go bhfuil sraitheanna dúblacha ar leith ar shlí eile. Ós rud é nach bhfuil na colúin bhreise le feiceáil sna torthaí ar ais (níl siad ann ach chun tacú le hordú), is cosúil go bhfuil torthaí neamh-shainiúla á thabhairt ar ais uaireanta.

Similarly, if you use a values() query to restrict the columns selected, the columns used in any order_by() (or default model ordering) will still be involved and may affect uniqueness of the results.

The moral here is that if you are using distinct() be careful about ordering by related models. Similarly, when using distinct() and values() together, be careful when ordering by fields not in the values() call.

Ar PostgreSQL amháin, is féidir leat argóintí seasaimh (*réimsí `) a rith d'fhonn ainmneacha na réimsí ar chóir go mbeadh feidhm ag an DISTINCT a shonrú. Aistríonn sé seo go fiosrúchán SQL SELECT DISTINCT ON. Seo an difríocht. Maidir le gnáthghlao ``difriúil () ``, déanann an bunachar sonraí comparáid idir gach réimse i ngach sraith agus iad ag cinneadh cé na sraitheanna atá ar leith. Maidir le glao ``difriúil () ``le hainmneacha réimse sonraithe, ní dhéanfaidh an bunachar sonraí ach comparáid idir na hainmneacha réimse sonraithe.

Samplaí (ní oibreoidh iad siúd tar éis an chéad cheann ach ar PostgreSQL):

Python console

>>> Author.objects.distinct()
<QuerySet [...]>
>>> Entry.objects.order_by("pub_date").distinct("pub_date")
<QuerySet [...]>
>>> Entry.objects.order_by("blog").distinct("blog")
<QuerySet [...]>
>>> Entry.objects.order_by("author", "pub_date").distinct("author", "pub_date")
<QuerySet [...]>
>>> Entry.objects.order_by("blog__name", "mod_date").distinct("blog__name", "mod_date")
<QuerySet [...]>
>>> Entry.objects.order_by("author", "pub_date").distinct("author")
<QuerySet [...]>

Note

Coinnigh i gcuimhne go n-úsáideann: meth: order_by aon ordú samhail ghaolmhara réamhshocraithe atá sainmhínithe. B'fhéidir go mbeidh ort ordú go sainráite de réir an ghaol _id nó réimse tagartha chun a chinntiú go n-oireann na nathanna DISTINCT ON iad siúd ag tús an chlásal ORDER BY ``. Mar shampla, má shainmhíníodh an tsamhail ``Blog an:attr: ~Django.db.Models.Options.Ordering le ``ainm ``:

Code

Entry.objects.order_by("blog").distinct("blog")

... ní oibreodh toisc go ndéanfaí an cheist a ordú ag blog__name agus ar an gcaoi sin mímheaitseáil an abairt DISTINCT ON. Bheadh ort ordú go sainráite de réir réimse gaolmhar _id (blog_id sa chás seo) nó an ceann tagartha (blog__pk) chun a chinntiú go n-oireann an dá abairt.

``luachanna () ``Link to this heading

values(*fields, **expressions)Link to this definition

Tugann “QuerySet” ar ais foclóirí, seachas cásanna samhlacha, nuair a úsáidtear é mar athrá.

Léiríonn gach ceann de na foclóirí sin réad, agus na heochracha a fhreagraíonn d'ainmneacha tréithe rudaí samhail.

Déanann an sampla seo comparáid idir foclóirí ``luachanna () ``leis na gnáth-rudaí samhail:

Python console

# This list contains a Blog object.
>>> Blog.objects.filter(name__startswith="Beatles")
<QuerySet [<Blog: Beatles Blog>]>

# This list contains a dictionary.
>>> Blog.objects.filter(name__startswith="Beatles").values()
<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>

Glacann an modh luachanna () ``argóintí suíomhanna roghnacha, ``*réimsí, a shonraíonn ainmneacha réimse ar chóir an SELECT a theorannú dóibh. Má shonraíonn tú na réimsí, ní bheidh i ngach foclóir ach na heochair/luachanna réimse do na réimsí a shonraíonn tú. Mura sonraíonn tú na réimsí, beidh eochair agus luach i ngach foclóir do gach réimse sa tábla bunachar sonraí.

Sampla:

Python console

>>> Blog.objects.values()
<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>
>>> Blog.objects.values("id", "name")
<QuerySet [{'id': 1, 'name': 'Beatles Blog'}]>

Glacann an modh luachanna () ``argóintí eochairfhocal roghnacha freisin, ``**léiritheach, a chuirtear trí:meth: annotate:

Python console

>>> from django.db.models.functions import Lower
>>> Blog.objects.values(lower_name=Lower("name"))
<QuerySet [{'lower_name': 'beatles blog'}]>

Is féidir leat úsáid a bhaint as ionsuite agus: doc: `cuardach saincheapaithe' ag ordú </howto/custom-lookups>. Mar shampla:

Python console

>>> from django.db.models import CharField
>>> from django.db.models.functions import Lower
>>> CharField.register_lookup(Lower)
>>> Blog.objects.values("name__lower")
<QuerySet [{'name__lower': 'beatles blog'}]>

Cuirtear comhiomlán laistigh de chlásal ``luachanna () ``i bhfeidhm roimh argóintí eile laistigh den chlásal ``luachanna () `céanna. Más gá duit grúpáil de réir luach eile, cuir é le clásal “luachanna ()” níos luaithe ina ionad. Mar shampla:

Python console

>>> from django.db.models import Count
>>> Blog.objects.values("entry__authors", entries=Count("entry"))
<QuerySet [{'entry__authors': 1, 'entries': 20}, {'entry__authors': 1, 'entries': 13}]>
>>> Blog.objects.values("entry__authors").annotate(entries=Count("entry"))
<QuerySet [{'entry__authors': 1, 'entries': 33}]>

Cúpla caolchúrsaíocht is fiú a lua:

Má tá réimse agat darb ainm foo` is é sin a:class: ~django.db.models.foreignKey, cuirfidh an glao réamhshocraithe values () ``ar ais eochair foclóra ar a dtugtar ``foo_id, ós rud é seo ainm an tréith samhail i bhfolach a stóráil an luach iarbhír (tagraíonn an tréith foo' don tsamhail ghaolmhar). Nuair a bhíonn tú ag glaoch ar `luachanna () ``agus ag dul isteach ainmneacha réimse, is féidir leat dul isteach ``foo` nó foo_id agus gheobhaidh tú an rud céanna ar ais (meaitneoidh an eochair foclóra leis an ainm réimse a chuaigh tú isteach).

Mar shampla:
Python console
```
>>> Entry.objects.values()
<QuerySet [{'blog_id': 1, 'headline': 'First Entry', ...}, ...]>

>>> Entry.objects.values("blog")
<QuerySet [{'blog': 1}, ...]>

>>> Entry.objects.values("blog_id")
<QuerySet [{'blog_id': 1}, ...]>
```
When using values() together with distinct(), be aware that ordering can affect the results. See the note in distinct() for details.
If you use a values() clause after an extra() call, any fields defined by a select argument in the extra() must be explicitly included in the values() call. Any extra() call made after a values() call will have its extra selected fields ignored.
Calling only() and defer() after values() doesn't make sense, so doing so will raise a TypeError.

Éilíonn claochruithe agus comhiomlánaithe a chur le chéile dhá ghlaonna: meth: annotate a úsáid, go sainráite nó mar argóintí eochairfhocal chuig:meth: luacha. Mar atá thuas, má tá an claochlú cláraithe ar an gcineál réimse ábhartha is féidir an chéad:meth: annotate a fhágáil, dá bhrí sin tá na samplaí seo a leanas coibhéiseach:

Python console

>>> from django.db.models import CharField, Count
>>> from django.db.models.functions import Lower
>>> CharField.register_lookup(Lower)
>>> Blog.objects.values("entry__authors__name__lower").annotate(entries=Count("entry"))
<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>
>>> Blog.objects.values(entry__authors__name__lower=Lower("entry__authors__name")).annotate(
...     entries=Count("entry")
... )
<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>
>>> Blog.objects.annotate(entry__authors__name__lower=Lower("entry__authors__name")).values(
...     "entry__authors__name__lower"
... ).annotate(entries=Count("entry"))
<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>

Tá sé úsáideach nuair a fhios agat nach mbeidh luachanna ag teastáil uait ach ó líon beag de na réimsí atá ar fáil agus ní bheidh feidhmiúlacht réad samhail de dhíth ort. Tá sé níos éifeachtaí ach na réimsí a theastaíonn uait a úsáid a roghnú.

Mar fhocal scoir, tabhair faoi deara gur féidir leat glaoch ar filter () ``, `order_by (), srl. Tar éis an ghlao ``values () ``, ciallaíonn sin go bhfuil an dá ghlao seo comhionann:

Code

Blog.objects.values().order_by("id")
Blog.objects.order_by("id").values()

Is fearr leis na daoine a rinne Django na modhanna go léir a théann i bhfeidhm ag SQL a chur ar dtús, agus aon mhodhanna a théann i bhfeidhm ag aschur (mar shampla `luachanna () `) ina dhiaidh sin (roghnach), ach níl sé tábhachtach i ndáiríre. Is é seo do sheans do dhaoine aonair a thaispeáint i ndáiríre.

Is féidir leat tagairt a dhéanamh freisin do réimsí ar mhúnlaí gaolmhara le caidreamh droim trí thréithe OneTooneField, ForeignKey` agus ManyTomanyField:

Python console

>>> Blog.objects.values("name", "entry__headline")
<QuerySet [{'name': 'My blog', 'entry__headline': 'An entry'},
     {'name': 'My blog', 'entry__headline': 'Another entry'}, ...]>

``liosta_luachanna () ``Link to this heading

values_list(*fields, flat=False, named=False)Link to this definition

Tá sé seo cosúil le ``luachanna () ``ach amháin go bhfilleann sé foclóirí ar ais, seachas foclóirí a thabhairt ar ais, nuair a dhéantar iad a athrá. Cuimsíonn gach tuple an luach ón réimse nó an abairt faoi seach a chuirtear isteach sa ghlao `values_list () `- mar sin is é an chéad mhír an chéad réimse, srl. Mar shampla:

Python console

>>> Entry.objects.values_list("id", "headline")
<QuerySet [(1, 'First entry'), ...]>
>>> from django.db.models.functions import Lower
>>> Entry.objects.values_list("id", Lower("headline"))
<QuerySet [(1, 'first entry'), ...]>

Mura dtéann tú ach i réimse amháin, is féidir leat dul isteach sa pharaiméadar flat freisin. Má tá “Fíor”, ciallaíonn sé seo gur luachanna aonair iad na torthaí ar ais, seachas 1-tuples. Ba chóir go ndéanfadh sampla an difríocht níos soiléire:

Python console

>>> Entry.objects.values_list("id").order_by("id")
<QuerySet[(1,), (2,), (3,), ...]>

>>> Entry.objects.values_list("id", flat=True).order_by("id")
<QuerySet [1, 2, 3, ...]>

Is earráid é dul isteach i flat nuair a bhíonn níos mó ná réimse amháin ann.

Is féidir leat named=true a rith chun torthaí a fháil mar a:func: ~python:collections.namedtuple:

Python console

>>> Entry.objects.values_list("id", "headline", named=True)
<QuerySet [Row(id=1, headline='First entry'), ...]>

Má úsáidtear tuple ainmnithe, d'fhéadfadh úsáid a bhaint as na torthaí níos inléite, ar chostas pionós feidhmíochta beag as na torthaí a athrú go tuple ainmnithe.

Mura gcuireann tú aon luachanna ar aghaidh chuig values_list () `, cuirfidh sé na réimsí go léir sa tsamhail ar ais, san ord a dearbhíodh iad.

Is é riachtanas coitianta luach réimse sonrach a fháil de shampla samhail áirithe. Chun é sin a bhaint amach, bain úsáid as values_list () ``agus glao ``get ()` ina dhiaidh sin:

Python console

>>> Entry.objects.values_list("headline", flat=True).get(pk=1)
'First entry'

Tá luachanna () ``agus `values_list () beartaithe araon mar bharrfheabhsú do chás úsáide ar leith: fo-thacar sonraí a aisghabháil gan an lascaire a bhaineann le samhail samhail a chruthú. Titeann an meafar seo óna chéile agus tú ag déileáil le caidrimh illuachmhar agus caidrimh illuachmhar eile (mar shampla gaol duine le go leor eochair eachtrach droim) toisc nach bhfuil an toimhde “aon tsraith, rud amháin”.

Mar shampla, tabhair faoi deara an t-iompar agus tú ag fiosrú ar fud a:class: ~django.db.models.manyToManyField:

Python console

>>> Author.objects.values_list("name", "entry__headline")
<QuerySet [('Noam Chomsky', 'Impressions of Gaza'),
 ('George Orwell', 'Why Socialists Do Not Believe in Fun'),
 ('George Orwell', 'In Defence of English Cooking'),
 ('Don Quixote', None)]>

Tá údair le hiontrálacha iolracha le feiceáil arís agus uaireanta agus tá ``None ``ag údair gan aon iontrálacha don cheannlíne iontrála.

Ar an gcaoi chéanna, nuair a fhiosraítear eochair eachtrach droim, tá ``None ``le feiceáil le haghaidh iontrálacha nach bhfuil aon údar acu:

Python console

>>> Entry.objects.values_list("authors")
<QuerySet [('Noam Chomsky',), ('George Orwell',), (None,)]>

``dátaí () ``Link to this heading

dates(field, kind, order='ASC')Link to this definition

Filleann QuerySet a mheastóidh ar liosta d':class: datetime.date rudaí a léiríonn gach dáta atá ar fáil de chineál áirithe laistigh d'ábhar an QuerySet.

Ba chóir go mbeadh réimse ``mar ainm ``Datefield de do mhúnla. Ba chóir go mbeadh cineál blian", "míos"`, "seachtaine"`, nó ``"lá” ``. Gach duine: Class: “datetime.date” réad sa liosta torthaí “gearrtha” go dtí an ``cineál ``tugtar.

Tugann "bliain" liosta de na luachanna bliana ar leith uile don réimse.
Tugann "mhí" liosta de na luachanna bliana/míosa ar leith go léir don réimse.
Tugann ``"seachtaine"` liosta de na luachanna bliana/seachtaine ar leith go léir don réimse. Is Luan a bheidh na dátaí go léir.
Tugann ``"lá” ``liosta de na luachanna ar leith bliant/mí/lá go léir don réimse.

Ba chóir go mbeadh `ASC'` nó ``DESC', ASC', 'ordú ``,' réamhshocraithe '. Sonraíonn sé seo conas na torthaí a ordú.

Samplaí:

Python console

>>> Entry.objects.dates("pub_date", "year")
[datetime.date(2005, 1, 1)]
>>> Entry.objects.dates("pub_date", "month")
[datetime.date(2005, 2, 1), datetime.date(2005, 3, 1)]
>>> Entry.objects.dates("pub_date", "week")
[datetime.date(2005, 2, 14), datetime.date(2005, 3, 14)]
>>> Entry.objects.dates("pub_date", "day")
[datetime.date(2005, 2, 20), datetime.date(2005, 3, 20)]
>>> Entry.objects.dates("pub_date", "day", order="DESC")
[datetime.date(2005, 3, 20), datetime.date(2005, 2, 20)]
>>> Entry.objects.filter(headline__contains="Lennon").dates("pub_date", "day")
[datetime.date(2005, 3, 20)]

``dáta-amanna () ``Link to this heading

datetimes(field_name, kind, order='ASC', tzinfo=None)Link to this definition

Filleann sé QuerySet a dhéanann meastóireacht ar liosta de:class: datetime.datetime rudaí a léiríonn gach dáta atá ar fáil de chineál áirithe laistigh d'ábhar an QuerySet.

Ba chóir go mbeadh field_name` ainm DateTimefield de do mhúnla.

Ba chóir go mbeadh cineál blian", "míos"`, "seachtaine"`, lá” `, `uair an chloig", nóiméad", nó "seachtaine". Gach duine: Class: datetime.datetime réad sa liosta torthaí “gearrtha” go dtí an cineál a thugtar.

Ba chóir go mbeadh `ASC'` nó ``DESC', ASC', 'ordú ``,' réamhshocraithe '. Sonraíonn sé seo conas na torthaí a ordú.

Sainmhíníonn tzinfo an crios ama ina ndéantar dáta-amanna a thiontú sula ndéantar iad a ghearradh. Go deimhin, tá léirithe difriúla ag dáta ar leith ag brath ar an gcrios ama atá in úsáid. Caithfidh an paraiméadar seo a: aicme: datetime.tzinfo réad. <default-current-time-zone>Más None ``é, úsáideann Django an:ref: `crios ama reatha `. Níl aon éifeacht aige nuair:setting: `USE_TZ` ``False.

``aon cheann () `Link to this heading

none()Link to this definition

Glaoch ar none () ``cruthófar tacar fiosrúcháin nach bhfilleann aon rudaí riamh agus ní fhorghníomhfar aon cheist nuair a rochtain ar na torthaí. Is sampla de ``emptyQuerySet is ea ``qs.none () ``cueryset.

Samplaí:

Python console

>>> Entry.objects.none()
<QuerySet []>
>>> from django.db.models.query import EmptyQuerySet
>>> isinstance(Entry.objects.none(), EmptyQuerySet)
True

``gach () `Link to this heading

all()Link to this definition

Returns a copy of the current QuerySet (or QuerySet subclass). This can be useful in situations where you might want to pass in either a model manager or a QuerySet and do further filtering on the result. After calling all() on either object, you'll definitely have a QuerySet to work with.

<when-querysets-are-evaluated>Nuair a bhíonn QuerySet: ref: meastóireacht `, is gnách go ndéanann sé a thorthaí a chosc. Má d'fhéadfadh go mbeadh athrú ar na sonraí sa bhunachar sonraí ó rinneadh meastóireacht ar ``QuerySet, is féidir leat torthaí nuashonraithe a fháil don cheist céanna trí ghlaoch ar all () ``ar `QuerySet a rinneadh meastóireacht roimhe seo.

``aontas () ``Link to this heading

union(*other_qs, all=False)Link to this definition

Úsáideann oibreoir UNION SQL chun torthaí dhá QuerySet` nó níos mó QuerySets a chomhcheangal. Mar shampla:

Code

>>> qs1.union(qs2, qs3)

Ní roghnaíonn an t-oibreoir UNION ach luachanna ar leith de réir réamhshocraithe. Chun luachanna dúblacha a cheadú, bain úsáid as an argóint all=True.

aontas () ``, `crosbhall (), agus difríocht () ``cásanna samhail ar ais den chineál den chéad ``QuerySet fiú más QuerySet iad na hargóintí QuerySet de mhúnlaí eile. Oibríonn pas samhlacha éagsúla chomh fada agus a bhíonn an liosta SELECT mar an gcéanna i ngach QuerySet (ar a laghad na cineálacha, is cuma na hainmneacha chomh fada agus a bhíonn na cineálacha san ord céanna). I gcásanna den sórt sin, ní mór duit na hainmneacha colún a úsáid ón gcéad QuerySet i modhanna QuerySet a chuirtear i bhfeidhm ar an QuerySet mar thoradh air. Mar shampla:

Python console

>>> qs1 = Author.objects.values_list("name")
>>> qs2 = Entry.objects.values_list("headline")
>>> qs1.union(qs2).order_by("name")

In addition, only LIMIT, OFFSET, COUNT(*), ORDER BY, and specifying columns (i.e. slicing, count(), exists(), order_by(), and values()/values_list()) are allowed on the resulting QuerySet. Further, databases place restrictions on what operations are allowed in the combined queries. For example, most databases don't allow LIMIT or OFFSET in the combined queries.

``trasna () ``Link to this heading

intersection(*other_qs)Link to this definition

Úsáideann oibreoir INTERSECT SQL chun na heilimintí roinnte de dhá QuerySet` nó níos mó QuerySets a thabhairt ar ais. Mar shampla:

Python console

>>> qs1.intersection(qs2, qs3)

Féach: Meth: aont le haghaidh roinnt srianta.

``difríocht () ``Link to this heading

difference(*other_qs)Link to this definition

Úsáideann sé oibreoir EXCEPT SQL chun ach eilimintí a choinneáil i láthair sa QuerySet ach ní i roinnt QuerySet eile. Mar shampla:

Python console

>>> qs1.difference(qs2, qs3)

Féach: Meth: aont le haghaidh roinnt srianta.

``roghnai_bhainteach () ``Link to this heading

select_related(*fields)Link to this definition

Filleann sé QuerySet a leanfaidh caidrimh eachtrach-eachtrach, ag roghnú sonraí breise réad gaolmhara nuair a fhorghníomhaíonn sé a cheist. Is teanndáileog feidhmíochta é seo a mbíonn ceist amháin níos casta mar thoradh air ach ciallaíonn nach mbeidh ceisteanna bunachar sonraí ag teastáil le húsáid níos déanaí caidrimh eachtracha

Léiríonn na samplaí seo a leanas an difríocht idir cuardach simplí agus cuardaigh ``select_related () ``. Seo cuardach caighdeánach:

Code

# Hits the database.
e = Entry.objects.get(id=5)

# Hits the database again to get the related Blog object.
b = e.blog

Agus seo cuardach select_related:

Code

# Hits the database.
e = Entry.objects.select_related("blog").get(id=5)

# Doesn't hit the database, because e.blog has been prepopulated
# in the previous query.
b = e.blog

Is féidir leat ``select_related () ``a úsáid le haon tacar ceisteanna rudaí:

Code

from django.utils import timezone

# Find all the blogs with entries scheduled to be published in the future.
blogs = set()

for e in Entry.objects.filter(pub_date__gt=timezone.now()).select_related("blog"):
    # Without select_related(), this would make a database query for each
    # loop iteration in order to fetch the related blog for each entry.
    blogs.add(e.blog)

Níl an t-ord a bhaineann le slabhraíocht filter () ``agus ``select_related () tábhachtach. Tá na ceisteanna ceisteanna seo coibhéiseach:

Code

Entry.objects.filter(pub_date__gt=timezone.now()).select_related("blog")
Entry.objects.select_related("blog").filter(pub_date__gt=timezone.now())

Is féidir leat eochracha eachtracha a leanúint ar bhealach cosúil leo a cheistiú. Má tá na samhlacha seo a leanas agat:

Code

from django.db import models


class City(models.Model):
    # ...
    pass


class Person(models.Model):
    # ...
    hometown = models.ForeignKey(
        City,
        on_delete=models.SET_NULL,
        blank=True,
        null=True,
    )


class Book(models.Model):
    # ...
    author = models.ForeignKey(Person, on_delete=models.CASCADE)

Then a call to Book.objects.select_related('author__hometown').get(id=4) will cache the related Person and the related City:

Code

# Hits the database with joins to the author and hometown tables.
b = Book.objects.select_related("author__hometown").get(id=4)
p = b.author  # Doesn't hit the database.
c = p.hometown  # Doesn't hit the database.

# Without select_related()...
b = Book.objects.get(id=4)  # Hits the database.
p = b.author  # Hits the database.
c = p.hometown  # Hits the database.

Is féidir leat tagairt a dhéanamh d'aon ghaol:class: ~django.db.models.foreignKey nó:class: ~django.db.models.onetoonefield sa liosta réimsí a chuirtear chuig ``select_related () ``.

Is féidir leat tagairt a dhéanamh freisin do threo droim a:class: ~django.db.models.onetoonefield sa liosta réimsí a chuirtear chuig select_related - is é sin, is féidir leat a:class: ~django.db.models.onetoonefield a thrasnú ar ais go dtí an réad ar a sainmhínítear an réimse. In ionad ainm an réimse a shonrú, bain úsáid as an:attr: `related_name <django.db.models.ForeignKey.related_name>`don réimse ar an réad gaolmhar.

D'fhéadfadh go mbeadh roinnt cásanna ann inar mian leat glaoch ar ``select_related () ``le go leor rudaí gaolmhara, nó nuair nach bhfuil a fhios agat na caidrimh go léir. Sna cásanna seo is féidir glaoch ar ``select_related () ``gan aon argóintí. Leanfaidh sé seo gach eochracha eachtracha neamh-neamh-niall is féidir leis a fháil - caithfear eochracha eachtracha in-neamhnaithe a Ní mholtar é seo i bhformhór na gcásanna mar is dócha go ndéanfaidh sé an ceist bhunúsach níos casta, agus níos mó sonraí a thabhairt ar ais, ná mar a theastaíonn i ndáiríre.

Más gá duit an liosta réimsí gaolmhara a chuir leis na glaonna roimhe seo de select_related` a ghlanadh ar QuerySet, is féidir leat None a rith mar pharaiméadar:

Python console

>>> without_relations = queryset.select_related(None)

Oibríonn glaonna select_related a shlánú ar bhealach cosúil le modhanna eile - is é sin go bhfuil select_related ('foo', 'bar') ``comhionann le ``select_related ('foo') .select_related ('bar').

``prefetch_related () ``Link to this heading

prefetch_related(*lookups)Link to this definition

Tugann “QuerySet” ar ais a aisghabhann rudaí gaolmhara go huathoibríoch, i mbaisc amháin, do gach ceann de na cuardaigh sonraithe.

Tá cuspóir comhchosúil aige seo le select_related, sa mhéid go bhfuil an dá cheann deartha chun stop a chur le tuilleadh ceisteanna bunachar sonraí is cúis le rochtain a fháil ar rudaí gaolmhara, ach tá an straitéis an-difriúil.

Oibríonn select_related trí chomhcheangal SQL a chruthú agus réimsí an réada gaolmhara a áireamh sa ráiteas SELECT. Ar an gcúis seo, faigheann select_related na rudaí gaolmhara san fhiosrúchán bunachar sonraí céanna. Mar sin féin, chun an tacar torthaí i bhfad níos mó a bheadh as dul isteach i rith caidreamh 'go leor' a sheachaint, tá select_related teoranta do chaidrimh aonluach - eochair eachtrach agus duine le duine.

Ar an láimh eile, déanann prefetch_related cuardach ar leithligh do gach caidreamh, agus déanann sé an 'ceangal' i Python. Ligeann sé seo dó rudaí go leor, go leor, agus:class: ~django.contrib.contentTypes.Fields.GenericRelation nach féidir a dhéanamh ag baint úsáide as select_related`, chomh maith leis na caidrimh eochair eachtracha agus duine le duine a thacaíonn le select_related`. Tacaíonn sé freisin le réamhghabháil o:class: ~django.contrib.contentTypes.fields.GenericForeignKey, áfach, ní mór an tacar ceisteanna do gach ContentType` a sholáthar sa pharaiméadar querysets de:class: ~django.contrib.contentTypes.prefetch.GenericPrefetch.

Mar shampla, cuir i gcás go bhfuil na samhlacha seo agat:

Code

from django.db import models


class Topping(models.Model):
    name = models.CharField(max_length=30)


class Pizza(models.Model):
    name = models.CharField(max_length=50)
    toppings = models.ManyToManyField(Topping)

    def __str__(self):
        return "%s (%s)" % (
            self.name,
            ", ".join(topping.name for topping in self.toppings.all()),
        )

agus rith:

Python console

>>> Pizza.objects.all()
<QuerySet [<Pizza: Hawaiian (ham, pineapple)>, <Pizza: Seafood (prawns, smoked salmon)>, ...]>

Is í an fhadhb leis seo ná gach uair Pizza. Iarrann __str__ () ````self.toppings.all () caithfidh sé an bunachar sonraí a cheistiú, mar sin reáchtálfaidh Pizza.Objects.all () `ceist ar an tábla Toppings le haghaidh **gach ear** sa Pizza ``QuerySet.

Is féidir linn laghdú go dtí dhá cheist ag baint úsáide as prefetch_related:

Python console

>>> Pizza.objects.prefetch_related("toppings")

Tugann sé seo le tuiscint go bhfuil self.toppings.all () ``do gach `Pizza`; anois gach uair a thugtar self.toppings.all (), in ionad dul chuig an mbunachar sonraí do na míreanna, gheobhaidh sé iad i taisce QuerySet réamhfhaighte a rinneadh i gceist amháin.

That is, all the relevant toppings will have been fetched in a single query, and used to make QuerySet instances that have a pre-filled cache of the relevant results; these are then used in the self.toppings.all() calls.

Déantar na ceisteanna breise i prefetch_related () ``a fhorghníomhú tar éis an ``QuerySet` a mheas agus an cheist phríomhúil a fhorghníomhú.

Tabhair faoi deara nach bhfuil aon mheicníocht ann chun ceist eile bunachar sonraí a chosc ó na míreanna a athrú idir forghníomhú na ceisteanna príomhúil agus na ceisteanna breise, a d'fhéadfadh toradh neamhchomhsheasmhach a bheith mar thoradh air. Mar shampla, má scriostar ``Pizza ``tar éis don cheist phríomhúil a fhorghníomhú, ní thabharfar a bholtaí ar ais sa cheist bhreise, agus is cosúil nach bhfuil aon fhorais ag an pizza:

Python console

>>> Pizza.objects.prefetch_related("toppings")
#  "Hawaiian" Pizza was deleted in another shell.
<QuerySet [<Pizza: Hawaiian ()>, <Pizza: Seafood (prawns, smoked salmon)>]>

Má tá cásanna samhail in-athraithe agat, is féidir leat tréithe gaolmhara a réamh-fháil ar na cásanna sin ag baint úsáide as an bhfeidhm:func: ~django.db.models.prefetch_related_objects.

Note that the result cache of the primary QuerySet and all specified related objects will then be fully loaded into memory. This changes the typical behavior of a QuerySet, which normally tries to avoid loading all objects into memory before they are needed, even after a query has been executed in the database.

Note

Remember that, as always with QuerySet objects, any subsequent chained methods which imply a different database query will ignore previously cached results, and retrieve data using a fresh database query. So, if you write the following:

Python console

>>> pizzas = Pizza.objects.prefetch_related("toppings")
>>> [list(pizza.toppings.filter(spicy=True)) for pizza in pizzas]

... ansin ní chabhróidh an fíric go bhfuil pizza.toppings.all () ``réamhfhaighte leat. Chuir an ``prefetch_related ('toppings') ``intuigthe ``pizza.toppings.all ()`, ach is ceist nua difriúil é ``pizza.toppings.filter () ``. Ní féidir leis an taisce réamhghabháilte cabhrú anseo; i ndáiríre gortaíonn sé feidhmíocht, ós rud é go bhfuil ceist bunachar sonraí déanta agat nár úsáideann tú. Mar sin bain úsáid as an ngné seo le cúramach!

<django.db.models.fields.related.RelatedManager>Chomh maith leis sin, má ghlaonn tú ar na modhanna athraithe bunachar sonraí: meth: ~Django.db.Models.Fields.Related.RelatedManager.add, :meth: ~Django.db.Models.Fields.Related.RelatedManager.Create, :meth: ~Django.db.Models.Fields.related.Manager.remove, :h: ~Django.db.Models.Fields.Related.RelatedManager.Clear nó: meth: ~Django.db.Models.Fields.Related.RelatedManager.Set, ar:class: `bhainisteoirí gaolmhara `, glanfar aon taisce réamhghabháilte don ghaol.

Is féidir leat an gnáthchomhréireacht a úsáid freisin chun réimsí gaolmhara de réimsí gaolmhara a dhéanamh. Cuir i gcás go bhfuil samhail bhreise againn leis an sampla thuas:

Code

class Restaurant(models.Model):
    pizzas = models.ManyToManyField(Pizza, related_name="restaurants")
    best_pizza = models.ForeignKey(
        Pizza, related_name="championed_by", on_delete=models.CASCADE
    )

Tá na nithe seo a leanas ar fad dlíthiúil:

Python console

>>> Restaurant.objects.prefetch_related("pizzas__toppings")

Tabharfaidh sé seo gach píosa a bhaineann le bialanna, agus gach topping a bhaineann leis na pizzí sin a réamh-aimsiú. Beidh 3 cheist bunachar sonraí san iomlán mar thoradh air seo - ceann do na bialanna, ceann do na pizzes, agus ceann do na toppings.

Python console

>>> Restaurant.objects.prefetch_related("best_pizza__toppings")

Tabharfaidh sé seo an pizza is fearr agus na toppings go léir don pizza is fearr do gach bialann. Déanfar é seo i 3 cheist bunachar sonraí - ceann do na bialanna, ceann do na 'pizzes is fearr ', agus ceann do na toppings.

D'fhéadfaí an caidreamh best_pizza ``a fháil freisin ag baint úsáide as ``select_related chun líon na fiosrúcháin a laghdú go 2:

Python console

>>> Restaurant.objects.select_related("best_pizza").prefetch_related("best_pizza__toppings")

Ós rud é go ndéantar an réamhcheistiú a fhorghníomhú tar éis na príomhiosrúcháin (lena n-áirítear na comhcheangail a theastaíonn ag select_related), tá sé in ann a bhrath go bhfuil na rudaí `best_pizza ``faighte cheana féin, agus scipeoidh sé iad a fháil arís.

Carnóidh glaonna prefetch_related a shlánú na cuardaigh atá réamhfhaighte. Chun aon iompar prefetch_related a ghlanadh, pas None mar pharaiméadar:

Python console

>>> non_prefetched = qs.prefetch_related(None)

Difríocht amháin le tabhairt faoi deara agus prefetch_related á úsáid ná gur féidir rudaí a chruthaítear le ceist a roinnt idir na rudaí éagsúla a bhfuil baint acu leo i.e. is féidir le samhail Python amháin a bheith le feiceáil ag níos mó ná pointe amháin sa chrann na rudaí a chuirtear ar ais. De ghnáth tarlóidh sé seo le príomhchaidrimh eachtracha. De ghnáth ní bheidh an t-iompar seo ina fhadhb, agus sábhálfaidh sé am cuimhne agus LAP araon i ndáiríre.

Cé go dtacaíonn prefetch_related le caidrimh GenericForeignKey réamhghabháilte, beidh líon na gceisteanna ag brath ar na sonraí. Ós rud é gur féidir le GenericForeignKey sonraí a thagairt i dtáblaí iolracha, teastaíonn ceist amháin in aghaidh an tábla dá dtagraítear, seachas ceist amháin do na míreanna go léir. D'fhéadfadh ceisteanna breise a bheith ann ar an tábla ContentType mura bhfuil na sraitheanna ábhartha faighte cheana féin.

Cuirfear prefetch_related i bhformhór na gcásanna i bhfeidhm ag baint úsáide as ceist SQL a úsáideann an oibreoir 'IN'. Ciallaíonn sé seo go bhféadfaí clásal mór 'IN' a ghiniúint do `QuerySet ``mór, a d'fhéadfadh fadhbanna feidhmíochta féin a bheith aige, ag brath ar an mbunachar sonraí, maidir le parsáil nó a fhorghníomhú an fhiosrúcháin SQL. Próifíl i gcónaí do do chás úsáide!

Má úsáideann tú iterator () ``chun an cheist a reáchtáil, ní bhreathnófar glaonna ``prefetch_related () ach amháin má chuirtear luach ar fáil do chunk_size`.

Is féidir leat an réad:class: ~django.db.models.prefetch a úsáid chun an oibríocht réamhfhreastalaí a rialú tuilleadh.

Sa fhoirm is simplí tá Prefetch` comhionann leis na cuardaigh thraidisiúnta bunaithe ar shreang:

Python console

>>> from django.db.models import Prefetch
>>> Restaurant.objects.prefetch_related(Prefetch("pizzas__toppings"))

Is féidir leat tacar ceisteanna saincheaptha a sholáthar leis an argóint roghnach ``queryset ``. Is féidir é seo a úsáid chun ordú réamhshocraithe an tacar fiosrúcháin a athrú:

Python console

>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas__toppings", queryset=Toppings.objects.order_by("name"))
... )

Or to call select_related() when applicable to reduce the number of queries even further:

Python console

>>> Pizza.objects.prefetch_related(
...     Prefetch("restaurants", queryset=Restaurant.objects.select_related("best_pizza"))
... )

Is féidir leat an toradh réamhfhaighte a shannadh freisin do thréith saincheaptha leis an argóint roghnach ``to_attr`. Stórálfar an toradh go díreach i liosta.

Ligeann sé seo an gaol céanna a réamhghabháil arís agus arís eile le QuerySet difriúil; mar shampla:

Python console

>>> vegetarian_pizzas = Pizza.objects.filter(vegetarian=True)
>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas", to_attr="menu"),
...     Prefetch("pizzas", queryset=vegetarian_pizzas, to_attr="vegetarian_menu"),
... )

Is féidir cuardaigh eile a chruthaítear le to_attr` saincheaptha a thrasnú mar is gnách:

Python console

>>> vegetarian_pizzas = Pizza.objects.filter(vegetarian=True)
>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas", queryset=vegetarian_pizzas, to_attr="vegetarian_menu"),
...     "vegetarian_menu__toppings",
... )

Moltar ``to_attr` a úsáid agus an toradh réamhfhaighte á scagadh síos toisc nach bhfuil sé chomh débhríoch ná toradh scagtha a stóráil i taisce an bhainisteora gaolmhar:

Python console

>>> queryset = Pizza.objects.filter(vegetarian=True)
>>>
>>> # Recommended:
>>> restaurants = Restaurant.objects.prefetch_related(
...     Prefetch("pizzas", queryset=queryset, to_attr="vegetarian_pizzas")
... )
>>> vegetarian_pizzas = restaurants[0].vegetarian_pizzas
>>>
>>> # Not recommended:
>>> restaurants = Restaurant.objects.prefetch_related(
...     Prefetch("pizzas", queryset=queryset),
... )
>>> vegetarian_pizzas = restaurants[0].pizzas.all()

Custom prefetching also works with single related relations like forward ForeignKey or OneToOneField. Generally you'll want to use select_related() for these relations, but there are a number of cases where prefetching with a custom QuerySet is useful:

Ba mhaith leat QuerySet a úsáid a dhéanann tuilleadh réamhghabhála ar mhúnlaí gaolmhara.
Ní theastaíonn uait ach fo-thacar de na rudaí gaolmhara a réamh-fháil.

<defer () >Ba mhaith leat teicnící optamaithe feidhmíochta a úsáid mar: meth: `réimsí iarchurtha `:

Python console

>>> queryset = Pizza.objects.only("name")
>>>
>>> restaurants = Restaurant.objects.prefetch_related(
...     Prefetch("best_pizza", queryset=queryset)
... )

Agus bunachair sonraí iolracha á úsáid agat, beidh meas ag Prefetch do rogha bunachar sonraí. Mura sonraíonn an cheist istigh bunachar sonraí, úsáidfidh sé an bunachar sonraí a roghnaíonn an cheist seachtrach. Tá gach ceann de na nithe seo a leanas bailí:

Python console

>>> # Both inner and outer queries will use the 'replica' database
>>> Restaurant.objects.prefetch_related("pizzas__toppings").using("replica")
>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas__toppings"),
... ).using("replica")
>>>
>>> # Inner will use the 'replica' database; outer will use 'default' database
>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas__toppings", queryset=Toppings.objects.using("replica")),
... )
>>>
>>> # Inner will use 'replica' database; outer will use 'cold-storage' database
>>> Restaurant.objects.prefetch_related(
...     Prefetch("pizzas__toppings", queryset=Toppings.objects.using("replica")),
... ).using("cold-storage")

Note

Tá tábhacht ag ordú cuardaigh.

Tóg na samplaí seo a leanas:

Python console

>>> prefetch_related("pizzas__toppings", "pizzas")

Oibríonn sé seo cé go bhfuil sé neamh-ordaithe toisc go bhfuil an fhaisnéis uile riachtanach ann cheana féin sa ``pizzas__toppings', dá bhrí sin tá an dara argóint `'pizzas'` iomarcach i ndáiríre.

Python console

>>> prefetch_related("pizzas__toppings", Prefetch("pizzas", queryset=Pizza.objects.all()))

Ardóidh sé seo Error lua mar gheall ar an iarracht tacar fiosrúcháin a chonacthas roimhe seo a athshainiú. Tabhair faoi deara gur cruthaíodh tacar ceisteanna intuigthe chun ``'pizzas'` a thrasnú mar chuid den chuardach ``pizzas__toppings'.

Python console

>>> prefetch_related("pizza_list__toppings", Prefetch("pizzas", to_attr="pizza_list"))

Spreagfaidh sé seo AttributeError toisc nach bhfuil pizza_list' ann fós nuair a bhíonn ``pizza_list__toppings'` á phróiseáil.

Níl an breithniú seo teoranta d'úsáid rudaí Prefetch. D'fhéadfadh go n-éilíonn roinnt ardteicnící go ndéanfaí na cuardaigh in ord sonrach chun ceisteanna breise a chruthú a sheachaint; dá bhrí sin moltar argóintí ``prefetch_related` a ordú go cúramach i gcónaí.

``breise () ``Link to this heading

extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)Link to this definition

Uaireanta, ní féidir le comhréiteach ceisteanna Django leis féin clásal casta WHERE a chur in iúl go héasca. Maidir leis na cásanna imeall seo, soláthraíonn Django an modhnóir ``extra () ``QuerySet - crúca chun clásail shonracha a instealladh isteach sa SQL a ghineann ``QuerySet`.

Úsáid an modh seo mar rogha dheireanach

This is an old API that we aim to deprecate at some point in the future. Use it only if you cannot express your query using other queryset methods. If you do need to use it, please file a ticket using the QuerySet.extra keyword with your use case (please check the list of existing tickets first) so that we can enhance the QuerySet API to allow removing extra(). We are no longer improving or fixing bugs for this method.

Mar shampla, an úsáid seo de ``extra () ``:

Python console

>>> qs.extra(
...     select={"val": "select col from sometable where othercol = %s"},
...     select_params=(someparam,),
... )

atá coibhéiseach le:

Python console

>>> qs.annotate(val=RawSQL("select col from sometable where othercol = %s", (someparam,)))

Is é an príomhbhuntáiste a bhaineann le húsáid:class: ~django.db.models.expressions.rawsql ná gur féidir leat output_field` a shocrú más gá. Is é an príomh-mhíbhuntáiste ná má thagraíonn tú d'ainm tábla éigin den tacar fiosrúcháin sa SQL amh, is féidir go bhféadfadh Django an t-ainm sin a athrú (mar shampla, nuair a úsáidtear an tacar fiosrúcháin mar fho-cheist i bhfiosrúchán eile fós).

Warning

Ba chóir duit a bheith an-chúramach aon uair a úsáideann tú ``extra () ``. Gach uair a úsáideann tú é, ba cheart duit éalú ar aon pharaiméadair is féidir leis an úsáideoir a rialú trí `params' a úsáid chun cosaint a dhéanamh ar ionsaithe insteallta SQL.

Ní mór duit sealbhóirí áiteanna a lua sa teaghrán SQL freisin. Tá an sampla seo leochaileach do instealladh SQL mar gheall ar na luachana timpeall %s:

SQL

SELECT col FROM sometable WHERE othercol = '%s'  # unsafe!

<sql-injection-protection>Is féidir leat tuilleadh a léamh faoin gcaoi a n-oibríonn Django's:ref: `Cosaint insteallta SQL `.

De réir sainmhínithe, b'fhéidir nach mbeidh na cuardaigh bhreise seo iniompartha d'innill bhunachar sonraí éagsúla (toisc go bhfuil cód SQL á scríobh go sainráite agat) agus sáraíonn tú prionsabal DRY, mar sin ba cheart duit iad a sheachaint

Sonraigh ceann amháin nó níos mó de params, roghnaithe`, cá háit ``nó ``tábla. Níl aon cheann de na hargóintí ag teastáil, ach ba cheart duit ceann acu ar a laghad a úsáid.

roghnaithe

The select argument lets you put extra fields in the SELECT clause. It should be a dictionary mapping attribute names to SQL clauses to use to calculate that attribute.

Sampla:
Code
```
Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})
```
Mar thoradh air sin, beidh tréith bhreise ag gach réad Entry', ``is_recent, boolean a léiríonn an bhfuil `pub_date ``an iontráil níos mó ná 1 Eanáir, 2006.

Cuireann Django an snippet SQL a thugtar isteach go díreach sa ráiteas SELECT, mar sin bheadh an SQL mar thoradh air den sampla thuas rud éigin mar:
SQL
```
SELECT blog_entry.*, (pub_date > '2006-01-01') AS is_recent
FROM blog_entry;
```
Tá an chéad sampla eile níos airde; déanann sé fo-cheist chun tréith entry_count` a thabhairt do gach réad `Blog mar thoradh air, comhaireamh sláimhir na rudaí Iontrála gaolmhara:
Code
```
Blog.objects.extra(
    select={
        "entry_count": "SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id"
    },
)
```
Sa chás áirithe seo, táimid ag leas as an bhfíric go mbeidh an tábla blog_blog sa chlásal FROM sa cheist cheana féin.

Is é an SQL mar thoradh air den sampla thuas ná:
SQL
```
SELECT blog_blog.*, (SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id) AS entry_count
FROM blog_blog;
```
Tabhair faoi deara nach bhfuil na lúibíní a éilíonn mórchuid na n-innill bunachar sonraí timpeall fo-cheisteanna ag teastáil i gclásail “roghnaigh” Django.

I roinnt cásanna neamhchoitianta, b'fhéidir gur mhaith leat paraiméadair a chur chuig na blúirí SQL i extra (roghnaigh =...) ``. Chun na críche seo, bain úsáid as an paraiméadar ``select_params.

Oibreoidh sé seo, mar shampla:
Code
```
Blog.objects.extra(
    select={"a": "%s", "b": "%s"},
    select_params=("one", "two"),
)
```
Más gá duit %s litriúil a úsáid taobh istigh de do shreang roghnaithe, bain úsáid as an seicheamh %%s.
`cá háit ``/``tábla

Is féidir leat clásail WHERE SQL sainráite a shainiú - b'fhéidir chun comhpháirteanna neamh-shoiléire a dhéanamh - trí `a úsáid`. Is féidir leat táblaí a chur de láimh leis an gclásal SQL FROM trí `táblaí ``a úsáid.

Glacann ````agus ``tábla liosta teaghráin araon. Tá na paraiméadair ````go léir “agus” déanta d'aon chritéir chuardaigh eile.

Sampla:
Code
```
Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
```
... aistríonn (go garbh) go dtí an SQL seo a leanas:
SQL
```
SELECT * FROM blog_entry WHERE (foo='a' OR bar='a') AND (baz='a')
```
Bí cúramach agus an paraiméadar ``táblaí ``á úsáid agat má tá táblaí á shonrú agat a úsáidtear cheana féin sa cheist. Nuair a chuireann tú táblaí breise tríd an bparaiméadar ``táblaí ``, glacann Django leis gur mhaith leat am breise a bheith san áireamh sa tábla sin, má tá sé san áireamh cheana féin. Cruthaíonn sé sin fadhb, ós rud é go dtabharfar ainm an tábla ansin. Má tá tábla le feiceáil arís agus arís i ráiteas SQL, ní mór don dara tarlú agus ina dhiaidh sin ainmneacha a úsáid ionas gur féidir leis an mbunachar sonraí iad a insint óna chéile. Má tá tú ag tagairt don tábla breise a chuir tú sa pharaiméadar breise ``cén áit ``beidh earráidí mar thoradh air seo.

De ghnáth ní bheidh tú ag cur ach táblaí breise nach bhfuil le feiceáil sa cheist cheana féin. Mar sin féin, má tharlaíonn an cás a leagtar amach thuas, tá cúpla réiteach ann. Ar dtús, féach an féidir leat dul tríd gan an tábla breise a áireamh agus bain úsáid as an gceann atá sa cheist cheana féin. Mura féidir é sin a dhéanamh, cuir do ghlao ``breise () ``ag tosaigh an tógála tacar fiosraithe ionas gurb é do thábla an chéad úsáid den tábla sin. Faoi dheireadh, má theipeann ar gach rud eile, féach ar an bhfiosrú a tháirgtear agus athscríobh do bhreise ``cá háit ``chun an alias a thugtar do do thábla breise a úsáid. Beidh an t-ailias mar an gcéanna gach uair a thógann tú an tacar fiosrúcháin ar an mbealach céanna, ionas gur féidir leat brath ar an ainm alias gan athrú.
ordó_by

If you need to order the resulting queryset using some of the new fields or tables you have included via extra() use the order_by parameter to extra() and pass in a sequence of strings. These strings should either be model fields (as in the normal order_by() method on querysets), of the form table_name.column_name or an alias for a column that you specified in the select parameter to extra().

Mar shampla:
Code
```
q = Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})
q = q.extra(order_by=["-is_recent"])
```
Sórtálfadh sé seo na míreanna go léir a bhfuil is_recent díreach maidir le tosaigh an tacar torthaí (True sórtálacha roimh False in ordú íslitheach).

Taispeánann sé seo, dála an scéil, gur féidir leat glaonna iolracha a dhéanamh chuig ``extra () ``agus iompróidh sé mar a bhíonn ag súil leat (srianta nua a chur leis gach uair).
Params

Féadfaidh an paraiméadar `a thuairiscítear thuas sealbhóirí teaghrán bunachar sonraí caighdeánach Python a úsáid - ```%s' chun paraiméadair a léiriú ba chóir don inneall bunachar sonraí a lua go huath Is é an argóint `params' ná liosta d'aon pharaiméadair bhreise atá le cur in ionad.

Sampla:
Code
```
Entry.objects.extra(where=["headline=%s"], params=["Lennon"])
```
Úsáid params` i gcónaí in ionad luachanna a leabú go díreach isteach i cén áit ``toisc go gcinnteoidh `params luachanna i gceart de réir do chúltaca áirithe. Mar shampla, éalófar luachana i gceart.

Droch:
Code
```
Entry.objects.extra(where=["headline='Lennon'"])
```
Go maith:
Code
```
Entry.objects.extra(where=["headline=%s"], params=["Lennon"])
```

``iarchur () `Link to this heading

defer(*fields)Link to this definition

I roinnt cásanna casta samhaltú sonraí, d'fhéadfadh go mbeadh go leor réimsí i do mhúnlaí, a bhféadfadh go leor sonraí a bheith i gcuid acu (mar shampla, réimsí téacs), nó próiseáil daor a bheith ag teastáil chun iad a thiontú go rudaí Python. Má tá torthaí tacar fiosrúcháin á úsáid agat i gcás éigin nach bhfuil a fhios agat an dteastaíonn na réimsí áirithe sin uait nuair a fhaigheann tú na sonraí ar dtús, is féidir leat a rá le Django gan iad a aisghabháil ón mbunachar sonraí.

Déantar é seo trí ainmneacha na réimsí a chur ar aghaidh chun gan luchtú chuig ``defer () ``:

Code

Entry.objects.defer("headline", "body")

Tabharfaidh tacar fiosrúcháin a bhfuil réimsí iarchurtha aige cásanna samhail ar ais fós. Aisghabfar gach réimse iarchurtha ón mbunachar sonraí má rochtain agat ar an réimse sin (ceann ag an am, ní na réimsí iarchurtha go léir ag an am céanna).

Is féidir leat glaonna iolracha a dhéanamh chuig ``fiafraigh () ``. Cuireann gach glao réimsí nua leis an tacar iarchurtha:

Code

# Defers both the body and headline fields.
Entry.objects.defer("body").filter(rating=5).defer("headline")

Is cuma an t-ord ina gcuirtear réimsí leis an tacar iarchurtha. Tá sé neamhdhíobhálach a ghlaoch ar ``déanamh () ``le hainm réimse atá curtha ar iarchur cheana féin (cuirfear an réimse ar iarchur fós).

You can defer loading of fields in related models (if the related models are loading via select_related()) by using the standard double-underscore notation to separate related fields:

Code

Blog.objects.select_related().defer("entry__headline", "entry__body")

Más mian leat an tacar réimsí iarchurtha a ghlanadh, cuir None mar pharaiméadar chuig ``defer () ``:

Code

# Load all fields immediately.
my_queryset.defer(None)

Some fields in a model won't be deferred, even if you ask for them. You can never defer the loading of the primary key. If you are using select_related() to retrieve related models, you shouldn't defer the loading of the field that connects from the primary model to the related one, doing so will result in an error.

Similarly, calling defer() (or its counterpart only()) including an argument from an aggregation (e.g. using the result of annotate()) doesn't make sense: doing so will raise an exception. The aggregated values will always be fetched into the resulting queryset.

Note

The defer() method (and its cousin, only(), below) are only for advanced use-cases. They provide an optimization for when you have analyzed your queries closely and understand exactly what information you need and have measured that the difference between returning the fields you need and the full set of fields for the model will be significant.

Fiú má cheapann tú go bhfuil tú sa chás ardchás úsáide, ** húsáid ach ** fiafraigh () ``**nuair nach féidir leat, ag am luchtaithe ceisteanna socraithe, a chinneadh an mbeidh na réimsí breise ag teastáil uait nó ní**. Má tá fo-thacar áirithe de do shonraí á luchtú agus ag úsáid tú go minic, is é an rogha is fearr is féidir leat a dhéanamh ná do mhúnlaí a normalú agus na sonraí neamh-luchtaithe a chur i samhail ar leithligh (agus tábla bunachar sonraí). Má chaithfidh na colúin ** fanacht sa tábla amháin ar chúis éigin, cruthaigh samhail <django.db.models.Options.managed>le `Meta.managed = False (féach an doiciméadach:attr: treit bhainistithe `) ina bhfuil ach na réimsí a chaithfidh tú a luchtú agus bain úsáid as sin ina bhféadfá ``defer () a ghlaoch ar shlí eile. Déanann sé seo do chód níos soiléire don léitheoir, tá sé beagán níos gasta agus ídíonn sé beagán níos lú cuimhne sa phróiseas Python.

Mar shampla, úsáideann an dá mhúnla seo an tábla bunachar sonraí céanna:

Code

class CommonlyUsedModel(models.Model):
    f1 = models.CharField(max_length=10)

    class Meta:
        managed = False
        db_table = "app_largetable"


class ManagedModel(models.Model):
    f1 = models.CharField(max_length=10)
    f2 = models.CharField(max_length=10)

    class Meta:
        db_table = "app_largetable"


# Two equivalent QuerySets:
CommonlyUsedModel.objects.all()
ManagedModel.objects.defer("f2")

Más gá go leor réimsí a dhúbailt sa tsamhail neamh-bhainistithe, b'fhéidir gur fearr samhail teibí a chruthú leis na réimsí roinnte agus ansin na samhlacha neamh-bhainistithe agus bainistithe a bheith oidhreachta ón tsamhail teibí.

``amháin () `Link to this heading

only(*fields)Link to this definition

Go bunúsach is é an modh ``only () ``a mhalairt de:meth: iarchur. Ní dhéantar ach na réimsí a chuirtear isteach sa mhodh seo agus nach nd* atá sonraithe cheana féin mar iarchurtha a luchtú láithreach nuair a dhéantar an tacar fiosrúcháin a mheas.

Má tá samhail agat ina gcaithfear beagnach na réimsí go léir a chur siar, d'fhéadfadh cód níos simplí a bheith mar thoradh ar ``only () ``chun an tacar chomhlántach réimsí a shonrú.

Cuir i gcás go bhfuil samhail agat le réimsí ainm ``, `aois agus beathaisnéis. Tá an dá cheist seo a leanas mar an gcéanna, i dtéarmaí réimsí iarchurtha:

Code

Person.objects.defer("age", "biography")
Person.objects.only("name")

Aon uair a ghlaonn tú ar ``only () ``, ath* aith* an tacar réimsí le luchtú láithreach. Is é ainm an mhodha mnemonic: amháin luchtaítear na réimsí sin láithreach; cuirtear an chuid eile ar iarchur. Mar sin, ní bhreithnítear ach na réimsí deiridh ar na réimsí deiridh mar thoradh ar ghlaonna i ndiaidh a chéile ar ``only () `:

Code

# This will defer all fields except the headline.
Entry.objects.only("body", "rating").only("headline")

Ós rud é go ngníomhaíonn diafraigh () ``go hincneamhach (réimsí a chur leis an liosta iarchurtha), is féidir leat glaonna a chur le ``only () agus ``deafer () ``a chomhcheangal agus iompraíonn rudaí go loighciúil:

Code

# Final result is that everything except "headline" is deferred.
Entry.objects.only("headline", "body").defer("body")

# Final result loads headline immediately.
Entry.objects.defer("body").only("headline", "body")

Baineann na rabhaidh go léir sa nóta maidir leis an doiciméadúisíocht: “athchur” le ``only () `chomh maith. Úsáid é go cúramach agus ach amháin tar éis do roghanna eile a ídiú.

Is earráid é ``only () ``a úsáid agus réimse a iarrtar a fhágáil ag baint úsáid:meth: select_related freisin. Ar an láimh eile, cuirfear glaoch ar ``only () ``gan aon argóintí, gach réimse (lena n-áirítear anótaí) a gheobhaidh an tacar fiosrúcháin ar ais.

Mar is amhlaidh le defer () ``, ní féidir leat rochtain a fháil ar na réimsí neamh-luchtaithe ó chód asincrónach agus a bheith ag súil go luchtálfaidh siad. Ina áit sin, gheobhaidh tú eisceacht ``SynchronousOnlyOperation. Déan cinnte go bhfuil gach réimse a d'fhéadfá rochtain a fháil i do ghlao ``only () ``.

``ag baint úsáide as () `Link to this heading

using(alias)Link to this definition

This method is for controlling which database the QuerySet will be evaluated against if you are using more than one database. The only argument this method takes is the alias of a database, as defined in DATABASES.

Mar shampla:

Python console

# queries the database with the 'default' alias.
>>> Entry.objects.all()

# queries the database with the 'backup' alias
>>> Entry.objects.using("backup")

``roghnaithe_for_nuashonraithe () ``Link to this heading

select_for_update(nowait=False, skip_locked=False, of=(), no_key=False)Link to this definition

Tugann sé tacar ceisteanna ar ais a ghlasálfaidh sraitheanna go dtí deireadh an idirbheart, ag gint ROGHNAIGH... LE HAGHAIDH UPDATE Ráiteas SQL ar bhunachair sonraí tacaithe.

Mar shampla:

Code

from django.db import transaction

entries = Entry.objects.select_for_update().filter(author=request.user)
with transaction.atomic():
    for entry in entries:
        ...

Nuair a dhéantar an tacar fiosrúcháin a mheas (``le haghaidh iontrála in iontrálacha ``sa chás seo), cuirfear gach iontráil comhoiriúnach faoi ghlas go dtí deireadh an bhloc idirbheart, rud a chiallaíonn go gcuirfear cosc ar idirbhearta eile glais a athrú nó a fháil orthu.

De ghnáth, má tá glas faighte ag idirbheart eile cheana féin ar cheann de na sraitheanna roghnaithe, cuirfidh an ceist bac go dtí go scaoilfear an glas. Mura bhfuil sé seo an t-iompar atá uait, glaoigh ar select_for_update (noWait=true) ``. Déanfaidh sé seo an glao gan bhlocáil. Má fhaightear glas contrártha cheana féin le hidirbheart eile, ardófar :exc: `~django.db.databaseError` nuair a dhéantar an tacar fiosrúcháin a mheas. Is féidir leat neamhaird a dhéanamh freisin ar shraitheanna faoi ghlas trí ``select_for_update (skip_locked=True) ``a úsáid ina ionad. Tá na `nowait agus skip_locked frithpháirteach agus beidh a: exc: ValueError mar thoradh ar iarrachtaí glaoch ar ``select_for_update () ``agus an dá rogha cumasaithe.

De réir réamhshocraithe, glasaíonn select_for_update () ``gach sraitheanna a roghnaíonn an cheist. Mar shampla, tá sraitheanna rudaí gaolmhara a shonraítear in:meth: `select_related` faoi ghlas i dteannta sraitheanna de mhúnla an tacar fiosrúcháin. Mura bhfuil sé seo ag teastáil, sonraigh na rudaí gaolmhara a theastaíonn uait a ghlasáil in ``select_for_update (of= (...)) ``ag baint úsáide as comhréir na réimsí céanna mar: meth: `select_related`. Úsáid an luach ``'self' chun tagairt a dhéanamh do mhúnla an tacar fiosrúcháin.

Glas samhlacha tuismitheoirí i ``select_for_update (de =( ... )) ``

Más mian leat samhlacha tuismitheoirí a ghlasáil agus tú ag úsáid:ref: oidhreacht il-tábla <multi-table-inheritance>, ní mór duit réimsí nasc tuismitheoirí a shonrú (de réir réamhshocraithe <parent_model_name>_ptr) san argóint of. Mar shampla:

Code

Restaurant.objects.select_for_update(of=("self", "place_ptr"))

Ar PostgreSQL amháin, is féidir leat no_key=true a rith d'fhonn glas níos laige a fháil, a cheadaíonn sraitheanna a chruthú nach dtagraíonn ach sraitheanna faoi ghlas (trí eochair eachtrach, mar shampla) agus an glas i bhfeidhm. < https://www.postgresql.org/docs/current/explicit-locking.html#LOCKING-ROWS>Tá tuilleadh sonraí ag doiciméadú PostgreSQL faoi `modhanna glasála leibhéal sraithe`_.

Ní féidir leat ``select_for_update () ``a úsáid ar chaidrimh neamhnaithe:

Python console

>>> Person.objects.select_related("hometown").select_for_update()
Traceback (most recent call last):
...
django.db.utils.NotSupportedError: FOR UPDATE cannot be applied to the nullable side of an outer join

Chun an srian sin a sheachaint, is féidir leat rudaí neall a eisiamh mura bhfuil cúram ort fúthu:

Python console

>>> Person.objects.select_related("hometown").select_for_update().exclude(hometown=None)
<QuerySet [<Person: ...)>, ...]>

Tacaíonn cúltaca bunachar sonraí postgresql, oracle, agus mysql select_for_update () ``. Mar sin féin, ní thacaíonn MariaDB ach leis an argóint ``nowait ``, tacaíonn MariaDB 10.6+ leis an argóint ``skip_locked freisin, agus tacaíonn MySQL leis na hargóintí nowait, skip_locked`, agus of. Ní thacaítear leis an argóint no_key ach ar PostgreSQL.

Ag dul noWait=True, skip_locked=true`, no_key=true`, nó of go ``select_for_update () ``ag baint úsáide as cúltaca bunachar sonraí nach dtacaíonn leis na roghanna seo, mar MySQL, ardaíonn a:exc: ~django.db.notSupportedError. Cuireann sé seo cosc ar chód ó bhlocáil gan choinne.

Meastóireacht a dhéanamh ar shraith ceisteanna le select_for_update () ``i mód uathchomhcheangail ar chúltaca a thacaíonn le ``SELECT... LE HAGHAIDH UPDATE is é:: exc: ~django.db.transaction.transactionManagementError earráid toisc nach bhfuil na sraitheanna faoi ghlas sa chás sin. Má cheadaítear é, éascódh sé seo éilliú sonraí agus d'fhéadfadh sé a bheith ina chúis go héasca trí chód glaonna atá ag súil go reáchtálfar in idirbheart lasmuigh de cheann amháin.

Ag baint úsáide as select_for_update () ``ar chúltaca nach dtacaíonn le ``SELECT... LE HAGHAIDH NUASHONRÚ ``(mar shampla SQLite) ní bheidh aon éifeacht ag. ``ROGHNAIGH... NÍ chuirfear FOR UPDATE leis an bhfiosrú, agus ní ardaítear earráid má úsáidtear ``select_for_update () ``i mód autocommit.

``amh () ``Link to this heading

raw(raw_query, params=(), translations=None, using=None)Link to this definition

Tógann sé ceist amh SQL, cuireann sé i bhfeidhm é, agus filleann sé sampla Django.db.Models.Query.RawQuerySet ``. Is féidir an cás ``RawQuerySet seo a athrú díreach cosúil le gnáth-QuerySet chun cásanna réada a sholáthar.

Féach an:doc: /topics/db/sql le haghaidh tuilleadh eolais.

Oibreoirí a chuireann ar ais `QuerySet`s nuaLink to this heading

Ní mór do cheisteanna comhcheangailte an tsamhail chéanna a úsáid.

AGUS (``& ``)Link to this heading

Comhcheanglaíonn dhá QuerySet ag baint úsáide as an oibreoir AND SQL ar bhealach cosúil le scagairí slabhraithe.

Tá na nithe seo a leanas coibhéiseach:

Code

Model.objects.filter(x=1) & Model.objects.filter(y=2)
Model.objects.filter(x=1).filter(y=2)

Coibhéis SQL:

SQL

SELECT ... WHERE x=1 AND y=2

NÓ (`|`)Link to this heading

Comhcheanglaíonn dhá QuerySets ag baint úsáide as an oibreoir SQL OR.

Tá na nithe seo a leanas coibhéiseach:

Code

Model.objects.filter(x=1) | Model.objects.filter(y=2)
from django.db.models import Q

Model.objects.filter(Q(x=1) | Q(y=2))

Coibhéis SQL:

SQL

SELECT ... WHERE x=1 OR y=2

Ní oibríocht chomhlaitheach é |`, toisc go bhféadfar ceisteanna difriúla (cé go coibhéiseach) a ghiniúint.

XOR (`^`)Link to this heading

Comhcheanglaíonn dhá QuerySets ag baint úsáide as an oibreoir SQL XOR. Meaitseálann abairt XOR sraitheanna atá comhoiriúnach le líon aige oibrandaí.

Tá na nithe seo a leanas coibhéiseach:

Code

Model.objects.filter(x=1) ^ Model.objects.filter(y=2)
from django.db.models import Q

Model.objects.filter(Q(x=1) ^ Q(y=2))

Coibhéis SQL:

SQL

SELECT ... WHERE x=1 XOR y=2

Note

Tugtar tacaíocht dúchasach le XOR ar MariaDB agus MySQL. Ar bhunachair sonraí eile, déantar x ^ y ^... ^ z a thiontú go coibhéis:

SQL

(x OR y OR ... OR z) AND
1=MOD(
    (CASE WHEN x THEN 1 ELSE 0 END) +
    (CASE WHEN y THEN 1 ELSE 0 END) +
    ...
    (CASE WHEN z THEN 1 ELSE 0 END),
    2
)

Modhanna nach gcuireann ar ais `QuerySet`sLink to this heading

Déanann na modhanna QuerySet seo a leanas measúnú ar an QuerySet agus cuireann siad rud éigin seachas QuerySet ar ais.

Ní úsáideann na modhanna seo taisce (féach:ref: caching-and-querysets). Ina ionad sin, fiosraíonn siad an bunachar sonraí gach uair a ghlaofar orthu.

Toisc go ndéanann na modhanna seo measúnú ar an QuerySet, tá siad ag blocáil glaonna, agus mar sin ní féidir a bpríomhleaganacha (sioncronacha) a ghlaoch ó chód asincrónach. Ar an gcúis seo, tá leagan asincrónach comhfhreagrach ag gach ceann acu le réimír a - mar shampla, seachas get (...) ``is féidir leat ``fanacht aget (...).

De ghnáth ní bhíonn aon difríocht in iompar seachas a nádúr asincrónach, ach tugtar faoi deara aon difríochtaí thíos in aice le gach modh.

``get () `Link to this heading

get(*args, **kwargs)Link to this definition

aget(*args, **kwargs)Link to this definition

Leagan asincrón: ``aget () ``

Filleann sé an réad a mheaitseálann na paraiméadair chuardaigh a thugtar, ar chóir go mbeadh sa fhormáid a thuairiscítear i `Cuardach réimse `_ Ba chóir duit cuardaigh a úsáid atá ráthaithe uathúil, mar shampla an príomh-eochair nó réimsí i srian uathúil. Mar shampla:

Code

Entry.objects.get(id=1)
Entry.objects.get(Q(blog=blog) & Q(entry_number=1))

Má tá tú ag súil go bhfaighidh tacar ceisteanna sraith amháin ar ais cheana féin, is féidir leat ``get () ``a úsáid gan aon argóintí chun an réad don tsraith sin a thabhairt ar ais:

Code

Entry.objects.filter(pk=1).get()

<django.db.models.Model.DoesNotExist>Mura bhfaigheann ``get () ``aon rud, ardaíonn sé: exc: `Model.doesNotExist `eisceacht:

Code

Entry.objects.get(id=-999)  # raises Entry.DoesNotExist

<django.db.models.Model.MultipleObjectsReturned>Má aimsíonn ``get () ``níos mó ná réad amháin, ardaíonn sé a: exc: `Model.MultipleObjectsReturned `eisceacht:

Code

Entry.objects.get(name="A Duplicated Name")  # raises Entry.MultipleObjectsReturned

Is tréithe den rang samhail iad an dá rang eisceachta seo, agus go sonrach don tsamhail sin. Más mian leat eisceachtaí den sórt sin a láimhseáil ó roinnt glaonna ``get () ``ar mhúnlaí éagsúla, is féidir leat a n-aicmí bonn cineálacha a úsáid. Mar shampla, is féidir leat: exc: Django.Core.Exceptions.ObjectDoesNotExist a úsáid chun láimhseáil: exc: ~django.db.models.model.doesNotExist eisceachtaí ó iolracha samhlacha:

Code

from django.core.exceptions import ObjectDoesNotExist

try:
    blog = Blog.objects.get(id=1)
    entry = Entry.objects.get(blog=blog, entry_number=1)
except ObjectDoesNotExist:
    print("Either the blog or entry doesn't exist.")

``cruthaigh () ``Link to this heading

create(**kwargs)Link to this definition

acreate(**kwargs)Link to this definition

Asynchronous version: acreate()

A convenience method for creating an object and saving it all in one step. Thus:

Code

p = Person.objects.create(first_name="Bruce", last_name="Springsteen")

agus:

Code

p = Person(first_name="Bruce", last_name="Springsteen")
p.save(force_insert=True)

iad coibhéiseach.

Tá an paraim <ref-models-force-insert>éadair: ref: force_insert `doiciméadaithe in áiteanna eile, ach ní chiallaíonn sé ach go gcruthófar réad nua i gcónaí. De ghnáth ní bheidh ort a bheith buartha faoi seo. Mar sin féin, má tá príomh-luach láimhe i do mhúnla a shocraíonn tú agus má tá an luach sin ann cheana sa bhunachar sonraí, teipeann ar ghlao ar `create () ``le an:exc: `~django.db.IntegrityError ós rud é go gcaithfidh eochracha bunscoile a bheith uathúil. Bí réidh chun an eisceacht a láimhseáil má tá eochracha bunscoile láimhe á úsáid agat.

``get_or_create () `Link to this heading

get_or_create(defaults=None, **kwargs)Link to this definition

aget_or_create(defaults=None, **kwargs)Link to this definition

Leagan asincrón: ``aget_or_create () ``

Modh áisiúlachta chun réad a chuardach leis an `kwargs ``tugtha (féadfaidh sé a bheith folamh má tá réamhshocruithe ag do mhúnla do gach réimse), ag cruthú ceann más gá.

Filleann sé tuple de (réad, cruthaithe), áit gurb é réad ``an réad aisghabháilte nó cruthaithe agus is boolean é ``cruthaithe a shonraíonn an cruthaíodh réad nua.

Tá sé seo i gceist chun rudaí dúblacha a chruthú nuair a dhéantar iarratais go comhthreomhar, agus mar aicearra chuig cód boilerplatish. Mar shampla:

Code

try:
    obj = Person.objects.get(first_name="John", last_name="Lennon")
except Person.DoesNotExist:
    obj = Person(first_name="John", last_name="Lennon", birthday=date(1940, 10, 9))
    obj.save()

Anseo, le hiarratais chomhthráthacha, féadfar iarrachtaí iolracha chun ``Duine ``a shábháil leis na paraiméadair chéanna. Chun an coinníoll rása seo a sheachaint, is féidir an sampla thuas a athscríobh ag baint úsáide as ``get_or_create () ``mar sin:

Code

obj, created = Person.objects.get_or_create(
    first_name="John",
    last_name="Lennon",
    defaults={"birthday": date(1940, 10, 9)},
)

Any keyword arguments passed to get_or_create() — except an optional one called defaults — will be used in a get() call. If an object is found, get_or_create() returns a tuple of that object and False.

<django.db.models.Q>Is féidir leat coinníollacha níos casta a shonrú don réad aisghabháilte trí get_or_create () ``a shlánú le ``filter () agus ag baint úsáid:class: `Q rudaí `. Mar shampla, chun Robert nó Bob Marley a aisghabháil má tá ceachtar acu ann, agus an dara ceann a chruthú ar shlí eile:

Code

from django.db.models import Q

obj, created = Person.objects.filter(
    Q(first_name="Bob") | Q(first_name="Robert"),
).get_or_create(last_name="Marley", defaults={"first_name": "Bob"})

Má aimsítear rudaí iolracha, ardaíonn get_or_create () `:exc: `~django.core.exceptions.multipleObjectsReturned`. Má aimsítear réad *ní fhaightear, déanfaidh `get_or_create () ``réad nua a thabhairt isteach agus a shábháil, ag tabhairt tuple den réad nua agus ``True ar ais. Cruthófar an réad nua go garbh de réir an algartam seo:

Code

params = {k: v for k, v in kwargs.items() if "__" not in k}
params.update({k: v() if callable(v) else v for k, v in defaults.items()})
obj = self.model(**params)
obj.save()

I mBéarla, ciallaíonn sé sin tosú le haon argóint eochairfhocal neamh-defaults nach bhfuil béim dhúbailte ann (a chuirfeadh le fios cuardach neamhchruinn). Ansin cuir ábhar defaults`, ag cur aon eochracha a shárú más gá, agus bain úsáid as an toradh mar na hargóintí eochairfhocal chuig an rang samhail. Má tá aon ghlaonna in defaults, déan meastóireacht orthu. Mar a thuairiscítear thuas, is simplíocht é seo ar an algartam a úsáidtear, ach tá na sonraí ábhartha go léir ann. Tá níos mó seiceála earráidí ag an gcur i bhfeidhm inmheánach ná seo agus láimhseálann sé roinnt coinníollacha imeall breise; má tá suim agat, léigh an cód.

Má tá réimse agat darb ainm defaults agus má theastaíonn uait é a úsáid mar chuardach cruinn i get_or_create () ``, bain úsáid as ``'defaults__exact', mar sin:

Code

Foo.objects.get_or_create(defaults__exact="bar", defaults={"defaults": "baz"})

The get_or_create() method has similar error behavior to create() when you're using manually specified primary keys. If an object needs to be created and the key already exists in the database, an IntegrityError will be raised.

Faoi dheireadh, focal maidir le get_or_create () ``a úsáid i dtuairimí Django. Déan cinnte go n-úsáidfidh tú é ach amháin in iarratais ``POST ``mura bhfuil cúis mhaith agat gan a dhéanamh. Níor cheart go mbeadh aon éifeacht ag iarratais ``GET ar shonraí. Ina áit sin, bain úsáid as `POST ``aon uair a bhíonn fo-éifeacht ag iarraidh ar leathanach ar do chuid sonraí. <9110 #section -9.2.1>Le haghaidh tuilleadh, féach: rfc: `Modhanna sábháilte' sa shonraíocht HTTP.

Warning

Is féidir leat tréithe ``get_or_create () ``a úsáid trí:class: ~django.db.models.manyToManyField agus caidreamh aisiompthe. Sa chás sin cuirfidh tú srian ar na ceisteanna taobh istigh de chomhthéacs an chaidrimh sin. D'fhéadfadh sé sin roinnt fadhbanna sláine a bheith mar thoradh ort mura n-úsáideann tú é go comhsheasmhach.

Mar na samhlacha seo a leanas:

Code

class Chapter(models.Model):
    title = models.CharField(max_length=255, unique=True)


class Book(models.Model):
    title = models.CharField(max_length=256)
    chapters = models.ManyToManyField(Chapter)

Is féidir leat ``get_or_create () ``a úsáid trí réimse caibidlí an Leabhair, ach ní fhaigheann sé ach taobh istigh de chomhthéacs an leabhair sin:

Python console

>>> book = Book.objects.create(title="Ulysses")
>>> book.chapters.get_or_create(title="Telemachus")
(<Chapter: Telemachus>, True)
>>> book.chapters.get_or_create(title="Telemachus")
(<Chapter: Telemachus>, False)
>>> Chapter.objects.create(title="Chapter 1")
<Chapter: Chapter 1>
>>> book.chapters.get_or_create(title="Chapter 1")
# Raises IntegrityError

This is happening because it's trying to get or create "Chapter 1" through the book "Ulysses", but it can't do either: the relation can't fetch that chapter because it isn't related to that book, but it can't create it either because title field should be unique.

``Update_or_create () ``Link to this heading

update_or_create(defaults=None, create_defaults=None, **kwargs)Link to this definition

aupdate_or_create(defaults=None, create_defaults=None, **kwargs)Link to this definition

Leagan asincrón: ``aupdate_or_create () ``

Modh áisiúlachta chun réad a nuashonrú leis an kwargs ``tugtha, ceann nua a chruthú más gá. Is foclóirí de phéirí (réimse, luach) iad `create_defaults` agus defaults` araon. Is féidir na luachanna i create_defaults` agus defaults` araon a bheith inghlaonta. Úsáidtear defaults chun an réad a nuashonrú agus úsáidtear create_defaults don oibríocht chruthaigh. Mura gcuirtear create_defaults` ar fáil, úsáidfear defaults don oibríocht chruthaithe.

Tugann sé tuple de (réad, cruthaithe), ina bhfuil réad ``an rud cruthaithe nó nuashonraithe agus is boolean é ``cruthaithe a shonraíonn an cruthaíodh réad nua.

Déanann an modh update_or_create` iarracht réad a fháil ón mbunachar sonraí bunaithe ar an kwargs ``tugtha. Má aimsítear meaitseáil, nuashonraíonn sé na réimsí a rith sa fhoclóir ``defaults.

Tá sé seo i gceist mar aicearra chuig cód boilerplatish. Mar shampla:

Code

defaults = {"first_name": "Bob"}
create_defaults = {"first_name": "Bob", "birthday": date(1940, 10, 9)}
try:
    obj = Person.objects.get(first_name="John", last_name="Lennon")
    for key, value in defaults.items():
        setattr(obj, key, value)
    obj.save()
except Person.DoesNotExist:
    new_values = {"first_name": "John", "last_name": "Lennon"}
    new_values.update(create_defaults)
    obj = Person(**new_values)
    obj.save()

Éiríonn an patrún seo go leor de réir mar a théann líon na réimsí i samhail suas. Is féidir an sampla thuas a athscríobh ag baint úsáide as ``update_or_create () ``mar sin:

Code

obj, created = Person.objects.update_or_create(
    first_name="John",
    last_name="Lennon",
    defaults={"first_name": "Bob"},
    create_defaults={"first_name": "Bob", "birthday": date(1940, 10, 9)},
)

Le haghaidh tuairisc mhionsonraithe ar an gcaoi a réitear ainmneacha a rith in kwargs`, féach:meth: get_or_create.

Mar a thuairiscítear thuas in:meth: get_or_create, tá seans go mbeidh coinníoll rásaíochta ag an modh seo a d'fhéadfadh sraitheanna iolracha a chur isteach ag an am céanna mura gcuirtear uathúlacht i bhfeidhm ag leibhéal an bhunachar sonraí.

Cosúil le: Meth: get_or_create agus:meth: create, má tá eochracha bunscoile sonraithe de láimh á úsáid agat agus má chaithfear réad a chruthú ach tá an eochair ann cheana sa bhunachar sonraí, an:exc: ~django.db.IntegrityError ardaítear.

``bulk_create () ``Link to this heading

bulk_create(objs, batch_size=None, ignore_conflicts=False, update_conflicts=False, update_fields=None, unique_fields=None)Link to this definition

abulk_create(objs, batch_size=None, ignore_conflicts=False, update_conflicts=False, update_fields=None, unique_fields=None)Link to this definition

Asynchronous version: abulk_create()

Cuireann an modh seo an liosta rudaí a chuirtear ar fáil isteach sa bhunachar sonraí ar bhealach éifeachtach (de ghnáth ní amháin ceist amháin, is cuma cé mhéad rudaí atá ann), agus tugann sé rudaí cruthaithe ar ais mar liosta, san ord céanna mar a chuirtear ar fáil:

Python console

>>> objs = Entry.objects.bulk_create(
...     [
...         Entry(headline="This is a test"),
...         Entry(headline="This is only a test"),
...     ]
... )

Tá roinnt rabhaidh aige seo áfach:

Ní ghlaofar modh save () ``an tsamhail, agus ní sheolfar na comharthaí ``pre_save agus post_save.
Ní oibríonn sé le samhlacha leanaí i gcás oidhreachta il-tábla.
If the model's primary key is an AutoField or has a db_default value, and ignore_conflicts is False, the primary key attribute can only be retrieved on certain databases (currently PostgreSQL, MariaDB, and SQLite 3.35+). On other databases, it will not be set.
Ní oibríonn sé le caidrimh go leor.
Caitheann sé objs chuig liosta, a dhéanann meastóireacht iomlán ar objs más gineadóir é. Ligeann an teilgthe gach rud a iniúchadh ionas gur féidir aon rudaí a bhfuil eochair phríomhúil socraithe de láimh acu a chur isteach ar dtús. Más mian leat rudaí a chur isteach i mbaisceanna gan an gineadóir iomlán a mheas ag an am céanna, is féidir leat an teicníc seo a úsáid chomh fada agus nach bhfuil aon eochracha bunscoile socraithe de láimh ag na rudaí:
Code
```
from itertools import islice

batch_size = 100
objs = (Entry(headline="Test %s" % i) for i in range(1000))
while True:
    batch = list(islice(objs, batch_size))
    if not batch:
        break
    Entry.objects.bulk_create(batch, batch_size)
```

The batch_size parameter controls how many objects are created in a single query. The default is to create as many objects in one batch as the database will allow. (SQLite and Oracle limit the number of parameters in a query.)

Ar bhunachair sonraí a thacaíonn leis (uile ach Oracle), deir an paraiméadar ignore_conflicts` a shocrú go True don bhunachar sonraí neamhaird a dhéanamh ar theip ar aon sraitheanna a chur isteach ina theipeann srianta mar luachanna uathúla dúbailte.

Ar bhunachair sonraí a thacaíonn leis (uile seachas Oracle), ag socrú an paraiméadar update_conflicts go True`, insíonn don bhunachar sonraí update_fields a nuashonrú nuair a theipeann ar ionchur sraith ar choimhlintí. Ar PostgreSQL agus SQLite, i dteannta le update_fields`, ní mór liosta de unique_fields a d'fhéadfadh a bheith i gcoinbhleacht a sholáthar.

Déanann an paraiméadar ignore_conflicts` a chumasú ar an bpríomh-eochair a shocrú ar gach samhail (má thacaíonn an bunachar sonraí leis de ghnáth).

``bulk_update () ``Link to this heading

bulk_update(objs, fields, batch_size=None)Link to this definition

abulk_update(objs, fields, batch_size=None)Link to this definition

Asynchronous version: abulk_update()

Nuashonraíonn an modh seo na réimsí tugtha go héifeachtúil ar na cásanna samhail a chuirtear ar fáil, go ginearálta le ceist amháin, agus filleann sé líon na ruda

Python console

>>> objs = [
...     Entry.objects.create(headline="Entry 1"),
...     Entry.objects.create(headline="Entry 2"),
... ]
>>> objs[0].headline = "This is entry 1"
>>> objs[1].headline = "This is entry 2"
>>> Entry.objects.bulk_update(objs, ["headline"])
2

: meth: Úsáidtear .querySet.Update chun na hathruithe a shábháil, mar sin tá sé seo níos éifeachtaí ná athrú tríd an liosta samhlacha agus glaoch ar `save () `ar gach ceann acu, ach tá cúpla rabhadh aige:

Ní féidir leat príomh-eochair an tsamhail a nuashonrú.
Ní thugtar ar mhodh save () ``gach samhail, agus ní sheoltar na comharthaí: attr: `~django.db.models.signals.pre_save agus:attr: ~django.db.models.signals.post_save.
Má nuashonraítear líon mór colúin i líon mór sraitheanna, is féidir leis an SQL a ghintear a bheith an-mhór. Seachain é seo trí batch_size` oiriúnach a shonrú.

When updating a large number of objects, be aware that bulk_update() prepares all of the WHEN clauses for every object across all batches before executing any queries. This can require more memory than expected. To reduce memory usage, you can use an approach like this:

Code

from itertools import islice

batch_size = 100
ids_iter = iter(range(1000))
while ids := list(islice(ids_iter, batch_size)):
    batch = Entry.objects.filter(id__in=ids)
    for entry in batch:
        entry.headline = f"Updated headline {entry.pk}"
    Entry.objects.bulk_update(batch, ["headline"], batch_size=batch_size)

Beidh ceist bhreise in aghaidh an sinsear ag nuashonrú réimsí a shainmhínítear ar sinsear oidhreachta
Nuair a bhíonn dúbailtí i mbaisc aonair, ní bheidh nuashonrú mar thoradh ar an gcéad chás sa bhaisc sin.
D'fhéadfadh go mbeadh líon na rudaí a nuashonraíonn an fheidhm ar ais níos lú ná líon na rudaí a chuirtear isteach. D'fhéadfadh sé seo a bheith mar gheall ar rudaí dúblacha a rith ina ndéantar nuashonrú sna dálaí baisc nó cine céanna ionas nach bhfuil rudaí i láthair sa bhunachar sonraí a thuilleadh.

Rialaíonn an paraiméadar batch_size cé mhéad rudaí a shábháiltear in aon cheist amháin. Is é an réamhshocrú ná gach rud a nuashonrú i mbaisc amháin, ach amháin SQLite agus Oracle a bhfuil srianta acu ar líon na n-athróg a úsáidtear i gceist.

``comhaireamh () ``Link to this heading

count()Link to this definition

acount()Link to this definition

Asynchronous version: acount()

Filleann sé sláimhir a léiríonn líon na rudaí sa bhunachar sonraí a mheaitseann leis an QuerySet.

Sampla:

Code

# Returns the total number of entries in the database.
Entry.objects.count()

# Returns the number of entries whose headline contains 'Lennon'
Entry.objects.filter(headline__contains="Lennon").count()

Déanann glao count () ```SELECT COUNT (*) taobh thiar de na radhairc, mar sin ba chóir duit count () ``a úsáid i gcónaí seachas an taifead go léir a luchtú isteach i rudaí Python agus glaoch ar `len () ar an toradh (mura gcaithfidh tú na rudaí a luchtú i gcuimhne ar aon nós, sa chás sin beidh `len () ``níos gasta).

Tabhair faoi deara más mian leat líon na míreanna i QuerySet agus má tá tú ag aisghabháil cásanna samhail uaidh freisin (mar shampla, trí athrú air), is dócha go mbeidh sé níos éifeachtaí len (queryset) ``a úsáid nach gcuirfidh ceist bunachar sonraí breise mar ``count ().

Má tá an tacar ceisteanna aisghabháilte go hiomlán cheana féin, úsáidfidh ``count () ``an fad sin seachas ceist breise bunachar sonraí a dhéanamh.

``in_bulk () ``Link to this heading

in_bulk(id_list=None, *, field_name='pk')Link to this definition

ain_bulk(id_list=None, *, field_name='pk')Link to this definition

Asynchronous version: ain_bulk()

Glacann sé liosta de luachanna réimse (id_list) agus an field_name do na luachanna sin, agus filleann sé foclóir a mhapáil gach luach go sampla den réad leis an luach réimse a thugtar. No:exc: Ardóidh eisceachtaí django.core.exceptions.objectDoesNotExist riamh le in_bulk; is é sin, ní dhéanfar neamhaird ar aon luach id_list nach bhfuil meaitseáil le haon chás. Mura gcuirtear id_list ar fáil, cuirtear gach rud sa tacar fiosrúcháin ar ais. Caithfidh field_name` a bheith ina réimse uathúil nó ina réimse ar leith (mura bhfuil ach réimse amháin ann a shonraítear in:meth: distint). Réamhshocraíonn field_name don eochair phríomhúil.

Sampla:

Python console

>>> Blog.objects.in_bulk([1])
{1: <Blog: Beatles Blog>}
>>> Blog.objects.in_bulk([1, 2])
{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>}
>>> Blog.objects.in_bulk([])
{}
>>> Blog.objects.in_bulk()
{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>, 3: <Blog: Django Weblog>}
>>> Blog.objects.in_bulk(["beatles_blog"], field_name="slug")
{'beatles_blog': <Blog: Beatles Blog>}
>>> Blog.objects.distinct("name").in_bulk(field_name="name")
{'Beatles Blog': <Blog: Beatles Blog>, 'Cheddar Talk': <Blog: Cheddar Talk>, 'Django Weblog': <Blog: Django Weblog>}

Má chuireann tú liosta folamh ar ``in_bulk () ``, gheobhaidh tú foclóir folamh.

``iterator () ``Link to this heading

iterator(chunk_size=None)Link to this definition

aiterator(chunk_size=None)Link to this definition

Asynchronous version: aiterator()

Déanann sé meastóireacht ar an QuerySet (tríd an bhfiosrú a dhéanamh) agus filleann sé athraitheoir (féach: pep: 234) thar na torthaí, nó athraitheoir asincrónach (féach: pep: 492) má ghlaonn tú ar a leagan asincrónach aiterator.

A QuerySet typically caches its results internally so that repeated evaluations do not result in additional queries. In contrast, iterator() will read results directly, without doing any caching at the QuerySet level. For a QuerySet which returns a large number of objects that you only need to access once, this can result in better performance and a significant reduction in memory.

Tabhair faoi deara go gcuirfidh úsáid iterator () ``ar `QuerySet a rinneadh meastóireacht cheana féin iallach air a mheas arís, ag athdhéanamh an cheist.

Tá iterator () ``comhoiriúnach le glaonna roimhe seo chuig ``prefetch_related () fad is a thugtar chunk_size. Beidh níos lú ceisteanna ag teastáil ó luachanna níos mó chun an réamhghabháil a chur i gcrích ar chostas níos mó úsáide cuimhne.

Ar roinnt bunachair sonraí (m.sh. Oracle, SQLite < https://www.sqlite.org/limits.html#max_variable_number>), d'fhéadfadh go mbeadh uaslíon téarmaí i gclásal SQL IN ``teoranta. Dá bhrí sin ba chóir luachanna faoi bhun an teorainn seo a úsáid. (Go háirithe, nuair a bhíonn dhá chaidreamh nó níos mó á réamhghabháil agat, ba chóir go mbeadh `chunk_size beag go leor go dtitfidh an líon na dtorthaí a bhfuil súil leis do gach caidreamh réamhfhaighte faoi bhun an teorainn fós.)

Chomh fada agus nach bhfaigheann an QuerySet aon rudaí gaolmhara roimh ré, ní úsáidfidh Django réamhshocrú intuigthe 2000 mar thoradh ar aon luach a sholáthar do chunk_size`.

Ag brath ar chúlcheann an bhunachar sonraí, luchtálfar torthaí fiosrúcháin uile ag an am céanna nó a shruthú ón mbunachar sonraí ag baint úsáide as cúrsóirí taobh an fhre

Le cúrsaí taobh an fhreastalaíLink to this heading

Úsáideann Oracle agus:ref: `PostgreSQL <postgresql-server-side-cursors>`cúrsaí taobh an fhreastalaí chun torthaí a shruthlú ón mbunachar sonraí gan an tacar toradh iomlán a luchtú isteach i gcuimhne.

Úsáideann tiománaí bunachar sonraí Oracle cúrsóirí taobh an fhreastalaí

Le cúrsóirí taobh an fhreastalaí, sonraíonn an paraiméadar chunk_size líon na dtorthaí le taisce ag leibhéal tiománaí an bhunachar sonraí. Laghdaíonn píosaí níos mó a fháil líon na dturais babhta idir tiománaí an bhunachar sonraí agus an bunachar sonraí, ar chostas na cuimhne.

<DATABASE-DISABLE_SERVER_SIDE_CURSORS>Ar PostgreSQL, ní úsáidfear cúrsóirí taobh an fhreastalaí ach nuair is é an socrú: setting: DISABLE_SERVER_SIDE_CURSORS ``False`. léitheo:ref: transaction-pooling-server-side-cursors má tá poiblí nasc á úsáid agat atá cumraithe i mód comhionannaithe idirbheart. Nuair a dhéantar cúrsóirí taobh an fhreastalaí a dhíchumasú, tá an t-iompar mar an gcéanna le bunachair sonraí nach dtacaíonn le cúrsóirí taobh an f

Gan cúrsaí taobh an fhreastalaíLink to this heading

Ní thacaíonn MySQL le torthaí sruthú, dá bhrí sin luchtaíonn tiománaí bunachar sonraí Python an toradh iomlán atá leagtha síos Ansin déantar an tacar torthaí a athrú go rudaí sraithe Python ag an oiriúnaitheoir bunachar sonraí ag baint úsáide as an modh ``fetchmany () ``atá sainmhínithe in:pep: 249.

Is féidir le SQLite torthaí a fháil i mbaisceanna ag baint úsáide as ``fetchmany () ``, ach ós rud é nach soláthraíonn SQLite aonrú idir ceisteanna laistigh de nasc, bí cúramach agus tú ag scríobh chuig an tábla atá á athrá. Féach: ref: sqlite-isolation le haghaidh tuilleadh faisnéise.

Rialaíonn an paraiméadar chunk_size méid na mbaisceanna a aisghabhann Django ón tiománaí bunachar sonraí. Laghdaíonn baisceanna níos mó lasbhaird cumarsáide leis an tiománaí bunachar sonraí ar chostas méadú beag ar thomhaltas cuimhne.

< https://www.postgresql.org/message-id/4D2F2C71.8080805%40dndg.it>Chomh fada agus nach bhfaigheann an QuerySet aon rudaí gaolmhara roimh ré, ní sholáthraíonn aon luach do chunk_size` mar thoradh ar Django réamhshocrú intuigthe de 2000, luach a dhíorthaítear ó `ríomh ar an liosta seoltaí psycopg`_:

Ag glacadh leis sraitheanna de 10-20 colún le meascán de shonraí téacsúla agus uimhriúla, tá 2000 chun níos lú ná 100KB sonraí a fháil, rud is cosúil gur comhréiteach maith é idir líon na sraitheanna a aistrítear agus na sonraí a scriosadh má imeádtar an lúb go luath.

``is déanaí () ``Link to this heading

latest(*fields)Link to this definition

alatest(*fields)Link to this definition

Leagan asincrón: ``alatest () ``

Tugann sé an réad is déanaí sa tábla ar ais bunaithe ar na réimsí (í) ar leith.

Tugann an sampla seo an Entry` is déanaí sa tábla, de réir réimse pub_date:

Code

Entry.objects.latest("pub_date")

Is féidir leat an ceann is déanaí a roghnú bunaithe ar roinnt réimsí. Mar shampla, chun an Entry` a roghnú leis an expire_date is luaithe nuair a bhíonn an pub_date` céanna ag dhá iontráil:

Code

Entry.objects.latest("pub_date", "-expire_date")

Ciallaíonn an comhartha diúltach in `'-expire_date'` ``dáta deighilte a shórtáil san ordú*downing*. Ós rud é go bhfaigheann latest () ``an toradh deireanach, roghnaítear an ``Entry leis an expire_date is luaithe.

Má shonraíonn do mhúnlaí:ref: Meta <meta-options>: attr: ~django.db.models.options.get_latest_by, is féidir leat aon argóintí a fhágáil go early () ``nó ``latest (). Úsáidfear na réimsí a shonraítear in:attr: ~django.db.models.options.get_latest_by de réir réamhshocraithe.

Like get(), earliest() and latest() raise DoesNotExist if there is no object with the given parameters.

Tabhair faoi deara go bhfuil is luaithe () ``agus ``is déanaí () ann ach ar mhaithe le háisiúlacht agus inléiteacht.

Féadfaidh `is luaithe () ``agus ``latest () cásanna a thabhairt ar ais le dátaí neall.

Ós rud é go ndéantar ordú a tharmligtear chuig an mbunachar sonraí, féadfar torthaí ar réimsí a cheadaíonn luachanna neall a ordú ar bhealach difriúil Mar shampla, déanann PostgreSQL agus MySQL luachanna null a shórtáil amhail is dá mbeadh siad níos airde ná luachanna neamh-niall, agus déanann SQLite a mhalairt.

B'fhéidir gur mhaith leat luachanna null a scagadh amach:

Code

Entry.objects.filter(pub_date__isnull=False).latest("pub_date")

``is luaithe () ``Link to this heading

earliest(*fields)Link to this definition

aearliest(*fields)Link to this definition

Leagan asincrón: ``aearly () ``

Oibríonn sé ar shlí eile cosúil:meth: ~django.db.models.query.queryset.latest ach amháin go n-athraítear an treo.

``chéad () `Link to this heading

first()Link to this definition

afirst()Link to this definition

Leagan asincrón: ``first () `

Filleann sé an chéad réad a mheaitseáil leis an tacar fiosrúcháin, nó None mura bhfuil aon rud meaitseála ann. Mura bhfuil aon ordú sainmhínithe ag an ``QuerySet`, ansin ordaítear an tacar fiosrúcháin go huathoibríoch ag an eochair phríomhúil. Féadfaidh sé seo dul i bhfeidhm ar thorthaí comhiomlánaithe mar a thuairiscítear in:ref: `comhiomlán-ordú-idirghníomhach

Sampla:

Code

p = Article.objects.order_by("title", "pub_date").first()

Tabhair faoi deara gur modh áisiúlachta é ``first () `, tá an sampla cód seo a leanas comhionann leis an sampla thuas:

Code

try:
    p = Article.objects.order_by("title", "pub_date")[0]
except IndexError:
    p = None

``deireanach () `Link to this heading

last()Link to this definition

alast()Link to this definition

Leagan asincrón: ``alast () ``

Works like first(), but returns the last object in the queryset.

``comhiomlán () ``Link to this heading

aggregate(*args, **kwargs)Link to this definition

aaggregate(*args, **kwargs)Link to this definition

Leagan asincrón: ``aaggregate () ``

Tugann foclóir ar ais de luachanna comhiomlána (meáin, suimeanna, srl.) arna ríomh thar an ``QuerySet`. Sonraíonn gach argóint le ``comhiomlán () ``luach a chuirfear san áireamh sa fhoclóir a thugtar ar ais.

Déantar cur síos ar na feidhmeanna comhiomlánaithe a sholáthraíonn Django i Feidhmeanna Comhiomlánacha thíos. Ós rud é go bhfuil comhiomlánaithe freis:doc: `léirithe fiosraithe', féadfaidh tú comhiomláin a chomhcheangal le comhiomlán</ref/models/expressions> acha nó luachanna eile chun comhiomlánacha casta a chruthú.

Úsáidfidh comhiomlánaithe a shonraítear ag úsáid argóintí eochairfhocal an eochairfhocal mar ainm don anótáil Beidh ainm ag argóintí gan ainm a ghintear dóibh bunaithe ar ainm na feidhme chomhiomlán agus ar an réimse samhail atá á chomhiomlánú. Ní féidir le comhiomlánaithe casta argóintí gan ainm a úsáid agus ní mór argóint eochairfhocal a shonrú mar ailias

Mar shampla, nuair a bhíonn tú ag obair le hiontrálacha blag, b'fhéidir gur mhaith leat a fháil amach líon na n-údar a chuir iontrálacha blag leis:

Python console

>>> from django.db.models import Count
>>> Blog.objects.aggregate(Count("entry__authors"))
{'entry__authors__count': 16}

Trí argóint eochairfhocal a úsáid chun an fheidhm chomhiomlán a shonrú, is féidir leat ainm an luach comhiomlánaithe a chuirtear ar ais a rialú:

Python console

>>> Blog.objects.aggregate(number_of_authors=Count("entry__authors"))
{'number_of_authors': 16}

Le haghaidh plé domhain ar chomhiomlánú, féach:doc: `an treoir ábhair ar Chomhiomlán' </topics/db/aggregation>.

``ann () ``Link to this heading

exists()Link to this definition

aexists()Link to this definition

Leagan asincrón: ``aexists () ``

Tugann sé True má tá aon torthaí an:class: .QuerySet, agus False mura bhfuil. Déanann sé seo iarracht an cheist a dhéanamh ar an mbealach is simplí agus is gasta is féidir, ach déanann sé* beagnach an cheist céanna a fhorghníomhú le fiosrúchán gnáth:class: .querySet.

exists() is useful for searches relating to the existence of any objects in a QuerySet, particularly in the context of a large QuerySet.

Chun a fháil amach an bhfuil aon earraí i tacar fiosrúcháin:

Code

if some_queryset.exists():
    print("There is at least one object in some_queryset")

Cé a bheidh níos gasta ná:

Code

if some_queryset:
    print("There is at least one object in some_queryset")

... ach ní ar leibhéal mór (dá bhrí sin teastaíonn tacar fiosrúcháin mór uait le haghaidh gnóthachain éifeachtúlachta).

Ina theannta sin, mura ndearnadh meastóireacht ar some_queryset` fós, ach tá a fhios agat go mbeidh sé ag pointe éigin, ansin déanfaidh `some_queryset.exists () ``níos mó obair fhoriomlán (ceist amháin maidir leis an seiceáil ann móide ceann breise chun na torthaí a aisghabháil níos déanaí) ná `bool (some_queryset) `a úsáid, a aisghabhann na torthaí agus ansin seiceálann an raibh aon cheann ann ar ais.

`tá ()`Link to this heading

contains(obj)Link to this definition

acontains(obj)Link to this definition

Asynchronous version: acontains()

Tugann sé True má tá obj sa :class: .QuerySet, agus False mura bhfuil. Déanann sé seo iarracht an cheist a dhéanamh ar an mbealach is simplí agus is gasta is féidir.

contains() is useful for checking an object membership in a QuerySet, particularly in the context of a large QuerySet.

Chun a sheiceáil an bhfuil mír ar leith i tacar fiosrúcháin:

Code

if some_queryset.contains(obj):
    print("Entry contained in queryset")

Beidh sé seo níos gasta ná an méid seo a leanas a éilíonn measúnú agus athrá tríd an tacar ceisteanna iomlán:

Code

if obj in some_queryset:
    print("Entry contained in queryset")

Cosúil le: Meth: exists, mura ndearnadh meastóireacht fós ar some_queryset ``, ach tá a fhios agat go mbeidh sé ag pointe éigin, ansin déanfar ceist bunachar sonraí breise ag baint úsáide as `some_queryset.contents (obj), agus go ginearálta beidh feidhmíocht fhoriomlán níos moille mar thoradh air.

``nuashonrú () ``Link to this heading

update(**kwargs)Link to this definition

aupdate(**kwargs)Link to this definition

Asynchronous version: aupdate()

Déanann sé fiosrúchán nuashonraithe SQL do na réimsí sonraithe, agus filleann sé líon na sraitheanna a mheaitseáil ar ais (nach bhféadfadh a bheith cothrom le líon na sraitheanna a nuashonraítear má tá an luach nua ag roinnt sraitheanna

Mar shampla, chun tuairimí a mhúchadh do gach iontráil blag a foilsíodh in 2010, d'fhéadfá é seo a dhéanamh:

Python console

>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)

(Glacann sé leis seo go bhfuil réimsí pub_date agus comments_on ag do mhúnla ``Iontrála`.)

Is féidir leat réimsí iolracha a nuashonrú - níl aon teorainn ar cé mhéad. Mar shampla, anseo déanaimid na réimsí comments_on agus headline a nuashonrú:

Python console

>>> Entry.objects.filter(pub_date__year=2010).update(
...     comments_on=False, headline="This is old"
... )

Cuirtear an modh update () `i bhfeidhm láithreach, agus is é an t-aon srian ar an: class: `.querySet a nuashonraítear ná nach féidir leis ach colúin a nuashonrú i bpríomh-thábla an tsamhail, ní ar mhúnlaí gaolmhara. Ní féidir leat é seo a dhéanamh, mar shampla:

Python console

>>> Entry.objects.update(blog__name="foo")  # Won't work!

Is féidir scagadh bunaithe ar réimsí gaolmhara fós, áfach:

Python console

>>> Entry.objects.filter(blog__id=1).update(comments_on=True)

Ní féidir leat glaoch ar ``update () ``ar a:class: .QuerySet a bhfuil slisnas tógtha nó nach féidir é a scagadh a thuilleadh.

Tugann an modh ``update () ``líon na sraitheanna atá buailte ar ais:

Python console

>>> Entry.objects.filter(id=64).update(comments_on=True)
1

>>> Entry.objects.filter(slug="nonexistent-slug").update(comments_on=True)
0

>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)
132

Mura bhfuil tú ach taifead a nuashonrú agus mura gá duit aon rud a dhéanamh leis an réad samhail, is é an cur chuige is éifeachtaí ná glaoch ar `update () `, seachas an réad samhail a luchtú isteach i gcuimhne. Mar shampla, in ionad seo a dhéanamh:

Code

e = Entry.objects.get(id=10)
e.comments_on = False
e.save()

... déan seo:

Code

Entry.objects.filter(id=10).update(comments_on=False)

Cuireann úsáid nuashonrú () ``cosc ar riocht rása ina bhféadfadh rud éigin athrú i do bhunachar sonraí sa tréimhse ghearr ama idir an réad a luchtú agus glaoch ar `save ().

Finally, realize that update() does an update at the SQL level and, thus, does not call any save() methods on your models, nor does it emit the pre_save or post_save signals (which are a consequence of calling Model.save()). If you want to update a bunch of records for a model that has a custom save() method, loop over them and call save(), like this:

Code

for e in Entry.objects.filter(pub_date__year=2010):
    e.comments_on = False
    e.save()

Tacar ceisteanna ordaitheLink to this heading

Ní thacaítear le slabhraíocht order_by () ``le `update () ach ar MariaDB agus MySQL, agus déantar neamhaird air do bhunachar sonraí éagsúla. Tá sé seo úsáideach chun réimse uathúil a nuashonrú san ord a shonraítear gan choimhlintí. Mar shampla:

Code

Entry.objects.order_by("-number").update(number=F("number") + 1)

``scrios () ``Link to this heading

delete()Link to this definition

adelete()Link to this definition

Leagan asincrón: ``adelete () ``

Déanann sé ceist scriosta SQL ar gach sraitheanna san: class: .querySet agus filleann sé líon na rudaí a scriosadh agus foclóir le líon na scriosadh in aghaidh an chineál réada.

Cuirtear an ``delete () ``i bhfeidhm láithreach. Ní féidir leat glaoch ar ``delete () ``ar a:class: .QuerySet a bhfuil slisnas tógtha air nó nach féidir é a scagadh a thuilleadh.

Mar shampla, chun na hiontrálacha go léir i mblag áirithe a scriosadh:

Python console

>>> b = Blog.objects.get(pk=1)

# Delete all the entries belonging to this Blog.
>>> Entry.objects.filter(blog=b).delete()
(4, {'blog.Entry': 2, 'blog.Entry_authors': 2})

De réir réamhshocraithe, déanann django's:class: ~django.db.models.foreignKey aithris ar an srian SQL ON DELETE CASCADE - i bhfocail eile, scriosfar aon rudaí le heochracha eachtracha atá ag díriú ar na rudaí atá le scriosadh in éineacht leo. Mar shampla:

Python console

>>> blogs = Blog.objects.all()

# This will delete all Blogs and all of their Entry objects.
>>> blogs.delete()
(5, {'blog.Blog': 1, 'blog.Entry': 2, 'blog.Entry_authors': 2})

Is féidir an t-iompar cascaire seo inoiriúnaithe tríd an argóint: attr: ~django.db.models.foreignkey.on_delete chuig an argóint: :class: ~django.db.models.foreignKey.

Déanann an modh delete () ``scriosadh mórchóir agus ní ghlaonn sé aon mhodhanna ``delete () ar do mhúnlaí. Astaíonn sé, áfach, na comharthaí: data: ~django.db.models.signals.pre_delete agus:data: ~django.db.models.signals.post_delete do gach rud scriosta (lena n-áirítear scriosadh cascadaithe).

Caithfidh Django rudaí a fháil isteach i gcuimhne chun comharthaí a sheoladh agus cascades a láimhseáil. Mar sin féin, mura bhfuil aon cascades agus aon chomharthaí ann, ansin féadfaidh Django cosán tapa a ghlacadh agus rudaí a scriosadh gan a fháil isteach i gcuimhne. Maidir le scriosadh móra is féidir úsáid cuimhne laghdaithe go suntasach mar thoradh air seo. Is féidir méid na gceisteanna forghníomhaithe a laghdú freisin.

Ní chuireann ForeignKeys atá socraithe to:attr: ~django.db.models.foreignkey.on_delete DO_NOTHING` cosc ar an gcosán tapa a ghlacadh le scriosadh.

Tabhair faoi deara gur mionsonraí cur chun feidhme iad na ceisteanna a ghintear i scriosadh réada faoi réir athraithe.

``as_bainisteoir () ``Link to this heading

classmethod as_manager()Link to this definition

Modh aicme a thugann sampla de:class: ~Django.db.Models.Manager le cóip de mhodhanna QuerySet. Féach:ref: create-manager-with-queryset-methods le haghaidh tuilleadh sonraí.

Tabhair faoi deara, murab ionann agus na hiontrálacha eile sa chuid seo, níl leagan asincrónach aige seo toisc nach bhfeidhmíonn sé ceist.

``mhínigh () ``Link to this heading

explain(format=None, **options)Link to this definition

aexplain(format=None, **options)Link to this definition

Leagan asincrónaithe: ``aexample () ``

Tugann sé sreang de phlean forghníomhaithe ``QuerySet` ar ais, a chuireann mionsonraí ar an gcaoi a ndéanfadh an bunachar sonraí an cheist a fhorghníomhú, lena n-áirítear aon innéacsanna nó comhpháirteanna a úsáidfeadh. D'fhéadfadh eolas a fháil ar na sonraí seo cabhrú leat feidhmíocht na gceisteanna mall a fheabh

Mar shampla, agus PostgreSQL á úsáid agat:

Python console

>>> print(Blog.objects.filter(title="My Blog").explain())
Seq Scan on blog  (cost=0.00..35.50 rows=10 width=12)
  Filter: (title = 'My Blog'::bpchar)

Tá difríocht shuntasach idir bunachair sonraí an aschur.

Tacaíonn gach cúltaca bunachar sonraí ionsuite le ``explain () ``ach amháin Oracle toisc nach bhfuil cur i bhfeidhm ann simplí.

The format parameter changes the output format from the database's default, which is usually text-based. PostgreSQL supports 'TEXT', 'JSON', 'YAML', and 'XML' formats. MariaDB and MySQL support 'TEXT' (also called 'TRADITIONAL') and 'JSON' formats. MySQL 8.0.16+ also supports an improved 'TREE' format, which is similar to PostgreSQL's 'TEXT' output and is used by default, if supported.

Glacann roinnt bunachair sonraí le bratacha ar féidir leo tuilleadh faisnéise faoin bhfiosrú Cuir na bratacha seo mar argóintí eochairfhocal. Mar shampla, agus PostgreSQL á úsáid agat:

Python console

>>> print(Blog.objects.filter(title="My Blog").explain(verbose=True, analyze=True))
Seq Scan on public.blog  (cost=0.00..35.50 rows=10 width=12) (actual time=0.004..0.004 rows=10 loops=1)
  Output: id, title
  Filter: (blog.title = 'My Blog'::bpchar)
Planning time: 0.064 ms
Execution time: 0.058 ms

Ar roinnt bunachair sonraí, d'fhéadfadh bratacha a bheith ina chúis leis an bhfiosrú a fhorghníomhú a d'fhéadfadh éifeachtaí díobhálacha Mar shampla, d'fhéadfadh athruithe ar shonraí a bheith mar thoradh ar an mbratach ANALYZE` le tacaíocht ó MariaDB, MySQL 8.0.18+, agus PostgreSQL má tá spreagthaí ann nó má ghlaítear feidhm, fiú le haghaidh ceist SELECT.

Cuardaigh `Field`Link to this heading

Field lookups are how you specify the meat of an SQL WHERE clause. They're specified as keyword arguments to the QuerySet methods filter(), exclude() and get().

<field-lookups-intro>Le haghaidh réamhrá, féach:ref: `samhlacha agus doiciméadú ceisteanna bunachar sonraí `.

Tá cuardaigh ionsuite Django liostaithe thíos. Is féidir freisin a scríobh: doc: saincheaptha cuardach do réimsí samhail. </howto/custom-lookups>

Mar áisiúlacht nuair nach gcuirtear aon chineál cuardaigh ar fáil (cosúil le Entry.Objects.get (id=14) `) glactar leis gurb é an cineál cuardaigh: lookup: exact.

`cruthLink to this heading

Meaitseáil cruinn. Más é None an luach a sholáthraítear le haghaidh comparáide, léirmhínítear é mar SQL NULL (féach:lookup: isnull le haghaidh tuilleadh sonraí).

Samplaí:

Code

Entry.objects.get(id__exact=14)
Entry.objects.get(id__exact=None)

Coibhéisí SQL:

SQL

SELECT ... WHERE id = 14;
SELECT ... WHERE id IS NULL;

`iacr`Link to this heading

Meaitseáil cruinn neamh-íogair. Más é None an luach a sholáthraítear le haghaidh comparáide, léirmhínítear é mar SQL NULL (féach:lookup: isnull le haghaidh tuilleadh sonraí).

Sampla:

Code

Blog.objects.get(name__iexact="beatles blog")
Blog.objects.get(name__iexact=None)

Coibhéisí SQL:

SQL

SELECT ... WHERE name ILIKE 'beatles blog';
SELECT ... WHERE name IS NULL;

Tabhair faoi deara go mbeidh an chéad cheist ag teacht le 'Beatles Blog`, ``beatles blog `, Beatles Blog, srl.

`Coimeád`Link to this heading

Tástáil srianta cás-íogair.

Sampla:

Code

Entry.objects.get(headline__contains="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline LIKE '%Lennon%';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

Tabhair faoi deara go mbeidh sé seo comhoiriúnach leis an gceannteideal ```'Lennon onóir inneo' ``ach ní ````lennon onóir inneo'.

`Icontains`Link to this heading

Tástáil srianta cás-neamh-íogair.

Sampla:

Code

Entry.objects.get(headline__icontains="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline ILIKE '%Lennon%';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

Invalid section title or transition marker.Link to this heading

I athraitheach ar leith; go minic liosta, tuple, nó tacar fiosrúcháin. Ní cás úsáide coitianta é, ach glactar le teaghráin (atá inathraithe).

Samplaí:

Code

Entry.objects.filter(id__in=[1, 3, 4])
Entry.objects.filter(headline__in="abc")

Coibhéisí SQL:

SQL

SELECT ... WHERE id IN (1, 3, 4);
SELECT ... WHERE headline IN ('a', 'b', 'c');

Is féidir leat tacar ceisteanna a úsáid freisin chun liosta luachanna a mheas go dinimiciúil in ionad liosta de luachanna liteartha a sholáthar:

Code

inner_qs = Blog.objects.filter(name__contains="Cheddar")
entries = Entry.objects.filter(blog__in=inner_qs)

Déanfar an tacar ceisteanna seo a mheas mar ráiteas fo-roghnaithe:

SQL

SELECT ... WHERE blog.id IN (SELECT id FROM ... WHERE NAME LIKE '%Cheddar%')

Má théann tú isteach i QuerySet a eascraíonn as values () ``nó `values_list () mar luach chuig cuardach __in, ní mór duit a chinntiú nach bhfuil ach réimse amháin á bhaint agat sa toradh. Mar shampla, oibreoidh sé seo (scagadh ar ainmneacha an bhlag):

Code

inner_qs = Blog.objects.filter(name__contains="Ch").values("name")
entries = Entry.objects.filter(blog__name__in=inner_qs)

Ardóidh an sampla seo eisceacht, ós rud é go bhfuil an cheist istigh ag iarraidh dhá luach réimse a bhaint, áit nach bhfuiltear ag súil le ceann amháin:

Code

# Bad code! Will raise a TypeError.
inner_qs = Blog.objects.filter(name__contains="Ch").values("name", "id")
entries = Entry.objects.filter(blog__name__in=inner_qs)

Creithniúcháin

Bí cúramach faoi cheisteanna neadaithe a úsáid agus tuig tréithe feidhmíochta do fhreastalaí bunachar sonraí (má tá amhras ort, tagarmharc!). Ní dhéanann roinnt cúltaca bunachar sonraí, go háirithe MySQL, ceisteanna neadaithe a bharrfheabhsú go han-mhaith. Tá sé níos éifeachtaí, sna cásanna sin, liosta luachanna a bhaint agus ansin é a chur isteach sa dara ceist. Is é sin, déan dhá cheist a fhorghníomhú in ionad ceann amháin:

Code

values = Blog.objects.filter(name__contains="Cheddar").values_list("pk", flat=True)
entries = Entry.objects.filter(blog__in=list(values))

Tabhair faoi deara an ghlao list () ``timpeall an Blag ``QuerySet chun an chéad cheist a chur i bhfeidhm. Gan é, déanfaí ceist neadaithe a fhorghníomhú, toisc go ndéanfaí: ref: querysets-are-lazy.

`gt`Link to this heading

Níos mó ná.

Sampla:

Code

Entry.objects.filter(id__gt=4)

Coibhéis SQL:

SQL

SELECT ... WHERE id > 4;

`gte`Link to this heading

Níos mó ná nó comhionann leis.

`lt`Link to this heading

Níos lú ná.

`lteLink to this heading

Níos lú ná nó cothrom le.

``tosaíonn leis ``Link to this heading

Tosaíonn cás-íogair - le.

Sampla:

Code

Entry.objects.filter(headline__startswith="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline LIKE 'Lennon%';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

Ní thacaíonn SQLite le ráitis ``LIKE ``atá íogair ó cháis; gníomhaíonn ``startswith mar istartswith do SQLite.

``istartswith`Link to this heading

Tosaíonn cás-neamh-íogair - le.

Sampla:

Code

Entry.objects.filter(headline__istartswith="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline ILIKE 'Lennon%';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

``Críochnaíonn ``Link to this heading

Críochna cás-íogair - le.

Sampla:

Code

Entry.objects.filter(headline__endswith="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline LIKE '%Lennon';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

`IdirleithLink to this heading

Críochtaí cás-neamh-íogair - le.

Sampla:

Code

Entry.objects.filter(headline__iendswith="Lennon")

Coibhéis SQL:

SQL

SELECT ... WHERE headline ILIKE '%Lennon';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

``raon ``Link to this heading

Tástáil raon (cuimsitheach).

Sampla:

Code

import datetime

start_date = datetime.date(2005, 1, 1)
end_date = datetime.date(2005, 3, 31)
Entry.objects.filter(pub_date__range=(start_date, end_date))

Coibhéis SQL:

SQL

SELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31';

Is féidir leat raon ``a úsáid in áit ar bith is féidir leat ``BETWEEN a úsáid i SQL - le haghaidh dátaí, uimhreacha agus fiú carachtair.

Warning

Ní chuimsíonn scagadh DateTimefield` le dátaí míreanna ar an lá deiridh, toisc go léirmhínítear na teorainneacha mar “0am ar an dáta ar leith”. Dá mbeadh ``pub_date ina DateTimefield`, déanfaí an abairt thuas a iompú isteach sa SQL seo:

SQL

SELECT ... WHERE pub_date BETWEEN '2005-01-01 00:00:00' and '2005-03-31 00:00:00';

Go ginearálta, ní féidir leat dátaí agus dáta a mheascadh.

``Dáta ``Link to this heading

Maidir le réimsí dáta-am, caitheann an luach mar dháta. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach dáta.

Sampla:

Code

Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

Nuair: SETTING: Is é USE_TZ True, déantar réimsí a thiontú go dtí an crios ama reatha sula ndéantar iad a scagadh. <database-time-zone-definitions>Éilíonn sé seo: ref: `sainmhínithe crios ama sa bhunachar sonraí `.

`bliant`Link to this heading

Maidir le réimsí dáta agus dáta, cluiche bliana cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé bliain slámhshláir.

Sampla:

Code

Entry.objects.filter(pub_date__year=2005)
Entry.objects.filter(pub_date__year__gte=2005)

Coibhéis SQL:

SQL

SELECT ... WHERE pub_date BETWEEN '2005-01-01' AND '2005-12-31';
SELECT ... WHERE pub_date >= '2005-01-01';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

Nuair: Socrú: Is é USE_TZ True, déantar réimsí dáta-ama a thiontú go dtí an crios ama reatha sula ndéantar iad a scagadh. <database-time-zone-definitions>Éilíonn sé seo: ref: `sainmhínithe crios ama sa bhunachar sonraí `.

`iso_bliain`Link to this heading

Maidir le réimsí dáta agus dáta, comhoiriúnú bliana uimhrithe seachtaine cruinn ISO 8601. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé bliain slámhshláir.

Sampla:

Code

Entry.objects.filter(pub_date__iso_year=2005)
Entry.objects.filter(pub_date__iso_year__gte=2005)

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

`mhí`Link to this heading

Maidir le réimsí dáta agus dáta, cluiche míosa cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir 1 (Eanáir) trí 12 (Nollaig).

Sampla:

Code

Entry.objects.filter(pub_date__month=12)
Entry.objects.filter(pub_date__month__gte=6)

Coibhéis SQL:

SQL

SELECT ... WHERE EXTRACT('month' FROM pub_date) = '12';
SELECT ... WHERE EXTRACT('month' FROM pub_date) >= '6';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

`Lae`Link to this heading

Maidir le réimsí dáta agus dáta, cluiche lá cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé lá sláireach.

Sampla:

Code

Entry.objects.filter(pub_date__day=3)
Entry.objects.filter(pub_date__day__gte=3)

Coibhéis SQL:

SQL

SELECT ... WHERE EXTRACT('day' FROM pub_date) = '3';
SELECT ... WHERE EXTRACT('day' FROM pub_date) >= '3';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le dáta pub_date ar an tríú lá den mhí, mar shampla 3 Eanáir, 3 Iúil, srl.

`seachtaine`Link to this heading

Mai< https://en.wikipedia.org/wiki/ISO-8601> dir le réimsí dáta agus dáta, cuir ar ais uimhir na seachtaine (1-52 nó 53) de réir ISO-8601, ie, tosaíonn seachtainí Dé Luain agus tá an chéad Déardaoin na bliana sa chéad seachtain.

Sampla:

Code

Entry.objects.filter(pub_date__week=52)
Entry.objects.filter(pub_date__week__gte=32, pub_date__week__lte=38)

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

`Lae_na seachtaine`Link to this heading

Maidir le réimsí dáta agus dáta-am, cluiche 'lá na seachtaine'. Ligeann sé cuardaigh réimse breise a shlánú.

Tógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Dé Domhnaigh) go 7 (Dé Sathairn).

Sampla:

Code

Entry.objects.filter(pub_date__week_day=2)
Entry.objects.filter(pub_date__week_day__gte=2)

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le pub_date a thiteann Dé Luain (lá 2 den tseachtain), beag beann ar an mí nó an bhliain ina dtarlaíonn sé. Déantar laethanta na seachtaine a innéacsú agus lá 1 é Dé Domhnaigh agus lá 7 ina Dé Sathairn.

`Lae_iso_seachtaine`Link to this heading

Maidir le réimsí dáta agus dáta-am, cluiche cruinn lá ISO 8601 den tseachtain. Ligeann sé cuardaigh réimse breise a shlánú.

Tógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Luan) go 7 (Dé Domhnaigh).

Sampla:

Code

Entry.objects.filter(pub_date__iso_week_day=1)
Entry.objects.filter(pub_date__iso_week_day__gte=1)

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le pub_date a thiteann Dé Luain (lá 1 den tseachtain), beag beann ar an mí nó an bhliain ina dtarlaíonn sé. Déantar laethanta na seachtaine a innéacsú agus lá 1 é Dé Luan agus lá 7 é Dé Domhnaigh.

`Ráith`Link to this heading

Maidir le réimsí dáta agus dáta, cluiche 'ceathrú den bhliain'. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach sláimhir idir 1 agus 4 a léiríonn ráithe den bhliain.

Sampla chun iontrálacha a aisghabháil sa dara ráithe (1 Aibreán go 30 Meitheamh):

Code

Entry.objects.filter(pub_date__quarter=2)

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

``Am `Link to this heading

Maidir le réimsí dáta-ama, caitheann an luach mar am. Ligeann sé cuardaigh réimse breise a shlánú. Glacann sé: aicme: luach datetime.time.

Sampla:

Code

Entry.objects.filter(pub_date__time=datetime.time(14, 30))
Entry.objects.filter(pub_date__time__range=(datetime.time(8), datetime.time(17)))

(Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun

`uair an chloig`Link to this heading

Maidir le réimsí dáta agus ama, meaitseáil uair an chloig cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 23.

Sampla:

Code

Event.objects.filter(timestamp__hour=23)
Event.objects.filter(time__hour=5)
Event.objects.filter(timestamp__hour__gte=12)

Coibhéis SQL:

SQL

SELECT ... WHERE EXTRACT('hour' FROM timestamp) = '23';
SELECT ... WHERE EXTRACT('hour' FROM time) = '5';
SELECT ... WHERE EXTRACT('hour' FROM timestamp) >= '12';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

`nóiméad`Link to this heading

Maidir le réimsí dáta agus ama, cluiche beacht nóiméad. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 59.

Sampla:

Code

Event.objects.filter(timestamp__minute=29)
Event.objects.filter(time__minute=46)
Event.objects.filter(timestamp__minute__gte=29)

Coibhéis SQL:

SQL

SELECT ... WHERE EXTRACT('minute' FROM timestamp) = '29';
SELECT ... WHERE EXTRACT('minute' FROM time) = '46';
SELECT ... WHERE EXTRACT('minute' FROM timestamp) >= '29';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

``an dara `Link to this heading

Maidir le réimsí dáta agus ama, an dara cluiche cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 59.

Sampla:

Code

Event.objects.filter(timestamp__second=31)
Event.objects.filter(time__second=2)
Event.objects.filter(timestamp__second__gte=31)

Coibhéis SQL:

SQL

SELECT ... WHERE EXTRACT('second' FROM timestamp) = '31';
SELECT ... WHERE EXTRACT('second' FROM time) = '2';
SELECT ... WHERE EXTRACT('second' FROM timestamp) >= '31';

(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)

`isnull`Link to this heading

Glacann sé True nó False`, a fhreagraíonn do cheisteanna SQL de IS NULL` agus IS NOT NULL, faoi seach.

Sampla:

Code

Entry.objects.filter(pub_date__isnull=True)

Coibhéis SQL:

SQL

SELECT ... WHERE pub_date IS NULL;

`Regex`Link to this heading

Meaitseáil léirithe rialta íogair do chás-

Is é an comhréiteach abairt rialta ná cúltaca an bhunachar sonraí atá in úsáid. I gcás SQLite, nach bhfuil aon tacaíocht léirithe ionsuite aige, soláthraíonn feidhm REGEXP (Python) atá sainmhínithe ag úsáideoir an ghné seo, agus dá bhrí sin is é an comhréiteach abairt rialta modúl re` Python.

Sampla:

Code

Entry.objects.get(title__regex=r"^(An?|The) +")

Coibhéisí SQL:

SQL

SELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL

SELECT ... WHERE REGEXP_LIKE(title, '^(An?|The) +', 'c'); -- Oracle

SELECT ... WHERE title ~ '^(An?|The) +'; -- PostgreSQL

SELECT ... WHERE title REGEXP '^(An?|The) +'; -- SQLite

Moltar teaghráin amh a úsáid (m.sh., r'foo'` in ionad 'foo') chun comhréiteach an abairt rialta a chur isteach.

`iregex`Link to this heading

Meaitseáil léirithe rialta neamh-íogair.

Sampla:

Code

Entry.objects.get(title__iregex=r"^(an?|the) +")

Coibhéisí SQL:

SQL

SELECT ... WHERE title REGEXP '^(an?|the) +'; -- MySQL

SELECT ... WHERE REGEXP_LIKE(title, '^(an?|the) +', 'i'); -- Oracle

SELECT ... WHERE title ~* '^(an?|the) +'; -- PostgreSQL

SELECT ... WHERE title REGEXP '(?i)^(an?|the) +'; -- SQLite

Feidhmeanna comhiomlánLink to this heading

Soláthraíonn Django na feidhmeanna comhiomlánaithe seo a leanas sa mhodúl django.db.models. Le haghaidh sonraí maidir le conas na feidhmeanna comhiomlána seo a úsáid, féach:doc: an treoir ábhair ar chomhiomlán' </topics/db/aggregation>. Féach an doiciméadach:class: `~django.db.models.aggregate chun foghlaim conas do chomhiomláin a chruthú.

Tá na paraiméadair seo a leanas i gcoiteann ag gach comhiomlán:

`léiritheach`Link to this heading

Teagáin a thagraíonn réimsí ar an tsamhail, athraíonn an réimse, nó:doc: `abairtí fiosraitheach' </ref/models/expressions>.

`réimseach_aschuir`Link to this heading

Argóint roghnach a léiríonn na:doc: réimse samhail den luach tuairisceáin </ref/models/fields>

`Scagair`Link to this heading

Rud roghnach: class: `Q <django.db.models.Q>`a úsáidtear chun na sraitheanna atá comhiomlánaithe a scagadh.

Féach: ref: comhiomlánú coinníollach agus:ref: filtering-on-annotations mar shampla úsáid.

`réamhshocraithe`Link to this heading

Argóint roghnach a cheadaíonn luach a shonrú le húsáid mar luach réamhshocraithe nuair nach bhfuil aon iontrálacha sa tacar ceisteanna (nó an grúpáil).

`**breise`Link to this heading

Argóintí eochairfhocal ar féidir leo comhthéacs breise a sholáthar don SQL a ghineann an comhiomlán

`AnyValue`Link to this heading

class AnyValue(expression, output_field=None, filter=None, default=None, **extra)Link to this definition

Returns an arbitrary value from the non-null input values.

Default alias: <field>__anyvalue
Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

Sampla úsáide:

Python console

>>> # Get average rating for each year along with a sample headline
>>> # from that year.
>>> from django.db.models import AnyValue, Avg, F, Q
>>> sample_headline = AnyValue("headline")
>>> Entry.objects.values(
...     pub_year=F("pub_date__year"),
... ).annotate(
...     avg_rating=Avg("rating"),
...     sample_headline=sample_headline,
... )

>>> # Get a sample headline from each year with rating greater than 4.5.
>>> sample_headline = AnyValue(
...     "headline",
...     filter=Q(rating__gt=4.5),
... )
>>> Entry.objects.values(
...     pub_year=F("pub_date__year"),
... ).annotate(
...     avg_rating=Avg("rating"),
...     sample_headline=sample_headline,
... )

Supported on SQLite, MySQL, Oracle, and PostgreSQL 16+.

`Avg`Link to this heading

class Avg(expression, output_field=None, distinct=False, filter=None, default=None, **extra)Link to this definition

Tugann sé meánluach an abairt a thugtar ar ais, a chaithfidh a bheith uimhriúil mura sonraíonn tú ``output_field` difriúil.

<field>Ainm réamhshocraithe: __avg
Cineál tuairisceáin: float má tá an t-ionchur int, ar shlí eile mar an réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar fiosrúcháin nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

distinctLink to this definition: Roghnach. Má tá Distinct=True, filleann Avg meánluach na luachanna uathúla ar ais. <field>Is é seo an coibhéis SQL le ``AVG (DISTINCT) ``. Is é “False” an luach réamhshocraithe.

`Comhaireant`Link to this heading

class Count(expression, distinct=False, filter=None, **extra)Link to this definition

Tugann sé ar ais líon na rudaí a bhaineann tríd an abairt a chuirtear ar fáil. Tá Count ('*') ``comhionann leis an abairt SQL ``COUNT (*).

<field>Ainm réamhshocraithe: __count
Cineál tuairisceáin: int

distinctLink to this definition: Roghnach. Má tá Distinct=True`, ní chuimsíonn an comhaireamh ach cásanna uathúla. Is é seo an coibhéis SQL le ``COUNT (DISTINCT<field>) ``. Is é “False” an luach réamhshocraithe.

`Uasmhéad`Link to this heading

class Max(expression, output_field=None, filter=None, default=None, **extra)Link to this definition

Tugann sé luach uasta an léirithe a thugtar ar ais.

<field>Ainm réamhshocraithe: __max
Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

`Mion`Link to this heading

class Min(expression, output_field=None, filter=None, default=None, **extra)Link to this definition

Tugann sé luach íosta na léirithe tugtha ar ais.

<field>Ainm réamhshocraithe: __min
Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

`Stddev`Link to this heading

class StdDev(expression, output_field=None, sample=False, filter=None, default=None, **extra)Link to this definition

Tugann sé diall caighdeánach na sonraí san abairt a chuirtear ar fáil ar ais.

<field>Ainm réamhshocraithe: __stddev
Cineál tuairisceáin: float má tá an t-ionchur int, ar shlí eile mar an réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar fiosrúcháin nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

sampleLink to this definition: Roghnach. De réir réamhshocraithe, filleann stdDev an diall caighdeánach daonra ar ais. Mar sin féin, má tá sample=True, is é an luach tuairisceáin an diall caighdeánach samplach.

`Sum`Link to this heading

class Sum(expression, output_field=None, distinct=False, filter=None, default=None, **extra)Link to this definition

Ríomhann sé suim na luachanna uile den abairt ar leith.

<field>Ainm réamhshocraithe: __sum
Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

distinctLink to this definition: Roghnach. Má tá Distinct=True, filleann Sum suim na luachanna uathúla. Is é seo an coibhéis SQL le ``SUM (DISTINCT<field>) ``. Is é “False” an luach réamhshocraithe.

`Athraithe`Link to this heading

class Variance(expression, output_field=None, sample=False, filter=None, default=None, **extra)Link to this definition

Tugann sé athrú na sonraí san abairt a chuirtear ar fáil ar ais.

<field>Ainm réamhshocraithe: __variance
Cineál tuairisceáin: float má tá an t-ionchur int, ar shlí eile mar an réimse ionchuir, nó output_field má sholáthraítear. Má tá an tacar fiosrúcháin nó an grúpáil folamh, cuirtear réamhshocraithe ar ais.

sampleLink to this definition: Roghnach. De réir réamhshocraithe, filleann Athraitheacht ``an t-athrú daonra ar ais. Mar sin féin, má tá ``sample=True, is é an luach tuairisceáin an t-athrú samplach.

`Stringag`Link to this heading

class StringAgg(expression, delimiter, output_field=None, distinct=False, filter=None, order_by=None, default=None, **extra)Link to this definition

Filleann sé na luachanna ionchuir atá comhcheangailte i sreang, scartha leis an teaghrán delimiter, nó default mura bhfuil aon luachanna ann.

Default alias: <field>__stringagg
Return type: string or output_field if supplied. If the queryset or grouping is empty, default is returned.

delimiterLink to this definition: A Value or expression representing the string that should separate each of the values. For example, Value(",").

Uirlisí a bhaineann le fiosrúLink to this heading

Soláthraíonn an chuid seo ábhar tagartha d'uirlisí a bhaineann le fiosrúcháin nach ndéanfar

``Q () ``rudaíLink to this heading

class QLink to this definition

Léiríonn réad Q () ``riocht SQL is féidir a úsáid in oibríochtaí a bhaineann le bunachar sonraí. Tá sé cosúil leis an gcaoi a léiríonn réad an:class: `F () <django.db.models.F>`luach réimse samhail nó anótála. Déanann siad coinníollacha a shainiú agus a athúsáid. Is féidir iad seo a dhiúltú ag baint úsáide as an oibreoir ``~ (NOT ``), agus a chur le chéile ag baint úsáide as oibreoirí mar `| (OR), & (AND), agus ^ (XOR`). Féach: ref: complex-lookups-with-q.

``Prefetch () ``rudaíLink to this heading

class Prefetch(lookup, queryset=None, to_attr=None)Link to this definition

The Prefetch() object can be used to control the operation of prefetch_related().

The lookup argument describes the relations to follow and works the same as the string based lookups passed to prefetch_related(). For example:

Python console

>>> from django.db.models import Prefetch
>>> Question.objects.prefetch_related(Prefetch("choice_set")).get().choice_set.all()
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>
# This will only execute two queries regardless of the number of Question
# and Choice objects.
>>> Question.objects.prefetch_related(Prefetch("choice_set"))
<QuerySet [<Question: What's up?>]>

The queryset argument supplies a base QuerySet for the given lookup. This is useful to further filter down the prefetch operation, or to call select_related() from the prefetched relation, hence reducing the number of queries even further:

Python console

>>> voted_choices = Choice.objects.filter(votes__gt=0)
>>> voted_choices
<QuerySet [<Choice: The sky>]>
>>> prefetch = Prefetch("choice_set", queryset=voted_choices)
>>> Question.objects.prefetch_related(prefetch).get().choice_set.all()
<QuerySet [<Choice: The sky>]>

Socraíonn an argóint to_attr` toradh na hoibríochta réamhfhillte go tréith saincheaptha:

Python console

>>> prefetch = Prefetch("choice_set", queryset=voted_choices, to_attr="voted_choices")
>>> Question.objects.prefetch_related(prefetch).get().voted_choices
<QuerySet [<Choice: The sky>]>
>>> Question.objects.prefetch_related(prefetch).get().choice_set.all()
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>

``rudaí prefetch_gaolmhara () ``Link to this heading

prefetch_related_objects(model_instances, *related_lookups)Link to this definition

aprefetch_related_objects(model_instances, *related_lookups)Link to this definition

Asynchronous version: aprefetch_related_objects()

Faigheann sé na cuardaigh a thugtar roimh ré ar chásanna samhail atá inathraithe. Tá sé seo úsáideach sa chód a fhaigheann liosta de na cásanna samhail seachas ``QuerySet`; mar shampla, nuair a bhíonn samhlacha á bhfaigheann tú ó taisce nó iad ag instanciú de láimh.

Pass an iterable of model instances (must all be of the same class and able to be iterated multiple times) and the lookups or Prefetch objects you want to prefetch for. For example:

Python console

>>> from django.db.models import prefetch_related_objects
>>> restaurants = fetch_top_restaurants_from_cache()  # A list of Restaurants
>>> prefetch_related_objects(restaurants, "pizzas__toppings")

Agus bunachair sonraí iolracha á n-úsáid agat le prefetch_related_objects, úsáidfidh an ceist réamhfhreastail an bunachar sonraí a bhaineann leis an samhail samhail. Is féidir é seo a shárú trí thacar ceisteanna saincheaptha a úsáid i gcuardach gaolmhar.

``FilteredRelation () ``rudaíLink to this heading

class FilteredRelation(relation_name, *, condition=Q())Link to this definition

relation_nameLink to this definition: Ainm an réimse ar mhaith leat an gaol a scagadh air.

conditionLink to this definition: A: Aicme: ~ Django.db.Models.q in aghaidh an scagadh a rialú.

FilteredRelation is used with annotate() to create an ON clause when a JOIN is performed. It doesn't act on the default relationship but on the annotation name (pizzas_vegetarian in example below).

Mar shampla, chun bialanna a fháil a bhfuil pizzes vegetarian acu le `mozzarella san ainm:

Python console

>>> from django.db.models import FilteredRelation, Q
>>> Restaurant.objects.annotate(
...     pizzas_vegetarian=FilteredRelation(
...         "pizzas",
...         condition=Q(pizzas__vegetarian=True),
...     ),
... ).filter(pizzas_vegetarian__name__icontains="mozzarella")

Má tá líon mór píosaí ann, feidhmíonn an tacar ceisteanna seo níos fearr ná:

Python console

>>> Restaurant.objects.filter(
...     pizzas__vegetarian=True,
...     pizzas__name__icontains="mozzarella",
... )

toisc nach n-oibreoidh an scagadh i gclásal WHERE den chéad tacar fiosrúcháin ach ar phiotsaí vegetarian.

Ní thacaíonn FilteredRelation le:

: meth: .queryset.only agus:meth: ~.queryset.prefetch_related.
A: Class: ~django.contrib.contentTypes.Fields.GenericForeignKey oidhreachta ó mhúnla tuismitheora.

Tagairt API ``QuerySet ``Link to this heading#

Nuair a dhéantar meastóireacht a dhéanamh ar ``QuerySet`Link to this heading#

Picling `QuerySetsLink to this heading#

API QuerySetLink to this heading#

Modhanna a thugann QuerySets nua ar aisLink to this heading#

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

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

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

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

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

``droim () `Link to this heading#

``difriúil () ``Link to this heading#

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

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

``dátaí () ``Link to this heading#

``dáta-amanna () ``Link to this heading#

``aon cheann () `Link to this heading#

``gach () `Link to this heading#

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

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

``difríocht () ``Link to this heading#

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

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

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

``iarchur () `Link to this heading#

``amháin () `Link to this heading#

``ag baint úsáide as () `Link to this heading#

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

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

Oibreoirí a chuireann ar ais QuerySets nuaLink to this heading#

AGUS (``& ``)Link to this heading#

NÓ (|)Link to this heading#

XOR (^)Link to this heading#

Modhanna nach gcuireann ar ais QuerySetsLink to this heading#

``get () `Link to this heading#

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

``get_or_create () `Link to this heading#

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

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

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

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

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

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

Le cúrsaí taobh an fhreastalaíLink to this heading#

Gan cúrsaí taobh an fhreastalaíLink to this heading#

``is déanaí () ``Link to this heading#

``is luaithe () ``Link to this heading#

``chéad () `Link to this heading#

``deireanach () `Link to this heading#

``comhiomlán () ``Link to this heading#

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

tá ()Link to this heading#

``nuashonrú () ``Link to this heading#

Tacar ceisteanna ordaitheLink to this heading#

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

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

``mhínigh () ``Link to this heading#

Cuardaigh FieldLink to this heading#

`cruthLink to this heading#

iacrLink to this heading#

CoimeádLink to this heading#

IcontainsLink to this heading#

Invalid section title or transition marker.Link to this heading#

gtLink to this heading#

gteLink to this heading#

ltLink to this heading#

`lteLink to this heading#

``tosaíonn leis ``Link to this heading#

``istartswith`Link to this heading#

``Críochnaíonn ``Link to this heading#

`IdirleithLink to this heading#

``raon ``Link to this heading#

``Dáta ``Link to this heading#

bliantLink to this heading#

iso_bliainLink to this heading#

mhíLink to this heading#

LaeLink to this heading#

seachtaineLink to this heading#

Lae_na seachtaineLink to this heading#

Lae_iso_seachtaineLink to this heading#

Tagairt API ``QuerySet ``Link to this heading

Nuair a dhéantar meastóireacht a dhéanamh ar ``QuerySet`Link to this heading

Picling `QuerySetsLink to this heading

API `QuerySet`Link to this heading

Modhanna a thugann `QuerySet`s nua ar aisLink to this heading

``scagaire () ``Link to this heading

``eisiamh () ``Link to this heading

``annotate () ``Link to this heading

``alias () ``Link to this heading

``ord_by () ``Link to this heading

``droim () `Link to this heading

``difriúil () ``Link to this heading

``luachanna () ``Link to this heading

``liosta_luachanna () ``Link to this heading

``dátaí () ``Link to this heading

``dáta-amanna () ``Link to this heading

``aon cheann () `Link to this heading

``gach () `Link to this heading

``aontas () ``Link to this heading

``trasna () ``Link to this heading

``difríocht () ``Link to this heading

``roghnai_bhainteach () ``Link to this heading

``prefetch_related () ``Link to this heading

``breise () ``Link to this heading

``iarchur () `Link to this heading

``amháin () `Link to this heading

``ag baint úsáide as () `Link to this heading

``roghnaithe_for_nuashonraithe () ``Link to this heading

``amh () ``Link to this heading

Oibreoirí a chuireann ar ais `QuerySet`s nuaLink to this heading

AGUS (``& ``)Link to this heading

NÓ (`|`)Link to this heading

XOR (`^`)Link to this heading

Modhanna nach gcuireann ar ais `QuerySet`sLink to this heading

``get () `Link to this heading

``cruthaigh () ``Link to this heading

``get_or_create () `Link to this heading

``Update_or_create () ``Link to this heading

``bulk_create () ``Link to this heading

``bulk_update () ``Link to this heading

``comhaireamh () ``Link to this heading

``in_bulk () ``Link to this heading

``iterator () ``Link to this heading

Le cúrsaí taobh an fhreastalaíLink to this heading

Gan cúrsaí taobh an fhreastalaíLink to this heading

``is déanaí () ``Link to this heading

``is luaithe () ``Link to this heading

``chéad () `Link to this heading

``deireanach () `Link to this heading

``comhiomlán () ``Link to this heading

``ann () ``Link to this heading

`tá ()`Link to this heading

``nuashonrú () ``Link to this heading

Tacar ceisteanna ordaitheLink to this heading

``scrios () ``Link to this heading

``as_bainisteoir () ``Link to this heading

``mhínigh () ``Link to this heading

Cuardaigh `Field`Link to this heading

`cruthLink to this heading

`iacr`Link to this heading

`Coimeád`Link to this heading

`Icontains`Link to this heading

Invalid section title or transition marker.Link to this heading

`gt`Link to this heading

`gte`Link to this heading

`lt`Link to this heading

`lteLink to this heading

``tosaíonn leis ``Link to this heading

``istartswith`Link to this heading

``Críochnaíonn ``Link to this heading

`IdirleithLink to this heading

``raon ``Link to this heading

``Dáta ``Link to this heading

`bliant`Link to this heading

`iso_bliain`Link to this heading

`mhí`Link to this heading

`Lae`Link to this heading

`seachtaine`Link to this heading

`Lae_na seachtaine`Link to this heading

`Lae_iso_seachtaine`Link to this heading