Soláthraíonn ciseal bunachar sonraí Django bealaí éagsúla chun cabhrú le forbróirí an leas is fearr a bhaint as a mbunachar Bailíonn an doiciméad seo naisc leis an doiciméad ábhartha le chéile, agus cuireann sé leideanna éagsúla leis, eagraithe faoi roinnt ceannteidil a thugann cur síos ar na céimeanna atá le glacadh agus tú ag iarraidh úsáid do bhunachar sonraí a
\nMar chleachtas cláraithe ginearálta, téann sé seo gan rá. <faq-see-raw-sql-queries>Faigh amach: ref: cad iad na ceisteanna atá á dhéanamh agat agus cad a chosnaíonn siad duit `. Úsáid: Meth: `.querySet.explain chun tuiscint a fháil ar cé chomh sonrach a fhorghníomhaíonn do bhunachar sonraí QuerySets. B'fhéidir gur mhaith leat tionscadal seachtrach a úsáid freisin cosúil:pypi: django-debug-toolbar, nó uirlis a dhéanann monatóireacht díreach ar do bhunachar sonraí.
Cuimhnigh go bhféadfadh tú a bheith ag barrfheabhsú le haghaidh luas nó cuimhne nó araon, ag brath ar do riachtanais Uaireanta beidh barrfheabhsú do cheann amháin díobhálach don cheann eile, ach uaireanta cabhróidh siad lena chéile. Chomh maith leis sin, b'fhéidir nach mbeadh an costas céanna (duitse) ag an obair a dhéanann an próiseas bunachar sonraí leis an méid céanna oibre a dhéantar i do phróiseas Python. Is fútsa atá sé cinneadh a dhéanamh cad iad do thosaíochtaí, cá gcaithfidh an t-iarmhéid a bheith, agus iad seo go léir a phróifíliú de réir mar is gá ós rud é go mbeidh sé seo ag brath ar d'iarratas agus ar d'fhre
\nLe gach rud a leanann, cuimhnigh próifíl a dhéanamh tar éis gach athraithe chun a chinntiú gur sochar é an t-athrú, agus sochar mór go leor i bhfianaise an laghdú ar inléiteacht do chód. ** Tagann gach ceann de na moltaí thíos leis an rabhadh go bhféadfadh an prionsabal ginearálta a bheith i bhfeidhm i do chúinsí, nó go bhféadfadh sé a aisiompú fiú.
\n... lena n-áirítear:
\nIndexes. This is a number one priority, after you have determined from\nprofiling what indexes should be added. Use\nMeta.indexes or\nField.db_index to add these from\nDjango. Consider adding indexes to fields that you frequently query using\nfilter(),\nexclude(),\norder_by(), etc. as indexes may help\nto speed up lookups. Note that determining the best indexes is a complex\ndatabase-dependent topic that will depend on your particular application.\nThe overhead of maintaining an index may outweigh any gains in query speed.
Úsáid chuí de chineálacha réimse.
Glacfaimid leis go ndearna tú na rudaí atá liostaithe thuas. Díríonn an chuid eile den doiciméad seo ar conas Django a úsáid sa chaoi nach bhfuil tú ag déanamh obair gan ghá. Ní thugann an doiciméad seo aghaidh freisin ar theicnící optamaithe eile a bhaineann le gach oibríocht daor, mar shampla:doc: taiscáil cuspóir ginear</topics/cache> álta.
\nQuerySetsLink to this heading#Tuiscint: doc: Tá QuerySets </ref/models/querysets> ríthábhachtach chun feidhmíocht mhaith a fháil le cód simplí. Go háirithe:
\nChun fadhbanna feidhmíochta a sheachaint, tá sé tábhachtach tuiscint:
\n\nChomh maith le caistriú an ``QuerySet ``iomlán, tá toradh tréithe ar rudaí ORM a chaitheamh a chaitheamh. Go ginearálta, déanfar tréithe nach féidir glaoch a stóráil. <queryset-model-example>Mar shampla, ag glacadh leis na:ref: `samplaí blag samplacha `:
\n>>> entry = Entry.objects.get(id=1)\n>>> entry.blog # Blog object is retrieved at this point\n>>> entry.blog # cached version, no DB access\nAch go ginearálta, is cúis le tréithe inghlaonta cuardach DB gach uair:
\n>>> entry = Entry.objects.get(id=1)\n>>> entry.authors.all() # query performed\n>>> entry.authors.all() # query performed again\nBí cúramach agus tú ag léamh cód teimpléid - ní cheadaíonn an córas teimpléid lúibíní a úsáid, ach glaoifidh sé glaonna go huathoibríoch, ag folach an t-idirdhealú thuas.
\nBí cúramach le d'airíonna saincheaptha féin - is fútsa atá sé caching a chur i bhfeidhm nuair is gá, mar shampla ag baint úsáide as an maisitheoir: class: ~django.utils.functional.cached_property.
\nChun úsáid a bhaint as iompar caching ``QuerySet ``, b'fhéidir go mbeidh ort an chlib teimpléad:ttag: with a úsáid.
\nWhen you have a lot of objects, the caching behavior of the QuerySet can\ncause a large amount of memory to be used. In this case,\niterator() may help.
QuerySet.explain() gives you detailed information about how the database\nexecutes a query, including indexes and joins that are used. These details may\nhelp you find queries that could be rewritten more efficiently, or identify\nindexes that could be added to improve performance.
Mar shampla:
\nAg an leibhéal is bunúsaí, bain úsáid as: ref: `scagadh agus eisiamh <queryset-api>`chun scagadh a dhéanamh sa bhunachar sonraí.
Use Nathanna ``F () `` to filter based on other fields within the same\nmodel.
Úsáid:doc: `anótáil chun comhiomlánú a dhéanamh sa bhunachar sonraithe' </topics/db/aggregation>.
Mura leor iad seo chun an SQL a theastaíonn uait a ghiniúint:
\nRawsqlLink to this heading#Modh nach bhfuil chomh iniompartha ach níos cumhachtaí ná an léir:class: ~Django.db.Models.Expressions.RawSql, a ligeann roinnt SQL a chur go sainráite leis an bhfiosrúchán. Mura bhfuil sé sin cumhachtach go leor fós:
\nScríobh do chuid féin: doc: SQL saincheaptha chun sonraí a aisghabháil nó samhlacha a dhaonrú '</topics/db/sql>. Úsáid ``django.db.connection.queries` chun a fháil amach cad atá ag scríobh Django duit agus tosú as sin.
\nTá dhá chúis ann le colún a úsáid le:attr: ~django.db.models.field.unique nó:attr: ~django.db.models.field.db_index agus tú ag úsáid: meth: ~django.db.models.queryset.get chun rudaí aonair a aisghabháil. Ar dtús, beidh an cheist níos gasta mar gheall ar an innéacs bunachar sonraí bunúsach. Chomh maith leis sin, d'fhéadfadh an cheist rith i bhfad níos moille má mheaitseálann ilrudaí leis an lorg; ráthaíonn srian uathúil a bheith agat ar an gcolún nach dtarlóidh sé seo riamh.
\n<queryset-model-example>Mar sin ag baint úsáide as an: ref: `sampla samhlacha blag `:
\n>>> entry = Entry.objects.get(id=10)\nbeidh sé níos gasta ná:
\n>>> entry = Entry.objects.get(headline="News Item Title")\ntoisc go ndéanann an bunachar sonraí innéacsaithe ``id ``agus ráthaítear go mbeidh sé uathúil.
\nD'fhéadfadh sé go mbeadh sé mall go leor na nithe seo a leanas
\n>>> entry = Entry.objects.get(headline__startswith="News")\nAr an gcéad dul síos, ní innéacsaítear ``ceannlíne ``, rud a fhágfaidh go bhfaighidh an bunachar sonraí bunúsach níos moille.
\nSecond, the lookup may return multiple results. Even though Django applies a\nlimit of 21 objects when using get(),\nthe database may still need to scan everything to evaluate a non-unique\ncondition. Narrowing your query up-front is more efficient.
QuerySet.values () ``agus ``values_list ()Link to this heading#When you only want a dict or list of values, and don't need ORM model\nobjects, make appropriate usage of\nvalues().\nThese can be useful for replacing model objects in template code - as long as\nthe dicts you supply have the same attributes as those used in the template,\nyou are fine.
QuerySet.defer () ``agus ``only ()Link to this heading#Use defer() and\nonly() if there are database columns\nyou know that you won't need (or won't need in most cases) to avoid loading\nthem. Note that if you do use them, the ORM will have to go and get them in\na separate query, making this a pessimization if you use it inappropriately.
Ná bí ró-ionsaitheach agus réimsí a chur ar iarchur gan próifíliú mar caithfidh an bunachar sonraí an chuid is mó de na sonraí neamh-téacs, neamh-Varchar a léamh ón diosca ar feadh sraith amháin sna torthaí, fiú mura gcríochnaíonn sé ach cúpla colún á úsáid. Tá na modhanna defer () ``agus ``only () is úsáideach nuair is féidir leat a lán sonraí téacs a luchtú a sheachaint nó do réimsí a d'fhéadfadh go leor próiseála a thógáil chun tiontú ar ais go Python. Mar is gnách, próifíl ar dtús, ansin barrfheabhsú.
... mura dteastaíonn uait ach a fháil amach an bhfuil obj ``sa tacar fiosrúcháin, seachas ``if obj in iarratas.
... mura dteastaíonn uait ach an comhaireamh, seachas `len (queryset) ``a dhéanamh.
\n... mura dteastaíonn uait ach a fháil amach an bhfuil toradh amháin ar a laghad ann, seachas ``if queryset ``.
\nAch:
\ntá () ``, `count (), agus ann ()Link to this heading#Má tá sonraí eile ag teastáil uait ón QuerySet, déan iad a mheas láithreach.
\nMar shampla, ag glacadh le samhail Grúpa a bhfuil gaol go leor aige le ``Úsáideoir ``, is fearr an cód seo a leanas:
members = group.members.all()\n\nif display_group_members:\n if members:\n if current_user in members:\n print("You and", len(members) - 1, "other users are members of this group.")\n else:\n print("There are", len(members), "members in this group.")\n\n for member in members:\n print(member.username)\n else:\n print("There are no members in this group.")\nTá sé is fearr mar gheall ar:
\nÓs rud é go bhfuil QuerySets leisciúil, ní dhéanann sé seo aon cheisteanna bunachar sonraí má tá display_group_members False`.
Trí stóráil group.members.all () ``sa athróg ``members is féidir a taisce torthaí a athúsáid.
Tá an líne if comhaltaí: ``is cúis le ``QuerySet. __bool__ () ``le glaoch, rud a fhágann go ndéanfar an ceist ``group.members.all () a reáchtáil ar an mbunachar sonraí. Mura bhfuil aon torthaí ann, cuirfidh sé ar ais False, ar shlí eile True.
Seiceálann an líne ``if current_user i gcomhaltaí: ``an bhfuil an t-úsáideoir sa taisce torthaí, mar sin ní eisítear aon cheisteanna breise bunachar sonraí.
Glaonn úsáid ``len (comhaltaí) ``QuerySet. __len__ () `, ag athúsáid taisce na dtorthaí, mar sin arís, ní eisítear aon cheisteanna bunachar sonraí.
Athraíonn an lúb for ball` thar taisce na torthaí.
San iomlán, déanann an cód seo ceisteanna bunachar sonraí amháin nó nialas. Is é an t-aon bharrfheabhsú d'aon ghnó a dhéantar ná an athróg baill ``a úsáid. Ag baint úsáide as ``QuerySet.exists () ``don `if, QuerySet.contents () ```, `in, nó ``QuerySet.count () ``don chomhaireamh bheadh ceisteanna breise ina chúis le ceisteanna breise.
QuerySet.Update () ``agus ``delete ()Link to this heading#<topics-db-queries-update>Seachas ualach rudaí a aisghabháil, socraigh roinnt luachanna, agus iad a shábháil aonair, bain úsáid as ráiteas mórchóir SQL UPDATE, trí:ref: `QuerySet.update () `. <topics-db-queries-delete>Ar an gcaoi chéanna, déan:ref: `bulk scriosann `nuair is féidir.
\nTabhair faoi deara, áfach, nach féidir leis na modhanna mór-nuashonraithe seo na modhanna save () ``nó ``delete () cásanna aonair a ghlaoch, rud a chiallaíonn nach gcuirfear aon iompar saincheaptha a chuir tú leis do na modhanna seo a fhorghníomhú, lena n-áirítear aon rud atá tiomáinte ón ngnáthréad bunachar sonraí: doc: signals </ref/signals>.
Mura dteastaíonn uait ach luach eochair eachtrach, bain úsáid as an eochairluach eachtrach atá ar an réad atá agat cheana féin, seachas an réad gaolmhar iomlán a fháil agus a phríomh-eochair a ghlacadh. ie déan:
\nentry.blog_id\nin ionad:
\nentry.blog.id\nOrdering is not free; each field to order by is an operation the database must\nperform. If a model has a default ordering (Meta.ordering) and you don't need it, remove\nit on a QuerySet by calling\norder_by() with no parameters.
D'fhéadfadh innéacs a chur le do bhunachar sonraí cabhrú le feidhmíocht ordaithe a fheabhsú
\nÚsáid modhanna mórchóir chun líon na ráitis SQL a laghdú.
\nWhen creating objects, where possible, use the\nbulk_create() method to reduce the\nnumber of SQL queries. For example:
Entry.objects.bulk_create(\n [\n Entry(headline="This is a test"),\n Entry(headline="This is only a test"),\n ]\n)\n... is fearr ná:
\nEntry.objects.create(headline="This is a test")\nEntry.objects.create(headline="This is only a test")\nNote that bulk_create() has several\ncaveats, so ensure it's appropriate for your use case.
When updating objects, where possible, use the\nbulk_update() method to reduce the\nnumber of SQL queries. Given a list or queryset of objects:
entries = Entry.objects.bulk_create(\n [\n Entry(headline="This is a test"),\n Entry(headline="This is only a test"),\n ]\n)\nAn sampla seo a leanas:
\nentries[0].headline = "This is not a test"\nentries[1].headline = "This is no longer a test"\nEntry.objects.bulk_update(entries, ["headline"])\n... is fearr ná:
\nentries[0].headline = "This is not a test"\nentries[0].save()\nentries[1].headline = "This is no longer a test"\nentries[1].save()\nNote that bulk_update() has several\ncaveats, so ensure it's appropriate for your use case.
Agus rudaí á chur isteach ion:class: ManyTomanyFields <django.db.models.ManyToManyField>, bain úsáid as: meth: ~Django.db.Models.Fields.Related.RelatedManager.Add le rudaí iolracha chun líon na gceisteanna SQL a laghdú. Mar shampla:
\nmy_band.members.add(me, my_friend)\n... is fearr ná:
\nmy_band.members.add(me)\nmy_band.members.add(my_friend)\n...where Band and Artist are models with a many-to-many relationship.
When inserting different pairs of objects into\nManyToManyField or when the custom\nthrough table is defined, use\nbulk_create() method to reduce the\nnumber of SQL queries. For example:
PizzaToppingRelationship = Pizza.toppings.through\nPizzaToppingRelationship.objects.bulk_create(\n [\n PizzaToppingRelationship(pizza=my_pizza, topping=pepperoni),\n PizzaToppingRelationship(pizza=your_pizza, topping=pepperoni),\n PizzaToppingRelationship(pizza=your_pizza, topping=mushroom),\n ],\n ignore_conflicts=True,\n)\n... is fearr ná:
\nmy_pizza.toppings.add(pepperoni)\nyour_pizza.toppings.add(pepperoni, mushroom)\n... áit a bhfuil caidreamh go leor ag Pizza` agus Topping. Tabhair faoi deara go bhfuil roinnt de: meth: rabhadh don mhodh seo <django.db.models.query.QuerySet.bulk_create>, mar sin déan cinnte go bhfuil sé oiriúnach do do chás úsáide.
Agus rudaí á bhaint as: class: ManyTomanyFields <django.db.models.ManyToManyField>, bain úsáid as: meth: ~Django.db.Models.Fields.Related.RelatedManager.Remove le rudaí iolracha chun líon na gceisteanna SQL a laghdú. Mar shampla:
\nmy_band.members.remove(me, my_friend)\n... is fearr ná:
\nmy_band.members.remove(me)\nmy_band.members.remove(my_friend)\n...where Band and Artist are models with a many-to-many relationship.
When removing multiple many-to-many relationships involving several instances\nof the related models, use the delete()\nmethod on a filtered queryset of the field's\nthrough model. By combining multiple\nconditions with ``Q () ``rudaí, you can delete several relationships in a\nsingle query. For example:
from django.db.models import Q\n\nPizzaToppingRelationship = Pizza.toppings.through\nPizzaToppingRelationship.objects.filter(\n Q(pizza=my_pizza, topping=pepperoni)\n | Q(pizza=your_pizza, topping=pepperoni)\n | Q(pizza=your_pizza, topping=mushroom)\n).delete()\n... is fearr ná:
\nmy_pizza.toppings.remove(pepperoni)\nyour_pizza.toppings.remove(pepperoni, mushroom)\n... áit a bhfuil caidreamh go leor ag Pizza` agus Topping.