Bugfixes in query and datasources.

lodel/leapi/query.py

@@ -465,10 +465,8 @@ class LeInsertQuery(LeQuery):
     # @param new_datas : datas to be inserted
     def _query(self, datas):
         datas = self._target_class.prepare_datas(datas, True, False)
-        nb_inserted = self._rw_datasource.insert(self._target_class,datas)
-        if nb_inserted <= 0:
-            raise LeApiQueryError("Insertion error")
-        return nb_inserted
+        id_inserted = self._rw_datasource.insert(self._target_class,datas)
+        return id_inserted
     """
     ## @brief Implements an insert query operation, with multiple insertions
     # @param datas : list of **datas to be inserted
@@ -610,15 +608,15 @@ class LeGetQuery(LeFilteredQuery):
         super().__init__(target_class, query_filters)
         
         ##@brief The fields to get
-        self.__field_list = None
+        self._field_list = None
         ##@brief An equivalent to the SQL ORDER BY
-        self.__order = None
+        self._order = None
         ##@brief An equivalent to the SQL GROUP BY
-        self.__group = None
+        self._group = None
         ##@brief An equivalent to the SQL LIMIT x
-        self.__limit = None
+        self._limit = None
         ##@brief An equivalent to the SQL LIMIT x, OFFSET
-        self.__offset = 0
+        self._offset = 0
         
         # Checking kwargs and assigning default values if there is some
         for argname in kwargs:
@@ -633,22 +631,22 @@ class LeGetQuery(LeFilteredQuery):
 
         if 'order' in kwargs:
             #check kwargs['order']
-            self.__order = kwargs['order']
+            self._order = kwargs['order']
         if 'group' in kwargs:
             #check kwargs['group']
-            self.__group = kwargs['group']
+            self._group = kwargs['group']
         if 'limit' in kwargs and kwargs['limit'] is not None:
             try:
-                self.__limit = int(kwargs['limit'])
-                if self.__limit <= 0:
+                self._limit = int(kwargs['limit'])
+                if self._limit <= 0:
                     raise ValueError()
             except ValueError:
                 msg = "limit argument expected to be an interger > 0"
                 raise ValueError(msg)
         if 'offset' in kwargs:
             try:
-                self.__offset = int(kwargs['offset'])
-                if self.__offset < 0:
+                self._offset = int(kwargs['offset'])
+                if self._offset < 0:
                     raise ValueError()
             except ValueError:
                 msg = "offset argument expected to be an integer >= 0"
@@ -670,7 +668,7 @@ class LeGetQuery(LeFilteredQuery):
         if len(err_l) > 0:
             msg = "Error while setting field_list in a get query"
             raise LeApiQueryErrors(msg = msg, exceptions = err_l)
-        self.__field_list = list(set(field_list))
+        self._field_list = list(set(field_list))
     
     ##@brief Execute the get query
     def execute(self, datas = None):
@@ -680,25 +678,25 @@ class LeGetQuery(LeFilteredQuery):
     # @returns a list containing the item(s)
     def _query(self, datas = None):
         # select datas corresponding to query_filter
-        l_datas=self._ro_datasource.select(  self._target_class,
-                                    list(self.field_list),
-                                    self.query_filter,
-                                    None,
-                                    self.__order,
-                                    self.__group,
-                                    self.__limit,
-                                    self.offset,
-                                    False)
+        l_datas=self._ro_datasource.select( 
+            target = self._target_class,
+            field_list = list(self._field_list),
+            filters = self._query_filter[0],
+            rel_filters = self._query_filter[1],
+            order = self._order,
+            group = self._group,
+            limit = self._limit,
+            offset = self._offset)
         return l_datas
     
     ##@return a dict with query infos
     def dump_infos(self):
         ret = super().dump_infos()
-        ret.update( {   'field_list' : self.__field_list,
-                        'order' : self.__order,
-                        'group' : self.__group,
-                        'limit' : self.__limit,
-                        'offset': self.__offset,
+        ret.update( {   'field_list' : self._field_list,
+                        'order' : self._order,
+                        'group' : self._group,
+                        'limit' : self._limit,
+                        'offset': self._offset,
         })
         return ret
 

plugins/mongodb_datasource/datasource.py

@@ -82,7 +82,7 @@ class MongoDbDatasource(object):
         collection_name = object_collection_name(target)
         collection = self.database[collection_name]
         query_filters = self.__process_filters(
-            target, filters, relational_filters)
+            target, filters, rel_filters)
         query_result_ordering = None
         if order is not None:
             query_result_ordering = parse_query_order(order)
@@ -155,15 +155,15 @@ class MongoDbDatasource(object):
     # @param new_datas dict : datas to insert
     # @return the inserted uid
     def insert(self, target, new_datas):
-        res = self.__collection(target).insert_one(new_datas)
-        return res.inserted_id
+        res = self.__collection(target).insert(new_datas)
+        return str(res)
 
     ## @brief Inserts a list of records in a given collection
     # @param target Emclass : class of the objects inserted
     # @param datas_list list : list of dict
     # @return list : list of the inserted records' ids
     def insert_multi(self, target, datas_list):
-        res = self.__collection.insert_many(datas_list)
+        res = self.__collection(target).insert_many(datas_list)
         return list(result.inserted_ids)
 
     ##@brief Connect to database
@@ -225,21 +225,20 @@ class MongoDbDatasource(object):
     #@return a list of pymongo filters ( dict {FIELD:{OPERATOR:VALUE}} )
     def __process_filters(self,target, filters, relational_filters):
         # Simple filters lodel2 -> pymongo converting
-        res = [convert_filter(filt) for filt in filters]
-        rfilters = self.__prepare_relational_filters(relational_filters)
+        res = self.__filters2mongo(filters)
+        rfilters = self.__prepare_relational_filters(target, relational_filters)
         #Now that everything is well organized, begin to forge subquerie
         #filters
-        subq_filters = self.__subqueries_from_relational_filters(
-            target, rfilters)
+        self.__subqueries_from_relational_filters(target, rfilters)
         # Executing subqueries, creating filters from result, and injecting
         # them in original filters of the query
-        if len(subq_filters) > 0:
+        if len(rfilters) > 0:
             logger.debug("Begining subquery execution")
-        for fname in subq_filters:
+        for fname in rfilters:
             if fname not in res:
                 res[fname] = dict()
             subq_results = set()
-            for leobject, sq_filters in subq_filters[fname].items():
+            for leobject, sq_filters in rfilters[fname].items():
                 uid_fname = mongo_fieldname(leobject._uid)
                 log_msg = "Subquery running on collection {coll} with filters \
 '{filters}'"
@@ -262,7 +261,7 @@ class MongoDbDatasource(object):
                     res[fname]['$in'] = list(deduped)
             else:
                 res[fname]['$in'] = list(subq_results)
-        if len(subq_filters) > 0:
+        if len(rfilters) > 0:
             logger.debug("End of subquery execution")
         return res
 
@@ -281,14 +280,15 @@ class MongoDbDatasource(object):
     #@param rfilters dict : A struct as returned by
     #MongoDbDatasource.__prepare_relational_filters()
     #@return None, the rfilters argument is modified by reference
-    def __subqueries_from_relational_filters(self, target, rfilters):
+    @classmethod
+    def __subqueries_from_relational_filters(cls, target, rfilters):
         for fname in rfilters:
             for leobject in rfilters[fname]:
                 for rfield in rfilters[fname][leobject]:
                     #This way of doing is not optimized but allows to trigger
                     #warnings in some case (2 different values for a same op
                     #on a same field on a same collection)
-                    mongofilters = self.__op_value_listconv(
+                    mongofilters = cls.__op_value_listconv(
                         rfilters[fname][leobject][rfield])
                     rfilters[fname][leobject][rfield] = mongofilters
 
@@ -307,7 +307,8 @@ class MongoDbDatasource(object):
     #@param target LeObject subclass (no instance) : Target class
     #@param relational_filters : same composition thant filters except that
     #@return a struct as described above
-    def __prepare_relational_filters(self, target, relational_filters):
+    @classmethod
+    def __prepare_relational_filters(cls, target, relational_filters):
         # We are going to regroup relationnal filters by reference field
         # then by collection
         rfilters = dict()
@@ -334,6 +335,26 @@ class MongoDbDatasource(object):
                     rfilters[fname][repr_leo][rfield] = list()
                 rfilters[fname][repr_leo][rfield].append((op, value))
         return rfilters
+    
+    ##@brief Convert lodel2 filters to pymongo conditions
+    #@param filters list : list of lodel filters
+    #@return dict representing pymongo conditions
+    @classmethod
+    def __filters2mongo(cls, filters):
+        res = dict()
+        for fieldname, op, value in filters:
+            oop = op
+            ovalue = value
+            op, value = cls.__op_value_conv(op, value)
+            if fieldname not in res:
+                res[fieldname] = dict()
+            if op in res[fieldname]:
+                logger.warn("Dropping condition : '%s %s %s'" % (
+                    fieldname, op, value))
+            else:
+                res[fieldname][op] = value
+        return res
+
 
     ##@brief Convert lodel2 operator and value to pymongo struct
     #
@@ -341,15 +362,16 @@ class MongoDbDatasource(object):
     #@param op str : take value in LeFilteredQuery::_query_operators
     #@param value mixed : the value
     #@return a tuple(mongo_op, mongo_value)
-    def __op_value_conv(self, op, value):
-        if op not in self.lodel2mongo_op_map:
+    @classmethod
+    def __op_value_conv(cls, op, value):
+        if op not in cls.lodel2mongo_op_map:
             msg = "Invalid operator '%s' found" % op
             raise MongoDbDataSourceError(msg)
-        mongop = self.lodel2mongo_op_map[op]
+        mongop = cls.lodel2mongo_op_map[op]
         mongoval = value
         #Converting lodel2 wildcarded string into a case insensitive
         #mongodb re
-        if mongop in self.mon_op_re:
+        if mongop in cls.mon_op_re:
             #unescaping \
             mongoval = value.replace('\\\\','\\')
             if not mongoval.startswith('*'):
@@ -358,16 +380,17 @@ class MongoDbDatasource(object):
             if not (mongoval[-1] == '*' and mongoval[-2] != '\\'):
                 mongoval += '$'
             #Replacing every other unescaped wildcard char
-            mongoval = self.wildcard_re.sub('.*', mongoval)
+            mongoval = cls.wildcard_re.sub('.*', mongoval)
             mongoval = {'$regex': mongoval, '$options': 'i'}
         return (op, mongoval)
 
     ##@brief Convert a list of tuple(OP, VALUE) into a pymongo filter dict
     #@return a dict with mongo op as key and value as value...
-    def __op_value_listconv(self, op_value_list):
+    @classmethod
+    def __op_value_listconv(cls, op_value_list):
         result = dict()
         for op, value in op_value_list:
-            mongop, mongoval = self.__op_value_conv(op, value)
+            mongop, mongoval = cls.__op_value_conv(op, value)
             if mongop in result:
                 warnings.warn("Duplicated value given for a single \
 field/operator couple in a query. We will keep only the first one")

plugins/mongodb_datasource/utils.py

@@ -81,13 +81,7 @@ def connect(host, port, db_name, username, password):
 # @param class_object EmClass
 # @return str
 def object_collection_name(class_object):
-    if not class_object.pure_abstract:
-        class_parent = class_object.parents[0].uid
-        collection_name = ("%s%s" % (collection_prefix['object'], class_parent)).lower()
-    else:
-        collection_name = ("%s%s" % (collection_prefix['object'], class_object.name)).lower()
-
-    return collection_name
+    return class_object.__name__
 
 
 ## @brief Determine a collection field name given a lodel2 fieldname