Django Redis Verbindung Backend oder wie man eine implementiert

Question

Gibt es ein Plugin oder 3rd-Party-Backend zu verwalten Redis-Verbindungen in Django, so dass die Methoden in view.py müssen nicht explizit für jede Anfrage Redis verbinden?

Wenn nicht, wie würden Sie beginnen, eines zu implementieren? Ein neues Plugin? ein neues Backend? eine neue Django-Middleware?

Vielen Dank.

Answer 1

Ich denke, der aufkommende Standard für Non-rel-Datenbanken ist django-nonrel. Ich weiß nicht, ob Django-Nonrel produktionsbereit ist oder ob Support wieder verfügbar ist, aber sie haben eine Anleitung zu writing a custom no-sql backend.

Leider glaube ich nicht, dass das Schreiben von Unterstützung für ein Redis auf Standard-Django ist einfach wie das Schreiben einer DatabaseBackend. Es gibt eine Menge in der Mechanik und dem Workflow von Django-Modellen, die einfach von einer ACID-Datenbank ausgehen. Was ist mit syncdb? Und über Querysets?

Sie können jedoch versuchen, eine schlechte-Mann-Ansatz mit models.Manager und eine Menge Feinabstimmung auf Ihrem Modell zu schreiben. Zum Beispiel:

# 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 

Bitte nicht, dass ich nur eine Skizze gemacht, wie Sie die django Modelle optimieren können. Ich habe nicht getestet und diesen Code ausführen. Ich empfehle Ihnen zuerst, Django-Nonrel zu untersuchen.