[Python] Gestione DB sqlite

[vegetassj2]

Ciao a tutti,
avrei bisogno di qualche input
Sto scrivendo una classe per potermi rendere più comodo l'interfacciamente con sqlite; nello specifico vorrei realizzare una specie di ORM, in modo da legare dei modelli definiti con delle classi a delle tabelle sul db per poi poterci fare delle operazioni. Per chi conosce Django, l'idea è creare qualcosa di simile al loro ORM, anche se molto più semplice.
Il problema è che ho delle GROSSE carenze sul design, quindi vorrei qualche suggerimento da voi su come strutturare il tutto.
Ecco qua quello che fin'ora ho realizzato:

#!/usr/bin/env python

import sqlite3
import sys
import os
from __future__ import with_statement

class Db():
    
    def __init__(self, dbname = ':memory:'):
        
        tables = []
        
        try:
            db = sqlite3.connect(dbname)
        except sqlite3.Error, e:
            print 'An error occurred:', e.args[0]
            
    def addTable(self, schema):
        table = self.Table(db,schema)
        tables.append(table)
        return
        
    def dropTable(self,schema):
        table = self.Table(db,schema)
        table.delete()
        return
    
    class Table():
        def __init__(self, db, schema = None):
            tableName = str(schema)
            try:
                conn = db.cursor()
                with conn:
                    conn.execute('SELECT tbl_name FROM sqlite_master')
                    tables = conn.fetch()
                    if table == tableName:
                        conn.execute("pragma table_info(%s)" %tableName)
                        return conn.fetchall()
                    return self.createTable(conn, schema)
                    
            except sqlite3.Error:
                print 'Sqlite error:',e.args[0]
                return None
                
        
        def createTable(self,conn, object = None):
            fields = [field for field in dir(object) if callable(getattr(object, field))]
            
            '''
            dalla lista dei field, che sono gli elementi della mia classe modello,
            devo creare lo statement sql per creare la tabella e restituire poi il pragma
            '''
            
        def delete(self, filter):
            pass

nello specifico non so come vadano creati i vari statement a partire dall'elenco dei metodi che ottengo con la funzione getattr.

[cdimauro]

Non ti conviene partire dall'ORM di Django e "ridurlo" per portarlo a quello che vorresti?

[vegetassj2]

Originariamente inviato da cdimauro

Non ti conviene partire dall'ORM di Django e "ridurlo" per portarlo a quello che vorresti?

in teoria si....in pratica vedevo questa cosa in ottica di didattica: in poche parole voglio imparare non avendo tempistiche, e volendo approfondire le mie conoscenze, mi chiedevo se qualcuno potesse darmi una mano, anche solo linkandomi della documentazione

[cdimauro]

Capito. Per "statement" cosa intendi, alla fine del tuo primo post?

[vegetassj2]

Originariamente inviato da cdimauro

Capito. Per "statement" cosa intendi, alla fine del tuo primo post?

rileggendo la mia risposta di poco fa, mi sono reso conto di essermi espresso in maniera abbastanza dura!sorry...troppo lavoro in ufficio fa male

tornando al codice, volevo trovare il modo di comporre la stringa della query(questo intendevo con statement) di creazione della tabella usando la funzione getattr per ricavare tutti i metodi implementati in una classe "modello".
In pratica vorrei definire una classe che modellizza un oggetto, che poi passerei al db per poter creare una tabella che lo rispecchi, in modo da mappare l'oggetto sulla tabella.

[cdimauro]

Il tono non mi sembra affatto duro.

Comunque dal codice mi sfugge il modo in cui recuperi le informazioni sui campi della tabella. Per essere più preciso, creato l'oggetto Table, da dove li prendi i campi a essa associati? E in che modo vengono rappresentati?

[vegetassj2]

Originariamente inviato da cdimauro

Il tono non mi sembra affatto duro.

Comunque dal codice mi sfugge il modo in cui recuperi le informazioni sui campi della tabella. Per essere più preciso, creato l'oggetto Table, da dove li prendi i campi a essa associati? E in che modo vengono rappresentati?

Ti spiego brevemente la struttura che avevo in mente.

Creo una classe Field generica, da cui per eredità creerò i vari tipi di Field: IntegerField, DateField, etc.....

class Field:
    
    def __init__(self, value):
        value = value
        
    def f1:
        pass
    
    class IntegerField(Field):
    
        def __init__(self, value):
            super.__init__(self,value)
        
        def f1:
            pass

A questo punto creo una classe generica modello che fa da contenitore generico, e da cui creo una sub-classe specifica per ogni tipo di oggetto che voglio mappare sul DB:

class Model:
    
    def __init__(self, name):
        name = name
        primary_key = None
        
    def f2:
        pass
    
class SpecificModel(Model):
    
    def __init__(self,name):
        self.__init__(self, name)
        
    int = Field.IntegerField()
    date = Field.DateField()
    
    def f2:
        pass

A questo punto, passerei un'istanza o una lista di istanze di SpecificModel all'oggetto DB, che provvederebbe a creare una tabella se non ancora esistente e a salvare i dati degli oggetti sul db.
Spero di essermi spiegato abbastanza bene
E' corretto il mio modo di strutturare il tutto?c'è qualche cosa di errato??

[cdimauro]

Mi sembra un buon modello , ma personalmente terrei tutti i "field" in una lista, anziché utilizzare dir() per ricavarli e poi lavorarci.

Questo perché anche l'ordine di creazione dei campi può essere importante, e con la dir() non hai la possibilità di ottenere l'esatto ordine di creazione.

Per quanto riguarda attribuiti specifici, come PRIMARY KEY o INDEX, realizzerei entità specifiche, diverse dai Field ma che ne facciano ovviamente uso.

Queste entità, alla creazione della tabella, verrebbero poi prelevate e comporterebbero o l'aggiunta di apposite righe nella CREATE TABLE, oppure la creazione di specifiche istruzioni ALTER TABLE che modifichino lo schema relazionale in accordo al tuo modello ORM.

Anche qui per gli indici starei attento all'ordine. Ad esempio, se creo una chiave primaria su tre Field, e successivamente c'è un'entità di tipo Field su uno di essi (magari proprio il primo ), creando prima la chiave primaria e poi l'indice, se l'engine SQL è intelligente comporterebbe la creazione del solo indice sulla chiave primaria, perché il secondo indice è già "incluso".

Se invece crei prima l'indice e poi la chiave primaria, probabilmente otterrai due indici diversi e ridondanti.

Non so se sono stato chiaro. Eventualmente parliamone ancora un po' finché non ti sarai fatto un'idea precisa.