Modèles dans la base de données vitesse vs dictionnaires statiques vitesse

Question

J'ai besoin d'un type d'information qui est essentiellement statique. Il n'y a pas beaucoup de cette information, mais beaucoup d'objets utiliseront cette information. Comme il n'y a pas beaucoup de ces informations (quelques dictionnaires et certaines listes), j'ai pensé que j'avais 2 options - créer des modèles pour conserver ces informations dans la base de données ou les écrire comme des dictionnaires/listes dans certains fichiers de paramètres. Ma question est - qui est plus rapide, de lire cette information de la base de données ou d'un fichier de paramètres? Dans les deux cas, je dois être en mesure d'accéder à cette information dans beaucoup d'endroits, ce qui signifierait beaucoup d'appels de lecture de base de données. Alors, qui serait plus rapide?

Answer 1

Si elles sont vraiment jamais, jamais va changer, alors ne hésitez pas à les mettre dans votre fichier settings.py comme vous déclarer un dictionnaire Python normal. Toutefois, si vous souhaitez que vos informations soient modifiables via les méthodes Django normales, utilisez la base de données pour un stockage persistant, puis exploitez au mieux Django's cache framework.

Enregistrer vos données à la base de données normale, puis la première fois qu'il est accessible, les mettre en cache:

from django.core.cache import cache 

def some_view_that_accesses_date(request): 
    my_data = cache.get('some_key') 

    if my_data is None: 
    my_data = MyObject.objects.all() 
    cache.set('some_key', my_data) 

    ... snip ... normal view code 

Assurez-vous de ne jamais enregistrer None dans un cache, comme:

Nous vous déconseillons de stocker la valeur littérale None dans le cache, car vous ne sera pas en mesure de faire la distinction entre votre valeur None stockée et un cache miss signifié b y une valeur de retour de None.

Assurez-vous que vous tuez le cache sur object deletion ou change:

from django.core.cache import cache 
from django.db.models.signals import post_save 
from myapp.models import MyModel 

def kill_object_cache(sender, **kwargs): 
    cache.delete('some_key') 

post_save.connect(kill_object_cache, sender=MyModel) 
post_delete.connect(kill_object_cache, sender=MyModel) 

J'ai quelque chose de semblable à cela dans une de mes applications, et il fonctionne très bien. Évidemment, vous ne verrez aucune amélioration des performances si vous utilisez ensuite le backend de base de données, mais il s'agit d'une approche plus proche de Django (Djangonic?) Que d'utiliser memcached directement.De toute évidence, il vaut probablement la peine de définir la clé de cache some_key quelque part, plutôt que de la jeter partout dans votre code, les exemples ci-dessus sont simplement destinés à être faciles à suivre, plutôt que des implémentations de mise en cache forcément complètes.

Answer 2

Si vous avez besoin d'un accès rapide à partir de plusieurs processus, une base de données est la meilleure option pour vous. Cependant, si vous souhaitez simplement conserver des données en mémoire et y accéder à partir de plusieurs endroits dans le même processus, les dictionnaires Python seront plus rapides que l'accès à une base de données.

Answer 3

Si les données sont statiques, il n'est pas nécessaire de revenir à la base de données. Il suffit de le lire la première fois et de mettre en cache le résultat.

S'il existe une raison pour laquelle vous ne pouvez pas mettre en cache le résultat dans votre application, vous pouvez toujours utiliser memcached pour éviter de cliquer sur la base de données. L'avantage d'utiliser memcached est que si les données changent, vous pouvez simplement mettre à jour la valeur dans memcached.

pseudocode pour l'utilisation memcached

if 'foo' in memcached 
    data = memcached.get('foo') 
else 
    data = database.get('foo') 
    memcached.put('foo', data)