More tests & debug on multi datasource queries + em_test update

- Added missing allowed_classes options to some references in em_test

em_test.py

@@ -276,7 +276,7 @@ person.new_field(   'linked_texts',
                     data_handler = 'list',
                     back_reference = ('Text', 'linked_persons'),
                     group = editorial_person_group,
-)
+                    allowed_classes = [text])
 
 text.new_field( 'linked_persons',
                 display_name = {
@@ -286,7 +286,7 @@ text.new_field( 'linked_persons',
                 data_handler = 'list',
                 back_reference = ('Person', 'linked_texts'),
                 group = editorial_person_group,
-)
+                allowed_classes = [person])
 
 #####################
 # Index classes     # <--- Note :   using a different datasource for testing

lodel/leapi/query.py

@@ -1,6 +1,8 @@
 #-*- coding: utf-8 -*-
 
 import re
+import copy
+
 from .leobject import LeObject, LeApiErrors, LeApiDataCheckError
 from lodel.plugin.hooks import LodelHook
 from lodel import logger
@@ -157,6 +159,7 @@ class LeFilteredQuery(LeQuery):
     #
     #@param query_filter list|tuple|str : A single filter or a list of filters
     #@see LeFilteredQuery._prepare_filters()
+    #@warning Does not support multiple UID
     def set_query_filter(self, query_filter):
         if isinstance(query_filter, str):
             query_filter = [query_filter]
@@ -175,15 +178,21 @@ class LeFilteredQuery(LeQuery):
             tmp_rel_filter = dict() #designed to stores rel_field of same DS
             # First step : simplification
             # Trying to delete relational filters done on referenced class uid
-            for tclass, tfield in ref_dict.items():
+            for tclass, tfield in copy.copy(ref_dict).items():
                 #tclass : reference target class
                 #tfield : referenced field from target class
-                if tfield == tclass.uid_fieldname:
+                #
+                #   !!!WARNING!!!
+                # The line below brake multi UID support
+                #
+                if tfield == tclass.uid_fieldname()[0]:
                     #This relational filter can be simplified as 
                     # ref_field, op, value
                     # Note : we will have to dedup filters_orig
                     filters_orig.append((rfield, op, value))
                     del(ref_dict[tclass])
+            if len(ref_dict) == 0:
+                continue
             #Determine what to do with other relational filters given 
             # referenced class datasource
             #Remember : each class in a relational filter has the same 
@@ -268,6 +277,7 @@ class LeFilteredQuery(LeQuery):
     #@param filters_l list : This list of str or tuple (or both)
     #@return a tuple(FILTERS, RELATIONNAL_FILTERS
     #@todo move this doc in another place (a dedicated page ?)
+    #@warning Does not supports multiple UID for an EmClass
     def _prepare_filters(self, filters_l):
         filters = list()
         res_filters = list()
@@ -294,7 +304,7 @@ class LeFilteredQuery(LeQuery):
             else:
                 err_l[field] = NameError(   "'%s' is not a valid relational \
 field name" % fieldname)
-                continue   
+                continue
             # Checking field against target_class
             ret = self._check_field(self._target_class, field)
             if isinstance(ret, Exception):
@@ -313,9 +323,15 @@ a relational field, but %s.%s was present in the filter"
                 #Relationnal field
                 if ref_field is None:
                     # ref_field default value
-                    ref_uid = set(
-                        [lc._uid for lc in field_datahandler.linked_classes])
-                    if len(ref_uid) == 1:
+                    #
+                    #   !!! WARNING !!!
+                    # This piece of code does not supports multiple UID for an
+                    # emclass
+                    #
+                    ref_uid = [ 
+                        lc._uid[0] for lc in field_datahandler.linked_classes]
+
+                    if len(set(ref_uid)) == 1:
                         ref_field = ref_uid[0]
                     else:
                         if len(ref_uid) > 1:
@@ -442,7 +458,8 @@ field to use for the relational filter"
                 if r_ds is None:
                     r_ds = ref_class._datasource_name
                 elif ref_class._datasource_name != r_ds:
-                    return RuntimeError("All referenced class doesn't have the same datasource. Query not possible")
+                    return RuntimeError("All referenced class doesn't have the\
+ same datasource. Query not possible")
                 if ref_field in ref_class.fieldnames(True):
                     ref_dict[ref_class] = ref_field
                 else:

tests/leapi/query/test_filtered.py

@@ -130,3 +130,44 @@ class LeFilteredQueryMultiDataHandlerTestCase(unittest.TestCase):
             qinfos['query_filter'],
             ([('title', '=', 'super titre !')],[])) 
         self.assertEqual(qinfos['field_list'], ['title'])
+
+    def test_uid_as_ref_field(self):
+        """ Testing basic query optimisation with a relationnal filter 
+            with lodel_id as referenced field"""
+        getq = LeGetQuery(
+            dyncode.Indextheme,
+            "texts.lodel_id in 1,2,3,42")
+        qinfos = getq.dump_infos()
+        #No subqueries should be created because referenced field is 
+        #the referenced class UID
+        self.assertEqual(qinfos['subqueries'],[])
+        self.assertEqual(
+            qinfos['query_filter'], 
+            ([('texts', 'in', '1,2,3,42')], []))
+
+    def test_implicit_uid(self):
+        """ Testing query with an UID as implicit referenced field for a 
+            relationnal filter """
+        getq = LeGetQuery(
+            dyncode.Indextheme,
+            "texts in 13,1337,357,80")
+        qinfos = getq.dump_infos()
+        #No subqueries expected
+        self.assertEqual(qinfos['subqueries'],[])
+        self.assertEqual(
+            qinfos['query_filter'], 
+            ([('texts', 'in', '13,1337,357,80')], []))
+
+    def test_same_datasource(self):
+        """ Testing a query with relationnal filters concerning only one
+            datasource to check for 'false positive' in subqueries creation """ 
+        getq = LeGetQuery(
+            dyncode.Text,
+            "linked_persons.fullname = John Doe")
+        qinfos = getq.dump_infos()
+        self.assertEqual(qinfos['subqueries'],[])
+        self.assertEqual(
+            qinfos['query_filter'], 
+            (   [],
+                [(('linked_persons', {dyncode.Person:'fullname'}),'=', 'John Doe')]))
+

tests/tests_conf.d/lodel2.ini

@@ -10,7 +10,7 @@ filename = -
 context = False
 
 [lodel2.editorialmodel]
-groups = index_group
+groups = 
 emfile = examples/em_test.pickle
 dyncode = leapi_dyncode.py
 editormode = True