Das deutsche Python-Forum

Hallo zusammen,

ich möchte eine SQL-Verbindung (MySQLdb) permanent offen halten und hatte mir das ursprünglich etwa so vorgestellt:

Code: Alles auswählen

class foo(Persistent):
    def __init__(self):
        self.connection = MySQL(host, user, ...)
    def sql(query):
        return self.connection(query)

Problem => Unpickleable Object
Also wollte ich mir mal volatile zu nutze machen (hab ich vorher noch nie verwendet).

Code: Alles auswählen

class foo(Persistent):
    ...
    def sql(query):
        if hasattr(self, '_v_connection'): # Es könnte ja eine der 3 Unload-Möglichkeiten eingetreten sein..
            self._v_connection = MySQL(host, user, ...)
        return self._v_connection(query)

Funktioniert so auch richtig gut!
Nur hab ich jetzt das Problem, dass _v_connection einfach irgendwann "invalidated" wird und ich keine Möglichkeit finde, dabei die SQL-Verbindung zu schließen..

Somit hab ich dann x offene SQL-Threads (Debian Woody).
Natürlich könnte ich dem jetzt mit thread-timeouts entgegenwirken, aber das ist in meinen Augen nur ne quick & dirty solution.

Hat jemand eine Idee, wie ich die SQL-Verbindung beim (_v_-)Unload closen kann?
Oder gibts vielleicht noch eine einfachere Möglichkeit eine SQL-Verbingung permanent offen zu halten?

LG
Jens

woolfy hat geschrieben:ich möchte eine SQL-Verbindung (MySQLdb) permanent offen halten

Hi Jens!

Wenn du eine Klasse von "Persistent" ableitest, dann versucht Zope die Klasseninstanz zu speichern. Natürlich lässt sich eine Datenbankverbindung nicht speichern. Mein Vorschlag (der rein aus der Luft gegriffen ist): Lege dir eine eigene Klasse für die Datenbankverbindung an, die nicht von "Persistent" abgeleitet wird.

Ich kann es jetzt nicht nachprüfen, aber vielleicht funktioniert dieser Vorschlag:

Code: Alles auswählen

class DB:
    def __init__(self, host = "mein host", user = "username", ...):
        self.connection = MySQL(host, user, ...)

class foo(Persistent):
    db = DB()
    def sql(query):
        return self.db.connection(query)

mfg
Gerold

Hallo gerold,

leider hatte ich in den letzten Tagen nur wenig Zeit...

Im Grunde habe ich dies schon getan, da die Klasse "MySQL" nicht Persistent ist.

Code: Alles auswählen

import MySQLdb

class MySQL:
    
    def __init__(self):
        """ init """
        self.conn    = None
        self.cursor  = None
    
    def open(self, host, user, passwd, db):
        """ open connection """
        self.conn    = MySQLdb.connect(host, user, passwd, db)
        self.cursor  = self.conn.cursor()
    
    def sql(self, query):
        """ query """
        self.cursor.execute(query)
        return self.cursor.fetchall()
    
    def close(self):
        """ close """
        self.cursor.close()
        self.conn.close()

Im Endeffekt habe ich doch dann eine "nicht Persistent"-Instanz, die ich dann einer "Persistent"-Instanz als Attribut zuweise.

Das ganze läuft also nach wie vor in einen "Unpickleable Object"-Error.

Ich hab mir jetzt mal noch "ZGadflyDA" genauer angesehen, hier wird die Verbindung auch mittels volatile-variablen gehalten.
In meinem Produkt hatte ich noch..

Code: Alles auswählen

def __init__(self):
    self._v_connection = None

..nachdem ich das rausgeworfen habe, verliere ich die Verbindung beim Produkt-refresh nicht mehr!

Allerdings verstehe ich nicht so recht weshalb, da __init__ beim Produkt-refresh ja eigentlich nicht ausgeführt wird...

Naja, jedenfalls läuft das ganze soweit recht stabil und ich werde es wohl vorerst so lassen, und beobachten wie es sich verhält.

Ich danke dir!

Gruß
Jens

Das deutsche Python-Forum

MySQL-Verbindung permanent offen halten mit _v_

MySQL-Verbindung permanent offen halten mit _v_

Re: MySQL-Verbindung permanent offen halten mit _v_