BainisteoiríLink to this heading#

Modhanna bainisteora breise a chur leisLink to this heading#

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 `, <model-methods>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úLink to this heading#

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

Model._default_managerLink to this definition#

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

<django.db.models.Options.default_manager_name>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í bonnLink to this heading#

Model._base_managerLink to this definition#

Ag glaoch ar mhodhanna saincheaptha ``QuerySet` ón mbainisteoirLink to this heading#

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

<django.db.models.query.QuerySet.as_manager>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()

<django.db.models.query.QuerySet.as_manager>Beidh an t-áis Bainiste a chruthaí:meth: QuerySet.as_Manager () `beagnach comhionann leis an ``PersonManager` ón sampla roimhe seo.

<django.db.models.query.QuerySet.delete>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

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

MyManager = CustomManager.from_queryset(CustomQuerySet)


class MyModel(models.Model):
    objects = MyManager()

Bainisteoirí saincheaptha agus oidhreacht samhailLink to this heading#

<model-inheritance>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 <django.db.models.Options.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 feidhmeLink to this heading#

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

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