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'.
\nGo 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
\nIs 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í:
for e in Entry.objects.all():\n print(e.headline)\nNó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.
\nAthrú asincrónaí. Is féidir QuerySet a athrú freisin trí async for:
async for e in Entry.objects.all():\n results.append(e)\nTá an taisce bunúsach céanna ag athraitheoirí sioncrónach agus asincrónach de QuerySets.
\nSliseach. 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.
\nPiccling/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.
\nliosta () . Meastóireacht a chur i bhfeidhm ar QuerySet trí `liosta () ``a ghlaoch air. Mar shampla:
entry_list = list(Entry.objects.all())\nbool () . 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:
if Entry.objects.filter(headline="Test"):\n print("There is at least one Entry with the headline Test")\nNó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.
\n`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.
\nMura 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:
>>> import pickle\n>>> query = pickle.loads(s) # Assuming 's' is the pickled string.\n>>> qs = MyModel.objects.all()\n>>> qs.query = query # Restore the original 'query'.\nIs 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.
QuerySetLink to this heading#Seo an dearbhú foirmiúil ar ``QuerySet ``:
\n<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ú:
True if the QuerySet is ordered — i.e. has an\norder_by() clause or a default ordering on the model.\nFalse otherwise.
An bunachar sonraí a úsáidfear má dhéantar an cheist seo a fhorghníomhú anois.
\nQuerySets 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.
\n\nFilleann 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.
\n<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.
\nFilleann 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 () ``.
\nNí 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 `:
\nEntry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline="Hello")\nI dtéarmaí SQL, déanann sé meastóireacht ar:
\nSELECT ...\nWHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello')\nNí 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”:
\nEntry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline="Hello")\nI dtéarmaí SQL, déanann sé meastóireacht ar:
\nSELECT ...\nWHERE NOT pub_date > '2005-1-3'\nAND NOT headline = 'Hello'\nTabhair faoi deara go bhfuil an dara sampla níos sriantacha.
\n<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.
\nAnnotates each object in the QuerySet with the provided list of query\nexpressions or Q objects.\nEach 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\nthe 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.
\nÚ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.
\nMar 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:
\n>>> from django.db.models import Count\n>>> q = Blog.objects.annotate(Count("entry"))\n# The name of the first blog\n>>> q[0].name\n'Blogasaurus'\n# The number of entries on the first blog\n>>> q[0].entry__count\n42\nNí 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ú:
>>> q = Blog.objects.annotate(number_of_entries=Count("entry"))\n# The number of entries on the first blog, using the name provided\n>>> q[0].number_of_entries\n42\nLe haghaidh plé domhain ar chomhiomlánú, féach:doc: `an treoir ábhair ar Chomhiomlán' </topics/db/aggregation>.
\nMar 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:
\n>>> from django.db.models import Count\n>>> blogs = Blog.objects.alias(entries=Count("entry")).filter(entries__gt=5)\nIs 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:
\nBlog.objects.alias(entries=Count("entry")).annotate(\n entries=F("entries"),\n).aggregate(Sum("entries"))\nIs 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.
\nDe 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:
\nEntry.objects.filter(pub_date__year=2005).order_by("-pub_date", "headline")\nOrdó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:
Entry.objects.order_by("?")\nNóta: ``order_by ('?') D'fhéadfadh ceisteanna ``a bheith daor agus mall, ag brath ar an gcúltaca bunachar sonraí atá á úsáid agat.
\nChun 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:
\nEntry.objects.order_by("blog__name", "headline")\n<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`:
\nEntry.objects.order_by("blog")\n... comhionann le:
\nEntry.objects.order_by("blog__id")\nDá mbeadh ordú = ['ainm'] ``ag `Blog, ansin bheadh an chéad tacar ceisteanna comhionann le:
Entry.objects.order_by("blog__name")\nIs 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:
\nEntry.objects.order_by(Coalesce("summary", "headline").desc())\nTá 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\ndistinct(). See the note in distinct() for an explanation of how\nrelated model ordering can change the expected results.
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.
\nIs 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:
\nEntry.objects.order_by(Lower("headline").desc())\nIf you don't want any ordering to be applied to a query, not even the default\nordering, 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:
Entry.objects.order_by("headline").order_by("pub_date")\nÚ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.
\nChun na cúig mhír “deireanach” a aisghabháil i tacar fiosrúcháin, d'fhéadfá seo a dhéanamh:
\nmy_queryset.reverse()[:5]\nTabhair 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.
\nAlso, note that reverse() should generally only be called on a QuerySet\nwhich has a defined ordering (e.g., when querying against a model which defines\na default ordering, or when using order_by()). If no such ordering is\ndefined for a given QuerySet, calling reverse() on it has no real\neffect (the ordering was undefined prior to calling reverse(), and will\nremain undefined afterward).
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 () `.
\n\nAr 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):
\n>>> Author.objects.distinct()\n<QuerySet [...]>\n>>> Entry.objects.order_by("pub_date").distinct("pub_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("blog").distinct("blog")\n<QuerySet [...]>\n>>> Entry.objects.order_by("author", "pub_date").distinct("author", "pub_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("blog__name", "mod_date").distinct("blog__name", "mod_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("author", "pub_date").distinct("author")\n<QuerySet [...]>\nTugann “QuerySet” ar ais foclóirí, seachas cásanna samhlacha, nuair a úsáidtear é mar athrá.
\nLéiríonn gach ceann de na foclóirí sin réad, agus na heochracha a fhreagraíonn d'ainmneacha tréithe rudaí samhail.
\nDéanann an sampla seo comparáid idir foclóirí ``luachanna () ``leis na gnáth-rudaí samhail:
\n# This list contains a Blog object.\n>>> Blog.objects.filter(name__startswith="Beatles")\n<QuerySet [<Blog: Beatles Blog>]>\n\n# This list contains a dictionary.\n>>> Blog.objects.filter(name__startswith="Beatles").values()\n<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>\nGlacann 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:
\n>>> Blog.objects.values()\n<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>\n>>> Blog.objects.values("id", "name")\n<QuerySet [{'id': 1, 'name': 'Beatles Blog'}]>\nGlacann an modh luachanna () ``argóintí eochairfhocal roghnacha freisin, ``**léiritheach, a chuirtear trí:meth: annotate:
>>> from django.db.models.functions import Lower\n>>> Blog.objects.values(lower_name=Lower("name"))\n<QuerySet [{'lower_name': 'beatles blog'}]>\nIs féidir leat úsáid a bhaint as ionsuite agus: doc: `cuardach saincheapaithe' ag ordú </howto/custom-lookups>. Mar shampla:
\n>>> from django.db.models import CharField\n>>> from django.db.models.functions import Lower\n>>> CharField.register_lookup(Lower)\n>>> Blog.objects.values("name__lower")\n<QuerySet [{'name__lower': 'beatles blog'}]>\nCuirtear 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:
\n>>> from django.db.models import Count\n>>> Blog.objects.values("entry__authors", entries=Count("entry"))\n<QuerySet [{'entry__authors': 1, 'entries': 20}, {'entry__authors': 1, 'entries': 13}]>\n>>> Blog.objects.values("entry__authors").annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors': 1, 'entries': 33}]>\nCúpla caolchúrsaíocht is fiú a lua:
\nMá 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:
\n>>> Entry.objects.values()\n<QuerySet [{'blog_id': 1, 'headline': 'First Entry', ...}, ...]>\n\n>>> Entry.objects.values("blog")\n<QuerySet [{'blog': 1}, ...]>\n\n>>> Entry.objects.values("blog_id")\n<QuerySet [{'blog_id': 1}, ...]>\nWhen using values() together with distinct(), be aware that\nordering can affect the results. See the note in distinct() for\ndetails.
If you use a values() clause after an extra() call,\nany fields defined by a select argument in the extra() must\nbe explicitly included in the values() call. Any extra() call\nmade after a values() call will have its extra selected fields\nignored.
Calling only() and defer() after values() doesn't make\nsense, 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:
\n>>> from django.db.models import CharField, Count\n>>> from django.db.models.functions import Lower\n>>> CharField.register_lookup(Lower)\n>>> Blog.objects.values("entry__authors__name__lower").annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\n>>> Blog.objects.values(entry__authors__name__lower=Lower("entry__authors__name")).annotate(\n... entries=Count("entry")\n... )\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\n>>> Blog.objects.annotate(entry__authors__name__lower=Lower("entry__authors__name")).values(\n... "entry__authors__name__lower"\n... ).annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\nTá 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ú.
\nMar 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:
Blog.objects.values().order_by("id")\nBlog.objects.order_by("id").values()\nIs 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.
\nIs 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:
>>> Blog.objects.values("name", "entry__headline")\n<QuerySet [{'name': 'My blog', 'entry__headline': 'An entry'},\n {'name': 'My blog', 'entry__headline': 'Another entry'}, ...]>\nTá 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:
\n>>> Entry.objects.values_list("id", "headline")\n<QuerySet [(1, 'First entry'), ...]>\n>>> from django.db.models.functions import Lower\n>>> Entry.objects.values_list("id", Lower("headline"))\n<QuerySet [(1, 'first entry'), ...]>\nMura 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:
>>> Entry.objects.values_list("id").order_by("id")\n<QuerySet[(1,), (2,), (3,), ...]>\n\n>>> Entry.objects.values_list("id", flat=True).order_by("id")\n<QuerySet [1, 2, 3, ...]>\nIs 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:
>>> Entry.objects.values_list("id", "headline", named=True)\n<QuerySet [Row(id=1, headline='First entry'), ...]>\nMá ú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.
\nMura 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.
\nIs é 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:
\n>>> Entry.objects.values_list("headline", flat=True).get(pk=1)\n'First entry'\nTá 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:
\n>>> Author.objects.values_list("name", "entry__headline")\n<QuerySet [('Noam Chomsky', 'Impressions of Gaza'),\n ('George Orwell', 'Why Socialists Do Not Believe in Fun'),\n ('George Orwell', 'In Defence of English Cooking'),\n ('Don Quixote', None)]>\nTá ú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.
\nAr 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:
\n>>> Entry.objects.values_list("authors")\n<QuerySet [('Noam Chomsky',), ('George Orwell',), (None,)]>\nFilleann 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í:
\n>>> Entry.objects.dates("pub_date", "year")\n[datetime.date(2005, 1, 1)]\n>>> Entry.objects.dates("pub_date", "month")\n[datetime.date(2005, 2, 1), datetime.date(2005, 3, 1)]\n>>> Entry.objects.dates("pub_date", "week")\n[datetime.date(2005, 2, 14), datetime.date(2005, 3, 14)]\n>>> Entry.objects.dates("pub_date", "day")\n[datetime.date(2005, 2, 20), datetime.date(2005, 3, 20)]\n>>> Entry.objects.dates("pub_date", "day", order="DESC")\n[datetime.date(2005, 3, 20), datetime.date(2005, 2, 20)]\n>>> Entry.objects.filter(headline__contains="Lennon").dates("pub_date", "day")\n[datetime.date(2005, 3, 20)]\nFilleann 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.
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í:
\n>>> Entry.objects.none()\n<QuerySet []>\n>>> from django.db.models.query import EmptyQuerySet\n>>> isinstance(Entry.objects.none(), EmptyQuerySet)\nTrue\nReturns a copy of the current QuerySet (or QuerySet subclass). This\ncan be useful in situations where you might want to pass in either a model\nmanager or a QuerySet and do further filtering on the result. After calling\nall() 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.
Úsáideann oibreoir UNION SQL chun torthaí dhá QuerySet` nó níos mó QuerySets a chomhcheangal. Mar shampla:
>>> qs1.union(qs2, qs3)\nNí 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:
>>> qs1 = Author.objects.values_list("name")\n>>> qs2 = Entry.objects.values_list("headline")\n>>> qs1.union(qs2).order_by("name")\nIn addition, only LIMIT, OFFSET, COUNT(*), ORDER BY, and\nspecifying columns (i.e. slicing, count(), exists(),\norder_by(), and values()/values_list()) are allowed\non the resulting QuerySet. Further, databases place restrictions on\nwhat operations are allowed in the combined queries. For example, most\ndatabases don't allow LIMIT or OFFSET in the combined queries.
Úsáideann oibreoir INTERSECT SQL chun na heilimintí roinnte de dhá QuerySet` nó níos mó QuerySets a thabhairt ar ais. Mar shampla:
>>> qs1.intersection(qs2, qs3)\nFéach: Meth: aont le haghaidh roinnt srianta.
\nÚ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:
>>> qs1.difference(qs2, qs3)\nFéach: Meth: aont le haghaidh roinnt srianta.
\nUaireanta, 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`.
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
\nSonraigh 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\nclause. It should be a dictionary mapping attribute names to SQL\nclauses to use to calculate that attribute.
Sampla:
\nEntry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})\nMar 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:
SELECT blog_entry.*, (pub_date > '2006-01-01') AS is_recent\nFROM blog_entry;\nTá 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:
Blog.objects.extra(\n select={\n "entry_count": "SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id"\n },\n)\nSa 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á:
\nSELECT blog_blog.*, (SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id) AS entry_count\nFROM blog_blog;\nTabhair 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.
\nI 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:
\nBlog.objects.extra(\n select={"a": "%s", "b": "%s"},\n select_params=("one", "two"),\n)\nMá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:
\nEntry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])\n... aistríonn (go garbh) go dtí an SQL seo a leanas:
\nSELECT * FROM blog_entry WHERE (foo='a' OR bar='a') AND (baz='a')\nBí 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.
\nDe 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ú.
\nordó_by
If you need to order the resulting queryset using some of the new\nfields or tables you have included via extra() use the order_by\nparameter to extra() and pass in a sequence of strings. These\nstrings should either be model fields (as in the normal\norder_by() method on querysets), of the form\ntable_name.column_name or an alias for a column that you specified\nin the select parameter to extra().
Mar shampla:
\nq = Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})\nq = q.extra(order_by=["-is_recent"])\nSó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).
\nParams
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:
\nEntry.objects.extra(where=["headline=%s"], params=["Lennon"])\nÚ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:
\nEntry.objects.extra(where=["headline='Lennon'"])\nGo maith:
\nEntry.objects.extra(where=["headline=%s"], params=["Lennon"])\nI 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í.
\nDéantar é seo trí ainmneacha na réimsí a chur ar aghaidh chun gan luchtú chuig ``defer () ``:
\nEntry.objects.defer("headline", "body")\nTabharfaidh 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).
\n\nIs féidir leat glaonna iolracha a dhéanamh chuig ``fiafraigh () ``. Cuireann gach glao réimsí nua leis an tacar iarchurtha:
\n# Defers both the body and headline fields.\nEntry.objects.defer("body").filter(rating=5).defer("headline")\nIs 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).
\nYou can defer loading of fields in related models (if the related models are\nloading via select_related()) by using the standard double-underscore\nnotation to separate related fields:
Blog.objects.select_related().defer("entry__headline", "entry__body")\nMás mian leat an tacar réimsí iarchurtha a ghlanadh, cuir None mar pharaiméadar chuig ``defer () ``:
# Load all fields immediately.\nmy_queryset.defer(None)\nSome fields in a model won't be deferred, even if you ask for them. You can\nnever defer the loading of the primary key. If you are using\nselect_related() to retrieve related models, you shouldn't defer the\nloading of the field that connects from the primary model to the related\none, doing so will result in an error.
Similarly, calling defer() (or its counterpart only()) including an\nargument from an aggregation (e.g. using the result of annotate())\ndoesn't make sense: doing so will raise an exception. The aggregated values\nwill always be fetched into the resulting queryset.
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.
\nMá 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ú.
\nCuir 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:
Person.objects.defer("age", "biography")\nPerson.objects.only("name")\nAon 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 () `:
\n# This will defer all fields except the headline.\nEntry.objects.only("body", "rating").only("headline")\nÓ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:
# Final result is that everything except "headline" is deferred.\nEntry.objects.only("headline", "body").defer("body")\n\n# Final result loads headline immediately.\nEntry.objects.defer("body").only("headline", "body")\nBaineann 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ú.
\nIs 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.
\nMar 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 () ``.
This method is for controlling which database the QuerySet will be\nevaluated against if you are using more than one database. The only argument\nthis method takes is the alias of a database, as defined in\nDATABASES.
Mar shampla:
\n# queries the database with the 'default' alias.\n>>> Entry.objects.all()\n\n# queries the database with the 'backup' alias\n>>> Entry.objects.using("backup")\nTugann 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:
\nfrom django.db import transaction\n\nentries = Entry.objects.select_for_update().filter(author=request.user)\nwith transaction.atomic():\n for entry in entries:\n ...\nNuair 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.
\nDe 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.
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:
\n>>> Person.objects.select_related("hometown").select_for_update()\nTraceback (most recent call last):\n...\ndjango.db.utils.NotSupportedError: FOR UPDATE cannot be applied to the nullable side of an outer join\nChun an srian sin a sheachaint, is féidir leat rudaí neall a eisiamh mura bhfuil cúram ort fúthu:
\n>>> Person.objects.select_related("hometown").select_for_update().exclude(hometown=None)\n<QuerySet [<Person: ...)>, ...]>\nTacaí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.
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.
\n\nQuerySets nuaLink to this heading#Ní mór do cheisteanna comhcheangailte an tsamhail chéanna a úsáid.
\nComhcheanglaí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:
\nModel.objects.filter(x=1) & Model.objects.filter(y=2)\nModel.objects.filter(x=1).filter(y=2)\nCoibhéis SQL:
\nSELECT ... 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:
\nModel.objects.filter(x=1) | Model.objects.filter(y=2)\nfrom django.db.models import Q\n\nModel.objects.filter(Q(x=1) | Q(y=2))\nCoibhéis SQL:
\nSELECT ... WHERE x=1 OR y=2\nNí oibríocht chomhlaitheach é |`, toisc go bhféadfar ceisteanna difriúla (cé go coibhéiseach) a ghiniúint.
\n^)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:
\nModel.objects.filter(x=1) ^ Model.objects.filter(y=2)\nfrom django.db.models import Q\n\nModel.objects.filter(Q(x=1) ^ Q(y=2))\nCoibhéis SQL:
\nSELECT ... WHERE x=1 XOR y=2\nQuerySetsLink 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.
\nToisc 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.
\nLeagan asincrón: ``aget () ``
\nFilleann 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:
\nEntry.objects.get(id=1)\nEntry.objects.get(Q(blog=blog) & Q(entry_number=1))\nMá 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:
\nEntry.objects.filter(pk=1).get()\n<django.db.models.Model.DoesNotExist>Mura bhfaigheann ``get () ``aon rud, ardaíonn sé: exc: `Model.doesNotExist `eisceacht:
\nEntry.objects.get(id=-999) # raises Entry.DoesNotExist\n<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:
\nEntry.objects.get(name="A Duplicated Name") # raises Entry.MultipleObjectsReturned\nIs 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:
\nfrom django.core.exceptions import ObjectDoesNotExist\n\ntry:\n blog = Blog.objects.get(id=1)\n entry = Entry.objects.get(blog=blog, entry_number=1)\nexcept ObjectDoesNotExist:\n print("Either the blog or entry doesn't exist.")\nAsynchronous version: acreate()
A convenience method for creating an object and saving it all in one step.\nThus:
\np = Person.objects.create(first_name="Bruce", last_name="Springsteen")\nagus:
\np = Person(first_name="Bruce", last_name="Springsteen")\np.save(force_insert=True)\niad coibhéiseach.
\nTá 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.
\nLeagan asincrón: ``aget_or_create () ``
\nModh á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á.
\nFilleann 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:
\ntry:\n obj = Person.objects.get(first_name="John", last_name="Lennon")\nexcept Person.DoesNotExist:\n obj = Person(first_name="John", last_name="Lennon", birthday=date(1940, 10, 9))\n obj.save()\nAnseo, 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:
\nobj, created = Person.objects.get_or_create(\n first_name="John",\n last_name="Lennon",\n defaults={"birthday": date(1940, 10, 9)},\n)\nAny keyword arguments passed to get_or_create() — except an optional one\ncalled defaults — will be used in a get() call. If an object is\nfound, 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:
from django.db.models import Q\n\nobj, created = Person.objects.filter(\n Q(first_name="Bob") | Q(first_name="Robert"),\n).get_or_create(last_name="Marley", defaults={"first_name": "Bob"})\nMá 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:
params = {k: v for k, v in kwargs.items() if "__" not in k}\nparams.update({k: v() if callable(v) else v for k, v in defaults.items()})\nobj = self.model(**params)\nobj.save()\nI 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:
Foo.objects.get_or_create(defaults__exact="bar", defaults={"defaults": "baz"})\nThe get_or_create() method has similar error behavior to create()\nwhen you're using manually specified primary keys. If an object needs to be\ncreated and the key already exists in the database, an\nIntegrityError 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.
Leagan asincrón: ``aupdate_or_create () ``
\nModh á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.
\nTá sé seo i gceist mar aicearra chuig cód boilerplatish. Mar shampla:
\ndefaults = {"first_name": "Bob"}\ncreate_defaults = {"first_name": "Bob", "birthday": date(1940, 10, 9)}\ntry:\n obj = Person.objects.get(first_name="John", last_name="Lennon")\n for key, value in defaults.items():\n setattr(obj, key, value)\n obj.save()\nexcept Person.DoesNotExist:\n new_values = {"first_name": "John", "last_name": "Lennon"}\n new_values.update(create_defaults)\n obj = Person(**new_values)\n obj.save()\nÉ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:
\nobj, created = Person.objects.update_or_create(\n first_name="John",\n last_name="Lennon",\n defaults={"first_name": "Bob"},\n create_defaults={"first_name": "Bob", "birthday": date(1940, 10, 9)},\n)\nLe haghaidh tuairisc mhionsonraithe ar an gcaoi a réitear ainmneacha a rith in kwargs`, féach:meth: get_or_create.
\nMar 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í.
\nCosú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.
\nAsynchronous 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:
\n>>> objs = Entry.objects.bulk_create(\n... [\n... Entry(headline="This is a test"),\n... Entry(headline="This is only a test"),\n... ]\n... )\nTá roinnt rabhaidh aige seo áfach:
\nNí 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\na db_default value, and ignore_conflicts\nis False, the primary key attribute can only be retrieved on certain\ndatabases (currently PostgreSQL, MariaDB, and SQLite 3.35+). On other\ndatabases, 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í:
from itertools import islice\n\nbatch_size = 100\nobjs = (Entry(headline="Test %s" % i) for i in range(1000))\nwhile True:\n batch = list(islice(objs, batch_size))\n if not batch:\n break\n Entry.objects.bulk_create(batch, batch_size)\nThe batch_size parameter controls how many objects are created in a single\nquery. The default is to create as many objects in one batch as the database\nwill 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).
\n\nAsynchronous 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
\n>>> objs = [\n... Entry.objects.create(headline="Entry 1"),\n... Entry.objects.create(headline="Entry 2"),\n... ]\n>>> objs[0].headline = "This is entry 1"\n>>> objs[1].headline = "This is entry 2"\n>>> Entry.objects.bulk_update(objs, ["headline"])\n2\n: 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:
\nNí 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()\nprepares all of the WHEN clauses for every object across all batches\nbefore executing any queries. This can require more memory than expected. To\nreduce memory usage, you can use an approach like this:
from itertools import islice\n\nbatch_size = 100\nids_iter = iter(range(1000))\nwhile ids := list(islice(ids_iter, batch_size)):\n batch = Entry.objects.filter(id__in=ids)\n for entry in batch:\n entry.headline = f"Updated headline {entry.pk}"\n Entry.objects.bulk_update(batch, ["headline"], batch_size=batch_size)\nBeidh 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.
Asynchronous version: acount()
Filleann sé sláimhir a léiríonn líon na rudaí sa bhunachar sonraí a mheaitseann leis an QuerySet.
Sampla:
\n# Returns the total number of entries in the database.\nEntry.objects.count()\n\n# Returns the number of entries whose headline contains 'Lennon'\nEntry.objects.filter(headline__contains="Lennon").count()\nDé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.
\nAsynchronous 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:
\n>>> Blog.objects.in_bulk([1])\n{1: <Blog: Beatles Blog>}\n>>> Blog.objects.in_bulk([1, 2])\n{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>}\n>>> Blog.objects.in_bulk([])\n{}\n>>> Blog.objects.in_bulk()\n{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>, 3: <Blog: Django Weblog>}\n>>> Blog.objects.in_bulk(["beatles_blog"], field_name="slug")\n{'beatles_blog': <Blog: Beatles Blog>}\n>>> Blog.objects.distinct("name").in_bulk(field_name="name")\n{'Beatles Blog': <Blog: Beatles Blog>, 'Cheddar Talk': <Blog: Cheddar Talk>, 'Django Weblog': <Blog: Django Weblog>}\nMá chuireann tú liosta folamh ar ``in_bulk () ``, gheobhaidh tú foclóir folamh.
\nAsynchronous 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\nevaluations do not result in additional queries. In contrast, iterator()\nwill read results directly, without doing any caching at the QuerySet\nlevel. For a QuerySet which returns a large number of objects that you\nonly need to access once, this can result in better performance and a\nsignificant 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`.
\nAg 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
\nÚ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.
\nÚsáideann tiománaí bunachar sonraí Oracle cúrsóirí taobh an fhreastalaí
\nLe 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
\nNí 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.
\nIs 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.
\nRialaí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`_:
\n\n\nAg 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.
\n
Leagan asincrón: ``alatest () ``
\nTugann sé an réad is déanaí sa tábla ar ais bunaithe ar na réimsí (í) ar leith.
\nTugann an sampla seo an Entry` is déanaí sa tábla, de réir réimse pub_date:
Entry.objects.latest("pub_date")\nIs 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:
Entry.objects.latest("pub_date", "-expire_date")\nCiallaí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\nDoesNotExist if there is no object with the\ngiven parameters.
Tabhair faoi deara go bhfuil is luaithe () ``agus ``is déanaí () ann ach ar mhaithe le háisiúlacht agus inléiteacht.
Leagan asincrón: ``aearly () ``
\nOibríonn sé ar shlí eile cosúil:meth: ~django.db.models.query.queryset.latest ach amháin go n-athraítear an treo.
\nLeagan asincrón: ``first () `
\nFilleann 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:
\np = Article.objects.order_by("title", "pub_date").first()\nTabhair faoi deara gur modh áisiúlachta é ``first () `, tá an sampla cód seo a leanas comhionann leis an sampla thuas:
\ntry:\n p = Article.objects.order_by("title", "pub_date")[0]\nexcept IndexError:\n p = None\nLeagan asincrón: ``alast () ``
\nWorks like first(), but returns the last object in the queryset.
Leagan asincrón: ``aaggregate () ``
\nTugann 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.
\nDé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ú.
\nÚ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
\nMar 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:
\n>>> from django.db.models import Count\n>>> Blog.objects.aggregate(Count("entry__authors"))\n{'entry__authors__count': 16}\nTrí 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ú:
\n>>> Blog.objects.aggregate(number_of_authors=Count("entry__authors"))\n{'number_of_authors': 16}\nLe haghaidh plé domhain ar chomhiomlánú, féach:doc: `an treoir ábhair ar Chomhiomlán' </topics/db/aggregation>.
\nLeagan asincrón: ``aexists () ``
\nTugann 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\nany objects in a QuerySet, particularly in the context of a large\nQuerySet.
Chun a fháil amach an bhfuil aon earraí i tacar fiosrúcháin:
\nif some_queryset.exists():\n print("There is at least one object in some_queryset")\nCé a bheidh níos gasta ná:
\nif some_queryset:\n print("There is at least one object in some_queryset")\n... 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).
\nIna 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.
\ntá ()Link to this heading#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\nQuerySet, particularly in the context of a large QuerySet.
Chun a sheiceáil an bhfuil mír ar leith i tacar fiosrúcháin:
\nif some_queryset.contains(obj):\n print("Entry contained in queryset")\nBeidh 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:
\nif obj in some_queryset:\n print("Entry contained in queryset")\nCosú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.
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
\nMar shampla, chun tuairimí a mhúchadh do gach iontráil blag a foilsíodh in 2010, d'fhéadfá é seo a dhéanamh:
\n>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)\n(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ú:
>>> Entry.objects.filter(pub_date__year=2010).update(\n... comments_on=False, headline="This is old"\n... )\nCuirtear 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:
\n>>> Entry.objects.update(blog__name="foo") # Won't work!\nIs féidir scagadh bunaithe ar réimsí gaolmhara fós, áfach:
\n>>> Entry.objects.filter(blog__id=1).update(comments_on=True)\nNí féidir leat glaoch ar ``update () ``ar a:class: .QuerySet a bhfuil slisnas tógtha nó nach féidir é a scagadh a thuilleadh.
\nTugann an modh ``update () ``líon na sraitheanna atá buailte ar ais:
\n>>> Entry.objects.filter(id=64).update(comments_on=True)\n1\n\n>>> Entry.objects.filter(slug="nonexistent-slug").update(comments_on=True)\n0\n\n>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)\n132\nMura 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:
\ne = Entry.objects.get(id=10)\ne.comments_on = False\ne.save()\n... déan seo:
\nEntry.objects.filter(id=10).update(comments_on=False)\nCuireann ú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,\ndoes not call any save() methods on your models, nor does it emit the\npre_save or\npost_save signals (which are a consequence of\ncalling Model.save()). If you want to\nupdate a bunch of records for a model that has a custom\nsave() method, loop over them and call\nsave(), like this:
for e in Entry.objects.filter(pub_date__year=2010):\n e.comments_on = False\n e.save()\nNí 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:
Entry.objects.order_by("-number").update(number=F("number") + 1)\nLeagan asincrón: ``adelete () ``
\nDé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.
\nCuirtear 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.
\nMar shampla, chun na hiontrálacha go léir i mblag áirithe a scriosadh:
\n>>> b = Blog.objects.get(pk=1)\n\n# Delete all the entries belonging to this Blog.\n>>> Entry.objects.filter(blog=b).delete()\n(4, {'blog.Entry': 2, 'blog.Entry_authors': 2})\nDe 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:
>>> blogs = Blog.objects.all()\n\n# This will delete all Blogs and all of their Entry objects.\n>>> blogs.delete()\n(5, {'blog.Blog': 1, 'blog.Entry': 2, 'blog.Entry_authors': 2})\nIs 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.
\nDé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.
\nNí chuireann ForeignKeys atá socraithe to:attr: ~django.db.models.foreignkey.on_delete DO_NOTHING` cosc ar an gcosán tapa a ghlacadh le scriosadh.
\nTabhair faoi deara gur mionsonraí cur chun feidhme iad na ceisteanna a ghintear i scriosadh réada faoi réir athraithe.
\nModh 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.
\nLeagan asincrónaithe: ``aexample () ``
\nTugann 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
\nMar shampla, agus PostgreSQL á úsáid agat:
\n>>> print(Blog.objects.filter(title="My Blog").explain())\nSeq Scan on blog (cost=0.00..35.50 rows=10 width=12)\n Filter: (title = 'My Blog'::bpchar)\nTá difríocht shuntasach idir bunachair sonraí an aschur.
\nTacaíonn gach cúltaca bunachar sonraí ionsuite le ``explain () ``ach amháin Oracle toisc nach bhfuil cur i bhfeidhm ann simplí.
\nThe format parameter changes the output format from the database's\ndefault, which is usually text-based. PostgreSQL supports 'TEXT',\n'JSON', 'YAML', and 'XML' formats. MariaDB and MySQL support\n'TEXT' (also called 'TRADITIONAL') and 'JSON' formats. MySQL\n8.0.16+ also supports an improved 'TREE' format, which is similar to\nPostgreSQL'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:
\n>>> print(Blog.objects.filter(title="My Blog").explain(verbose=True, analyze=True))\nSeq Scan on public.blog (cost=0.00..35.50 rows=10 width=12) (actual time=0.004..0.004 rows=10 loops=1)\n Output: id, title\n Filter: (blog.title = 'My Blog'::bpchar)\nPlanning time: 0.064 ms\nExecution time: 0.058 ms\nAr 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.
FieldLink to this heading#Field lookups are how you specify the meat of an SQL WHERE clause. They're\nspecified as keyword arguments to the QuerySet methods filter(),\nexclude() and get().
<field-lookups-intro>Le haghaidh réamhrá, féach:ref: `samhlacha agus doiciméadú ceisteanna bunachar sonraí `.
\nTá cuardaigh ionsuite Django liostaithe thíos. Is féidir freisin a scríobh: doc: saincheaptha cuardach do réimsí samhail. </howto/custom-lookups>
\nMar á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.
\n`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í:
\nEntry.objects.get(id__exact=14)\nEntry.objects.get(id__exact=None)\nCoibhéisí SQL:
\nSELECT ... WHERE id = 14;\nSELECT ... WHERE id IS NULL;\niacrLink 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:
\nBlog.objects.get(name__iexact="beatles blog")\nBlog.objects.get(name__iexact=None)\nCoibhéisí SQL:
\nSELECT ... WHERE name ILIKE 'beatles blog';\nSELECT ... WHERE name IS NULL;\nTabhair faoi deara go mbeidh an chéad cheist ag teacht le 'Beatles Blog`, ``beatles blog `, Beatles Blog, srl.
CoimeádLink to this heading#Tástáil srianta cás-íogair.
\nSampla:
\nEntry.objects.get(headline__contains="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline LIKE '%Lennon%';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nTabhair faoi deara go mbeidh sé seo comhoiriúnach leis an gceannteideal ```'Lennon onóir inneo' ``ach ní ````lennon onóir inneo'.
\n\nIcontainsLink to this heading#Tástáil srianta cás-neamh-íogair.
\nSampla:
\nEntry.objects.get(headline__icontains="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline ILIKE '%Lennon%';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\n\nI 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).
\nSamplaí:
\nEntry.objects.filter(id__in=[1, 3, 4])\nEntry.objects.filter(headline__in="abc")\nCoibhéisí SQL:
\nSELECT ... WHERE id IN (1, 3, 4);\nSELECT ... WHERE headline IN ('a', 'b', 'c');\nIs 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:
\ninner_qs = Blog.objects.filter(name__contains="Cheddar")\nentries = Entry.objects.filter(blog__in=inner_qs)\nDéanfar an tacar ceisteanna seo a mheas mar ráiteas fo-roghnaithe:
\nSELECT ... WHERE blog.id IN (SELECT id FROM ... WHERE NAME LIKE '%Cheddar%')\nMá 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):
inner_qs = Blog.objects.filter(name__contains="Ch").values("name")\nentries = Entry.objects.filter(blog__name__in=inner_qs)\nArdó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:
\n# Bad code! Will raise a TypeError.\ninner_qs = Blog.objects.filter(name__contains="Ch").values("name", "id")\nentries = Entry.objects.filter(blog__name__in=inner_qs)\ngtLink to this heading#Níos mó ná.
\nSampla:
\nEntry.objects.filter(id__gt=4)\nCoibhéis SQL:
\nSELECT ... WHERE id > 4;\ngteLink to this heading#Níos mó ná nó comhionann leis.
\nltLink to this heading#Níos lú ná.
\n`lteLink to this heading#Níos lú ná nó cothrom le.
\nTosaíonn cás-íogair - le.
\nSampla:
\nEntry.objects.filter(headline__startswith="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline LIKE 'Lennon%';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNí thacaíonn SQLite le ráitis ``LIKE ``atá íogair ó cháis; gníomhaíonn ``startswith mar istartswith do SQLite.
\nTosaíonn cás-neamh-íogair - le.
\nSampla:
\nEntry.objects.filter(headline__istartswith="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline ILIKE 'Lennon%';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\n\nCríochna cás-íogair - le.
\nSampla:
\nEntry.objects.filter(headline__endswith="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline LIKE '%Lennon';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\n\n`IdirleithLink to this heading#Críochtaí cás-neamh-íogair - le.
\nSampla:
\nEntry.objects.filter(headline__iendswith="Lennon")\nCoibhéis SQL:
\nSELECT ... WHERE headline ILIKE '%Lennon';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\n\nTástáil raon (cuimsitheach).
\nSampla:
\nimport datetime\n\nstart_date = datetime.date(2005, 1, 1)\nend_date = datetime.date(2005, 3, 31)\nEntry.objects.filter(pub_date__range=(start_date, end_date))\nCoibhéis SQL:
\nSELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31';\nIs 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.
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.
\nSampla:
\nEntry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))\nEntry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))\n(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
\nNuair: 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í `.
bliantLink 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.
\nSampla:
\nEntry.objects.filter(pub_date__year=2005)\nEntry.objects.filter(pub_date__year__gte=2005)\nCoibhéis SQL:
\nSELECT ... WHERE pub_date BETWEEN '2005-01-01' AND '2005-12-31';\nSELECT ... WHERE pub_date >= '2005-01-01';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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_bliainLink 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.
\nSampla:
\nEntry.objects.filter(pub_date__iso_year=2005)\nEntry.objects.filter(pub_date__iso_year__gte=2005)\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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í `.
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).
\nSampla:
\nEntry.objects.filter(pub_date__month=12)\nEntry.objects.filter(pub_date__month__gte=6)\nCoibhéis SQL:
\nSELECT ... WHERE EXTRACT('month' FROM pub_date) = '12';\nSELECT ... WHERE EXTRACT('month' FROM pub_date) >= '6';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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í `.
LaeLink 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.
\nSampla:
\nEntry.objects.filter(pub_date__day=3)\nEntry.objects.filter(pub_date__day__gte=3)\nCoibhéis SQL:
\nSELECT ... WHERE EXTRACT('day' FROM pub_date) = '3';\nSELECT ... WHERE EXTRACT('day' FROM pub_date) >= '3';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nTabhair 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.
\nNuair: 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í `.
seachtaineLink 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.
\nSampla:
\nEntry.objects.filter(pub_date__week=52)\nEntry.objects.filter(pub_date__week__gte=32, pub_date__week__lte=38)\n(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
\nNuair: 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í `.
Lae_na seachtaineLink 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ú.
\nTógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Dé Domhnaigh) go 7 (Dé Sathairn).
\nSampla:
\nEntry.objects.filter(pub_date__week_day=2)\nEntry.objects.filter(pub_date__week_day__gte=2)\n(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
\nTabhair 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.
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í `.
Lae_iso_seachtaineLink 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ú.
\nTógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Luan) go 7 (Dé Domhnaigh).
\nSampla:
\nEntry.objects.filter(pub_date__iso_week_day=1)\nEntry.objects.filter(pub_date__iso_week_day__gte=1)\n(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
\nTabhair 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.
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í `.
RáithLink 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.
\nSampla chun iontrálacha a aisghabháil sa dara ráithe (1 Aibreán go 30 Meitheamh):
\nEntry.objects.filter(pub_date__quarter=2)\n(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
\nNuair: 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í `.
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.
\nSampla:
\nEntry.objects.filter(pub_date__time=datetime.time(14, 30))\nEntry.objects.filter(pub_date__time__range=(datetime.time(8), datetime.time(17)))\n(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
\nNuair: 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í `.
uair an chloigLink 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.
\nSampla:
\nEvent.objects.filter(timestamp__hour=23)\nEvent.objects.filter(time__hour=5)\nEvent.objects.filter(timestamp__hour__gte=12)\nCoibhéis SQL:
\nSELECT ... WHERE EXTRACT('hour' FROM timestamp) = '23';\nSELECT ... WHERE EXTRACT('hour' FROM time) = '5';\nSELECT ... WHERE EXTRACT('hour' FROM timestamp) >= '12';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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í `.
nóiméadLink 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.
\nSampla:
\nEvent.objects.filter(timestamp__minute=29)\nEvent.objects.filter(time__minute=46)\nEvent.objects.filter(timestamp__minute__gte=29)\nCoibhéis SQL:
\nSELECT ... WHERE EXTRACT('minute' FROM timestamp) = '29';\nSELECT ... WHERE EXTRACT('minute' FROM time) = '46';\nSELECT ... WHERE EXTRACT('minute' FROM timestamp) >= '29';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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í `.
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.
\nSampla:
\nEvent.objects.filter(timestamp__second=31)\nEvent.objects.filter(time__second=2)\nEvent.objects.filter(timestamp__second__gte=31)\nCoibhéis SQL:
\nSELECT ... WHERE EXTRACT('second' FROM timestamp) = '31';\nSELECT ... WHERE EXTRACT('second' FROM time) = '2';\nSELECT ... WHERE EXTRACT('second' FROM timestamp) >= '31';\n(Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.)
\nNuair: 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í `.
isnullLink to this heading#Glacann sé True nó False`, a fhreagraíonn do cheisteanna SQL de IS NULL` agus IS NOT NULL, faoi seach.
Sampla:
\nEntry.objects.filter(pub_date__isnull=True)\nCoibhéis SQL:
\nSELECT ... WHERE pub_date IS NULL;\nRegexLink to this heading#Meaitseáil léirithe rialta íogair do chás-
\nIs é 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.
\nSampla:
\nEntry.objects.get(title__regex=r"^(An?|The) +")\nCoibhéisí SQL:
\nSELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL\n\nSELECT ... WHERE REGEXP_LIKE(title, '^(An?|The) +', 'c'); -- Oracle\n\nSELECT ... WHERE title ~ '^(An?|The) +'; -- PostgreSQL\n\nSELECT ... WHERE title REGEXP '^(An?|The) +'; -- SQLite\nMoltar teaghráin amh a úsáid (m.sh., r'foo'` in ionad 'foo') chun comhréiteach an abairt rialta a chur isteach.
iregexLink to this heading#Meaitseáil léirithe rialta neamh-íogair.
\nSampla:
\nEntry.objects.get(title__iregex=r"^(an?|the) +")\nCoibhéisí SQL:
\nSELECT ... WHERE title REGEXP '^(an?|the) +'; -- MySQL\n\nSELECT ... WHERE REGEXP_LIKE(title, '^(an?|the) +', 'i'); -- Oracle\n\nSELECT ... WHERE title ~* '^(an?|the) +'; -- PostgreSQL\n\nSELECT ... WHERE title REGEXP '(?i)^(an?|the) +'; -- SQLite\nSolá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:
\nléiritheachLink 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>.
\nréimseach_aschuirLink to this heading#Argóint roghnach a léiríonn na:doc: réimse samhail den luach tuairisceáin </ref/models/fields>
\n\nScagairLink to this heading#Rud roghnach: class: `Q <django.db.models.Q>`a úsáidtear chun na sraitheanna atá comhiomlánaithe a scagadh.
\nFéach: ref: comhiomlánú coinníollach agus:ref: filtering-on-annotations mar shampla úsáid.
\nréamhshocraitheLink 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).
\n**breiseLink to this heading#Argóintí eochairfhocal ar féidir leo comhthéacs breise a sholáthar don SQL a ghineann an comhiomlán
\nAnyValueLink to this heading#Returns an arbitrary value from the non-null input values.
\nDefault 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:
\n>>> # Get average rating for each year along with a sample headline\n>>> # from that year.\n>>> from django.db.models import AnyValue, Avg, F, Q\n>>> sample_headline = AnyValue("headline")\n>>> Entry.objects.values(\n... pub_year=F("pub_date__year"),\n... ).annotate(\n... avg_rating=Avg("rating"),\n... sample_headline=sample_headline,\n... )\n\n>>> # Get a sample headline from each year with rating greater than 4.5.\n>>> sample_headline = AnyValue(\n... "headline",\n... filter=Q(rating__gt=4.5),\n... )\n>>> Entry.objects.values(\n... pub_year=F("pub_date__year"),\n... ).annotate(\n... avg_rating=Avg("rating"),\n... sample_headline=sample_headline,\n... )\nSupported on SQLite, MySQL, Oracle, and PostgreSQL 16+.
\n\nAvgLink to this heading#Tugann sé meánluach an abairt a thugtar ar ais, a chaithfidh a bheith uimhriúil mura sonraíonn tú ``output_field` difriúil.
\n<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.
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.
ComhaireantLink to this heading#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
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.
\nUasmhéadLink to this heading#Tugann sé luach uasta an léirithe a thugtar ar ais.
\n<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.
MionLink to this heading#Tugann sé luach íosta na léirithe tugtha ar ais.
\n<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.
StddevLink to this heading#Tugann sé diall caighdeánach na sonraí san abairt a chuirtear ar fáil ar ais.
\n<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.
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.
SumLink to this heading#Ríomhann sé suim na luachanna uile den abairt ar leith.
\n<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.
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.
AthraitheLink to this heading#Tugann sé athrú na sonraí san abairt a chuirtear ar fáil ar ais.
\n<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.
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.
StringagLink to this heading#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\nqueryset or grouping is empty, default is returned.
A Value or expression representing the string that should separate\neach of the values. For example, Value(",").