test/unittest_rqlrewrite.py
changeset 4907 e623afd49356
parent 4252 6c4f109c2b03
child 4908 b3ad329cbe17
equal deleted inserted replaced
4906:9a50539f01d1 4907:e623afd49356
   121         self.failUnlessEqual(rqlst.as_string(),
   121         self.failUnlessEqual(rqlst.as_string(),
   122                              u"Any 2 WHERE B eid %(C)s, "
   122                              u"Any 2 WHERE B eid %(C)s, "
   123                              "EXISTS(2 in_state A, B in_group D, E require_state A, "
   123                              "EXISTS(2 in_state A, B in_group D, E require_state A, "
   124                              "E name 'read', E require_group D, A is State, D is CWGroup, E is CWPermission)")
   124                              "E name 'read', E require_group D, A is State, D is CWGroup, E is CWPermission)")
   125 
   125 
   126     def test_optional_var(self):
   126     def test_optional_var_base(self):
   127         card_constraint = ('X in_state S, U in_group G, P require_state S,'
   127         card_constraint = ('X in_state S, U in_group G, P require_state S,'
   128                            'P name "read", P require_group G')
   128                            'P name "read", P require_group G')
   129         rqlst = parse('Any A,C WHERE A documented_by C?')
   129         rqlst = parse('Any A,C WHERE A documented_by C?')
   130         rewrite(rqlst, {('C', 'X'): (card_constraint,)}, {})
   130         rewrite(rqlst, {('C', 'X'): (card_constraint,)}, {})
   131         self.failUnlessEqual(rqlst.as_string(),
   131         self.failUnlessEqual(rqlst.as_string(),
   132                              "Any A,C WHERE A documented_by C?, A is Affaire "
   132                              "Any A,C WHERE A documented_by C?, A is Affaire "
   133                              "WITH C BEING "
   133                              "WITH C BEING "
   134                              "(Any C WHERE C in_state B, D in_group F, G require_state B, G name 'read', "
   134                              "(Any C WHERE EXISTS(C in_state B, D in_group F, G require_state B, G name 'read', "
   135                              "G require_group F, D eid %(A)s, C is Card)")
   135                              "G require_group F), D eid %(A)s, C is Card)")
   136         rqlst = parse('Any A,C,T WHERE A documented_by C?, C title T')
   136         rqlst = parse('Any A,C,T WHERE A documented_by C?, C title T')
   137         rewrite(rqlst, {('C', 'X'): (card_constraint,)}, {})
   137         rewrite(rqlst, {('C', 'X'): (card_constraint,)}, {})
   138         self.failUnlessEqual(rqlst.as_string(),
   138         self.failUnlessEqual(rqlst.as_string(),
   139                              "Any A,C,T WHERE A documented_by C?, A is Affaire "
   139                              "Any A,C,T WHERE A documented_by C?, A is Affaire "
   140                              "WITH C,T BEING "
   140                              "WITH C,T BEING "
   141                              "(Any C,T WHERE C in_state B, D in_group F, G require_state B, G name 'read', "
   141                              "(Any C,T WHERE C title T, EXISTS(C in_state B, D in_group F, "
   142                              "G require_group F, C title T, D eid %(A)s, C is Card)")
   142                              "G require_state B, G name 'read', G require_group F), "
       
   143                              "D eid %(A)s, C is Card)")
       
   144 
       
   145     def test_optional_var_inlined(self):
       
   146         c1 = ('X require_permission P')
       
   147         c2 = ('X inlined_card O, O require_permission P')
       
   148         rqlst = parse('Any C,A,R WHERE A? inlined_card C, A ref R')
       
   149         rewrite(rqlst, {('C', 'X'): (c1,),
       
   150                         ('A', 'X'): (c2,),
       
   151                         }, {})
       
   152         # XXX suboptimal
       
   153         self.failUnlessEqual(rqlst.as_string(),
       
   154                              "Any C,A,R WITH A,R,C BEING "
       
   155                              "(Any A,R,C WHERE A ref R, A? inlined_card C, "
       
   156                              "(A is NULL) OR (EXISTS(A inlined_card B, B require_permission D, "
       
   157                              "B is Card, D is CWPermission)), "
       
   158                              "A is Affaire, C is Card, EXISTS(C require_permission E, E is CWPermission))")
       
   159 
       
   160     # def test_optional_var_inlined_has_perm(self):
       
   161     #     c1 = ('X require_permission P')
       
   162     #     c2 = ('X inlined_card O, U has_read_permission O')
       
   163     #     rqlst = parse('Any C,A,R WHERE A? inlined_card C, A ref R')
       
   164     #     rewrite(rqlst, {('C', 'X'): (c1,),
       
   165     #                     ('A', 'X'): (c2,),
       
   166     #                     }, {})
       
   167     #     self.failUnlessEqual(rqlst.as_string(),
       
   168     #                          "")
   143 
   169 
   144     def test_relation_optimization_1_lhs(self):
   170     def test_relation_optimization_1_lhs(self):
   145         # since Card in_state State as monovalued cardinality, the in_state
   171         # since Card in_state State as monovalued cardinality, the in_state
   146         # relation used in the rql expression can be ignored and S replaced by
   172         # relation used in the rql expression can be ignored and S replaced by
   147         # the variable from the incoming query
   173         # the variable from the incoming query
   241         constraint = ('X concerne Y')
   267         constraint = ('X concerne Y')
   242         rqlst = parse('Any X,C WHERE X? documented_by C')
   268         rqlst = parse('Any X,C WHERE X? documented_by C')
   243         rewrite(rqlst, {('X', 'X'): (constraint,)}, {})
   269         rewrite(rqlst, {('X', 'X'): (constraint,)}, {})
   244         # ambiguity are kept in the sub-query, no need to be resolved using OR
   270         # ambiguity are kept in the sub-query, no need to be resolved using OR
   245         self.failUnlessEqual(rqlst.as_string(),
   271         self.failUnlessEqual(rqlst.as_string(),
   246                              u"Any X,C WHERE X? documented_by C, C is Card WITH X BEING (Any X WHERE X concerne A, X is Affaire)")
   272                              u"Any X,C WHERE X? documented_by C, C is Card WITH X BEING (Any X WHERE EXISTS(X concerne A), X is Affaire)")
   247 
   273 
   248 
   274 
   249     def test_rrqlexpr_nonexistant_subject_1(self):
   275     def test_rrqlexpr_nonexistant_subject_1(self):
   250         constraint = RRQLExpression('S owned_by U')
   276         constraint = RRQLExpression('S owned_by U')
   251         rqlst = parse('Card C')
   277         rqlst = parse('Card C')