Merge branch 'master' of git.labocleo.org:lodel2

Database/sqlalter.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import sqlalchemy as sqla
+from sqlalchemy.ext.compiler import compiles
+
+## @file sqlalter.py
+# This file defines all DDL (data definition langage) for the ALTER TABLE instructions
+# 
+# It uses the SqlAlchemy compilation and quoting methos to generate SQL
+
+
+class AddColumn(sqla.schema.DDLElement):
+    """ Defines the ddl for adding a column to a table """
+    def __init__(self,table, column):
+        """ Instanciate the DDL
+            @param table sqlalchemy.Table: A sqlalchemy table object
+            @param column sqlalchemy.Column: A sqlalchemy column object
+        """
+        self.col = column
+        self.table = table
+
+@compiles(AddColumn, 'mysql')
+@compiles(AddColumn, 'postgresql')
+@compiles(AddColumn, 'sqlite')
+def visit_add_column(element, ddlcompiler, **kw):
+    """ Compiles the AddColumn DDL for mysql, postgresql and sqlite"""
+    prep = ddlcompiler.sql_compiler.preparer
+    tname = prep.format_table(element.table)
+    colname = prep.format_column(element.col)
+    return 'ALTER TABLE %s ADD COLUMN %s %s'%(tname,  colname, element.col.type)
+
+@compiles(AddColumn)
+def visit_add_column(element, ddlcompiler, **kw):
+    raise NotImplementedError('Add column not yet implemented for '+str(ddlcompiler.dialect.name))
+
+class DropColumn(sqla.schema.DDLElement):
+    """ Defines the DDL for droping a column from a table """
+    def __init__(self, table, column):
+        """ Instanciate the DDL
+            @param table sqlalchemy.Table: A sqlalchemy table object
+            @param column sqlalchemy.Column: A sqlalchemy column object representing the column to drop
+        """
+        self.col = column
+        self.table = table
+
+@compiles(DropColumn,'mysql')
+@compiles(DropColumn, 'postgresql')
+def visit_drop_column(element, ddlcompiler, **kw):
+    """ Compiles the DropColumn DDL for mysql & postgresql """
+    prep = ddlcompiler.sql_compiler.preparer
+    tname = prep.format_table(element.table)
+    colname = prep.format_column(element.col)
+    return 'ALTER TABLE %s DROP COLUMN %s'%(tname, colname)
+
+@compiles(DropColumn)
+def visit_drop_column(element, ddlcompiler, **kw):
+    raise NotImplementedError('Drop column not yet implemented for '+str(ddlcompiler.dialect.name))
+
+class AlterColumn(sqla.schema.DDLElement):
+    """ Defines the DDL for changing the type of a column """
+    def __init__(self, table, column):
+        """ Instanciate the DDL
+            @param table sqlalchemy.Table: A sqlalchemy Table object
+            @param column sqlalchemy.Column: A sqlalchemy Column object representing the new column
+        """
+        self.col = column
+        self.table = table
+
+@compiles(AlterColumn, 'mysql')
+def visit_alter_column(element, ddlcompiler, **kw):
+    """ Compiles the AlterColumn DDL for mysql """
+    prep = ddlcompiler.sql_compiler.preparer
+    tname = prep.format_table(element.table)
+    colname = prep.format_column(element.col)
+    return 'ALTER TABLE %s ALTER COLUMN %s %s'%(tname, colname, element.col.type)
+
+@compiles(AlterColumn, 'postgresql')
+def visit_alter_column(element, ddlcompiler, **kw):
+    """ Compiles the AlterColumn DDL for postgresql """
+    prep = ddlcompiler.sql_compiler.preparer
+    tname = prep.format_table(element.table)
+    colname = prep.format_column(element.col)
+    return 'ALTER TABLE %s ALTER COLUMN %s TYPE %s'%(tname, colname, element.col.type)
+
+@compiles(AlterColumn)
+def visit_alter_column(element, ddlcompiler, **kw):
+    raise NotImplementedError('Alter column not yet implemented for '+str(ddlcompiler.dialect.name))
+

Database/sqlobject.py

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import logging as logger
-
-import sqlalchemy as sql
-
-from Database.sqlwrapper import SqlWrapper
-
-class SqlObject(object):
-    """ Object that make aliases with sqlalchemy
-        
-        Example usage of object that inherite from SqlObject :
-        
-        class foo(SlqObject,...):
-            def __init__(self, ...):
-                self.__class__.tname = 'foo_table'
-
-        f = foo(...)
-        req = f.where(f.col.id == 42)
-        res = f.rexec(req)
-
-        e = bar(...)
-        req = f.join(e.col.id == f.col.id)
-        res = f.rexec(req)
-
-    """
-
-    def __init__(self, tname):
-        if not type(tname) is str:
-            logger.error("Unable to instanciate, bad argument...")
-            raise TypeError('Excepted a string not a '+str(type(tname)))
-
-        self.tname = tname
-        self.table = self.Table()
-        pass
-
-    def Table(self):
-        self.table = sql.Table(self.tname, sql.MetaData(), autoload_with=SqlWrapper.rengine, autoload=True)
-        return self.table
-
-    @property
-    def col(self):
-        return self.table.c
-    
-    @property
-    def sel(self):
-        return sql.select([self.table])
-
-    @property
-    def where(self):
-        return self.sel.where
-
-    @property
-    def join(self):
-        return self.sel.join
-
-    @property
-    def rconn(self):
-        return SqlWrapper.rc()
-
-    @property
-    def wconn(self):
-        return SqlWrapper.wc()
-
-    def sFetchAll(self, sel):
-        return self.rexec(sel).fetchall()
-
-    def rexec(self, o):
-        return self.rconn.execute(o)
-
-    def wexec(self, o):
-        return self.wconn.execute(o)

Database/sqlquerybuilder.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+import os
+import logging as logger
+
+import sqlalchemy as sql
+
+from Database.sqlwrapper import SqlWrapper
+
+class SqlQueryBuilder():
+
+    def __init__(self, sqlwrapper, table):
+        if not type(sqlwrapper) is SqlWrapper:
+             logger.error("Unable to instanciate, bad argument...")
+             raise TypeError('Excepted a SqlWrapper not a '+str(type(sqlwrapper)))
+        self.table = table
+        self.sqlwrapper = sqlwrapper
+        self.proxy = None
+
+
+    def Select(self, arg):
+        """ Alias for select clause
+            @param arg iterable: arg must be a Python list or other iterable and contain eather table name/type or colum/literal_column
+        """
+
+        self.proxy = sql.select(arg)
+        return self.proxy
+
+    def Where(self, arg):
+        """ Alias for where clause
+            @param arg SQL expression object or string
+        """
+        self.proxy = self.proxy.where(arg)
+
+    def From(self, arg):
+        """ Alias for select_from clause
+            @param arg Table or table('tablename') or join clause
+        """
+        self.proxy = self.proxy.select_from(arg)
+
+    def Update(self):
+        self.proxy = self.table.update()
+
+    def Insert(self):
+        self.proxy = self.table.insert()
+
+    def Delete(self):
+        self.proxy = self.proxy.delete()
+
+    def Value(self, arg):
+        """
+        Allow you to specifies the VALUES or SET clause of the statement.
+        @param arg: VALUES or SET clause
+        """
+        self.proxy = self.proxy.values(arg)
+
+    def Execute(self, bindedparam):
+        """
+        Execute the sql query constructed in the proxy and return the result.
+        If no query then return False.
+        @return: query result on success else False
+        """
+        if(self.proxy.__str__().split() == 'SELECT'):
+            if('bindparam' in self.proxy.__str__()):
+                #on test separement la présence de la clause bindparam et le type de l'argument correspondant
+                #car si la clause est présente mais que l'argument est defectueux on doit renvoyer False et non pas executer la requete
+                if(type(bindedparam) is list and type(bindedparam[0]) is dict):
+                    return self.sqlwrapper.rconn.execute(self.proxy, bindedparam)
+                else:
+                    return False
+            else:
+                return self.sqlwrapper.rconn.execute(self.proxy)
+        elif(self.proxy is not None):
+            if('bindparam' in self.proxy.__str__()):
+                if(type(bindedparam) is list and type(bindedparam[0]) is dict):
+                    return self.sqlwrapper.wconn.execute(self.proxy, bindedparam)
+                else:
+                    return False
+            else:
+                return self.sqlwrapper.wconn.execute(self.proxy)
+        else:
+            return False
+
+
+

Database/sqlsetup.py

@@ -1,11 +1,12 @@
 # -*- coding: utf-8 -*-
 
 from Database.sqlwrapper import SqlWrapper
+import sqlalchemy as sql
 
 class SQLSetup(object): 
 
-    def initDb(self, dbconfname = 'default'):
-        db = SqlWrapper(read_db = dbconfname, write_db = dbconfname)
+    def initDb(self, dbconfname = 'default', alchemy_logs=None):
+        db = SqlWrapper(read_db = dbconfname, write_db = dbconfname, alchemy_logs=alchemy_logs)
         tables = self.get_schema()
         db.dropAll()
         db.createAllFromConf(tables)
@@ -14,13 +15,13 @@ 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"},
             {"name":"rank",         "type":"INTEGER"},
-            {"name":"date_update",  "type":"DATE"},
-            {"name":"date_create",  "type":"DATE"}
+            {"name":"date_create",  "type":"DATETIME"},
+            {"name":"date_update",  "type":"DATETIME"},
         ]
 
         # Table listing all objects created by lodel, giving them an unique id
@@ -47,7 +48,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 +57,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 +66,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",   "type":"VARCHAR(50)", "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":True, "server_default": sql.text('NULL')}}, # if relational: type this field refer to
+            {"name":"rel_field_id",   "type":"INTEGER", "extra":{"foreignkey":"em_type.uid", "nullable":True, "server_default": sql.text('NULL')}}, # if relational: field that specify the rel_to_type_id
             {"name":"optional",       "type":"BOOLEAN"},
             {"name":"internal",       "type":"BOOLEAN"},
             {"name":"icon",           "type":"INTEGER"},
@@ -85,8 +86,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,12 +95,12 @@ 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":"date_update", "type":"DATE"},
-                {"name":"date_create", "type":"DATE"},
+                {"name":"class_id",    "type":"INTEGER", "extra":{"foreignkey":"em_class.uid"}},
+                {"name":"type_id",     "type":"INTEGER", "extra":{"foreignkey":"em_type.uid"}},
+                {"name":"date_create", "type":"DATETIME"},
+                {"name":"date_update", "type":"DATETIME"},
                 {"name":"history",     "type":"TEXT"}
             ]
         }
@@ -110,7 +111,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/sqlutils.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import logging as logger
+
+import sqlalchemy as sqla
+from django.conf import settings
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
+
+ENGINES = {'mysql': {
+				'driver': 'pymysql',
+				'encoding': 'utf8'
+			},
+			'postgresql': {
+				'driver': 'psycopg2',
+				'encoding': 'utf8',
+			},
+			'sqlite': {
+				'driver': 'pysqlite',
+				'encoding': 'utf8',
+			},
+}
+
+sqlcfg = settings.LODEL2SQLWRAPPER
+
+def getEngine(ename = 'default', sqlalogging = None):
+	""" Return a sqlalchemy engine
+		@param read bool: If True return the read engine, else 
+		return the write one
+		@return a sqlachemy engine instance
+
+		@todo Put the check on db config in SqlWrapper.checkConf()
+	"""
+	#Loading confs
+	cfg = sqlcfg['db'][ename]
+
+	edata = ENGINES[cfg['ENGINE']] #engine infos
+	conn_str = ""
+
+	if cfg['ENGINE'] == 'sqlite':
+		#Sqlite connection string
+		conn_str = '%s+%s:///%s'%( cfg['ENGINE'],
+			edata['driver'],
+			cfg['NAME'])
+	else:
+		#Mysql and Postgres connection string
+		user = cfg['USER']
+		user += (':'+cfg['PASSWORD'] if 'PASSWORD' in cfg else '')
+		
+		if 'HOST' not in cfg:
+			logger.info('Not HOST in configuration, using localhost')
+			host = 'localhost'
+		else:
+			host = cfg['HOST']
+
+		host += (':'+cfg['PORT'] if 'PORT' in cfg else '')
+
+		conn_str = '%s+%s://'%(cfg['ENGINE'], edata['driver'])
+		conn_str += '%s@%s/%s'%(user,host,cfg['NAME'])
+
+
+	ret = sqla.create_engine(conn_str, encoding=edata['encoding'], echo=sqlalogging)
+
+	logger.debug("Getting engine :"+str(ret))
+
+	return ret
+
+def meta(engine):
+		res = sqla.MetaData()
+		res.reflect(bind=engine)
+		return res

Database/sqlwrapper.py

@@ -1,13 +1,19 @@
 # -*- coding: utf-8 -*-
 import os
 import re
-import logging as logger
+import logging
 
 import sqlalchemy as sqla
+from sqlalchemy.ext.compiler import compiles
 from django.conf import settings
 
+from Database.sqlalter import *
+
 #Logger config
-logger.getLogger().setLevel('DEBUG')
+#logger.getLogger().setLevel('WARNING')
+logger = logging.getLogger('lodel2.Database.sqlwrapper')
+logger.setLevel('WARNING')
+logger.propagate = False
 #To be able to use dango confs
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
 
@@ -38,26 +44,32 @@ class SqlWrapper(object):
     ##Wrapper instance list
     wrapinstance = dict()
 
-    def __init__(self, name="default", alchemy_logs=None, read_db = "default", write_db = "default"):
+    def __init__(self, name=None, alchemy_logs=None, read_db = "default", write_db = "default"):
         """ Instanciate a new SqlWrapper
             @param name str: The wrapper name
             @param alchemy_logs bool: If true activate sqlalchemy logger
             @param read_db str: The name of the db conf
             @param write_db str: The name of the db conf
+
+            @todo Better use of name (should use self.cfg['wrapper'][name] to get engines configs
+            @todo Is it a really good idea to store instance in class scope ? Maybe not !!
         """
         
         self.sqlalogging = False if alchemy_logs == None else bool(alchemy_logs)
 
-        self.name = name
+        if name == None:
+            self.name = read_db+'+'+write_db
+        else:
+            self.name = name
     
         self.r_dbconf = read_db
         self.w_dbconf = write_db
 
-        self.checkConf() #raise if errors in configuration
+        self._checkConf() #raise if errors in configuration
 
-        if name in self.__class__.wrapinstance:
-            logger.warning("A SqlWrapper with the name "+name+" allready exist. Replacing the old one by the new one")
-        SqlWrapper.wrapinstance[name] = self
+        if self.name in self.__class__.wrapinstance:
+            logger.warning("A SqlWrapper with the name "+self.name+" allready exist. Replacing the old one by the new one")
+        SqlWrapper.wrapinstance[self.name] = self
 
         #Engine and wrapper initialisation
         self.r_engine = self._getEngine(True, self.sqlalogging)
@@ -66,33 +78,53 @@ class SqlWrapper(object):
         self.w_conn = None
 
 
-        self.meta = None #TODO : use it to load all db schema in 1 request and don't load it each table instanciation
+        self.metadata = None #TODO : use it to load all db schema in 1 request and don't load it each table instanciation
         self.meta_crea = None
+
+        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 """
+        return self.__class__.config;
     @property
-    def cfg(self): return self.__class__.config;
+    def _engines_cfg(self):
+        return self.__class__.ENGINES;
+
     @property
-    def engines_cfg(self): return self.__class__.ENGINES;
+    def meta(self):
+        if self.metadata == None:
+            self.renewMetaData()
+        return self.metadata
+
+    def renewMetaData(self):
+        """ (Re)load the database schema """
+        self.metadata = sqla.MetaData(bind=self.r_engine)
+        self.metadata.reflect()
 
     @property
     def rconn(self):
         """ Return the read connection
             @warning Do not store the connection, call this method each time you need it
         """
-        return self.getConnection(True)
+        return self._getConnection(True)
     @property
     def wconn(self):
         """ Return the write connection
             @warning Do not store the connection, call this method each time you need it
         """
-        return self.getConnection(False)
+        return self._getConnection(False)
 
-
-    def getConnection(self, read):
+    def _getConnection(self, read):
         """ Return an opened connection
             @param read bool: If true return the reading connection
             @return A sqlAlchemy db connection
+            @private
         """
         if read:
             r = self.r_conn
@@ -102,7 +134,7 @@ class SqlWrapper(object):
         if r == None:
             #Connection not yet opened
             self.connect(read)
-            r = self.getConnection(read) #TODO : Un truc plus safe/propre qu'un appel reccursif ?
+            r = self._getConnection(read) #TODO : Un truc plus safe/propre qu'un appel reccursif ?
         return r
 
 
@@ -129,11 +161,17 @@ class SqlWrapper(object):
             @return None
         """
         if read or read == None:
-            self.r_conn.close()
+            if self.r_conn == None:
+                logger.info('Unable to close read connection : connection not opened')
+            else:
+                self.r_conn.close()
             self.r_conn = None
 
         if not read or read == None:
-            self.w_conn.close()
+            if self.r_conn == None:
+                logger.info('Unable to close write connection : connection not opened')
+            else:
+                self.w_conn.close()
             self.w_conn = None
 
     def reconnect(self, read = None):
@@ -146,6 +184,9 @@ class SqlWrapper(object):
 
     @classmethod
     def reconnectAll(c, read = None):
+        """ Reconnect all the wrappers 
+            @static
+        """
         for wname in c.wrapinstance:
             c.wrapinstance[wname].reconnect(read)
             
@@ -156,7 +197,8 @@ class SqlWrapper(object):
         """
         if not isinstance(tname, str):
             return TypeError('Excepting a <class str> but got a '+str(type(tname)))
-        return sqla.Table(tname, sqla.MetaData(), autoload_with=self.r_engine, autoload=True)
+        #return sqla.Table(tname, self.meta, autoload_with=self.r_engine, autoload=True)
+        return sqla.Table(tname, self.meta)
 
     def _getEngine(self, read=True, sqlalogging = None):
         """ Return a sqlalchemy engine
@@ -169,7 +211,7 @@ class SqlWrapper(object):
         #Loading confs
         cfg = self.cfg['db'][self.r_dbconf if read else self.w_dbconf]
 
-        edata = self.engines_cfg[cfg['ENGINE']] #engine infos
+        edata = self._engines_cfg[cfg['ENGINE']] #engine infos
         conn_str = ""
 
         if cfg['ENGINE'] == 'sqlite':
@@ -194,7 +236,11 @@ class SqlWrapper(object):
             conn_str += '%s@%s/%s'%(user,host,cfg['NAME'])
 
 
-        return sqla.create_engine(conn_str, encoding=edata['encoding'], echo=self.sqlalogging)
+        ret = sqla.create_engine(conn_str, encoding=edata['encoding'], echo=self.sqlalogging)
+
+        logger.debug("Getting engine :"+str(ret))
+
+        return ret
 
     @classmethod
     def getWrapper(c, name):
@@ -208,7 +254,7 @@ class SqlWrapper(object):
             raise KeyError("No wrapper named '"+name+"' exists")
         return c.wrapinstance[name]
 
-    def checkConf(self):
+    def _checkConf(self):
         """ Class method that check the configuration
             
             Configuration looks like
@@ -232,13 +278,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+'"')
                         
@@ -253,7 +296,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
 
@@ -264,11 +308,16 @@ class SqlWrapper(object):
         """
         self.meta_crea = sqla.MetaData()
 
+        logger.info("Running function createAllFromConf")
         for i,table in enumerate(schema):
+            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(self.w_engine)
+        
+        self.meta_crea.create_all(bind = self.w_engine)
+        logger.info("All tables created")
         self.meta_crea = None
+        self.renewMetaData()
         pass
             
     def createTable(self, name, columns, **kw):
@@ -288,12 +337,16 @@ 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")
 
         pass
 
@@ -306,12 +359,13 @@ class SqlWrapper(object):
                 - extra : a dict like { "primarykey":True, "nullable":False, "default":"test"...}
             @param **kwargs 
         """
-        if not 'name' in kwargs or not 'type' in kwargs:
+        if not 'name' in kwargs or ('type' not in kwargs and 'type_' not in kwargs):
             pass#ERROR
 
         #Converting parameters
-        kwargs['type_'] = self._strToSqlAType(kwargs['type'])
-        del kwargs['type']
+        if 'type_' not in kwargs and 'type' in kwargs:
+            kwargs['type_'] = self._strToSqlAType(kwargs['type'])
+            del kwargs['type']
 
         if 'extra' in kwargs:
             #put the extra keys in kwargs
@@ -331,13 +385,12 @@ class SqlWrapper(object):
             kwargs['primary_key'] = kwargs['primarykey']
             del kwargs['primarykey']
 
-
-        logger.debug('Column creation arguments : '+str(kwargs))
         res = sqla.Column(**kwargs)
 
         if fk != None:
             res.append_foreign_key(fk)
 
+        #logger.debug("Column '"+kwargs['name']+"' created")
         return res
     
     def _strToSqlAType(self, strtype):
@@ -357,6 +410,86 @@ class SqlWrapper(object):
         check_length = re.search(re.compile('VARCHAR\(([\d]+)\)', re.IGNORECASE), vstr)
         column_length = int(check_length.groups()[0]) if check_length else None
         return sqla.VARCHAR(length=column_length)
-        
+     
 
+    def dropColumn(self, tname, colname):
+        """ Drop a column from a table
+            @param tname str|sqlalchemy.Table: The table name or a Table object
+            @param colname str|sqlalchemy.Column: The column name or a column object
+            @return None
+        """
+        if tname not in self.meta.tables: #Useless ?
+            raise NameError("The table '"+tname+"' dont exist")
+        table = self.Table(tname)
+        col = sqla.Column(colname)
+
+        ddl = DropColumn(table, col)
+        sql = ddl.compile(dialect=self.w_engine.dialect)
+        sql = str(sql)
+        logger.debug("Executing SQL  : '"+sql+"'")
+        ret = bool(self.w_engine.execute(sql))
+
+        self.renewMetaData()
+        return ret
+
+    
+    def addColumn(self, tname, colname, coltype):
+        """ Add a column to a table
+            @param tname str: The table name
+            @param colname str: The column name
+            @param coltype str: The new column type
+
+            @return True if query success False if it fails
+        """
+        if tname not in self.meta.tables: #Useless ?
+            raise NameError("The table '"+tname+"' dont exist")
+        table = self.Table(tname)
+        newcol = self.createColumn(name=colname, type_ = coltype)
+
+        ddl = AddColumn(table, newcol)
+        sql = ddl.compile(dialect=self.w_engine.dialect)
+        sql = str(sql)
+        logger.debug("Executing SQL  : '"+sql+"'")
+        ret = bool(self.wconn.execute(sql))
+
+        self.renewMetaData()
+        return ret
+
+    def alterColumn(self, tname, colname, col_newtype):
+        """ Change the type of a column
+            @param tname str: The table name
+            @param colname str: The column name
+            @param col_newtype str: The column new type
+
+            @return True if query successs False if it fails
+        """
+        
+        if tname not in self.meta.tables: #Useless ?
+            raise NameError("The table '"+tname+"' dont exist")
+
+        col = self.createColumn(name=colname, type_=col_newtype)
+        table = self.Table(tname)
+
+        ddl = AlterColumn(table, newcol)
+        sql = ddl.compile(dialect=self.w_engine.dialect)
+        sql = str(sql)
+        logger.debug("Executing SQL  : '"+sql+"'")
+        ret = bool(self.wconn.execute(sql))
+
+        self.renewMetaData()
+        return ret
+
+    def _debug__printSchema(self):
+        """ Debug function to print the db schema """
+        print(self.meta)
+        for tname in self.meta.tables:
+            self._debug__printTable(tname)
+
+    def _debug__printTable(self, tname):
+        t = self.meta.tables[tname]
+        tstr = 'Table : "'+tname+'" :\n'
+        for c in t.c:
+            tstr += '\t\t"'+c.name+'"('+str(c.type)+') \n'
+        print(tstr)
+            
 

Database/test/test_sqlwrapper.py

@@ -1,519 +0,0 @@
-import os
-import logging
-import random
-
-from unittest import TestCase
-from unittest.mock import MagicMock, Mock, patch, call
-import unittest
-
-import sqlalchemy
-from Database.sqlwrapper import SqlWrapper
-
-from django.conf import settings
-from Database.sqlsettings import SQLSettings
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
-
-BADNAMES = ['',  "  \t  ", "bad--", "%", "*", "`", '"', "'", "\0", "hello`World", 'Hello"world', 'foo%', '*bar.*', '%%', "hello\0world", print, 42 ]
-
-for c in ('*','%','`', "'", '"', "\\"):
-    for _ in range(16):
-        c = "\\"+c
-        BADNAMES.append(c)
-BADNAMES+=[chr(i) for i in list(range(0,0x09))+[0x0b, 0x0c]+list(range(0x0e, 0x01f))]
-
-class SqlWrapperTests(TestCase):
-
-    def setUp(self):
-        #Overwriting database conf
-        SQLSettings.DB_READ_CONNECTION_NAME = 'testdb'
-        SQLSettings.DB_WRITE_CONNECTION_NAME = 'testdb'
-        
-
-        self.testdb = os.path.join('/tmp/', 'lodel2_testdb.sqlite3')
-
-        settings.DATABASES['testdb'] = {
-            'ENGINE': 'sqlite',
-            'NAME': self.testdb,
-        }
-        #Disable logging but CRITICAL
-        logging.basicConfig(level=logging.CRITICAL)
-        pass
-
-    def tearDown(self):
-        try:
-            os.unlink(self.testdb) #Removing the test database
-        except FileNotFoundError: pass
-    
-    """ Testing standart instanciation of sqlwrapper """
-    def test_init_sqlwrapper(self):
-        sw = SqlWrapper()
-        self.assertIsInstance(sw, SqlWrapper)
-        sw2 = SqlWrapper()
-        self.assertIsInstance(sw2, SqlWrapper)
-
-    def test_get_engine(self):
-        sw = SqlWrapper()
-        engine = sw.get_engine(SQLSettings.DB_READ_CONNECTION_NAME)
-        self.assertIsInstance(engine, sqlalchemy.engine.base.Engine)
-    
-    def test_get_engine_badargs(self):
-        sw = SqlWrapper()
-        with self.assertRaises(Exception):
-            sw.get_engine(0)
-        with self.assertRaises(Exception):
-            sw.get_engine('')
-        with self.assertRaises(Exception):
-            sw.get_engine('           ')
-
-    
-    @patch.object(SqlWrapper, 'get_read_engine')
-    def test_execute_queries(self, mock_read):
-        queries = [ 'SELECT * FROM foo', 'SELECT * FROM bar', 'SELECT foo.id, bar.id FROM foo, bar WHERE foo.id = 42 AND bar.name = \'hello world !\'' ]
-
-        mock_read.return_value = MagicMock()
-        mock_engine = mock_read.return_value
-        mock_engine.connect.return_value = MagicMock()
-        mock_conn = mock_engine.connect.return_value
-        sw = SqlWrapper()
-
-        #One query execution
-        sw.execute(queries[0], 'read')
-        mock_conn.execute.assert_called_with(queries[0])
-        mock_conn.reset_mock()
-
-        #multiple queries execution
-        sw.execute(queries, 'read')
-
-        except_calls = [ call(q) for q in queries ]
-        self.assertEqual(except_calls, mock_conn.execute.mock_calls)
-
-    @patch.object(sqlalchemy.ForeignKeyConstraint, '__init__')
-    def test_create_fk_constraint_mock(self, mock_fk):
-        mock_fk.return_value = None
-
-        sw = SqlWrapper()
-        sw.create_foreign_key_constraint_object('foo','bar', 'foobar')
-        mock_fk.asser_called_with(['foo'], ['bar'], 'foobar')
-
-    def test_create_fk_constraint(self):
-        sw = SqlWrapper()
-        fk = sw.create_foreign_key_constraint_object('foo', 'bar', 'foobar')
-        self.assertIsInstance(fk, sqlalchemy.ForeignKeyConstraint)
-        
-    @unittest.skip('Dev') #TODO remove it
-    def test_create_fk_constraint_badargs(self):
-        sw = SqlWrapper()
-
-        
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(['foo', 'bar'], 'foofoo', 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('bar', 2, 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(None, 'foo', 'bar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('bar', None, 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(None, None, 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(print, 'foo', 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('foo', print, 'babar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('foo', 'bar', print)
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('bar', 'foo', 42)
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('bar', 'foo', '   ')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(" \t  ", 'foo')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('bar', 'foo', "  \t ")
-
-        foocol = sqlalchemy.Column('foo',sqlalchemy.INTEGER)
-
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(foocol, foocol)
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object(foocol, 'bar')
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('foo', foocol)
-        with self.assertRaises(Exception):
-            sw.create_foreign_key_constraint_object('foo', 'bar', foocol)
-    
-    @patch.object(sqlalchemy.Column, '__init__')
-    def test_create_column(self, mockcol):
-        mockcol.return_value = None
-        sw = SqlWrapper()
-        foo = sw.create_column_object('foo', 'INTEGER')
-        mockcol.assert_called_once_with('foo', sqlalchemy.INTEGER)
-        mockcol.reset_mock()
-
-        foo = sw.create_column_object('foo', 'VARCHAR(50)')
-        self.assertEqual(mockcol.call_args[0][0], 'foo')
-        self.assertIsInstance(mockcol.call_args[0][1], sqlalchemy.VARCHAR)
-        self.assertEqual(mockcol.call_args[0][1].length, 50)
-        mockcol.reset_mock()
-
-        foo = sw.create_column_object('foo', 'TEXT')
-        mockcol.assert_called_once_with('foo', sqlalchemy.TEXT)
-        mockcol.reset_mock()
-
-        foo = sw.create_column_object('foo', 'DATE')
-        mockcol.assert_called_once_with('foo', sqlalchemy.DATE)
-        mockcol.reset_mock()
-
-        foo = sw.create_column_object('foo', 'BOOLEAN')
-        mockcol.assert_called_once_with('foo', sqlalchemy.BOOLEAN)
-        mockcol.reset_mock()
- 
-        xtrmlongname = ''
-        for _ in range(200):
-            xtrmlongname += 'veryvery'
-        xtrmlongname += 'longname'
-
-        foo = sw.create_column_object(xtrmlongname, 'TEXT')
-        mockcol.assert_called_once_with(xtrmlongname, sqlalchemy.TEXT)
-        mockcol.reset_mock()
-
-    def test_create_column_extra_fk(self):
-        sw = SqlWrapper()
-
-        extra = { 'foreignkey': 'bar' }
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol, sqlalchemy.Column)
-        fk = rescol.foreign_keys.pop()
-        self.assertIsInstance(fk, sqlalchemy.ForeignKey)
-        self.assertEqual(fk._colspec, 'bar')
-
-    def test_create_column_extra_default(self):
-        sw = SqlWrapper()
-
-
-        extra = { 'default': None, 'nullable': True }
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, None)
-
-        extra = { 'default': "NULL", 'nullable': True }
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, "NULL")
-
-        extra = { 'default': 'null', 'nullable': True }
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 'null')
-
-        extra = { 'default': 42 }
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 42)
-
-        extra = { 'default': 'foobardefault' }
-        rescol = sw.create_column_object('foo', 'VARCHAR(50)', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 'foobardefault')
-
-        extra = { 'default': 'foodefault' }
-        rescol = sw.create_column_object('foo', 'TEXT', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 'foodefault')
-
-        extra = { 'default': True }
-        rescol = sw.create_column_object('foo', 'BOOLEAN', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, True)
-
-        extra = { 'default': False }
-        rescol = sw.create_column_object('foo', 'BOOLEAN', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, False)
-
-        extra = { 'default': "true" }
-        rescol = sw.create_column_object('foo', 'BOOLEAN', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, "true")
-
-        extra = { 'default': 0 }
-        rescol = sw.create_column_object('foo', 'BOOLEAN', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 0)
-
-        extra = { 'default': 1 }
-        rescol = sw.create_column_object('foo', 'BOOLEAN', extra)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 1)
-
-
-    def test_create_column_extra_pknull(self):
-        sw = SqlWrapper()
-
-        for b in (True,False):
-            extra = { 'primarykey': b }
-            rescol = sw.create_column_object('foo', 'INTEGER', extra)
-            self.assertIsInstance(rescol, sqlalchemy.Column)
-            self.assertEqual(rescol.primary_key, b)
-
-            extra = { 'nullable': b }
-            rescol = sw.create_column_object('foo', 'INTEGER', extra)
-            self.assertIsInstance(rescol, sqlalchemy.Column)
-            self.assertEqual(rescol.nullable, b)
-
-            extra = { 'primarykey' : b, 'nullable': not b }
-            rescol = sw.create_column_object('foo', 'INTEGER', extra)
-            self.assertIsInstance(rescol, sqlalchemy.Column)
-            self.assertEqual(rescol.primary_key, b)
-            self.assertEqual(rescol.nullable, not b)
-
-            extra = { 'primarykey' : b, 'nullable': b }
-            rescol = sw.create_column_object('foo', 'INTEGER', extra)
-            self.assertIsInstance(rescol, sqlalchemy.Column)
-            self.assertEqual(rescol.primary_key, b)
-            self.assertEqual(rescol.nullable, b)
-
-
-
-    def test_create_column_extra_all(self):
-        sw = SqlWrapper()
-
-        extra = { 'primarykey': False, 'nullable': False, 'default':42, 'foreignkey': 'foobar'}
-        rescol = sw.create_column_object('foo', 'INTEGER', extra)
-        self.assertIsInstance(rescol, sqlalchemy.Column)
-        self.assertEqual(rescol.primary_key, False)
-        self.assertEqual(rescol.nullable, False)
-        self.assertIsInstance(rescol.default, sqlalchemy.ColumnDefault)
-        self.assertEqual(rescol.default.arg, 42)
-        fk = rescol.foreign_keys.pop()
-        self.assertIsInstance(fk, sqlalchemy.ForeignKey)
-        self.assertEqual(fk._colspec, 'foobar')
-
-    @unittest.skip('Dev') #TODO remove it
-    def test_create_column_badargs(self):
-        sw = SqlWrapper()
-        
-        cc = sw.create_column_object
-        ain = self.assertIsNone
-        
-        for bname in BADNAMES:
-            ain(cc(bname, 'INTEGER'))
-
-        ain(cc('c', 'INNNTEGER'))
-        ain(cc(" \t\t  ", 'TEXT'))
-        ain(cc('c', '             '))
-        ain(cc('c', 'VARCHAR(foo)'))
-        ain(cc('supercol', 'SUPERNOTTYPEDVARCHARSTR'))
-
-        ain(cc('c', None))
-        ain(cc(None, None))
-
-    @unittest.skip('Dev') #TODO remove it
-    def test_create_column_badextra(self):
-        sw = SqlWrapper()
-
-        cc = sw.create_column_object
-        ain = self.assertIsNone
-        
-        #Put junk in extra datas
-        for xtra_name in [ 'primarykey', 'nullable', 'foreignkey' ]:
-            for junk in [ print, sqlalchemy, SqlWrapper, '   ' ]+BADNAMES:
-                ain(cc('c', 'TEXT', { xtra_name: junk }))
-
-        for junk in [True, False, 52, '   ']+BADNAMES:
-            ain(cc('c', 'TEXT', { 'foreignkey': junk }))
-
-        for xtra_name in ('primarykey', 'nullalble'):
-            for junk in [4096, 'HELLO WORLD !', '   ']+BADNAMES:
-                ain(cc('c', 'TEXT', { xtra_name, junk } ))
-
-    @patch.object(sqlalchemy.Table, '__init__')
-    def test_create_table(self, mock_table):
-        #TODO check constraints
-        """ Create tables and check that the names are ok """
-        mock_table.return_value = None
-        sw = SqlWrapper()
-        
-        cols = [
-            { 'name': 'supercol', 'type': 'INTEGER', 'extra': { 'nullable': True } },
-            { 'name': 'superpk', 'type': 'INTEGER', 'extra': { 'primarykey': True} },
-            { 'name': 'col2', 'type': 'TEXT' }
-        ]
-        
-        for table_name in ['supertable', 'besttableever', 'foo-table']:
-
-            params = { 'name': table_name, 'columns': cols, 'constraints':dict() }
-
-            self.assertTrue(sw.create_table(params))
-            self.assertEqual(mock_table.call_args[0][0], table_name)
-        pass
-    
-    @patch.object(sqlalchemy.Table, 'append_column')
-    def test_create_table_col(self, mock_append):
-        #TODO check constraints
-        """ Create a table and check that the columns are OK """
-        sw = SqlWrapper()
-        
-        table_name = 'supertablecol'
-
-        cols = [
-            { 'name': 'supercol', 'type': 'INTEGER', 'extra': { 'nullable': True } },
-            { 'name': 'superpk', 'type': 'INTEGER', 'extra': { 'primarykey': True} },
-            { 'name': 'col2', 'type': 'TEXT' }
-        ]
-
-        except_coltype = [ sqlalchemy.INTEGER, sqlalchemy.INTEGER, sqlalchemy.TEXT ]
-
-        params = { 'name': table_name, 'columns': cols, 'constraints':dict() }
-    
-        sw.create_table(params) #This call return false because of the mock on append_column
-        
-        self.assertEqual(len(mock_append.mock_calls), len(cols))
-
-        for n,c in enumerate(mock_append.mock_calls):
-            self.assertEqual(c[1][0].name, cols[n]['name'])
-            self.assertIsInstance(c[1][0].type, except_coltype[n])
-        pass
-    
-    def test_create_table_recreate(self):
-        #TODO check constraints
-        """ Try to create the same table 2 times (except a False return the second time) """
-        sw = SqlWrapper()
-
-        params = { 'name': 'redondant', 'columns': [{'name':'foocol', 'type': 'INTEGER'}]}
-
-        self.assertTrue(sw.create_table(params))
-
-        params['columns'] = [{'name':'barcol', 'type': 'INTEGER'}]
-
-        self.assertFalse(sw.create_table(params))
-
-    @unittest.skip('dev') #TODO remove it
-    def test_create_table_badargs(self):
-        sw = SqlWrapper()
-
-        af = self.assertFalse
-        ct = sw.create_table
-
-        foocol = {'name': 'foocol', 'type': 'INTEGER'}
-
-        p = {'name': 'foo'}
-        af(ct(p)) #no columns
-        for bname in BADNAMES: #bad column name
-            p['columns'] = bname
-            af(ct(p))
-        p['columns']=[]; af(ct(p)) #empty columns TODO Or return True is normal ???
-
-
-        p = {'columns':[foocol]}
-        af(ct(p)) #no name
-        for bname in BADNAMES:
-            p['name'] = bname
-            af(ct(p))
-        pass
-
-    
-    def create_test_table(self, sw):
-        """ Create a table for test purpose """
-        table_name = 'testtable'
-        cols = [
-            { 'name': 'pk', 'type': 'INTEGER', 'extra': {'primarykey': True} },
-            { 'name': 'testtxt', 'type': 'TEXT', 'extra': {'nullable': True, 'default': 'hello'} },
-            { 'name': 'testchr', 'type': 'VARCHAR(50)', 'extra': {'nullable': True, 'default': 'hello world'} },
-        ]
-        
-        sw.create_table( { 'name': table_name, 'columns': cols} )
-        pass
-    
-    def test_get_table(self):
-        """ Try to get the testtable (check the name and type of return) """
-        sw = SqlWrapper()
-
-        self.create_test_table(sw)
-
-        rt = sw.get_table('testtable')
-        self.assertIsInstance(rt, sqlalchemy.Table)
-        self.assertEqual(rt.name, 'testtable')
-
-        rt = sw.get_table('testtable', 'write')
-        self.assertIsInstance(rt, sqlalchemy.Table)
-        self.assertEqual(rt.name, 'testtable')
-
-        rt = sw.get_table('testtable', 'read')
-        self.assertIsInstance(rt, sqlalchemy.Table)
-        self.assertEqual(rt.name, 'testtable')
-        pass
-
-    @unittest.skip('dev') #TODO remove skip
-    def test_get_table_badargs(self):
-        sw = SqlWrapper()
-
-        self.create_test_table(sw)
-
-        for badname in BADNAMES:
-            with self.assertRaises((sqlalchemy.exc.NoSuchTableError, Exception)):
-                sw.get_table(badname)
-
-        with self.assertRaises(sqlalchemy.exc.NoSuchTableError):
-            sw.get_table('FOOBAR')
-        with self.assertRaises(Exception):
-            sw.get_table(print)
-        with self.assertRaises(Exception):
-            sw.get_table(1)
-
-        #bad action types
-        with self.assertRaises(Exception):
-            sw.get_table('testtable', print)
-        with self.assertRaises(Exception):
-            sw.get_table('testtable', 'foobar')
-        with self.assertRaises(Exception):
-            sw.get_table('testtable', 42)
-        pass
-
-    def test_drop_table(self):
-        sw = SqlWrapper()
-        
-        self.create_test_table(sw)
-
-        self.assertTrue(sw.drop_table('testtable'))
-        self.assertFalse(sw.drop_table('testtable'))
-        self.assertFalse(sw.drop_table('nonexisting'))
-        pass
-
-    def test_drop_table_badargs(self):
-        sw = SqlWrapper()
-
-        self.create_test_table(sw)
-
-        af = self.assertFalse
-
-        for bname in BADNAMES:
-            self.assertFalse(sw.drop_table(bname))
-
-    def test_create_get_drop_table(self):
-        sw = SqlWrapper()
-        
-        funkynames = ('standart', "wow-nice", "-really-", "test_test-test", "_test", "test_", "test42", "foobar_123", "foobar-123", "foofoo--babar")
-        types = ['INTEGER', 'VARCHAR(5)', 'VARCHAR(128)', 'TEXT', 'BOOLEAN']
-        params = dict()
-
-        cols = []
-        for i,name in enumerate(funkynames):
-            cols.append({'name':name, 'type':types[i%len(types)]})
-        params['columns'] = cols
-
-
-        for name in random.sample(funkynames, len(funkynames)):
-            params['name'] = name
-            self.assertTrue(sw.create_table(params))
-
-        for name in random.sample(funkynames, len(funkynames)):
-            rt = sw.get_table(name)
-            self.assertIsInstance(rt, sqlalchemy.Table)#do we get a table ?
-            self.assertEqual(rt.name, name)
-
-        for name in random.sample(funkynames, len(funkynames)):
-            self.assertTrue(sw.drop_table(name))
-        pass
-        
-

Database/test/test_sqlwrapper_querystring.py

@@ -1,175 +0,0 @@
-import os
-import logging
-import random
-
-from unittest import TestCase
-import unittest
-
-from Database.sqlwrapper import SqlWrapper
-
-from django.conf import settings
-from Database.sqlsettings import SQLSettings
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
-
-#Bad strings for injection tests
-INJECTIONS = [ 'foo UNION SELECT 1,2,3,4--', "foo' UNION SELECT 1,2,3--", 'foo" UNION SELECT 1,2,3--', 'foo` UNION SELECT 1,2,3,4--', '--', 'foo`; SELECT 1,2,3', 'foo"; SELECT 1,2,3', "foo'; SELECT 1,2,3", "; SELECT 1,2,3" ]
-NAMEINJECT = INJECTIONS + [ '%', '*', "\0", "\b\b\b\b\b\b\b\b\b" ]
-
-#Valid SQL types
-VTYPES = [ 'integer', 'varchar(1)', 'varchar(50)', 'text', 'boolean' ]
-
-class SqlWrapperQueryStrTests(TestCase):
-    
-    def setUp(self):
-        #creating a test table
-        sw = SqlWrapper()
-        self.ttn = 'testtable'
-        self.cols = [
-            { 'name': 'pk', 'type': 'INTEGER', 'extra': {'primarykey': True} },
-            { 'name': 'testtxt', 'type': 'TEXT', 'extra': {'nullable': True, 'default': 'hello'} },
-            { 'name': 'testchr', 'type': 'VARCHAR(50)', 'extra': {'nullable': True, 'default': 'hello world'} },
-            { 'name': 'testbool', 'type': 'BOOLEAN', 'extra': {'nullable':False, 'default': False}},
-        ]
-        
-        sw.create_table( { 'name': self.ttn, 'columns': self.cols} )
-
-
-        #Disable logging but CRITICAL
-        logging.basicConfig(level=logging.CRITICAL)
-        pass
-
-    def tearDown(self):
-        sw = SqlWrapper()
-        sw.drop_table(self.ttn)
-
-    @unittest.skip('dev') #TODO remove skip
-    def test_get_querystring(self):
-        sw = SqlWrapper()
-
-        actions = [ 'add_column', 'alter_column', 'drop_column' ]
-        dialects = [ 'default', 'mysql', 'postgresql' ]
-
-        for action in actions:
-            for dialect in dialects:
-                r = sw.get_querystring(action, dialect)
-                self.assertIsInstance(r, str)
-
-    @unittest.skip('dev') #TODO remove skip
-    def test_get_querystring_badargs(self):
-        sw = SqlWrapper()
-        
-        actions = [ 1, -1, print, [], 'foo']
-        dialects = actions
-        for action in actions:
-            for dialect in dialects:
-                with self.assertRaises(ValueError):
-                    r = sw.get_querystring(action, dialect)
-    
-    @unittest.skip('dev') #TODO remove skip
-    def test_add_column(self):
-        sw = SqlWrapper()
-
-        colnames = [ 'taddcol1', 'test-add-col', 'test_add_col', '-test', '_add', '__col__' ]
-
-        for i, name in enumerate(colnames):
-            col = { 'name': name, 'type': VTYPES[i%len(VTYPES)] }
-            self.assertTrue(sw.add_column(self.ttn, col))
-        pass
-
-    @unittest.skip('dev') #TODO remove skip
-    def test_add_column_badargs(self):
-        sw = SqlWrapper()
-
-        coolname = 'cool'
-        i=0
-        self.assertFalse(sw.add_column(self.ttn, {'type': 'INTEGER'}))
-        self.assertFalse(sw.add_column(self.ttn, {'name': 'foo'}))
-        self.assertFalse(sw.add_column(self.ttn, dict()))
-        self.assertFalse(sw.add_column(self.ttn, print))
-        self.assertFalse(sw.add_column(self.ttn, ['foo', 'integer']))
-        self.assertFalse(sw.add_column(self.ttn, None))
-        self.assertFalse(sw.add_column(self.ttn, 42))
-        self.assertFalse(sw.add_column(1, {'name':'foo', 'type':'integer'}))
-        self.assertFalse(sw.add_column(print, {'name':'foo', 'type':'integer'}))
-        self.assertFalse(sw.add_column([], {'name':'foo', 'type':'integer'}))
-        self.assertFalse(sw.add_column(dict(), {'name':'foo', 'type':'integer'}))
-        for badname in NAMEINJECT:
-            self.assertFalse(sw.add_column(self.ttn, {'name':badname, 'type':'INTEGER'}))
-            self.assertFalse(sw.add_column(self.ttn, {'name':coolname+str(i), 'type':badname}))
-            self.assertFalse(sw.add_column(badname, {'name':coolname+str(i), 'type':'INTEGER'}))
-            i+=1
-        
-    @unittest.skip('dev') #TODO remove skip
-    def test_alter_column(self):
-        sw = SqlWrapper()
-
-        colnames = ['talter', 'talter1', 'test_alter', 'test-alter-col', '-test_alter', '__test_alter__']
-        for i,name in enumerate(random.sample(colnames, len(colnames))):
-            col = { 'name': name, 'type': VTYPES[i%len(VTYPES)] }
-            self.assertTrue(sw.add_column( self.ttn, col))
-
-        for i,name in enumerate(random.sample(colnames, len(colnames))):
-            col = {'name': name, 'type': VTYPES[i%len(VTYPES)]}
-            self.assertTrue(self.ttn, col)
-        pass
-
-    @unittest.skip('dev') #TODO remove skip
-    def test_alter_column_badargs(self):
-        sw = SqlWrapper()
-
-        colnames = ['tabad', 'tabad1']
-
-        for i,name in enumerate(colnames):
-            col = { 'name': name, 'type': VTYPES[i%len(VTYPES)] }
-            self.assertTrue(sw.add_column(self.ttn, col))
-
-        for i,badname in enumerate(NAMEINJECT):
-            col = { 'name': badname, 'type': VTYPES[i%len(VTYPES)] }
-            self.assertFalse(sw.alter_column(self.ttn, col))
-
-            col = { 'name': colnames[i%len(colnames)], 'type': badname}
-            self.assertFalse(sw.alter_column(self.ttn, col))
-
-            col = { 'name': badname, 'type': NAMEINJECT[random.randint(0,len(NAMEINJECT))]}
-            self.assertFalse(sw.alter_column(self.ttn, col))
-
-            col = { 'name': colnames[i%len(colnames)], 'type': VTYPES[i%len(VTYPES)] }
-            self.assertFalse(sw.alter_column(badname, col))
-
-    def test_insert(self):
-        sw = SqlWrapper()
-
-        records = [
-            {   'pk': 0,
-                'testchr': 'Hello world !',
-                'testtext': 'Wow ! Super text... I\'m amazed',
-                'testbool': False
-            },
-            {   'pk': 1,
-                'testchr': 'Hello"world...--',
-                'testtext': 'Another wonderfull text. But this time with spécials chars@;,:--*/+\'{}]{[|~&ù^$*µ$£ê;<ç>\/*-+',
-                'testbool': True
-            },
-            {   'pk': 2 }, #default values for others
-            {   'pk': '3',
-                'testchr': None,
-                'testtext': None,
-                'testbool': 'true'
-            },
-            {   'pk': 4,
-                'testchr': '',
-                'testtext': '',
-                'testbool': 'false'
-            },
-            {   'pk': 5,
-                'testbool': 0
-            },
-            {   'pk': 6,
-                'testbool': 1
-            },
-            {   'pk':1024,
-                'testbool': False
-            },
-        ]
-                

Database/tests.py

@@ -1,3 +0,0 @@
-from django.test import TestCase
-
-# Create your tests here.

EditorialModel/classes.py

@@ -5,11 +5,16 @@
     @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 import sqlutils
+import sqlalchemy as sql
+
 import EditorialModel
 
+
+
 class EmClass(EmComponent):
     table = 'em_class'
 
@@ -21,21 +26,39 @@ 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)
+            res = 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
+            res = c._createDb(name, class_type)
+            logger.debug("EmClass successfully created")
+
+        return res
+
+    @classmethod
+    def _createDb(c, name, class_type):
+        """ Do the db querys for EmClass::create() """
+
+        #Create a new entry in the em_class table
+        values = { 'name':name, 'classtype':class_type['name'] }
+        resclass = super(EmClass,c).create(values)
+
 
-            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)
+        dbe = c.getDbE()
+        conn = dbe.connect()
+
+        #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 resclass
 
-        return exists
 
     def populate(self):
         row = super(EmClass, self).populate()
@@ -60,16 +83,21 @@ class EmClass(EmComponent):
         @return field_groups [EmFieldGroup]:
     """
     def fieldgroups(self):
-        fieldgroups_req = SqlObject(EditorialModel.fieldgroups.EmFieldGroup.table)
-        select = fieldgroups_req.sel
-        select.where(fieldgroups_req.col.class_id == self.id)
-
-        sqlresult = fieldgroups_req.rexec(select)
-        records = sqlresult.fetchall()
+        records = self._fieldgroupsDb()
         fieldgroups = [ EditorialModel.fieldgroups.EmFieldGroup(int(record.uid)) for record in records ]
 
         return fieldgroups
 
+    def _fieldgroupsDb(self):
+        dbe = self.__class__.getDbE()
+        emfg = sql.Table(EditorialModel.fieldgroups.EmFieldGroup.table, sqlutils.meta(dbe))
+        req = emfg.select().where(emfg.c.class_id == self.id)
+        
+        conn = dbe.connect()
+        res = conn.execute(req)
+        return res.fetchall()
+
+
     """ retrieve list of fields
         @return fields [EmField]:
     """
@@ -80,16 +108,19 @@ class EmClass(EmComponent):
         @return types [EmType]:
     """
     def types(self):
-        emtype = SqlObject(EditorialModel.types.EmType.table)
-        select = emtype.sel
-        select.where(emtype.col.class_id == self.id)
-
-        sqlresult = emtype.rexec(select)
-        records = sqlresult.fetchall()
+        records = self._typesDb()
         types = [ EditorialModel.types.EmType(int(record.uid)) for record in records ]
 
         return types
 
+    def _typesDb(self):
+        dbe = self.__class__.getDbE()
+        emtype = sql.Table(EditorialModel.types.EmType.table, sqlutils.meta(dbe))
+        req = emtype.select().where(emtype.c.class_id == self.id)
+        conn = dbe.connect()
+        res = conn.execute(req)
+        return res.fetchall()
+    
     """ add a new EmType that can ben linked to this class
         @param  t EmType: type to link
         @return success bool: done or not

EditorialModel/components.py

@@ -5,23 +5,26 @@
     @see EmClass, EmType, EmFieldGroup, EmField
 """
 
+import datetime
+
 from Lodel.utils.mlstring import MlString
-from Database.sqlwrapper import SqlWrapper
-from Database.sqlobject import SqlObject
 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
+    table = None
+    
     """ 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:
+        if type(self) is EmComponent:
             raise EnvironmentError('Abstract class')
         if isinstance(id_or_name, int):
             self.id = id_or_name
@@ -31,25 +34,12 @@ class EmComponent(object):
             self.name = id_or_name
             self.populate()
         else:
-            raise TypeError('Bad argument: expecting <int> or <str>')
+            raise TypeError('Bad argument: expecting <int> or <str> but got : '+str(type(id_or_name)))
 
     """ 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,25 +56,97 @@ 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 = req.where(component.c.name == self.name)
+        else:
+            req = 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
+    
+    ## Insert a new component in the database
+    # This function create and assign a new UID and handle the date_create value
+    # @param values The values of the new component
+    # @return An instance of the created component
+    #
+    # @todo Check that the query didn't failed
+    @classmethod
+    def create(c, values):
+        values['uid'] = c.newUid()
+        values['date_update'] = values['date_create'] = datetime.datetime.utcnow()
+
+        dbe = c.getDbE()
+        conn = dbe.connect()
+        table = sql.Table(c.table, sqlutils.meta(dbe))
+        req = table.insert(values)
+        res = conn.execute(req) #Check res?
+        conn.close()
+        return c(values['name']) #Maybe no need to check res because this would fail if the query failed
+        
+
     """ write the representation of the component in the database
         @return bool
     """
     def save(self, values):
+
         values['name'] = self.name
         values['rank'] = self.rank
-        values['date_update'] = self.date_update
-        values['date_create'] = self.date_create
+        values['date_update'] = datetime.datetime.utcnow()
         values['string'] = str(self.string)
         values['help']= str(self.help)
 
-        emclass = SqlObject(self.table)
-        update = emclass.table.update(values=values)
-        res = emclass.wexec(update)
+        #Don't allow creation date overwritting
+        if 'date_create' in values:
+            del values['date_create']
+            logger.warning("date_create supplied for save, but overwritting of date_create not allowed, the date will not be changed")
+
+        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(component, values = values).where(component.c.uid == 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.c.uid == 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
@@ -99,6 +161,25 @@ class EmComponent(object):
         else:
             return "<%s #%s, '%s'>" % (type(self).__name__, self.id, self.name)
 
+    @classmethod
+    def newUid(c):
+        """ This function register a new component in uids table
+            @return The new uid
+        """
+        dbe = c.getDbE()
+
+        uidtable = sql.Table('uids', sqlutils.meta(dbe))
+        conn = dbe.connect()
+        req = uidtable.insert(values={'table':c.table})
+        res = conn.execute(req)
+
+        uid = res.inserted_primary_key[0]
+        logger.debug("Registering a new UID '"+str(uid)+"' for '"+c.table+"' component")
+
+        conn.close()
+
+        return uid
+
 
 class EmComponentNotExistError(Exception):
     pass

EditorialModel/fieldgroups.py

@@ -1,7 +1,8 @@
 #-*- coding: utf-8 -*-
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
-from Database.sqlobject import SqlObject
+from Database import sqlutils
+import sqlalchemy as sql
 
 import EditorialModel
 
@@ -23,8 +24,8 @@ class EmFieldGroup(EmComponent):
         self.table = EmFieldGroup.table
         super(EmFieldGroup, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_class):
+    @classmethod
+    def create(c, name, em_class):
         """ Create a new EmFieldGroup, save it and instanciate it
 
             @param name str: The name of the new fielgroup
@@ -33,13 +34,7 @@ class EmFieldGroup(EmComponent):
         try:
             exists = EmFieldGroup(name)
         except EmComponentNotExistError:
-            uids = SqlObject('uids')
-            res = uids.wexec(uids.table.insert().values(table=EmFieldGroup.table))
-            uid = res.inserted_primary_key
-
-            emfieldgroup = SqlObject(EmFieldGroup.table)
-            res = emfieldgroup.wexec(emfieldgroup.table.insert().values(uid=uid, name=name, class_id=em_class.id))
-            return EmFieldGroup(name)
+            return super(EmFieldGroup, c).create({'name': name, 'class_id':em_class.id}) #Check the return value ?
 
         return exists
 

EditorialModel/fields.py

@@ -1,7 +1,9 @@
 #-*- coding: utf-8 -*-
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
-from Database.sqlobject import SqlObject
+from Database import sqlutils
+
+import sqlalchemy as sql
 
 import EditorialModel
 
@@ -19,8 +21,8 @@ class EmField(EmComponent):
         self.table = EmField.table
         super(EmField, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_fieldgroup, em_fieldtype, optional=True, internal=False):
+    @classmethod
+    def create(c, name, em_fieldgroup, em_fieldtype, optional=True, internal=False):
         """ Create a new EmField and instanciate it
             @static
 
@@ -40,36 +42,30 @@ class EmField(EmComponent):
         try:
             exists = EmField(name)
         except EmComponentNotExistError:
-            uids = SqlObject('uids')
-            res = uids.wexec(uids.table.insert().values(table=EmField.table))
-            uid = res.inserted_primary_key
-
             values = {
-                'uid' : uid,
+                'uid' : None,
                 'name' : name,
                 'fieldgroup_id' : em_fieldgroup.id,
-                'fieldtype_id' : em_fieldtype.id,
+                'fieldtype' : em_fieldtype.name,
                 'optional' : 1 if optional else 0,
                 'internal' : 1 if internal else 0,
             }
-
-            emfield_req = SqlObject(EmField.table)
-            res = emfield_req.wexec(emfield_req.table.insert(values=values))
-            return EmField(name)
+            return super(EmField,c).create(values)
 
         return exists
 
+
     """ Use dictionary (from database) to populate the object
     """
     def populate(self):
         row = super(EmField, self).populate()
         self.em_fieldgroup = EditorialModel.fieldgroups.EmFieldGroup(int(row.fieldgroup_id))
-        self.em_fieldtype = EditorialModel.fieldtypes.EmFieldType(int(row.fieldtype_id))
+        self.em_fieldtype = EditorialModel.fieldtypes.get_field_type(row.fieldtype)
         self.optional = True if row.optional == 1 else False;
         self.internal = True if row.internal == 1 else False;
         self.icon = row.icon
-        self.rel_to_type_id = EditorialModel.fieldtypes.EmFieldType(int(row.rel_to_type_id)) if row.rel_to_type_id else ''
-        self.rel_field_id = EmField(int(row.rel_field_id)) if row.rel_field_id else ''
+        self.rel_to_type_id = EditorialModel.fieldtypes.EmFieldType(int(row.rel_to_type_id)) if row.rel_to_type_id else None
+        self.rel_field_id = EmField(int(row.rel_field_id)) if row.rel_field_id else None
 
     def save(self):
         # should not be here, but cannot see how to do this
@@ -78,12 +74,12 @@ class EmField(EmComponent):
 
         values = {
             'fieldgroup_id' : self.em_fieldgroup.id,
-            'fieldtype_id' : self.em_fieldtype.id,
+            'fieldtype' : self.em_fieldtype.name,
             'optional' : 1 if self.optional else 0,
             'internal' : 1 if self.internal else 0,
             'icon' : self.icon,
-            'rel_to_type_id' : self.rel_to_type_id,
-            'rel_field_id' : self.rel_field_id
+            'rel_to_type_id' : self.rel_to_type_id.id if self.rel_to_type_id is not None else None,
+            'rel_field_id' : self.rel_field_id.id if self.rel_field_id is not None else None
         }
 
         return super(EmField, self).save(values)

EditorialModel/fieldtypes.py

@@ -1,8 +1,107 @@
 #-*- coding: utf-8 -*-
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
+from Lodel.utils.mlstring import MlString
+from sqlalchemy import Column, INTEGER, BOOLEAN, VARCHAR
+
+def get_field_type(name):
+    class_name = 'EmField_' + name
+    constructor = globals()[class_name]
+    instance = constructor()
+    return instance
 
 class EmFieldType():
 
-    def __init__(self, id):
-        self.id = id
+    def __init__(self, name):
+        self.name = name
+
+
+class EmField_integer(EmFieldType):
+
+    def __init__(self):
+        super(EmField_integer, self).__init__('integer')
+
+    def to_python(self, value):
+        if value == '':
+            self.value = 0
+        else:
+            self.value = int(value)
+
+    def to_sql(self, value = None):
+        if value is None:
+            value = self.value
+        return str(value)
+
+    def sql_column(self):
+        return "int(11) NOT NULL"
+
+    def sqlalchemy_args(self):
+        # TODO Ajouter la prise en charge de la taille max
+        return {'type_': INTEGER, 'nullable': False}
+
+class EmField_boolean(EmFieldType):
+
+    def __init__(self):
+        super(EmField_boolean, self).__init__('boolean')
+
+    def to_python(self, value):
+        if value:
+            self.value = True
+        else:
+            self.value = False
+        return self.value
+
+    def to_sql(self, value = None):
+        if value is None:
+            value = self.value
+        return 1 if value else 0
+
+    def sql_column(self):
+        return "tinyint(1) DEFAULT NULL"
+
+    def sqlalchemy_args(self):
+        return {'type_': BOOLEAN, 'nullable': True, 'default': None}
+
+class EmField_char(EmFieldType):
+
+    def __init__(self):
+        super(EmField_char, self).__init__('char')
+
+    def to_python(self, value):
+        if value:
+            self.value = value
+        else:
+            self.value = ''
+        return self.value
+
+    def to_sql(self, value = None):
+        if value is None:
+            value = self.value
+        return value
+
+    def sql_column(self):
+        return "varchar(250) DEFAULT NULL"
+
+    def sqlalchemy_args(self):
+        return {'type_': VARCHAR(250), 'nullable': True, 'default': None}
+
+
+class EmField_mlstring(EmFieldType):
+
+    def __init__(self):
+        super(EmField_mlstring, self).__init__('mlstring')
+
+    def to_python(self, value):
+        self.value = MlString.load(value)
+        return self.value
+
+    def to_sql(self, value = None):
+        if value is None:
+            value = self.value
+        return str(value)
+
+    def sql_column(self):
+        return "varchar(250) DEFAULT NULL"
+
+    def sqlalchemy_args(self):
+        return {'type_': VARCHAR(250), 'nullable': True, 'default': None}

EditorialModel/types.py

@@ -1,7 +1,8 @@
 #-*- coding: utf-8 -*-
 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
-from Database.sqlobject import SqlObject
+from Database import sqlutils
+import sqlalchemy as sql
 
 import EditorialModel.classes
 
@@ -24,8 +25,8 @@ class EmType(EmComponent):
         self.table = EmType.table
         super(EmType, self).__init__(id_or_name)
 
-    @staticmethod
-    def create(name, em_class):
+    @classmethod
+    def create(c, name, em_class):
         """ Create a new EmType and instanciate it
 
             @param name str: The name of the new type
@@ -34,18 +35,12 @@ class EmType(EmComponent):
             @see EmComponent::__init__()
 
             @todo Change the icon param type
-            @todo change staticmethod to classmethod
+            @todo check that em_class is an EmClass object
         """
         try:
             exists = EmType(name)
         except EmComponentNotExistError:
-            uids = SqlObject('uids')
-            res = uids.wexec(uids.table.insert().values(table=EmType.table))
-            uid = res.inserted_primary_key
-
-            emtype = SqlObject(EmType.table)
-            res = emtype.wexec(emtype.table.insert().values(uid=uid, name=name, class_id=em_class.id))
-            return EmType(name)
+            return super(EmType, c).create({'name':name, 'class_id': em_class.id})
 
         return exists