--- title: "Tagairt API ``QuerySet ``" version: 6.1 locale: ga source: https://docs.djangoproject.com/ga/6.1/ref/models/querysets/ canonical: https://djangodocs.dev/ga/6.1/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` if the `QuerySet` is ordered — i.e. has an [`order_by()`](#django.db.models.query.QuerySet.order_by) clause or a default ordering on the model. `False` otherwise. #### `totally_ordered` > **New in Django 6.1** Returns `True` if the `QuerySet` is ordered and the ordering is deterministic. This requires that the ordering includes a field (or set of fields) that is unique and non-nullable. For queries involving a `GROUP BY` clause, the model's default ordering is ignored. Ordering specified via `.extra(order_by=...)` is also ignored. #### `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. If you need to execute more complex queries (for example, queries with `OR` statements), you can use [\`\`Q () \`\`rudaí](#q-objects) (`*args`). #### 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/6.1/ref/models/expressions/) or [\`\`Q () \`\`rudaí](#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) ``` `alias()` can be used in conjunction with [`annotate()`](#django.db.models.query.QuerySet.annotate), [`exclude()`](#django.db.models.query.QuerySet.exclude), [`filter()`](#django.db.models.query.QuerySet.filter), [`order_by()`](#django.db.models.query.QuerySet.order_by), and [`update()`](#django.db.models.query.QuerySet.update). To use an aliased expression with other methods (e.g. [`aggregate()`](#django.db.models.query.QuerySet.aggregate)), you must promote it to an annotation: ``` Blog.objects.alias(entries=Count("entry")).annotate( entries=F("entries"), ).aggregate(Sum("entries")) ``` [`filter()`](#django.db.models.query.QuerySet.filter) and [`order_by()`](#django.db.models.query.QuerySet.order_by) can take expressions directly, but expression construction and usage often does not happen in the same place (for example, `QuerySet` method creates expressions, for later use in views). `alias()` allows building complex expressions incrementally (possibly spanning multiple methods and modules), referring to the expression parts by their aliases, and only using [`annotate()`](#django.db.models.query.QuerySet.annotate) for the final result. #### 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. Be cautious when ordering by fields in related models if you are also using [`distinct()`](#django.db.models.query.QuerySet.distinct). See the note in [`distinct()`](#django.db.models.query.QuerySet.distinct) for an explanation of how related model ordering can change the expected results. > **Note** > > Tá sé ceadaithe réimse illuachmhara a shonrú chun na torthaí a ordú trí (mar shampla, a:class: réimse ~django.db.models.manyToManyField, nó an gaol droim a: réimse a:class: ~Django.db.Models.ForeignKey). > > Smaoinigh ar an gcás seo: > > ``` > 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()) ``` If you don't want any ordering to be applied to a query, not even the default ordering, call [`order_by()`](#django.db.models.query.QuerySet.order_by) with no parameters. Is féidir leat a rá an bhfuil ceist ordaithe nó nach bhfuil tríd an tréith: attr: .querySet.Ordered a sheiceáil, a bheidh ina `True` má ordaíodh an `QuerySet` ar bhealach ar bith. Glanfaidh gach glao ```order_by () ``aon ordú roimhe seo. Mar shampla, ordófar an cheist seo ag ``pub_date``` agus ní `headline`: ``` Entry.objects.order_by("headline").order_by("pub_date") ``` > **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. Also, note that `reverse()` should generally only be called on a `QuerySet` which has a defined ordering (e.g., when querying against a model which defines a default ordering, or when using [`order_by()`](#django.db.models.query.QuerySet.order_by)). If no such ordering is defined for a given `QuerySet`, calling `reverse()` on it has no real effect (the ordering was undefined prior to calling `reverse()`, and will remain undefined afterward). #### difriúil () \`\` #### `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. > > Similarly, if you use a [`values()`](#django.db.models.query.QuerySet.values) query to restrict the columns > selected, the columns used in any [`order_by()`](#django.db.models.query.QuerySet.order_by) (or default model > ordering) will still be involved and may affect uniqueness of the results. > > The moral here is that if you are using `distinct()` be careful about > ordering by related models. Similarly, when using `distinct()` and > [`values()`](#django.db.models.query.QuerySet.values) together, be careful when ordering by fields not in the > [`values()`](#django.db.models.query.QuerySet.values) call. Ar PostgreSQL amháin, is féidir leat argóintí seasaimh (\*réimsí \`) a rith d'fhonn ainmneacha na réimsí ar chóir go mbeadh feidhm ag an `DISTINCT` a shonrú. Aistríonn sé seo go fiosrúchán SQL `SELECT DISTINCT ON`. Seo an difríocht. Maidir le gnáthghlao difriúil () , déanann an bunachar sonraí comparáid idir *gach réimse* i ngach sraith agus iad ag cinneadh cé na sraitheanna atá ar leith. Maidir le glao difriúil () le hainmneacha réimse sonraithe, ní dhéanfaidh an bunachar sonraí ach comparáid idir na hainmneacha réimse sonraithe. > **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") ``` - When using `values()` together with [`distinct()`](#django.db.models.query.QuerySet.distinct), be aware that ordering can affect the results. See the note in [`distinct()`](#django.db.models.query.QuerySet.distinct) for details. - If you use a `values()` clause after an [`extra()`](#django.db.models.query.QuerySet.extra) call, any fields defined by a `select` argument in the [`extra()`](#django.db.models.query.QuerySet.extra) must be explicitly included in the `values()` call. Any [`extra()`](#django.db.models.query.QuerySet.extra) call made after a `values()` call will have its extra selected fields ignored. - Calling [`only()`](#django.db.models.query.QuerySet.only) and [`defer()`](#django.db.models.query.QuerySet.defer) after `values()` doesn't make sense, so doing so will raise a `TypeError`. - Éilíonn claochruithe agus comhiomlánaithe a chur le chéile dhá ghlaonna: meth: annotate a úsáid, go sainráite nó mar argóintí eochairfhocal chuig:meth: luacha. Mar atá thuas, má tá an claochlú cláraithe ar an gcineál réimse ábhartha is féidir an chéad:meth: annotate a fhágáil, dá bhrí sin tá na samplaí seo a leanas coibhéiseach: ```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. #### 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. #### 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()` Returns a *copy* of the current `QuerySet` (or `QuerySet` subclass). This can be useful in situations where you might want to pass in either a model manager or a `QuerySet` and do further filtering on the result. After calling `all()` on either object, you'll definitely have a `QuerySet` to work with. \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") ``` In addition, only `LIMIT`, `OFFSET`, `COUNT(*)`, `ORDER BY`, and specifying columns (i.e. slicing, [`count()`](#django.db.models.query.QuerySet.count), [`exists()`](#django.db.models.query.QuerySet.exists), [`order_by()`](#django.db.models.query.QuerySet.order_by), and [`values()`](#django.db.models.query.QuerySet.values)/[`values_list()`](#django.db.models.query.QuerySet.values_list)) are allowed on the resulting `QuerySet`. Further, databases place restrictions on what operations are allowed in the combined queries. For example, most databases don't allow `LIMIT` or `OFFSET` in the combined queries. #### trasna () \`\` #### `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. #### `fetch_mode()` > **New in Django 6.1** #### `fetch_mode(mode)` Returns a `QuerySet` that sets the given fetch mode for all model instances created by this `QuerySet`. The fetch mode controls on-demand loading of fields when they are accessed, such as for foreign keys and deferred fields. For example, to use the [`FETCH_PEERS`](/ga/6.1/topics/db/fetch-modes/#django.db.models.FETCH_PEERS) mode to batch-load all related objects on first access: ```python from django.db import models books = Book.objects.fetch_mode(models.FETCH_PEERS) ``` See more in the [fetch mode topic guide](/ga/6.1/topics/db/fetch-modes/). #### roghnai\_bhainteach () \`\` #### `select_related(*fields)` Returns a `QuerySet` that will join in the named foreign-key relationships, selecting additional related objects when it executes its query. This method can be a performance booster, fetching data ahead of time rather than triggering on-demand loading through the model instances' [fetch mode](/ga/6.1/topics/db/fetch-modes/), at the cost of a more complex initial query. 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 ``` You can use `select_related()` with any queryset. The order of chaining with other methods isn't important. For example, these querysets are equivalent: ``` 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) ``` Then a call to `Book.objects.select_related('author__hometown').get(id=4)` will cache the related `Person` *and* the related `City`: ``` # 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. 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')```. 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. > **Deprecated since Django 6.1** > > Deprecated since version 6.1: Calling `select_related()` with no arguments is deprecated, and support > for it will be removed in Django 7.0. Specify the fields to fetch instead. #### prefetch\_related () \`\` #### `prefetch_related(*lookups)` Returns a `QuerySet` that will automatically retrieve the given lookups, each in one extra batch query. Prefetching is a way to optimize database access when you know you'll be accessing related objects later, so you can avoid triggering the on-demand loading behavior of the model instances' [fetch mode](/ga/6.1/topics/db/fetch-modes/). This method has a similar purpose to [`select_related()`](#django.db.models.query.QuerySet.select_related), in that both are designed to eagerly fetch related objects. However, they work in different ways. 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() , , ...]> ``` 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! > > Also, if you call the database-altering methods > [`add()`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager.add), > [`create()`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager.create), > [`remove()`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager.remove), > [`clear()`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager.clear) or > [`set()`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager.set), on a > [`RelatedManager`](/ga/6.1/ref/models/relations/#django.db.models.fields.related.RelatedManager), any prefetched > cache for the relation will be cleared. 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")) ... ) ``` Or to call [`select_related()`](#django.db.models.query.QuerySet.select_related) when applicable to reduce the number of queries even further: ```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() ``` Custom prefetching also works with single related relations like forward `ForeignKey` or `OneToOneField`. Generally you'll want to use [`select_related()`](#django.db.models.query.QuerySet.select_related) for these relations, but there are a number of cases where prefetching with a custom `QuerySet` is useful: - Ba mhaith leat `QuerySet` a úsáid a dhéanann tuilleadh réamhghabhála ar mhúnlaí gaolmhara. - Ní theastaíonn uait ach fo-thacar de na rudaí gaolmhara a réamh-fháil. - You want to use performance optimization techniques like deferring fields, for example, via [`defer()`](#django.db.models.query.QuerySet.defer) or [`only()`](#django.db.models.query.QuerySet.only): ```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** > > This is an old API that we aim to deprecate at some point in the future. > Use it only if you cannot express your query using other queryset methods. > If you do need to use it, please [file a ticket](https://code.djangoproject.com/newticket) using the [QuerySet.extra > keyword](https://code.djangoproject.com/query?keywords=~QuerySet.extra) > with your use case (please check the list of existing tickets first) so > that we can enhance the QuerySet API to allow removing `extra()`. We are > no longer improving or fixing bugs for this method. > > Mar shampla, an úsáid seo de extra () : > > ```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` The `select` argument lets you put extra fields in the `SELECT` clause. It should be a dictionary mapping attribute names to SQL clauses to use to calculate that attribute. Sampla: ``` 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` If you need to order the resulting queryset using some of the new fields or tables you have included via `extra()` use the `order_by` parameter to `extra()` and pass in a sequence of strings. These strings should either be model fields (as in the normal [`order_by()`](#django.db.models.query.QuerySet.order_by) method on querysets), of the form `table_name.column_name` or an alias for a column that you specified in the `select` parameter to `extra()`. Mar shampla: ``` 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). You can defer loading of fields in related models (if the related models are loading via [`select_related()`](#django.db.models.query.QuerySet.select_related)) by using the standard double-underscore notation to separate related fields: ``` 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) ``` Some fields in a model won't be deferred, even if you ask for them. You can never defer the loading of the primary key. If you are using [`select_related()`](#django.db.models.query.QuerySet.select_related) to retrieve related models, you shouldn't defer the loading of the field that connects from the primary model to the related one, doing so will result in an error. Similarly, calling `defer()` (or its counterpart [`only()`](#django.db.models.query.QuerySet.only)) including an argument from an aggregation (e.g. using the result of [`annotate()`](#django.db.models.query.QuerySet.annotate)) doesn't make sense: doing so will raise an exception. The aggregated values will always be fetched into the resulting queryset. > **Note** > > The `defer()` method (and its cousin, [`only()`](#django.db.models.query.QuerySet.only), below) are only for > advanced use-cases. They provide an optimization for when you have analyzed > your queries closely and understand *exactly* what information you need and > have measured that the difference between returning the fields you need and > the full set of fields for the model will be significant. > > Even if you think you are in the advanced use-case situation, **only use** > `defer()` **when you cannot, at queryset load time, determine if you will > need the extra fields or not**. If you are frequently loading and using a > particular subset of your data, the best choice you can make is to > normalize your models and put the non-loaded data into a separate model > (and database table). If the columns *must* stay in the one table for some > reason, create a model with `Meta.managed = False` (see the > [`managed`](/ga/6.1/ref/models/options/#django.db.models.Options.managed) documentation) containing just > the fields you normally need to load and use that where you might otherwise > call `defer()`. This makes your code more explicit to the reader, is > slightly faster and consumes a little less memory in the Python process. > > 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** > > When calling [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save) for instances with > deferred fields, only the loaded fields will be saved. See > [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save) for more details. #### 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** > > When calling [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save) for instances with > deferred fields, only the loaded fields will be saved. See > [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save) for more details. > **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)` This method is for controlling which database the `QuerySet` will be evaluated against if you are using more than one database. The only argument this method takes is the alias of a database, as defined in [`DATABASES`](/ga/6.1/ref/settings/#std-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) , ...]> ``` The `postgresql`, `oracle`, and `mysql` database backends support `select_for_update()`. However, MariaDB only supports the `nowait` and `skip_locked` arguments, and MySQL supports the `nowait`, `skip_locked`, and `of` arguments. The `no_key` argument is only supported on 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** > > Although `select_for_update()` normally fails in autocommit mode, since > [`TestCase`](/ga/6.1/topics/testing/tools/#django.test.TestCase) automatically wraps each test in a > transaction, calling `select_for_update()` in a `TestCase` even outside > an [`atomic()`](/ga/6.1/topics/db/transactions/#django.db.transaction.atomic) block will (perhaps unexpectedly) > pass without raising a `TransactionManagementError`. To properly test > `select_for_update()` you should use > [`TransactionTestCase`](/ga/6.1/topics/testing/tools/#django.test.TransactionTestCase). > **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()` A convenience method for creating an object and saving it all in one step. Thus: ``` 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)}, ) ``` Any keyword arguments passed to `get_or_create()` — *except* an optional one called `defaults` — will be used in a [`get()`](#django.db.models.query.QuerySet.get) call. If an object is found, `get_or_create()` returns a tuple of that object and `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. You can specify more complex conditions for the retrieved object by chaining `get_or_create()` with `filter()` and using [\`\`Q () \`\`rudaí](#q-objects). For example, to retrieve Robert or Bob Marley if either exists, and create the latter otherwise: ``` 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"}) ``` The `get_or_create()` method has similar error behavior to [`create()`](#django.db.models.query.QuerySet.create) when you're using manually specified primary keys. If an object needs to be created and the key already exists in the database, an [`IntegrityError`](/ga/6.1/ref/exceptions/#django.db.IntegrityError) will be raised. Faoi dheireadh, focal maidir le ```get_or_create () ``a úsáid i dtuairimí Django. Déan cinnte go n-úsáidfidh tú é ach amháin in iarratais ``POST ``mura bhfuil cúis mhaith agat gan a dhéanamh. Níor cheart go mbeadh aon éifeacht ag iarratais ``GET``` ar shonraí. Ina áit sin, bain úsáid as POST aon uair a bhíonn fo-éifeacht ag iarraidh ar leathanach ar do chuid sonraí. \<9110 #section -9.2.1\>Le haghaidh tuilleadh, féach: rfc: Modhanna sábháilte' sa shonraíocht HTTP. > **Warning** > > Is féidir leat tréithe get\_or\_create () a úsáid trí:class: ~django.db.models.manyToManyField agus caidreamh aisiompthe. Sa chás sin cuirfidh tú srian ar na ceisteanna taobh istigh de chomhthéacs an chaidrimh sin. D'fhéadfadh sé sin roinnt fadhbanna sláine a bheith mar thoradh ort mura n-úsáideann tú é go comhsheasmhach. > > Mar na samhlacha seo a leanas: > > ``` > 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: - The model's `save()` method [will not be called](/ga/6.1/topics/db/models/#methods-not-called-on-bulk-operations), and the `pre_save` and `post_save` signals will not be sent. - Ní oibríonn sé le samhlacha leanaí i gcás oidhreachta il-tábla. - If the model's primary key is an [`AutoField`](/ga/6.1/ref/models/fields/#django.db.models.AutoField) or has a [`db_default`](/ga/6.1/ref/models/fields/#django.db.models.Field.db_default) value, and `ignore_conflicts` is `False`, the primary key attribute can only be retrieved on certain databases (currently PostgreSQL, MariaDB, and SQLite). On other databases, it will not be set. - Ní oibríonn sé le caidrimh go leor. - Caitheann sé `objs` chuig liosta, a dhéanann meastóireacht iomlán ar `objs` más gineadóir é. Ligeann an teilgthe gach rud a iniúchadh ionas gur féidir aon rudaí a bhfuil eochair phríomhúil socraithe de láimh acu a chur isteach ar dtús. Más mian leat rudaí a chur isteach i mbaisceanna gan an gineadóir iomlán a mheas ag an am céanna, is féidir leat an teicníc seo a úsáid chomh fada agus nach bhfuil aon eochracha bunscoile socraithe de láimh ag na rudaí: ``` 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ú. - Each model's `save()` method [isn't called](/ga/6.1/topics/db/models/#methods-not-called-on-bulk-operations), and the [`pre_save`](/ga/6.1/ref/signals/#django.db.models.signals.pre_save) and [`post_save`](/ga/6.1/ref/signals/#django.db.models.signals.post_save) signals aren't sent. - 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 = iter(range(1000)) while ids := list(islice(ids_iter, batch_size)): batch = Entry.objects.filter(id__in=ids) for entry in batch: entry.headline = f"Updated headline {entry.pk}" Entry.objects.bulk_update(batch, ["headline"], batch_size=batch_size) ``` - Beidh ceist bhreise in aghaidh an sinsear ag nuashonrú réimsí a shainmhínítear ar sinsear oidhreachta - Nuair a bhíonn dúbailtí i mbaisc aonair, ní bheidh nuashonrú mar thoradh ar an gcéad chás sa bhaisc sin. - D'fhéadfadh go mbeadh líon na rudaí a nuashonraíonn an fheidhm ar ais níos lú ná líon na rudaí a chuirtear isteach. D'fhéadfadh sé seo a bheith mar gheall ar rudaí dúblacha a rith ina ndéantar nuashonrú sna dálaí baisc nó cine céanna ionas nach bhfuil rudaí i láthair sa bhunachar sonraí a thuilleadh. Rialaíonn an paraiméadar `batch_size` cé mhéad rudaí a shábháiltear in aon cheist amháin. Is é an réamhshocrú ná gach rud a nuashonrú i mbaisc amháin, ach amháin SQLite agus Oracle a bhfuil srianta acu ar líon na n-athróg a úsáidtear i gceist. #### comhaireamh () \`\` #### `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. > **Changed in Django 6.1** > > Support for chaining `in_bulk()` after [`values()`](#django.db.models.query.QuerySet.values) or > [`values_list()`](#django.db.models.query.QuerySet.values_list) was added. #### iterator () \`\` #### `iterator(chunk_size=None)` #### `aiterator(chunk_size=None)` *Asynchronous version*: `aiterator()` Evaluates the `QuerySet` (by performing the query) and returns an [iterator](https://docs.python.org/3/glossary.html#term-iterator) over the results, or an [asynchronous iterator](https://docs.python.org/3/glossary.html#term-asynchronous-iterator) if you call its asynchronous version `aiterator`. A `QuerySet` typically caches its results internally so that repeated evaluations do not result in additional queries. In contrast, `iterator()` will read results directly, without doing any caching at the `QuerySet` level. For a `QuerySet` which returns a large number of objects that you only need to access once, this can result in better performance and a significant reduction in memory. Tabhair faoi deara go gcuirfidh úsáid ```iterator () ``ar `QuerySet``` a rinneadh meastóireacht cheana féin iallach air a mheas arís, ag athdhéanamh an cheist. Tá ```iterator () ``comhoiriúnach le glaonna roimhe seo chuig ``prefetch_related ()``` fad is a thugtar `chunk_size`. Beidh níos lú ceisteanna ag teastáil ó luachanna níos mó chun an réamhghabháil a chur i gcrích ar chostas níos mó úsáide cuimhne. Ar roinnt bunachair sonraí (m.sh. Oracle, [SQLite](#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. Like [`get()`](#django.db.models.query.QuerySet.get), `earliest()` and `latest()` raise [`DoesNotExist`](/ga/6.1/ref/models/class/#django.db.models.Model.DoesNotExist) if there is no object with the given parameters. Tabhair faoi deara go bhfuil ```is luaithe () ``agus ``is déanaí ()``` ann ach ar mhaithe le háisiúlacht agus inléiteacht. > **Féadfaidh `is luaithe () ``agus ``latest () cásanna a thabhairt ar ais le dátaí neall.** > > Ós rud é go ndéantar ordú a tharmligtear chuig an mbunachar sonraí, féadfar torthaí ar réimsí a cheadaíonn luachanna neall a ordú ar bhealach difriúil Mar shampla, déanann PostgreSQL agus MySQL luachanna null a shórtáil amhail is dá mbeadh siad níos airde ná luachanna neamh-niall, agus déanann SQLite a mhalairt. > > B'fhéidir gur mhaith leat luachanna null a scagadh amach: > > ``` > 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 () \` Returns the first object matched by the queryset, or `None` if there is no matching object. If the `QuerySet` has no ordering defined (and has not had ordering forcibly cleared by calling [`order_by()`](#django.db.models.query.QuerySet.order_by) with no arguments), then the queryset is automatically ordered by the primary key. This can affect aggregation results as described in [Idirghníomhaíocht le \`\`order\_by () \`\`](/ga/6.1/topics/db/aggregation/#aggregation-ordering-interaction). 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 ``` > **Changed in Django 6.1** > > `first()` and [`last()`](#django.db.models.query.QuerySet.last) no longer order by the primary key when > ordering has been forcibly cleared by calling [`order_by()`](#django.db.models.query.QuerySet.order_by) with no > arguments. #### deireanach () \` #### `last()` #### `alast()` *Leagan asincrón*: alast () \`\` Works like [`first()`](#django.db.models.query.QuerySet.first), but returns the last object in the queryset. #### 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. Finally, realize that `update()` does an update at the SQL level and, thus, method [does not call](/ga/6.1/topics/db/models/#methods-not-called-on-bulk-operations) any `save()` methods on your models, nor does it emit the [`pre_save`](/ga/6.1/ref/signals/#django.db.models.signals.pre_save) or [`post_save`](/ga/6.1/ref/signals/#django.db.models.signals.post_save) signals (which are a consequence of calling [`Model.save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save)). If you want to update a bunch of records for a model that has a custom [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save) method, loop over them and call [`save()`](/ga/6.1/ref/models/instances/#django.db.models.Model.save), like this: ``` 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 () \`\` Performs an SQL delete query on all rows in the [`QuerySet`](#django.db.models.query.QuerySet) and returns the number of objects deleted and a dictionary with the number of deletions per object type. The return value will count instances from related models if Django is emulating cascade behavior via Python [`on_delete`](/ga/6.1/ref/models/fields/#django.db.models.ForeignKey.on_delete) variants. Otherwise, for database variants such as [`DB_CASCADE`](/ga/6.1/ref/models/fields/#django.db.models.DB_CASCADE), the return value will report only instances of the [`QuerySet`](#django.db.models.query.QuerySet)'s model. 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. The `delete()` method does a bulk delete and [does not call](/ga/6.1/topics/db/models/#methods-not-called-on-bulk-operations) any `delete()` methods on your models. It does, however, emit the [`pre_delete`](/ga/6.1/ref/signals/#django.db.models.signals.pre_delete) and [`post_delete`](/ga/6.1/ref/signals/#django.db.models.signals.post_delete) signals for all deleted objects (including cascaded deletions). Signals won't be sent when `DB_CASCADE` is used. Also, `delete()` doesn't return information about objects deleted from database variants (`DB_*`) of the [`on_delete`](/ga/6.1/ref/models/fields/#django.db.models.ForeignKey.on_delete) argument, e.g. `DB_CASCADE`. Django won’t need to fetch objects into memory when deleting them in the following cases: 1. If related fields use `DB_*` options. 2. If there are no cascades and no delete signal receivers. In these cases, Django may take a fast path and delete objects without fetching them, which can result in significantly reduced memory usage and fewer executed queries. 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. > **Changed in Django 6.1** > > Support for the `DB_*` variants of `on_delete` attribute was added. #### 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í. The `format` parameter changes the output format from the database's default, which is usually text-based. PostgreSQL supports `'TEXT'`, `'JSON'`, `'YAML'`, and `'XML'` formats. MariaDB and MySQL support `'TEXT'` (also called `'TRADITIONAL'`) and `'JSON'` formats. MySQL 8.0.16+ also supports an improved `'TREE'` format, which is similar to PostgreSQL's `'TEXT'` output and is used by default, if supported. Glacann roinnt bunachair sonraí le bratacha ar féidir leo tuilleadh faisnéise faoin bhfiosrú Cuir na bratacha seo mar argóintí eochairfhocal. Mar shampla, agus PostgreSQL á úsáid agat: ```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 ``` On some databases, flags may cause the query to be executed which could have adverse effects on your database. For example, the `ANALYZE` flag supported by MariaDB, MySQL, and PostgreSQL could result in changes to data if there are triggers or if a function is called, even for a `SELECT` query. ### Cuardaigh `Field` Field lookups are how you specify the meat of an SQL `WHERE` clause. They're specified as keyword arguments to the `QuerySet` methods [`filter()`](#django.db.models.query.QuerySet.filter), [`exclude()`](#django.db.models.query.QuerySet.exclude) and [`get()`](#django.db.models.query.QuerySet.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 `` Exact match. If the value provided for comparison is `None`, it will be interpreted as an SQL `NULL` (see [`isnull`](#std-fieldlookup-isnull) for more details). [`Key and index lookups`](/ga/6.1/topics/db/queries/#std-fieldlookup-jsonfield.key) are exceptions: they interpret `None` as JSON `null` instead. 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%'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) Tabhair faoi deara go mbeidh sé seo comhoiriúnach leis an gceannteideal 'Lennon onóir inneo' ach ní lennon onóir inneo'. > **Ú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%'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) > **Ú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%'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) Ní thacaíonn SQLite le ráitis LIKE atá íogair ó cháis; gníomhaíonn startswith mar istartswith do SQLite. #### istartswith\` Tosaíonn cás-neamh-íogair - le. Sampla: ``` Entry.objects.filter(headline__istartswith="Lennon") ``` Coibhéis SQL: ```sql SELECT ... WHERE headline ILIKE 'Lennon%'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) > **Ú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'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) > **Ú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'; ``` (Athraíonn an comhréir cruinn SQL do gach inneall bunachar sonraí.) > **Ú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` An optional [Q object](#q-objects) that's used to filter the rows that are aggregated. 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 #### `AnyValue` > **New in Django 6.0** #### `class AnyValue(expression, output_field=None, filter=None, default=None, **extra)` Returns an arbitrary value from the non-null input values. - Default alias: `__anyvalue` - Cineál tuairisceáin: mar an gcéanna le réimse ionchuir, nó `output_field` má sholáthraítear. Má tá an tacar ceisteanna nó an grúpáil folamh, cuirtear `réamhshocraithe` ar ais. Sampla úsáide: ```pycon >>> # Get average rating for each year along with a sample headline >>> # from that year. >>> from django.db.models import AnyValue, Avg, F, Q >>> sample_headline = AnyValue("headline") >>> Entry.objects.values( ... pub_year=F("pub_date__year"), ... ).annotate( ... avg_rating=Avg("rating"), ... sample_headline=sample_headline, ... ) >>> # Get a sample headline from each year with rating greater than 4.5. >>> sample_headline = AnyValue( ... "headline", ... filter=Q(rating__gt=4.5), ... ) >>> Entry.objects.values( ... pub_year=F("pub_date__year"), ... ).annotate( ... avg_rating=Avg("rating"), ... sample_headline=sample_headline, ... ) ``` Supported on SQLite, MySQL, Oracle, and PostgreSQL 16+. > **MySQL with ONLY_FULL_GROUP_BY enabled** > > When the `ONLY_FULL_GROUP_BY` SQL mode is enabled on MySQL it may be > necessary to use `AnyValue` if an aggregation includes a mix of > aggregate and non-aggregate functions. Using `AnyValue` allows the > non-aggregate function to be referenced in the select list when > database cannot determine that it is functionally dependent on the > columns in the [group by](https://dev.mysql.com/doc/refman/8.4/en/group-by-handling.html) clause. See the [aggregation > documentation](/ga/6.1/topics/db/aggregation/#aggregation-mysql-only-full-group-by) for more details. #### `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. #### `Bitand` #### `class BitAnd(expression, filter=None, default=None, **extra)` > **New in Django 6.1** Filleann sé `int` de ghiotán `AND` de na luachanna ionchuir neamh-null go léir, nó `default` má tá na luachanna go léir neall. The `default` parameter is not supported on MariaDB, MySQL, and Oracle. #### `Bitor` #### `class BitOr(expression, filter=None, default=None, **extra)` > **New in Django 6.1** Filleann sé `int` den OR\` bitwise de na luachanna ionchuir neamh-null go léir, nó `default` má tá na luachanna go léir niall. The `default` parameter is not supported on MariaDB, MySQL, and Oracle. #### `Bitxor` #### `class BitXor(expression, filter=None, default=None, **extra)` > **New in Django 6.1** Returns an `int` of the bitwise `XOR` of all non-null input values, or `default` if all values are null. The `default` parameter is not supported on MariaDB, MySQL, and Oracle. #### `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. #### `Stringag` > **New in Django 6.0** #### `class StringAgg(expression, delimiter, output_field=None, distinct=False, filter=None, order_by=None, default=None, **extra)` Filleann sé na luachanna ionchuir atá comhcheangailte i sreang, scartha leis an teaghrán `delimiter`, nó `default` mura bhfuil aon luachanna ann. - Default alias: `__stringagg` - Return type: `string` or `output_field` if supplied. If the queryset or grouping is empty, `default` is returned. #### `delimiter` A `Value` or expression representing the string that should separate each of the values. For example, `Value(",")`. (On SQLite, the literal delimiter `Value(",")` is the only delimiter compatible with `distinct=True`.) > **Changed in Django 6.1** > > Support for using `distinct=True` with a delimiter of > `Value(",")` on SQLite was added. ## 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)` The `Prefetch()` object can be used to control the operation of [`prefetch_related()`](#django.db.models.query.QuerySet.prefetch_related). The `lookup` argument describes the relations to follow and works the same as the string based lookups passed to [`prefetch_related()`](#django.db.models.query.QuerySet.prefetch_related). For example: ```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")) ]> ``` The `queryset` argument supplies a base `QuerySet` for the given lookup. This is useful to further filter down the prefetch operation, or to call [`select_related()`](#django.db.models.query.QuerySet.select_related) from the prefetched relation, hence reducing the number of queries even further: ```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. Pass an iterable of model instances (must all be of the same class and able to be iterated multiple times) and the lookups or [`Prefetch`](#django.db.models.Prefetch) objects you want to prefetch for. For example: ```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 [Q object](#q-objects) to control the filtering. `FilteredRelation` is used with [`annotate()`](#django.db.models.query.QuerySet.annotate) to create an `ON` clause when a `JOIN` is performed. It doesn't act on the default relationship but on the annotation name (`pizzas_vegetarian` in example below). Mar shampla, chun bialanna a fháil a bhfuil pizzes vegetarian acu le `` `mozzarella `` san ainm: ```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.