--- title: "Bainisteoirí" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/topics/db/managers/ canonical: https://djangodocs.dev/ga/5.2/topics/db/managers/ --- # Bainisteoirí #### `class Manager` Is é “Bainisteoir” an comhéadan trína gcuirtear oibríochtaí fiosrúcháin bunachar sonraí ar fáil do mhúnlaí Django. Tá Bainisteoir amháin ar a laghad ann do gach samhail i bhfeidhmchlár Django. Déantar an bealach a oibríonn ranganna `Bainiste` doiciméadaithe in:doc: /topics/db/queries; baineann an doiciméad seo go sonrach le roghanna samhlacha a shaincheapann iompar `Bainiste`. ## Ainmneacha bainisteora De réir réamhshocraithe, cuireann Django `Bainiste` leis an ainm `ruda` le gach rang samhail Django. Mar sin féin, más mian leat `ruda` a úsáid mar ainm réimse, nó más mian leat ainm seachas `ruda` a úsáid don Bainiste\`, is féidir leat é a athainmniú ar bhonn in aghaidh an mhúnla. Chun an `Bainiste` a athainmniú do rang ar leith, sainmhínigh tréith aicme de chineál Models.manager () ar an tsamhail sin. Mar shampla: ``` from django.db import models class Person(models.Model): # ... people = models.Manager() ``` Ag baint úsáide as an tsamhail samplach seo, ginfidh `Person.Objects` eisceacht `AttributeError`, ach soláthróidh ```Person.People.all () ``liosta de na rudaí ``Person``` go léir. ## Bainisteoirí saincheaptha Is féidir leat ```Bainisteoir ``saincheaptha a úsáid i samhail áirithe tríd an rang bonn ``Bainiste``` a leathnú agus do Bainisteoir\` saincheaptha a chur i do mhúnla. Tá dhá chúis ann b'fhéidir gur mhaith leat `Bainiste` a shaincheapadh: modhanna `Bainiste` breise a chur leis, agus/nó an QuerySet\` tosaigh `Bainiste` a mhodhnú. ### Modhanna bainisteora breise a chur leis Is é modhanna breise `Bainiste` a chur leis an mbealach is fearr chun feidhmiúlacht “leibhéal tábla” a chur le do mhúnlaí. (Maidir le feidhmiúlacht “leibhéal sraithe” - ie, feidhmeanna a ghníomhaíonn ar shampla amháin de réad samhail - bain úsáid as: ref: Modhanna samhlacha \`, \ní modhanna saincheaptha \`\`Bainiste\`.) Mar shampla, cuireann an ```Bainisteoir ``saincheaptha seo modh ``with_counts ()```: ``` from django.db import models from django.db.models.functions import Coalesce class PollManager(models.Manager): def with_counts(self): return self.annotate(num_responses=Coalesce(models.Count("response"), 0)) class OpinionPoll(models.Model): question = models.CharField(max_length=200) objects = PollManager() class Response(models.Model): poll = models.ForeignKey(OpinionPoll, on_delete=models.CASCADE) # ... ``` Leis an sampla seo, úsáidfeá ```OpinionPoll.Objects.with_Counts () ``chun `QuerySet` de rudaí ``OpinionPoll``` a fháil leis an tréith breise `num_responses` ceangailte. Is féidir le modh saincheaptha `Bainiste` aon rud a theastaíonn uait a thabhairt ar ais. Ní gá dó QuerySet a thabhairt ar ais. Rud eile le tabhairt faoi deara ná gur féidir le modhanna `Bainiste` rochtain a fháil ar self.model chun an rang samhail lena bhfuil siad ceangailte a fháil. ### “QuerySet” tosaigh bainisteora a mhodhnú Tugann bonn `Bainiste` QuerySet\` gach rud sa chóras ar ais. Mar shampla, ag baint úsáide as an tsamhail seo: ``` from django.db import models class Book(models.Model): title = models.CharField(max_length=100) author = models.CharField(max_length=50) ``` ... cuirfidh an ráiteas Book.Objects.all () gach leabhar sa bhunachar sonraí ar ais. Is féidir leat bonn `` `Manager `` QuerySet\` a shárú tríd an modh Manager.get\_querySet () \`\`a shárú. Ba chóir go gcuirfeadh \`\`get\_queryset () \`\`QuerySet\` a thabhairt ar ais leis na hairíonna a theastaíonn uait. Mar shampla, tá *dha* Bainisteoir s sa tsamhail seo a leanas - ceann a thugann gach rud ar ais, agus ceann nach dtugann ach na leabhair le Roald Dahl ar ais: ``` # First, define the Manager subclass. class DahlBookManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(author="Roald Dahl") # Then hook it into the Book model explicitly. class Book(models.Model): title = models.CharField(max_length=100) author = models.CharField(max_length=50) objects = models.Manager() # The default manager. dahl_objects = DahlBookManager() # The Dahl-specific manager. ``` Leis an tsamhail samplach seo, ní thabharfaidh Book.Objects.all () \`\`gach leabhar sa bhunachar sonraí ar ais, ach ní thabharfaidh \`Book.dahl\_objects.all ()\` ach na cinn a scríobh Roald Dahl ar ais. Toisc go bhfilleann ```get_queryset () ``réad ``QuerySet```, is féidir leat ```filter () ``,```, () ```a úsáid agus na modhanna ``QuerySet``` eile air. Mar sin tá na ráitis seo go léir dlíthiúil: ``` Book.dahl_objects.all() Book.dahl_objects.filter(title="Matilda") Book.dahl_objects.count() ``` Chuir an sampla seo in iúl teicníc spéisiúil eile freisin: bainisteoirí iolracha a úsáid ar an tsamhail chéanna. Is féidir leat an oiread cásanna Bainisteoir () a cheangal le samhail agus is mian leat. Is bealach neamh-athchleachtach é seo chun “scagairí” coitianta do do mhúnlaí a shainiú. Mar shampla: ``` class AuthorManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(role="A") class EditorManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(role="E") class Person(models.Model): first_name = models.CharField(max_length=50) last_name = models.CharField(max_length=50) role = models.CharField(max_length=1, choices={"A": _("Author"), "E": _("Editor")}) people = models.Manager() authors = AuthorManager() editors = EditorManager() ``` Ligeann an sampla seo duit ```Person.Authors.all () ``, `Person.Editors.all ()```, agus Person.People.all () a iarraidh, ag tabhairt torthaí intuartha. ### Bainisteoirí réamhshoc #### `Model._default_manager` Má úsáideann tú rudaí saincheaptha `Bainiste`, tabhair faoi deara go bhfuil stádas speisialta ag an gcéad ```Bainisteoir ``Django (san ord ina sainmhínítear iad sa tsamhail). Léirmhíníonn Django an chéad ``Bainiste``` a shainmhínítear i rang mar an “réamhshocraithe” `Bainiste`, agus úsáidfidh roinnt codanna de Django (lena n-áirítear: djadmin: dumpdata) an Bainisteoir sin go heisiach don tsamhail sin. Mar thoradh air sin, is smaoineamh maith é a bheith cúramach i do rogha bainisteora réamhshocraithe d'fhonn cás a sheachaint ina mbíonn neamhábaltacht rudaí ar mhaith leat oibriú leo mar thoradh ar 'get\_queryset ()' a shárú. \Is féidir leat bainisteoir réamhshocraithe saincheaptha a shonrú ag baint úsáidea:attr: meta.default\_manager\_name . Má tá cód éigin á scríobh agat a chaithfidh samhail anaithnid a láimhseáil, mar shampla, in aip tríú páirtí a chuireann dearcadh cineálach i bhfeidhm, bain úsáid as an mbainisteoir seo (nó: attr: ~Model. \_base\_manager) seachas glacadh leis go bhfuil bainisteoir `ruda` ag an tsamhail. ### Bainisteoirí bonn #### `Model._base_manager` #### Bainisteoirí a úsáid le haghaidh rochtana gaolmhara By default, Django uses an instance of the `Model._base_manager` manager class when accessing related objects (e.g. `choice.question`), not the `_default_manager` on the related object. This is because Django needs to be able to retrieve the related object, even if it would otherwise be filtered out (and hence be inaccessible) by the default manager. \Mura bhfuil an gnáthrang bainisteora bonn (:class: Django.db.Models.Manager) oiriúnach do do chúinsí, is féidir leat a rá le Django cén rang atá le húsáid trí shocting:attr: Meta.base\_Manager\_name . \Ní úsáidtear bainisteoirí bonn agus iad ag fiosrú ar mhúnlaí gaolmhara, nó nuair: ref: rochtain a fháil ar chaidreamh duine le go leor nó go leor '. Mar shampla, má bhí \réimse \`\`scriostha \`\`agus bainisteoir bonn ag an tsamhail \`\`Cheiste ón rang teagaisc\` agus bainisteoir bonn a scagann amach cásanna le `deleted=true`, chuimsíodh roghanna a bhaineann le ceisteanna scriosta mar choice.objects.filter (question\_\_name\_\_startswith='What') . #### Ná scagadh aon torthaí sa chineál seo fo-aicme bainisteora Úsáidtear an bainisteoir seo chun rochtain a fháil ar rudaí a bhaineann leo ó mhúnla éigin eile. Sna cásanna sin, caithfidh Django a bheith in ann na rudaí go léir don tsamhail atá á fháil aige a fheiceáil, ionas gur féidir *aon ruda* a dtagraítear dó a aisghabháil. Dá bhrí sin, níor cheart duit get\_queryset () a shárú chun aon sraitheanna a scagadh amach. Má dhéanann tú amhlaidh, cuirfidh Django torthaí neamhiomlán ar ais. ### Ag glaoch ar mhodhanna saincheaptha QuerySet\` ón mbainisteoir Cé go bhfuil an chuid is mó de na modhanna ón gcaighdeán ```QuerySet` inrochtana go díreach ón ``Bainiste```, is amhlaidh amháin maidir leis na modhanna breise atá sainmhínithe ar `QuerySet` saincheaptha má chuireann tú i bhfeidhm iad ar an `Bainiste` freisin: ``` class PersonQuerySet(models.QuerySet): def authors(self): return self.filter(role="A") def editors(self): return self.filter(role="E") class PersonManager(models.Manager): def get_queryset(self): return PersonQuerySet(self.model, using=self._db) def authors(self): return self.get_queryset().authors() def editors(self): return self.get_queryset().editors() class Person(models.Model): first_name = models.CharField(max_length=50) last_name = models.CharField(max_length=50) role = models.CharField(max_length=1, choices={"A": _("Author"), "E": _("Editor")}) people = PersonManager() ``` Ligeann an sampla seo duit glaoch ar ```údair () ``agus `eagarthóirí ()``` araon ón mbainisteoir `Person.People`. ### Bainisteoir a chruthú le modhanna QuerySet\` \In ionad an chur chuige thuas a éilíonn modhanna dúbailte ar an `QuerySet` agus an Bainiste\` araon, is féidir :meth: QuerySet.as\_Manager () \`a úsáid chun sampla de \`Bainisteoir \`\`a chruthú le cóip de mhodhanna saincheaptha \`\`QuerySet\`: ``` class Person(models.Model): ... people = PersonQuerySet.as_manager() ``` \Beidh an t-áis `Bainiste` a chruthaí:meth: QuerySet.as\_Manager () \`beagnach comhionann leis an \`\`PersonManager\` ón sampla roimhe seo. \Ní bhíonn ciall ar gach modh ```QuerySet` ag leibhéal ``Bainiste```; mar shampla cuirimid cosc d'aon ghnó an modh:meth: QuerySet.delete () \`ó chóipeáil chuig an rang \`\`Bainiste\`. Déantar modhanna a chóipeáil de réir na rialacha seo a leanas: - Cóipeáltar modhanna poiblí de réir réamhshoc - Ní chóipeáiltear modhanna príobháideacha (ag tosú le béim) de réir réamhshocraithe. - Déantar modhanna a bhfuil tréith `queryset_only` socraithe go `False` cóipeáil i gcónaí. - Ní chóipeáiltear modhanna le tréith `queryset_only` atá socraithe go `True` riamh. Mar shampla: ``` class CustomQuerySet(models.QuerySet): # Available on both Manager and QuerySet. def public_method(self): return # Available only on QuerySet. def _private_method(self): return # Available only on QuerySet. def opted_out_public_method(self): return opted_out_public_method.queryset_only = True # Available on both Manager and QuerySet. def _opted_in_private_method(self): return _opted_in_private_method.queryset_only = False ``` #### from\_queryset () \` #### `classmethod from_queryset(queryset_class)` Le haghaidh ardúsáide b'fhéidir gur mhaith leat `Bainiste` saincheaptha agus ```QuerySet` saincheaptha araon. Is féidir leat é sin a dhéanamh trí ghlaoch ar `Manager.from_querySet () ``a thugann seach*fo-aicme* de do bhonn ``Bainiste``` le cóip de na modhanna saincheaptha `QuerySet`: ``` class CustomManager(models.Manager): def manager_only_method(self): return class CustomQuerySet(models.QuerySet): def manager_and_queryset_method(self): return class MyModel(models.Model): objects = CustomManager.from_queryset(CustomQuerySet)() ``` Féadfaidh tú an rang a ghintear a stóráil in athróg freisin: ``` MyManager = CustomManager.from_queryset(CustomQuerySet) class MyModel(models.Model): objects = MyManager() ``` ### Bainisteoirí saincheaptha agus oidhreacht samhail \Seo mar a láimhseálann Django bainisteoirí saincheaptha agus:ref: oidhreacht mhúnla : 1. Déanann an rang leanaí oidhreacht bainisteoirí ó ranganna bonn i gcónaí, ag baint úsáide as gnáthordú réitigh ainmneacha Python (athraíonn ainmneacha ar an rang linbh gach duine eile; ansin tagann ainmneacha ar an gcéad rang tuismitheora, agus mar sin de). 2. Mura dhearbhaítear aon bhainisteoirí ar mhúnla agus/nó a thuismitheoirí, cruthaíonn Django an bainisteoir rudaí go huathoibríoch. 3. Is é an bainisteoir réamhshocraithe ar rang an ceann a roghnaíodh le:attr: meta.default\_manager\_name \, nó an chéad bhainisteoir a dhearbhaigh ar an tsamhail, nó bainisteoir réamhshocraithe an chéad mhúmhúnla tuismitheora. Soláthraíonn na rialacha seo an tsolúbthacht riachtanach más mian leat bailiúchán bainisteoirí saincheaptha a shuiteáil ar ghrúpa samhlacha, trí rang bonn teibí, ach an bainisteoir réamhshocraithe a shaincheapadh fós. Mar shampla, cuir leis go bhfuil an bunaicme seo agat: ``` class AbstractBase(models.Model): # ... objects = CustomManager() class Meta: abstract = True ``` Má úsáideann tú é seo go díreach i rang leanaí, is é rudaí an bainisteoir réamhshocraithe mura ndearbhaíonn tú aon bhainisteoirí sa rang linbh: ``` class ChildA(AbstractBase): # ... # This class has CustomManager as the default manager. pass ``` Más mian leat oidhreacht a dhéanamh ó AbstractBase \`, ach bainisteoir réamhshocraithe difriúil a sholáthar, is féidir leat an bainisteoir réamhshocraithe a sholáthar ar rang an linbh: ``` class ChildB(AbstractBase): # ... # An explicit default manager. default_manager = OtherManager() ``` Anseo, is é `default_manager` an réamhshocraithe. Tá an bainisteoir `ruda` ar fáil fós, ós rud é go bhfuil sé oidhreachta, ach ní úsáidtear é mar réamhshocraithe. Faoi dheireadh don sampla seo, cuir i gcás gur mhaith leat bainisteoirí breise a chur le rang an linbh, ach bain úsáid as an réamhshocrú ó AbstractBase fós. Ní féidir leat an bainisteoir nua a chur go díreach i rang an linbh, mar go ndéanfadh sé sin an réamhshocrú agus bheadh ort na bainisteoirí go léir ón rang bonn teibí a áireamh go sainráite freisin. Is é an réiteach ná na bainisteoirí breise a chur i mbunaicme eile agus iad a thabhairt isteach san ordlathas oidhreacht\* tar éis \* na réamhshocruithe: ``` class ExtraManager(models.Model): extra_manager = OtherManager() class Meta: abstract = True class ChildC(AbstractBase, ExtraManager): # ... # Default manager is CustomManager, but OtherManager is # also available via the "extra_manager" attribute. pass ``` Tabhair faoi deara cé gur féidir leat\* bainisteoir saincheaptha a shainiú ar an tsamhail teibí, ní féidir leat\* aon mhodhanna a úsáid ag baint úsáide as an tsamhail teibí. Is é sin: ``` ClassA.objects.do_something() ``` tá sé dlíthiúil, ach: ``` AbstractBase.objects.do_something() ``` ardóidh sé eisceacht. Tá sé seo toisc go bhfuil sé i gceist le bainisteoirí loighic a chumhdú chun bailiúcháin rudaí a bhainistiú. Ós rud é nach féidir leat bailiúchán rudaí teibí a bheith agat, níl sé ciall a bheith ag bainistiú iad. Má tá feidhmiúlacht agat a bhaineann leis an tsamhail teibí, ba cheart duit an fheidhmiúlacht sin a chur i “modh statach” nó i “modh ranga” ar an tsamhail teibí. ### Imeachtaí cur chun feidhme Cibé gnéithe a chuireann tú le do “Bainisteoir” saincheaptha, caithfidh sé a bheith indéanta cóip éadrom a dhéanamh de shampla `Bainiste`; ie, caithfidh an cód seo a leanas oibriú: ```pycon >>> import copy >>> manager = MyManager() >>> my_copy = copy.copy(manager) ``` Déanann Django cóipeanna éadmhara de rudaí bainisteora le linn fiosruithe áirithe; mura féidir do Bhainisteoir a chóipeáil, teipeann ar Ní cheist é seo don chuid is mó de na bainisteoirí saincheaptha. Mura bhfuil tú ach modhanna simplí ag cur le do `Bainiste`, ní dócha go ndéanfaidh tú cásanna de do Bainisteoir \`\`gan chóipeáil gan aon ghnó. Mar sin féin, má tá tú ag dul i bhfeidhm ar \`\`\_\_getattr\_\_\` nó modh príobháideach éigin eile de do réad `` `Bainiste `` a rialaíonn staid réada, ba cheart duit a chinntiú nach ndéanann tú difear do chumas do Bainisteoir a chóipeáil.