The automatic UID creation by datasource implementation implies somes changes :

	The UniqID datahandler has to call the datasource
	LeObject has to be able to determine wich parent class define its UID datahandler
	[NOT IMPLEMENTED] the datasource should be able to select with an abstract LeObject as target ( see #92 )

em_test.py

 ####################
 #   Lodel Object   #
 ####################
+em_abstract = em.new_class( 'abstract_object',
+    display_name = 'Abstract lodel object',
+    help_text = 'For testing purpose',
+    group = base_group,
+    abstract = True)
+
 em_object = em.new_class(   'object',
                             display_name = 'Object',
                             help_text = 'Main class for all Em objects',
                             group = base_group,
                             abstract = True,
+                            parents = em_abstract,
 )
 em_object.new_field(    'lodel_id',
                         display_name = 'Lodel identifier',

lodel/leapi/datahandlers/datas.py

     def _check_data_value(self, value):
         return value, None
 
+    def construct_data(self, emcomponent, fname, datas, cur_value):
+        if cur_value is None:
+            #Ask datasource to provide a new uniqID
+            return emcomponent._ro_datasource.new_numeric_id(emcomponent)
+        return cur_value
+
 class LeobjectSubclassIdentifier(Varchar):
     
     help = 'Datahandler designed to handle LeObject subclass identifier in DB'

lodel/leapi/datahandlers/datas_base.py

     def construct_data(self, emcomponent, fname, datas, cur_value):
         if (self.now_on_create and cur_value is None) or self.now_on_update:
             return datetime.datetime.now()
+        return cur_value
 
 ##@brief Data field designed to handle long string
 class Text(DataField):

lodel/leapi/leobject.py

     def fields(cls):
         return copy.copy(cls._fields)
     
+    ##@brief Return the list of parents classes
+    #
+    #@note the first item of the list is the current class, the second is it's
+    #parent etc...
+    #@param cls
+    #@warning multiple inheritance broken by this method
+    #@return a list of LeObject child classes
+    #@todo multiple parent capabilities implementation
+    @classmethod
+    def hierarch(cls):
+        res = [cls]
+        cur = cls
+        while True:
+            cur = cur.__bases__[0] # Multiple inheritance broken HERE
+            if cur in (LeObject, object):
+                break
+            else:
+                res.append(cur)
+        return res
+    
+    ##@brief Return the parent class that is the "source" of uid
+    #
+    #The method goal is to return the parent class that defines UID.
+    #@return a LeObject child class or false if no UID defined
+    @classmethod
+    def uid_source(cls):
+        if cls._uid is None or len(cls._uid) == 0:
+            return False
+        hierarch = cls.hierarch()
+        prev = hierarch[0]
+        uid_handlers = set( cls._fields[name] for name in cls._uid )
+        for pcls in cls.hierarch()[1:]:
+            puid_handlers = set(cls._fields[name] for name in pcls._uid)
+            if set(pcls._uid) != set(pcls._uid) \
+                or puid_handlers != uid_handlers:
+                break
+            prev = pcls
+        return prev
+    
     ##@brief Initialise both datasources (ro and rw)
     #
     #This method is used once at dyncode load to replace the datasource string

plugins/dummy_datasource/datasource.py

     def __init__(self, *conn_args, **conn_kwargs):
         self.conn_args = conn_args
         self.conn_kwargs = conn_kwargs
+    
+    ##@brief Provide a new uniq numeric ID
+    #@param emcomp LeObject subclass (not instance) : To know on wich things we
+    #have to be uniq
+    #@return an integer
+    def new_numeric_id(self, emcomp):
+        pass
 
-    ## @brief returns a selection of documents from the datasource
-    # @param target_cls Emclass
-    # @param field_list list
-    # @param filters list : List of filters
-    # @param rel_filters list : List of relational filters
-    # @param order list : List of column to order. ex: order = [('title', 'ASC'),]
-    # @param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),]
-    # @param limit int : Number of records to be returned
-    # @param offset int: used with limit to choose the start record
-    # @param instanciate bool : If true, the records are returned as instances, else they are returned as dict
-    # @return list
+    ##@brief returns a selection of documents from the datasource
+    #@param target_cls Emclass
+    #@param field_list list
+    #@param filters list : List of filters
+    #@param rel_filters list : List of relational filters
+    #@param order list : List of column to order. ex: order = [('title', 'ASC'),]
+    #@param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),]
+    #@param limit int : Number of records to be returned
+    #@param offset int: used with limit to choose the start record
+    #@param instanciate bool : If true, the records are returned as instances, else they are returned as dict
+    #@return list
     def select(self, target_cls, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0,
                instanciate=True):
         pass

plugins/mongodb_datasource/datasource.py

             del(self._connections[self.__conn_hash])
             logger.info("Closing connection to database")
 
+    ##@brief Provide a new uniq numeric ID
+    #@param emcomp LeObject subclass (not instance) : To know on wich things we
+    #have to be uniq
+    #@warning multiple UID broken by this method
+    #@return an integer
+    def new_numeric_id(self, emcomp):
+        target = emcomp.uid_source()
+        tuid = target._uid[0] # Multiple UID broken here
+        results = self.select(
+            target, [tuid], [], order=[(tuid, 'DESC')], limit = 1)
+        return results[0][tuid]+1
+
     ##@brief returns a selection of documents from the datasource
     #@param target Emclass
     #@param field_list list
     #@param instanciate bool : If true, the records are returned as instances, else they are returned as dict
     #@return list
     #@todo Implement the relations
-    def select(self, target, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0):
+    def select(self, target, field_list, filters = None, rel_filters=None, order=None, group=None, limit=None, offset=0):
+        # Default arg init
+        filters = [] if filters is None else filters
+        rel_filters = [] if rel_filters is None else rel_filters
+
         collection_name = object_collection_name(target)
         collection = self.database[collection_name]
         query_filters = self.__process_filters(