--- title: "Tagairt API ``QuerySet ``" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/ref/models/querysets/ canonical: https://djangodocs.dev/ga/5.2/ref/models/querysets/ --- # Tagairt API QuerySet \`\` 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í \, mar sin is dócha go mbeidh tú ag iarraidh na do\ 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 \ \\`a chuirtear i láthair in:doc: treoir fiosrúcháin bunachar sonraithe'. ## Nuair a dhéantar meastóireacht a dhéanamh ar QuerySet\` Go hinmheánach, is féidir QuerySet\` a thógáil, a scagadh, a sliseadh, agus a rith timpeall go ginearálta gan an bunachar sonraí a bhualadh i ndáiríre. Ní tharlaíonn aon ghníomhaíocht bunachar sonraí i ndáiríre go dtí go ndéanann tú rud éigin chun an tac Is féidir leat `QuerySet` a mheas ar na bealaí seo a leanas: - **Aiter.** Tá `QuerySet` in-athraithe, agus déanann sé a cheist bunachar sonraí a fhorghníomhú an chéad uair a dhéanann tú athrá air. Mar shampla, priontóidh sé seo ceannlíne na n-iontrálacha go léir sa bhunachar sonraí: ``` for e in Entry.objects.all(): print(e.headline) ``` Nóta: Ná húsáid é seo más mian leat a dhéanamh ach a chinneadh an bhfuil toradh amháin ar a laghad ann. Tá sé níos éifeachtaí úsáid: meth: ~QuerySet.exists. - **Athrú asincrónaí.** Is féidir `QuerySet` a athrú freisin trí `async for`: ``` async for e in Entry.objects.all(): results.append(e) ``` Tá an taisce bunúsach céanna ag athraitheoirí sioncrónach agus asincrónach de QuerySets. - **Sliseach.** Mar a mhínítear in:ref: limiting-querysets, is féidir `QuerySet` a sliseadh, ag baint úsáide as comhréiteach slisnú eagair Python. Is gnách go bhfillfidh `QuerySet` neamh-mheasúnaithe ``` `QuerySet ``eile gan mheasúnú, ach déanfaidh Django ceist an bhunachar sonraí a fhorghníomhú má úsáideann tú an paraiméadar “céim” de chomhréir sliseanna, agus cuirfidh sé liosta ar ais. Tugann sé liosta freisin ag sliseadh ``QuerySet ``` a rinneadh meastóireacht air. Tabhair faoi deara freisin cé go bhfilleann QuerySet\` neamh-mheasúnaithe QuerySet eile neamh-mheasúnaithe, ní cheadaítear é a mhodhnú tuilleadh (m.sh., níos mó scagairí a chur leis, nó ordú a mhodhnú), ós rud é nach aistríonn sé go maith go SQL agus ní bheadh brí soiléir aige ach an oiread. - **Piccling/Caching.** Féach an chuid seo a leanas le haghaidh sonraí faoin méid a bhfuil i gceist le linn [Picling QuerySets](#pickling-querysets). Is é an rud tábhachtach chun críocha an chuid seo ná go léitear na torthaí ón mbunachar sonraí. - **repr () .** Déantar meastóireacht ar `QuerySet` nuair a ghlaonn tú repr () air. Tá sé seo ar mhaithe le háisiúlacht san ateangaire idirghníomhach Python, ionas gur féidir leat do thorthaí a fheiceáil láithreach agus an API á úsáid idirghníomhach. - **len () .** Déantar meastóireacht ar `QuerySet` nuair a ghlaonn tú len () air. Tugann sé seo, mar a d'fhéadfá a bheith ag súil leis, fad an liosta torthaí ar ais. Nóta: Mura gá duit ach líon na dtaifid sa tacar a chinneadh (agus mura dteastaíonn na rudaí iarbhír uait), tá sé i bhfad níos éifeachtaí comhaireamh a láimhseáil ag leibhéal an bhunachar sonraí ag baint úsáide as SELECT COUNT (\*) SQL. Soláthraíonn Django modh a: meth: \`~QuerySet.count ar an gcúis seo go beacht. - **liosta () .** Meastóireacht a chur i bhfeidhm ar `QuerySet` trí liosta () a ghlaoch air. Mar shampla: ``` entry_list = list(Entry.objects.all()) ``` - **bool () .** Trí thástáil a dhéanamh ar `QuerySet` i gcomhthéacs boolean, mar shampla ```bool () ``, `nó```, nó \`, and\` nó ráiteas `if`, ```a úsáid, is cúis leis an bhfiosrú a fhorghníomhú. Má tá toradh amháin ar a laghad ann, is é an ``QuerySet``` True\`, True\`, ar shlí eile `False`. Mar shampla: ``` if Entry.objects.filter(headline="Test"): print("There is at least one Entry with the headline Test") ``` Nóta: Mura dteastaíonn uait ach a chinneadh an bhfuil toradh amháin ar a laghad ann (agus nach dteastaíonn na rudaí iarbhír uait), tá sé níos éifeachtaí úsáid: meth: ~QuerySet.exists. ### Picling `` `QuerySet ``s Má tá tú: mod: pickle agus QuerySet , cuirfidh sé seo iallach ar na torthaí go léir a luchtú isteach i gcuimhne sula ndéantar piceáil. De ghnáth úsáidtear picling mar réamhtheoir do chaching agus nuair a dhéantar an tacar fiosrúcháin a athluchtú, ba mhaith leat go mbeadh na torthaí i láthair cheana féin agus réidh le húsáid (is féidir le léamh ón mbunachar sonraí roinnt ama a thógáil, ag ruaigeadh cuspóir na caching). Ciallaíonn sé seo nuair a dhíphicfidh tú QuerySet\`, go bhfuil na torthaí ann i láthair na huaire gur piceáladh é, seachas na torthaí atá sa bhunachar sonraí faoi láthair. Mura dteastaíonn uait ach an fhaisnéis riachtanach a phiocadh chun an `QuerySet` a athchruthú ón mbunachar sonraí níos déanaí, piceáil tréith `` `QuerySet `` den QuerySet\`. Ansin is féidir leat an QuerySet bunaidh a athchruthú (gan aon torthaí luchtaithe) ag baint úsáide as cód éigin mar seo: ```pycon >>> import pickle >>> query = pickle.loads(s) # Assuming 's' is the pickled string. >>> qs = MyModel.objects.all() >>> qs.query = query # Restore the original 'query'. ``` Is réad trédhearcach é an tréith `fiosraithe`. Léiríonn sé inmheánacha tógála na fiosrúcháin agus níl sé mar chuid den API poiblí. Mar sin féin, tá sé sábháilte (agus tacaítear go hiomlán) ábhar na tréithe a phiocadh agus a dhíphiocadh mar a thuairiscítear anseo. > **Srianta ar ``QuerySet.values_List () ``** > > Má athchruthaíonn tú: meth: QuerySet.values\_list ag baint úsáide as an tréith picilte `` `Query ``, déanfar é a thiontú u:meth: QuerySet.values: > > ```pycon > >>> import pickle > >>> qs = Blog.objects.values_list("id", "name") > >>> qs > > >>> reloaded_qs = Blog.objects.all() > >>> reloaded_qs.query = pickle.loads(pickle.dumps(qs.query)) > >>> reloaded_qs > > ``` > **Ní féidir leat picíní a roinnt idir leaganacha** > > Pickles of `QuerySet` objects are only valid for the version of Django > that was used to generate them. If you generate a pickle using Django > version N, there is no guarantee that pickle will be readable with > Django version N+1. Pickles should not be used as part of a long-term > archival strategy. > > Ós rud é go bhféadfadh sé a bheith deacair earráidí comhoiriúnachta picéil a dhiagnóisiú, mar shampla rudaí truaillithe go ciúin, ardaítear `RuntimeWarning` nuair a dhéanann tú iarracht tacar ceisteanna a dhíphiocadh i leagan Django atá difriúil ná an ceann inar piceadh é. ## API `QuerySet` Seo an dearbhú foirmiúil ar QuerySet : #### `class QuerySet(model=None, query=None, using=None, hints=None)` \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ú: #### `ordered` `True` má ordaítear an `QuerySet` \- ie tá clásal: ord\_by () \`aige nó ordú réamhshocraithe ar an tsamhail. \`\`Bréag\` ar shlí eile. #### `db` An bunachar sonraí a úsáidfear má dhéantar an cheist seo a fhorghníomhú anois. > **Note** > > Tá an paraiméadar `fiosraithe` to:class: QuerySet ann ionas gur féidir le fo-aicmí ceisteanna speisialaithe staid fiosrúcháin inmheánach a athchóiriú. Is léiriú trédhearcach den stát fiosrúcháin sin é luach an pharaiméadair agus níl sé mar chuid d'API poiblí. ### Modhanna a thugann `QuerySet`s nua ar ais 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. > **Note** > > Ní reáchtáil na modhanna seo ceisteanna bunachar sonraí, dá bhrí sin tá siad **sábháilte dó** reáchtáil i gcód asincrónas\*\*, agus níl leaganacha asincrónacha ar leithligh acu. #### scagaire () \`\` #### `filter(*args, **kwargs)` Filleann sé `QuerySet` nua ina bhfuil rudaí a mheaitseálann leis na paraiméadair chuardaigh ar leith. Ba chóir go mbeadh na paraiméadair chuardaigh (\*\*kwargs \`) san fhormáid a thuairiscítear i [Cuardach allamui](#id4) thíos. Ceanglaítear paraiméadair iolracha trí AND\` sa ráiteas SQL bunúsach. \Más gá duit ceisteanna níos casta a fhorghníomhú (mar shampla, ceisteanna le ráitis OR\`), is féidir leat:class: Q earraí \`(\`\`\*args\`) a úsáid. #### eisiamh () \`\` #### `exclude(*args, **kwargs)` Filleann sé `QuerySet` nua ina bhfuil rudaí nach meaitníon\* leis na paraiméadair chuardaigh a thugtar. Ba chóir go mbeadh na paraiméadair chuardaigh (\*\*kwargs \`) san fhormáid a thuairiscítear i [Cuardach allamui](#id4) thíos. Ceanglaítear paraiméadair iolracha trí AND\` sa ráiteas SQL bunúsach, agus tá an rud iomlán faoi iúl i NOT () . Ní chuimsíonn an sampla seo gach iontráil a bhfuil a “pub\_date” níos déanaí ná 2005-1-3 AGUS a bhfuil “Dia duit” a ceannlíne \`: ``` Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline="Hello") ``` I dtéarmaí SQL, déanann sé meastóireacht ar: ```sql SELECT ... WHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello') ``` Ní chuimsíonn an sampla seo gach iontráil a bhfuil a “pub\_date” níos déanaí ná 2005-1-3 NÓ a bhfuil a cheannteideal “Dia duit”: ``` Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline="Hello") ``` I dtéarmaí SQL, déanann sé meastóireacht ar: ```sql SELECT ... WHERE NOT pub_date > '2005-1-3' AND NOT headline = 'Hello' ``` Tabhair faoi deara go bhfuil an dara sampla níos sriantacha. \Más gá duit ceisteanna níos casta a fhorghníomhú (mar shampla, ceisteanna le ráitis OR\`), is féidir leat:class: Q earraí \`(\`\`\*args\`) a úsáid. #### annotate () \`\` #### `annotate(*args, **kwargs)` Annotates each object in the `QuerySet` with the provided list of [query expressions](/ga/5.2/ref/models/expressions/) or [`Q`](#django.db.models.Q) objects. Each object can be annotated with: - a simple value, via `Value()`; - a reference to a field on the model (or any related models), via `F()`; - a boolean, via `Q()`; or - a result from an aggregate expression (averages, sums, etc.) computed over the objects that are related to the objects in the `QuerySet`. Is anótáil é gach argóint le ```annotate () ``a chuirfear le gach rud sa `QuerySet``` a chuirtear ar ais. Déantar cur síos ar na feidhmeanna comhiomlánaithe a sholáthraíonn Django i [Feidhmeanna Comhiomlánacha](#id6) thíos. Úsáidfidh anótaí a shonraítear ag baint úsáide as argóintí eochairfhocal an eochairfhocal mar an alias don anótáil Beidh ainm ar argóintí gan ainm a ghintear dóibh bunaithe ar ainm na feidhme chomhiomlán agus ar an réimse samhail atá á chomhiomlánú. Ní féidir ach nathanna comhiomlána a thagraíonn réimse amháin a bheith ina argóintí gan ainm Caithfidh gach rud eile a bheith ina argóint eochairfhocal. Mar shampla, má bhí tú ag ionramháil liosta blaganna, b'fhéidir gur mhaith leat a chinneadh cé mhéad iontráil a rinneadh i ngach blag: ```pycon >>> from django.db.models import Count >>> q = Blog.objects.annotate(Count("entry")) # The name of the first blog >>> q[0].name 'Blogasaurus' # The number of entries on the first blog >>> q[0].entry__count 42 ``` Ní shainmhíníonn an tsamhail ```Blag ``tréith `entry__count``` leis féin, ach trí argóint eochairfhocal a úsáid chun an fheidhm chomhiomlán a shonrú, is féidir leat ainm na nótaí a rialú: ```pycon >>> q = Blog.objects.annotate(number_of_entries=Count("entry")) # The number of entries on the first blog, using the name provided >>> q[0].number_of_entries 42 ``` Le haghaidh plé domhain ar chomhiomlánú, féach:doc: an treoir ábhair ar Chomhiomlán' \. #### alias () \`\` #### `alias(*args, **kwargs)` Mar an gcéanna len:meth: annotate, ach in ionad rudaí a anótáil sa QuerySet \`, sábhálann sé an abairt lena n-athúsáid níos déanaí le modhanna `QuerySet` eile. Tá sé seo úsáideach nuair nach bhfuil toradh na léirithe féin ag teastáil ach úsáidtear é chun scagadh, ordú nó mar chuid de léiriú casta. Gan roghnú an luach neamhúsáidte cuirtear obair iomarcach ón mbunachar sonraí agus ba chóir go mbeadh feidhmíocht níos fearr Mar shampla, más mian leat blaganna a fháil le níos mó ná 5 iontráil, ach nach bhfuil suim agat i líon cruinn na n-iontrálacha, d'fhéadfá é seo a dhéanamh: ```pycon >>> from django.db.models import Count >>> blogs = Blog.objects.alias(entries=Count("entry")).filter(entries__gt=5) ``` Is féidir alias () a úsáid i gcomhar le:meth: annotate, :meth: eisiú, :meth: filter, :meth: ord\_by, agus:meth: nuashonraithe. Chun léiriú ailíseach a úsáid le modhanna eile (e.g.:meth: comhiomlán), ní mór duit é a chur chun cinn go dtí anótáil: ``` Blog.objects.alias(entries=Count("entry")).annotate( entries=F("entries"), ).aggregate(Sum("entries")) ``` Is féidir le: meth: filter agus:meth: order\_by abairtí a ghlacadh go díreach, ach is minic nach dtarlaíonn tógáil agus úsáid abairtí san áit chéanna (mar shampla, cruthaíonn modh QuerySet abairtí, le húsáid níos déanaí i radhairc). Ligeann alias () abairtí casta a thógáil go hinchéimiúil, b'fhéidir go gcuimsíonn modhanna agus modúil iolracha, tagairt a dhéanamh do na codanna abairt de réir a n-ainmneacha agus ní úsáidtear ach: meth: annotate don toradh deiridh. #### ord\_by () \`\` #### `order_by(*fields)` De réir réamhshocraithe, ordaítear na torthaí a chuirtear ar ais ag QuerySet tríd an tuple ordaithe a thugann an rogha ```ordú ``i `Meta``` an tsamhail. Is féidir leat é seo a shárú ar bhonn Per-`QuerySet` tríd an modh `order_by` a úsáid. Sampla: ``` Entry.objects.filter(pub_date__year=2005).order_by("-pub_date", "headline") ``` Ordófar an toradh thuas ag ```pub_date ``ag dul síos, ansin ag ``ceannlíne``` ag ardú. Léiríonn an comhartha diúltach os comhair `” -pub_date “` ordú\* síos. Tá ord ardaitheach intuigthe. Chun ordú go randamach, bain úsáid as ”?” , mar sin: ``` Entry.objects.order_by("?") ``` Nóta: order\_by ('?') D'fhéadfadh ceisteanna a bheith daor agus mall, ag brath ar an gcúltaca bunachar sonraí atá á úsáid agat. Chun ordú de réir réimse i samhail dhifriúil, bain úsáid as an gcomhréir céanna agus nuair a bhíonn tú ag fiosrú ar fud caidrimh mhúnla. Is é sin, ainm an réimse, ina dhiaidh sin béim dúbailte (\_\_\`), agus ainm an réimse sa tsamhail nua ina dhiaidh sin, agus mar sin de do an oiread samhlacha agus is mian leat páirt a ghlacadh. Mar shampla: ``` Entry.objects.order_by("blog__name", "headline") ``` \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\`: ``` Entry.objects.order_by("blog") ``` ... comhionann le: ``` Entry.objects.order_by("blog__id") ``` Dá mbeadh ```ordú = ['ainm'] ``ag `Blog```, ansin bheadh an chéad tacar ceisteanna comhionann le: ``` Entry.objects.order_by("blog__name") ``` Is féidir leat ordú freisin trí:doc: léirithe fiosraithe trí ghlaoch ar: meth: ~.Expression.asc nó\ :meth: ~.Expression.desc ar an abairt: ``` Entry.objects.order_by(Coalesce("summary", "headline").desc()) ``` Tá argóintí ag: meth: ~.Expression.asc agus:meth: ~.Expression.desc (`nulls_first` agus `nulls_last`) a rialaíonn an chaoi a ndéantar luachanna null a shórtáil. Bí cúramach agus tú ag ordú de réir réimsí i samhlacha gaolmhara má tá tú ag úsáid freisin: meth: different () \`. Féach an nóta in:meth: \`distint le haghaidh míniú ar an gcaoi ar féidir le hordú samhail gaolmhar na torthaí a bhfuil súil leo a athrú. > **Note** > > Tá sé ceadaithe réimse illuachmhara a shonrú chun na torthaí a ordú trí (mar shampla, a:class: réimse ~django.db.models.manyToManyField, nó an gaol droim a: réimse a:class: ~Django.db.Models.ForeignKey). > > Smaoinigh ar an gcás seo: > > ``` > class Event(Model): > parent = models.ForeignKey( > "self", > on_delete=models.CASCADE, > related_name="children", > ) > date = models.DateField() > > > Event.objects.order_by("children__date") > ``` > > Anseo, d'fhéadfadh go mbeadh sonraí iolracha ordaithe ann do gach ```Imeacht ``; cuirfear gach ``Imeacht``` le leana\` iolracha ar ais go leor uaireanta isteach sa `QuerySet` nua a chruthaíonn ```order_by () ``. Is é sin le rá, d'fhéadfadh go n-úsáidtear ``order_by () ``ar an `QuerySet``` níos mó earraí a thabhairt ar ais ná mar a bhí tú ag obair orthu chun tús a chur leis - rud nach bhfuil súil leis ná úsáideach is dócha. > > Mar sin, bí cúramach agus réimse illuachmhara á úsáid agat chun na torthaí a ordú. Más féidir leat a bheith cinnte nach mbeidh ach píosa sonraí amháin ag ordú do gach ceann de na míreanna atá á ordú agat, níor cheart go mbeadh fadhbanna ag an gcur chuige seo. Mura bhfuil, déan cinnte gurb iad na torthaí an rud a bhfuil súil agat leo. Níl aon bhealach ann chun a shonrú an chóir go mbeadh ordú íogair ó cháis. Maidir le cás-íogaireacht, ordóidh Django torthaí ach is gnách go n-ordóidh do chúlcheann bunachar sonraí iad. Is féidir leat ordú trí réimse a thiontú go litreacha beaga le:class: ~django.db.models.functions.lower a bhaint amach ordú comhsheasmhach cás-chomhsheasmhach: ``` Entry.objects.order_by(Lower("headline").desc()) ``` Mura dteastaíonn uait go gcuirfí aon ordú i bhfeidhm ar cheist, ní fiú an t-ordú réamhshocraithe, glaoigh ar: meth: order\_by () gan aon pharaiméadair. 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") ``` > **Warning** > > Ní oibríocht saor in aisce é ordú. Tá costas ar do bhunachar sonraí ag gach réimse a chuireann tú leis an ordú. Cuimsíonn gach eochair eachtrach a chuireann tú leis go hiontach a ordú réamhshocraithe go léir freisin. > > Mura bhfuil ordú sonraithe i gceist, cuirtear torthaí ar ais ón mbunachar sonraí in ord neamhshonraithe. Ní ráthaítear ordú áirithe ach amháin nuair a ordaítear é ag sraith réimsí a shainaithníonn gach rud sna torthaí go uathúil. Mar shampla, mura bhfuil réimse ainm uathúil, ní ráthóidh ordú leis go mbeidh rudaí leis an ainm céanna le feiceáil san ord céanna i gcónaí. #### droim () \` #### `reverse()` Úsáid an modh reverse () chun an t-ord ina gcuirtear eilimintí tacar fiosrúcháin ar ais a aisiompú. Athchógann glaoch ar reverse () an dara huair an t-ordú ar ais go dtí an gnáththreo. Chun na cúig mhír “deireanach” a aisghabháil i tacar fiosrúcháin, d'fhéadfá seo a dhéanamh: ``` my_queryset.reverse()[:5] ``` Tabhair faoi deara nach bhfuil sé seo mar an gcéanna le slisnú ó dheireadh seicheamh i Python. Tabharfaidh an sampla thuas an mír deireanach ar ais ar dtús, ansin an mír leathdheiridh agus mar sin de. Dá mbeadh seicheamh Python againn agus dá bhféachfaimis ar seq \[-5:\] , feicfimid an cúigiú mír deireanach ar dtús. Ní thacaíonn Django leis an modh rochtana sin (slisnú ón deireadh), toisc nach féidir é a dhéanamh go héifeachtúil i SQL. Chomh maith leis sin, tabhair faoi deara nach gcaithfear reverse () \`\`a ghlaoch de ghnáth ach ar \`\`QuerySet\` a bhfuil ordú sainmhínithe aige (m.sh., agus tú ag fiosrú i gcoinne samhail a shainmhíníonn ordú réamhshocraithe, nó nuair a úsáidtear: meth: order\_by () \`). Mura sainmhínítear aon ordú den sórt sin le haghaidh \`\`QuerySet ar leith, níl aon éifeacht fhíor ag glaoch ar ```reverse () ``air (ní raibh an t-ordú neamhshainithe sula nglaoigh ar ``reverse ()```, agus fanfaidh sé gan sainmhíniú ina dhiaidh sin). #### difriúil () \`\` #### `distinct(*fields)` Filleann `QuerySet` nua a úsáideann `SELECT DISTINCT` ina cheist SQL. Cuireann sé seo deireadh le sraitheanna dúblacha ó thorthaí na gce De réir réamhshocraithe, ní chuirfidh QuerySet \`\`deireadh le sraitheanna dúblacha. Go praiticiúil, is annamh a bhíonn sé seo ina fhadhb, toisc nach dtugann ceisteanna simplí mar \`Blog.Objects.all () \`isteach an fhéidearthacht sraitheanna torthaí dúblacha. Mar sin féin, má chuimsíonn d'fhiosrúchán iolrthaí táblaí, is féidir torthaí dúblacha a fháil nuair a dhéantar “QuerySet” a mheas. Sin nuair a úsáideann tú \`\`difriúil () \`. > **Note** > > Tá aon réimsí a úsáidtear i nglao an:meth: order\_by san áireamh sna colúin SQL `SELECT`. Uaireanta d'fhéadfadh torthaí gan choinne a bheith mar thoradh air seo nuair a úsáidtear iad i gcomhar le difriúil () . Má ordaíonn tú de réir réimsí ó mhúnla gaolmhar, cuirfear na réimsí sin leis na colúin roghnaithe agus féadfaidh siad a bheith cosúil go bhfuil sraitheanna dúblacha ar leith ar shlí eile. Ós rud é nach bhfuil na colúin bhreise le feiceáil sna torthaí ar ais (níl siad ann ach chun tacú le hordú), is cosúil go bhfuil torthaí neamh-shainiúla á thabhairt ar ais uaireanta. > > Ar an gcaoi chéanna, má úsáideann tú fiosrúchán a:meth: values () \`chun srian a chur ar na colúin a roghnaíodh, beidh baint fós ag na colúin a úsáidtear in aon: meth: \`order\_by () (nó ordú samhail réamhshocraithe) agus féadfaidh siad dul i bhfeidhm ar uathúlacht na dtorthaí. > > Is é an moráltacht anseo má tá tú ag úsáid `()` bí cúramach faoi ordú de réir samhlacha gaolmhara. Ar an gcaoi chéanna, agus tú ag úsáid `()` agus:meth: luachanna () \`le chéile, bí cúramach agus tú ag ordú de réir réimsí nach bhfuil sa ghlao:meth: \`values (). Ar PostgreSQL amháin, is féidir leat argóintí seasaimh (\*réimsí \`) a rith d'fhonn ainmneacha na réimsí ar chóir go mbeadh feidhm ag an `DISTINCT` a shonrú. Aistríonn sé seo go fiosrúchán SQL `SELECT DISTINCT ON`. Seo an difríocht. Maidir le gnáthghlao difriúil () , déanann an bunachar sonraí comparáid idir *gach réimse* i ngach sraith agus iad ag cinneadh cé na sraitheanna atá ar leith. Maidir le glao difriúil () le hainmneacha réimse sonraithe, ní dhéanfaidh an bunachar sonraí ach comparáid idir na hainmneacha réimse sonraithe. > **Note** > > Nuair a shonraíonn tú ainmneacha réimse, ní mór duit\* ```order_by () ``a sholáthar sa ``QuerySet```, agus ní mór do na réimsí i order\_by ()\` tosú leis na réimsí i `()`, san ord céanna. > > Mar shampla, tugann ```SELECT DISTINCT ON (a) ``an chéad tsraith duit do gach luach i gcolún ``a```. Mura ndéanann tú ordú a shonrú, gheobhaidh tú sraith treallach éigin. Samplaí (ní oibreoidh iad siúd tar éis an chéad cheann ach ar PostgreSQL): ```pycon >>> Author.objects.distinct() [...] >>> Entry.objects.order_by("pub_date").distinct("pub_date") [...] >>> Entry.objects.order_by("blog").distinct("blog") [...] >>> Entry.objects.order_by("author", "pub_date").distinct("author", "pub_date") [...] >>> Entry.objects.order_by("blog__name", "mod_date").distinct("blog__name", "mod_date") [...] >>> Entry.objects.order_by("author", "pub_date").distinct("author") [...] ``` > **Note** > > Coinnigh i gcuimhne go n-úsáideann: meth: order\_by aon ordú samhail ghaolmhara réamhshocraithe atá sainmhínithe. B'fhéidir go mbeidh ort ordú go sainráite de réir an ghaol `_id` nó réimse tagartha chun a chinntiú go n-oireann na nathanna `DISTINCT ON` iad siúd ag tús an chlásal ```ORDER BY ``. Mar shampla, má shainmhíníodh an tsamhail ``Blog``` an:attr: ~Django.db.Models.Options.Ordering le ainm : > > ``` > Entry.objects.order_by("blog").distinct("blog") > ``` > > ... ní oibreodh toisc go ndéanfaí an cheist a ordú ag `blog__name` agus ar an gcaoi sin mímheaitseáil an abairt `DISTINCT ON`. Bheadh ort ordú go sainráite de réir réimse gaolmhar `_id` (`blog_id` sa chás seo) nó an ceann tagartha (`blog__pk`) chun a chinntiú go n-oireann an dá abairt. #### luachanna () \`\` #### `values(*fields, **expressions)` Tugann “QuerySet” ar ais foclóirí, seachas cásanna samhlacha, nuair a úsáidtear é mar athrá. Léiríonn gach ceann de na foclóirí sin réad, agus na heochracha a fhreagraíonn d'ainmneacha tréithe rudaí samhail. Déanann an sampla seo comparáid idir foclóirí luachanna () leis na gnáth-rudaí samhail: ```pycon # This list contains a Blog object. >>> Blog.objects.filter(name__startswith="Beatles") ]> # This list contains a dictionary. >>> Blog.objects.filter(name__startswith="Beatles").values() ``` Glacann an modh ```luachanna () ``argóintí suíomhanna roghnacha, ``*réimsí```, a shonraíonn ainmneacha réimse ar chóir an `SELECT` a theorannú dóibh. Má shonraíonn tú na réimsí, ní bheidh i ngach foclóir ach na heochair/luachanna réimse do na réimsí a shonraíonn tú. Mura sonraíonn tú na réimsí, beidh eochair agus luach i ngach foclóir do gach réimse sa tábla bunachar sonraí. Sampla: ```pycon >>> Blog.objects.values() >>> Blog.objects.values("id", "name") ``` Glacann an modh ```luachanna () ``argóintí eochairfhocal roghnacha freisin, ``**léiritheach```, a chuirtear trí:meth: annotate: ```pycon >>> from django.db.models.functions import Lower >>> Blog.objects.values(lower_name=Lower("name")) ``` Is féidir leat úsáid a bhaint as ionsuite agus: doc: cuardach saincheapaithe' ag ordú \. Mar shampla: ```pycon >>> from django.db.models import CharField >>> from django.db.models.functions import Lower >>> CharField.register_lookup(Lower) >>> Blog.objects.values("name__lower") ``` Cuirtear comhiomlán laistigh de chlásal luachanna () i bhfeidhm roimh argóintí eile laistigh den chlásal luachanna () céanna. Más gá duit grúpáil de réir luach eile, cuir é le clásal “luachanna ()” níos luaithe ina ionad. Mar shampla: ```pycon >>> from django.db.models import Count >>> Blog.objects.values("entry__authors", entries=Count("entry")) >>> Blog.objects.values("entry__authors").annotate(entries=Count("entry")) ``` Cúpla caolchúrsaíocht is fiú a lua: - Má tá réimse agat darb ainm foo\` is é sin a:class: ~django.db.models.foreignKey, cuirfidh an glao réamhshocraithe ```values () ``ar ais eochair foclóra ar a dtugtar ``foo_id```, ós rud é seo ainm an tréith samhail i bhfolach a stóráil an luach iarbhír (tagraíonn an tréith foo' don tsamhail ghaolmhar). Nuair a bhíonn tú ag glaoch ar \`luachanna () \`\`agus ag dul isteach ainmneacha réimse, is féidir leat dul isteach \`\`foo\` nó `foo_id` agus gheobhaidh tú an rud céanna ar ais (meaitneoidh an eochair foclóra leis an ainm réimse a chuaigh tú isteach). Mar shampla: ```pycon >>> Entry.objects.values() >>> Entry.objects.values("blog") >>> Entry.objects.values("blog_id") ``` - Agus luachanna () \`á n-úsáid agat in éineacht le:meth: \`different (), bí ar an eolas go bhféadfadh ordú dul i bhfeidhm ar na torthaí. Féach an nóta in:meth: distint le haghaidh sonraí. - Má úsáideann tú clásal ```luachanna () ``tar éis glao:meth: `extra () `, ní mór aon réimsí a shainmhínítear le argóint ``roghnaithe``` sa :meth: extra () a chur san áireamh go sainráite sa ghlao `luachanna ()`. Déanfar neamhaird ar a réimsí breise roghnaithe aon: Meth: extra () \`a dhéantar tar éis glao \`\`values () \`. - Níl ciall ag glaoch: Meth: only () \`agus:meth: \`diafer () tar éis ```luachanna () ``, agus mar sin déanfar amhlaidh ardóidh ``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: ```pycon >>> from django.db.models import CharField, Count >>> from django.db.models.functions import Lower >>> CharField.register_lookup(Lower) >>> Blog.objects.values("entry__authors__name__lower").annotate(entries=Count("entry")) >>> Blog.objects.values(entry__authors__name__lower=Lower("entry__authors__name")).annotate( ... entries=Count("entry") ... ) >>> Blog.objects.annotate(entry__authors__name__lower=Lower("entry__authors__name")).values( ... "entry__authors__name__lower" ... ).annotate(entries=Count("entry")) ``` Tá sé úsáideach nuair a fhios agat nach mbeidh luachanna ag teastáil uait ach ó líon beag de na réimsí atá ar fáil agus ní bheidh feidhmiúlacht réad samhail de dhíth ort. Tá sé níos éifeachtaí ach na réimsí a theastaíonn uait a úsáid a roghnú. Mar fhocal scoir, tabhair faoi deara gur féidir leat glaoch ar ```filter () ``, `order_by ()```, srl. Tar éis an ghlao values () , ciallaíonn sin go bhfuil an dá ghlao seo comhionann: ``` Blog.objects.values().order_by("id") Blog.objects.order_by("id").values() ``` Is fearr leis na daoine a rinne Django na modhanna go léir a théann i bhfeidhm ag SQL a chur ar dtús, agus aon mhodhanna a théann i bhfeidhm ag aschur (mar shampla luachanna () ) ina dhiaidh sin (roghnach), ach níl sé tábhachtach i ndáiríre. Is é seo do sheans do dhaoine aonair a thaispeáint i ndáiríre. Is féidir leat tagairt a dhéanamh freisin do réimsí ar mhúnlaí gaolmhara le caidreamh droim trí thréithe `OneTooneField`, ForeignKey\` agus `ManyTomanyField`: ```pycon >>> Blog.objects.values("name", "entry__headline") ``` > **Warning** > > Toisc go bhféadfadh sraitheanna gaolmhara iolracha a bheith ag tréithe agus caidrimh droim: ~django.db.models.manyToManyField agus caidrimh droim, lena n-áirítear is féidir leo seo éifeacht iolraitheach a bheith acu ar mhéid do thraith torthaí. Cuirfear é seo a fhuaimniú go háirithe má chuireann tú réimsí den sórt sin san áireamh i d'fhiosrúchán luachanna () , agus sa chás sin cuirfear gach teaglaim féideartha ar ais. > **Luachanna speisialta do JSONField ar SQLite** > > Mar gheall ar an mbealach a chuirtear feidhmeanna SQL JSON\_EXTRACT\` agus `JSON_TYPE` i bhfeidhm ar SQLite, agus easpa an chineál sonraí BOOLEAN\`, cuirfidh luachanna () \`\`ar ais \`True\`, False\`, agus `None` in ionad `true"`, agus Athraíonn eochair teaghráin `"null"` d'aicme: ~django.db.models.jsonField. > **Changed in Django 5.2** > > The `SELECT` clause generated when using `values()` was updated to > respect the order of the specified `*fields` and `**expressions`. #### liosta\_luachanna () \`\` #### `values_list(*fields, flat=False, named=False)` Tá sé seo cosúil le luachanna () ach amháin go bhfilleann sé foclóirí ar ais, seachas foclóirí a thabhairt ar ais, nuair a dhéantar iad a athrá. Cuimsíonn gach tuple an luach ón réimse nó an abairt faoi seach a chuirtear isteach sa ghlao values\_list () \- mar sin is é an chéad mhír an chéad réimse, srl. Mar shampla: ```pycon >>> Entry.objects.values_list("id", "headline") >>> from django.db.models.functions import Lower >>> Entry.objects.values_list("id", Lower("headline")) ``` Mura dtéann tú ach i réimse amháin, is féidir leat dul isteach sa pharaiméadar `flat` freisin. Má tá “Fíor”, ciallaíonn sé seo gur luachanna aonair iad na torthaí ar ais, seachas 1-tuples. Ba chóir go ndéanfadh sampla an difríocht níos soiléire: ```pycon >>> Entry.objects.values_list("id").order_by("id") >>> Entry.objects.values_list("id", flat=True).order_by("id") ``` Is earráid é dul isteach i `flat` nuair a bhíonn níos mó ná réimse amháin ann. Is féidir leat `named=true` a rith chun torthaí a fháil mar a:func: ~python:collections.namedtuple: ```pycon >>> Entry.objects.values_list("id", "headline", named=True) ``` Má úsáidtear tuple ainmnithe, d'fhéadfadh úsáid a bhaint as na torthaí níos inléite, ar chostas pionós feidhmíochta beag as na torthaí a athrú go tuple ainmnithe. Mura gcuireann tú aon luachanna ar aghaidh chuig values\_list () \`, cuirfidh sé na réimsí go léir sa tsamhail ar ais, san ord a dearbhíodh iad. Is é riachtanas coitianta luach réimse sonrach a fháil de shampla samhail áirithe. Chun é sin a bhaint amach, bain úsáid as values\_list () \`\`agus glao \`\`get ()\` ina dhiaidh sin: ```pycon >>> Entry.objects.values_list("headline", flat=True).get(pk=1) 'First entry' ``` Tá ```luachanna () ``agus `values_list ()``` beartaithe araon mar bharrfheabhsú do chás úsáide ar leith: fo-thacar sonraí a aisghabháil gan an lascaire a bhaineann le samhail samhail a chruthú. Titeann an meafar seo óna chéile agus tú ag déileáil le caidrimh illuachmhar agus caidrimh illuachmhar eile (mar shampla gaol duine le go leor eochair eachtrach droim) toisc nach bhfuil an toimhde “aon tsraith, rud amháin”. Mar shampla, tabhair faoi deara an t-iompar agus tú ag fiosrú ar fud a:class: ~django.db.models.manyToManyField: ```pycon >>> Author.objects.values_list("name", "entry__headline") ``` Tá údair le hiontrálacha iolracha le feiceáil arís agus uaireanta agus tá None ag údair gan aon iontrálacha don cheannlíne iontrála. Ar an gcaoi chéanna, nuair a fhiosraítear eochair eachtrach droim, tá None le feiceáil le haghaidh iontrálacha nach bhfuil aon údar acu: ```pycon >>> Entry.objects.values_list("authors") ``` > **Luachanna speisialta do JSONField ar SQLite** > > Mar gheall ar an mbealach a chuirtear feidhmeanna SQL `JSON_EXTRACT` agus `JSON_TYPE` i bhfeidhm ar SQLite, agus easpa an chineál sonraí `BOOLEAN`, cuirfidh values\_list () \`\`ar ais \`True\`, False\`, agus `None` in ionad `true"`, bréag\` , agus teaghráin \`"null"\`\` le haghaidh: aicme: ~django.db.models.jsonField eochair athraitheacha. > **Changed in Django 5.2** > > The `SELECT` clause generated when using `values_list()` was updated to > respect the order of the specified `*fields`. #### dátaí () \`\` #### `dates(field, kind, order='ASC')` Filleann `QuerySet` a mheastóidh ar liosta d':class: datetime.date rudaí a léiríonn gach dáta atá ar fáil de chineál áirithe laistigh d'ábhar an `QuerySet`. Ba chóir go mbeadh ```réimse ``mar ainm ``Datefield``` de do mhúnla. Ba chóir go mbeadh `cineál` `blian"`, "míos"\`, "seachtaine"\`, nó "lá” . Gach duine: Class: “datetime.date” réad sa liosta torthaí “gearrtha” go dtí an cineál tugtar. - Tugann `"bliain"` liosta de na luachanna bliana ar leith uile don réimse. - Tugann `"mhí"` liosta de na luachanna bliana/míosa ar leith go léir don réimse. - Tugann "seachtaine"\` liosta de na luachanna bliana/seachtaine ar leith go léir don réimse. Is Luan a bheidh na dátaí go léir. - Tugann "lá” liosta de na luachanna ar leith bliant/mí/lá go léir don réimse. Ba chóir go mbeadh ``` `ASC'` nó ``DESC' ```, `ASC'`, 'ordú ,' réamhshocraithe '. Sonraíonn sé seo conas na torthaí a ordú. Samplaí: ```pycon >>> Entry.objects.dates("pub_date", "year") [datetime.date(2005, 1, 1)] >>> Entry.objects.dates("pub_date", "month") [datetime.date(2005, 2, 1), datetime.date(2005, 3, 1)] >>> Entry.objects.dates("pub_date", "week") [datetime.date(2005, 2, 14), datetime.date(2005, 3, 14)] >>> Entry.objects.dates("pub_date", "day") [datetime.date(2005, 2, 20), datetime.date(2005, 3, 20)] >>> Entry.objects.dates("pub_date", "day", order="DESC") [datetime.date(2005, 3, 20), datetime.date(2005, 2, 20)] >>> Entry.objects.filter(headline__contains="Lennon").dates("pub_date", "day") [datetime.date(2005, 3, 20)] ``` #### dáta-amanna () \`\` #### `datetimes(field_name, kind, order='ASC', tzinfo=None)` Filleann sé `QuerySet` a dhéanann meastóireacht ar liosta de:class: datetime.datetime rudaí a léiríonn gach dáta atá ar fáil de chineál áirithe laistigh d'ábhar an `QuerySet`. Ba chóir go mbeadh field\_name\` ainm `DateTimefield` de do mhúnla. Ba chóir go mbeadh `cineál` `blian"`, "míos"\`, "seachtaine"\`, `` lá” ` ``, `` `uair an chloig" ``, `nóiméad"`, nó `"seachtaine"`. Gach duine: Class: datetime.datetime réad sa liosta torthaí “gearrtha” go dtí an `cineál` a thugtar. Ba chóir go mbeadh ``` `ASC'` nó ``DESC' ```, `ASC'`, 'ordú ,' réamhshocraithe '. Sonraíonn sé seo conas na torthaí a ordú. Sainmhíníonn `tzinfo` an crios ama ina ndéantar dáta-amanna a thiontú sula ndéantar iad a ghearradh. Go deimhin, tá léirithe difriúla ag dáta ar leith ag brath ar an gcrios ama atá in úsáid. Caithfidh an paraiméadar seo a: aicme: datetime.tzinfo réad. \Más ```None ``é, úsáideann Django an:ref: `crios ama reatha `. Níl aon éifeacht aige nuair:setting: `USE_TZ` ``False```. > **Note** > > Déanann an fheidhm seo tiontaithe crios ama go díreach sa bhunachar sonraí. Mar thoradh air sin, caithfidh do bhunachar sonraí a bheith in ann luach tzinfo.tzname (None) a léirmhíniú. Aistríonn sé seo sna ceanglais seo a leanas: > > - SQLite: gan aon riachtanais. Déantar tiontaithe i Python. > - PostgreSQL: gan aon riachtanais (féach Criosanna Ama \_). > - Oracle: gan aon riachtanais (féach [Comhad Crios Ama a Roghnaithe](https://docs.oracle.com/en/database/oracle/oracle-database/18/nlspg/datetime-data-types-and-time-zone-support.html#GUID-805AB986-DE12-4FEA-AF56-5AABCD2132DF)). > - MySQL: luchtaigh na táblaí crios ama le [mysql\_tzinfo\_to\_sql](https://dev.mysql.com/doc/refman/en/mysql-tzinfo-to-sql.html). #### aon cheann () \` #### `none()` 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í: ```pycon >>> Entry.objects.none() >>> from django.db.models.query import EmptyQuerySet >>> isinstance(Entry.objects.none(), EmptyQuerySet) True ``` #### gach () \` #### `all()` Filleann sé cóip\* den fho-aicme reatha `QuerySet` (nó ```QuerySet ``). D'fhéadfadh sé seo a bheith úsáideach i gcásanna inar mbeadh tú ag iarraidh bainisteoir samhail nó ``QuerySet` a rith isteach agus scagadh breise a dhéanamh ar an toradh. Tar éis glaoch ar ``all () ``ar cheachtar réad, is cinnte go mbeidh ``QuerySet``` agat le bheith ag obair leis. \Nuair a bhíonn `QuerySet`: ref: meastóireacht \`, is gnách go ndéanann sé a thorthaí a chosc. Má d'fhéadfadh go mbeadh athrú ar na sonraí sa bhunachar sonraí ó rinneadh meastóireacht ar \`\`QuerySet, is féidir leat torthaí nuashonraithe a fháil don cheist céanna trí ghlaoch ar ```all () ``ar `QuerySet``` a rinneadh meastóireacht roimhe seo. #### aontas () \`\` #### `union(*other_qs, all=False)` Úsáideann oibreoir `UNION` SQL chun torthaí dhá QuerySet\` nó níos mó `QuerySet`s a chomhcheangal. Mar shampla: ``` >>> qs1.union(qs2, qs3) ``` Ní roghnaíonn an t-oibreoir UNION ach luachanna ar leith de réir réamhshocraithe. Chun luachanna dúblacha a cheadú, bain úsáid as an argóint `all=True`. ```aontas () ``, `crosbhall ()```, agus ```difríocht () ``cásanna samhail ar ais den chineál den chéad ``QuerySet``` fiú más `QuerySet` iad na hargóintí `QuerySet` de mhúnlaí eile. Oibríonn pas samhlacha éagsúla chomh fada agus a bhíonn an liosta `SELECT` mar an gcéanna i ngach `QuerySet` (ar a laghad na cineálacha, is cuma na hainmneacha chomh fada agus a bhíonn na cineálacha san ord céanna). I gcásanna den sórt sin, ní mór duit na hainmneacha colún a úsáid ón gcéad `QuerySet` i modhanna `QuerySet` a chuirtear i bhfeidhm ar an `QuerySet` mar thoradh air. Mar shampla: ```pycon >>> qs1 = Author.objects.values_list("name") >>> qs2 = Entry.objects.values_list("headline") >>> qs1.union(qs2).order_by("name") ``` Ina theannta sin, ní cheadaítear ach `LIMIT`, OFFSET\`, ```COUNT (*) ``, `ORDER BY```, agus colúin a shonrú (ie slisnú, :meth: count, :meth: exists, :meth: ord\_by, agus:meth: luachanna () \`ar an “QuerySet” mar thoradh air. Ina theannta sin, cuireann bunachair sonraí srianta ar na hoibríochtaí atá ceadaithe sna ceisteanna comhcheangailte Mar shampla, ní cheadaíonn an chuid is mó de na bunachair sonraí \`\`LIMIT\` nó `OFFSET` sna ceisteanna comhcheangailte. #### trasna () \`\` #### `intersection(*other_qs)` Úsáideann oibreoir `INTERSECT` SQL chun na heilimintí roinnte de dhá QuerySet\` nó níos mó `QuerySet`s a thabhairt ar ais. Mar shampla: ```pycon >>> qs1.intersection(qs2, qs3) ``` Féach: Meth: aont le haghaidh roinnt srianta. #### difríocht () \`\` #### `difference(*other_qs)` Ú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: ```pycon >>> qs1.difference(qs2, qs3) ``` Féach: Meth: aont le haghaidh roinnt srianta. #### roghnai\_bhainteach () \`\` #### `select_related(*fields)` Filleann sé `QuerySet` a leanfaidh caidrimh eachtrach-eachtrach, ag roghnú sonraí breise réad gaolmhara nuair a fhorghníomhaíonn sé a cheist. Is teanndáileog feidhmíochta é seo a mbíonn ceist amháin níos casta mar thoradh air ach ciallaíonn nach mbeidh ceisteanna bunachar sonraí ag teastáil le húsáid níos déanaí caidrimh eachtracha Léiríonn na samplaí seo a leanas an difríocht idir cuardach simplí agus cuardaigh select\_related () . Seo cuardach caighdeánach: ``` # Hits the database. e = Entry.objects.get(id=5) # Hits the database again to get the related Blog object. b = e.blog ``` Agus seo cuardach `select_related`: ``` # Hits the database. e = Entry.objects.select_related("blog").get(id=5) # Doesn't hit the database, because e.blog has been prepopulated # in the previous query. b = e.blog ``` Is féidir leat select\_related () a úsáid le haon tacar ceisteanna rudaí: ``` from django.utils import timezone # Find all the blogs with entries scheduled to be published in the future. blogs = set() for e in Entry.objects.filter(pub_date__gt=timezone.now()).select_related("blog"): # Without select_related(), this would make a database query for each # loop iteration in order to fetch the related blog for each entry. blogs.add(e.blog) ``` Níl an t-ord a bhaineann le slabhraíocht ```filter () ``agus ``select_related ()``` tábhachtach. Tá na ceisteanna ceisteanna seo coibhéiseach: ``` Entry.objects.filter(pub_date__gt=timezone.now()).select_related("blog") Entry.objects.select_related("blog").filter(pub_date__gt=timezone.now()) ``` Is féidir leat eochracha eachtracha a leanúint ar bhealach cosúil leo a cheistiú. Má tá na samhlacha seo a leanas agat: ``` from django.db import models class City(models.Model): # ... pass class Person(models.Model): # ... hometown = models.ForeignKey( City, on_delete=models.SET_NULL, blank=True, null=True, ) class Book(models.Model): # ... author = models.ForeignKey(Person, on_delete=models.CASCADE) ``` ... ansin glao chuig ```Book.Objects.select_related ('author__baile') .get (id=4) ``taisceoidh an ``Person``` gaolmhar agus\* an `Cathair` gaolmhar: ``` # Hits the database with joins to the author and hometown tables. b = Book.objects.select_related("author__hometown").get(id=4) p = b.author # Doesn't hit the database. c = p.hometown # Doesn't hit the database. # Without select_related()... b = Book.objects.get(id=4) # Hits the database. p = b.author # Hits the database. c = p.hometown # Hits the database. ``` Is féidir leat tagairt a dhéanamh d'aon ghaol:class: ~django.db.models.foreignKey nó:class: ~django.db.models.onetoonefield sa liosta réimsí a chuirtear chuig select\_related () . Is féidir leat tagairt a dhéanamh freisin do threo droim a:class: ~django.db.models.onetoonefield sa liosta réimsí a chuirtear chuig `select_related` \- is é sin, is féidir leat a:class: ~django.db.models.onetoonefield a thrasnú ar ais go dtí an réad ar a sainmhínítear an réimse. In ionad ainm an réimse a shonrú, bain úsáid as an:attr: related\_name \\`don réimse ar an réad gaolmhar. D'fhéadfadh go mbeadh roinnt cásanna ann inar mian leat glaoch ar select\_related () le go leor rudaí gaolmhara, nó nuair nach bhfuil a fhios agat na caidrimh go léir. Sna cásanna seo is féidir glaoch ar select\_related () gan aon argóintí. Leanfaidh sé seo gach eochracha eachtracha neamh-neamh-niall is féidir leis a fháil - caithfear eochracha eachtracha in-neamhnaithe a Ní mholtar é seo i bhformhór na gcásanna mar is dócha go ndéanfaidh sé an ceist bhunúsach níos casta, agus níos mó sonraí a thabhairt ar ais, ná mar a theastaíonn i ndáiríre. Más gá duit an liosta réimsí gaolmhara a chuir leis na glaonna roimhe seo de select\_related\` a ghlanadh ar `QuerySet`, is féidir leat `None` a rith mar pharaiméadar: ```pycon >>> without_relations = queryset.select_related(None) ``` Oibríonn glaonna `select_related` a shlánú ar bhealach cosúil le modhanna eile - is é sin go bhfuil ```select_related ('foo', 'bar') ``comhionann le ``select_related ('foo') .select_related ('bar')```. #### prefetch\_related () \`\` #### `prefetch_related(*lookups)` Tugann “QuerySet” ar ais a aisghabhann rudaí gaolmhara go huathoibríoch, i mbaisc amháin, do gach ceann de na cuardaigh sonraithe. Tá cuspóir comhchosúil aige seo le select\_related, sa mhéid go bhfuil an dá cheann deartha chun stop a chur le tuilleadh ceisteanna bunachar sonraí is cúis le rochtain a fháil ar rudaí gaolmhara, ach tá an straitéis an-difriúil. Oibríonn `select_related` trí chomhcheangal SQL a chruthú agus réimsí an réada gaolmhara a áireamh sa ráiteas `SELECT`. Ar an gcúis seo, faigheann `select_related` na rudaí gaolmhara san fhiosrúchán bunachar sonraí céanna. Mar sin féin, chun an tacar torthaí i bhfad níos mó a bheadh as dul isteach i rith caidreamh 'go leor' a sheachaint, tá `select_related` teoranta do chaidrimh aonluach - eochair eachtrach agus duine le duine. Ar an láimh eile, déanann `prefetch_related` cuardach ar leithligh do gach caidreamh, agus déanann sé an 'ceangal' i Python. Ligeann sé seo dó rudaí go leor, go leor, agus:class: ~django.contrib.contentTypes.Fields.GenericRelation nach féidir a dhéanamh ag baint úsáide as select\_related\`, chomh maith leis na caidrimh eochair eachtracha agus duine le duine a thacaíonn le select\_related\`. Tacaíonn sé freisin le réamhghabháil o:class: ~django.contrib.contentTypes.fields.GenericForeignKey, áfach, ní mór an tacar ceisteanna do gach ContentType\` a sholáthar sa pharaiméadar `querysets` de:class: ~django.contrib.contentTypes.prefetch.GenericPrefetch. Mar shampla, cuir i gcás go bhfuil na samhlacha seo agat: ``` from django.db import models class Topping(models.Model): name = models.CharField(max_length=30) class Pizza(models.Model): name = models.CharField(max_length=50) toppings = models.ManyToManyField(Topping) def __str__(self): return "%s (%s)" % ( self.name, ", ".join(topping.name for topping in self.toppings.all()), ) ``` agus rith: ```pycon >>> Pizza.objects.all() ["Hawaiian (ham, pineapple)", "Seafood (prawns, smoked salmon)"... ``` Is í an fhadhb leis seo ná gach uair `````Pizza. Iarrann __str__ () ````self.toppings.all ()````` caithfidh sé an bunachar sonraí a cheistiú, mar sin reáchtálfaidh ```Pizza.Objects.all () `ceist ar an tábla Toppings le haghaidh **gach ear** sa Pizza ``QuerySet```. Is féidir linn laghdú go dtí dhá cheist ag baint úsáide as `prefetch_related`: ```pycon >>> Pizza.objects.prefetch_related("toppings") ``` Tugann sé seo le tuiscint go bhfuil self.toppings.all () \`\`do gach \`Pizza\`; anois gach uair a thugtar `self.toppings.all ()`, in ionad dul chuig an mbunachar sonraí do na míreanna, gheobhaidh sé iad i taisce `QuerySet` réamhfhaighte a rinneadh i gceist amháin. That is, all the relevant toppings will have been fetched in a single query, and used to make `QuerySet` instances that have a pre-filled cache of the relevant results; these are then used in the `self.toppings.all()` calls. Déantar na ceisteanna breise i prefetch\_related () \`\`a fhorghníomhú tar éis an \`\`QuerySet\` a mheas agus an cheist phríomhúil a fhorghníomhú. Tabhair faoi deara nach bhfuil aon mheicníocht ann chun ceist eile bunachar sonraí a chosc ó na míreanna a athrú idir forghníomhú na ceisteanna príomhúil agus na ceisteanna breise, a d'fhéadfadh toradh neamhchomhsheasmhach a bheith mar thoradh air. Mar shampla, má scriostar Pizza tar éis don cheist phríomhúil a fhorghníomhú, ní thabharfar a bholtaí ar ais sa cheist bhreise, agus is cosúil nach bhfuil aon fhorais ag an pizza: ```pycon >>> Pizza.objects.prefetch_related("toppings") # "Hawaiian" Pizza was deleted in another shell. , ]> ``` Má tá cásanna samhail in-athraithe agat, is féidir leat tréithe gaolmhara a réamh-fháil ar na cásanna sin ag baint úsáide as an bhfeidhm:func: ~django.db.models.prefetch\_related\_objects. Note that the result cache of the primary `QuerySet` and all specified related objects will then be fully loaded into memory. This changes the typical behavior of a `QuerySet`, which normally tries to avoid loading all objects into memory before they are needed, even after a query has been executed in the database. > **Note** > > Remember that, as always with `QuerySet` objects, any subsequent chained > methods which imply a different database query will ignore previously > cached results, and retrieve data using a fresh database query. So, if you > write the following: > > ```pycon > >>> pizzas = Pizza.objects.prefetch_related("toppings") > >>> [list(pizza.toppings.filter(spicy=True)) for pizza in pizzas] > ``` > > ... ansin ní chabhróidh an fíric go bhfuil pizza.toppings.all () \`\`réamhfhaighte leat. Chuir an \`\`prefetch\_related ('toppings') \`\`intuigthe \`\`pizza.toppings.all ()\`, ach is ceist nua difriúil é pizza.toppings.filter () . Ní féidir leis an taisce réamhghabháilte cabhrú anseo; i ndáiríre gortaíonn sé feidhmíocht, ós rud é go bhfuil ceist bunachar sonraí déanta agat nár úsáideann tú. Mar sin bain úsáid as an ngné seo le cúramach! > > \Chomh maith leis sin, má ghlaonn tú ar na modhanna athraithe bunachar sonraí: meth: ~Django.db.Models.Fields.Related.RelatedManager.add, :meth: ~Django.db.Models.Fields.Related.RelatedManager.Create, :meth: ~Django.db.Models.Fields.related.Manager.remove, :h: ~Django.db.Models.Fields.Related.RelatedManager.Clear nó: meth: ~Django.db.Models.Fields.Related.RelatedManager.Set, ar:class: bhainisteoirí gaolmhara , glanfar aon taisce réamhghabháilte don ghaol. Is féidir leat an gnáthchomhréireacht a úsáid freisin chun réimsí gaolmhara de réimsí gaolmhara a dhéanamh. Cuir i gcás go bhfuil samhail bhreise againn leis an sampla thuas: ``` class Restaurant(models.Model): pizzas = models.ManyToManyField(Pizza, related_name="restaurants") best_pizza = models.ForeignKey( Pizza, related_name="championed_by", on_delete=models.CASCADE ) ``` Tá na nithe seo a leanas ar fad dlíthiúil: ```pycon >>> Restaurant.objects.prefetch_related("pizzas__toppings") ``` Tabharfaidh sé seo gach píosa a bhaineann le bialanna, agus gach topping a bhaineann leis na pizzí sin a réamh-aimsiú. Beidh 3 cheist bunachar sonraí san iomlán mar thoradh air seo - ceann do na bialanna, ceann do na pizzes, agus ceann do na toppings. ```pycon >>> Restaurant.objects.prefetch_related("best_pizza__toppings") ``` Tabharfaidh sé seo an pizza is fearr agus na toppings go léir don pizza is fearr do gach bialann. Déanfar é seo i 3 cheist bunachar sonraí - ceann do na bialanna, ceann do na 'pizzes is fearr ', agus ceann do na toppings. D'fhéadfaí an caidreamh ```best_pizza ``a fháil freisin ag baint úsáide as ``select_related``` chun líon na fiosrúcháin a laghdú go 2: ```pycon >>> Restaurant.objects.select_related("best_pizza").prefetch_related("best_pizza__toppings") ``` Ós rud é go ndéantar an réamhcheistiú a fhorghníomhú tar éis na príomhiosrúcháin (lena n-áirítear na comhcheangail a theastaíonn ag `select_related`), tá sé in ann a bhrath go bhfuil na rudaí best\_pizza faighte cheana féin, agus scipeoidh sé iad a fháil arís. Carnóidh glaonna `prefetch_related` a shlánú na cuardaigh atá réamhfhaighte. Chun aon iompar `prefetch_related` a ghlanadh, pas `None` mar pharaiméadar: ```pycon >>> non_prefetched = qs.prefetch_related(None) ``` Difríocht amháin le tabhairt faoi deara agus `prefetch_related` á úsáid ná gur féidir rudaí a chruthaítear le ceist a roinnt idir na rudaí éagsúla a bhfuil baint acu leo i.e. is féidir le samhail Python amháin a bheith le feiceáil ag níos mó ná pointe amháin sa chrann na rudaí a chuirtear ar ais. De ghnáth tarlóidh sé seo le príomhchaidrimh eachtracha. De ghnáth ní bheidh an t-iompar seo ina fhadhb, agus sábhálfaidh sé am cuimhne agus LAP araon i ndáiríre. Cé go dtacaíonn `prefetch_related` le caidrimh GenericForeignKey réamhghabháilte, beidh líon na gceisteanna ag brath ar na sonraí. Ós rud é gur féidir le GenericForeignKey sonraí a thagairt i dtáblaí iolracha, teastaíonn ceist amháin in aghaidh an tábla dá dtagraítear, seachas ceist amháin do na míreanna go léir. D'fhéadfadh ceisteanna breise a bheith ann ar an tábla `ContentType` mura bhfuil na sraitheanna ábhartha faighte cheana féin. Cuirfear `prefetch_related` i bhformhór na gcásanna i bhfeidhm ag baint úsáide as ceist SQL a úsáideann an oibreoir 'IN'. Ciallaíonn sé seo go bhféadfaí clásal mór 'IN' a ghiniúint do QuerySet mór, a d'fhéadfadh fadhbanna feidhmíochta féin a bheith aige, ag brath ar an mbunachar sonraí, maidir le parsáil nó a fhorghníomhú an fhiosrúcháin SQL. Próifíl i gcónaí do do chás úsáide! Má úsáideann tú ```iterator () ``chun an cheist a reáchtáil, ní bhreathnófar glaonna ``prefetch_related ()``` ach amháin má chuirtear luach ar fáil do chunk\_size\`. Is féidir leat an réad:class: ~django.db.models.prefetch a úsáid chun an oibríocht réamhfhreastalaí a rialú tuilleadh. Sa fhoirm is simplí tá Prefetch\` comhionann leis na cuardaigh thraidisiúnta bunaithe ar shreang: ```pycon >>> from django.db.models import Prefetch >>> Restaurant.objects.prefetch_related(Prefetch("pizzas__toppings")) ``` Is féidir leat tacar ceisteanna saincheaptha a sholáthar leis an argóint roghnach queryset . Is féidir é seo a úsáid chun ordú réamhshocraithe an tacar fiosrúcháin a athrú: ```pycon >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas__toppings", queryset=Toppings.objects.order_by("name")) ... ) ``` Nó glaoch ar: meth: ~django.db.models.query.queryset.select\_related () nuair is infheidhme chun líon na gceisteanna a laghdú tuilleadh fós: ```pycon >>> Pizza.objects.prefetch_related( ... Prefetch("restaurants", queryset=Restaurant.objects.select_related("best_pizza")) ... ) ``` Is féidir leat an toradh réamhfhaighte a shannadh freisin do thréith saincheaptha leis an argóint roghnach to\_attr\`. Stórálfar an toradh go díreach i liosta. Ligeann sé seo an gaol céanna a réamhghabháil arís agus arís eile le QuerySet difriúil; mar shampla: ```pycon >>> vegetarian_pizzas = Pizza.objects.filter(vegetarian=True) >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas", to_attr="menu"), ... Prefetch("pizzas", queryset=vegetarian_pizzas, to_attr="vegetarian_menu"), ... ) ``` Is féidir cuardaigh eile a chruthaítear le to\_attr\` saincheaptha a thrasnú mar is gnách: ```pycon >>> vegetarian_pizzas = Pizza.objects.filter(vegetarian=True) >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas", queryset=vegetarian_pizzas, to_attr="vegetarian_menu"), ... "vegetarian_menu__toppings", ... ) ``` Moltar to\_attr\` a úsáid agus an toradh réamhfhaighte á scagadh síos toisc nach bhfuil sé chomh débhríoch ná toradh scagtha a stóráil i taisce an bhainisteora gaolmhar: ```pycon >>> queryset = Pizza.objects.filter(vegetarian=True) >>> >>> # Recommended: >>> restaurants = Restaurant.objects.prefetch_related( ... Prefetch("pizzas", queryset=queryset, to_attr="vegetarian_pizzas") ... ) >>> vegetarian_pizzas = restaurants[0].vegetarian_pizzas >>> >>> # Not recommended: >>> restaurants = Restaurant.objects.prefetch_related( ... Prefetch("pizzas", queryset=queryset), ... ) >>> vegetarian_pizzas = restaurants[0].pizzas.all() ``` Oibríonn réamhghabháil saincheaptha freisin le caidreamh aonair a bhaineann le cosúil le ForeignKey\` nó OneTooneField\` . Go ginearálta beidh tú ag iarraidh: meth: select\_related () a úsáid le haghaidh na caidrimh seo, ach tá roinnt cásanna ann ina bhfuil réamh-ghabháil le saincheaptha QuerySet úsáideach: - Ba mhaith leat `QuerySet` a úsáid a dhéanann tuilleadh réamhghabhála ar mhúnlaí gaolmhara. - Ní theastaíonn uait ach fo-thacar de na rudaí gaolmhara a réamh-fháil. - \Ba mhaith leat teicnící optamaithe feidhmíochta a úsáid mar: meth: réimsí iarchurtha : ```pycon >>> queryset = Pizza.objects.only("name") >>> >>> restaurants = Restaurant.objects.prefetch_related( ... Prefetch("best_pizza", queryset=queryset) ... ) ``` Agus bunachair sonraí iolracha á úsáid agat, beidh meas ag `Prefetch` do rogha bunachar sonraí. Mura sonraíonn an cheist istigh bunachar sonraí, úsáidfidh sé an bunachar sonraí a roghnaíonn an cheist seachtrach. Tá gach ceann de na nithe seo a leanas bailí: ```pycon >>> # Both inner and outer queries will use the 'replica' database >>> Restaurant.objects.prefetch_related("pizzas__toppings").using("replica") >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas__toppings"), ... ).using("replica") >>> >>> # Inner will use the 'replica' database; outer will use 'default' database >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas__toppings", queryset=Toppings.objects.using("replica")), ... ) >>> >>> # Inner will use 'replica' database; outer will use 'cold-storage' database >>> Restaurant.objects.prefetch_related( ... Prefetch("pizzas__toppings", queryset=Toppings.objects.using("replica")), ... ).using("cold-storage") ``` > **Note** > > Tá tábhacht ag ordú cuardaigh. > > Tóg na samplaí seo a leanas: > > ```pycon > >>> prefetch_related("pizzas__toppings", "pizzas") > ``` > > Oibríonn sé seo cé go bhfuil sé neamh-ordaithe toisc go bhfuil an fhaisnéis uile riachtanach ann cheana féin sa pizzas\_\_toppings', dá bhrí sin tá an dara argóint \`'pizzas'\` iomarcach i ndáiríre. > > ```pycon > >>> prefetch_related("pizzas__toppings", Prefetch("pizzas", queryset=Pizza.objects.all())) > ``` > > Ardóidh sé seo `Error lua` mar gheall ar an iarracht tacar fiosrúcháin a chonacthas roimhe seo a athshainiú. Tabhair faoi deara gur cruthaíodh tacar ceisteanna intuigthe chun 'pizzas'\` a thrasnú mar chuid den chuardach pizzas\_\_toppings'. > > ```pycon > >>> prefetch_related("pizza_list__toppings", Prefetch("pizzas", to_attr="pizza_list")) > ``` > > Spreagfaidh sé seo `AttributeError` toisc nach bhfuil `pizza_list'` ann fós nuair a bhíonn pizza\_list\_\_toppings'\` á phróiseáil. > > Níl an breithniú seo teoranta d'úsáid rudaí `Prefetch`. D'fhéadfadh go n-éilíonn roinnt ardteicnící go ndéanfaí na cuardaigh in ord sonrach chun ceisteanna breise a chruthú a sheachaint; dá bhrí sin moltar argóintí prefetch\_related\` a ordú go cúramach i gcónaí. #### breise () \`\` #### `extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)` Uaireanta, ní féidir le comhréiteach ceisteanna Django leis féin clásal casta `WHERE` a chur in iúl go héasca. Maidir leis na cásanna imeall seo, soláthraíonn Django an modhnóir extra () QuerySet \- crúca chun clásail shonracha a instealladh isteach sa SQL a ghineann QuerySet\`. > **Úsáid an modh seo mar rogha dheireanach** > > Is sean-API é seo a bhfuil sé mar aidhm againn a dhíchur ag pointe éigin sa todhchaí. Úsáid é ach amháin mura féidir leat do cheist a chur in iúl ag baint úsáide as modhanna ceisteanna eile. Más gá duit é a úsáid, le do thoil ag baint \< \> úsáide as an eochairfhocal le do chás úsáide (seiceáil liosta na dticéad atá ann cheana ar dtús) ionas gur féidir linn an API QuerySet a fheabhsú chun cead a bhaint extra () . Nílimid ag feabhsú nó ag socrú fabhtanna don mhodh seo a thuilleadh. > > Mar shampla, an úsáid seo de extra () : > > ```pycon > >>> qs.extra( > ... select={"val": "select col from sometable where othercol = %s"}, > ... select_params=(someparam,), > ... ) > ``` > > atá coibhéiseach le: > > ```pycon > >>> qs.annotate(val=RawSQL("select col from sometable where othercol = %s", (someparam,))) > ``` > > Is é an príomhbhuntáiste a bhaineann le húsáid:class: ~django.db.models.expressions.rawsql ná gur féidir leat output\_field\` a shocrú más gá. Is é an príomh-mhíbhuntáiste ná má thagraíonn tú d'ainm tábla éigin den tacar fiosrúcháin sa SQL amh, is féidir go bhféadfadh Django an t-ainm sin a athrú (mar shampla, nuair a úsáidtear an tacar fiosrúcháin mar fho-cheist i bhfiosrúchán eile fós). > **Warning** > > Ba chóir duit a bheith an-chúramach aon uair a úsáideann tú extra () . Gach uair a úsáideann tú é, ba cheart duit éalú ar aon pharaiméadair is féidir leis an úsáideoir a rialú trí params' a úsáid chun cosaint a dhéanamh ar ionsaithe insteallta SQL. > > Ní mór duit sealbhóirí áiteanna a lua sa teaghrán SQL freisin. Tá an sampla seo leochaileach do instealladh SQL mar gheall ar na luachana timpeall `%s`: > > ```sql > SELECT col FROM sometable WHERE othercol = '%s' # unsafe! > ``` > > \Is féidir leat tuilleadh a léamh faoin gcaoi a n-oibríonn Django's:ref: Cosaint insteallta SQL . De réir sainmhínithe, b'fhéidir nach mbeidh na cuardaigh bhreise seo iniompartha d'innill bhunachar sonraí éagsúla (toisc go bhfuil cód SQL á scríobh go sainráite agat) agus sáraíonn tú prionsabal DRY, mar sin ba cheart duit iad a sheachaint Sonraigh ceann amháin nó níos mó de `params`, roghnaithe\`, ```cá háit ``nó ``tábla```. Níl aon cheann de na hargóintí ag teastáil, ach ba cheart duit ceann acu ar a laghad a úsáid. - `roghnaithe` Ligeann an argóint ```roghnaigh ``duit réimsí breise a chur sa chlásal ``SELECT```. Ba chóir go mbeadh ainmneacha tréithe ag mapáil foclóra le clásail SQL le húsáid chun an tréith sin a ríomh. Sampla: ``` Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"}) ``` Mar thoradh air sin, beidh tréith bhreise ag gach réad ```Entry', ``is_recent```, boolean a léiríonn an bhfuil pub\_date an iontráil níos mó ná 1 Eanáir, 2006. Cuireann Django an snippet SQL a thugtar isteach go díreach sa ráiteas `SELECT`, mar sin bheadh an SQL mar thoradh air den sampla thuas rud éigin mar: ```sql SELECT blog_entry.*, (pub_date > '2006-01-01') AS is_recent FROM blog_entry; ``` Tá an chéad sampla eile níos airde; déanann sé fo-cheist chun tréith entry\_count\` a thabhairt do gach réad `` `Blog `` mar thoradh air, comhaireamh sláimhir na rudaí `Iontrála` gaolmhara: ``` Blog.objects.extra( select={ "entry_count": "SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id" }, ) ``` Sa chás áirithe seo, táimid ag leas as an bhfíric go mbeidh an tábla `blog_blog` sa chlásal `FROM` sa cheist cheana féin. Is é an SQL mar thoradh air den sampla thuas ná: ```sql SELECT blog_blog.*, (SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id) AS entry_count FROM blog_blog; ``` Tabhair faoi deara nach bhfuil na lúibíní a éilíonn mórchuid na n-innill bunachar sonraí timpeall fo-cheisteanna ag teastáil i gclásail “roghnaigh” Django. I roinnt cásanna neamhchoitianta, b'fhéidir gur mhaith leat paraiméadair a chur chuig na blúirí SQL i ```extra (roghnaigh =...) ``. Chun na críche seo, bain úsáid as an paraiméadar ``select_params```. Oibreoidh sé seo, mar shampla: ``` Blog.objects.extra( select={"a": "%s", "b": "%s"}, select_params=("one", "two"), ) ``` Más gá duit `%s` litriúil a úsáid taobh istigh de do shreang roghnaithe, bain úsáid as an seicheamh `%%s`. - ``` `cá háit ``/``tábla ``` Is féidir leat clásail `WHERE` SQL sainráite a shainiú - b'fhéidir chun comhpháirteanna neamh-shoiléire a dhéanamh - trí `` `a úsáid` ``. Is féidir leat táblaí a chur de láimh leis an gclásal SQL `FROM` trí táblaí a úsáid. Glacann ````` ````agus ``tábla ````` liosta teaghráin araon. Tá na paraiméadair go léir “agus” déanta d'aon chritéir chuardaigh eile. Sampla: ``` Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) ``` ... aistríonn (go garbh) go dtí an SQL seo a leanas: ```sql SELECT * FROM blog_entry WHERE (foo='a' OR bar='a') AND (baz='a') ``` Bí cúramach agus an paraiméadar táblaí á úsáid agat má tá táblaí á shonrú agat a úsáidtear cheana féin sa cheist. Nuair a chuireann tú táblaí breise tríd an bparaiméadar táblaí , glacann Django leis gur mhaith leat am breise a bheith san áireamh sa tábla sin, má tá sé san áireamh cheana féin. Cruthaíonn sé sin fadhb, ós rud é go dtabharfar ainm an tábla ansin. Má tá tábla le feiceáil arís agus arís i ráiteas SQL, ní mór don dara tarlú agus ina dhiaidh sin ainmneacha a úsáid ionas gur féidir leis an mbunachar sonraí iad a insint óna chéile. Má tá tú ag tagairt don tábla breise a chuir tú sa pharaiméadar breise cén áit beidh earráidí mar thoradh air seo. De ghnáth ní bheidh tú ag cur ach táblaí breise nach bhfuil le feiceáil sa cheist cheana féin. Mar sin féin, má tharlaíonn an cás a leagtar amach thuas, tá cúpla réiteach ann. Ar dtús, féach an féidir leat dul tríd gan an tábla breise a áireamh agus bain úsáid as an gceann atá sa cheist cheana féin. Mura féidir é sin a dhéanamh, cuir do ghlao breise () ag tosaigh an tógála tacar fiosraithe ionas gurb é do thábla an chéad úsáid den tábla sin. Faoi dheireadh, má theipeann ar gach rud eile, féach ar an bhfiosrú a tháirgtear agus athscríobh do bhreise cá háit chun an alias a thugtar do do thábla breise a úsáid. Beidh an t-ailias mar an gcéanna gach uair a thógann tú an tacar fiosrúcháin ar an mbealach céanna, ionas gur féidir leat brath ar an ainm alias gan athrú. - `ordó_by` Más gá duit an tacar iarratais a ordú ag baint úsáide as cuid de na réimsí nó na táblaí nua atá san áireamh agat trí ```extra () ``bain úsáid as an paraiméadar ``order_by``` go extra ()\` agus pas i seicheamh teaghráin. Ba chóir go mbeadh na teaghráin seo ina réimsí samhail (mar atá sa modh gnáth:meth: order\_by () \`ar cheisteanna ceisteanna), den fhoirm \`\`table\_name.column\_name\` nó ainm do cholún a shonraigh tú sa pharaiméadar ```roghnaigh ``go `extra ()```. Mar shampla: ``` q = Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"}) q = q.extra(order_by=["-is_recent"]) ``` Sórtálfadh sé seo na míreanna go léir a bhfuil `is_recent` díreach maidir le tosaigh an tacar torthaí (`True` sórtálacha roimh `False` in ordú íslitheach). Taispeánann sé seo, dála an scéil, gur féidir leat glaonna iolracha a dhéanamh chuig extra () agus iompróidh sé mar a bhíonn ag súil leat (srianta nua a chur leis gach uair). - `Params` Féadfaidh an paraiméadar ```` `a thuairiscítear thuas sealbhóirí teaghrán bunachar sonraí caighdeánach Python a úsáid - ```%s' ```` chun paraiméadair a léiriú ba chóir don inneall bunachar sonraí a lua go huath Is é an argóint params' ná liosta d'aon pharaiméadair bhreise atá le cur in ionad. Sampla: ``` Entry.objects.extra(where=["headline=%s"], params=["Lennon"]) ``` Úsáid params\` i gcónaí in ionad luachanna a leabú go díreach isteach i ```cén áit ``toisc go gcinnteoidh `params``` luachanna i gceart de réir do chúltaca áirithe. Mar shampla, éalófar luachana i gceart. Droch: ``` Entry.objects.extra(where=["headline='Lennon'"]) ``` Go maith: ``` Entry.objects.extra(where=["headline=%s"], params=["Lennon"]) ``` > **Warning** > > Má tá tú ag déanamh ceisteanna ar MySQL, tabhair faoi deara go bhféadfadh foréigean cineál ciúin MySQL a bheith ina chúis le torthaí gan choinne agus cineál Má fhiosraíonn tú ar cholún cineál sreangán, ach le luach sláimhir, cuirfidh MySQL na cineálacha na luachanna go léir sa tábla a chur i gcomhar sula ndéanann tú an comparáid. Mar shampla, má tá na luachanna `'abc'`, def'\`\` i do thábla agus má fhiosraíonn tú ar `WHERE mycolumn=0`, meaitneoidh an dá shraith. Chun é seo a chosc, déan an clóscáil cheart sula n-úsáidtear an luach i bhfiosrúchán. #### iarchur () \` #### `defer(*fields)` I roinnt cásanna casta samhaltú sonraí, d'fhéadfadh go mbeadh go leor réimsí i do mhúnlaí, a bhféadfadh go leor sonraí a bheith i gcuid acu (mar shampla, réimsí téacs), nó próiseáil daor a bheith ag teastáil chun iad a thiontú go rudaí Python. Má tá torthaí tacar fiosrúcháin á úsáid agat i gcás éigin nach bhfuil a fhios agat an dteastaíonn na réimsí áirithe sin uait nuair a fhaigheann tú na sonraí ar dtús, is féidir leat a rá le Django gan iad a aisghabháil ón mbunachar sonraí. Déantar é seo trí ainmneacha na réimsí a chur ar aghaidh chun gan luchtú chuig defer () : ``` Entry.objects.defer("headline", "body") ``` Tabharfaidh tacar fiosrúcháin a bhfuil réimsí iarchurtha aige cásanna samhail ar ais fós. Aisghabfar gach réimse iarchurtha ón mbunachar sonraí má rochtain agat ar an réimse sin (ceann ag an am, ní na réimsí iarchurtha go léir ag an am céanna). > **Note** > > Ní luchtálfaidh réimsí iarchurtha mar seo ó chód asincrónach. Ina áit sin, gheobhaidh tú eisceacht `SynchronousOnlyOperation`. Má tá cód asincrónach á scríobh agat, níor cheart duit iarracht a dhéanamh rochtain a fháil ar aon réimsí a dhéanann tú fiafraí () . Is féidir leat glaonna iolracha a dhéanamh chuig fiafraigh () . Cuireann gach glao réimsí nua leis an tacar iarchurtha: ``` # Defers both the body and headline fields. Entry.objects.defer("body").filter(rating=5).defer("headline") ``` Is cuma an t-ord ina gcuirtear réimsí leis an tacar iarchurtha. Tá sé neamhdhíobhálach a ghlaoch ar déanamh () le hainm réimse atá curtha ar iarchur cheana féin (cuirfear an réimse ar iarchur fós). Féadfaidh tú luchtú réimsí i samhlacha gaolmhara a chur siar (má tá na samhlacha gaolmhara ag luchtú via:meth: select\_related () ) tríd an nótaí caighdeánach béim dhúbailte a úsáid chun réimsí gaolmhara ar leithligh: ``` Blog.objects.select_related().defer("entry__headline", "entry__body") ``` Más mian leat an tacar réimsí iarchurtha a ghlanadh, cuir `None` mar pharaiméadar chuig defer () : ``` # Load all fields immediately. my_queryset.defer(None) ``` Ní iarchurfar roinnt réimsí i samhail, fiú má iarrann tú iad. Ní féidir leat luchtú an phríomh-eochair a chur siar riamh. Má tá tú ag úsáid: meth: select\_related () chun samhlacha gaolmhara a aisghabháil, níor cheart duit luchtú an réimse a nascann ón bpríomh-mhúnla leis an gceann gaolmhar a chur siar, agus beidh earráid mar thoradh air sin. Ar an gcaoi chéanna, ní bhíonn ciall ag glaoch ar defer () (nó a chontrapháirt:meth: only () \`) lena n-áirítear argóint ó chomhiomlánú (m.sh. ag úsáid toradh de:meth: \`annotate ()): ardóidh eisceacht ag déanamh amhlaidh. Tabharfar na luachanna comhiomlánaithe isteach sa tacar fiosrúcháin mar thoradh air i gcónaí. > **Note** > > Níl an modh defer () (agus a chathrach, :meth: only () , thíos) ach le haghaidh ardchásanna úsáide. Soláthraíonn siad barrfheabhsú nuair a dhéanann tú anailís go dlúth ar do chuid ceisteanna agus tuigeann tú *go beacht* cén fhaisnéis a theastaíonn uait agus a thomhas go mbeidh an difríocht idir na réimsí a theastaíonn uait a thabhairt ar ais agus an tacar iomlán réimsí don tsamhail suntasach. > > Fiú má cheapann tú go bhfuil tú sa chás ardchás úsáide, \*\* húsáid ach \*\* ```fiafraigh () ``**nuair nach féidir leat, ag am luchtaithe ceisteanna socraithe, a chinneadh an mbeidh na réimsí breise ag teastáil uait nó ní**. Má tá fo-thacar áirithe de do shonraí á luchtú agus ag úsáid tú go minic, is é an rogha is fearr is féidir leat a dhéanamh ná do mhúnlaí a normalú agus na sonraí neamh-luchtaithe a chur i samhail ar leithligh (agus tábla bunachar sonraí). Má chaithfidh na colúin ** fanacht sa tábla amháin ar chúis éigin, cruthaigh samhail le `Meta.managed = False``` (féach an doiciméadach:attr: treit bhainistithe \`) ina bhfuil ach na réimsí a chaithfidh tú a luchtú agus bain úsáid as sin ina bhféadfá \`\`defer () a ghlaoch ar shlí eile. Déanann sé seo do chód níos soiléire don léitheoir, tá sé beagán níos gasta agus ídíonn sé beagán níos lú cuimhne sa phróiseas Python. > > Mar shampla, úsáideann an dá mhúnla seo an tábla bunachar sonraí céanna: > > ``` > class CommonlyUsedModel(models.Model): > f1 = models.CharField(max_length=10) > > class Meta: > managed = False > db_table = "app_largetable" > > > class ManagedModel(models.Model): > f1 = models.CharField(max_length=10) > f2 = models.CharField(max_length=10) > > class Meta: > db_table = "app_largetable" > > > # Two equivalent QuerySets: > CommonlyUsedModel.objects.all() > ManagedModel.objects.defer("f2") > ``` > > Más gá go leor réimsí a dhúbailt sa tsamhail neamh-bhainistithe, b'fhéidir gur fearr samhail teibí a chruthú leis na réimsí roinnte agus ansin na samhlacha neamh-bhainistithe agus bainistithe a bheith oidhreachta ón tsamhail teibí. > **Note** > > Agus tú ag glaoch: meth: ~django.db.models.model.save () le haghaidh cásanna le réimsí iarchurtha, ní shábhálfar ach na réimsí luchtaithe. Féach: Meth: ~django.db.models.model.save () le haghaidh tuilleadh sonraí. #### amháin () \` #### `only(*fields)` Go bunúsach is é an modh only () a mhalairt de:meth: iarchur. Ní dhéantar ach na réimsí a chuirtear isteach sa mhodh seo agus nach nd\* atá sonraithe cheana féin mar iarchurtha a luchtú láithreach nuair a dhéantar an tacar fiosrúcháin a mheas. Má tá samhail agat ina gcaithfear beagnach na réimsí go léir a chur siar, d'fhéadfadh cód níos simplí a bheith mar thoradh ar only () chun an tacar chomhlántach réimsí a shonrú. Cuir i gcás go bhfuil samhail agat le réimsí ```ainm ``, `aois``` agus `beathaisnéis`. Tá an dá cheist seo a leanas mar an gcéanna, i dtéarmaí réimsí iarchurtha: ``` Person.objects.defer("age", "biography") Person.objects.only("name") ``` Aon uair a ghlaonn tú ar only () , ath\* aith\* an tacar réimsí le luchtú láithreach. Is é ainm an mhodha mnemonic: **amháin** luchtaítear na réimsí sin láithreach; cuirtear an chuid eile ar iarchur. Mar sin, ní bhreithnítear ach na réimsí deiridh ar na réimsí deiridh mar thoradh ar ghlaonna i ndiaidh a chéile ar only () : ``` # This will defer all fields except the headline. Entry.objects.only("body", "rating").only("headline") ``` Ós rud é go ngníomhaíonn ```diafraigh () ``go hincneamhach (réimsí a chur leis an liosta iarchurtha), is féidir leat glaonna a chur le ``only ()``` agus deafer () a chomhcheangal agus iompraíonn rudaí go loighciúil: ``` # Final result is that everything except "headline" is deferred. Entry.objects.only("headline", "body").defer("body") # Final result loads headline immediately. Entry.objects.defer("body").only("headline", "body") ``` Baineann na rabhaidh go léir sa nóta maidir leis an doiciméadúisíocht: “athchur” le only () chomh maith. Úsáid é go cúramach agus ach amháin tar éis do roghanna eile a ídiú. Is earráid é only () a úsáid agus réimse a iarrtar a fhágáil ag baint úsáid:meth: select\_related freisin. Ar an láimh eile, cuirfear glaoch ar only () gan aon argóintí, gach réimse (lena n-áirítear anótaí) a gheobhaidh an tacar fiosrúcháin ar ais. Mar is amhlaidh le ```defer () ``, ní féidir leat rochtain a fháil ar na réimsí neamh-luchtaithe ó chód asincrónach agus a bheith ag súil go luchtálfaidh siad. Ina áit sin, gheobhaidh tú eisceacht ``SynchronousOnlyOperation```. Déan cinnte go bhfuil gach réimse a d'fhéadfá rochtain a fháil i do ghlao only () . > **Note** > > Agus tú ag glaoch: meth: ~django.db.models.model.save () le haghaidh cásanna le réimsí iarchurtha, ní shábhálfar ach na réimsí luchtaithe. Féach: Meth: ~django.db.models.model.save () le haghaidh tuilleadh sonraí. > **Note** > > Nuair a úsáidtear: meth: iarchur tar éis ```only () ``, cuirfidh na réimsí in:meth: `iarchur ``only ()``` i gcás réimsí atá liostaithe sa dá cheann. #### ag baint úsáide as () \` #### `using(alias)` Is é an modh seo chun rialú a dhéanamh ar an mbunachar sonraí a dhéanfar meastóireacht ar an QuerySet\` i gcoinne má tá níos mó ná bunachar sonraí amháin á úsáid agat. Is é an t-aon argóint a ghlacann an modh seo ná ainm bunachar sonraí, mar a shainmhínítear in:setting: DATABASES. Mar shampla: ```pycon # queries the database with the 'default' alias. >>> Entry.objects.all() # queries the database with the 'backup' alias >>> Entry.objects.using("backup") ``` #### roghnaithe\_for\_nuashonraithe () \`\` #### `select_for_update(nowait=False, skip_locked=False, of=(), no_key=False)` Tugann sé tacar ceisteanna ar ais a ghlasálfaidh sraitheanna go dtí deireadh an idirbheart, ag gint `ROGHNAIGH... LE HAGHAIDH UPDATE` Ráiteas SQL ar bhunachair sonraí tacaithe. Mar shampla: ``` from django.db import transaction entries = Entry.objects.select_for_update().filter(author=request.user) with transaction.atomic(): for entry in entries: ... ``` Nuair a dhéantar an tacar fiosrúcháin a mheas (le haghaidh iontrála in iontrálacha sa chás seo), cuirfear gach iontráil comhoiriúnach faoi ghlas go dtí deireadh an bhloc idirbheart, rud a chiallaíonn go gcuirfear cosc ar idirbhearta eile glais a athrú nó a fháil orthu. De ghnáth, má tá glas faighte ag idirbheart eile cheana féin ar cheann de na sraitheanna roghnaithe, cuirfidh an ceist bac go dtí go scaoilfear an glas. Mura bhfuil sé seo an t-iompar atá uait, glaoigh ar ```select_for_update (noWait=true) ``. Déanfaidh sé seo an glao gan bhlocáil. Má fhaightear glas contrártha cheana féin le hidirbheart eile, ardófar :exc: `~django.db.databaseError` nuair a dhéantar an tacar fiosrúcháin a mheas. Is féidir leat neamhaird a dhéanamh freisin ar shraitheanna faoi ghlas trí ``select_for_update (skip_locked=True) ``a úsáid ina ionad. Tá na `nowait``` agus `skip_locked` frithpháirteach agus beidh a: exc: ValueError mar thoradh ar iarrachtaí glaoch ar select\_for\_update () agus an dá rogha cumasaithe. De réir réamhshocraithe, glasaíonn ```select_for_update () ``gach sraitheanna a roghnaíonn an cheist. Mar shampla, tá sraitheanna rudaí gaolmhara a shonraítear in:meth: `select_related` faoi ghlas i dteannta sraitheanna de mhúnla an tacar fiosrúcháin. Mura bhfuil sé seo ag teastáil, sonraigh na rudaí gaolmhara a theastaíonn uait a ghlasáil in ``select_for_update (of= (...)) ``ag baint úsáide as comhréir na réimsí céanna mar: meth: `select_related`. Úsáid an luach ``'self'``` chun tagairt a dhéanamh do mhúnla an tacar fiosrúcháin. > **Glas samhlacha tuismitheoirí i ``select_for_update (de =( ... )) ``** > > Más mian leat samhlacha tuismitheoirí a ghlasáil agus tú ag úsáid:ref: oidhreacht il-tábla \, ní mór duit réimsí nasc tuismitheoirí a shonrú (de réir réamhshocraithe `_ptr`) san argóint `of`. Mar shampla: > > ``` > Restaurant.objects.select_for_update(of=("self", "place_ptr")) > ``` > **Ag baint úsáide as ``select_for_update (of= (...)) ``le réimsí sonraithe** > > Más mian leat samhlacha a ghlasáil agus réimsí roghnaithe a shonrú, m.sh. ag baint úsáide as: meth: luacha, ní mór duit réimse amháin ar a laghad a roghnú ó gach samhail san argóint `of`. Ní ghlasálfar samhlacha gan réimsí roghnaithe. 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. \< \>Tá tuilleadh sonraí ag doiciméadú PostgreSQL faoi . Ní féidir leat select\_for\_update () a úsáid ar chaidrimh neamhnaithe: ```pycon >>> Person.objects.select_related("hometown").select_for_update() Traceback (most recent call last): ... django.db.utils.NotSupportedError: FOR UPDATE cannot be applied to the nullable side of an outer join ``` Chun an srian sin a sheachaint, is féidir leat rudaí neall a eisiamh mura bhfuil cúram ort fúthu: ```pycon >>> Person.objects.select_related("hometown").select_for_update().exclude(hometown=None) , ...]> ``` Tacaíonn cúltaca bunachar sonraí `postgresql`, `oracle`, agus `mysql` ```select_for_update () ``. Mar sin féin, ní thacaíonn MariaDB ach leis an argóint ``nowait ``, tacaíonn MariaDB 10.6+ leis an argóint ``skip_locked``` freisin, agus tacaíonn MySQL leis na hargóintí `nowait`, skip\_locked\`, agus `of`. Ní thacaítear leis an argóint `no_key` ach ar PostgreSQL. Ag dul `noWait=True`, skip\_locked=true\`, no\_key=true\`, nó `of` go select\_for\_update () ag baint úsáide as cúltaca bunachar sonraí nach dtacaíonn leis na roghanna seo, mar MySQL, ardaíonn a:exc: ~django.db.notSupportedError. Cuireann sé seo cosc ar chód ó bhlocáil gan choinne. Meastóireacht a dhéanamh ar shraith ceisteanna le ```select_for_update () ``i mód uathchomhcheangail ar chúltaca a thacaíonn le ``SELECT... LE HAGHAIDH UPDATE``` is é:: exc: ~django.db.transaction.transactionManagementError earráid toisc nach bhfuil na sraitheanna faoi ghlas sa chás sin. Má cheadaítear é, éascódh sé seo éilliú sonraí agus d'fhéadfadh sé a bheith ina chúis go héasca trí chód glaonna atá ag súil go reáchtálfar in idirbheart lasmuigh de cheann amháin. Ag baint úsáide as ```select_for_update () ``ar chúltaca nach dtacaíonn le ``SELECT... LE HAGHAIDH NUASHONRÚ ``(mar shampla SQLite) ní bheidh aon éifeacht ag. ``ROGHNAIGH... NÍ chuirfear FOR UPDATE``` leis an bhfiosrú, agus ní ardaítear earráid má úsáidtear select\_for\_update () i mód autocommit. > **Warning** > > Cé go dteipeann ```select_for_update () ``de ghnáth i mód autocommit, ós rud é go ndéanfaidh: class: `~django.test.testcase` gach tástáil i idirbheart go huathoibríoch, ag glaoch ``select_for_update () `i `testcase``` fiú taobh amuigh an:func: ~django.db.transaction.atomic ().) pas gan `TransactionManagementError` a ardú. Chun select\_for\_update () a thástáil i gceart ba cheart duit:class: ~django.test.transactionTestCase a úsáid. > **Ní fhéadfar tacú le nathanna áirithe** > > Ní thacaíonn PostgreSQL le select\_for\_update () le nathanna: class: ~django.db.Models.Expressions.Window. #### amh () \`\` #### `raw(raw_query, params=(), translations=None, using=None)` 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. > **Warning** > > Spreagann raw () ceist nua i gcónaí agus ní chuireann sé cuntas ar scagadh roimhe seo. Mar sin, ba chóir é a ghlaoch go ginearálta ón “Bainisteoir” nó ó shampla úr QuerySet\`. ### Oibreoirí a chuireann ar ais `QuerySet`s nua Ní mór do cheisteanna comhcheangailte an tsamhail chéanna a úsáid. #### AGUS (& ) Comhcheanglaíonn dhá `QuerySet` ag baint úsáide as an oibreoir `AND` SQL ar bhealach cosúil le scagairí slabhraithe. Tá na nithe seo a leanas coibhéiseach: ``` Model.objects.filter(x=1) & Model.objects.filter(y=2) Model.objects.filter(x=1).filter(y=2) ``` Coibhéis SQL: ```sql SELECT ... WHERE x=1 AND y=2 ``` #### NÓ (`|`) Comhcheanglaíonn dhá `QuerySet`s ag baint úsáide as an oibreoir SQL `OR`. Tá na nithe seo a leanas coibhéiseach: ``` Model.objects.filter(x=1) | Model.objects.filter(y=2) from django.db.models import Q Model.objects.filter(Q(x=1) | Q(y=2)) ``` Coibhéis SQL: ```sql SELECT ... WHERE x=1 OR y=2 ``` Ní oibríocht chomhlaitheach é |\`, toisc go bhféadfar ceisteanna difriúla (cé go coibhéiseach) a ghiniúint. #### XOR (`^`) Comhcheanglaíonn dhá `QuerySet`s 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: ``` Model.objects.filter(x=1) ^ Model.objects.filter(y=2) from django.db.models import Q Model.objects.filter(Q(x=1) ^ Q(y=2)) ``` Coibhéis SQL: ```sql SELECT ... WHERE x=1 XOR y=2 ``` > **Note** > > Tugtar tacaíocht dúchasach le `XOR` ar MariaDB agus MySQL. Ar bhunachair sonraí eile, déantar `x ^ y ^... ^ z` a thiontú go coibhéis: > > ```sql > (x OR y OR ... OR z) AND > 1=MOD( > (CASE WHEN x THEN 1 ELSE 0 END) + > (CASE WHEN y THEN 1 ELSE 0 END) + > ... > (CASE WHEN z THEN 1 ELSE 0 END), > 2 > ) > ``` ### Modhanna nach gcuireann ar ais `QuerySet`s Déanann na modhanna `QuerySet` seo a leanas measúnú ar an `QuerySet` agus cuireann siad rud éigin seachas `QuerySet` ar ais. Ní úsáideann na modhanna seo taisce (féach:ref: caching-and-querysets). Ina ionad sin, fiosraíonn siad an bunachar sonraí gach uair a ghlaofar orthu. Toisc go ndéanann na modhanna seo measúnú ar an QuerySet, tá siad ag blocáil glaonna, agus mar sin ní féidir a bpríomhleaganacha (sioncronacha) a ghlaoch ó chód asincrónach. Ar an gcúis seo, tá leagan asincrónach comhfhreagrach ag gach ceann acu le réimír `a` \- mar shampla, seachas ```get (...) ``is féidir leat ``fanacht aget (...)```. De ghnáth ní bhíonn aon difríocht in iompar seachas a nádúr asincrónach, ach tugtar faoi deara aon difríochtaí thíos in aice le gach modh. #### get () \` #### `get(*args, **kwargs)` #### `aget(*args, **kwargs)` *Leagan asincrón*: aget () \`\` Filleann sé an réad a mheaitseálann na paraiméadair chuardaigh a thugtar, ar chóir go mbeadh sa fhormáid a thuairiscítear i Cuardach réimse \_ Ba chóir duit cuardaigh a úsáid atá ráthaithe uathúil, mar shampla an príomh-eochair nó réimsí i srian uathúil. Mar shampla: ``` Entry.objects.get(id=1) Entry.objects.get(Q(blog=blog) & Q(entry_number=1)) ``` Má tá tú ag súil go bhfaighidh tacar ceisteanna sraith amháin ar ais cheana féin, is féidir leat get () a úsáid gan aon argóintí chun an réad don tsraith sin a thabhairt ar ais: ``` Entry.objects.filter(pk=1).get() ``` \Mura bhfaigheann get () aon rud, ardaíonn sé: exc: Model.doesNotExist eisceacht: ``` Entry.objects.get(id=-999) # raises Entry.DoesNotExist ``` \Má aimsíonn get () níos mó ná réad amháin, ardaíonn sé a: exc: Model.MultipleObjectsReturned eisceacht: ``` Entry.objects.get(name="A Duplicated Name") # raises Entry.MultipleObjectsReturned ``` Is tréithe den rang samhail iad an dá rang eisceachta seo, agus go sonrach don tsamhail sin. Más mian leat eisceachtaí den sórt sin a láimhseáil ó roinnt glaonna get () ar mhúnlaí éagsúla, is féidir leat a n-aicmí bonn cineálacha a úsáid. Mar shampla, is féidir leat: exc: Django.Core.Exceptions.ObjectDoesNotExist a úsáid chun láimhseáil: exc: ~django.db.models.model.doesNotExist eisceachtaí ó iolracha samhlacha: ``` from django.core.exceptions import ObjectDoesNotExist try: blog = Blog.objects.get(id=1) entry = Entry.objects.get(blog=blog, entry_number=1) except ObjectDoesNotExist: print("Either the blog or entry doesn't exist.") ``` #### cruthaigh () \`\` #### `create(**kwargs)` #### `acreate(**kwargs)` *Asynchronous version*: `acreate()` Modh áisiúlachta chun réad a chruthú agus é go léir a shábháil i gcéim amháin. Dá bhrí sin: ``` p = Person.objects.create(first_name="Bruce", last_name="Springsteen") ``` agus: ``` p = Person(first_name="Bruce", last_name="Springsteen") p.save(force_insert=True) ``` iad coibhéiseach. Tá an paraim \éadair: ref: force\_insert \`doiciméadaithe in áiteanna eile, ach ní chiallaíonn sé ach go gcruthófar réad nua i gcónaí. De ghnáth ní bheidh ort a bheith buartha faoi seo. Mar sin féin, má tá príomh-luach láimhe i do mhúnla a shocraíonn tú agus má tá an luach sin ann cheana sa bhunachar sonraí, teipeann ar ghlao ar \`create () \`\`le an:exc: \`~django.db.IntegrityError ós rud é go gcaithfidh eochracha bunscoile a bheith uathúil. Bí réidh chun an eisceacht a láimhseáil má tá eochracha bunscoile láimhe á úsáid agat. #### get\_or\_create () \` #### `get_or_create(defaults=None, **kwargs)` #### `aget_or_create(defaults=None, **kwargs)` *Leagan asincrón*: aget\_or\_create () \`\` Modh áisiúlachta chun réad a chuardach leis an kwargs tugtha (féadfaidh sé a bheith folamh má tá réamhshocruithe ag do mhúnla do gach réimse), ag cruthú ceann más gá. Filleann sé tuple de `(réad, cruthaithe)`, áit gurb é ```réad ``an réad aisghabháilte nó cruthaithe agus is boolean é ``cruthaithe``` a shonraíonn an cruthaíodh réad nua. Tá sé seo i gceist chun rudaí dúblacha a chruthú nuair a dhéantar iarratais go comhthreomhar, agus mar aicearra chuig cód boilerplatish. Mar shampla: ``` try: obj = Person.objects.get(first_name="John", last_name="Lennon") except Person.DoesNotExist: obj = Person(first_name="John", last_name="Lennon", birthday=date(1940, 10, 9)) obj.save() ``` Anseo, le hiarratais chomhthráthacha, féadfar iarrachtaí iolracha chun Duine a shábháil leis na paraiméadair chéanna. Chun an coinníoll rása seo a sheachaint, is féidir an sampla thuas a athscríobh ag baint úsáide as get\_or\_create () mar sin: ``` obj, created = Person.objects.get_or_create( first_name="John", last_name="Lennon", defaults={"birthday": date(1940, 10, 9)}, ) ``` Úsáidfear aon argóintí eochairfhocal a chuirtear chuig ```get_or_create () ``- *seachas ceann roghnach ar a dtugtar ``defaults``` \- i nglao a:meth: get () \`. Má aimsítear réad, filleann \`\`get\_or\_create () \`\`tuple den réad sin agus \`\`False\`. > **Warning** > > Tá an modh seo adamach ag glacadh leis go gcuireann an bunachar sonraí uathúlacht na n-argóintí eochairfhocal i bhfeidhm (féach: attr: ~django.db.models.field.unique nó: attr: ~django.db.models.options.unique\_together). Mura bhfuil srian uathúlachta ag na réimsí a úsáidtear sna hargóintí eochairfhocal, d'fhéadfadh go mbeadh sraitheanna iolracha leis na paraiméadair chéanna isteach mar thoradh ar ghlaonna comharthacha ar an modh seo. \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 obj, created = Person.objects.filter( Q(first_name="Bob") | Q(first_name="Robert"), ).get_or_create(last_name="Marley", defaults={"first_name": "Bob"}) ``` Má aimsítear rudaí iolracha, ardaíonn ```get_or_create () `:exc: `~django.core.exceptions.multipleObjectsReturned`. Má aimsítear réad *ní fhaightear, déanfaidh `get_or_create () ``réad nua a thabhairt isteach agus a shábháil, ag tabhairt tuple den réad nua agus ``True``` ar ais. Cruthófar an réad nua go garbh de réir an algartam seo: ``` params = {k: v for k, v in kwargs.items() if "__" not in k} params.update({k: v() if callable(v) else v for k, v in defaults.items()}) obj = self.model(**params) obj.save() ``` I mBéarla, ciallaíonn sé sin tosú le haon argóint eochairfhocal neamh-`defaults` nach bhfuil béim dhúbailte ann (a chuirfeadh le fios cuardach neamhchruinn). Ansin cuir ábhar defaults\`, ag cur aon eochracha a shárú más gá, agus bain úsáid as an toradh mar na hargóintí eochairfhocal chuig an rang samhail. Má tá aon ghlaonna in `defaults`, déan meastóireacht orthu. Mar a thuairiscítear thuas, is simplíocht é seo ar an algartam a úsáidtear, ach tá na sonraí ábhartha go léir ann. Tá níos mó seiceála earráidí ag an gcur i bhfeidhm inmheánach ná seo agus láimhseálann sé roinnt coinníollacha imeall breise; má tá suim agat, léigh an cód. Má tá réimse agat darb ainm `defaults` agus má theastaíonn uait é a úsáid mar chuardach cruinn i ```get_or_create () ``, bain úsáid as ``'defaults__exact'```, mar sin: ``` Foo.objects.get_or_create(defaults__exact="bar", defaults={"defaults": "baz"}) ``` Tá iompar earráide comhchosúil ag an modh get\_or\_create () leas:meth: create () \`nuair a bhíonn eochracha bunscoile sonraithe de láimh á úsáid agat. Más gá réad a chruthú agus má tá an eochair ann cheana sa bhunachar sonraí, ardófar an:exc: \`~django.db.IntegrityError. Faoi dheireadh, focal maidir le ```get_or_create () ``a úsáid i dtuairimí Django. Déan cinnte go n-úsáidfidh tú é ach amháin in iarratais ``POST ``mura bhfuil cúis mhaith agat gan a dhéanamh. Níor cheart go mbeadh aon éifeacht ag iarratais ``GET``` ar shonraí. Ina áit sin, bain úsáid as POST aon uair a bhíonn fo-éifeacht ag iarraidh ar leathanach ar do chuid sonraí. \<9110 #section -9.2.1\>Le haghaidh tuilleadh, féach: rfc: Modhanna sábháilte' sa shonraíocht HTTP. > **Warning** > > Is féidir leat tréithe get\_or\_create () a úsáid trí:class: ~django.db.models.manyToManyField agus caidreamh aisiompthe. Sa chás sin cuirfidh tú srian ar na ceisteanna taobh istigh de chomhthéacs an chaidrimh sin. D'fhéadfadh sé sin roinnt fadhbanna sláine a bheith mar thoradh ort mura n-úsáideann tú é go comhsheasmhach. > > Mar na samhlacha seo a leanas: > > ``` > class Chapter(models.Model): > title = models.CharField(max_length=255, unique=True) > > > class Book(models.Model): > title = models.CharField(max_length=256) > chapters = models.ManyToManyField(Chapter) > ``` > > Is féidir leat get\_or\_create () a úsáid trí réimse caibidlí an Leabhair, ach ní fhaigheann sé ach taobh istigh de chomhthéacs an leabhair sin: > > ```pycon > >>> book = Book.objects.create(title="Ulysses") > >>> book.chapters.get_or_create(title="Telemachus") > (, True) > >>> book.chapters.get_or_create(title="Telemachus") > (, False) > >>> Chapter.objects.create(title="Chapter 1") > > >>> book.chapters.get_or_create(title="Chapter 1") > # Raises IntegrityError > ``` > > This is happening because it's trying to get or create "Chapter 1" through the > book "Ulysses", but it can't do either: the relation can't fetch that chapter > because it isn't related to that book, but it can't create it either because > `title` field should be unique. #### Update\_or\_create () \`\` #### `update_or_create(defaults=None, create_defaults=None, **kwargs)` #### `aupdate_or_create(defaults=None, create_defaults=None, **kwargs)` *Leagan asincrón*: aupdate\_or\_create () \`\` Modh áisiúlachta chun réad a nuashonrú leis an kwargs \`\`tugtha, ceann nua a chruthú más gá. Is foclóirí de phéirí (réimse, luach) iad \`create\_defaults\` agus defaults\` araon. Is féidir na luachanna i create\_defaults\` agus defaults\` araon a bheith inghlaonta. Úsáidtear `defaults` chun an réad a nuashonrú agus úsáidtear `create_defaults` don oibríocht chruthaigh. Mura gcuirtear create\_defaults\` ar fáil, úsáidfear `defaults` don oibríocht chruthaithe. Tugann sé tuple de `(réad, cruthaithe)`, ina bhfuil ```réad ``an rud cruthaithe nó nuashonraithe agus is boolean é ``cruthaithe``` a shonraíonn an cruthaíodh réad nua. Déanann an modh update\_or\_create\` iarracht réad a fháil ón mbunachar sonraí bunaithe ar an kwargs \`\`tugtha. Má aimsítear meaitseáil, nuashonraíonn sé na réimsí a rith sa fhoclóir \`\`defaults. Tá sé seo i gceist mar aicearra chuig cód boilerplatish. Mar shampla: ``` defaults = {"first_name": "Bob"} create_defaults = {"first_name": "Bob", "birthday": date(1940, 10, 9)} try: obj = Person.objects.get(first_name="John", last_name="Lennon") for key, value in defaults.items(): setattr(obj, key, value) obj.save() except Person.DoesNotExist: new_values = {"first_name": "John", "last_name": "Lennon"} new_values.update(create_defaults) obj = Person(**new_values) obj.save() ``` Éiríonn an patrún seo go leor de réir mar a théann líon na réimsí i samhail suas. Is féidir an sampla thuas a athscríobh ag baint úsáide as update\_or\_create () mar sin: ``` obj, created = Person.objects.update_or_create( first_name="John", last_name="Lennon", defaults={"first_name": "Bob"}, create_defaults={"first_name": "Bob", "birthday": date(1940, 10, 9)}, ) ``` Le haghaidh tuairisc mhionsonraithe ar an gcaoi a réitear ainmneacha a rith in kwargs\`, féach:meth: get\_or\_create. Mar a thuairiscítear thuas in:meth: get\_or\_create, tá seans go mbeidh coinníoll rásaíochta ag an modh seo a d'fhéadfadh sraitheanna iolracha a chur isteach ag an am céanna mura gcuirtear uathúlacht i bhfeidhm ag leibhéal an bhunachar sonraí. Cosúil le: Meth: get\_or\_create agus:meth: create, má tá eochracha bunscoile sonraithe de láimh á úsáid agat agus má chaithfear réad a chruthú ach tá an eochair ann cheana sa bhunachar sonraí, an:exc: ~django.db.IntegrityError ardaítear. #### bulk\_create () \`\` #### `bulk_create(objs, batch_size=None, ignore_conflicts=False, update_conflicts=False, update_fields=None, unique_fields=None)` #### `abulk_create(objs, batch_size=None, ignore_conflicts=False, update_conflicts=False, update_fields=None, unique_fields=None)` *Asynchronous version*: `abulk_create()` Cuireann an modh seo an liosta rudaí a chuirtear ar fáil isteach sa bhunachar sonraí ar bhealach éifeachtach (de ghnáth ní amháin ceist amháin, is cuma cé mhéad rudaí atá ann), agus tugann sé rudaí cruthaithe ar ais mar liosta, san ord céanna mar a chuirtear ar fáil: ```pycon >>> objs = Entry.objects.bulk_create( ... [ ... Entry(headline="This is a test"), ... Entry(headline="This is only a test"), ... ] ... ) ``` Tá roinnt rabhaidh aige seo áfach: - Ní ghlaofar modh ```save () ``an tsamhail, agus ní sheolfar na comharthaí ``pre_save``` agus `post_save`. - Ní oibríonn sé le samhlacha leanaí i gcás oidhreachta il-tábla. - Más é príomh-eochair an tsamhail ná: class: ~django.db.models.autofield agus `ignore_conflicts` False, ní féidir an príomh-thréith a aisghabháil ach ar bhunachair sonraí áirithe (PostgreSQL, MariaDB, agus SQLite 3.35+ faoi láthair). Ar bhunachair sonraí eile, ní shocrófar é. - 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 batch_size = 100 objs = (Entry(headline="Test %s" % i) for i in range(1000)) while True: batch = list(islice(objs, batch_size)) if not batch: break Entry.objects.bulk_create(batch, batch_size) ``` The `batch_size` parameter controls how many objects are created in a single query. The default is to create as many objects in one batch as the database will allow. (SQLite and Oracle limit the number of parameters in a query.) Ar bhunachair sonraí a thacaíonn leis (uile ach Oracle), deir an paraiméadar ignore\_conflicts\` a shocrú go `True` don bhunachar sonraí neamhaird a dhéanamh ar theip ar aon sraitheanna a chur isteach ina theipeann srianta mar luachanna uathúla dúbailte. Ar bhunachair sonraí a thacaíonn leis (uile seachas Oracle), ag socrú an paraiméadar `update_conflicts` go True\`, insíonn don bhunachar sonraí `update_fields` a nuashonrú nuair a theipeann ar ionchur sraith ar choimhlintí. Ar PostgreSQL agus SQLite, i dteannta le update\_fields\`, ní mór liosta de `unique_fields` a d'fhéadfadh a bheith i gcoinbhleacht a sholáthar. Déanann an paraiméadar ignore\_conflicts\` a chumasú ar an bpríomh-eochair a shocrú ar gach samhail (má thacaíonn an bunachar sonraí leis de ghnáth). > **Warning** > > Ar MySQL agus MariaDB, déanann an paraiméadar ignore\_conflicts\` a shocrú go `True`, iompaíonn cineálacha áirithe earráidí, seachas eochair dúbailte, ina rabhaidh. Fiú amháin le Mód Dian. Mar shampla: luachanna neamhbhailí nó sáruithe neamh-inneamhnaithe. Féach an doiciméadú MySQL \_ agus doiciméadú MariaDB \_ le haghaidh tuilleadh sonraí. #### bulk\_update () \`\` #### `bulk_update(objs, fields, batch_size=None)` #### `abulk_update(objs, fields, batch_size=None)` *Asynchronous version*: `abulk_update()` Nuashonraíonn an modh seo na réimsí tugtha go héifeachtúil ar na cásanna samhail a chuirtear ar fáil, go ginearálta le ceist amháin, agus filleann sé líon na ruda ```pycon >>> objs = [ ... Entry.objects.create(headline="Entry 1"), ... Entry.objects.create(headline="Entry 2"), ... ] >>> objs[0].headline = "This is entry 1" >>> objs[1].headline = "This is entry 2" >>> Entry.objects.bulk_update(objs, ["headline"]) 2 ``` : meth: Úsáidtear .querySet.Update chun na hathruithe a shábháil, mar sin tá sé seo níos éifeachtaí ná athrú tríd an liosta samhlacha agus glaoch ar save () ar gach ceann acu, ach tá cúpla rabhadh aige: - Ní féidir leat príomh-eochair an tsamhail a nuashonrú. - Ní thugtar ar mhodh save () \`\`gach samhail, agus ní sheoltar na comharthaí: attr: \`~django.db.models.signals.pre\_save agus:attr: ~django.db.models.signals.post\_save. - Má nuashonraítear líon mór colúin i líon mór sraitheanna, is féidir leis an SQL a ghintear a bheith an-mhór. Seachain é seo trí batch\_size\` oiriúnach a shonrú. - When updating a large number of objects, be aware that `bulk_update()` prepares all of the `WHEN` clauses for every object across all batches before executing any queries. This can require more memory than expected. To reduce memory usage, you can use an approach like this: ``` from itertools import islice batch_size = 100 ids_iter = range(1000) while ids := list(islice(ids_iter, batch_size)): batch = Entry.objects.filter(ids__in=ids) for entry in batch: entry.headline = f"Updated headline {entry.pk}" Entry.objects.bulk_update(batch, ["headline"], batch_size=batch_size) ``` - Beidh ceist bhreise in aghaidh an sinsear ag nuashonrú réimsí a shainmhínítear ar sinsear oidhreachta - Nuair a bhíonn dúbailtí i mbaisc aonair, ní bheidh nuashonrú mar thoradh ar an gcéad chás sa bhaisc sin. - D'fhéadfadh go mbeadh líon na rudaí a nuashonraíonn an fheidhm ar ais níos lú ná líon na rudaí a chuirtear isteach. D'fhéadfadh sé seo a bheith mar gheall ar rudaí dúblacha a rith ina ndéantar nuashonrú sna dálaí baisc nó cine céanna ionas nach bhfuil rudaí i láthair sa bhunachar sonraí a thuilleadh. Rialaíonn an paraiméadar `batch_size` cé mhéad rudaí a shábháiltear in aon cheist amháin. Is é an réamhshocrú ná gach rud a nuashonrú i mbaisc amháin, ach amháin SQLite agus Oracle a bhfuil srianta acu ar líon na n-athróg a úsáidtear i gceist. #### comhaireamh () \`\` #### `count()` #### `acount()` *Asynchronous version*: `acount()` Filleann sé sláimhir a léiríonn líon na rudaí sa bhunachar sonraí a mheaitseann leis an `QuerySet`. Sampla: ``` # Returns the total number of entries in the database. Entry.objects.count() # Returns the number of entries whose headline contains 'Lennon' Entry.objects.filter(headline__contains="Lennon").count() ``` Déanann glao ````count () ```SELECT COUNT (*)```` taobh thiar de na radhairc, mar sin ba chóir duit ```count () ``a úsáid i gcónaí seachas an taifead go léir a luchtú isteach i rudaí Python agus glaoch ar `len ()``` ar an toradh (mura gcaithfidh tú na rudaí a luchtú i gcuimhne ar aon nós, sa chás sin beidh len () níos gasta). Tabhair faoi deara más mian leat líon na míreanna i `QuerySet` agus má tá tú ag aisghabháil cásanna samhail uaidh freisin (mar shampla, trí athrú air), is dócha go mbeidh sé níos éifeachtaí ```len (queryset) ``a úsáid nach gcuirfidh ceist bunachar sonraí breise mar ``count ()```. Má tá an tacar ceisteanna aisghabháilte go hiomlán cheana féin, úsáidfidh count () an fad sin seachas ceist breise bunachar sonraí a dhéanamh. #### in\_bulk () \`\` #### `in_bulk(id_list=None, * (Keyword-only parameters separator (PEP 3102)), field_name='pk')` #### `ain_bulk(id_list=None, * (Keyword-only parameters separator (PEP 3102)), field_name='pk')` *Asynchronous version*: `ain_bulk()` Glacann sé liosta de luachanna réimse (`id_list`) agus an `field_name` do na luachanna sin, agus filleann sé foclóir a mhapáil gach luach go sampla den réad leis an luach réimse a thugtar. No:exc: Ardóidh eisceachtaí django.core.exceptions.objectDoesNotExist riamh le `in_bulk`; is é sin, ní dhéanfar neamhaird ar aon luach `id_list` nach bhfuil meaitseáil le haon chás. Mura gcuirtear `id_list` ar fáil, cuirtear gach rud sa tacar fiosrúcháin ar ais. Caithfidh field\_name\` a bheith ina réimse uathúil nó ina réimse ar leith (mura bhfuil ach réimse amháin ann a shonraítear in:meth: distint). Réamhshocraíonn `field_name` don eochair phríomhúil. Sampla: ```pycon >>> Blog.objects.in_bulk([1]) {1: } >>> Blog.objects.in_bulk([1, 2]) {1: , 2: } >>> Blog.objects.in_bulk([]) {} >>> Blog.objects.in_bulk() {1: , 2: , 3: } >>> Blog.objects.in_bulk(["beatles_blog"], field_name="slug") {'beatles_blog': } >>> Blog.objects.distinct("name").in_bulk(field_name="name") {'Beatles Blog': , 'Cheddar Talk': , 'Django Weblog': } ``` Má chuireann tú liosta folamh ar in\_bulk () , gheobhaidh tú foclóir folamh. #### iterator () \`\` #### `iterator(chunk_size=None)` #### `aiterator(chunk_size=None)` *Asynchronous version*: `aiterator()` Déanann sé meastóireacht ar an `QuerySet` (tríd an bhfiosrú a dhéanamh) agus filleann sé athraitheoir (féach: pep: 234) thar na torthaí, nó athraitheoir asincrónach (féach: pep: 492) má ghlaonn tú ar a leagan asincrónach `aiterator`. De ghnáth cuireann “QuerySet” a thorthaí a chosc go hinmheánach ionas nach mbíonn ceisteanna breise mar thoradh ar mheastóireachtaí arís agus arís eile. I gcodarsnacht leis sin, léifidh ```iterator () ``torthaí go díreach, gan aon chaching a dhéanamh ag an leibhéal ``QuerySet` (go hinmheánach, glaonn an t-iterator réamhshocraithe ``iterator ()``` agus cuireann sé an luach tuairisceáin). Maidir le QuerySet\` a thugann líon mór rudaí ar ais nach gá duit rochtain a fháil ach uair amháin, d'fhéadfadh feidhmíocht níos fearr agus laghdú suntasach ar chuimhne a bheith mar thoradh air seo. 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](#sqlite) \< [https://www.sqlite.org/limits.html#max\_variable\_number](https://www.sqlite.org/limits.html#max_variable_number)\>), d'fhéadfadh go mbeadh uaslíon téarmaí i gclásal SQL ```IN ``teoranta. Dá bhrí sin ba chóir luachanna faoi bhun an teorainn seo a úsáid. (Go háirithe, nuair a bhíonn dhá chaidreamh nó níos mó á réamhghabháil agat, ba chóir go mbeadh `chunk_size``` beag go leor go dtitfidh an líon na dtorthaí a bhfuil súil leis do gach caidreamh réamhfhaighte faoi bhun an teorainn fós.) Chomh fada agus nach bhfaigheann an QuerySet aon rudaí gaolmhara roimh ré, ní úsáidfidh Django réamhshocrú intuigthe 2000 mar thoradh ar aon luach a sholáthar do chunk\_size\`. Ag brath ar chúlcheann an bhunachar sonraí, luchtálfar torthaí fiosrúcháin uile ag an am céanna nó a shruthú ón mbunachar sonraí ag baint úsáide as cúrsóirí taobh an fhre ##### Le cúrsaí taobh an fhreastalaí Úsáideann Oracle agus:ref: PostgreSQL \\`cúrsaí taobh an fhreastalaí chun torthaí a shruthlú ón mbunachar sonraí gan an tacar toradh iomlán a luchtú isteach i gcuimhne. Úsáideann tiománaí bunachar sonraí Oracle cúrsóirí taobh an fhreastalaí Le cúrsóirí taobh an fhreastalaí, sonraíonn an paraiméadar `chunk_size` líon na dtorthaí le taisce ag leibhéal tiománaí an bhunachar sonraí. Laghdaíonn píosaí níos mó a fháil líon na dturais babhta idir tiománaí an bhunachar sonraí agus an bunachar sonraí, ar chostas na cuimhne. \Ar PostgreSQL, ní úsáidfear cúrsóirí taobh an fhreastalaí ach nuair is é an socrú: setting: DISABLE\_SERVER\_SIDE\_CURSORS \`\`False\`. léitheo:ref: transaction-pooling-server-side-cursors má tá poiblí nasc á úsáid agat atá cumraithe i mód comhionannaithe idirbheart. Nuair a dhéantar cúrsóirí taobh an fhreastalaí a dhíchumasú, tá an t-iompar mar an gcéanna le bunachair sonraí nach dtacaíonn le cúrsóirí taobh an f ##### Gan cúrsaí taobh an fhreastalaí Ní thacaíonn MySQL le torthaí sruthú, dá bhrí sin luchtaíonn tiománaí bunachar sonraí Python an toradh iomlán atá leagtha síos Ansin déantar an tacar torthaí a athrú go rudaí sraithe Python ag an oiriúnaitheoir bunachar sonraí ag baint úsáide as an modh fetchmany () atá sainmhínithe in:pep: 249. Is féidir le SQLite torthaí a fháil i mbaisceanna ag baint úsáide as fetchmany () , ach ós rud é nach soláthraíonn SQLite aonrú idir ceisteanna laistigh de nasc, bí cúramach agus tú ag scríobh chuig an tábla atá á athrá. Féach: ref: sqlite-isolation le haghaidh tuilleadh faisnéise. Rialaíonn an paraiméadar `chunk_size` méid na mbaisceanna a aisghabhann Django ón tiománaí bunachar sonraí. Laghdaíonn baisceanna níos mó lasbhaird cumarsáide leis an tiománaí bunachar sonraí ar chostas méadú beag ar thomhaltas cuimhne. \< \>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 ó : > Ag glacadh leis sraitheanna de 10-20 colún le meascán de shonraí téacsúla agus uimhriúla, tá 2000 chun níos lú ná 100KB sonraí a fháil, rud is cosúil gur comhréiteach maith é idir líon na sraitheanna a aistrítear agus na sonraí a scriosadh má imeádtar an lúb go luath. #### is déanaí () \`\` #### `latest(*fields)` #### `alatest(*fields)` *Leagan asincrón*: alatest () \`\` Tugann sé an réad is déanaí sa tábla ar ais bunaithe ar na réimsí (í) ar leith. Tugann an sampla seo an Entry\` is déanaí sa tábla, de réir réimse `pub_date`: ``` Entry.objects.latest("pub_date") ``` Is féidir leat an ceann is déanaí a roghnú bunaithe ar roinnt réimsí. Mar shampla, chun an Entry\` a roghnú leis an `expire_date` is luaithe nuair a bhíonn an pub\_date\` céanna ag dhá iontráil: ``` Entry.objects.latest("pub_date", "-expire_date") ``` Ciallaíonn an comhartha diúltach in ``` `'-expire_date'` ``dáta deighilte ``` a shórtáil san ordú\*downing\*. Ós rud é go bhfaigheann ```latest () ``an toradh deireanach, roghnaítear an ``Entry``` leis an `expire_date` is luaithe. Má shonraíonn do mhúnlaí:ref: Meta \: 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. Cosúil le: Meth: get () \`, \`\`() \`\`agus \`\`latest ()\` 'ardaithe:exc: ~django.db.models.model.doesNotExist mura bhfuil aon rud ann leis na paraiméadair a thugtar. Tabhair faoi deara go bhfuil ```is luaithe () ``agus ``is déanaí ()``` ann ach ar mhaithe le háisiúlacht agus inléiteacht. > **Féadfaidh `is luaithe () ``agus ``latest () cásanna a thabhairt ar ais le dátaí neall.** > > Ós rud é go ndéantar ordú a tharmligtear chuig an mbunachar sonraí, féadfar torthaí ar réimsí a cheadaíonn luachanna neall a ordú ar bhealach difriúil Mar shampla, déanann PostgreSQL agus MySQL luachanna null a shórtáil amhail is dá mbeadh siad níos airde ná luachanna neamh-niall, agus déanann SQLite a mhalairt. > > B'fhéidir gur mhaith leat luachanna null a scagadh amach: > > ``` > Entry.objects.filter(pub_date__isnull=False).latest("pub_date") > ``` #### is luaithe () \`\` #### `earliest(*fields)` #### `aearliest(*fields)` *Leagan asincrón*: aearly () \`\` Oibríonn sé ar shlí eile cosúil:meth: ~django.db.models.query.queryset.latest ach amháin go n-athraítear an treo. #### chéad () \` #### `first()` #### `afirst()` *Leagan asincrón*: first () \` Filleann sé an chéad réad a mheaitseáil leis an tacar fiosrúcháin, nó `None` mura bhfuil aon rud meaitseála ann. Mura bhfuil aon ordú sainmhínithe ag an QuerySet\`, ansin ordaítear an tacar fiosrúcháin go huathoibríoch ag an eochair phríomhúil. Féadfaidh sé seo dul i bhfeidhm ar thorthaí comhiomlánaithe mar a thuairiscítear in:ref: comhiomlán-ordú-idirghníomhach Sampla: ``` p = Article.objects.order_by("title", "pub_date").first() ``` Tabhair faoi deara gur modh áisiúlachta é first () , tá an sampla cód seo a leanas comhionann leis an sampla thuas: ``` try: p = Article.objects.order_by("title", "pub_date")[0] except IndexError: p = None ``` #### deireanach () \` #### `last()` #### `alast()` *Leagan asincrón*: alast () \`\` Oibríonn sé cosúil le: meth: first () , ach filleann sé an rud deireanach sa tacar ceisteanna. #### comhiomlán () \`\` #### `aggregate(*args, **kwargs)` #### `aaggregate(*args, **kwargs)` *Leagan asincrón*: aaggregate () \`\` Tugann foclóir ar ais de luachanna comhiomlána (meáin, suimeanna, srl.) arna ríomh thar an QuerySet\`. Sonraíonn gach argóint le comhiomlán () luach a chuirfear san áireamh sa fhoclóir a thugtar ar ais. Déantar cur síos ar na feidhmeanna comhiomlánaithe a sholáthraíonn Django i [Feidhmeanna Comhiomlánacha](#id6) thíos. Ós rud é go bhfuil comhiomlánaithe freis:doc: léirithe fiosraithe', féadfaidh tú comhiomláin a chomhcheangal le comhiomlán\ acha nó luachanna eile chun comhiomlánacha casta a chruthú. Úsáidfidh comhiomlánaithe a shonraítear ag úsáid argóintí eochairfhocal an eochairfhocal mar ainm don anótáil Beidh ainm ag argóintí gan ainm a ghintear dóibh bunaithe ar ainm na feidhme chomhiomlán agus ar an réimse samhail atá á chomhiomlánú. Ní féidir le comhiomlánaithe casta argóintí gan ainm a úsáid agus ní mór argóint eochairfhocal a shonrú mar ailias Mar shampla, nuair a bhíonn tú ag obair le hiontrálacha blag, b'fhéidir gur mhaith leat a fháil amach líon na n-údar a chuir iontrálacha blag leis: ```pycon >>> from django.db.models import Count >>> Blog.objects.aggregate(Count("entry__authors")) {'entry__authors__count': 16} ``` Trí argóint eochairfhocal a úsáid chun an fheidhm chomhiomlán a shonrú, is féidir leat ainm an luach comhiomlánaithe a chuirtear ar ais a rialú: ```pycon >>> Blog.objects.aggregate(number_of_authors=Count("entry__authors")) {'number_of_authors': 16} ``` Le haghaidh plé domhain ar chomhiomlánú, féach:doc: an treoir ábhair ar Chomhiomlán' \. #### ann () \`\` #### `exists()` #### `aexists()` *Leagan asincrón*: aexists () \`\` Tugann sé `True` má tá aon torthaí an:class: .QuerySet, agus `False` mura bhfuil. Déanann sé seo iarracht an cheist a dhéanamh ar an mbealach is simplí agus is gasta is féidir, ach déanann sé\* beagnach an cheist céanna a fhorghníomhú le fiosrúchán gnáth:class: .querySet. [`exists()`](#django.db.models.query.QuerySet.exists) is useful for searches relating to the existence of any objects in a [`QuerySet`](#django.db.models.query.QuerySet), particularly in the context of a large [`QuerySet`](#django.db.models.query.QuerySet). Chun a fháil amach an bhfuil aon earraí i tacar fiosrúcháin: ``` if some_queryset.exists(): print("There is at least one object in some_queryset") ``` Cé a bheidh níos gasta ná: ``` if some_queryset: print("There is at least one object in some_queryset") ``` ... ach ní ar leibhéal mór (dá bhrí sin teastaíonn tacar fiosrúcháin mór uait le haghaidh gnóthachain éifeachtúlachta). Ina theannta sin, mura ndearnadh meastóireacht ar some\_queryset\` fós, ach tá a fhios agat go mbeidh sé ag pointe éigin, ansin déanfaidh some\_queryset.exists () níos mó obair fhoriomlán (ceist amháin maidir leis an seiceáil ann móide ceann breise chun na torthaí a aisghabháil níos déanaí) ná bool (some\_queryset) a úsáid, a aisghabhann na torthaí agus ansin seiceálann an raibh aon cheann ann ar ais. #### `tá ()` #### `contains(obj)` #### `acontains(obj)` *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()`](#django.db.models.query.QuerySet.contains) is useful for checking an object membership in a [`QuerySet`](#django.db.models.query.QuerySet), particularly in the context of a large [`QuerySet`](#django.db.models.query.QuerySet). Chun a sheiceáil an bhfuil mír ar leith i tacar fiosrúcháin: ``` if some_queryset.contains(obj): print("Entry contained in queryset") ``` Beidh sé seo níos gasta ná an méid seo a leanas a éilíonn measúnú agus athrá tríd an tacar ceisteanna iomlán: ``` if obj in some_queryset: print("Entry contained in queryset") ``` Cosúil le: Meth: exists, mura ndearnadh meastóireacht fós ar ```some_queryset ``, ach tá a fhios agat go mbeidh sé ag pointe éigin, ansin déanfar ceist bunachar sonraí breise ag baint úsáide as `some_queryset.contents (obj)```, agus go ginearálta beidh feidhmíocht fhoriomlán níos moille mar thoradh air. #### nuashonrú () \`\` #### `update(**kwargs)` #### `aupdate(**kwargs)` *Asynchronous version*: `aupdate()` Déanann sé fiosrúchán nuashonraithe SQL do na réimsí sonraithe, agus filleann sé líon na sraitheanna a mheaitseáil ar ais (nach bhféadfadh a bheith cothrom le líon na sraitheanna a nuashonraítear má tá an luach nua ag roinnt sraitheanna Mar shampla, chun tuairimí a mhúchadh do gach iontráil blag a foilsíodh in 2010, d'fhéadfá é seo a dhéanamh: ```pycon >>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False) ``` (Glacann sé leis seo go bhfuil réimsí `pub_date` agus `comments_on` ag do mhúnla Iontrála\`.) Is féidir leat réimsí iolracha a nuashonrú - níl aon teorainn ar cé mhéad. Mar shampla, anseo déanaimid na réimsí `comments_on` agus `headline` a nuashonrú: ```pycon >>> Entry.objects.filter(pub_date__year=2010).update( ... comments_on=False, headline="This is old" ... ) ``` Cuirtear an modh update () \`i bhfeidhm láithreach, agus is é an t-aon srian ar an: class: \`.querySet a nuashonraítear ná nach féidir leis ach colúin a nuashonrú i bpríomh-thábla an tsamhail, ní ar mhúnlaí gaolmhara. Ní féidir leat é seo a dhéanamh, mar shampla: ```pycon >>> Entry.objects.update(blog__name="foo") # Won't work! ``` Is féidir scagadh bunaithe ar réimsí gaolmhara fós, áfach: ```pycon >>> Entry.objects.filter(blog__id=1).update(comments_on=True) ``` Ní féidir leat glaoch ar update () ar a:class: .QuerySet a bhfuil slisnas tógtha nó nach féidir é a scagadh a thuilleadh. Tugann an modh update () líon na sraitheanna atá buailte ar ais: ```pycon >>> Entry.objects.filter(id=64).update(comments_on=True) 1 >>> Entry.objects.filter(slug="nonexistent-slug").update(comments_on=True) 0 >>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False) 132 ``` Mura bhfuil tú ach taifead a nuashonrú agus mura gá duit aon rud a dhéanamh leis an réad samhail, is é an cur chuige is éifeachtaí ná glaoch ar update () , seachas an réad samhail a luchtú isteach i gcuimhne. Mar shampla, in ionad seo a dhéanamh: ``` e = Entry.objects.get(id=10) e.comments_on = False e.save() ``` ... déan seo: ``` Entry.objects.filter(id=10).update(comments_on=False) ``` Cuireann úsáid ```nuashonrú () ``cosc ar riocht rása ina bhféadfadh rud éigin athrú i do bhunachar sonraí sa tréimhse ghearr ama idir an réad a luchtú agus glaoch ar `save ()```. > **MySQL does not support self-select updates** > > On MySQL, `QuerySet.update()` may execute a `SELECT` followed by an > `UPDATE` instead of a single `UPDATE` when filtering on related tables, > which can introduce a race condition if concurrent changes occur between > the queries. To ensure atomicity, consider using transactions or avoiding > such filter conditions on MySQL. \Mar fhocal scoir, tuig go ndéanann update () \`\`nuashonrú ar an leibhéal SQL agus, dá bhrí sin, ní ghlaonn sé aon mhodhanna \`\`save () \`ar do mhúnlaí, ná ní scaoileann sé na comharthaí: attr: \`~django.db.models.post\_save (atá mar thoradh ar ghlao: meth: Model.save ()). Más mian leat dornán taifid a nuashonrú do mhúnla a bhfuil modh saincheaptha: meth: ~django.db.models.model.save () \`, lúb orthu agus glaoigh ar: meth: \`~django.db.models.model.save (), mar seo: ``` for e in Entry.objects.filter(pub_date__year=2010): e.comments_on = False e.save() ``` ##### Tacar ceisteanna ordaithe Ní thacaítear le slabhraíocht ```order_by () ``le `update ()``` ach ar MariaDB agus MySQL, agus déantar neamhaird air do bhunachar sonraí éagsúla. Tá sé seo úsáideach chun réimse uathúil a nuashonrú san ord a shonraítear gan choimhlintí. Mar shampla: ``` Entry.objects.order_by("-number").update(number=F("number") + 1) ``` > **Note** > > Déanfar neamhaird ar chlásal order\_by () má tá anótaí ann, réimsí oidhreachta, nó cuardaigh a chuimsíonn caidreamh. #### scrios () \`\` #### `delete()` #### `adelete()` *Leagan asincrón*: adelete () \`\` Déanann sé ceist scriosta SQL ar gach sraitheanna san: class: .querySet agus filleann sé líon na rudaí a scriosadh agus foclóir le líon na scriosadh in aghaidh an chineál réada. Cuirtear an delete () i bhfeidhm láithreach. Ní féidir leat glaoch ar delete () ar a:class: .QuerySet a bhfuil slisnas tógtha air nó nach féidir é a scagadh a thuilleadh. Mar shampla, chun na hiontrálacha go léir i mblag áirithe a scriosadh: ```pycon >>> b = Blog.objects.get(pk=1) # Delete all the entries belonging to this Blog. >>> Entry.objects.filter(blog=b).delete() (4, {'blog.Entry': 2, 'blog.Entry_authors': 2}) ``` De réir réamhshocraithe, déanann django's:class: ~django.db.models.foreignKey aithris ar an srian SQL `ON DELETE CASCADE` \- i bhfocail eile, scriosfar aon rudaí le heochracha eachtracha atá ag díriú ar na rudaí atá le scriosadh in éineacht leo. Mar shampla: ```pycon >>> blogs = Blog.objects.all() # This will delete all Blogs and all of their Entry objects. >>> blogs.delete() (5, {'blog.Blog': 1, 'blog.Entry': 2, 'blog.Entry_authors': 2}) ``` Is féidir an t-iompar cascaire seo inoiriúnaithe tríd an argóint: attr: ~django.db.models.foreignkey.on\_delete chuig an argóint: :class: ~django.db.models.foreignKey. Déanann an modh ```delete () ``scriosadh mórchóir agus ní ghlaonn sé aon mhodhanna ``delete ()``` ar do mhúnlaí. Astaíonn sé, áfach, na comharthaí: data: ~django.db.models.signals.pre\_delete agus:data: ~django.db.models.signals.post\_delete do gach rud scriosta (lena n-áirítear scriosadh cascadaithe). Caithfidh Django rudaí a fháil isteach i gcuimhne chun comharthaí a sheoladh agus cascades a láimhseáil. Mar sin féin, mura bhfuil aon cascades agus aon chomharthaí ann, ansin féadfaidh Django cosán tapa a ghlacadh agus rudaí a scriosadh gan a fháil isteach i gcuimhne. Maidir le scriosadh móra is féidir úsáid cuimhne laghdaithe go suntasach mar thoradh air seo. Is féidir méid na gceisteanna forghníomhaithe a laghdú freisin. Ní chuireann ForeignKeys atá socraithe to:attr: ~django.db.models.foreignkey.on\_delete DO\_NOTHING\` cosc ar an gcosán tapa a ghlacadh le scriosadh. Tabhair faoi deara gur mionsonraí cur chun feidhme iad na ceisteanna a ghintear i scriosadh réada faoi réir athraithe. #### as\_bainisteoir () \`\` #### `classmethod as_manager()` Modh aicme a thugann sampla de:class: ~Django.db.Models.Manager le cóip de mhodhanna `QuerySet`. Féach:ref: create-manager-with-queryset-methods le haghaidh tuilleadh sonraí. Tabhair faoi deara, murab ionann agus na hiontrálacha eile sa chuid seo, níl leagan asincrónach aige seo toisc nach bhfeidhmíonn sé ceist. #### mhínigh () \`\` #### `explain(format=None, **options)` #### `aexplain(format=None, **options)` *Leagan asincrónaithe*: aexample () \`\` Tugann sé sreang de phlean forghníomhaithe QuerySet\` ar ais, a chuireann mionsonraí ar an gcaoi a ndéanfadh an bunachar sonraí an cheist a fhorghníomhú, lena n-áirítear aon innéacsanna nó comhpháirteanna a úsáidfeadh. D'fhéadfadh eolas a fháil ar na sonraí seo cabhrú leat feidhmíocht na gceisteanna mall a fheabh Mar shampla, agus PostgreSQL á úsáid agat: ```pycon >>> print(Blog.objects.filter(title="My Blog").explain()) Seq Scan on blog (cost=0.00..35.50 rows=10 width=12) Filter: (title = 'My Blog'::bpchar) ``` Tá difríocht shuntasach idir bunachair sonraí an aschur. Tacaíonn gach cúltaca bunachar sonraí ionsuite le explain () ach amháin Oracle toisc nach bhfuil cur i bhfeidhm ann simplí. Athraíonn an paraiméadar ```formáid` an fhormáid aschuir ó réamhshocraithe na mbunachair sonraí, atá bunaithe ar théacs de ghnáth. Tacaíonn PostgreSQL le formáidí ``'TEXT'```, `JSON'`, `YAML'`, agus `` `XML' ``. Tacaíonn MariaDB agus MySQL le formáidí `'TEXT'` (ar a dtugtar `` `TRADITIONAL `` freisin) agus `` `JSON ``. Tacaíonn MySQL 8.0.16+ le formáid “TREE” feabhsaithe freisin, atá cosúil le aschur `TEXT` PostgreSQL agus úsáidtear de réir réamhshocraithe, má thacaítear leis. 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: ```pycon >>> print(Blog.objects.filter(title="My Blog").explain(verbose=True, analyze=True)) Seq Scan on public.blog (cost=0.00..35.50 rows=10 width=12) (actual time=0.004..0.004 rows=10 loops=1) Output: id, title Filter: (blog.title = 'My Blog'::bpchar) Planning time: 0.064 ms Execution time: 0.058 ms ``` Ar roinnt bunachair sonraí, d'fhéadfadh bratacha a bheith ina chúis leis an bhfiosrú a fhorghníomhú a d'fhéadfadh éifeachtaí díobhálacha Mar shampla, d'fhéadfadh athruithe ar shonraí a bheith mar thoradh ar an mbratach ANALYZE\` le tacaíocht ó MariaDB, MySQL 8.0.18+, agus PostgreSQL má tá spreagthaí ann nó má ghlaítear feidhm, fiú le haghaidh ceist `SELECT`. > **Changed in Django 5.1** > > Cuireadh tacaíocht don rogha generic\_plan ar PostgreSQL 16+ leis. > **Changed in Django 5.2** > > Support for the `memory` and `serialize` options on PostgreSQL 17+ was > added. ### Cuardaigh `Field` Is iad cuardaigh réimse an chaoi a shonraíonn tú feoil clásal SQL `WHERE`. Sonraítear iad mar argóintí eochairfhocal leis na modhanna `QuerySet`: meth: filter () \`, :meth: \`eisiamh () agus:meth: get () . \Le haghaidh réamhrá, féach:ref: samhlacha agus doiciméadú ceisteanna bunachar sonraí . Tá cuardaigh ionsuite Django liostaithe thíos. Is féidir freisin a scríobh: doc: saincheaptha cuardach do réimsí samhail. \ Mar áisiúlacht nuair nach gcuirtear aon chineál cuardaigh ar fáil (cosúil le Entry.Objects.get (id=14) \`) glactar leis gurb é an cineál cuardaigh: lookup: exact. #### `` `cruth `` 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í: ``` Entry.objects.get(id__exact=14) Entry.objects.get(id__exact=None) ``` Coibhéisí SQL: ```sql SELECT ... WHERE id = 14; SELECT ... WHERE id IS NULL; ``` > **Comparáidí MySQL** > > I MySQL, cinneann socrú “comhdhlúthú” tábla bunachar sonraí an bhfuil comparáidí cruinn íogair cás-íogair. Is socrú bunachar sonraí é seo, \* ní\* suíomh Django. Is féidir do tháblaí MySQL a chumrú chun comparáidí cás-íogair a úsáid, ach tá roinnt trádálacha i gceist. Le haghaidh tuilleadh faisnéise faoi seo, féach an ranna:ref: colation \`sa doiciméadúiséis:doc: \`\ \databases. #### `iacr` 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: ``` Blog.objects.get(name__iexact="beatles blog") Blog.objects.get(name__iexact=None) ``` Coibhéisí SQL: ```sql SELECT ... WHERE name ILIKE 'beatles blog'; SELECT ... WHERE name IS NULL; ``` Tabhair faoi deara go mbeidh an chéad cheist ag teacht le `` 'Beatles Blog` ``, ``` ``beatles blog ` ```, `Beatles Blog`, srl. > **Úsáideoirí SQLite** > > \Agus na teaghráin cúltaca SQLite agus neamh-ASCII á n-úsáid agat, cuimhnigh: ref: nóta bunachar sonraí faoi chomparáidí teaghráin. Ní dhéanann SQLite meaitseáil cás-neamh-íogair le haghaidh teaghráin neamh-ASCII. #### `Coimeád` Tástáil srianta cás-íogair. Sampla: ``` Entry.objects.get(headline__contains="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline LIKE '%Lennon%'; ``` Tabhair faoi deara go mbeidh sé seo comhoiriúnach leis an gceannteideal 'Lennon onóir inneo' ach ní lennon onóir inneo'. > **Úsáideoirí SQLite** > > Ní thacaíonn SQLite le ráitis LIKE atá íogair ó cháis; gníomhaíonn contains\` mar icontains do SQLite. Féach an:ref: nóta bunachar sonraí \\`le haghaidh tuilleadh eolais. #### `Icontains` Tástáil srianta cás-neamh-íogair. Sampla: ``` Entry.objects.get(headline__icontains="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline ILIKE '%Lennon%'; ``` > **Úsáideoirí SQLite** > > \Agus na teaghráin cúltaca SQLite agus neamh-ASCII á n-úsáid agat, cuimhnigh: ref: nóta bunachar sonraí faoi chomparáidí teaghráin. #### Invalid section title or transition marker. I athraitheach ar leith; go minic liosta, tuple, nó tacar fiosrúcháin. Ní cás úsáide coitianta é, ach glactar le teaghráin (atá inathraithe). Samplaí: ``` Entry.objects.filter(id__in=[1, 3, 4]) Entry.objects.filter(headline__in="abc") ``` Coibhéisí SQL: ```sql SELECT ... WHERE id IN (1, 3, 4); SELECT ... WHERE headline IN ('a', 'b', 'c'); ``` Is féidir leat tacar ceisteanna a úsáid freisin chun liosta luachanna a mheas go dinimiciúil in ionad liosta de luachanna liteartha a sholáthar: ``` inner_qs = Blog.objects.filter(name__contains="Cheddar") entries = Entry.objects.filter(blog__in=inner_qs) ``` Déanfar an tacar ceisteanna seo a mheas mar ráiteas fo-roghnaithe: ```sql SELECT ... WHERE blog.id IN (SELECT id FROM ... WHERE NAME LIKE '%Cheddar%') ``` Má théann tú isteach i `QuerySet` a eascraíonn as ```values () ``nó `values_list ()``` mar luach chuig cuardach `__in`, ní mór duit a chinntiú nach bhfuil ach réimse amháin á bhaint agat sa toradh. Mar shampla, oibreoidh sé seo (scagadh ar ainmneacha an bhlag): ``` inner_qs = Blog.objects.filter(name__contains="Ch").values("name") entries = Entry.objects.filter(blog__name__in=inner_qs) ``` Ardóidh an sampla seo eisceacht, ós rud é go bhfuil an cheist istigh ag iarraidh dhá luach réimse a bhaint, áit nach bhfuiltear ag súil le ceann amháin: ``` # Bad code! Will raise a TypeError. inner_qs = Blog.objects.filter(name__contains="Ch").values("name", "id") entries = Entry.objects.filter(blog__name__in=inner_qs) ``` > **Creithniúcháin** > > Bí cúramach faoi cheisteanna neadaithe a úsáid agus tuig tréithe feidhmíochta do fhreastalaí bunachar sonraí (má tá amhras ort, tagarmharc!). Ní dhéanann roinnt cúltaca bunachar sonraí, go háirithe MySQL, ceisteanna neadaithe a bharrfheabhsú go han-mhaith. Tá sé níos éifeachtaí, sna cásanna sin, liosta luachanna a bhaint agus ansin é a chur isteach sa dara ceist. Is é sin, déan dhá cheist a fhorghníomhú in ionad ceann amháin: > > ``` > values = Blog.objects.filter(name__contains="Cheddar").values_list("pk", flat=True) > entries = Entry.objects.filter(blog__in=list(values)) > ``` > > Tabhair faoi deara an ghlao ```list () ``timpeall an Blag ``QuerySet``` chun an chéad cheist a chur i bhfeidhm. Gan é, déanfaí ceist neadaithe a fhorghníomhú, toisc go ndéanfaí: ref: querysets-are-lazy. #### `gt` Níos mó ná. Sampla: ``` Entry.objects.filter(id__gt=4) ``` Coibhéis SQL: ```sql SELECT ... WHERE id > 4; ``` #### `gte` Níos mó ná nó comhionann leis. #### `lt` Níos lú ná. #### `` `lte `` Níos lú ná nó cothrom le. #### tosaíonn leis \`\` Tosaíonn cás-íogair - le. Sampla: ``` Entry.objects.filter(headline__startswith="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline LIKE 'Lennon%'; ``` Ní thacaíonn SQLite le ráitis LIKE atá íogair ó cháis; gníomhaíonn startswith mar istartswith do SQLite. #### istartswith\` Tosaíonn cás-neamh-íogair - le. Sampla: ``` Entry.objects.filter(headline__istartswith="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline ILIKE 'Lennon%'; ``` > **Úsáideoirí SQLite** > > \Agus na teaghráin cúltaca SQLite agus neamh-ASCII á n-úsáid agat, cuimhnigh: ref: nóta bunachar sonraí faoi chomparáidí teaghráin. #### Críochnaíonn \`\` Críochna cás-íogair - le. Sampla: ``` Entry.objects.filter(headline__endswith="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline LIKE '%Lennon'; ``` > **Úsáideoirí SQLite** > > Ní thacaíonn SQLite le ráitis `LIKE` íogair cás-íogair; gníomhaíonn endswith mar iendswith\` do SQLite. Féach ar an doiciméadach:ref: bunachar sonraí \\`le haghaidh tuilleadh eolais. #### `` `Idirleith `` Críochtaí cás-neamh-íogair - le. Sampla: ``` Entry.objects.filter(headline__iendswith="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline ILIKE '%Lennon' ``` > **Úsáideoirí SQLite** > > \Agus na teaghráin cúltaca SQLite agus neamh-ASCII á n-úsáid agat, cuimhnigh: ref: nóta bunachar sonraí faoi chomparáidí teaghráin. #### raon \`\` Tástáil raon (cuimsitheach). Sampla: ``` import datetime start_date = datetime.date(2005, 1, 1) end_date = datetime.date(2005, 3, 31) Entry.objects.filter(pub_date__range=(start_date, end_date)) ``` Coibhéis SQL: ```sql SELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31'; ``` Is féidir leat ```raon ``a úsáid in áit ar bith is féidir leat ``BETWEEN``` a úsáid i SQL - le haghaidh dátaí, uimhreacha agus fiú carachtair. > **Warning** > > Ní chuimsíonn scagadh ```DateTimefield` le dátaí míreanna ar an lá deiridh, toisc go léirmhínítear na teorainneacha mar “0am ar an dáta ar leith”. Dá mbeadh ``pub_date``` ina DateTimefield\`, déanfaí an abairt thuas a iompú isteach sa SQL seo: > > ```sql > SELECT ... WHERE pub_date BETWEEN '2005-01-01 00:00:00' and '2005-03-31 00:00:00'; > ``` > > Go ginearálta, ní féidir leat dátaí agus dáta a mheascadh. #### Dáta \`\` Maidir le réimsí dáta-am, caitheann an luach mar dháta. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach dáta. Sampla: ``` Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun Nuair: SETTING: Is é USE\_TZ `True`, déantar réimsí a thiontú go dtí an crios ama reatha sula ndéantar iad a scagadh. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `bliant` Maidir le réimsí dáta agus dáta, cluiche bliana cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé bliain slámhshláir. Sampla: ``` Entry.objects.filter(pub_date__year=2005) Entry.objects.filter(pub_date__year__gte=2005) ``` Coibhéis SQL: ```sql SELECT ... WHERE pub_date BETWEEN '2005-01-01' AND '2005-12-31'; SELECT ... WHERE pub_date >= '2005-01-01'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) Nuair: Socrú: Is é USE\_TZ `True`, déantar réimsí dáta-ama a thiontú go dtí an crios ama reatha sula ndéantar iad a scagadh. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `iso_bliain` Maidir le réimsí dáta agus dáta, comhoiriúnú bliana uimhrithe seachtaine cruinn ISO 8601. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé bliain slámhshláir. Sampla: ``` Entry.objects.filter(pub_date__iso_year=2005) Entry.objects.filter(pub_date__iso_year__gte=2005) ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `mhí` Maidir le réimsí dáta agus dáta, cluiche míosa cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir 1 (Eanáir) trí 12 (Nollaig). Sampla: ``` Entry.objects.filter(pub_date__month=12) Entry.objects.filter(pub_date__month__gte=6) ``` Coibhéis SQL: ```sql SELECT ... WHERE EXTRACT('month' FROM pub_date) = '12'; SELECT ... WHERE EXTRACT('month' FROM pub_date) >= '6'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `Lae` Maidir le réimsí dáta agus dáta, cluiche lá cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé lá sláireach. Sampla: ``` Entry.objects.filter(pub_date__day=3) Entry.objects.filter(pub_date__day__gte=3) ``` Coibhéis SQL: ```sql SELECT ... WHERE EXTRACT('day' FROM pub_date) = '3'; SELECT ... WHERE EXTRACT('day' FROM pub_date) >= '3'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le dáta pub\_date ar an tríú lá den mhí, mar shampla 3 Eanáir, 3 Iúil, srl. 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `seachtaine` Mai\< \> dir le réimsí dáta agus dáta, cuir ar ais uimhir na seachtaine (1-52 nó 53) de réir [ISO-8601](#iso-8601), ie, tosaíonn seachtainí Dé Luain agus tá an chéad Déardaoin na bliana sa chéad seachtain. Sampla: ``` Entry.objects.filter(pub_date__week=52) Entry.objects.filter(pub_date__week__gte=32, pub_date__week__lte=38) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `Lae_na seachtaine` Maidir le réimsí dáta agus dáta-am, cluiche 'lá na seachtaine'. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Dé Domhnaigh) go 7 (Dé Sathairn). Sampla: ``` Entry.objects.filter(pub_date__week_day=2) Entry.objects.filter(pub_date__week_day__gte=2) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le `pub_date` a thiteann Dé Luain (lá 2 den tseachtain), beag beann ar an mí nó an bhliain ina dtarlaíonn sé. Déantar laethanta na seachtaine a innéacsú agus lá 1 é Dé Domhnaigh agus lá 7 ina Dé Sathairn. 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `Lae_iso_seachtaine` Maidir le réimsí dáta agus dáta-am, cluiche cruinn lá ISO 8601 den tseachtain. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach sláimhir a léiríonn lá na seachtaine ó 1 (Luan) go 7 (Dé Domhnaigh). Sampla: ``` Entry.objects.filter(pub_date__iso_week_day=1) Entry.objects.filter(pub_date__iso_week_day__gte=1) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun Tabhair faoi deara go gcuirfidh sé seo aon taifead a mheaitseáil le `pub_date` a thiteann Dé Luain (lá 1 den tseachtain), beag beann ar an mí nó an bhliain ina dtarlaíonn sé. Déantar laethanta na seachtaine a innéacsú agus lá 1 é Dé Luan agus lá 7 é Dé Domhnaigh. 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `Ráith` Maidir le réimsí dáta agus dáta, cluiche 'ceathrú den bhliain'. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé luach sláimhir idir 1 agus 4 a léiríonn ráithe den bhliain. Sampla chun iontrálacha a aisghabháil sa dara ráithe (1 Aibreán go 30 Meitheamh): ``` Entry.objects.filter(pub_date__quarter=2) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### Am \` Maidir le réimsí dáta-ama, caitheann an luach mar am. Ligeann sé cuardaigh réimse breise a shlánú. Glacann sé: aicme: luach datetime.time. Sampla: ``` Entry.objects.filter(pub_date__time=datetime.time(14, 30)) Entry.objects.filter(pub_date__time__range=(datetime.time(8), datetime.time(17))) ``` (Níl aon bhrúin coibhéiseach cód SQL san áireamh don chuardach seo toisc go n-athraíonn cur i bhfeidhm na fiosrúcháin ábhartha i measc innill bhun Nuair: SETTING: Is é USE\_TZ `True`, déantar réimsí a thiontú go dtí an crios ama reatha sula ndéantar iad a scagadh. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `uair an chloig` Maidir le réimsí dáta agus ama, meaitseáil uair an chloig cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 23. Sampla: ``` Event.objects.filter(timestamp__hour=23) Event.objects.filter(time__hour=5) Event.objects.filter(timestamp__hour__gte=12) ``` Coibhéis SQL: ```sql SELECT ... WHERE EXTRACT('hour' FROM timestamp) = '23'; SELECT ... WHERE EXTRACT('hour' FROM time) = '5'; SELECT ... WHERE EXTRACT('hour' FROM timestamp) >= '12'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `nóiméad` Maidir le réimsí dáta agus ama, cluiche beacht nóiméad. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 59. Sampla: ``` Event.objects.filter(timestamp__minute=29) Event.objects.filter(time__minute=46) Event.objects.filter(timestamp__minute__gte=29) ``` Coibhéis SQL: ```sql SELECT ... WHERE EXTRACT('minute' FROM timestamp) = '29'; SELECT ... WHERE EXTRACT('minute' FROM time) = '46'; SELECT ... WHERE EXTRACT('minute' FROM timestamp) >= '29'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### an dara \` Maidir le réimsí dáta agus ama, an dara cluiche cruinn. Ligeann sé cuardaigh réimse breise a shlánú. Tógann sé sláimhir idir 0 agus 59. Sampla: ``` Event.objects.filter(timestamp__second=31) Event.objects.filter(time__second=2) Event.objects.filter(timestamp__second__gte=31) ``` Coibhéis SQL: ```sql SELECT ... WHERE EXTRACT('second' FROM timestamp) = '31'; SELECT ... WHERE EXTRACT('second' FROM time) = '2'; SELECT ... WHERE EXTRACT('second' FROM timestamp) >= '31'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) 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. \Éilíonn sé seo: ref: sainmhínithe crios ama sa bhunachar sonraí . #### `isnull` Glacann sé `True` nó False\`, a fhreagraíonn do cheisteanna SQL de IS NULL\` agus `IS NOT NULL`, faoi seach. Sampla: ``` Entry.objects.filter(pub_date__isnull=True) ``` Coibhéis SQL: ```sql SELECT ... WHERE pub_date IS NULL; ``` #### `Regex` Meaitseáil léirithe rialta íogair do chás- Is é an comhréiteach abairt rialta ná cúltaca an bhunachar sonraí atá in úsáid. I gcás SQLite, nach bhfuil aon tacaíocht léirithe ionsuite aige, soláthraíonn feidhm REGEXP (Python) atá sainmhínithe ag úsáideoir an ghné seo, agus dá bhrí sin is é an comhréiteach abairt rialta modúl re\` Python. Sampla: ``` Entry.objects.get(title__regex=r"^(An?|The) +") ``` Coibhéisí SQL: ```sql SELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL SELECT ... WHERE REGEXP_LIKE(title, '^(An?|The) +', 'c'); -- Oracle SELECT ... WHERE title ~ '^(An?|The) +'; -- PostgreSQL SELECT ... WHERE title REGEXP '^(An?|The) +'; -- SQLite ``` Moltar teaghráin amh a úsáid (m.sh., r'foo'\` in ionad `'foo'`) chun comhréiteach an abairt rialta a chur isteach. #### `iregex` Meaitseáil léirithe rialta neamh-íogair. Sampla: ``` Entry.objects.get(title__iregex=r"^(an?|the) +") ``` Coibhéisí SQL: ```sql SELECT ... WHERE title REGEXP '^(an?|the) +'; -- MySQL SELECT ... WHERE REGEXP_LIKE(title, '^(an?|the) +', 'i'); -- Oracle SELECT ... WHERE title ~* '^(an?|the) +'; -- PostgreSQL SELECT ... WHERE title REGEXP '(?i)^(an?|the) +'; -- SQLite ``` ### Feidhmeanna comhiomlán Soláthraíonn Django na feidhmeanna comhiomlánaithe seo a leanas sa mhodúl `django.db.models`. Le haghaidh sonraí maidir le conas na feidhmeanna comhiomlána seo a úsáid, féach:doc: an treoir ábhair ar chomhiomlán' \. Féach an doiciméadach:class: \`~django.db.models.aggregate chun foghlaim conas do chomhiomláin a chruthú. > **Warning** > > Ní féidir le SQLite comhiomlánú a láimhseáil ar réimsí dáta/ama as an mbosca. Tá sé seo toisc nach bhfuil aon réimsí dáta/ama dúchasacha i SQLite agus déanann Django aithris ar na gnéithe seo faoi láthair ag baint úsáide as réimse téacs. Ardóidh iarrachtaí comhiomlánú ar réimsí dáta/ama i SQLite `NotSupportedError`. > **Ceisteanna nó grúpaí folamh** > > Tugann feidhmeanna comhiomlánaithe `None` ar ais nuair a úsáidtear iad le ```QuerySet` nó grúpa folamh. Mar shampla, filleann an fheidhm chomhiomlánaithe ``Sum``` `None` in ionad `0` mura bhfuil aon iontrálacha sa `QuerySet` nó d'aon ghrúpa folamh i `QuerySet` neamh-folamh. Chun luach eile a thabhairt ar ais ina ionad sin, sainmhínigh an argóint `réamhshocraithe`. Is eisceacht é `Count` ón iompar seo; filleann sé `0` má tá an `QuerySet` folamh ós rud é nach dtacaíonn `Count` leis an argóint `réamhshocraithe`. Tá na paraiméadair seo a leanas i gcoiteann ag gach comhiomlán: #### `léiritheach` Teagáin a thagraíonn réimsí ar an tsamhail, athraíonn an réimse, nó:doc: abairtí fiosraitheach' \. #### `réimseach_aschuir` Argóint roghnach a léiríonn na:doc: réimse samhail den luach tuairisceáin \ > **Note** > > Agus cineálacha réimse iolracha á gcomhcheangal agat, ní féidir le Django ach an output\_field a chinneadh má tá gach réimse den chineál céanna. Seachas sin, ní mór duit an output\_field\` a sholáthar duit féin. #### `Scagair` Rud roghnach: class: Q \\`a úsáidtear chun na sraitheanna atá comhiomlánaithe a scagadh. Féach: ref: comhiomlánú coinníollach agus:ref: filtering-on-annotations mar shampla úsáid. #### `réamhshocraithe` Argóint roghnach a cheadaíonn luach a shonrú le húsáid mar luach réamhshocraithe nuair nach bhfuil aon iontrálacha sa tacar ceisteanna (nó an grúpáil). #### `**breise` Argóintí eochairfhocal ar féidir leo comhthéacs breise a sholáthar don SQL a ghineann an comhiomlán #### `Avg` #### `class Avg(expression, output_field=None, distinct=False, filter=None, default=None, **extra)` Tugann sé meánluach an abairt a thugtar ar ais, a chaithfidh a bheith uimhriúil mura sonraíonn tú output\_field\` difriúil. - \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. #### `distinct` Roghnach. Má tá `Distinct=True`, filleann `Avg` meánluach na luachanna uathúla ar ais. \Is é seo an coibhéis SQL le AVG (DISTINCT) . Is é “False” an luach réamhshocraithe. #### `Comhaireant` #### `class Count(expression, distinct=False, filter=None, **extra)` 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 (*)```. - \Ainm réamhshocraithe: `__count` - Cineál tuairisceáin: `int` #### `distinct` Roghnach. Má tá Distinct=True\`, ní chuimsíonn an comhaireamh ach cásanna uathúla. Is é seo an coibhéis SQL le COUNT (DISTINCT\) . Is é “False” an luach réamhshocraithe. > **Note** > > Ní thacaítear leis an argóint `réamhshocraithe`. #### `Uasmhéad` #### `class Max(expression, output_field=None, filter=None, default=None, **extra)` Tugann sé luach uasta an léirithe a thugtar ar ais. - \Ainm réamhshocraithe: `__max` - Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó `output_field` má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear `réamhshocraithe` ar ais. #### `Mion` #### `class Min(expression, output_field=None, filter=None, default=None, **extra)` Tugann sé luach íosta na léirithe tugtha ar ais. - \Ainm réamhshocraithe: `__min` - Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó `output_field` má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear `réamhshocraithe` ar ais. #### `Stddev` #### `class StdDev(expression, output_field=None, sample=False, filter=None, default=None, **extra)` Tugann sé diall caighdeánach na sonraí san abairt a chuirtear ar fáil ar ais. - \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. #### `sample` Roghnach. De réir réamhshocraithe, filleann `stdDev` an diall caighdeánach daonra ar ais. Mar sin féin, má tá `sample=True`, is é an luach tuairisceáin an diall caighdeánach samplach. #### `Sum` #### `class Sum(expression, output_field=None, distinct=False, filter=None, default=None, **extra)` Ríomhann sé suim na luachanna uile den abairt ar leith. - \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. #### `distinct` Roghnach. Má tá `Distinct=True`, filleann `Sum` suim na luachanna uathúla. Is é seo an coibhéis SQL le SUM (DISTINCT\) . Is é “False” an luach réamhshocraithe. #### `Athraithe` #### `class Variance(expression, output_field=None, sample=False, filter=None, default=None, **extra)` Tugann sé athrú na sonraí san abairt a chuirtear ar fáil ar ais. - \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. #### `sample` 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. ## Uirlisí a bhaineann le fiosrú Soláthraíonn an chuid seo ábhar tagartha d'uirlisí a bhaineann le fiosrúcháin nach ndéanfar ### Q () rudaí #### `class Q` Léiríonn réad ```Q () ``riocht SQL is féidir a úsáid in oibríochtaí a bhaineann le bunachar sonraí. Tá sé cosúil leis an gcaoi a léiríonn réad an:class: `F () `luach réimse samhail nó anótála. Déanann siad coinníollacha a shainiú agus a athúsáid. Is féidir iad seo a dhiúltú ag baint úsáide as an oibreoir ``~``` (```NOT ``), agus a chur le chéile ag baint úsáide as oibreoirí mar `|``` (`OR`), `&` (`AND`), agus `^` (XOR\`). Féach: ref: complex-lookups-with-q. ### Prefetch () rudaí #### `class Prefetch(lookup, queryset=None, to_attr=None)` Is féidir an réad Prefetch () a úsáid chun oibriú: meth: ~django.db.models.queryset.prefetch\_related () a rialú. Déanann an argóint `lookup` cur síos ar na caidrimh atá le leanúint agus oibríonn sé mar an gcéanna leis na cuardaigh sreanga-bhunaithe a chuirtear chuig: meth: ~django.db.models.query.queryset.prefetch\_related () . Mar shampla: ```pycon >>> from django.db.models import Prefetch >>> Question.objects.prefetch_related(Prefetch("choice_set")).get().choice_set.all() , , ]> # This will only execute two queries regardless of the number of Question # and Choice objects. >>> Question.objects.prefetch_related(Prefetch("choice_set")) ]> ``` Soláthraíonn an argóint ```Queryset ``bonn ``QuerySet``` don chuardach ar leith. Tá sé seo úsáideach chun an oibríocht réamhfhillte a scagadh síos, nó glaoch ar: meth: ~django.db.models.query.queryset.select\_related () ón ngaol réamhfhaighte, agus mar sin laghdaítear líon na gceisteanna níos mó fós: ```pycon >>> voted_choices = Choice.objects.filter(votes__gt=0) >>> voted_choices ]> >>> prefetch = Prefetch("choice_set", queryset=voted_choices) >>> Question.objects.prefetch_related(prefetch).get().choice_set.all() ]> ``` Socraíonn an argóint to\_attr\` toradh na hoibríochta réamhfhillte go tréith saincheaptha: ```pycon >>> prefetch = Prefetch("choice_set", queryset=voted_choices, to_attr="voted_choices") >>> Question.objects.prefetch_related(prefetch).get().voted_choices [] >>> Question.objects.prefetch_related(prefetch).get().choice_set.all() , , ]> ``` > **Note** > > Nuair a úsáidtear `to_attr`, stóráiltear an toradh réamhfhaighte i liosta. Féadann sé seo feabhas suntasach luais a sholáthar thar ghlaonna traidisiúnta prefetch\_related\` a stóráilíonn an toradh taisceáilte laistigh de shampla QuerySet\`. ### rudaí prefetch\_gaolmhara () \`\` #### `prefetch_related_objects(model_instances, *related_lookups)` #### `aprefetch_related_objects(model_instances, *related_lookups)` *Asynchronous version*: `aprefetch_related_objects()` Faigheann sé na cuardaigh a thugtar roimh ré ar chásanna samhail atá inathraithe. Tá sé seo úsáideach sa chód a fhaigheann liosta de na cásanna samhail seachas QuerySet\`; mar shampla, nuair a bhíonn samhlacha á bhfaigheann tú ó taisce nó iad ag instanciú de láimh. Rith athraitheach cásanna samhail (caithfidh gach duine a bheith den rang céanna) agus na rudaí cuardaigh nó:class: Prefetch is mian leat réamhfhaighteacht dóibh. Mar shampla: ```pycon >>> from django.db.models import prefetch_related_objects >>> restaurants = fetch_top_restaurants_from_cache() # A list of Restaurants >>> prefetch_related_objects(restaurants, "pizzas__toppings") ``` Agus bunachair sonraí iolracha á n-úsáid agat le `prefetch_related_objects`, úsáidfidh an ceist réamhfhreastail an bunachar sonraí a bhaineann leis an samhail samhail. Is féidir é seo a shárú trí thacar ceisteanna saincheaptha a úsáid i gcuardach gaolmhar. ### FilteredRelation () rudaí #### `class FilteredRelation(relation_name, * (Keyword-only parameters separator (PEP 3102)), condition=Q())` #### `relation_name` Ainm an réimse ar mhaith leat an gaol a scagadh air. #### `condition` A: Aicme: ~ Django.db.Models.q in aghaidh an scagadh a rialú. Úsáidtear `FilteredRelation` le:meth: ~.queryset.annotate () \`chun clásal \`\`ON\` a chruthú nuair a dhéantar `JOIN`. Ní ghníomhaíonn sé ar an gcaidreamh réamhshocraithe ach ar an ainm anótála (`pizzas_vegetarian` i sampla thíos). Mar shampla, chun bialanna a fháil a bhfuil pizzes vegetarian acu le `` `mozzarella `` san ainm: ```pycon >>> from django.db.models import FilteredRelation, Q >>> Restaurant.objects.annotate( ... pizzas_vegetarian=FilteredRelation( ... "pizzas", ... condition=Q(pizzas__vegetarian=True), ... ), ... ).filter(pizzas_vegetarian__name__icontains="mozzarella") ``` Má tá líon mór píosaí ann, feidhmíonn an tacar ceisteanna seo níos fearr ná: ```pycon >>> Restaurant.objects.filter( ... pizzas__vegetarian=True, ... pizzas__name__icontains="mozzarella", ... ) ``` toisc nach n-oibreoidh an scagadh i gclásal `WHERE` den chéad tacar fiosrúcháin ach ar phiotsaí vegetarian. Ní thacaíonn `FilteredRelation` le: - : meth: .queryset.only agus:meth: ~.queryset.prefetch\_related. - A: Class: ~django.contrib.contentTypes.Fields.GenericForeignKey oidhreachta ó mhúnla tuismitheora.