Merge branch 'sqlupdates' with SQL isolation and sqlsetup fixes

Database/sqlsetup.py

@@ -5,7 +5,7 @@ from Database.sqlwrapper import SqlWrapper
 class SQLSetup(object): 
 
     def initDb(self, dbconfname = 'default'):
-        db = SqlWrapper(read_db = dbconfname, write_db = dbconfname)
+        db = SqlWrapper(read_db = dbconfname, write_db = dbconfname, alchemy_logs=True)
         tables = self.get_schema()
         db.dropAll()
         db.createAllFromConf(tables)
@@ -14,7 +14,7 @@ class SQLSetup(object):
         tables = []
 
         default_columns = [
-            {"name":"uid",          "type":"VARCHAR(50)", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
+            {"name":"uid",          "type":"INTEGER", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
             {"name":"name",         "type":"VARCHAR(50)", "extra":{"nullable":False, "unique":True}},
             {"name":"string",       "type":"TEXT"},
             {"name":"help",         "type":"TEXT"},
@@ -47,7 +47,7 @@ class SQLSetup(object):
         # Table listing the types
         em_type = {"name":"em_type"}
         em_type['columns'] = default_columns + [
-            {"name":"class_id",     "type":"VARCHAR(50)", "extra":{"foreignkey":"em_class.uid", "nullable":False}},
+            {"name":"class_id",     "type":"INTEGER", "extra":{"foreignkey":"em_class.uid", "nullable":False}},
             {"name":"sortcolumn",   "type":"VARCHAR(50)", "extra":{"default":"rank"}},
             {"name":"icon",         "type":"INTEGER"},
         ]
@@ -56,8 +56,8 @@ class SQLSetup(object):
         # relation between types: which type can be a child of another
         em_type_hierarchy = {"name":"em_type_hierarchy"}
         em_type_hierarchy['columns'] = [
-            {"name":"superior_id",    "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
-            {"name":"subordinate_id", "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
+            {"name":"superior_id",    "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
+            {"name":"subordinate_id", "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
             {"name":"nature",         "type":"VARCHAR(50)"},
         ]
         tables.append(em_type_hierarchy)
@@ -65,17 +65,17 @@ class SQLSetup(object):
        # Table listing the fieldgroups of a class
         em_fieldgroup = {"name":"em_fieldgroup"}
         em_fieldgroup['columns'] = default_columns + [
-            {"name":"class_id",     "type":"VARCHAR(50)", "extra":{"foreignkey":"em_class.uid", "nullable":False}},
+            {"name":"class_id",     "type":"INTEGER", "extra":{"foreignkey":"em_class.uid", "nullable":False}},
         ]
         tables.append(em_fieldgroup)
 
         # Table listing the fields of a fieldgroup
         em_field = {"name":"em_field"}
         em_field['columns'] = default_columns + [
-            {"name":"fieldtype_id",   "type":"VARCHAR(50)", "extra":{"nullable":False}},
-            {"name":"fieldgroup_id",  "type":"VARCHAR(50)", "extra":{"foreignkey":"em_fieldgroup.uid", "nullable":False}},
-            {"name":"rel_to_type_id", "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid", "nullable":False}}, # if relational: type this field refer to
-            {"name":"rel_field_id",   "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid", "nullable":False}}, # if relational: field that specify the rel_to_type_id
+            {"name":"fieldtype_id",   "type":"INTEGER", "extra":{"nullable":False}},
+            {"name":"fieldgroup_id",  "type":"INTEGER", "extra":{"foreignkey":"em_fieldgroup.uid", "nullable":False}},
+            {"name":"rel_to_type_id", "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":False}}, # if relational: type this field refer to
+            {"name":"rel_field_id",   "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":False}}, # if relational: field that specify the rel_to_type_id
             {"name":"optional",       "type":"BOOLEAN"},
             {"name":"internal",       "type":"BOOLEAN"},
             {"name":"icon",           "type":"INTEGER"},
@@ -85,8 +85,8 @@ class SQLSetup(object):
         # selected field for each type
         em_field_type = {"name":"em_field_type"}
         em_field_type['columns'] = [
-            {"name":"type_id",   "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
-            {"name":"field_id",  "type":"VARCHAR(50)", "extra":{"foreignkey":"em_field.uid", "nullable":False, "primarykey":True}},
+            {"name":"type_id",   "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":False, "primarykey":True}},
+            {"name":"field_id",  "type":"INTEGER", "extra":{"foreignkey":"em_field.uid", "nullable":False, "primarykey":True}},
         ]
         tables.append(em_field_type)
 
@@ -94,10 +94,10 @@ class SQLSetup(object):
         objects = {
             "name":"objects",
             "columns":[
-                {"name":"uid",         "type":"VARCHAR(50)", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
+                {"name":"uid",         "type":"INTEGER", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
                 {"name":"string",      "type":"VARCHAR(50)"},
-                {"name":"class_id",    "type":"VARCHAR(50)", "extra":{"foreignkey":"em_class.uid"}},
-                {"name":"type_id",     "type":"VARCHAR(50)", "extra":{"foreignkey":"em_type.uid"}},
+                {"name":"class_id",    "type":"INTEGER", "extra":{"foreignkey":"em_class.uid"}},
+                {"name":"type_id",     "type":"INTEGER", "extra":{"foreignkey":"em_type.uid"}},
                 {"name":"date_update", "type":"DATE"},
                 {"name":"date_create", "type":"DATE"},
                 {"name":"history",     "type":"TEXT"}
@@ -110,7 +110,7 @@ class SQLSetup(object):
         files = {
             "name":"files",
             "columns":[
-                {"name":"uid",     "type":"VARCHAR(50)", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
+                {"name":"uid",     "type":"INTEGER", "extra":{"foreignkey":"uids.uid", "nullable":False, "primarykey":True}},
                 {"name":"field1",  "type":"VARCHAR(50)"}
             ]
         }

Database/sqlwrapper.py

@@ -81,6 +81,10 @@ class SqlWrapper(object):
         logger.debug("New wrapper instance : <"+self.name+" read:"+str(self.r_engine)+" write:"+str(self.w_engine))
         pass
 
+    @classmethod
+    def getEngine(c, ename = 'default', logs = None):
+        return c(read_db = ename, write_db = ename, alchemy_logs = logs).r_engine
+
     @property
     def cfg(self):
         """ Return the SqlWrapper.config dict """
@@ -273,13 +277,10 @@ class SqlWrapper(object):
                     err.append('Missing "'+dbname+'" db configuration')
                 else:
                     db = self.cfg['db'][dbname]
-                    if 'ENGINE' not in db:
-                        err.append('Missing "ENGINE" in database "'+db+'"')
-                    else:
-                        if db['ENGINE'] not in self._engines_cfg:
-                            err.append('Unknown engine "'+db['ENGINE']+'"')
-                        elif db['ENGINE'] != 'sqlite' and 'USER' not in db:
-                            err.append('Missing "User" in configuration of database "'+dbname+'"')
+                    if db['ENGINE'] not in self._engines_cfg:
+                        err.append('Unknown engine "'+db['ENGINE']+'"')
+                    elif db['ENGINE'] != 'sqlite' and 'USER' not in db:
+                        err.append('Missing "User" in configuration of database "'+dbname+'"')
                     if 'NAME' not in db:
                         err.append('Missing "NAME" in database "'+dbname+'"')
                         
@@ -294,7 +295,8 @@ class SqlWrapper(object):
         if not settings.DEBUG:
             logger.critical("Trying to drop all tables but we are not in DEBUG !!!")
             raise RuntimeError("Trying to drop all tables but we are not in DEBUG !!!")
-        meta = sqla.MetaData(bind=self.w_engine, reflect = True)
+        meta = sqla.MetaData(bind=self.w_engine)
+        meta.reflect()
         meta.drop_all()
         pass
 
@@ -310,7 +312,7 @@ class SqlWrapper(object):
             if not isinstance(table, dict):
                 raise TypeError("Excepted a list of dict but got a "+str(type(schema))+" in the list")
             self.createTable(**table)
-
+        
         self.meta_crea.create_all(bind = self.w_engine)
         logger.info("All tables created")
         self.meta_crea = None
@@ -334,14 +336,17 @@ class SqlWrapper(object):
         if not isinstance(name, str):
             raise TypeError("<class str> excepted for table name, but got "+type(name))
 
+        #if not 'mysql_engine' in kw and self.w_engine.dialect.name == 'mysql':
+        #    kw['mysql_engine'] = 'InnoDB'
+
         res = sqla.Table(name, self.meta_crea, **kw)
         for i,col in enumerate(columns):
             res.append_column(self.createColumn(**col))
 
         if crea_now:
             self.meta_crea.create_all(self.w_engine)
+            logger.debug("Table '"+name+"' created")
 
-        #logger.debug("Table '"+name+"' created")
         pass
 
     def createColumn(self, **kwargs):

EditorialModel/classes.py

@@ -5,11 +5,17 @@
     @see EmClass, EmType, EmFieldGroup, EmField
 """
 
+import logging as logger
+
 from EditorialModel.components import EmComponent, EmComponentNotExistError
-from Database.sqlwrapper import SqlWrapper
-from Database.sqlobject import SqlObject
+#from Database.sqlwrapper import SqlWrapper
+from Database import sqlutils
+import sqlalchemy as sql
+
 import EditorialModel
 
+
+
 class EmClass(EmComponent):
     table = 'em_class'
 
@@ -21,22 +27,44 @@ class EmClass(EmComponent):
         @param name str: name of the new class
         @param class_type EmClasstype: type of the class
     """
-    @staticmethod
-    def create(name, class_type):
+    @classmethod
+    def create(c, name, class_type):
         try:
             exists = EmClass(name)
+            logger.info("Trying to create an EmClass that allready exists")
         except EmComponentNotExistError:
-            uids = SqlObject('uids')
-            res = uids.wexec(uids.table.insert().values(table=EmClass.table))
-            uid = res.inserted_primary_key
-
-            emclass = SqlObject(EmClass.table)
-            res = emclass.wexec(emclass.table.insert().values(uid=uid, name=name, classtype=class_type['name']))
-            SqlWrapper.wc().execute("CREATE TABLE %s (uid VARCHAR(50))" % name)
-            return EmClass(name)
+            return c._createDb(name, class_type)
 
         return exists
 
+    @classmethod
+    def _createDb(c, name, class_type):
+        """ Do the db querys for EmClass::create() """
+        dbe = c.getDbE()
+        #Create a new uid
+        uids = sql.Table('uids', sqlutils.meta(dbe))
+        conn = dbe.connect()
+        req = uids.insert(values={'table':c.table})
+        res = conn.execute(req)
+        
+        uid = res.inserted_primary_key
+
+        #Create a new entry in the em_class table
+        dbclass = sql.Table(c.table, sqlutils.meta(dbe))
+        req = dbclass.insert().values(uid = uid, name=name, classtype=class_type['name'])
+        res = conn.execute(req)
+
+        #Create a new table storing LodelObjects of this EmClass
+        meta = sql.MetaData()
+        emclasstable = sql.Table(name, meta,
+            sql.Column('uid', sql.VARCHAR(50), primary_key = True))
+        emclasstable.create(conn)
+
+        conn.close()
+
+        return EmClass(res.inserted_primary_key)
+
+
     def populate(self):
         row = super(EmClass, self).populate()
         self.classtype = row.classtype

EditorialModel/components.py

@@ -6,21 +6,22 @@
 """
 
 from Lodel.utils.mlstring import MlString
-from Database.sqlwrapper import SqlWrapper
-from Database.sqlobject import SqlObject
+#from Database.sqlwrapper import SqlWrapper
 import logging
 import sqlalchemy as sql
+from Database import sqlutils
 
 logger = logging.getLogger('Lodel2.EditorialModel')
 
 class EmComponent(object):
 
+    dbconf = 'default' #the name of the engine configuration
+
     """ instaciate an EmComponent
         @param id_or_name int|str: name or id of the object
         @exception TypeError
     """
     def __init__(self, id_or_name):
-        SqlWrapper.start()
         if self is EmComponent:
             raise EnvironmentError('Abstract class')
         if isinstance(id_or_name, int):
@@ -36,20 +37,7 @@ class EmComponent(object):
     """ Lookup in the database properties of the object to populate the properties
     """
     def populate(self):
-        table = SqlObject(self.table)
-        select = table.sel
-
-        if self.id is None:
-            select.where(table.col.name == self.name)
-        else:
-            select.where(table.col.uid == self.id)
-
-        sqlresult = table.rexec(select)
-        records = sqlresult.fetchall()
-
-        if not records:
-            # could have two possible Error message for id and for name
-            raise EmComponentNotExistError("Bad id_or_name: could not find the component")
+        records = self._populateDb() #Db query
 
         for record in records:
             row = type('row', (object,), {})()
@@ -66,6 +54,32 @@ class EmComponent(object):
 
         return row
 
+    @classmethod
+    def getDbE(c):
+        """ Shortcut that return the sqlAlchemy engine """
+        return sqlutils.getEngine(c.dbconf)
+
+    def _populateDb(self):
+        """ Do the query on the db """
+        dbe = self.__class__.getDbE()
+        component = sql.Table(self.table, sqlutils.meta(dbe))
+        req = sql.sql.select([component])
+
+        if self.id == None:
+            req.where(component.c.name == self.name)
+        else:
+            req.where(component.c.uid == self.id)
+        c = dbe.connect()
+        res = c.execute(req)
+        c.close()
+
+        res = res.fetchall()
+
+        if not res or len(res) == 0:
+            raise EmComponentNotExistError("No component found with "+('name '+self.name if self.id == None else 'id '+self.id ))
+
+        return res
+
     """ write the representation of the component in the database
         @return bool
     """
@@ -77,14 +91,35 @@ class EmComponent(object):
         values['string'] = str(self.string)
         values['help']= str(self.help)
 
-        emclass = SqlObject(self.table)
-        update = emclass.table.update(values=values)
-        res = emclass.wexec(update)
+        self._saveDb(values)
+
+    def _saveDb(self, values):
+        """ Do the query on the db """
+        dbe = self.__class__.getDbE()
+        component = sql.Table(self.table, sqlutils.meta(dbe))
+        req = sql.update(t, values = values).where(component.id == self.id)
+
+        c = dbe.connect()
+        res = c.execute(req)
+        c.close()
+        if not res:
+            raise RuntimeError("Unable to save the component in the database")
+        
 
     """ delete this component data in the database
         @return bool
     """
     def delete(self):
+        #<SQL>
+        dbe = self.__class__.getDbE()
+        component = sql.Table(self.table, sqlutils.meta(dbe))
+        req= component.delete().where(component.id == self.id)
+        c = dbe.connect()
+        res = c.execute(req)
+        c.close
+        if not res:
+            raise RuntimeError("Unable to delete the component in the database")
+        #</SQL>
         pass
 
     """ change the rank of the component