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</topics/db/models> ú, 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</ref/models/index> ardaigh samhlacha éagsúla go léir.
\nLe linn na treoir seo (agus sa tagairt), déanfaimid tagairt do na samhlacha seo a leanas, a chuimsíonn feidhmchlár blag:
\nfrom datetime import date\n\nfrom django.db import models\n\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n tagline = models.TextField()\n\n def __str__(self):\n return self.name\n\n\nclass Author(models.Model):\n name = models.CharField(max_length=200)\n email = models.EmailField()\n\n def __str__(self):\n return self.name\n\n\nclass Entry(models.Model):\n blog = models.ForeignKey(Blog, on_delete=models.CASCADE)\n headline = models.CharField(max_length=255)\n body_text = models.TextField()\n pub_date = models.DateField()\n mod_date = models.DateField(default=date.today)\n authors = models.ManyToManyField(Author)\n number_of_comments = models.IntegerField(default=0)\n number_of_pingbacks = models.IntegerField(default=0)\n rating = models.IntegerField(default=5)\n\n def __str__(self):\n return self.headline\nChun 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í.
\nChun 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í.
\nAg glacadh leis go gcónaíonn samhlacha i gcomhad models.py taobh istigh d'aip `blog ``Django, seo sampla:
>>> from blog.models import Blog\n>>> b = Blog(name="Beatles Blog", tagline="All the latest Beatles news.")\n>>> b.save()\nDé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.
\n\nChun 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.
\nMar 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í:
>>> b5.name = "New name"\n>>> b5.save()\nDé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.
ForeignKey agus ManyTomanyField a shábháilLink to this heading#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):
>>> from blog.models import Blog, Entry\n>>> entry = Entry.objects.get(pk=1)\n>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")\n>>> entry.blog = cheese_blog\n>>> entry.save()\nOibrí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:
>>> from blog.models import Author\n>>> joe = Author.objects.create(name="Joe")\n>>> entry.authors.add(joe)\nChun 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:
\n>>> john = Author.objects.create(name="John")\n>>> paul = Author.objects.create(name="Paul")\n>>> george = Author.objects.create(name="George")\n>>> ringo = Author.objects.create(name="Ringo")\n>>> entry.authors.add(john, paul, george, ringo)\nDéanfaidh Django gearán má dhéanann tú iarracht réad den chineál mícheart a shannadh nó a chur leis.
\nChun 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.
\nA: 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:
\n>>> Blog.objects\n<django.db.models.manager.Manager object at ...>\n>>> b = Blog(name="Foo", tagline="Bar")\n>>> b.objects\nTraceback:\n ...\nAttributeError: "Manager isn't accessible via Blog instances."\nThe Manager is the main source of querysets for\na model. For example, Blog.objects.all() returns a\nQuerySet that contains all Blog objects in\nthe database.
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:
\n>>> all_entries = Entry.objects.all()\nTugann 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í.
\nDé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ú.
\nChun 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ú:
\nFilleann sé nua:class: ~django.db.models.query.querySet ina bhfuil rudaí a mheaitseálann leis na paraiméadair cuardaigh ar leith.
\nFilleann sé nua:class: ~django.db.models.query.querySet ina bhfuil rudaí nach n-oireann naí* leis na paraiméadair chuardaigh a thugtar.
\nBa 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.
\nMar 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:
\nEntry.objects.filter(pub_date__year=2006)\nLeis an rang bainisteora réamhshocraithe, tá sé mar an gcéanna le:
\nEntry.objects.all().filter(pub_date__year=2006)\nIs é 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:
\n>>> Entry.objects.filter(headline__startswith="What").exclude(\n... pub_date__gte=datetime.date.today()\n... ).filter(pub_date__gte=datetime.date(2005, 1, 30))\nTó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.
\nQuerySet uathúilLink to this heading#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.
\nSampla:
\n>>> q1 = Entry.objects.filter(headline__startswith="What")\n>>> q2 = q1.exclude(pub_date__gte=datetime.date.today())\n>>> q3 = q1.filter(pub_date__gte=datetime.date.today())\nThese three querysets are separate. The first is a base\nQuerySet containing all entries that contain a\nheadline starting with "What". The second is a subset of the first, with an\nadditional criteria that excludes records whose pub_date is today or in the\nfuture. The third is a subset of the first, with an additional criteria that\nselects only the records whose pub_date is today or in the future. The\ninitial QuerySet (q1) is unaffected by the\nrefinement process.
QuerySet leisciúilLink to this heading#QuerySet objects are lazy -- the act of creating a\nQuerySet doesn't involve any database\nactivity. You can stack filters together all day long, and Django won't\nactually run the query until the QuerySet is\nevaluated. Take a look at this example:
>>> q = Entry.objects.filter(headline__startswith="What")\n>>> q = q.filter(pub_date__lte=datetime.date.today())\n>>> q = q.exclude(body_text__icontains="food")\n>>> print(q)\nCé 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.
\nfilter() will always give you a\nQuerySet, even if only a single object matches\nthe query - in this case, it will be a\nQuerySet 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:
\n>>> one_entry = Entry.objects.get(pk=1)\nIs 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 thíos.
\nTabhair 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.
\nAn 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 <queryset-api>osta iomlán de na modhanna éagsúla:class: `~django.db.models.queryset go léir.
\nQuerySetsLink to this heading#Ú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):
>>> Entry.objects.all()[:5]\nTugann sé seo an séú réad tríd an deichiú rud ar ais (OFFSET 5 TEORAINN 5):
>>> Entry.objects.all()[5:10]\nNí thacaítear le hinnéacsú diúltach (ie ``Entry.Objects.all () [-1] ``).
\nGo 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:
\n>>> Entry.objects.all()[:10:2]\nTá 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.
\nChun 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:
>>> Entry.objects.order_by("headline")[0]\nTá sé seo coibhéiseach thart ar:
\n>>> Entry.objects.order_by("headline")[0:1].get()\nTabhair 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í.
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:
>>> Entry.objects.filter(pub_date__lte="2006-01-01")\naistríonn (go garbh) go dtí an SQL seo a leanas:
\nSELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';\nCaithfidh 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:
>>> Entry.objects.filter(blog_id=4)\nMá chuireann tú argóint eochairfhocal neamhbhailí, ardóidh feidhm chuardaigh typeError.
<field-lookups>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:
\nexactCluiche “cruinn”. Mar shampla:
\n>>> Entry.objects.get(headline__exact="Cat bites dog")\nGhinfidh sé SQL ar na línte seo:
\nSELECT ... WHERE headline = 'Cat bites dog';\nMura 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.
\nMar shampla, tá an dá ráiteas seo a leanas coibhéiseach:
\n>>> Blog.objects.get(id__exact=14) # Explicit form\n>>> Blog.objects.get(id=14) # __exact is implied\nTá sé seo ar mhaithe le háisiúlacht, mar is é cuardaigh ``cruinn ``an cás coitianta.
\niexactCluiche cás-neamh-íogair. Mar sin, an cheist:
\n>>> Blog.objects.get(name__iexact="beatles blog")\nMeaitseálann sé Blag dar teideal "Blag Beatles", blog beatles", nó fiú "Blag Beatles".
containsTástáil srianta cás-íogair. Mar shampla:
\nEntry.objects.get(headline__contains="Lennon")\nAistríonn sé go garbh go dtí an SQL seo:
\nSELECT ... WHERE headline LIKE '%Lennon%';\nTabhair 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.
\nstartswith, endswithTosaí-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.
\nArís, ní scriosann sé seo ach an dromchla. <field-lookups>Is féidir tagairt iomlán a fháil in:ref: `tagairt cuardaigh réimse `.
\nCuireann 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.
\nAisghabhraíonn an sampla seo gach rud Entry le Blog a bhfuil ainm `````Blog `Beatles Blog`:
>>> Entry.objects.filter(blog__name="Beatles Blog")\nIs féidir leis an sceitheadh seo a bheith chomh domhain agus is mian leat.
\nIt works backwards, too. While it can be customized by setting\nrelated_query_name, by default you\nrefer to a "reverse" relationship in a lookup using the lowercase name of the\nmodel.
Aisghabhraíonn an sampla seo gach rud `Blog a bhfuil Iontrála amháin ar a laghad aici a bhfuil Lennon 'ceannlíne ``:
>>> Blog.objects.filter(entry__headline__contains="Lennon")\nMá 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")\n(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)\ncuirfidh 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)\nNuair 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:
\nBlog.objects.filter(entry__headline__contains="Lennon", entry__pub_date__year=2008)\nSeachas 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:
\nBlog.objects.filter(entry__headline__contains="Lennon").filter(\n entry__pub_date__year=2008\n)\nCuir 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.
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?
\nDjango provides Nathanna ``F () `` to allow such comparisons. Instances of\nF() act as a reference to a model field within a query. These references\ncan then be used in query filters to compare the values of two different fields\non the same model instance.
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:
>>> from django.db.models import F\n>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks"))\nTacaí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ú:
\n>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks") * 2)\nChun 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:
\n>>> Entry.objects.filter(rating__lt=F("number_of_comments") + F("number_of_pingbacks"))\nIs 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:
\n>>> Entry.objects.filter(authors__name=F("blog__name"))\nMaidir 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ú:
\n>>> from datetime import timedelta\n>>> Entry.objects.filter(mod_date__gt=F("pub_date") + timedelta(days=3))\nTacaíonn na rudaí F () ``le hoibríochtaí bitwise le ``.bitand (), .bitor () `, .bitxor ()`, .bitxor () `, .bitrightshift ()`, agus ``.bitleftshift () ``. Mar shampla:
>>> F("somefield").bitand(16)\nTacaíonn Django le hathruithe a úsáid i nathanna.
\nMar shampla, chun gach rud ``Iontrála` a fhoilsíodh sa bhliain chéanna agus a mhodhníodh iad go deireanach a aimsiú:
\n>>> from django.db.models import F\n>>> Entry.objects.filter(pub_date__year=F("mod_date__year"))\nChun an bhliain is luaithe foilsíodh iontráil a fháil, is féidir linn an cheist a eisiúint:
\n>>> from django.db.models import Min\n>>> Entry.objects.aggregate(first_published_year=Min("pub_date__year"))\nAimsíonn an sampla seo luach an iontrála is airde agus líon iomlán na dtuairimí ar gach iontráil do gach bliain:
\n>>> from django.db.models import OuterRef, Subquery, Sum\n>>> Entry.objects.values("pub_date__year").annotate(\n... top_rating=Subquery(\n... Entry.objects.filter(\n... pub_date__year=OuterRef("pub_date__year"),\n... )\n... .order_by("-rating")\n... .values("rating")[:1]\n... ),\n... total_comments=Sum("number_of_comments"),\n... )\npkLink to this heading#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:
>>> Blog.objects.get(id__exact=14) # Explicit form\n>>> Blog.objects.get(id=14) # __exact is implied\n>>> Blog.objects.get(pk=14) # pk implies id__exact\nNí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:
# Get blogs entries with id 1, 4 and 7\n>>> Blog.objects.filter(pk__in=[1, 4, 7])\n\n# Get all blog entries with id > 14\n>>> Blog.objects.filter(pk__gt=14)\nOibríonn cuardaigh pk` trasna comhpháirteanna freisin. Mar shampla, tá na trí ráiteas seo coibhéiseach:
\n>>> Entry.objects.filter(blog__id__exact=3) # Explicit form\n>>> Entry.objects.filter(blog__id=3) # __exact is implied\n>>> Entry.objects.filter(blog__pk=3) # __pk implies __id__exact\nLIKELink to this heading#É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
\n>>> Entry.objects.filter(headline__contains="%")\nTugann Django aire don luachan duit; beidh cuma mar seo ar an SQL mar seo:
\nSELECT ... WHERE headline LIKE '%\\%%';\nBaineann an rud céanna le béim. Déantar comharthaí céatadáin agus béim a láimhseáil duit go trédhearcach.
\nQuerySetsLink to this heading#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.
\nI: 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.
\nCoinnigh 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:
\n>>> print([e.headline for e in Entry.objects.all()])\n>>> print([e.pub_date for e in Entry.objects.all()])\nCiallaí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.
\nChun an fhadhb seo a sheachaint, sábháil an:class: ~django.db.models.query.queryset agus athúsáid é:
\n>>> queryset = Entry.objects.all()\n>>> print([p.headline for p in queryset]) # Evaluate the query set.\n>>> print([p.pub_date for p in queryset]) # Reuse the cache from the evaluation.\nQuerySet\\ s a choscLink to this heading#Querysets do not always cache their results. When evaluating only part of\nthe queryset, the cache is checked, but if it is not populated then the items\nreturned by the subsequent query are not cached. Specifically, this means that\nlimiting the queryset using an array slice or an\nindex will not populate the cache.
\nMar 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:
\n>>> queryset = Entry.objects.all()\n>>> print(queryset[5]) # Queries the database\n>>> print(queryset[5]) # Queries the database again\nMar sin féin, má rinneadh an tacar fiosrúcháin iomlán a mheas cheana féin, seiceálfar an taisce ina ionad sin:
\n>>> queryset = Entry.objects.all()\n>>> [entry for entry in queryset] # Queries the database\n>>> print(queryset[5]) # Uses cache\n>>> print(queryset[5]) # Uses cache\nSeo 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:
\n>>> [entry for entry in queryset]\n>>> bool(queryset)\n>>> entry in queryset\n>>> list(queryset)\nMá 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).
\nAr á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.
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"):\n ...\nBí 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.
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. </ref/models/querysets>
Ansin, gheobhaidh tú na modhanna ar QuerySets atá grúpáilte ina dhá chuid:
\nMethods that return new querysets: These are the non-blocking ones,\nand don't have asynchronous versions. You're free to use these in any\nsituation, but understand the constraint of no deferred queries before\nusing defer(),\nonly(), or\nfetch_mode().
Methods that do not return querysets: These are the blocking ones, and\nhave asynchronous versions - the asynchronous name for each is noted in its\ndocumentation, 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í:
\nuser = await User.objects.filter(username=my_input).afirst()\nFilleann 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.
Relations are deferred by default. If the blog relation is not prefetched,\naccessing entry.blog during asynchronous evaluation of a queryset attempts\na blocking database query, raising SynchronousOnlyOperation. (A similar\nlimitation applies to fields deferred via defer() or only().) To avoid\nthis, see the advice on prefetching in Rudaí gaolmhara.
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.
\nJsonfieldLink to this heading#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:
\nfrom django.db import models\n\n\nclass Dog(models.Model):\n name = models.CharField(max_length=200)\n data = models.JSONField(null=True)\n\n def __str__(self):\n return self.name\nNoneLink to this heading#As with other fields, storing None as the field's value will store it as\nSQL NULL. While not recommended, it is possible to store JSON scalar\nnull instead of SQL NULL by using the JSONNull() expression.
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.
This only applies to None as the top-level value of the field. If None\nis inside a list or dict, it will always be interpreted\nas JSON null.
When querying, isnull=True is used to match SQL NULL,\nwhile exact-matching JSONNull() is used to match JSON null.
>>> from django.db.models import JSONNull\n>>> Dog.objects.create(name="Max", data=None) # SQL NULL.\n<Dog: Max>\n>>> Dog.objects.create(name="Archie", data=JSONNull()) # JSON null.\n<Dog: Archie>\n>>> Dog.objects.filter(data=None)\n...: RemovedInDjango70Warning: Using None as the right-hand side of an\nexact lookup on JSONField to mean JSON scalar 'null' is deprecated. Use\nJSONNull() instead (or use the __isnull lookup if you meant SQL NULL).\n...\n<QuerySet [<Dog: Archie>]>\n>>> Dog.objects.filter(data=JSONNull())\n<QuerySet [<Dog: Archie>]>\n>>> Dog.objects.filter(data__isnull=True)\n<QuerySet [<Dog: Max>]>\n>>> Dog.objects.filter(data__isnull=False)\n<QuerySet [<Dog: Archie>]>\nMura 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.
Chun ceist a dhéanamh bunaithe ar eochair foclóra ar leith, bain úsáid as an eochair sin mar ainm an chuardaigh:
\n>>> Dog.objects.create(\n... name="Rufus",\n... data={\n... "breed": "labrador",\n... "owner": {\n... "name": "Bob",\n... "other_pets": [\n... {\n... "name": "Fishy",\n... }\n... ],\n... },\n... },\n... )\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": None})\n<Dog: Meg>\n>>> Dog.objects.filter(data__breed="collie")\n<QuerySet [<Dog: Meg>]>\nTo query a key for JSON null, None or JSONNull() can be used.
>>> Dog.objects.filter(data__owner=None)\n<Dog: Meg>\n>>> Dog.objects.filter(data__owner=JSONNull())\n<Dog: Meg>\nIs féidir eochracha iolracha a shlánú le chéile chun cuardach cosáin a fhoirmiú:
\n>>> Dog.objects.filter(data__owner__name="Bob")\n<QuerySet [<Dog: Rufus>]>\nMás slámhshláir é an eochair, léirmhínítear é mar athrú innéacs i sraith:
\n>>> Dog.objects.filter(data__owner__other_pets__0__name="Fishy")\n<QuerySet [<Dog: Rufus>]>\nIf the key is a negative integer, it cannot be used in a filter keyword\ndirectly, but you can still use dictionary unpacking to use it in a query:
\n>>> Dog.objects.filter(**{"data__owner__other_pets__-1__name": "Fishy"})\n<QuerySet [<Dog: Rufus>]>\n<jsonfield.contains>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.
\nChun ceist a dhéanamh ar eochracha atá in easnamh, bain úsáid as an lorg isnull:
>>> Dog.objects.create(name="Shep", data={"breed": "collie"})\n<Dog: Shep>\n>>> Dog.objects.filter(data__owner__isnull=True)\n<QuerySet [<Dog: Shep>]>\nLé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:
\n>>> from django.db.models.fields.json import KT\n>>> Dog.objects.create(\n... name="Shep",\n... data={\n... "owner": {"name": "Bob"},\n... "breed": ["collie", "lhasa apso"],\n... },\n... )\n<Dog: Shep>\n>>> Dog.objects.annotate(\n... first_breed=KT("data__breed__1"), owner_name=KT("data__owner__name")\n... ).filter(first_breed__startswith="lhasa", owner_name="Bob")\n<QuerySet [<Dog: Shep>]>\nCoimeádLink to this heading#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:
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n<Dog: Meg>\n>>> Dog.objects.create(name="Fred", data={})\n<Dog: Fred>\n>>> Dog.objects.create(\n... name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]}\n... )\n>>> Dog.objects.filter(data__contains={"owner": "Bob"})\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\n>>> Dog.objects.filter(data__contains={"breed": "collie"})\n<QuerySet [<Dog: Meg>]>\n>>> Dog.objects.filter(data__contains={"tricks": ["dance"]})\n<QuerySet [<Dog: Merry>]>\ncoinneáilteo_agLink to this heading#Is é seo an inbhéar den chuardach: lookup: conté <jsonfield.contains>- 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:
\n>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n<Dog: Meg>\n>>> Dog.objects.create(name="Fred", data={})\n<Dog: Fred>\n>>> Dog.objects.create(\n... name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]}\n... )\n>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})\n<QuerySet [<Dog: Meg>, <Dog: Fred>]>\n>>> Dog.objects.filter(data__contained_by={"breed": "collie"})\n<QuerySet [<Dog: Fred>]>\n>>> Dog.objects.filter(\n... data__contained_by={"breed": "pekingese", "tricks": ["dance", "fetch", "hug"]}\n... )\n<QuerySet [<Dog: Merry>, <Dog: Fred>]>\na_eochairLink to this heading#Tugann sé rudaí ar ais i gcás ina bhfuil an eochair thugtar i barr-leibhéal na sonraí. Mar shampla:
\n>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n<Dog: Meg>\n>>> Dog.objects.filter(data__has_key="owner")\n<QuerySet [<Dog: Meg>]>\nhais_eochairLink to this heading#Tugann sé rudaí ar ais ina bhfuil na heochracha a thugtar go léir i barr-leibhéal na sonraí. Mar shampla:
\n>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})\n<Dog: Meg>\n>>> Dog.objects.filter(data__has_keys=["breed", "owner"])\n<QuerySet [<Dog: Meg>]>\n`aon_eochairLink to this heading#Tugann sé rudaí ar ais ina bhfuil aon cheann de na heochracha a thugtar i barr-leibhéal na sonraí. Mar shampla:
\n>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})\n<Dog: Rufus>\n>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})\n<Dog: Meg>\n>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])\n<QuerySet [<Dog: Rufus>, <Dog: Meg>]>\nQLink to this heading#Keyword argument queries -- in filter(),\netc. -- are "AND"ed together. If you need to execute more complex queries (for\nexample, queries with OR statements), you can use ``Q () ``rudaí.
A Q object (django.db.models.Q) is an object used to\nencapsulate a collection of keyword arguments. These keyword arguments are\nspecified as in "Field lookups" above.
Mar shampla, cuimsíonn an réad Q seo fiosrúchán LIKE amháin:
from django.db.models import Q\n\nQ(question__startswith="What")\nIs 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")\nTá sé seo coibhéiseach leis an gclásal SQL WHERE seo a leanas:
WHERE question LIKE 'Who%' OR question LIKE 'What%'\nIs 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)\nIs 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(\n Q(question__startswith="Who"),\n Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),\n)\n... aistríonn sé go garbh go dtí an SQL:
\nSELECT * from polls WHERE question LIKE 'Who%'\n AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')\nIs 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(\n Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),\n question__startswith="Who",\n)\n... a bheadh ina cheist bailí, coibhéiseach leis an sampla roimhe seo; ach:
\n# INVALID QUERY\nPoll.objects.get(\n question__startswith="Who",\n Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),\n)\n... ní bheadh bailí.
\n\nChun 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:
\n>>> some_entry == other_entry\n>>> some_entry.id == other_entry.id\nMura 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:
\n>>> some_obj == other_obj\n>>> some_obj.name == other_obj.name\nAinmní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:
\n>>> e.delete()\n(1, {'blog.Entry': 1})\nIs 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.
\nMar shampla, scriosann sé seo gach rud Entry ``le bliain ``pub_date de 2005:
>>> Entry.objects.filter(pub_date__year=2005).delete()\n(5, {'webapp.Entry': 5})\nCoinnigh 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:
\nb = Blog.objects.get(pk=1)\n# This will delete the Blog and all of its Entry objects.\nb.delete()\nIs féidir an t-iompar cascaire seo inoiriúnaithe tríd an argóint: attr: ~django.db.models.foreignkey.on_delete chuig an argóint: :class: ~django.db.models.foreignKey.
\nTabhair 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:
\nEntry.objects.all().delete()\nCé 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. <django.db.models.Model._state>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")\nblog.save() # blog.pk == 1\n\nblog.pk = None\nblog._state.adding = True\nblog.save() # blog.pk == 2\nÉiríonn rudaí níos casta má úsáideann tú oidhreacht. Smaoinigh ar fho-aicme de Blog:
class ThemeBlog(Blog):\n theme = models.CharField(max_length=200)\n\n\ndjango_blog = ThemeBlog(name="Django", tagline="Django is easy", theme="python")\ndjango_blog.save() # django_blog.pk == 3\nMar 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\ndjango_blog.id = None\ndjango_blog._state.adding = True\ndjango_blog.save() # django_blog.pk == 4\nNí 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\nold_authors = entry.authors.all()\nentry.pk = None\nentry._state.adding = True\nentry.save()\nentry.authors.set(old_authors)\nMaidir 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:
\ndetail = EntryDetail.objects.all()[0]\ndetail.pk = None\ndetail._state.adding = True\ndetail.entry = entry\ndetail.save()\nNote that it is not possible to copy instances of models with deferred fields\nusing this pattern unless values are assigned to them:
\n>>> blog = Blog.objects.defer("name")[0]\n>>> blog.pk = None\n>>> blog._state.adding = True\n>>> blog.save()\nTraceback (most recent call last):\n ...\nAttributeError: Cannot retrieve deferred field 'name' from an unsaved model.\n>>> blog.name = "Another Blog"\n>>> blog.save()\nUaireanta 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:
\n# Update all the headlines with pub_date in 2007.\nEntry.objects.filter(pub_date__year=2007).update(headline="Everything is the same")\nNí 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:
\n>>> b = Blog.objects.get(pk=1)\n\n# Change every Entry so that it belongs to this Blog.\n>>> Entry.objects.update(blog=b)\nCuirtear 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:
\n>>> b = Blog.objects.get(pk=1)\n\n# Update all the headlines belonging to this Blog.\n>>> Entry.objects.filter(blog=b).update(headline="Everything is the same")\nBí 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:\n item.save()\nCalls to update can also use Nathanna ``F () `` to update one field based on\nthe value of another field in the model. This is especially useful for\nincrementing counters based upon their current value. For example, to increment\nthe pingback count for every entry in the blog:
\n>>> Entry.objects.update(number_of_pingbacks=F("number_of_pingbacks") + 1)\nMar 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:
# This will raise a FieldError\n>>> Entry.objects.update(headline=F("blog__name"))\nMá 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.
\nFaoi 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í.
\n