--- title: "Ceisteanna a dhéanamh" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/topics/db/queries/ canonical: https://djangodocs.dev/ga/5.2/topics/db/queries/ --- # Ceisteanna a dhéanamh Nuair a bheidh do: doc: samhlacha sonraí cruthaithe agat, tugann Django API teastarbhaithe bunachar sonraí duit go huathoibríoch a ligeann duit rudaí a chruth\ ú, a aisghabháil, a nuashonrú agus a scriosadh. Míníonn an doiciméad seo conas an API seo a úsáid. Féach ar an: doc: \`tagairt samhail sonraí le haghaidh sonraí iomlána faoi na roghanna cu\ ardaigh samhlacha éagsúla go léir. Le linn na treoir seo (agus sa tagairt), déanfaimid tagairt do na samhlacha seo a leanas, a chuimsíonn feidhmchlár blag: ```python from datetime import date from django.db import models class Blog(models.Model): name = models.CharField(max_length=100) tagline = models.TextField() def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=200) email = models.EmailField() def __str__(self): return self.name class Entry(models.Model): blog = models.ForeignKey(Blog, on_delete=models.CASCADE) headline = models.CharField(max_length=255) body_text = models.TextField() pub_date = models.DateField() mod_date = models.DateField(default=date.today) authors = models.ManyToManyField(Author) number_of_comments = models.IntegerField(default=0) number_of_pingbacks = models.IntegerField(default=0) rating = models.IntegerField(default=5) def __str__(self): return self.headline ``` ## Cruthú rudaí Chun sonraí tábla bunachar sonraí a léiriú i rudaí Python, úsáideann Django córas iomasach: Léiríonn rang samhail tábla bunachar sonraí, agus léiríonn sampla den rang sin taifead áirithe sa tábla bunachar sonraí. Chun réad a chruthú, cuir isteach é ag baint úsáide as argóintí eochairfhocal chuig an rang samhail, ansin glaoigh ar: meth: ~django.db.models.model.save chun é a shábháil ar an mbunachar sonraí. Ag glacadh leis go gcónaíonn samhlacha i gcomhad `models.py` taobh istigh d'aip blog Django, seo sampla: ```pycon >>> from blog.models import Blog >>> b = Blog(name="Beatles Blog", tagline="All the latest Beatles news.") >>> b.save() ``` Déanann sé seo ráiteas SQL `INSERT` taobh thiar de na radhairc. Ní bhuaileann Django an bunachar sonraí go dtí go nglaonn tú go sainráite ar: meth: ~django.db.models.model.save. Níl aon luach tuairisceáin ag an modh: Meth: ~django.db.models.model.save. > **See also** > > : meth: ~django.db.models.model.save tógann roinnt ardroghanna nach bhfuil cur síos orthu anseo. Féach an doiciméadú le haghaidh: meth: ~django.db.models.model.save le haghaidh sonraí iomlána. > > Chun réad a chruthú agus a shábháil i gcéim amháin, bain úsáid as an modh:meth: ~django.db.models.query.queryset.create () . ## Athruithe a shábháil ar rudaí Chun athruithe a shábháil ar réad atá sa bhunachar sonraí cheana féin, bain úsáid as: meth: ~django.db.models.model.save. Mar gheall ar shampla `Blog` `b5` atá sábháilte cheana féin sa bhunachar sonraí, athraíonn an sampla seo a ainm agus nuashonraíonn a taifead sa bhunachar sonraí: ```pycon >>> b5.name = "New name" >>> b5.save() ``` Déanann sé seo ráiteas SQL `UPDATE` taobh thiar de na radhairc. Ní bhuaileann Django an bunachar sonraí go dtí go nglaonn tú go sainráite ar: meth: ~django.db.models.model.save. ### Réimsí `ForeignKey` agus `ManyTomanyField` a shábháil Oibríonn réimse a: class: ~Django.db.Models.ForeignKey a nuashonrú ar an mbealach céanna le gnáthréimse a shábháil -- sannadh réad den chineál ceart don réimse atá i gceist. Nuashonraíonn an sampla seo tréith `blog` de shampla `Iontrála` `iontrála`, ag glacadh leis go bhfuil cásanna cuí `Iontrála` agus `Blog` sábháilte sa bhunachar sonraí cheana féin (ionas gur féidir linn iad a aisghabháil thíos): ```pycon >>> from blog.models import Blog, Entry >>> entry = Entry.objects.get(pk=1) >>> cheese_blog = Blog.objects.get(name="Cheddar Talk") >>> entry.blog = cheese_blog >>> entry.save() ``` Oibríonn nuashonrú a:class: ~django.db.models.manyToManyField beagán difriúil - bain úsáid as an modh: meth: ~Django.db.Models.Fields.Related.RelatedManager.Add ar an réimse chun taifead a chur leis an ngaol. Cuireann an sampla seo an sampla `````Audar ````joe````` leis an réad `` `iontrála ``: ```pycon >>> from blog.models import Author >>> joe = Author.objects.create(name="Joe") >>> entry.authors.add(joe) ``` Chun iolrthaifid a chur le a:class: ~django.db.models.manyToManyField in aon dul amháin, cuir argóintí iolracha san áireamh sa ghlao chuig:meth: ~Django.db.Models.Fields.Related.RelatedManager.Add, mar seo: ```pycon >>> john = Author.objects.create(name="John") >>> paul = Author.objects.create(name="Paul") >>> george = Author.objects.create(name="George") >>> ringo = Author.objects.create(name="Ringo") >>> entry.authors.add(john, paul, george, ringo) ``` Déanfaidh Django gearán má dhéanann tú iarracht réad den chineál mícheart a shannadh nó a chur leis. ## Rudaí a aisghabháil Chun rudaí a aisghabháil ó do bhunachar sonraí, tóg a:class: ~django.db.models.query.queryset trí a:class: ~django.db.models.manager ar do rang samhail. A: Class: ~django.db.models.query.querySet léiríonn bailiúchán rudaí ó do bhunachar sonraí. Is féidir leis nialas, ceann amháin nó go leor scagair\* a bheith aige. Cuimsíonn scagairí torthaí na bhfiosrúcháin bunaithe ar na paraiméadair I dtéarmaí SQL, a: class: ~django.db.models.query.queryset cothrom le ráiteas `SELECT`, agus is clásal teorannach é scagaire mar `WHERE` nó LIMIT\`. Faigheann tú a:class: ~django.db.models.query.queryset trí úsáid a bhaint as do mhúnlaí:class: ~django.db.models.manager. Tá ceann amháin ar a laghad ag gach samhail:: ~Django.db.Models.Manager, agus tugtar air:attr: ~django.db.models.model.objects de réir réamhshocraithe. Rochtain a fháil go díreach air tríd an rang samhail, mar sin: ```pycon >>> Blog.objects >>> b = Blog(name="Foo", tagline="Bar") >>> b.objects Traceback: ... AttributeError: "Manager isn't accessible via Blog instances." ``` > **Note** > > A `Manager` is accessible only via model classes, rather than from model > instances, to enforce a separation between "table-level" operations and > "record-level" operations. The [`Manager`](/ga/5.2/topics/db/managers/#django.db.models.Manager) is the main source of querysets for a model. For example, `Blog.objects.all()` returns a [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) that contains all `Blog` objects in the database. ### Aisghabháil gach rud Is é an bealach is simplí chun rudaí a aisghabháil ó thábla ná iad go léir a fháil. Chun seo a dhéanamh, bain úsáid as an modh:meth: ~django.db.models.query.queryset.all ar a:class: ~django.db.models.manager: ```pycon >>> all_entries = Entry.objects.all() ``` Tugann an modh: Meth: ~django.db.models.query.queryset.all ar ais a:class: ~django.db.models.query.queryset de na rudaí go léir sa bhunachar sonraí. ### Rudaí ar leith a aisghabháil le scagairí Déan:class: ~django.db.models.query.queryset ar ais ar:meth: ~django.db.models.queryset.all cur síos ar gach rud sa tábla bunachar sonraí. De ghnáth, áfach, ní bheidh ort ach fo-thacar den tsraith iomlán rudaí a roghnú. Chun fo-thacar den sórt sin a chruthú, déanann tú an tosaigh: class: ~django.db.models.query.querySet a bheachtú, ag cur coinníollacha scagaire leis. Is iad an dá bhealach is coitianta chun a:class: ~django.db.models.query.queryset a bheachtú: **scagaire (kwargs) \`\`** Filleann sé nua:class: ~django.db.models.query.querySet ina bhfuil rudaí a mheaitseálann leis na paraiméadair cuardaigh ar leith. **eisiamh (kwargs) \`\`** Filleann sé nua:class: ~django.db.models.query.querySet ina bhfuil rudaí nach n-oireann naí\* leis na paraiméadair chuardaigh a thugtar. Ba chóir go mbeadh na paraiméadair chuardaigh (kwargs sna sainmhínithe feidhme thuas) san fhormáid a thuairiscítear i Cuardach réimse \_ thíos. Mar shampla, chun a:class: ~django.db.models.query.queryset d'iontrálacha blag ón mbliain 2006 a fháil, bain úsáid as: meth: ~django.db.models.query.queryset.filter mar sin: ``` Entry.objects.filter(pub_date__year=2006) ``` Leis an rang bainisteora réamhshocraithe, tá sé mar an gcéanna le: ``` Entry.objects.all().filter(pub_date__year=2006) ``` #### Scagairí slabhraithe Is é an toradh a bhaineann le scagadh a: ~django.db.models.query.queryset é féin a: aicme: ~django.db.models.query.queryset, mar sin is féidir mionscrúcháin a shlánú le chéile. Mar shampla: ```pycon >>> Entry.objects.filter(headline__startswith="What").exclude( ... pub_date__gte=datetime.date.today() ... ).filter(pub_date__gte=datetime.date(2005, 1, 30)) ``` Tógann sé seo an tosaigh: class: ~django.db.models.query.queryset de gach iontráil sa bhunachar sonraí, cuireann sé scagaire, ansin eisiamh, ansin scagaire eile. Is é an toradh deiridh a:class: ~django.db.models.query.queryset ina bhfuil gach iontráil le ceannteideal a thosaíonn le “Cad”, a foilsíodh idir 30 Eanáir, 2005, agus an lá reatha. #### Tá scagtha `QuerySet` uathúil Gach uair a bheachnaíonn tú a:class: ~django.db.models.query.queryset, gheobhaidh tú branda-nua:class: ~django.db.models.query.queryset nach bhfuil ceangailte ar aon bhealach leis an roimhe seo: ~django.db.models.queryset. Cruthaíonn gach scagadh ar leithligh agus difriúil: aicme: ~django.db.models.query.queryset is féidir a stóráil, a úsáid agus a athúsáid. Sampla: ```pycon >>> q1 = Entry.objects.filter(headline__startswith="What") >>> q2 = q1.exclude(pub_date__gte=datetime.date.today()) >>> q3 = q1.filter(pub_date__gte=datetime.date.today()) ``` These three querysets are separate. The first is a base [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) containing all entries that contain a headline starting with "What". The second is a subset of the first, with an additional criteria that excludes records whose `pub_date` is today or in the future. The third is a subset of the first, with an additional criteria that selects only the records whose `pub_date` is today or in the future. The initial [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) (`q1`) is unaffected by the refinement process. #### Tá `QuerySet` leisciúil `QuerySet` objects are lazy -- the act of creating a [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) doesn't involve any database activity. You can stack filters together all day long, and Django won't actually run the query until the [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) is *evaluated*. Take a look at this example: ```pycon >>> q = Entry.objects.filter(headline__startswith="What") >>> q = q.filter(pub_date__lte=datetime.date.today()) >>> q = q.exclude(body_text__icontains="food") >>> print(q) ``` Cé go bhfuil sé seo cosúil le trí bhualadh bunachar sonraí, i ndáiríre ní bhuaileann sé an bunachar sonraí ach uair amháin, ag an líne dheireanach (print (q) ). Go ginearálta, ní fhaightear torthaí a:class: ~django.db.models.query.querySet ón mbunachar sonraí go dtí go n-iarrann tú iad. Nuair a dhéanann tú, déantar an:class: ~django.db.models.query.queryset *meastóireach* trí rochtain a fháil ar an mbunachar sonraí. Le haghaidh tuilleadh sonraí maidir le cathain a dhéantar an mheastóireacht, féach:ref: when-querysets-are-evaluated. ### Aisghabháil réad amháin le get () \`\` [`filter()`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet.filter) will always give you a [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet), even if only a single object matches the query - in this case, it will be a [`QuerySet`](/ga/5.2/ref/models/querysets/#django.db.models.query.QuerySet) containing a single element. Má tá a fhios agat nach bhfuil ach réad amháin a mheaitseálann le d'fhiosrúchán, is féidir leat an modh:meth: ~django.db.models.query.queryset.get a úsáid ar a:class: ~django.db.models.manager a thugann an réad ar ais go díreach: ```pycon >>> one_entry = Entry.objects.get(pk=1) ``` Is féidir leat aon abairt fiosrúcháin a úsáid le:meth: ~django.db.models.query.queryset.get, díreach cosúil le: meth: ~django.db.models.query.queryset.filter \- arís, féach [Field lookups](#field-lookups) thíos. Tabhair faoi deara go bhfuil difríocht idir úsáid: meth: ~django.db.models.query.queryset.get, agus úsáid: meth: ~django.db.models.query.queryset.filter le slisnacht `[0]`. Mura bhfuil aon torthaí ann a mheaitseálann leis an bhfiosrú, :meth: ~django.db.models.query.queryset.get ardóidh eisceacht `doesNotExist`. Is tréith den aicme samhail í an eisceacht seo a bhfuil an cheist á dhéanamh air - mar sin sa chód thuas, mura bhfuil aon réad ```Entry` ann le príomh-eochair 1, ardóidh Django ``entry.doesNotExist```. Ar an gcaoi chéanna, déanfaidh Django gearán má mheaitseálann níos mó ná mír amháin leis an bhfiosrúchán:: ~django.db.models.queryset.get. Sa chás seo, ardóidh sé: exc: ~Django.Core.Exceptions.MultipleObjectsReturned, atá ina tréith den rang samhail féin arís. ### Modhanna eile QuerySet\` An chuid is mó den am a úsáidfidh tú: meth: ~django.db.models.query.queryset.all, :meth: ~django.db.models.queryset.get, :meth: ~django.db.models.query.queryset.filter agus:meth: ~django.db.models.querys.querys.querys.ery.queryset.exclude nuair is gá duit rudaí a lorg suas ón mbunachar sonraí. Mar sin féin, tá sé sin i bhfad ó gach rud atá ann; féach an:ref: QuerySet API Tagairt \`le haghaidh li \osta iomlán de na modhanna éagsúla:class: \`~django.db.models.queryset go léir. ### Teorannú ar `QuerySet`s Úsáid fo-thacar de chomhpháirtíocht slisnú eagair Python chun do: class: ~django.db.models.query.querySet a theorannú go líon áirithe torthaí. Is é seo coibhéis le clásail `LIMIT` agus `OFFSET` SQL. Mar shampla, tugann sé seo an chéad 5 rud ar ais (`LIMIT 5`): ```pycon >>> Entry.objects.all()[:5] ``` Tugann sé seo an séú réad tríd an deichiú rud ar ais (`OFFSET 5 TEORAINN 5`): ```pycon >>> Entry.objects.all()[5:10] ``` Ní thacaítear le hinnéacsú diúltach (ie Entry.Objects.all () \[-1\] ). Go ginearálta, cuireann sliseadh a:class: ~django.db.models.query.queryset ar ais nua:class: ~django.db.models.queryset \- ní dhéanann sé measúnú ar an gceist. Is eisceacht ná má úsáideann tú an paraiméadar “céim” de chomhréir slisní Python. Mar shampla, chuirfeadh sé seo an ceist i ndáiríre i ndáiríre d'fhonn liosta de ghach\* soicind\* réad den chéad 10 a thabhairt ar ais: ```pycon >>> Entry.objects.all()[:10:2] ``` Tá cosc ar scagadh nó ordú breise tacar fiosrúcháin slisnaithe mar gheall ar nádúr débhríoch an chaoi a d'fhéadfadh sé sin a bheith ag obair. Chun réad\*aon\* a aisghabháil seachas liosta (m.sh. `SELECT foo FROM barra LIMIT 1`), bain úsáid as innéacs in ionad slisnacht. Mar shampla, filleann sé seo an chéad `Iontrála` sa bhunachar sonraí, tar éis iontrálacha a ordú in ord aibítre de réir ceanncheanntála: ```pycon >>> Entry.objects.order_by("headline")[0] ``` Tá sé seo coibhéiseach thart ar: ```pycon >>> Entry.objects.order_by("headline")[0:1].get() ``` Tabhair faoi deara, áfach, go n-ardóidh an chéad cheann díobh seo `IndexError` agus ardóidh an dara ceann `doesNotExist` mura n-oireann aon rud leis na critéir a thugtar. Féach: Meth: ~django.db.models.query.queryset.get le haghaidh tuilleadh sonraí. ### Cuardaigh allamuigh Is iad cuardaigh réimse an chaoi a shonraíonn tú feoil clásal SQL `WHERE`. Sonraítear iad mar argóintí eochairfhocal chuig:class: ~django.db.models.query.queryset modh:meth: ~django.db.models.query.queryset.filter, :meth: ~django.db.models.query.queryset.exclude agus:meth: ~django.db.models.query.queryset.exclude .queryset.get”. Glacann argóintí eochairfhocal cuardaigh bunúsacha an fhoirm `field__lookuptype=value`. (Is béim dhúbailte é sin). Mar shampla: ```pycon >>> Entry.objects.filter(pub_date__lte="2006-01-01") ``` aistríonn (go garbh) go dtí an SQL seo a leanas: ```sql SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01'; ``` > **Conas is féidir é seo** > > Tá sé de chumas ag Python feidhmeanna a shainiú a ghlacann le hargóintí treallach ainm-luach a ndéantar a n-ainmneacha agus a luachanna a mheas ag am Le haghaidh tuilleadh faisnéise, féach:ref: tut-keywordargs sa rang teagaisc oifigiúil Python. Caithfidh ainm réimse samhail an réimse a shonraítear i gcuardach. Tá eisceacht amháin ann áfach, i gcás a:class: ~Django.db.Models.ForeignKey is féidir leat an t-ainm réimse a shonrú le `_id`. Sa chás seo, táthar ag súil go mbeidh amluach príomh-eochair an tsamhail eachtrach sa pharaiméadar luacha. Mar shampla: ```pycon >>> Entry.objects.filter(blog_id=4) ``` Má chuireann tú argóint eochairfhocal neamhbhailí, ardóidh feidhm chuardaigh `typeError`. \Tacaíonn an API bunachar sonraí le thart ar dhá dhosaen cineálacha cuardaigh; is féidir tagairt iomlán a fháil in:ref: tagairt cuardaigh réimse . Chun blas a thabhairt duit ar na rudaí atá ar fáil, seo cuid de na cuardaigh is coitianta a úsáidfidh tú is dócha: **[`exact`](/ga/5.2/ref/models/querysets/#std-fieldlookup-exact)** Cluiche “cruinn”. Mar shampla: ```pycon >>> Entry.objects.get(headline__exact="Cat bites dog") ``` Ghinfidh sé SQL ar na línte seo: ```sql SELECT ... WHERE headline = 'Cat bites dog'; ``` Mura soláthraíonn tú cineál cuardaigh - is é sin, mura bhfuil béim dhúbailte ag d'argóint eochairfhocal - glactar leis gurb é “cruinn” an cineál cuardaigh. Mar shampla, tá an dá ráiteas seo a leanas coibhéiseach: ```pycon >>> Blog.objects.get(id__exact=14) # Explicit form >>> Blog.objects.get(id=14) # __exact is implied ``` Tá sé seo ar mhaithe le háisiúlacht, mar is é cuardaigh cruinn an cás coitianta. **[`iexact`](/ga/5.2/ref/models/querysets/#std-fieldlookup-iexact)** Cluiche cás-neamh-íogair. Mar sin, an cheist: ```pycon >>> Blog.objects.get(name__iexact="beatles blog") ``` Meaitseálann sé `Blag` dar teideal `"Blag Beatles"`, `blog beatles"`, nó fiú `"Blag Beatles"`. **[`contains`](/ga/5.2/ref/models/querysets/#std-fieldlookup-contains)** Tástáil srianta cás-íogair. Mar shampla: ``` Entry.objects.get(headline__contains="Lennon") ``` Aistríonn sé go garbh go dtí an SQL seo: ```sql SELECT ... WHERE headline LIKE '%Lennon%'; ``` Tabhair faoi deara go mbeidh sé seo comhoiriúnach leis an gceannteideal ``` ``Inniu Lennon onored' ``` ach ní `` `inniu lennon onored' ``. Tá leagan cás-neamh-íogair ann freisin, :lookup: icontains. **[`startswith`](/ga/5.2/ref/models/querysets/#std-fieldlookup-startswith), [`endswith`](/ga/5.2/ref/models/querysets/#std-fieldlookup-endswith)** Tosaí-le cuardach agus críochnaí-le cuardach, faoi seach. Tá leaganacha cás-neamh-íogair ann freisin ar a dtugtar: lookup: istartswith agus:lookup: iendswith. Arís, ní scriosann sé seo ach an dromchla. \Is féidir tagairt iomlán a fháil in:ref: tagairt cuardaigh réimse . ### Cuardaigh a bhaineann le caidrimh Cuireann Django bealach cumhachtach iomasach ar fáil chun caidrimh a “leanúint” i gcuardaigh, ag tabhairt aire do na SQL JOIN\` duitse go huathoibríoch, taobh thiar de na radhairc. Chun caidreamh a sceitheadh, bain úsáid as ainm réimse réimsí gaolmhara ar fud samhlacha, scartha le béim dhúbailte, go dtí go sroicheann tú an réimse atá uait. Aisghabhraíonn an sampla seo gach rud `Entry` le `Blog` a bhfuil ``````ainm `````Blog`````` `` `Beatles Blog` ``: ```pycon >>> Entry.objects.filter(blog__name="Beatles Blog") ``` Is féidir leis an sceitheadh seo a bheith chomh domhain agus is mian leat. Oibríonn sé ar chúl, freisin. Cé gur féidir é: attr: a shaincheapadh \<.foreignKey.related\_query\_name\>, de réir réamhshocraithe tagraíonn tú do chaidreamh “droim” i gcuardach ag baint úsáide as ainm beaga an tsamhail. Aisghabhraíonn an sampla seo gach rud `` `Blog `` a bhfuil `Iontrála` amháin ar a laghad aici a bhfuil `Lennon` 'ceannlíne : ```pycon >>> Blog.objects.filter(entry__headline__contains="Lennon") ``` Má tá tú ag scagadh ar fud caidrimh iolracha agus mura bhfuil luach ag ceann de na samhlacha idirmheánacha a chomhlíonann coinníoll an scagaire, déileálfaidh Django leis amhail is dá mbeadh folamh ann (tá gach luach `NULL`), ach bailí, réad ann. Ciallaíonn sé seo go léir ná nach n-ardófar aon earráid. Mar shampla, sa scagaire seo: ``` Blog.objects.filter(entry__authors__name="Lennon") ``` (dá mbeadh samhail ghaolmhar `Údar` ann), mura mbeadh aon `údar` a bhaineann le hiontráil, déileálfaí leis amhail is dá mbeadh aon ```ainm ``ceangailte ann freisin, seachas earráid a ardú mar gheall ar an ``údar``` atá in easnamh. De ghnáth is é seo go díreach cad ba mhaith leat a tharlóidh. Is é an t-aon chás ina bhféadfadh sé a bheith mearbhall ná má tá tú ag baint úsáidea:lookup: isnull. Dá bhrí sin: ``` Blog.objects.filter(entry__authors__name__isnull=True) ``` cuirfidh sé ar ais rudaí `Blog` a bhfuil ```ainm folamh acu ar an ``údar``` agus freisin iad siúd a bhfuil `údar` folamh acu ar an `iontrála`. Mura dteastaíonn na rudaí deiridh sin uait, d'fhéadfá scríobh: ``` Blog.objects.filter(entry__authors__isnull=False, entry__authors__name__isnull=True) ``` #### Cuimsíonn caidrimh illuachmhar Nuair a chuimsíonn a:class: ~django.db.models.manyToManyField nó a reverse:class: ~django.db.models.foreignKey (mar shampla ó `Blog` go Entry \`), ardaíonn scagadh ar iolrthréithe an cheist an gcaithfidh gach tréith a bheith ag teacht leis an réad gaolmhar céanna. D'fhéadfaimis blaganna a lorg a bhfuil iontráil acu ó 2008 len\* “Lennon” \* ina cheannlíne, nó d'fhéadfaimis blaganna a lorg nach bhfuil ach aon iontráil acu ó 2008 chomh maith le roinnt iontráil níos nuaí nó níos sine len\* “Lennon” \* ina cheannlíne. Chun gach blaganna a roghnú ina bhfuil iontráil amháin ar a laghad ó 2008 ina bhfuil *"Lennon"* ina cheannlíne (an iontráil chéanna a shlíonann an dá choinníoll), scríobhfaimis: ``` Blog.objects.filter(entry__headline__contains="Lennon", entry__pub_date__year=2008) ``` Seachas sin, chun fiosrúchán níos ceadaithe a dhéanamh ag roghnú aon bhlaganna nach bhfuil ach iontráil\* éigin\* lennon"\* ina cheannlíne agus iontráil\* éigin\* ó 2008, scríobhfaimis: ``` Blog.objects.filter(entry__headline__contains="Lennon").filter( entry__pub_date__year=2008 ) ``` Cuir i gcás nach bhfuil ach blag amháin ann a bhfuil an dá iontráil ina bhfuil *"Lennon"* agus iontrálacha ó 2008, ach nach raibh *"Lennon"* in aon cheann de na hiontrálacha ó 2008. Ní thabharfadh an chéad cheist aon bhlag ar ais, ach chuirfeadh an dara ceist ar ais an blag amháin sin. (Tá sé seo toisc go bhféadfadh nó nach bhféadfadh na hiontrálacha a roghnaíonn an dara scagaire a bheith mar an gcéanna leis na hiontrálacha sa chéad scagaire. Táimid ag scagadh na míreanna `Blag` le gach ráiteas scagaire, ní na míreanna Iontrála\`.) I mbeagán focal, más gá do gach coinníoll an réad gaolmhar céanna a mheaitseáil, ba chóir go mbeadh gach ceann acu i nglao aonair: meth: ~django.db.models.query.queryset.filter. > **Note** > > De réir mar a shlabhraíonn an dara ceist (níos ceadaithe) scagairí iolracha, déanann sé iolracha comhcheangail leis an bpríomhúnsamhail, rud a d'fhéadfadh dúbailtí a thabhairt. > > ```pycon > >>> from datetime import date > >>> beatles = Blog.objects.create(name="Beatles Blog") > >>> pop = Blog.objects.create(name="Pop Music Blog") > >>> Entry.objects.create( > ... blog=beatles, > ... headline="New Lennon Biography", > ... pub_date=date(2008, 6, 1), > ... ) > > >>> Entry.objects.create( > ... blog=beatles, > ... headline="New Lennon Biography in Paperback", > ... pub_date=date(2009, 6, 1), > ... ) > > >>> Entry.objects.create( > ... blog=pop, > ... headline="Best Albums of 2008", > ... pub_date=date(2008, 12, 15), > ... ) > > >>> Entry.objects.create( > ... blog=pop, > ... headline="Lennon Would Have Loved Hip Hop", > ... pub_date=date(2020, 4, 1), > ... ) > > >>> Blog.objects.filter( > ... entry__headline__contains="Lennon", > ... entry__pub_date__year=2008, > ... ) > ]> > >>> Blog.objects.filter( > ... entry__headline__contains="Lennon", > ... ).filter( > ... entry__pub_date__year=2008, > ... ) > , , > ``` > **Note** > > Ní chuirtear iompar: meth: ~django.db.models.query.queryset.filter i bhfeidhm go coibhéiseach le haghaidh ceisteanna a bhaineann le caidrimh illuacha, mar a thuairiscítear thuas, go coibhéiseach le haghaidh: meth: ~django.db.models.query.queryset.exclude. Ina áit sin, ní gá go dtagróidh na coinníollacha i nglao aonair: meth: ~django.db.models.query.queryset.exclude don mhír chéanna. > > Mar shampla, ní chuirfeadh an cheist seo a leanas blaganna ina bhfuil iontrálacha *"Lennon"* san iontrálacha ceannlín\*agus\* a foilsíodh in 2008: > > ``` > Blog.objects.exclude( > entry__headline__contains="Lennon", > entry__pub_date__year=2008, > ) > ``` > > Mar sin féin, murab ionann agus an t-iompar nuair a úsáidtear: meth: ~django.db.models.query.queryset.filter, ní chuirfidh sé seo teorainn le blaganna bunaithe ar iontrálacha a shánaíonn an dá choinníoll. D'fhonn é sin a dhéanamh, ie gach blaganna nach bhfuil iontrálacha foilsíodh len\*"Lennon"\* a foilsíodh in 2008 a roghnú, ní mór duit dhá cheist a dhéanamh: > > ``` > Blog.objects.exclude( > entry__in=Entry.objects.filter( > headline__contains="Lennon", > pub_date__year=2008, > ), > ) > ``` ### Is féidir le scagairí réimsí tagartha a dhéanamh ar an Sna samplaí a tugadh go dtí seo, tá scagairí tógtha againn a dhéanann comparáid idir luach réimse samhail le tairiseach. Ach cad más mian leat luach réimse samhail a chur i gcomparáid le réimse eile ar an tsamhail chéanna? Soláthraíonn Django: class: Abairtí F \\`chun comparáidí den sórt sin a cheadú. Feidhmíonn cásanna F () mar thagairt do réimse samhail laistigh de cheist. Is féidir na tagairtí seo a úsáid ansin i scagairí fiosrúcháin chun luachanna dhá réimse éagsúla a chur i gcomparáid ar an samhail chéanna. Mar shampla, chun liosta de na hiontrálacha blag go léir a raibh níos mó tuairimí acu ná pingbacks a fháil, tógaimid réad ```F () ``chun tagairt a dhéanamh don chomhaireamh pingback, agus úsáidimid an rud ``F ()``` sin san cheist: ```pycon >>> from django.db.models import F >>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks")) ``` Tacaíonn Django le húsáid suimithe, íolraithe, iolraithe, roinnte, modulo, agus uimhrithíochta cumhachta le rudaí F () , le comhsheasmhacha agus le rudaí \`F () eile. Chun na hiontrálacha blag go léir a fháil le níos mó ná \* dhá uaire\* an oiread tuairimí le pingbacks, déanaimid an cheist a mhodhnú: ```pycon >>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks") * 2) ``` Chun na hiontrálacha go léir a fháil ina bhfuil rátáil an iontrála níos lú ná suim an chomhaireamh pingback agus comhaireamh tráchta, eisíodh an cheist: ```pycon >>> Entry.objects.filter(rating__lt=F("number_of_comments") + F("number_of_pingbacks")) ``` Is féidir leat an nótaí béim dhúbailte a úsáid freisin chun caidrimh a shlánú i réad F () . Tabharfaidh réad F () le béim dúbailte aon cheangal a theastaíonn chun rochtain a fháil ar an réad gaolmhar. Mar shampla, chun na hiontrálacha go léir a aisghabháil ina bhfuil ainm an údair mar an gcéanna le hainm an bhlag, d'fhéadfaimis an cheist a eisiúint: ```pycon >>> Entry.objects.filter(authors__name=F("blog__name")) ``` Maidir le réimsí dáta agus dáta/ama, is féidir leat a: class: ~datetime.timedelta réad a chur leis nó a bhaint. Chuirfeadh na nithe seo a leanas ar ais gach iontráil a modhníodh níos mó ná 3 lá tar éis iad a fhoilsiú: ```pycon >>> from datetime import timedelta >>> Entry.objects.filter(mod_date__gt=F("pub_date") + timedelta(days=3)) ``` Tacaíonn na rudaí ```F () ``le hoibríochtaí bitwise le ``.bitand ()```, .bitor () \`, .bitxor ()\`, .bitxor () \`, .bitrightshift ()\`, agus .bitleftshift () . Mar shampla: ```pycon >>> F("somefield").bitand(16) ``` > **Oracle** > > Ní thacaíonn Oracle le hoibriú bitwise XOR. ### Is féidir le nathanna tagairt a dhéanamh d'athrú Tacaíonn Django le hathruithe a úsáid i nathanna. Mar shampla, chun gach rud Iontrála\` a fhoilsíodh sa bhliain chéanna agus a mhodhníodh iad go deireanach a aimsiú: ```pycon >>> from django.db.models import F >>> Entry.objects.filter(pub_date__year=F("mod_date__year")) ``` Chun an bhliain is luaithe foilsíodh iontráil a fháil, is féidir linn an cheist a eisiúint: ```pycon >>> from django.db.models import Min >>> Entry.objects.aggregate(first_published_year=Min("pub_date__year")) ``` Aimsíonn an sampla seo luach an iontrála is airde agus líon iomlán na dtuairimí ar gach iontráil do gach bliain: ```pycon >>> from django.db.models import OuterRef, Subquery, Sum >>> Entry.objects.values("pub_date__year").annotate( ... top_rating=Subquery( ... Entry.objects.filter( ... pub_date__year=OuterRef("pub_date__year"), ... ) ... .order_by("-rating") ... .values("rating")[:1] ... ), ... total_comments=Sum("number_of_comments"), ... ) ``` ### An aicearra cuardaigh `pk` Ar mhaithe le áisiúlacht, soláthraíonn Django aicearra cuardaigh `pk`, a sheasann do “eochair phríomhúil”. Sa tsamhail `Blog` sampla, is é an príomh-eochair an réimse id\`, mar sin tá na trí ráiteas seo coibhéiseach: ```pycon >>> Blog.objects.get(id__exact=14) # Explicit form >>> Blog.objects.get(id=14) # __exact is implied >>> Blog.objects.get(pk=14) # pk implies id__exact ``` Níl úsáid pk\` teoranta do cheisteanna `__exact` \- is féidir aon téarma fiosrúcháin a chomhcheangal le pk\` chun ceist a dhéanamh ar phríomh-eochair mhúnla: ```pycon # Get blogs entries with id 1, 4 and 7 >>> Blog.objects.filter(pk__in=[1, 4, 7]) # Get all blog entries with id > 14 >>> Blog.objects.filter(pk__gt=14) ``` Oibríonn cuardaigh pk\` trasna comhpháirteanna freisin. Mar shampla, tá na trí ráiteas seo coibhéiseach: ```pycon >>> Entry.objects.filter(blog__id__exact=3) # Explicit form >>> Entry.objects.filter(blog__id=3) # __exact is implied >>> Entry.objects.filter(blog__pk=3) # __pk implies __id__exact ``` ### Comharthaí agus béim faoin gcéad ag éalú i ráitis `LIKE` Éalóidh na cuardaigh réimse atá cothrom le ráitis SQL LIKE\` (iexact\`, contains\`, icontains\`, startswith\`, istartswith\`, ```deireadh ``agus ``iendswith```) éalóidh go huathoibríoch an dá charachtar speisialta a úsáidtear i ráitis LIKE\` -- an céatadán agus an comhartha an béim. (I ráiteas LIKE , léiríonn an comhartha faoin gcéad cárta fiáin ilcharachtar agus léiríonn an béim cárta fiáin aon charachtar.) Ciallaíonn sé seo gur chóir go n-oibreodh rudaí go iomasach, ionas nach sceitheann an teastarbhú. Mar shampla, chun na hiontrálacha go léir ina bhfuil comhartha faoin gcéad a aisghabháil, bain úsáid as an gcomhartha céatadáin mar aon charachtar eile ```pycon >>> Entry.objects.filter(headline__contains="%") ``` Tugann Django aire don luachan duit; beidh cuma mar seo ar an SQL mar seo: ```sql SELECT ... WHERE headline LIKE '%\%%'; ``` Baineann an rud céanna le béim. Déantar comharthaí céatadáin agus béim a láimhseáil duit go trédhearcach. ### Caching agus `QuerySet`s Tá taisce ag gach ceann: Class: ~django.db.models.query.querySet chun rochtain ar bhunachar sonraí a íoslaghdú. Ligfidh tuiscint ar an gcaoi a n-oibríonn sé duit an cód is éifeachtaí a scríobh. I: class: ~django.db.models.query.queryset nua-chruthaithe, tá an taisce folamh. An chéad uair a dhéantar a: class: ~django.db.models.query.queryset a mheas -- agus, dá bhrí sin, tarlaíonn ceist bunachar sonraí -- Sábhálann Django torthaí na fiosrúcháin i taisce:class: ~django.db.models.queryset agus filleann sé na torthaí a iarradh go sainráite (m.sh., an chéad eilimint eile, más air:class: ~django..DB.Models.Query.QuerySet á athrá). Déanann meastóireachtaí ina dhiaidh sin ar an: aicme: ~django.db.models.query.queryset athúsáid na torthaí taisceáilte. Coinnigh an t-iompar taiscéála seo i gcuimhne, toisc go bhféadfadh sé greim ort mura n-úsáideann tú do: class: ~django.db.models.query.querysets i gceart. Mar shampla, cruthóidh an méid seo a leanas dhá cheant:class: ~django.db.models.query.querysets, iad a mheas, agus caith amach iad: ```pycon >>> print([e.headline for e in Entry.objects.all()]) >>> print([e.pub_date for e in Entry.objects.all()]) ``` Ciallaíonn sé sin go ndéanfar an ceist bunachar sonraí céanna a fhorghníomhú faoi dhó, ag dúbailt go héifeachtach Chomh maith leis sin, tá an fhéidearthacht nach gcuimsíonn an dá liosta na taifid bunachar sonraí céanna, toisc go bhféadfadh “Iontráil” a chur leis nó a scriosadh sa dara scoilt idir an dá iarratas. Chun an fhadhb seo a sheachaint, sábháil an:class: ~django.db.models.query.queryset agus athúsáid é: ```pycon >>> queryset = Entry.objects.all() >>> print([p.headline for p in queryset]) # Evaluate the query set. >>> print([p.pub_date for p in queryset]) # Reuse the cache from the evaluation. ``` #### Nuair nach ndéantar `QuerySet`\\ s a chosc Ní dhéanann Querysets a gcuid torthaí a taisce i gcónaí. Nuair a dhéantar meastóireacht amháin\* den tacar fiosrúcháin amháin, déantar an taisce a sheiceáil, ach mura bhfuil sé daonra ansin ní chuirtear na míreanna ar ais ag an gceist ina dhiaidh sin a chosc. Go sonrach, ciallaíonn sé seo nach ndéanfaidh: ref: teorannú an tacar fiosrúcháin \\`ag baint úsáide as slisnacht eagar nó innéacs an taisce a líonadh. Mar shampla, déanfaidh innéacs áirithe a fháil arís agus arís agus arís eile i réad socraithe ceisteanna an bunachar sonraí gach uair: ```pycon >>> queryset = Entry.objects.all() >>> print(queryset[5]) # Queries the database >>> print(queryset[5]) # Queries the database again ``` Mar sin féin, má rinneadh an tacar fiosrúcháin iomlán a mheas cheana féin, seiceálfar an taisce ina ionad sin: ```pycon >>> queryset = Entry.objects.all() >>> [entry for entry in queryset] # Queries the database >>> print(queryset[5]) # Uses cache >>> print(queryset[5]) # Uses cache ``` Seo roinnt samplaí de ghníomhartha eile a mbeidh meastóireacht ar an tacar fiosrúcháin iomlán mar thoradh air agus dá bhrí sin an taisce a líonadh: ```pycon >>> [entry for entry in queryset] >>> bool(queryset) >>> entry in queryset >>> list(queryset) ``` > **Note** > > Ní dhéanfaidh an taisce an taisce a phriontáil ach an tacar fiosrúcháin a phriontáil. Tá sé seo toisc nach bhfilleann an glao chuig \_\_repr\_\_ () ach slisnacht den tacar fiosrúcháin iomlán. ## Fiosrúcháin asincrónach Má tá tuairimí nó cód asincrónacha á scríobh agat, ní féidir leat an ORM a úsáid le haghaidh fiosrúcháin ar an mbealach atá cur síos againn thuas, mar ní féidir leat cód sioncrónas\* a ghlaoch ó chód asincrónach - cuirfidh sé bac ar an lúb imeachta (nó, is dóichí, tabharfaidh Django faoi deara agus ardóidh sé “SynchronousOnlyOperation” chun é sin a stopadh ó tharlóidh). Ar ámharaí an tsaoil, is féidir leat go leor ceisteanna a dhéanamh ag baint úsáide as APIs ceist asincrónach Django. Tá leagan asincrónach ag gach modh a d'fhéadfadh bac a chur - mar shampla ```get () ``nó ``delete ()``` \- ```nó ``adelete ()```), agus nuair a athraitheann tú thar thorthaí, is féidir leat athrú asincrónach (async for\`) a úsáid ina ionad. ### Athraitheadh ceisteanna Beidh ceist bunachar sonraí blocála taobh thiar de na radhairc mar thoradh ar an mbealach réamhshocraithe chun athrá thar cheist - le for\` \- - mar thoradh ar an mbealach réamhshocraithe agus Django á luchtú ag am athraithe. Chun é seo a shocrú, is féidir leat a mhalartú go `async for`: ``` async for entry in Authors.objects.filter(name__startswith="A"): ... ``` Bí ar an eolas nach féidir leat rudaí eile a dhéanamh a d'fhéadfadh athrú thar an tacar ceisteanna, mar shampla ```liosta () ``a fhilleadh timpeall air chun a mheastóireacht a chur i bhfeidhm (is féidir leat ``async for``` a úsáid i dtuiscint, más mian leat é). Toisc nach ritheann modhanna ```QuerySet ``mar `filter ()``` agus eisiamh () an ceist i ndáiríre - bhunaíonn siad an tacar ceisteanna le rith nuair a dhéantar é a athrá - is féidir leat iad sin a úsáid go saor i gcód asincrónach. Le haghaidh treoir maidir le cé na modhanna is féidir a choinneáil a úsáid mar seo, agus a bhfuil leaganacha asincrónacha acu, léigh an chéad chuid eile. ### QuerySet agus modhanna bainisteora Cuireann roinnt modhanna ar bhainisteoirí agus ceisteanna ceisteanna - cosúil le ```get () ``agus ``first ()``` \- forghníomhú an tacar ceisteanna agus tá siad ag blocáil. Ní chuireann cuid acu, cosúil le filter () \`\`agus \`\`eisiamh ()\`, forghníomhú i bhfeidhm agus mar sin tá siad sábháilte a rith ó chód asincrónach. Ach conas a cheaptar duit an difríocht a insint? Cé go bhféadfá dul timpeall agus a fheiceáil an bhfuil leagan réamhshocraithe `a` ann (mar shampla, tá ```aget () ``againn ach ní ``afilter ()```), tá bealach níos loighciúla ann - féach suas cén cineál modh atá ann in:doc: QuerySet tagair. \ Ansin, gheobhaidh tú na modhanna ar QuerySets atá grúpáilte ina dhá chuid: - *Methods that return new querysets*: These are the non-blocking ones, and don't have asynchronous versions. You're free to use these in any situation, though read the notes on `defer()` and `only()` before you use them. - *Methods that do not return querysets*: These are the blocking ones, and have asynchronous versions - the asynchronous name for each is noted in its documentation, though our standard pattern is to add an `a` prefix. Ag baint úsáide as an idirdhealú seo, is féidir leat oibriú amach nuair is gá duit leaganacha asincrónacha a úsáid, agus nuair nach ndéanann tú. Mar shampla, seo ceist asincrónach bailí: ``` user = await User.objects.filter(username=my_input).afirst() ``` Filleann ```filter () ``tacar fiosrúcháin, agus mar sin tá sé go breá é a choinneáil taobh istigh de thimpeallacht asincrónach, ach déanann ``first ()``` measúnú agus filleann sé samhail - dá bhrí sin, athraímid go first () , agus úsáidimid ag teacht tosaigh an abairt iomlán chun é a ghlaoch ar bhealach asincrónach. > **Note** > > \Má dhéanann tú dearmad an chuid ag fanacht a chur isteach, b'fhéidir go bhfeicfidh tú earráidí cosúil\* “níl aon tréith x” \* nó *"* teaghráin ag réad coroutine in ionad do chásanna samhail. Má fheiceann tú iad seo riamh, tá “ag fanacht” in easnamh áit éigin chun an coroutine sin a iompú ina luach fíor. ### Idirbhearta Ní thacaítear le hidirbhearta faoi láthair le ceisteanna agus nuashonruithe asincrónacha. Gheobhaidh tú amach go n-ardaíonn iarracht ceann amháin a úsáid `SynchronousOnlyOperation`. Más mian leat idirbheart a úsáid, molaimid duit do chód ORM a scríobh istigh de fheidhm shioncronach ar leithligh agus ansin glaoch air sin ag úsáid sync\_to\_async\` \- féach: doc: /topics/async le haghaidh tuilleadh. ## Ag fiosrú `Jsonfield` Tá cur i bhfeidhm Lookups difriúil in:class: ~django.db.models.jsonField, go príomha mar gheall ar phríomhchlaochruithe a bheith ann. Chun a thaispeáint, úsáidfimid an tsamhail sampla seo a leanas: ``` from django.db import models class Dog(models.Model): name = models.CharField(max_length=200) data = models.JSONField(null=True) def __str__(self): return self.name ``` ### Stóráil agus fiosrú ar `None` Mar is amhlaidh le réimsí eile, stóráilfear `None` mar luach an réimse é mar SQL `NULL`. \Cé nach mholtar, is féidir scalar JSON a stóráil `null` in ionad SQL `NULL` trí:class: Value (None, JSONField ()) a úsáid. Cibé ceann de na luachanna a stóráiltear, nuair a aisghabtar ón mbunachar sonraí, tá léiriú Python ar an scalar JSON `null` mar an gcéanna le SQL `NULL`, ie None . Dá bhrí sin, is féidir go mbeadh sé deacair idirdhealú eatarthu. Ní bhaineann sé seo ach le `None` mar luach barrleibhéil an réimse. Má tá `None` taobh istigh de a:py:class: list nó: py:class: dict, léirmhínítear é i gcónaí mar JSON `null`. Agus tú ag fiosrú, léirmhínítear luach ```None ``i gcónaí mar JSON ``null```. Chun fiosrú a dhéanamh ar SQL `NULL`, bain úsáid:lookup: isnull: ```pycon >>> Dog.objects.create(name="Max", data=None) # SQL NULL. >>> Dog.objects.create(name="Archie", data=Value(None, JSONField())) # JSON null. >>> Dog.objects.filter(data=None) ]> >>> Dog.objects.filter(data=Value(None, JSONField())) ]> >>> Dog.objects.filter(data__isnull=True) ]> >>> Dog.objects.filter(data__isnull=False) ]> ``` Mura bhfuil tú cinnte gur mhaith leat oibriú le luachanna SQL `NULL`, smaoinigh ar Null=False\` a shocrú agus réamhshocrú oiriúnach a sholáthar do luachanna folmha, mar shampla `default=dict`. > **Note** > > \Ní sháraíonn scálar JSON `null` a stóráil: attr: Null = false . ### Athraíonn eochair, innéacs agus cosán Chun ceist a dhéanamh bunaithe ar eochair foclóra ar leith, bain úsáid as an eochair sin mar ainm an chuardaigh: ```pycon >>> Dog.objects.create( ... name="Rufus", ... data={ ... "breed": "labrador", ... "owner": { ... "name": "Bob", ... "other_pets": [ ... { ... "name": "Fishy", ... } ... ], ... }, ... }, ... ) >>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": None}) >>> Dog.objects.filter(data__breed="collie") ]> ``` Is féidir eochracha iolracha a shlánú le chéile chun cuardach cosáin a fhoirmiú: ```pycon >>> Dog.objects.filter(data__owner__name="Bob") ]> ``` Más slámhshláir é an eochair, léirmhínítear é mar athrú innéacs i sraith: ```pycon >>> Dog.objects.filter(data__owner__other_pets__0__name="Fishy") ]> ``` \Má tá an eochair is mian leat a cheistiú trí chomhraic le hainm cuardaigh eile, bain úsáid as an cuardach: lookup: include ina ionad. Chun ceist a dhéanamh ar eochracha atá in easnamh, bain úsáid as an lorg `isnull`: ```pycon >>> Dog.objects.create(name="Shep", data={"breed": "collie"}) >>> Dog.objects.filter(data__owner__isnull=True) ]> ``` > **Note** > > Úsáideann na samplaí cuardaigh a thugtar thuas go hinchinneach an cuardach: lookup: exact. Is féidir athfhoirmithe eochair, innéacs agus cosáin a shlánú freisin le: :lookup: icontains, :lookup: endswith, :lookup: iendswith, :lookup: iexact, :lookup: regex, :lookup: iregex, :lookup: istarts , :lookup: \`lt, :lookup: lte, :lookup: gt, agus:lookup: gte, chomh maith le:ref: coinníomh-agus-cuardach eochair. #### Nathanna KT () \`\` #### `class KT(lookup)` Léiríonn sé luach téacs eochair, innéacs nó claochlú cosáin de:class: ~django.db.models.jsonField. Is féidir leat an nótaí béim dhúbailte a úsáid i `lookup` chun eochair foclóra agus claochruithe innéacs a shlabhra. Mar shampla: ```pycon >>> from django.db.models.fields.json import KT >>> Dog.objects.create( ... name="Shep", ... data={ ... "owner": {"name": "Bob"}, ... "breed": ["collie", "lhasa apso"], ... }, ... ) >>> Dog.objects.annotate( ... first_breed=KT("data__breed__1"), owner_name=KT("data__owner__name") ... ).filter(first_breed__startswith="lhasa", owner_name="Bob") ]> ``` > **Note** > > Mar gheall ar an mbealach a n-oibríonn ceisteanna cosáin eochair, ní ráthaítear go dtáirgfidh: :meth: ~django.db.models.query.queryset.filter tacair uileghabhálacha. Más mian leat rudaí nach bhfuil an cosán acu a chur san áireamh, cuir an cuardach `isnull` leis. > **Warning** > > Ós rud é go bhféadfadh aon teaghrán a bheith ina eochair i réad JSON, léirmhínítear aon chuardach seachas iad siúd atá liostaithe thíos mar phríomhchuardach. Ní ardaítear aon earráidí. Bí cúramach thar a bheith cúramach maidir le botúin clóscríobh, agus seiceáil i gcónaí go n-oibríonn do chuid > **Úsáideoirí MariaDB agus Oracle** > > Ag baint úsáid:Meth: ~django.db.models.query.queryset.order\_by ar eochair, innéacs nó athraithe cosáin déanfaidh siad na rudaí a shórtáil ag baint úsáide as léiriú teaghrán na luachanna. Tá sé seo toisc nach soláthraíonn MariaDB agus Bunachar Sonraí Oracle feidhm a athraíonn luachanna JSON ina luachanna coibhéiseach SQL. > **Úsáideoirí Oracle** > > Ar Bhunachar Sonraí Oracle, ag baint úsáide as `None` mar an luach cuardaigh i an:meth: ~django.db.models.query.queryset.exclude, cuirfear ar ais rudaí nach bhfuil null\` acu mar an luach ag an gcosán ar leith, lena n-áirítear rudaí nach bhfuil an cosán acu. Ar chúltaca bunachar sonraí eile, cuirfidh an ceist ar ais rudaí a bhfuil an cosán acu agus nach bhfuil an luach `null`. > **Úsáideoirí PostgreSQL** > > Ar PostgreSQL, mura n-úsáidtear ach eochair nó innéacs amháin, úsáidtear an t-oibreoir SQL ```-> ``. Má úsáidtear oibreoirí iolracha ansin úsáidtear an oibreoir ``#>```. > **Úsáideoirí SQLite** > > Ar SQLite, léirmhínítear luachanna teaghrán `"true"`, `bréagai"`, agus `` `null" `` luachanna teaghrán i gcónaí mar `True`, False\`, agus JSON `null` faoi seach. ### Cuardaigh coimeádta agus príomhfheidhmeanna #### `Coimeád` Cuirtear an cuardach: lookup: contains ar `JSONfield`. Is iad na rudaí a thugtar ar ais iad siúd ina bhfuil an `dict` tugtha de phéirí eochairluacha go léir i mbarrleibhéal an réimse. Mar shampla: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"}) >>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"}) >>> Dog.objects.create(name="Fred", data={}) >>> Dog.objects.create( ... name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]} ... ) >>> Dog.objects.filter(data__contains={"owner": "Bob"}) , ]> >>> Dog.objects.filter(data__contains={"breed": "collie"}) ]> >>> Dog.objects.filter(data__contains={"tricks": ["dance"]}) ]> ``` > **Oracle agus SQLite** > > Ní thacaítear le `contains` ar Oracle agus SQLite. #### `coinneáilteo_ag` Is é seo an inbhéar den chuardach: lookup: conté \\- is iad na rudaí a chuirtear ar ais iad na rudaí ina bhfuil na péirí luacha eochair ar an réad ina fho-thacar de na rudaí sa luach a rith. Mar shampla: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"}) >>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"}) >>> Dog.objects.create(name="Fred", data={}) >>> Dog.objects.create( ... name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]} ... ) >>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"}) , ]> >>> Dog.objects.filter(data__contained_by={"breed": "collie"}) ]> >>> Dog.objects.filter( ... data__contained_by={"breed": "pekingese", "tricks": ["dance", "fetch", "hug"]} ... ) , ]> ``` > **Oracle agus SQLite** > > Ní thacaítear le `contained_by` ar Oracle agus SQLite. #### `a_eochair` Tugann sé rudaí ar ais i gcás ina bhfuil an eochair thugtar i barr-leibhéal na sonraí. Mar shampla: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador"}) >>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"}) >>> Dog.objects.filter(data__has_key="owner") ]> ``` #### `hais_eochair` Tugann sé rudaí ar ais ina bhfuil na heochracha a thugtar go léir i barr-leibhéal na sonraí. Mar shampla: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador"}) >>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"}) >>> Dog.objects.filter(data__has_keys=["breed", "owner"]) ]> ``` #### `` `aon_eochair `` Tugann sé rudaí ar ais ina bhfuil aon cheann de na heochracha a thugtar i barr-leibhéal na sonraí. Mar shampla: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador"}) >>> Dog.objects.create(name="Meg", data={"owner": "Bob"}) >>> Dog.objects.filter(data__has_any_keys=["owner", "breed"]) , ]> ``` ## Cuardaigh casta le rudaí `Q` Is iad ceisteanna argóint eochairfhocal -- in: meth: ~django.db.models.query.queryset.filter, srl. -- “agus"ED le chéile. \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í a úsáid. A: aicme: Is réad é Q \'(\`Django.db.Models.q\`) réad a úsáidtear chun bailiúchán argóintí eochairfhocal a chumhdú. Sonraítear na hargóintí eochairfhocal seo mar atá i “Cuardaigh réimse” thuas. Mar shampla, cuimsíonn an réad `Q` seo fiosrúchán `LIKE` amháin: ``` from django.db.models import Q Q(question__startswith="What") ``` Is féidir rudaí `Q` a chomhcheangal ag baint úsáide as na hoibreoirí `&`, |\`, agus `^`. Nuair a úsáidtear oibreoir ar dhá rud `Q`, tugann sé réad nua `Q`. Mar shampla, tugann an ráiteas seo réad `Q` amháin a léiríonn “OR” de dhá cheist ``` ``ceiste__startswith" ```: ``` Q(question__startswith="Who") | Q(question__startswith="What") ``` Tá sé seo coibhéiseach leis an gclásal SQL `WHERE` seo a leanas: ```sql WHERE question LIKE 'Who%' OR question LIKE 'What%' ``` Is féidir leat ráitis de chastacht treallach a chumadh trí rudaí `Q` a chomhcheangal leis na hoibreoirí `&`, |\`, agus `^` agus grúpáil lúibheach a úsáid. Chomh maith leis sin, is féidir rudaí `Q` a dhiúltú ag baint úsáide as an oibreoir `~`, ag ligean cuardach comhcheangailte a chomhcheanglaíonn gnáthcheistiú agus ceist diúltaithe (NOT ) araon: ``` Q(question__startswith="Who") | ~Q(pub_date__year=2005) ``` Is féidir gach feidhm chuardaigh a ghlacann argóintí eochairfhocal (e.g.:meth: ~django.db.models.query.queryset.filter, :meth: ~django.db.models.query.queryset.exclude, :meth: ~django.db.models.queryset.get) a rith freisin amháin nó níos mó Rud \`Q\` mar argóintí seasmhacha (gan ainmnithe). Má sholáthraíonn tú argóintí réad `Q` iolracha d'fheidhm cuardaigh, beidh na hargóintí “agus"ED le chéile. Mar shampla: ``` Poll.objects.get( Q(question__startswith="Who"), Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), ) ``` ... aistríonn sé go garbh go dtí an SQL: ```sql SELECT * from polls WHERE question LIKE 'Who%' AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') ``` Is féidir le feidhmeanna cuardaigh úsáid rudaí `Q` agus argóintí eochairfhocal a mheascadh. Tá na hargóintí go léir a chuirtear ar fáil do fheidhm chuardaigh (bíodh argóintí eochairfhocal nó rudaí `Q` iad) “agus” iad le chéile. Mar sin féin, má chuirtear réad `Q` ar fáil, ní mór dó roimh an sainmhíniú ar aon argóintí eochairfhocal. Mar shampla: ``` Poll.objects.get( Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), question__startswith="Who", ) ``` ... a bheadh ina cheist bailí, coibhéiseach leis an sampla roimhe seo; ach: ``` # INVALID QUERY Poll.objects.get( question__startswith="Who", Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), ) ``` ... ní bheadh bailí. > **See also** > > Taispeánann an: Foinse: OR sampla\ í cuardaitheach' i dtástálacha aonaid Django roinnt úsáidí féideartha de \`\`Q\`. ## Déan comparáid a dhéanamh Chun dhá chás samhail a chur i gcomparáid, bain úsáid as an oibreoir comparáide caighdeánach Python, an comhartha cothrom dúbailte: `==` Taobh thiar de na radhairc, déanann comparáid idir príomhluachanna dhá mhúnla. Ag baint úsáide as an sampla Iontrála\` thuas, tá an dá ráiteas seo a leanas coibhéiseach: ```pycon >>> some_entry == other_entry >>> some_entry.id == other_entry.id ``` Mura dtugtar “id” ar phríomh-eochair mhúnla, níl aon fhadhb ann. Úsáidfidh comparáidí an príomh-eochair i gcónaí, cibé rud a thugtar air. Mar shampla, má thugtar “ainm” ar phríomhréimse samhail, tá an dá ráiteas seo coibhéiseach: ```pycon >>> some_obj == other_obj >>> some_obj.name == other_obj.name ``` ## Rudaí a scriosadh Ainmnítear an modh scriosta, go háisiúil,: meth: ~django.db.models.model.delete. Scriostann an modh seo an réad láithreach agus filleann sé líon na rudaí a scriosadh agus foclóir le líon na scriosadh in aghaidh an chineál réada. Sampla: ```pycon >>> e.delete() (1, {'blog.Entry': 1}) ``` Is féidir leat rudaí a scriosadh ar an mórchóir freisin. Tá a:meth: ~django.db.models.query.queryset: ~django.db.models.queryset.delete modh, a scriosann gach ball den ain:class: ~django.db.models.queryset. Mar shampla, scriosann sé seo gach rud ```Entry ``le bliain ``pub_date``` de 2005: ```pycon >>> Entry.objects.filter(pub_date__year=2005).delete() (5, {'webapp.Entry': 5}) ``` Coinnigh i gcuimhne go ndéanfar é seo, nuair is féidir, a fhorghníomhú i SQL amháin, agus mar sin ní gá go nglófar ar na modhanna ```delete () `de chásanna réad aonair le linn an phróisis. Má chuir tú modh saincheaptha ``delete () ``ar fáil ar rang samhail agus má theastaíonn uait a chinntiú go nglactar air, beidh ort cásanna den tsamhail sin a scriosadh “de láimh” (m.sh., trí athrú thar a:class: `~django.db.Models.query.querySet` agus glaoch ar `delete ()``` ar gach rud ina n-aonar) seachas an bulk:meth: ~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~djan:~Modh go.db.models.queryset.delete de a:class: ~django.db.models.query.queryset. Nuair a scriosann Django réad, de réir réamhshocraithe déanann sé aithris ar iompar an srianta SQL ON DELETE CASCADE\` \- i bhfocail eile, scriosfar aon rudaí a raibh eochracha eachtracha ag díriú ar an réad atá le scriosadh in éineacht leis. Mar shampla: ``` b = Blog.objects.get(pk=1) # This will delete the Blog and all of its Entry objects. b.delete() ``` 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. Tabhair faoi deara gur:meth: ~django.db.models.query.queryset.delete an modh aon:class: ~django.db.models.queryset nach bhfuil nochtaithe ar a:class: ~Django.db.Models.Manager féin. Is meicníocht sábháilteachta é seo chun cosc a chur ort Entry.Objects.delete () a iarraidh de thaisme, agus *uach* na hiontrálacha a scriosadh. Más mian leat\* na rudaí go léir a scriosadh, ansin caithfidh tú tacar ceisteanna iomlán a iarraidh go sainráite: ``` Entry.objects.all().delete() ``` ## Cóipeáil cásanna samhail Cé nach bhfuil aon mhodh ionsuite ann chun cásanna samhail a chóipeáil, is féidir sampla nua a chruthú go héasca le luachanna gach réimse a chóipeáil. \Sa chás is simplí, is féidir leat pk\` a shocrú go `None` agus:attr: \_state.ag cur \`le \`\`True\`. Ag baint úsáide as ár sampla blag: ``` blog = Blog(name="My blog", tagline="Blogging is easy") blog.save() # blog.pk == 1 blog.pk = None blog._state.adding = True blog.save() # blog.pk == 2 ``` Éiríonn rudaí níos casta má úsáideann tú oidhreacht. Smaoinigh ar fho-aicme de `Blog`: ``` class ThemeBlog(Blog): theme = models.CharField(max_length=200) django_blog = ThemeBlog(name="Django", tagline="Django is easy", theme="python") django_blog.save() # django_blog.pk == 3 ``` Mar gheall ar an gcaoi a n-oibríonn oidhreacht, caithfidh tú `pk` agus id\` araon a shocrú go `None`, agus `_state.adding` go `True`: ``` django_blog.pk = None django_blog.id = None django_blog._state.adding = True django_blog.save() # django_blog.pk == 4 ``` Ní chóipeálann an próiseas seo caidrimh nach bhfuil mar chuid de thábla bunachar sonraí an tsamhail. Mar shampla, tá `` `ManyTomanyField `` ag `Entry` go `Údar`. Tar éis duit iontráil a dhúbailt, ní mór duit an caidreamh go leor a shocrú don iontráil nua: ``` entry = Entry.objects.all()[0] # some previous entry old_authors = entry.authors.all() entry.pk = None entry._state.adding = True entry.save() entry.authors.set(old_authors) ``` Maidir le OneToonefield\`, ní mór duit an réad gaolmhar a dhúbailt agus é a shannadh do réimse an réada nua chun an srian uathúil duine le duine a shárú. Mar shampla, ag glacadh leis go bhfuil “iontráil” dúbailte cheana féin mar atá thuas: ``` detail = EntryDetail.objects.all()[0] detail.pk = None detail._state.adding = True detail.entry = entry detail.save() ``` ## Nuashonrú iolrrudaí ag an am Uaireanta ba mhaith leat réimse a shocrú go luach áirithe do na rudaí go léir in a:class: ~django.db.models.query.queryset. Is féidir leat é seo a dhéanamh leis an modh: meth: ~django.db.models.query.queryset.update. Mar shampla: ``` # Update all the headlines with pub_date in 2007. Entry.objects.filter(pub_date__year=2007).update(headline="Everything is the same") ``` Ní féidir leat ach réimsí neamhghaolmhar agus:class: ~django.db.models.ForeignKey a shocrú ag baint úsáide as an modh seo. Chun réimse neamhghaolmhar a nuashonrú, cuir an luach nua ar fáil mar thairiseach. Chun réimsí: class: ~django.db.models.foreignKey a nuashonrú, socraigh an luach nua mar an samhail nua ar mhaith leat a chur in iúl dó. Mar shampla: ```pycon >>> b = Blog.objects.get(pk=1) # Change every Entry so that it belongs to this Blog. >>> Entry.objects.update(blog=b) ``` Cuirtear an modh update () \`\`i bhfeidhm láithreach agus filleann sé líon na sraitheanna a mheaitseálann an cheist (nach bhféadfadh a bheith comhionann le líon na sraitheanna a nuashonraítear má tá an luach nua ag roinnt sraitheanna cheana féin). Is é an t-aon srian ar an:class: \`~django.db.models.query.queryset atá á nuashonrú ná nach féidir leis rochtain a fháil ach tábla bunachar sonraí amháin: príomh-tábla an tsamhail. Is féidir leat scagadh bunaithe ar réimsí gaolmhara, ach ní féidir leat colúin a nuashonrú ach i bpríomh-thábla an tsamhail. Sampla: ```pycon >>> b = Blog.objects.get(pk=1) # Update all the headlines belonging to this Blog. >>> Entry.objects.filter(blog=b).update(headline="Everything is the same") ``` Bí ar an eolas go ndéantar an modh ```update () ``a thiontú go díreach go ráiteas SQL. Is mór-oibríocht í le haghaidh nuashonruithe díreacha. Ní ritheann sé modhanna ar bit:meth: `~django.db.models.model.save` ar do mhúnlaí, nó astaíonn sé na comharthaí ``pre_save``` nó `post_save` (atá mar thoradh ar ghlao:meth: ~Django.db.Models.Model.save), nó onóir dó:attr: ~django.db.db.Rogha réimse models.datefield.auto\_now. Más mian leat gach mír a shábháil in a:class: ~django.db.models.query.queryset agus a chinntiú go ndéantar an modh:meth: ~django.db.models.model.save ar gach cás, ní gá duit aon fheidhm speisialta chun é sin a láimhseáil. Lúb orthu agus glaoigh ar: meth: ~django.db.models.model.save: ``` for item in my_queryset: item.save() ``` Is féidir le glaonna chun nuashonrú a úsáid freisin: aicme: abairtí F \\`chun réimse amháin a nuashonrú bunaithe ar luach réimse eile sa tsamhail. Tá sé seo úsáideach go háirithe chun cuntair a mhéadú bunaithe ar a luach reatha. Mar shampla, chun an comhaireamh pingback a mhéadú do gach iontráil sa bhlag: ```pycon >>> Entry.objects.update(number_of_pingbacks=F("number_of_pingbacks") + 1) ``` Mar sin féin, murab ionann agus rudaí F () \`\`i gclásail scagaire agus eisiamh, ní féidir leat comhpháirteanna a thabhairt isteach nuair a úsáideann tú rudaí \`\`F ()\` i nuashonrú - ní féidir leat tagairt a dhéanamh ach réimsí áitiúla don tsamhail atá á nuashonrú. Má dhéanann tú iarracht teagmháil a thabhairt isteach le réad ```F () ``, ardófar ``Fielderror```: ```pycon # This will raise a FieldError >>> Entry.objects.update(headline=F("blog__name")) ``` ## Rudaí gaolmhara Nuair a shainmhíníonn tú caidreamh i samhail (ie: a:class: ~django.db.models.foreignKey, :class: ~django.db.models.onetoonefield, nó:class: ~django.db.models.manyToManyField), beidh API áisiúil ag cásanna den tsamhail sin chun rochtain a fháil ar an réad (í) gaolmhar. Ag baint úsáide as na samhlacha ag barr an leathanaigh seo, mar shampla, is féidir le réad `` `Entry `` a réad gaolmhar `Blog` a fháil trí rochtain a fháil ar an tréith ```blog ``: `e.blog```. \( Taobh thiar de na radhairc, cuireann Python: Doc: tuairiscí 'i bhfeidhm an fheidhmiúlacht seo. Níor chóir go bhfuil sé seo tábhachtach duit i ndáiríre, ach cuirimid in iúl é anseo do dhaoine aisteach.) Cruthaíonn Django rochtainí API freisin don taobh “eile” den chaidreamh - an nasc ón tsamhail ghaolmhar leis an tsamhail a shainmhíníonn an caidreamh. Mar shampla, tá rochtain ag réad `Blog` `b` ar liosta de na rudaí gaolmhara `Entry` tríd an tréith `entry_set`: b.entry\_set.all () \`. Úsáideann gach sampla sa chuid seo na samhlacha samplacha `Blog`, Údar\` agus `Iontrála` atá sainmhínithe ag barr an leathanaigh seo. ### Caidrimh duine le go leor #### Ar aghaidh Má tá a: class: ~django.db.models.foreignKey ag samhail, beidh rochtain ag cásanna den tsamhail sin ar an réad gaolmhar (eachtrach) trí thréith den tsamhail. Sampla: ```pycon >>> e = Entry.objects.get(id=2) >>> e.blog # Returns the related Blog object. ``` Is féidir leat a fháil agus a shocrú trí thréith eochair eachtrach. Mar a d'fhéadfá a bheith ag súil leis, ní shábháiltear athruithe ar an eochair eachtrach sa bhunachar sonraí go dtí go nglaonn tú ar: meth: ~django.db.models.model.save. Sampla: ```pycon >>> e = Entry.objects.get(id=2) >>> e.blog = some_blog >>> e.save() ``` Má tá a: class: ~django.db.models.foreignKey sraith `Null=True` réimse (ie, ceadaíonn sé luachanna `NULL`), is féidir leat `None` a shannadh chun an gaol a bhaint. Sampla: ```pycon >>> e = Entry.objects.get(id=2) >>> e.blog = None >>> e.save() # "UPDATE blog_entry SET blog_id = NULL ...;" ``` Déantar rochtain ar aghaidh ar chaidrimh duine le go leor a stóráil an chéad uair a rochtaítear ar an réad gaolmhar. Déantar rochtainí ina dhiaidh sin ar an eochair eachtrach ar an gcás réad céanna a stóráil. Sampla: ```pycon >>> e = Entry.objects.get(id=2) >>> print(e.blog) # Hits the database to retrieve the associated Blog. >>> print(e.blog) # Doesn't hit the database; uses cached version. ``` Tabhair faoi deara go ndéanann an modh:meth: `select_related` ~django.db.models.query.queryset taisce gach caidreamh duine le go leor roimh am go réamh-athshlánach. Sampla: ```pycon >>> e = Entry.objects.select_related().get(id=2) >>> print(e.blog) # Doesn't hit the database; uses cached version. >>> print(e.blog) # Doesn't hit the database; uses cached version. ``` #### Ag leanúint caidrimh “siar” If a model has a [`ForeignKey`](/ga/5.2/ref/models/fields/#django.db.models.ForeignKey), instances of the foreign-key model will have access to a [`Manager`](/ga/5.2/topics/db/managers/#django.db.models.Manager) that returns all instances of the first model. By default, this [`Manager`](/ga/5.2/topics/db/managers/#django.db.models.Manager) is named `FOO_set`, where `FOO` is the source model name, lowercased. This [`Manager`](/ga/5.2/topics/db/managers/#django.db.models.Manager) returns `QuerySet` instances, which can be filtered and manipulated as described in the "Retrieving objects" section above. Sampla: ```pycon >>> b = Blog.objects.get(id=1) >>> b.entry_set.all() # Returns all Entry objects related to Blog. # b.entry_set is a Manager that returns QuerySets. >>> b.entry_set.filter(headline__contains="Lennon") >>> b.entry_set.count() ``` Is féidir leat an t-ainm foo\_set\` a shárú tríd an sainmhíniú:attr: ~Django.db.Models.ForeignKey.Related\_Name a shocrú sa sainmhíniú: class: ~Django.db.Models.ForeignKey. Mar shampla, má athraíodh an tsamhail ```Entry ``go `blog = ForeignKey (Blog, on_delete=Models.Cascade, related_name='entries')```, bheadh cuma seo ar an gcód sampla thuas: ```pycon >>> b = Blog.objects.get(id=1) >>> b.entries.all() # Returns all Entry objects related to Blog. # b.entries is a Manager that returns ``QuerySet`` instances. >>> b.entries.filter(headline__contains="Lennon") >>> b.entries.count() ``` #### Bainisteoir droim saincheaptha a úsáid \De réir réamhshocraithe an: class: ~django.db.Models.Fields.Related.RelatedManager a úsáidtear le haghaidh caidrimh droim ina fho-aicme den :ref: bainisteoir réamhshocraithe don tsamhail sin. Más mian leat bainisteoir difriúil a shonrú le haghaidh ceist ar leith is féidir leat an comhréir seo a leanas a úsáid: ``` from django.db import models class Entry(models.Model): # ... objects = models.Manager() # Default Manager entries = EntryManager() # Custom Manager b = Blog.objects.get(id=1) b.entry_set(manager="entries").all() ``` Má rinne `EntryManager` scagadh réamhshocraithe ina mhodh ```get_queryset () ``, bheadh feidhm ag an scagadh sin leis an nglao ``all ()```. Cuireann bainisteoir droim saincheaptha a shonrú ar chumas tú a mhodhanna saincheaptha a ghlaoch freisin: ``` b.entry_set(manager="entries").is_published() ``` > **Idirghníomhaíocht le réamhghabháil** > > Agus tú ag glaoch: meth: ~django.db.models.query.queryset.prefetch\_related le gaol droim, úsáidfear an bainisteoir réamhshocraithe. \Más mian leat rudaí gaolmhara a réamh-fháil ag baint úsáide as bainisteoir droim saincheaptha, bain úsáid as: class: Prefetch () . Mar shampla: > > ``` > from django.db.models import Prefetch > > prefetch_manager = Prefetch("entry_set", queryset=Entry.entries.all()) > Blog.objects.prefetch_related(prefetch_manager) > ``` #### Modhanna breise chun rudaí gaolmhara a láim Chomh maith leis na modhanna: :class: ~django.db.models.query.querySet atá sainmhínithe i “Aisghabháil rudaí” thuas, tá modhanna breise ag an:class: ~django.db.models.manager chun an tacar rudaí gaolmhara a láimhseáil. Tá achoimre ar gach ceann thíos, agus is féidir sonraí iomlána a fháil in:doc: tagairt rudaí gaolmhara '\. **add (obj1, obj2, ... ) \`\`** Cuireann sé na rudaí samhail sonraithe leis an tacar réad gaolmhar. **cruthaigh (kwargs) \`\`** Cruthaíonn sé réad nua, sábhálann sé agus cuireann sé sa tacar réad gaolmhar é. Tugann sé an réad nua-chruthaithe ar ais. **bhaint (obj1, obj2, ... ) \`\`** Baineann na rudaí samhail sonraithe as an tacar réad gaolmhar. **soiléir () \`\`** Baineann gach rud as an tacar réad gaolmhar. **set (objs) \`\`** Cuir an tacar rudaí gaolmhara in ionad. Chun baill tacar gaolmhar a shannadh, bain úsáid as an modh ````set () ``le cásanna réad inathraithe. Mar shampla, más cásanna ```Iontrála```` iad e1\` agus `e2`: ``` b = Blog.objects.get(id=1) b.entry_set.set([e1, e2]) ``` Má tá an modh ```clear () ``ar fáil, bainfear aon rudaí atá ann cheana ón `entry_set``` sula gcuirfear gach rud san athraitheach (sa chás seo, liosta) leis an tacar. Má tá an modh clear () *níl* ar fáil, cuirfear gach rud san athraitheach leis gan aon eilimintí atá ann cheana a bhaint. Tá éifeacht láithreach ag gach oibríocht “droim” a thuairiscítear sa chuid seo ar an mbunachar sonraí. Sábháiltear gach breise, cruthú agus scriosadh láithreach agus go huathoibríoch sa bhunachar sonraí ### Caidrimh go leor Faigheann an dá fhoirceann de chaidreamh go leor rochtain uathoibríoch API ar an gceann eile. Oibríonn an API cosúil le caidreamh duine le go leor “ar chúl”, thuas. Tá difríocht amháin san ainmniú tréithe: Úsáideann an tsamhail a shainmhíníonn an:class: ~django.db.models.manyToManyField ainm tréithe an réimse sin féin, ach úsáideann an tsamhail “droim” ainm samhail íseal an tsamhail bhunaidh, móide '\_set'\` (díreach cosúil le caidrimh aon-go leor). Déanann sampla é seo níos éasca a thuiscint: ``` e = Entry.objects.get(id=3) e.authors.all() # Returns all Author objects for this Entry. e.authors.count() e.authors.filter(name__contains="John") a = Author.objects.get(id=5) a.entry_set.all() # Returns all Entry objects for this Author. ``` Cosúil le: Class: ~Django.db.Models.ForeignKey, :class: ~django.db.models.manyToManyField is féidir le sonraithe:attr: ~django.db.models.manyToManyField.Related\_Nam. Sa sampla thuas, má shonraíodh an:class: ~django.db.models.manyToManyField i Entry\` ```related_name='entries'`, ansin bheadh tréith ``entries``` ag gach `Author` tréith `entries` in ionad entry\_set\`. Difríocht eile ó chaidrimh duine le go leor ná go nglacann na modhanna ```add () ``, `set ()```, agus ```remove () ``ar chaidrimh go leor príomhluachanna, i dteannta le cásanna samhail. Mar shampla, más cásanna ``Entry``` iad `e1` agus `e2`, ansin oibríonn na glaonna set () seo go comhionann: ``` a = Author.objects.get(id=5) a.entry_set.set([e1, e2]) a.entry_set.set([e1.pk, e2.pk]) ``` ### Caidrimh duine le duine Tá caidrimh duine le duine an-chosúil le caidrimh go leor. Má shainmhíníonn tú a:class: ~django.db.models.onetoonefield ar do mhúnla, beidh rochtain ag cásanna den tsamhail sin ar an réad gaolmhar trí thréith den tsamhail. Mar shampla: ``` class EntryDetail(models.Model): entry = models.OneToOneField(Entry, on_delete=models.CASCADE) details = models.TextField() ed = EntryDetail.objects.get(id=2) ed.entry # Returns the related Entry object. ``` Tagann an difríocht i gceisteanna “droim”. Tá rochtain ag an tsamhail ghaolmhar i gcaidreamh duine le duine freisin ar réad a:class: ~django.db.Models.Manager, ach is ionann: class: ~django.db.Models.Manager réad amháin, seachas bailiúchán rudaí: ``` e = Entry.objects.get(id=2) e.entrydetail # returns the related EntryDetail object ``` Mura sannadh aon réad don chaidreamh seo, ardóidh Django eisceacht DoesNotExist. Is féidir cásanna a shannadh don chaidreamh droim ar an mbealach céanna agus a shannófá an réamhchaidreamh: ``` e.entrydetail = ed ``` ### Conas is féidir na caidrimh chúl indéanta? Éilíonn mapaitheoirí réad-ghaolmhara eile ort caidrimh a shainiú ar an dá thaobh. Creideann forbróirí Django gur sárú é seo ar phrionsabal DRY (Ná Déan Athdhéanamh Féin), mar sin ní éilíonn Django ach ort an caidreamh a shainiú ar cheann amháin. Ach conas is féidir é seo a dhéanamh, ós rud é nach bhfuil a fhios ag rang samhail cé na ranganna samhail eile a bhaineann leis go dtí go luchtaítear na ranganna samhail eile sin? \Tá an freagra sa chlárlann: data: app \`. Nuair a thosaíonn Django, allmhairíonn sé gach feidhmchlár atá liostaithe in:setting: \`INSTALLED\_APPS, agus ansin an modúl samhlacha taobh istigh de gach feidhmchlár. Aon uair a chruthaítear rang samhail nua, cuireann Django caidrimh siar le haon mhúnlaí gaolmhara. Mura n-allmhairíodh na samhlacha gaolmhara fós, coinníonn Django rianta de na caidrimh agus cuireann sé leo nuair a allmhairítear na samhlacha gaolmhara sa deireadh. Ar an gcúis seo, tá sé tábhachtach go bhfuil na samhlacha go léir atá á úsáid agat a shainiú in iarratais atá liostaithe in:setting: INSTALLED\_APPS. Seachas sin, b'fhéidir nach n-oibreoidh caidreamh cúil i gceart. ### Fiosruithe ar rudaí gaolm Leanann ceisteanna a bhaineann le rudaí gaolmhara na rialacha céanna le ceisteanna a bhaineann le réimsí Nuair a shonraítear an luach le haghaidh ceisteanna a mheaitseáil, féadfaidh tú sampla réada féin, nó an príomhluach don réad a úsáid. Mar shampla, má tá réad Blag `b` agat le id=5\`, bheadh na trí cheist seo a leanas comhionann: ``` Entry.objects.filter(blog=b) # Query using object instance Entry.objects.filter(blog=b.id) # Query using id from instance Entry.objects.filter(blog=5) # Query using id directly ``` ## Ag titim ar ais go SQL amh Má bhíonn gá duit fiosrúchán SQL a scríobh atá ró-chasta chun mapálaí bunachar sonraí Django a láimhseáil, is féidir leat titim siar ar SQL a scríobh de láimh. Tá cúpla rogha ag Django chun ceisteanna SQL amh a scríobh; féach: doc: /topics/db/sql. Faoi dheireadh, tá sé tábhachtach a thabhairt faoi deara nach bhfuil ciseal bunachar sonraí Django ach comhéadan le do bhunachar sonraí. Is féidir leat rochtain a fháil ar do bhunachar sonraí trí uirlisí eile, teangacha cláir nó creataí bunachar sonraí; níl aon rud Django-sonrach faoi do bhunachar sonraí.