def test_and_operator_triple(self):
p1 = parse("eq(a,0)&eq(b,1)&eq(c,2)")
p2 = parse("and(eq(a, 0), eq(b, 1), eq(c, 2))")
p3 = {
"name":
"and",
"args": [
{
"name": "eq",
"args": ["a", 0]
},
{
"name": "eq",
"args": ["b", 1]
},
{
"name": "eq",
"args": ["c", 2]
},
],
}
assert p1 == p2
assert p1 == p3
def test_unbalanced_parenthesis_11(self):
parsed = parse(r"in(foo,(foo,bar))&sort(+foo)&eq(userid,user)")
assert parsed == {'name': 'and', 'args': [
{'name': 'in', 'args': ['foo', ('foo', 'bar')]},
{'name': 'sort', 'args': [('+', 'foo')]},
{'name': 'eq', 'args': ['userid', 'user']}
]}
with pytest.raises(RQLSyntaxError) as exc:
parse(r"in(foo,(foo,bar))&sort(+foo))&eq(userid,user)")
assert exc.value.args[2] == "Expected end of text"
def test_recurse_function(self):
expr = "recurse(lero)"
rep = {"name": "recurse", "args": ["lero"]}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_limit_function(self):
expr = "limit(10,0)"
rep = {"name": "limit", "args": [10, 0]}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_result_functions(self, func):
expr = "%s()" % func
rep = {"name": func, "args": []}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_aggregate_functions(self, func):
expr = "%s((a,b,c))" % func
rep = {"name": func, "args": [("a", "b", "c")]}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_bool_functions(self, func, args):
expr = "%s(%s)" % (func, ",".join(args))
rep = {"name": func, "args": args}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_member_functions(self, func):
expr = "%s(name,(a,b))" % func
rep = {"name": func, "args": ["name", ("a", "b")]}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_parenthesis(self):
pd = parse("(state=Florida|state=Alabama)&gender=female")
rep = {
"name":
"and",
"args": [
{
"name":
"or",
"args": [
{
"name": "eq",
"args": ["state", "Florida"]
},
{
"name": "eq",
"args": ["state", "Alabama"]
},
],
},
{
"name": "eq",
"args": ["gender", "female"]
},
],
}
assert pd == rep
def test_unparser_error_4(self):
expr = r"and(eq(accountId,(123456789)), eq(yyyy,(2020)), eq(mm,(10)))"
rep = {
"name": "and",
"args": [
{"name": "eq", "args": ["accountId", (123456789,)]},
{"name": "eq", "args": ["yyyy", (2020,)]},
{"name": "eq", "args": ["mm", (10,)]},
],
}
pd = parse(expr)
upd = parse(unparse(pd))
assert pd == rep
assert upd == pd
def rql(self, query, limit=None):
if len(self._entities) > 1:
raise NotImplementedError("Query must have a single entity")
expr = query
if not expr:
self.rql_parsed = None
self.rql_expr = ""
else:
self.rql_expr = expr
try:
self.rql_parsed = parse(expr)
except RQLSyntaxError as exc:
raise self._rql_error_cls("RQL Syntax error: %r" % (exc.args,))
self._rql_select_clause = []
self._rql_values_clause = None
self._rql_scalar_clause = None
self._rql_where_clause = None
self._rql_order_by_clause = None
self._rql_limit_clause = None
self._rql_offset_clause = None
self._rql_one_clause = None
self._rql_distinct_clause = None
self._rql_group_by_clause = None
self._rql_joins = []
self._rql_walk(self.rql_parsed)
query = self
for other in self._rql_joins:
query = query.join(other)
if self._rql_where_clause is not None:
query = query.filter(self._rql_where_clause)
if self._rql_order_by_clause is not None:
query = query.order_by(*self._rql_order_by_clause)
# limit priority is: default, method parameter, querystring parameter
if self._rql_default_limit:
query = query.limit(self._rql_default_limit)
if limit is not None:
query = query.limit(limit)
if self._rql_limit_clause is not None:
query = query.limit(self._rql_limit_clause)
if self._rql_offset_clause is not None:
query = query.offset(self._rql_offset_clause)
if self._rql_distinct_clause is not None:
query = query.distinct()
return query
def test_recurse_function(self):
expr = 'recurse(lero)'
rep = {'name': 'recurse', 'args': ['lero']}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_result_functions(self, func):
expr = '%s()' % func
rep = {'name': func, 'args': []}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_limit_function(self):
expr = 'limit(10,0)'
rep = {'name': 'limit', 'args': [10, 0]}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_member_functions(self, func):
expr = '%s(name,(a,b))' % func
rep = {'name': func, 'args': ['name', ('a', 'b')]}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_aggregate_functions(self, func):
expr = '%s((a,b,c))' % func
rep = {'name': func, 'args': [('a', 'b', 'c')]}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_bool_functions(self, func, args):
expr = '%s(%s)' % (func, ','.join(args))
rep = {'name': func, 'args': args}
pd = parse(expr)
assert rep == pd
assert unparse(pd) == expr
def test_explicit_types_symmetry(in_, out):
parsed = {"name": "eq", "args": ["a", in_]}
upd = unparse(parsed)
pd = parse(upd)
assert pd == parsed
assert upd == "eq(a,%s)" % out
def test_parenthesis(self):
pd = parse('(state=Florida|state=Alabama)&gender=female')
rep = {
'name':
'and',
'args': [{
'name':
'or',
'args': [
{
'name': 'eq',
'args': ['state', 'Florida']
},
{
'name': 'eq',
'args': ['state', 'Alabama']
},
]
}, {
'name': 'eq',
'args': ['gender', 'female']
}]
}
assert pd == rep
def test_or_operator(self):
p1 = parse('(f(1)|f(2))')
p2 = parse('or(f(1),f(2))')
p3 = {
'name': 'or',
'args': [{
'name': 'f',
'args': [1]
}, {
'name': 'f',
'args': [2]
}]
}
assert p1 == p2
assert p1 == p3
def test_or_operator(self):
p1 = parse("(f(1)|f(2))")
p2 = parse("or(f(1),f(2))")
p3 = {
"name": "or",
"args": [{
"name": "f",
"args": [1]
}, {
"name": "f",
"args": [2]
}],
}
assert p1 == p2
assert p1 == p3
def test_and_operator_pair(self):
p1 = parse('eq(a,0)&eq(b,1)')
p2 = parse('and(eq(a, 0), eq(b, 1))')
p3 = {
'name':
'and',
'args': [{
'name': 'eq',
'args': ['a', 0]
}, {
'name': 'eq',
'args': ['b', 1]
}]
}
assert p1 == p2
assert p1 == p3
def test_rfc_aggregate_example(self):
expr = "aggregate(departmentId,sum(sales))"
rep = {
"name": "aggregate",
"args": ["departmentId", {"name": "sum", "args": ["sales"]}],
}
pd = parse(expr)
assert pd == rep
def test_string_starting_with_number(self):
expr = 'uuid=27f1db1c029e4a428961b85433de25fd'
rep = {
'name': 'eq',
'args': ['uuid', '27f1db1c029e4a428961b85433de25fd']
}
pd = parse(expr)
assert pd == rep
def test_query_functions(self, func):
expr = "%s(username,password,(address,city))" % func
rep = {
"name": func,
"args": ["username", "password", ("address", "city")]
}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_query_functions(self, func):
expr = '%s(username,password,(address,city))' % func
rep = {
'name': func,
'args': ['username', 'password', ('address', 'city')]
}
pd = parse(expr)
assert pd == rep
assert unparse(pd) == expr
def test_and_operator(self, expr):
rep = {
"name": "and",
"args": [
{"name": "eq", "args": ["foo", 3]},
{"name": "lt", "args": ["price", 10]},
],
}
assert parse(expr) == rep
def test_rfc_aggregate_example(self):
expr = 'aggregate(departmentId,sum(sales))'
rep = {
'name': 'aggregate',
'args': ['departmentId', {
'name': 'sum',
'args': ['sales']
}]
}
pd = parse(expr)
assert pd == rep
def test_rfc_nested_operators_example(self):
expr = "or(eq(category,toy),eq(category,food))"
rep = {
"name": "or",
"args": [
{"name": "eq", "args": ["category", "toy"]},
{"name": "eq", "args": ["category", "food"]},
],
}
pd = parse(expr)
assert pd == rep
def test_rfc_abstract_example(self):
expr = "category=dates&sort(+price)"
rep = {
"name": "and",
"args": [
{"name": "eq", "args": ["category", "dates"]},
{"name": "sort", "args": [("+", "price")]},
],
}
pd = parse(expr)
assert pd == rep
