not - Django: ¿relacionado con Force Select?

filter django

Question

Creé un modelo y estoy representando el modelo predeterminado / no modificado para él. Esto solo genera 64 consultas SQL porque tiene bastantes claves externas, y éstas a su vez tienen más claves foráneas.

¿Es posible obligarlo a que siempre (de forma predeterminada) realice una select_related cada vez que se devuelve uno de estos modelos?

Answer 1

Aquí también hay un truco divertido:

class DefaultSelectOrPrefetchManager(models.Manager):
def __init__(self, *args, **kwargs):
self._select_related = kwargs.pop(''select_related'', None)
self._prefetch_related = kwargs.pop(''prefetch_related'', None)
super(DefaultSelectOrPrefetchManager, self).__init__(*args, **kwargs)
def get_queryset(self, *args, **kwargs):
qs = super(DefaultSelectOrPrefetchManager, self).get_queryset(*args, **kwargs)
if self._select_related:
qs = qs.select_related(*self._select_related)
if self._prefetch_related:
qs = qs.prefetch_related(*self._prefetch_related)
return qs
class Sandwich(models.Model):
bread = models.ForeignKey(Bread)
extras = models.ManyToManyField(Extra)
# ...
objects = DefaultSelectOrPrefetchManager(select_related=(''bread'',), prefetch_related=(''extras'',))

Luego puede reutilizar el administrador fácilmente entre clases modelo. Como caso de uso de ejemplo, esto sería apropiado si tuviera un método __unicode__ en el modelo que representara una cadena que incluyera cierta información de un modelo relacionado (o cualquier otra cosa que implique que casi siempre se requiere un modelo relacionado).

... y si realmente quieres volverte loco, aquí tienes una versión más generalizada. Le permite llamar a cualquier secuencia de métodos en el conjunto de consultas predeterminado con cualquier combinación de kwargs o kwargs . Puede haber algunos errores en el código, pero entiendes la idea.

from django.db import models
class MethodCalls(object):
"""
A mock object which logs chained method calls.
"""
def __init__(self):
self._calls = []
def __getattr__(self, name):
c = Call(self, name)
self._calls.append(c)
return c
def __iter__(self):
for c in self._calls:
yield tuple(c)
class Call(object):
"""
Used by `MethodCalls` objects internally to represent chained method calls.
"""
def __init__(self, calls_obj, method_name):
self._calls = calls_obj
self.method_name = method_name
def __call__(self, *method_args, **method_kwargs):
self.method_args = method_args
self.method_kwargs = method_kwargs
return self._calls
def __iter__(self):
yield self.method_name
yield self.method_args
yield self.method_kwargs
class DefaultQuerysetMethodCallsManager(models.Manager):
"""
A model manager class which allows specification of a sequence of
method calls to be applied by default to base querysets.
`DefaultQuerysetMethodCallsManager` instances expose a property
`default_queryset_method_calls` to which chained method calls can be
applied to indicate which methods should be called on base querysets.
"""
def __init__(self, *args, **kwargs):
self.default_queryset_method_calls = MethodCalls()
super(DefaultQuerysetMethodCallsManager, self).__init__(*args, **kwargs)
def get_queryset(self, *args, **kwargs):
qs = super(DefaultQuerysetMethodCallsManager, self).get_queryset(*args, **kwargs)
for method_name, method_args, method_kwargs in self.default_queryset_method_calls:
qs = getattr(qs, method_name)(*method_args, **method_kwargs)
return qs
class Sandwich(models.Model):
bread = models.ForeignKey(Bread)
extras = models.ManyToManyField(Extra)
# Other field definitions...
objects = DefaultQuerysetMethodCallsManager()
objects.default_queryset_method_calls.filter(
bread__type=''wheat'',
).select_related(
''bread'',
).prefetch_related(
''extras'',
)

El objeto MethodCalls inspirado en python-mock es un intento de hacer que la API sea más natural. Algunos pueden encontrar eso un poco confuso. Si es así, puede __init__ ese código para un __init__ o kwarg que solo acepta una tupla de información de llamada de método.

Answer 2

Cree un models.Manager personalizado. models.Manager y anule todos los métodos ( filter , get , etc.) y añada select_related a cada consulta. Luego configure este administrador como el atributo de objects en el modelo.

Yo recomendaría simplemente select_related su código y agregar select_related donde sea necesario, porque hacer select_related en todo va a causar problemas graves de rendimiento más adelante (y no estaría del todo claro de dónde viene).

Answer 3

Puede crear un administrador personalizado y simplemente anular get_queryset para que se aplique en todas partes. Por ejemplo:

class MyManager(models.Manager):
def get_queryset(self):
return super(MyManager, self).get_queryset().select_related(''foo'', ''bar'')

(Antes de Django 1.6, era get_query_set ).