Django: ¿Cómo se puede evitar que las consultas largas maten a su base de datos?

Question

Estoy usando Django 1.1 con las tablas Mysql 5. * y MyISAM.

Algunas de mis consultas pueden tomar un montón de tiempo para valores atípicos en mi conjunto de datos. Estos bloquean las tablas y cierran el sitio. En otras ocasiones, parece que algunos usuarios cancelan la solicitud antes de que finalice y algunas consultas quedan atrapadas en la fase de "Preparación" bloqueando todas las demás consultas.

Trataré de buscar todas las cajas de esquina, pero es bueno tener una red de seguridad para que el sitio no se caiga.

¿Cómo puedo evitar esto? ¿Puedo establecer los tiempos máximos de consulta?

Answer 1

Desafortunadamente MySQL no le permite una manera fácil de evitar esto. Un método común es, básicamente, escribir un script que verifique todos los procesos en ejecución cada X segundos (según lo que piense que es "largo") y eliminar los que cree que se están ejecutando demasiado tiempo. Sin embargo, al menos puede obtener algunos diagnósticos básicos configurando log_slow_queries en MySQL que escribirá todas las consultas que tarden más de 10 segundos en un registro. Si es demasiado tiempo para lo que considera "lento" para sus propósitos, puede configurar long_query_time a un valor distinto de 10 para cambiar el umbral.

Answer 2

Parece que la única manera confiable de abortar una consulta es kill command. Una medida menos drástica es cerrar la conexión (y volver a abrir una nueva); esto terminará las consultas tan pronto como intenten send some output al cliente.

Answer 3

¿Sabes cuáles son las consultas? ¿Tal vez podría optimizar el SQL o poner algunos índices en sus tablas?

Answer 4

Estoy haciendo una aplicación Django DB-replication y tengo la misma situación, las consultas a través de una WAN a veces pueden parecer suspendidas si aumenta la latencia de la red.

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

Receta 576780: Tiempo de espera para (casi) cualquier exigible

Crear un tiempo de versión limitada de cualquier exigible. Por ejemplo, para limitar la función f a t segundos, cree primero una versión limitada en el tiempo de f.

from timelimited import * 

f_t = TimeLimited(f, t) 

Entonces, en lugar de invocar f(...), utilice f_t como

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

utilice de la siguiente manera, por ejemplo:

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

Utilizar tablas InnoDB, que hacen row-locking en lugar de table-locking.

Answer 6

No debe escribir consultas como esa, al menos no para ejecutar contra su base de datos en vivo. Mysql tiene un parámetro de "consultas lentas" que puede usar para identificar las consultas que lo están matando. La mayoría de las veces, estas consultas lentas son defectuosas o pueden acelerarse definiendo un nuevo índice o dos.