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