Ceisteanna a dhéanamhLink to this heading#

Réimsí 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
>>> 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:

>>> 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:

>>> 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.

Aisghabháil gach rudLink to this heading#

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:

>>> 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íLink to this heading#

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)

>>> Entry.objects.filter(headline__startswith="What").exclude(
...     pub_date__gte=datetime.date.today()
... ).filter(pub_date__gte=datetime.date(2005, 1, 30))

>>> 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())

>>> 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)

Aisghabháil réad amháin le ``get () ``Link to this heading#

filter() will always give you a QuerySet, even if only a single object matches the query - in this case, it will be a 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:

>>> 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 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`Link to this heading#

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 <queryset-api>osta iomlán de na modhanna éagsúla:class: `~django.db.models.queryset go léir.

Teorannú ar QuerySetsLink 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]

Tugann sé seo an séú réad tríd an deichiú rud ar ais (OFFSET 5 TEORAINN 5):

>>> 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:

>>> 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:

>>> Entry.objects.order_by("headline")[0]

Tá sé seo coibhéiseach thart ar:

>>> 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 allamuighLink to this heading#

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")

aistríonn (go garbh) go dtí an SQL seo a leanas:

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

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:

>>> Entry.objects.filter(blog_id=4)

Má 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:

exact

Cluiche “cruinn”. Mar shampla:

Python console

>>> 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:

Python console

>>> 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

Cluiche cás-neamh-íogair. Mar sin, an cheist:

Python console

>>> Blog.objects.get(name__iexact="beatles blog")

Meaitseálann sé Blag dar teideal "Blag Beatles", blog beatles", nó fiú "Blag Beatles".

contains

Tástáil srianta cás-íogair. Mar shampla:

Code

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, 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. <field-lookups>Is féidir tagairt iomlán a fháil in:ref: `tagairt cuardaigh réimse `.

Cuardaigh a bhaineann le caidrimhLink to this heading#

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`:

>>> Entry.objects.filter(blog__name="Beatles Blog")

Is féidir leis an sceitheadh seo a bheith chomh domhain agus is mian leat.

It works backwards, too. While it can be customized by setting related_query_name, by default you refer to a "reverse" relationship in a lookup using the lowercase name of the model.

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")

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)

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
)

Is féidir le scagairí réimsí tagartha a dhéanamh ar anLink to this heading#

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?

Django provides Nathanna ``F () `` to allow such comparisons. Instances of F() act as a reference to a model field within a query. These references can then be used in query filters to compare the values of two different fields on 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
>>> 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ú:

>>> 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:

>>> 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:

>>> 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ú:

>>> 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:

>>> F("somefield").bitand(16)

Is féidir le nathanna tagairt a dhéanamh d'athrúLink to this heading#

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ú:

>>> 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:

>>> 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:

>>> 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 pkLink 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
>>> 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:

# 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:

>>> 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 LIKELink 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

>>> Entry.objects.filter(headline__contains="%")

Tugann Django aire don luachan duit; beidh cuma mar seo ar an SQL mar seo:

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 QuerySetsLink 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.

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:

>>> 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 é:

>>> 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.

>>> queryset = Entry.objects.all()
>>> print(queryset[5])  # Queries the database
>>> print(queryset[5])  # Queries the database again

>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset]  # Queries the database
>>> print(queryset[5])  # Uses cache
>>> print(queryset[5])  # Uses cache

>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

Athraitheadh ceisteannaLink to this heading#

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 bainisteoraLink to this heading#

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:

• 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, but understand the constraint of no deferred queries before using defer(), only(), or fetch_mode().

• 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.

No deferred queriesLink to this heading#

Relations are deferred by default. If the blog relation is not prefetched, accessing entry.blog during asynchronous evaluation of a queryset attempts a blocking database query, raising SynchronousOnlyOperation. (A similar limitation applies to fields deferred via defer() or only().) To avoid this, see the advice on prefetching in Rudaí gaolmhara.

IdirbheartaLink to this heading#

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.

Stóráil agus fiosrú ar NoneLink to this heading#

As with other fields, storing None as the field's value will store it as SQL NULL. While not recommended, it is possible to store JSON scalar null 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 is inside a list or dict, it will always be interpreted as JSON null.

When querying, isnull=True is used to match SQL NULL, while exact-matching JSONNull() is used to match JSON null.

>>> from django.db.models import JSONNull
>>> Dog.objects.create(name="Max", data=None)  # SQL NULL.
<Dog: Max>
>>> Dog.objects.create(name="Archie", data=JSONNull())  # JSON null.
<Dog: Archie>
>>> Dog.objects.filter(data=None)
...: RemovedInDjango70Warning: Using None as the right-hand side of an
exact lookup on JSONField to mean JSON scalar 'null' is deprecated. Use
JSONNull() instead (or use the __isnull lookup if you meant SQL NULL).
...
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data=JSONNull())
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data__isnull=True)
<QuerySet [<Dog: Max>]>
>>> Dog.objects.filter(data__isnull=False)
<QuerySet [<Dog: Archie>]>

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.

Athraíonn eochair, innéacs agus cosánLink to this heading#

Chun ceist a dhéanamh bunaithe ar eochair foclóra ar leith, bain úsáid as an eochair sin mar ainm an chuardaigh:

>>> Dog.objects.create(
...     name="Rufus",
...     data={
...         "breed": "labrador",
...         "owner": {
...             "name": "Bob",
...             "other_pets": [
...                 {
...                     "name": "Fishy",
...                 }
...             ],
...         },
...     },
... )
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": None})
<Dog: Meg>
>>> Dog.objects.filter(data__breed="collie")
<QuerySet [<Dog: Meg>]>

To query a key for JSON null, None or JSONNull() can be used.

>>> Dog.objects.filter(data__owner=None)
<Dog: Meg>
>>> Dog.objects.filter(data__owner=JSONNull())
<Dog: Meg>

Is féidir eochracha iolracha a shlánú le chéile chun cuardach cosáin a fhoirmiú:

>>> Dog.objects.filter(data__owner__name="Bob")
<QuerySet [<Dog: Rufus>]>

Más slámhshláir é an eochair, léirmhínítear é mar athrú innéacs i sraith:

>>> Dog.objects.filter(data__owner__other_pets__0__name="Fishy")
<QuerySet [<Dog: Rufus>]>

If the key is a negative integer, it cannot be used in a filter keyword directly, but you can still use dictionary unpacking to use it in a query:

>>> Dog.objects.filter(**{"data__owner__other_pets__-1__name": "Fishy"})
<QuerySet [<Dog: Rufus>]>

<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.

Chun ceist a dhéanamh ar eochracha atá in easnamh, bain úsáid as an lorg isnull:

>>> Dog.objects.create(name="Shep", data={"breed": "collie"})
<Dog: Shep>
>>> Dog.objects.filter(data__owner__isnull=True)
<QuerySet [<Dog: Shep>]>

Cuardaigh coimeádta agus príomhfheidhmeannaLink to this heading#

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.create(
...     name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]}
... )
>>> Dog.objects.filter(data__contains={"owner": "Bob"})
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
>>> Dog.objects.filter(data__contains={"breed": "collie"})
<QuerySet [<Dog: Meg>]>
>>> Dog.objects.filter(data__contains={"tricks": ["dance"]})
<QuerySet [<Dog: Merry>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.create(
...     name="Merry", data={"breed": "pekingese", "tricks": ["fetch", "dance"]}
... )
>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})
<QuerySet [<Dog: Meg>, <Dog: Fred>]>
>>> Dog.objects.filter(data__contained_by={"breed": "collie"})
<QuerySet [<Dog: Fred>]>
>>> Dog.objects.filter(
...     data__contained_by={"breed": "pekingese", "tricks": ["dance", "fetch", "hug"]}
... )
<QuerySet [<Dog: Merry>, <Dog: Fred>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_key="owner")
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_keys=["breed", "owner"])
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

Caidrimh duine le go leorLink to this heading#

>>> e = Entry.objects.get(id=2)
>>> e.blog  # Returns the related Blog object.

>>> e = Entry.objects.get(id=2)
>>> e.blog = some_blog
>>> e.save()

>>> e = Entry.objects.get(id=2)
>>> e.blog = None
>>> e.save()  # "UPDATE blog_entry SET blog_id = NULL ...;"

>>> 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.

>>> 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.

>>> 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()

>>> 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()

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()

b.entry_set(manager="entries").is_published()

b = Blog.objects.get(id=1)
b.entry_set.set([e1, e2])

Caidrimh go leorLink to this heading#

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])

>>> from datetime import date
>>> batucada = Blog.objects.create(name="Batucada Blog")
>>> e = Entry.objects.create(
...     blog=batucada,
...     headline="Supporting social movements with drums",
...     pub_date=date(2019, 6, 14),
... )

>>> gloria = Author.objects.create(name="Gloria")
>>> anna = Author.objects.create(name="Anna")
>>> e.authors.add(gloria, anna)

>>> anna.entry_set.filter(authors__name="Gloria")
<QuerySet []>

>>> anna.entry_set.filter().filter(authors__name="Gloria")
<QuerySet [<Entry: Supporting social movements with drums>]>

Caidrimh duine le duineLink to this heading#

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?Link to this heading#

É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?

The answer lies in the app registry. When Django starts, it imports each application listed in INSTALLED_APPS, and then the models module inside each application. Whenever a new model class is created, Django adds backward-relationships to any related models. If the related models haven't been imported yet, Django keeps track of the relationships and adds them when the related models eventually are imported.

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í gaolmLink to this heading#

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