Bonsoir !


Donc voilà je cherchais à créer une classe type (avec des méthodes d'ouverture, fermeture, sauvegarde, ajout & récupération de clef) pour une BDD.

J'ai regardé autour du module shelve (bizzarement ce n'est pas enregistré dans le fichier), (c)Pickle (j'aime pas trop), SQLite3 (bien, mais j'aurais besoin d'aide, à voir en dessous).

Donc avec sqlite3 j'ai vu que y'avais une classe class <ClassName>(sqlite3.Connection) mais malheureusement il me demande un argument, de type string donc je sais pas quoi mettre ... je pensais à un sqlite3 object du genre sqlite3.connect() mais cela ne fonctionne pas.

Je ne sais pas si SQLite3 est la meilleure solution, mais ma classe en shelve ne fonctionne pas (pas de sauvegarde dans le fichier)


Merci d'avance.

Je ne connais pas sqlite3, mais en faisant

import sqlite3
help(sqlite3)

Tu trouveras peut-être ton bonheur.

En fait j'ai créé deux classes cet après-midi, le problème est que le SQLite3 est assez compliqué, et que avec shelve la BDD n'est pas sauvegardé ...

SQLite3 :

from sqlite3 import Connection

class DatabaseManager(Connection):
    def __init__(self, path):
        self.path = path
        self.text_factory = str
        
    def __del__(self):
        self.commit()
        self.close()

    def update(self, table, primaryKeyName, primaryKeyValue, options):
        keys = ""
        if not isinstance(options, dict):
            raise ValueError, "Expected 'options' argument to be a dictionary, instead received: %s" % type(options).__name__
        if options:
            for key, value in options.iteritems():
                if isinstance(key, str):
                    key   = key.replace("'", "''")

                if isinstance(value, str):
                    value = value.replace("'", "''")
                keys += "%s='%s'," % (key, value)
            keys = keys[:-1]
            query = "UPDATE " + str(table) + " SET " + keys + " WHERE " + str(primaryKeyName) + "='" + str(primaryKeyValue) + "'"
            self.execute(query)
        
        
    def increment(self, table, primaryKeyName, primaryKeyValue, options):
        keys = ""
        if not isinstance(options, dict):
            raise ValueError, "Expected 'options' argument to be a dictionary, instead received: %s" % type(options).__name__
        for key, value in options.iteritems():
            if isinstance(key, str):
                key   = key.replace("'", "''")
            if isinstance(value, str):
                value = value.replace("'", "''")
            keys += "%s=%s+%i," % (key, key, value)
        keys = keys[:-1]
        self.execute("UPDATE ? SET %s WHERE ?=?+?" % keys, table, primaryKeyName, primaryKeyName, primaryKeyValue)
        
    def query(self, table, primaryKeyName, primaryKeyValue, options):
        if hasattr(options, "__len__"):
            query = 'SELECT ' + ",".join( map(lambda x: str(x).replace("'", "''"), options) ) + " FROM " + table \
                    + " WHERE " + primaryKeyName + "='" + primaryKeyValue + "'"
        else:
            query = "SELECT " + str(options).replace("'", "''") + " FROM " + table + \
                    " WHERE " + primaryKeyName + "='" + primaryKeyValue + "'"
        self.execute(query)
        return self.fetchone()
        
    def fetchall(self):
        trueValues = []
        for value in self.cursor.fetchall():
            if isinstance(value, tuple):
                if len(value) > 1:
                    tempValues = []
                    for tempValue in value:
                        if isinstance(tempValue, long):
                            tempValue = int(tempValue)
                        tempValues.append(tempValue)
                    trueValues.append(tempValues)
                else:
                    if isinstance(value[0], long):
                        trueValues.append(int(value[0]))
                    else:
                        trueValues.append(value[0])
            else:
                if isinstance(value, long):
                    value = int(value)
                trueValues.append(value)
        return trueValues
        
    def fetchone(self):
        result = self.cursor.fetchone()
        if hasattr(result, "__iter__"):
            if len(result) == 1:
                trueResults = result[0]
                if isinstance(trueResults, long):
                    trueResults = int(trueResults)
                return trueResults
            else:
                trueResults = []
                for trueResult in result:
                    if isinstance(trueResult, long):
                        trueResult = int(trueResult)
                    trueResults.append(trueResult)
                return trueResults
        if isinstance(result, long):
            result = int(result)
        return result    
        
    def clear(self, tables, saveDatabase = True):
        for table in tables:
            self.execute("DROP TABLE ?", (table, ))
        if saveDatabase:
            self.save()

database = DatabaseManager(<path>)

shelve :

from shelve import DbfilenameShelf

class DatabaseManager(DbfilenameShelf):
    def addPlayer(self, steamid):
        if not steamid in self:
            self[steamid] = {}
            
    def removePlayer(self, steamid):
        if steamid in self:
            del self[steamid]
            
database = DatabaseManager(<path>, writeback = True)

Je crois que tu n'as pas initialisé

Un exemple avec la classe str

class A(str):
    def __init__(self, chaine):
        self.chaine=chaine
        str.__init__(self) # ton initialisation que tu dois faire
    def get(self):
        return self.upper()

a=A("coucou")
print a.get()

Tu parles de la classe avec comme attribut Connection ou celle en shelve?

Ba je te dirais bien les deux

Du genre comme ça ?

from shelve import DbfilenameShelf

class DatabaseManager(DbfilenameShelf):
    def __init__(self, filename, flag='c', protocol=None, writeback=False):
        self.filename  = filename
        self.flag      = flag
        self.protocol  = protocol
        self.writeback = writeback
        DbfilenameShelf.__init__(self, filename, flag, protocol, writeback)
        
    def addPlayer(self, steamid):
        if not steamid in self:
            self[steamid] = {}
            
    def removePlayer(self, steamid):
        if steamid in self:
            del self[steamid]
            
database = DatabaseManager(<path>, writeback = True)

Oui maintenant faut tester je suis plus sur mon pc donc je peux pas plus t'aider. Faut voir quel argument t'as besoin pour cette classe.

As-tu comme contrainte d'utiliser seulement la bibliothèque standard de Python ?
Est-ce que ton application risque d'utiliser intensivement la base de données ?

Si tu as de nombreuses données à sauvegarder/récupérer dans une base de données, peut-être que l'utilisation d'un <acronym title="Object Relational Mapper">ORM</acronym> comme SQLAlchemy peut s'avérer bénéfique : ça permet grosso-modo de créer une couche d'abstraction entre ton application et la base de données, et c'est utilisable avec beaucoup de backends (SQLite, PostgreSQL...).

Sinon, SQLite3 est largement suffisant pour une petite appli.

J'ai aucune contrainte mise à part que je l'appli dois fonctionner en Python 2.5.1.

Les requêtes vers la BDD se feront toutes les 5 secondes environ (voir plus, voir moins ^^)

Je vais voir du côté de SQLAlchemy, je connais pas du tout