Implémentation requete

lodel/leapi/query.py

@@ -5,11 +5,30 @@ from .leobject import LeObject, LeApiErrors, LeApiDataCheckError
 from lodel.plugin.hooks import LodelHook
 
 class LeQueryError(Exception):
-    pass
+    ##@brief Instanciate a new exceptions handling multiple exceptions
+    # @param msg str : Exception message
+    # @param exceptions dict : A list of data check Exception with concerned field (or stuff) as key
+    def __init__(self, msg = "Unknow error", exceptions = None):
+        self._msg = msg
+        self._exceptions = dict() if exceptions is None else exceptions
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
+        msg = self._msg
+        for_iter = self._exceptions.items() if isinstance(self._exceptions, dict) else enumerate(self.__exceptions)
+        for obj, expt in for_iter:
+            msg += "\n\t{expt_obj} : ({expt_name}) {expt_msg}; ".format(
+                    expt_obj = obj,
+                    expt_name=expt.__class__.__name__,
+                    expt_msg=str(expt)
+            )
+        return msg
 
 class LeQuery(object):
     
-    ##@brief Hookname preffix
+    ##@brief Hookname prefix
     _hook_prefix = None
     ##@brief arguments for the LeObject.check_data_value()
     _data_check_args = { 'complete': False, 'allow_internal': False }
@@ -18,7 +37,7 @@ class LeQuery(object):
     # @param target_class LeObject : class of object the query is about
     def __init__(self, target_class):
         if hook_prefix is None:
-            raise NotImplementedError("Asbtract class")
+            raise NotImplementedError("Abstract class")
         if not issubclass(target_class, LeObject):
             raise TypeError("target class has to be a child class of LeObject")
         self.__target_class = target_class
@@ -61,29 +80,82 @@ class LeFilteredQuery(LeQuery):
                         '!=',
                         '<',
                         '>',
-                        ' in ',
-                        ' not in ',
-                        ' like ',
-                        ' not like ']
+                        'in',
+                        'not in',
+                        'like',
+                        'not like']
 
     ##@brief Abtract constructor for queries with filter
     # @param target_class LeObject : class of object the query is about
-    # @param query_filters list : list of string of query filters (or tuple 
-    #(FIELD, OPERATOR, VALUE) )
+    # @param query_filters list : with a tuple (only one filter) or a list of tuple
+    #   or a dict: {OP,list(filters)} with OP = 'OR' or 'AND
+    #   For tuple (FIELD,OPERATOR,VALUE)
     def __init__(self, target_class, query_filter):
         super().__init__(target_class)
         ##@brief The query filter
         self.__query_filter = None
-        self.set_qeury_filter(query_filter)
+        self.set_query_filter(query_filter)
     
     ##@brief Set the query filter for a query
     def set_query_filter(self, query_filter):
         #
-        #   Query filter check & prepare should be done here
-        #
-        self.__query_filter = query_filter
+        #   Query filter check & prepare 
+        #   query_filters can be a tuple (only one filter), a list of tuple
+        #   or a dict: {OP,list(filters)} with OP = 'OR' or 'AND
+        #   For tuple (FIELD,OPERATOR,VALUE)
+        #   FIELD has to be in the field_names list of target class
+        #   OPERATOR in query_operator attribute
+        #   VALUE has to be a correct value for FIELD
+
+        fieldnames = self.__target_class.fieldnames()
+        # Recursive method which checks filters
+        def check_tuple(tupl, fieldnames, target_class):
+            if isinstance(tupl, tuple):
+                if tupl[0] not in fieldnames:
+                    return False
+                if tupl[1] not in self.query_operators:
+                    return False
+                if not isinstance(tupl[2], target_class.datahandler(tupl[0])):
+                    return False
+                return True
+            elif isinstance(tupl,dict):
+                return check_tuple(tupl[1])
+            elif isinstance(tupl,list):
+                for tup in tupl:
+                    return check_tuple(tup)
+            else: 
+                raise TypeError("Wrong filters for query")
+
+        check_ok=check_tuple(query_filter, fieldnames, self.__target_class)
+        if check_ok:            
+            self.__query_filter = query_filter
+            
+        # try to check if a query string is a simple condition like 'fieldname operator value'
+    def simple_cond(cond, target_class):
+            # cond is the where clause
 
-##@brief A query for insert a new object
+        if 'AND' in cond.upper():
+            return False
+        if 'OR' in cond.upper():
+            return False
+        
+        n_ops = 0
+        for op in target_class.query_operators:
+            if op in cond:
+                q_op=op
+                n_ops+=1
+        if n_ops > 1 or n_ops==0:
+            raise TypeError("%s isn't a valid sql condition" % cond)
+        tupl=cond.partition(q_op)
+
+        if tupl[0].strip() not in target_class.fieldnames:
+            raise TypeError("%s isn't a valid fieldname" % tupl[0].strip())
+        if not isinstance(tupl[2].strip(), target_class.datahandler(tupl[0].strip())):
+            raise TypeError("%s is not of a valid type for fieldname % s" % tupl[0],tupl[2])
+        return True
+    
+
+##@brief A query to insert a new object
 class LeInsertQuery(LeQuery):
     
     _hook_prefix = 'leapi_insert_'
@@ -92,11 +164,18 @@ class LeInsertQuery(LeQuery):
     def __init__(self, target_class):
         super().__init__(target_class)
     
-    ## @brief Implements an insert query operations
+    ## @brief Implements an insert query operation
     # @param **datas : datas to be inserted
     def __query(self, datasource, **datas):
-        pass
+        nb_inserted = datasource.insert(self.__target_class,**datas)
+        if nb_inserted < 0:
+            raise LeQueryError("Insertion error")
+        return nb_inserted
 
+    ## @brief Execute the insert query
+    def execute(self, datasource):
+        super().execute()
+        
 ##@brief A query to update datas for a given object
 class LeUpdateQuery(LeFilteredQuery):
     
@@ -108,8 +187,20 @@ class LeUpdateQuery(LeFilteredQuery):
     
     ##@brief Implements an update query
     # @param **datas : datas to update
+    # @returns the number of updated items
+    # @exception when the number of updated items is not as expected
     def __query(self, datasource, **datas):
-        pass
+        # select _uid corresponding to query_filter
+        l_uids=datasource.select(self.__target_class,list(self.__target_class.getuid()),query_filter,None, None, None, None, 0, False)
+        # list of dict l_uids : _uid(s) of the objects to be updated, corresponding datas
+        nb_updated = datasource.update(self.__target_class,l_uids, **datas)
+        if (nb_updated != len(l_uids):
+            raise LeQueryError("Number of updated items: %d is not as expected: %d " % (nb_updated, len(l_uids)))
+        return nb_updated
+    
+    ## @brief Execute the update query
+    def execute(self, datasource):
+        super().execute()
 
 ##@brief A query to delete an object
 class LeDeleteQuery(LeFilteredQuery):
@@ -124,8 +215,16 @@ class LeDeleteQuery(LeFilteredQuery):
         super().execute()
     
     ##@brief Implements delete query operations
+    # @returns the number of deleted items
+    # @exception when the number of deleted items is not as expected
     def __query(self, datasource):
-        pass
+        # select _uid corresponding to query_filter
+        l_uids=datasource.select(self.__target_class,list(self.__target_class.getuid()),query_filter,None, None, None, None, 0, False)
+        # list of dict l_uids : _uid(s) of the objects to be deleted
+        nb_deleted = datasource.update(self.__target_class,l_uids, **datas)
+        if (nb_deleted != len(l_uids):
+            raise LeQueryError("Number of deleted items %d is not as expected %d " % (nb_deleted, len(l_uids)))
+        return nb_deleted
 
 class LeGetQuery(LeFilteredQuery):
     
@@ -133,8 +232,8 @@ class LeGetQuery(LeFilteredQuery):
 
     ##@brief Instanciate a new get query
     # @param target_class LeObject : class of object the query is about
-    # @param query_filters list : list of string of query filters (or tuple 
-    #(FIELD, OPERATOR, VALUE) )
+    # @param query_filters dict : {OP, list of query filters }
+    #        or tuple (FIELD, OPERATOR, VALUE) )
     # @param field_list list|None : list of string representing fields see @ref leobject_filters
     # @param order list : A list of field names or tuple (FIELDNAME, [ASC | DESC])
     # @param group list : A list of field names or tuple (FIELDNAME, [ASC | DESC])
@@ -161,7 +260,7 @@ class LeGetQuery(LeFilteredQuery):
 
         if 'field_list' not in kwargs:
             #field_list = target_class.get_field_list
-            pass
+            field_list = target_class.fieldnames()
         else:
             #target_class.check_fields(kwargs['field_list'])
             field_list = kwargs['field_list']
@@ -190,3 +289,13 @@ class LeGetQuery(LeFilteredQuery):
     def execute(self, datasource):
         super().execute(datasource)
 
+    ##@brief Implements select query operations
+    # @returns a list containing the item(s)
+
+    def __query(self, datasource):
+        # select _uid corresponding to query_filter
+        l_datas=datasource.select(self.__target_class,list(self.field_list),self.query_filter,None, self.__order, self.__group, self.__limit, self.offset, False)
+        return l_datas
+        
+
+