def analyze_rq(rq): print("RQL:", rq) helper1 = RQLHelper(schema, Resolver=ETypeResolver) helper2 = RQLHelper(schema, Resolver=ETypeResolver2) node1 = helper1.parse(rq) node2 = helper2.parse(rq) sol1 = helper1.get_solutions(node1) sol2 = helper2.get_solutions(node2) return helper1, helper2, node1, node2, sol1, sol2
def rqlhelper(self): return RQLHelper(self.schema, special_relations={'eid': 'uid', 'has_text': 'fti'})
def setUp(self): self.helper = RQLHelper(DummySchema(), {'eid': self._type_from_eid})
class AnalyzerClassTest(TestCase): """check wrong queries arre correctly detected """ eids = {10: 'Eetype'} def _type_from_eid(self, eid): return self.eids.get(eid, 'Person') def setUp(self): self.helper = RQLHelper(DummySchema(), {'eid': self._type_from_eid}) def test_raise(self): for rql in UNRESOLVABLE_QUERIES: if DEBUG: print(rql) node = self.helper.parse(rql) self.assertRaises(TypeResolverException, self.helper.compute_solutions, node, debug=DEBUG) def test_base_1(self): node = self.helper.parse('Any X') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Address' }, { 'X': 'Company' }, { 'X': 'Eetype' }, { 'X': 'Person' }, { 'X': 'Student' }]) def test_base_2(self): node = self.helper.parse('Person X') # check constant type of the is relation inserted self.assertEqual(node.children[0].where.children[1].children[0].type, 'etype') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertEqual(sols, [{'X': 'Person'}]) def test_base_3(self): node = self.helper.parse('Any X WHERE X eid 1') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertEqual(sols, [{'X': 'Person'}]) self.helper.simplify(node) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertEqual(sols, [{}]) def test_base_guess_1(self): node = self.helper.parse('Person X WHERE X work_for Y') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'X': 'Person', 'Y': 'Company'}]) def test_base_guess_2(self): node = self.helper.parse('Any X WHERE X name "Logilab"') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Company' }, { 'X': 'Person' }, { 'X': 'Student' }]) def test_non_regr_no_final_type(self): """https://www.logilab.net/elo/ticket/9042""" node = self.helper.parse( 'Any X WHERE X creation_date > ((2009 - 4) - 16)') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Address' }, { 'X': 'Company' }, { 'X': 'Eetype' }, { 'X': 'Person' }, { 'X': 'Student' }]) def test_is_instance_of_1(self): node = self.helper.parse('Any X WHERE X is_instance_of Person') # check constant type of the is relation inserted self.assertEqual(node.children[0].where.children[1].children[0].type, 'etype') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'X': 'Person'}, {'X': 'Student'}]) def test_is_instance_of_2(self): node = self.helper.parse('Any X WHERE X is_instance_of Student') # check constant type of the is relation inserted self.assertEqual(node.children[0].where.children[1].children[0].type, 'etype') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertEqual(sols, [{'X': 'Student'}]) def test_is_query(self): node = self.helper.parse('Any T WHERE X name "logilab", X is T') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Company', 'T': 'Eetype' }, { 'X': 'Person', 'T': 'Eetype' }, { 'X': 'Student', 'T': 'Eetype' }]) def test_is_query_const(self): node = self.helper.parse('Any X WHERE X is T, T eid 10') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Address', 'T': 'Eetype' }, { 'X': 'Company', 'T': 'Eetype' }, { 'X': 'Eetype', 'T': 'Eetype' }, { 'X': 'Person', 'T': 'Eetype' }, { 'X': 'Student', 'T': 'Eetype' }]) def test_not(self): node = self.helper.parse('Any X WHERE NOT X is Person') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions expected = ALL_SOLS[:] expected.remove({'X': 'Person'}) self.assertCountEqual(sols, expected) def test_not_identity(self): node = self.helper.parse( 'Any X WHERE X located A, P is Person, NOT X identity P') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [ { 'X': 'Company', 'A': 'Address', 'P': 'Person' }, { 'X': 'Person', 'A': 'Address', 'P': 'Person' }, { 'X': 'Student', 'A': 'Address', 'P': 'Person' }, ]) def test_uid_func_mapping(self): h = self.helper def type_from_uid(name): self.assertEqual(name, "Logilab") return 'Company' uid_func_mapping = {'name': type_from_uid} # constant as rhs of the uid relation node = h.parse('Any X WHERE X name "Logilab"') h.compute_solutions(node, uid_func_mapping, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'X': 'Company'}]) # variable as rhs of the uid relation node = h.parse('Any N WHERE X name N') h.compute_solutions(node, uid_func_mapping, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Company', 'N': 'String' }, { 'X': 'Person', 'N': 'String' }, { 'X': 'Student', 'N': 'String' }]) # substitute as rhs of the uid relation node = h.parse('Any X WHERE X name %(company)s') h.compute_solutions(node, uid_func_mapping, {'company': 'Logilab'}, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'X': 'Company'}]) def test_non_regr_subjobj1(self): h = self.helper def type_from_uid(name): self.assertEqual(name, "Societe") return 'Eetype' uid_func_mapping = {'name': type_from_uid} # constant as rhs of the uid relation node = h.parse('Any X WHERE X name "Societe", X is ISOBJ, ISSIBJ is X') h.compute_solutions(node, uid_func_mapping, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Eetype', 'ISOBJ': 'Eetype', 'ISSIBJ': 'Address' }, { 'X': 'Eetype', 'ISOBJ': 'Eetype', 'ISSIBJ': 'Company' }, { 'X': 'Eetype', 'ISOBJ': 'Eetype', 'ISSIBJ': 'Eetype' }, { 'X': 'Eetype', 'ISOBJ': 'Eetype', 'ISSIBJ': 'Person' }, { 'X': 'Eetype', 'ISOBJ': 'Eetype', 'ISSIBJ': 'Student' }]) def test_non_regr_subjobj2(self): h = self.helper def type_from_uid(name): self.assertEqual(name, "Societe") return 'Eetype' uid_func_mapping = {'name': type_from_uid} node = h.parse( 'Any X WHERE X name "Societe", X is ISOBJ, ISSUBJ is X, ' 'X is_instance_of ISIOOBJ, ISIOSUBJ is_instance_of X') h.compute_solutions(node, uid_func_mapping, debug=DEBUG) select = node.children[0] sols = select.solutions self.assertEqual(len(sols), 25) def var_sols(var): s = set() for sol in sols: s.add(sol.get(var)) return s self.assertEqual(var_sols('X'), set(('Eetype', ))) self.assertEqual(var_sols('X'), select.defined_vars['X'].stinfo['possibletypes']) self.assertEqual( var_sols('ISSUBJ'), set(('Address', 'Company', 'Eetype', 'Person', 'Student')), ) self.assertEqual( var_sols('ISSUBJ'), select.defined_vars['ISSUBJ'].stinfo['possibletypes'], ) self.assertEqual(var_sols('ISOBJ'), set(('Eetype', ))) self.assertEqual( var_sols('ISOBJ'), select.defined_vars['ISOBJ'].stinfo['possibletypes'], ) self.assertEqual( var_sols('ISIOSUBJ'), set(('Address', 'Company', 'Eetype', 'Person', 'Student')), ) self.assertEqual( var_sols('ISIOSUBJ'), select.defined_vars['ISIOSUBJ'].stinfo['possibletypes'], ) self.assertEqual(var_sols('ISIOOBJ'), set(('Eetype', ))) self.assertEqual( var_sols('ISIOOBJ'), select.defined_vars['ISIOOBJ'].stinfo['possibletypes'], ) def test_unusableuid_func_mapping(self): h = self.helper def type_from_uid(name): self.assertEqual(name, "Logilab") return 'Company' uid_func_mapping = {'name': type_from_uid} node = h.parse('Any X WHERE NOT X name %(company)s') h.compute_solutions(node, uid_func_mapping, {'company': 'Logilab'}, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, ALL_SOLS) node = h.parse('Any X WHERE X name > %(company)s') h.compute_solutions(node, uid_func_mapping, {'company': 'Logilab'}, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, ALL_SOLS) def test_base_guess_3(self): node = self.helper.parse('Any Z GROUPBY Z WHERE X name Z') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Company', 'Z': 'String' }, { 'X': 'Person', 'Z': 'String' }, { 'X': 'Student', 'Z': 'String' }]) def test_var_name(self): node = self.helper.parse( 'Any E1 GROUPBY E1 WHERE E2 is Person, E2 name E1') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'E2': 'Person', 'E1': 'String'}]) def test_relation_eid(self): node = self.helper.parse('Any E2 WHERE E2 work_for E1, E2 eid 2') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'E1': 'Company', 'E2': 'Person'}]) self.helper.simplify(node) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'E1': 'Company'}]) node = self.helper.parse('Any E1 WHERE E2 work_for E1, E2 eid 2') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'E1': 'Company', 'E2': 'Person'}]) self.helper.simplify(node) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'E1': 'Company'}]) def test_not_symmetric_relation_eid(self): node = self.helper.parse('Any P WHERE X eid 0, NOT X connait P') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'P': 'Person', 'X': 'Person' }, { 'P': 'Student', 'X': 'Person' }]) self.helper.simplify(node) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'P': 'Person'}, {'P': 'Student'}]) def test_union(self): node = self.helper.parse( '(Any P WHERE X eid 0, X is Person, NOT X connait P) ' 'UNION (Any E1 WHERE E2 work_for E1, E2 eid 2)') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual( sols, [{ 'P': 'Person', 'X': 'Person' }, { 'P': 'Student', 'X': 'Person' }], ) sols = node.children[1].solutions self.assertCountEqual(sols, [{'E1': 'Company', 'E2': 'Person'}]) self.helper.simplify(node) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual( sols, [{ 'P': 'Person' }, { 'P': 'Student' }], ) sols = node.children[1].solutions self.assertCountEqual(sols, [{'E1': 'Company'}]) def test_exists(self): node = self.helper.parse( "Any X WHERE X firstname 'lulu'," "EXISTS (X owned_by U, U name 'lulufanclub' OR U name 'managers');" ) self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'X': 'Person', 'U': 'Person' }, { 'X': 'Student', 'U': 'Person' }]) def test_subqueries_base(self): node = self.helper.parse( 'Any L, Y, F WHERE Y located L ' 'WITH Y,F BEING ((Any X,F WHERE X is Person, X firstname F) ' 'UNION (Any X,F WHERE X is Company, X name F))') self.helper.compute_solutions(node, debug=DEBUG) self.assertEqual(node.children[0].with_[0].query.children[0].solutions, [{ 'X': 'Person', 'F': 'String' }]) self.assertEqual(node.children[0].with_[0].query.children[1].solutions, [{ 'X': 'Company', 'F': 'String' }]) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'Y': 'Company', 'L': 'Address', 'F': 'String' }, { 'Y': 'Person', 'L': 'Address', 'F': 'String' }]) def test_subqueries_aggregat(self): node = self.helper.parse('Any L, SUM(X)*100/Y GROUPBY L ' 'WHERE X is Person, X located L ' 'WITH Y BEING (Any SUM(X) WHERE X is Person)') self.helper.compute_solutions(node, debug=DEBUG) self.assertEqual(node.children[0].with_[0].query.children[0].solutions, [{ 'X': 'Person' }]) self.assertEqual(node.children[0].solutions, [{ 'X': 'Person', 'Y': 'Person', 'L': 'Address' }]) def test_subqueries_outer_filter_type(self): # this kind of query may be generated by erudi's facettes box node = self.helper.parse( 'Any L, Y, F WHERE Y located L, Y is Person ' 'WITH Y,F BEING ((Any X,F WHERE X is Person, X firstname F) ' 'UNION (Any X,F WHERE X is Company, X name F))') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'Y': 'Person', 'L': 'Address', 'F': 'String' }]) self.assertEqual(node.children[0].with_[0].query.children[0].solutions, [{ 'X': 'Person', 'F': 'String' }]) # auto-simplification self.assertEqual( node.as_string(), 'Any L,Y,F WHERE Y located L, Y is Person WITH Y,F ' 'BEING (Any X,F WHERE X is Person, X firstname F)', ) self.assertEqual( node.children[0].with_[0].query.children[0].solutions, [{ 'X': 'Person', 'F': 'String' }], ) def test_insert(self): node = self.helper.parse( 'INSERT Person X : X name "toto", X work_for Y WHERE Y name "logilab"' ) self.helper.compute_solutions(node, debug=DEBUG) sols = node.solutions self.assertCountEqual(sols, [{'X': 'Person', 'Y': 'Company'}]) def test_delete(self): node = self.helper.parse( 'DELETE Person X WHERE X name "toto", X work_for Y') self.helper.compute_solutions(node, debug=DEBUG) sols = node.solutions self.assertCountEqual(sols, [{'X': 'Person', 'Y': 'Company'}]) def test_set(self): node = self.helper.parse( 'SET X name "toto", X work_for Y WHERE Y name "logilab"') self.helper.compute_solutions(node, debug=DEBUG) sols = node.solutions self.assertCountEqual(sols, [{ 'X': 'Person', 'Y': 'Company' }, { 'X': 'Student', 'Y': 'Company' }]) def test_set_mathexpr(self): node = self.helper.parse( 'SET S number N/4 WHERE P work_for S, P number N') self.helper.compute_solutions(node, debug=DEBUG) sols = node.solutions self.assertCountEqual(sols, [{ 'P': 'Person', 'S': 'Company', 'N': 'Int' }, { 'P': 'Student', 'S': 'Company', 'N': 'Int' }]) def test_nonregr_not_u_ownedby_u(self): node = self.helper.parse('Any U WHERE NOT U owned_by U') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{'U': 'Person'}]) def test_selection_with_cast(self): node = self.helper.parse( 'Any X WHERE X name CAST(String, E), Y eid E, X owned_by Y') self.helper.compute_solutions(node, debug=DEBUG) sols = node.children[0].solutions self.assertCountEqual(sols, [{ 'E': 'Int', 'X': 'Company', 'Y': 'Person' }, { 'E': 'Int', 'X': 'Person', 'Y': 'Person' }, { 'E': 'Int', 'X': 'Student', 'Y': 'Person' }]) def test_set_with_cast(self): node = self.helper.parse( 'SET X name CAST(String, E), X work_for Y WHERE Y eid E') self.helper.compute_solutions(node, debug=DEBUG) sols = node.solutions self.assertCountEqual(sols, [{ 'X': 'Person', 'Y': 'Company', 'E': 'Int' }, { 'X': 'Student', 'Y': 'Company', 'E': 'Int' }])
# You should have received a copy of the GNU Lesser General Public License along # with rql. If not, see <http://www.gnu.org/licenses/>. import sys import itertools from datetime import date, datetime from logilab.common.testlib import TestCase, unittest_main from rql import nodes, stmts, parse, BadRQLQuery, RQLHelper, RQLException, CoercionError from rql.stcheck import RQLSTAnnotator from unittest_analyze import DummySchema schema = DummySchema() annotator = RQLSTAnnotator(schema, {}) helper = RQLHelper(schema, None, {'eid': 'uid'}) def sparse(rql): tree = helper.parse(rql) helper.compute_solutions(tree) return tree class EtypeFromPyobjTC(TestCase): def test_bool(self): self.assertEqual(nodes.etype_from_pyobj(True), 'Boolean') self.assertEqual(nodes.etype_from_pyobj(False), 'Boolean') def test_int(self): self.assertEqual(nodes.etype_from_pyobj(0), 'Int')
def setUp(self): self.h = RQLHelper(DummySchema(), None)
class RQLCompareClassTest(TestCase): """ Compare RQL strings """ @classmethod def setUpClass(cls): raise SkipTest('broken') def setUp(self): self.h = RQLHelper(DummySchema(), None) def _compareEquivalent(self, r1, r2): """fails if the RQL strings r1 and r2 are equivalent""" self.skipTest('broken') self.failUnless(self.h.compare(r1, r2), 'r1: %s\nr2: %s' % (r1, r2)) def _compareNotEquivalent(self, r1, r2): """fails if the RQL strings r1 and r2 are not equivalent""" self.failIf(self.h.compare(r1, r2), 'r1: %s\nr2: %s' % (r1, r2)) # equivalent queries ################################################## def test_same_request_simple(self): r = "Any X WHERE X is Note ;" self._compareEquivalent(r, r) def test_same_request_diff_names(self): r1 = "Any X ;" r2 = "Any Y ;" self._compareEquivalent(r1, r2) def test_same_request_diff_names_simple(self): r1 = "Any X WHERE X is Note ;" r2 = "Any Y WHERE Y is Note ;" self._compareEquivalent(r1, r2) def test_same_request_any(self): r1 = "Any X WHERE X is Note ;" r2 = "Note X ;" self._compareEquivalent(r1, r2) def test_same_request_any_diff_names(self): r1 = "Any X WHERE X is Note ;" r2 = "Note Y ;" self._compareEquivalent(r1, r2) def test_same_request_complex(self): r = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") self._compareEquivalent(r, r) def test_same_request_comma_and(self): r1 = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") r2 = ("Any N, N2 WHERE N is Note AND N2 is Note AND N a_faire_par P1 " "AND P1 nom 'jphc' AND N2 a_faire_par P2 AND P2 nom 'ocy' ;") self._compareEquivalent(r1, r2) def test_same_request_diff_names_complex(self): r1 = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") r2 = ("Any Y, X WHERE X is Note, Y is Note, X a_faire_par A1, " "A1 nom 'ocy', Y a_faire_par A2, A2 nom 'jphc' ;") self._compareEquivalent(r1, r2) def test_same_request_diff_order(self): r1 = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") r2 = ("Any N, N2 WHERE N2 is Note, N is Note, N a_faire_par P1, " "N2 a_faire_par P2, P2 nom 'ocy', P1 nom 'jphc' ;") self._compareEquivalent(r1, r2) def test_same_request_diff_order_diff_names(self): r1 = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") r2 = ("Any Y, X WHERE X is Note, X a_faire_par P1, P1 nom 'ocy', " "Y is Note, Y a_faire_par P2, P2 nom 'jphc' ;") self._compareEquivalent(r1, r2) def test_same_request_with_comparison(self): r1 = "Note N WHERE N a_faire_par P, P nom 'jphc', K creation_date > today-10;" r2 = "Note K WHERE K a_faire_par Y, K creation_date > today-10, Y nom 'jphc';" self._compareEquivalent(r1, r2) def test_same_request_in_or(self): r1 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc' or P nom 'ludal';") r2 = "Note K WHERE K a_faire_par Y, K creation_date > today-10, Y nom in ('jphc', 'ludal');" self._compareEquivalent(r1, r2) def test_same_request_reverse_or(self): r1 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc' or P nom 'ludal';") r2 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'ludal' or P nom 'jphc';") self._compareEquivalent(r1, r2) def test_same_request_reverse_or2(self): r1 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P prenom 'jphc' or P nom 'ludal';") r2 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'ludal' or P prenom 'jphc';") self._compareEquivalent(r1, r2) def test_same_request_duplicate_expr(self): r1 = "Note N WHERE N creation_date D, N creation_date D;" r2 = "Note N WHERE N creation_date D;" self._compareEquivalent(r1, r2) def test_same_request_not_in_or(self): r1 = ("Note K WHERE K a_faire_par Y, K creation_date > today-10, " "not Y nom in ('jphc', 'ludal');") r2 = ("Note K WHERE K a_faire_par Y, K creation_date > today-10, " "not Y nom 'jphc' and not Y nom 'ludal';") self._compareEquivalent(r1, r2) # non equivalent queries ################################################## def test_diff_request(self): r1 = ("Any N, N2 WHERE N is Note, N2 is Note, N a_faire_par P1, " "P1 nom 'jphc', N2 a_faire_par P2, P2 nom 'ocy' ;") r2 = "Any X WHERE X is Note ;" self._compareNotEquivalent(r1, r2) def test_diff_request_and_or(self): r1 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc' or P nom 'ludal';") r2 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc', P nom 'ludal';") self._compareNotEquivalent(r1, r2) def test_diff_request_and_or2(self): r1 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc' or P prenom 'ludal';") r2 = ("Note N WHERE N creation_date > today-10, N a_faire_par P, " "P nom 'jphc', P prenom 'ludal';") self._compareNotEquivalent(r1, r2) def test_diff_request_non_selected_var(self): r1 = "Any X, D WHERE X is Note, X creation_date D ;" r2 = "Any X WHERE X is Note, X creation_date D ;" self._compareNotEquivalent(r1, r2) def test_diff_request_aggregat(self): r1 = "Any X, D WHERE X is Note, X creation_date D ;" r2 = "Any X, MAX(D) WHERE X is Note, X creation_date D ;" self._compareNotEquivalent(r1, r2) def test_diff_request_group(self): r1 = "Any X GROUPBY X WHERE X is Note;" r2 = "Any X WHERE X is Note;" self._compareNotEquivalent(r1, r2) def test_diff_request_sort(self): r1 = "Any X ORDERBY X WHERE X is Note;" r2 = "Any X WHERE X is Note;" self._compareNotEquivalent(r1, r2) def test_diff_request_not(self): r1 = "Any X WHERE NOT X is Note ;" r2 = "Any X WHERE X is Note;" self._compareNotEquivalent(r1, r2) def test_diff_request_not_in_or(self): r1 = ("Note K WHERE K a_faire_par Y, K creation_date > today-10, " "not Y nom in ('jphc', 'ludal');") r2 = ("Note K WHERE K a_faire_par Y, K creation_date > today-10, " "not Y nom 'jphc' or not Y nom 'ludal';") self._compareNotEquivalent(r1, r2)
def setUp(self): helper = RQLHelper(DummySchema(), None, {'eid': 'uid'}) self.parse = helper.parse self.simplify = helper.simplify