マネージャ (Manager) とは、Django のモデルに対するデータベースクエリの操作を提供するインターフェイスです。Django アプリケーション内の1つのモデルに対して、Manager は最低でも1つは存在します。
Manager クラスの詳細については、クエリを作成する に書かれています。ここでは、特に、Manager の動作をカスタマイズするモデルのオプションについて説明しています。
デフォルトでは、Django は objects という名前の Manager を各 Django モデルクラスに対して追加します。しかし、もし objects をフィールド名として使いたい場合や、あるいは、Manager に対して objects 以外の名前を使いたい場合には、各モデル単位で好きな名前を付けることができます。あるクラスの Manager の名前を変えるには、そのクラスの上で models.Manager() と書いて、クラス変数を定義します。たとえば、次のように書きます。
from django.db import models\n\nclass Person(models.Model):\n #...\n people = models.Manager()\nこのモデル例を使うと、Person.objects は AttributeError 例外を起こしますが、Person.people.all() と書けば、すべての Person オブジェクトのリストが得られます。
Manager ベースクラスを拡張し、カスタマイズした Manager をモデル内でインスタンス化すれば、特定のモデル用にカスタマイズした Manager を使うことができます。
Manager をカスタマイズしたくなるシチュエーションとしては、たとえば次の2つのような場合が考えられます。1つ目は、Manager に新しいメソッドを追加したい場合、もう1つは、Manager が最初に返す QuerySet を修正したい場合です。
Manager に新しいメソッドを追加するのがふさわしいのは、モデルに対する「テーブルレベル」での操作を追加したい場合です。(「低レベル」の機能、たとえば、あるモデルオブジェクトの1つのインスタンスに作用するような関数の場合には、Manager をカスタマイズするのではなく、モデルメソッド を使ってください。
For example, this custom Manager adds a method with_counts():
from django.db import models\nfrom django.db.models.functions import Coalesce\n\nclass PollManager(models.Manager):\n def with_counts(self):\n return self.annotate(\n num_responses=Coalesce(models.Count("response"), 0)\n )\n\nclass OpinionPoll(models.Model):\n question = models.CharField(max_length=200)\n objects = PollManager()\n\nclass Response(models.Model):\n poll = models.ForeignKey(OpinionPoll, on_delete=models.CASCADE)\n # ...\nWith this example, you'd use OpinionPoll.objects.with_counts() to get a\nQuerySet of OpinionPoll objects with the extra num_responses\nattribute attached.
Manager のカスタマイズメソッドは、どんなオブジェクトを返しても構いませんが、QuerySet だけは返してはいけません。
Another thing to note is that Manager methods can access self.model to\nget the model class to which they're attached.
QuerySet を修正するLink to this heading#A Manager’s base QuerySet returns all objects in the system. For\nexample, using this model:
from django.db import models\n\nclass Book(models.Model):\n title = models.CharField(max_length=100)\n author = models.CharField(max_length=50)\n``Book.objects.all()``は、データベース内の全ての本を返します。
\n``Manager.get_queryset()``メソッドをオーバーライドすることで、 ``Manager``のベース``QuerySet``を上書きできます。``get_queryset()``は、必要な属性を含む``QuerySet``を返す必要があります。
\n例えば、次のモデルには*2つ*の``Manager``があります。片方はすべてのオブジェクトを返し、もう片方はRoald Dahlの本のみを返します:
\n# First, define the Manager subclass.\nclass DahlBookManager(models.Manager):\n def get_queryset(self):\n return super().get_queryset().filter(author='Roald Dahl')\n\n# Then hook it into the Book model explicitly.\nclass Book(models.Model):\n title = models.CharField(max_length=100)\n author = models.CharField(max_length=50)\n\n objects = models.Manager() # The default manager.\n dahl_objects = DahlBookManager() # The Dahl-specific manager.\nこのモデルの例では、 ``Book.objects.all()``はデータベース上の本を全て返 しますが、 ``Book.dahl_objects.all()``は Roald Dahl の書いた本だけを返しま す。
\nBecause get_queryset() returns a QuerySet object, you can use\nfilter(), exclude() and all the other QuerySet methods on it. So\nthese statements are all legal:
Book.dahl_objects.all()\nBook.dahl_objects.filter(title='Matilda')\nBook.dahl_objects.count()\nThis example also pointed out another interesting technique: using multiple\nmanagers on the same model. You can attach as many Manager() instances to\na model as you'd like. This is a non-repetitive way to define common "filters"\nfor your models.
例:
\nclass AuthorManager(models.Manager):\n def get_queryset(self):\n return super().get_queryset().filter(role='A')\n\nclass EditorManager(models.Manager):\n def get_queryset(self):\n return super().get_queryset().filter(role='E')\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=50)\n last_name = models.CharField(max_length=50)\n role = models.CharField(max_length=1, choices=[('A', _('Author')), ('E', _('Editor'))])\n people = models.Manager()\n authors = AuthorManager()\n editors = EditorManager()\nThis example allows you to request Person.authors.all(), Person.editors.all(),\nand Person.people.all(), yielding predictable results.
If you use custom Manager objects, take note that the first Manager\nDjango encounters (in the order in which they're defined in the model) has a\nspecial status. Django interprets the first Manager defined in a class as\nthe "default" Manager, and several parts of Django (including\ndumpdata) will use that Manager exclusively for that model. As a\nresult, it's a good idea to be careful in your choice of default manager in\norder to avoid a situation where overriding get_queryset() results in an\ninability to retrieve objects you'd like to work with.
You can specify a custom default manager using Meta.default_manager_name.
If you're writing some code that must handle an unknown model, for example, in\na third-party app that implements a generic view, use this manager (or\n_base_manager) rather than assuming the model has an objects\nmanager.
This manager is used to access objects that are related to from some other\nmodel. In those situations, Django has to be able to see all the objects for\nthe model it is fetching, so that anything which is referred to can be\nretrieved.
\nTherefore, you should not override get_queryset() to filter out any rows.\nIf you do so, Django will return incomplete results.
While most methods from the standard QuerySet are accessible directly from\nthe Manager, this is only the case for the extra methods defined on a\ncustom QuerySet if you also implement them on the Manager:
class PersonQuerySet(models.QuerySet):\n def authors(self):\n return self.filter(role='A')\n\n def editors(self):\n return self.filter(role='E')\n\nclass PersonManager(models.Manager):\n def get_queryset(self):\n return PersonQuerySet(self.model, using=self._db)\n\n def authors(self):\n return self.get_queryset().authors()\n\n def editors(self):\n return self.get_queryset().editors()\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=50)\n last_name = models.CharField(max_length=50)\n role = models.CharField(max_length=1, choices=[('A', _('Author')), ('E', _('Editor'))])\n people = PersonManager()\nThis example allows you to call both authors() and editors() directly from\nthe manager Person.people.
In lieu of the above approach which requires duplicating methods on both the\nQuerySet and the Manager, QuerySet.as_manager() can be used to create an instance\nof Manager with a copy of a custom QuerySet’s methods:
class Person(models.Model):\n ...\n people = PersonQuerySet.as_manager()\nThe Manager instance created by QuerySet.as_manager() will be virtually\nidentical to the PersonManager from the previous example.
Not every QuerySet method makes sense at the Manager level; for\ninstance we intentionally prevent the QuerySet.delete() method from being copied onto\nthe Manager class.
Methods are copied according to the following rules:
\nPublic methods are copied by default.
Private methods (starting with an underscore) are not copied by default.
Methods with a queryset_only attribute set to False are always copied.
Methods with a queryset_only attribute set to True are never copied.
例:
\nclass CustomQuerySet(models.QuerySet):\n # Available on both Manager and QuerySet.\n def public_method(self):\n return\n\n # Available only on QuerySet.\n def _private_method(self):\n return\n\n # Available only on QuerySet.\n def opted_out_public_method(self):\n return\n opted_out_public_method.queryset_only = True\n\n # Available on both Manager and QuerySet.\n def _opted_in_private_method(self):\n return\n _opted_in_private_method.queryset_only = False\nfrom_queryset()Link to this heading#For advanced usage you might want both a custom Manager and a custom\nQuerySet. You can do that by calling Manager.from_queryset() which\nreturns a subclass of your base Manager with a copy of the custom\nQuerySet methods:
class CustomManager(models.Manager):\n def manager_only_method(self):\n return\n\nclass CustomQuerySet(models.QuerySet):\n def manager_and_queryset_method(self):\n return\n\nclass MyModel(models.Model):\n objects = CustomManager.from_queryset(CustomQuerySet)()\nYou may also store the generated class into a variable:
\nMyManager = CustomManager.from_queryset(CustomQuerySet)\n\nclass MyModel(models.Model):\n objects = MyManager()\nHere's how Django handles custom managers and model inheritance:
\nManagers from base classes are always inherited by the child class,\nusing Python's normal name resolution order (names on the child\nclass override all others; then come names on the first parent class,\nand so on).
If no managers are declared on a model and/or its parents, Django\nautomatically creates the objects manager.
The default manager on a class is either the one chosen with\nMeta.default_manager_name, or the first manager\ndeclared on the model, or the default manager of the first parent model.
These rules provide the necessary flexibility if you want to install a\ncollection of custom managers on a group of models, via an abstract base\nclass, but still customize the default manager. For example, suppose you have\nthis base class:
\nclass AbstractBase(models.Model):\n # ...\n objects = CustomManager()\n\n class Meta:\n abstract = True\nIf you use this directly in a subclass, objects will be the default\nmanager if you declare no managers in the base class:
class ChildA(AbstractBase):\n # ...\n # This class has CustomManager as the default manager.\n pass\nIf you want to inherit from AbstractBase, but provide a different default\nmanager, you can provide the default manager on the child class:
class ChildB(AbstractBase):\n # ...\n # An explicit default manager.\n default_manager = OtherManager()\nHere, default_manager is the default. The objects manager is\nstill available, since it's inherited, but isn't used as the default.
Finally for this example, suppose you want to add extra managers to the child\nclass, but still use the default from AbstractBase. You can't add the new\nmanager directly in the child class, as that would override the default and you would\nhave to also explicitly include all the managers from the abstract base class.\nThe solution is to put the extra managers in another base class and introduce\nit into the inheritance hierarchy after the defaults:
class ExtraManager(models.Model):\n extra_manager = OtherManager()\n\n class Meta:\n abstract = True\n\nclass ChildC(AbstractBase, ExtraManager):\n # ...\n # Default manager is CustomManager, but OtherManager is\n # also available via the "extra_manager" attribute.\n pass\nNote that while you can define a custom manager on the abstract model, you\ncan't invoke any methods using the abstract model. That is:
\nClassA.objects.do_something()\nis legal, but:
\nAbstractBase.objects.do_something()\nwill raise an exception. This is because managers are intended to encapsulate\nlogic for managing collections of objects. Since you can't have a collection of\nabstract objects, it doesn't make sense to be managing them. If you have\nfunctionality that applies to the abstract model, you should put that functionality\nin a staticmethod or classmethod on the abstract model.
Whatever features you add to your custom Manager, it must be\npossible to make a shallow copy of a Manager instance; i.e., the\nfollowing code must work:
>>> import copy\n>>> manager = MyManager()\n>>> my_copy = copy.copy(manager)\nDjango makes shallow copies of manager objects during certain queries;\nif your Manager cannot be copied, those queries will fail.
\nThis won't be an issue for most custom managers. If you are just\nadding simple methods to your Manager, it is unlikely that you\nwill inadvertently make instances of your Manager uncopyable.\nHowever, if you're overriding __getattr__ or some other private\nmethod of your Manager object that controls object state, you\nshould ensure that you don't affect the ability of your Manager to\nbe copied.