2009-05-27 8 views
20

Je suis nouveau à Django, mais l'application que j'ai à l'esprit pourrait finir par avoir des URL qui ressemblent à ceci:Les requêtes de modèle Django asynchrones sont-elles possibles?

http://mysite/compare/id_1/id_2 

Où « ID_1 » et « id_2 » sont des identifiants de deux objets modèles distincts. Dans le gestionnaire de "comparer", je voudrais asynchrone, et en parallèle, interroger et récupérer les objets id_1 et id_2.

Y at-il un moyen de le faire en utilisant une syntaxe Django standard? J'espère pour pseudocode qui finit par regarder quelque chose comme ceci:

import django.async 

# Issue the model query, but set it up asynchronously. 
# The next 2 lines don't actually touch my database 
o1 = Object(id=id_1).async_fetch() 
o2 = Object(id=id_2).async_fetch() 

# Now that I know what I want to query, fire off a fetch to do them all 
# in parallel, and wait for all queries to finish before proceeding. 

async.Execute((o2,o2)) 

# Now the code can use data from o1 and o2 below... 
+1

+1: Question intéressante :-) –

+0

Puisque tout est mis en mémoire cache, je doute que vous verriez tout gain de ce genre de chose. Votre objet récupère-t-il vraiment la partie la plus lente de votre application? –

+0

Tout ne sera pas mis en cache, et c'est en fait juste une version simple de la conception réelle que je considère. Imaginez quelque chose comme "aller chercher tous les messages dans ce fil" pour le logiciel de forum. Le nombre de messages peut être très important (1000) et le modèle d'accès peut être tel qu'ils ne sont pas tous mis en cache. – slacy

Répondre

11

Il n'y a pas des opérations strictement asynchrones que vous avez parlé, mais je pense que vous pouvez obtenir le même effet en utilisant in_bulk opérateur de requête de django, qui prend une liste d'identifiants à interroger.

Quelque chose comme ça pour le urls.py:

urlpatterns = patterns('', 
    (r'^compare/(\d+)/(\d+)/$', 'my.compareview'), 
) 

Et ceci pour la vue:

def compareview(request, id1, id2): 
    # in_bulk returns a dict: { obj_id1: <MyModel instance>, 
    #       obj_id2: <MyModel instance> } 
    # the SQL pulls all at once, rather than sequentially... arguably 
    # better than async as it pulls in one DB hit, rather than two 
    # happening at the same time 
    comparables = MyModel.objects.in_bulk([id1, id2]) 
    o1, o2 = (comparables.get(id1), comparables.get(id2))  
+0

Est-ce que in_bulk utilise des threads pour émettre les requêtes en parallèle ou est-il encore sérialisé? Je cherche à minimiser la latence de rendu de page. – slacy

+0

En vrac écrit une requête SQL unique, donc rien n'est sérialisé ou en parallèle ... il y a juste un seul hit DB qui récupère les deux instances. –

+0

C'est malheureux. Sur une base de données rapide, il est plus rapide d'émettre N requêtes en parallèle que d'en émettre une pour tous les objets. in_bulk() réduira légèrement la latence. J'espere un rendu de O (1) page. – slacy

Questions connexes