Django: Comment pouvez-vous empêcher les longues requêtes de détruire votre base de données?

Question

J'utilise Django 1.1 avec les tables Mysql 5. * et MyISAM.

Certaines de mes requêtes peuvent prendre beaucoup de temps pour les valeurs aberrantes dans mon ensemble de données. Ceux-ci verrouillent les tables et ferment le site. D'autres fois, il semble que certains utilisateurs annulent la requête avant que cela ne soit fait et que certaines requêtes soient bloquées dans la phase "Préparation", bloquant toutes les autres requêtes.

Je vais essayer de retrouver tous les boîtiers d'angle, mais c'est bien d'avoir un filet de sécurité pour que le site ne tombe pas.

Comment éviter cela? Puis-je définir des temps de requête maximum?

Answer 1

Malheureusement, MySQL ne vous permet pas d'éviter cela facilement. Une méthode courante consiste à écrire un script qui vérifie tous les processus en cours toutes les X secondes (en fonction de ce que vous pensez être "long") et d'en tuer un qui fonctionne trop longtemps. Vous pouvez au moins obtenir des diagnostics de base, en définissant log_slow_queries dans MySQL qui écrira toutes les requêtes qui durent plus de 10 secondes dans un journal. Si cela est trop long pour ce que vous considérez comme "lent" pour vos besoins, vous pouvez définir long_query_time à une valeur autre que 10 pour modifier le seuil.

Answer 2

Il semble que le seul moyen fiable d'abandonner une requête est le kill command. Une mesure moins radicale consiste à fermer la connexion (et à en ouvrir une nouvelle); Cela met fin aux requêtes dès qu'elles tentent de send some output au client.

Answer 3

Savez-vous quelles sont les requêtes? Peut-être pourriez-vous optimiser le SQL ou mettre des index sur vos tables?

Answer 4

Je fais une application de réplication de base de données Django et j'ai la même situation, les requêtes sur un WAN peuvent parfois sembler se bloquer si la latence du réseau augmente.

De http://code.activestate.com/recipes/576780/

Recette 576780: Délai d'attente pour (presque) tout appelable

Créer un temps version limitée de toute appelable.

Par exemple, pour limiter la fonction f à t secondes, créez d'abord une version limitée dans le temps de f.

from timelimited import * 

f_t = TimeLimited(f, t) 

Ensuite, au lieu d'invoquer f(...), utilisez f_t comme

try: 
    r = f_t(...) 
except TimeLimitExpired: 
    r = ... # timed out 

Utilisez la manière suivante par exemple:

def _run_timed_query(cursor, log_msg, timeout, query_string, *query_args): 
    """Run a timed query, do error handling and logging""" 
    import sys 
    import traceback 
    from timelimited import * 

    try: 
     return TimeLimited(cursor.execute, timeout)(query_string, *query_args) 
    except TimeLimitExpired: 
     logger_ec.error('%s; Timeout error.' % log_msg) 
     raise TimeLimitExpired 
    except: 
     (exc_type, exc_info, tb) = sys.exc_info() 
     logger_ec.error('%s; %s.' % (log_msg, traceback.format_exception(exc_type, exc_info, None)[0])) 
     raise exc_type 

Answer 5

Utilisez les tables InnoDB, ils row-locking au lieu de table-locking.

Answer 6

Vous ne devriez pas écrire des requêtes de ce type, au moins de ne pas exécuter votre base de données en direct. Mysql a un paramètre "lent requêtes" que vous pouvez utiliser pour identifier les requêtes qui vous tuent. La plupart du temps, ces requêtes lentes sont buggées ou peuvent être accélérées en définissant un nouvel index ou deux.