Backdoor de conexión de Django redis o cómo implementar uno

Question

¿Hay algún complemento o backend de terceros para administrar conexiones de redis en Django, por lo que los métodos en view.py no tienen que conectarse explícitamente a redis para cada solicitud?

Si no, ¿cómo comenzarías a implementar uno? Un nuevo plugin? un nuevo back-end? un nuevo middleware django?

Gracias.

Answer 1

Creo que el estándar emergente para bases de datos no rel es django-nonrel. No sé si django-nonrel está listo para producción o si es compatible con redis, pero tienen una guía en writing a custom no-sql backend.

Desafortunadamente, no creo que escribir soporte para una redis en django estándar sea fácil como escribir DatabaseBackend. Hay mucho en mecánica de modelos django y flujo de trabajo que simplemente asume una base de datos ACID. ¿Qué hay de syncdb? ¿Y aproximadamente Querysets?

Sin embargo, puede tratar de escribir un enfoque de personas pobres utilizando models.Manager y un montón de ajustes en su modelo. Por ejemplo:

# helper 
def fill_model_instance(instance, values): 
    """ Fills an model instance with the values from dict values """          
    attributes = filter(lambda x: not x.startswith('_'), instance.__dict__.keys()) 

    for a in attributes: 
     try: 
      setattr(instance, a, values[a.upper()]) 
      del values[a.upper()] 
     except: 
      pass 

    for v in values.keys(): 
     setattr(instance, v, values[v]) 

    return instance 




class AuthorManager(models.Manager): 

    # You may try to use the default methods. 
    # But should be freaking hard... 
    def get_query_set(self): 
     raise NotImplementedError("Maybe you can write a Non relational Queryset()! ") 

    def latest(self, *args, **kwargs): 
     # redis Latest query 
     pass 

    def filter(self, *args, **kwargs): 
     # redis filter query 
     pass 

    # Custom methods that you may use, instead of rewriting 
    # the defaults ones. 
    def open_connection(self): 
     # Open a redis connection 
     pass 

    def search_author(self, *args, **kwargs): 
     self.open_connection() 

     # Write your query. I don't know how this shiny non-sql works. 
     # Assumes it returns a dict for every matched author. 
     authors_list = [{'name': 'Leibniz', 'email': 'iinventedcalculus@gmail.com'}, 
         'name': 'Kurt Godel','email': 'self.consistent.error@gmail.com'}] 

     return [fill_instance(Author(), author) for author in authors_list] 



class Author(models.Model): 
    name  = models.CharField(max_length = 255) 
    email  = models.EmailField(max_length = 255) 

    def save(self): 
     raise NotImplementedError("TODO: write a redis save") 

    def delete(self): 
     raise NotImplementedError(""TODO: write a delete save") 

    class Meta: 
      managed = False 

favor, no que yo sólo he hecho un boceto de cómo se puede ajustar los modelos de Django. No he probado y ejecuto este código. Primero sugiero que investigue django-nonrel.