def test_testRulesWithLongBodies():
a = relation("a")
b = relation("b")
c = relation("c")
d = relation("d")
e = relation("e")
f = relation("f")
g = relation("g")
A, B, C, D, E, F, G = variables("A", "B", "C", "D", "E", "F", "G")
X = variables(*["X" + str(r) for r in range(1, 23)])
program = [
p(A, B, C, D, E, F, G) <=
[a(A), b(B), c(C), d(D), e(E),
f(F), g(G)],
a(1),
b(1),
c(1),
d(1),
d(2),
e(1),
f(1),
g(1),
]
ans = match_relations(program)
assert ans(p(A, B, C, D, E, F, G),
[p(1, 1, 1, 1, 1, 1, 1),
p(1, 1, 1, 2, 1, 1, 1)])
foo1 = "foo1"
foo2 = "foo2"
foo3 = "foo3"
foo4 = "foo4"
foo5 = "foo5"
bar = "bar"
program = [
p(A, B, C, D, E) <= [
a(A, X[1], X[2], X[3], X[5]),
b(X[6], B, X[7], X[8], X[9]),
c(X[10], X[11], C, X[12], X[13]),
d(X[14], X[15], X[16], D, X[17]),
e(X[18], X[19], X[20], X[21], E),
],
a(foo1, 2, 3, 4, 5),
b(6, foo2, 8, 9, 10),
c(11, 12, foo3, 14, 15),
d(16, 17, 18, foo4, 20),
e(21, 22, 23, 24, foo5),
c(foo1, foo2, bar, foo4, foo5),
]
ans = match_relations(program)
assert ans(
p(A, B, C, D, E),
[p(foo1, foo2, foo3, foo4, foo5),
p(foo1, foo2, bar, foo4, foo5)],
)
def test_testRulesWithUnusedVariables1():
or_ = relation("or")
on = relation("on")
L, L1 = variables("L", "L1")
a = "a"
b = "b"
c = "c"
program = [on(L) <= [or_(L, L1, X), on(L1)], or_(a, b, c), on(b)]
ans = match_relations(program)
assert ans(on(a), [on(a)])
assert ans(on(X), [on(a), on(b)])
def testRulesWithAnonymousVariables():
or_ = relation("or")
on = relation("on")
L, L1 = variables("L", "L1")
a = "a"
b = "b"
c = "c"
d = "d"
program = [
on(L) <= [or_(L, L1, _), on(L1)],
on(L) <= [or_(L, _, L1), on(L1)],
or_(a, b, c),
on(b),
]
ans = match_relations(program)
assert ans(on(a), [on(a)])
assert ans(on(_), [on(a), on(b)])
program = [p() <= [q(_, _), r(_, _)], q(a, b), r(c, d)]
ans = match_relations(program)
assert ans(p(), [p()])
import pytest
from mercylog.types import relation, variables, _
from mercylog.core import query_variables
import pandas as pd
parent = relation("parent")
man = relation("man")
X, Y, Z = variables("X", "Y", "Z")
# def parent(father, son): return dict(father=father, son=son)
# database = [
# parent("Abe", "Bob"), # Abe is a parent of Bob
# parent("Abby", "Bob"),
# parent("Bob", "Carl"),
# parent("Bob", "Connor"),
# parent("Beatrice", "Carl"),
# ]
# db_df = pd.DataFrame(database)
# def test_db_df():
# print(db_df)
# parents_carl = run(database, [], [parent(X, "Carl")])
# assert_df(parents_carl, a_df({X: ["Bob", "Beatrice"]}))
def test_query_variables():
query = [man(X)]
assert query_variables(query) == {X}
query = [parent(X, "Carl")]
assert query_variables(query) == {X}
query = [man(X), parent(X, Z), parent(Z, Y)]
assert query_variables(query) == {X, Y, Z}
query = [parent(X, _)]
assert query_variables(query) == {X}
a = "a"
b = "b"
c = "c"
d = "d"
e = "e"
tc = relation("tc")
not_tc = relation("not_tc")
edge = relation("edge")
node = relation("node")
cycle = relation("cycle")
noncycle = relation("noncycle")
beginsAtC = relation("beginsAtC")
beginsNotAtC = relation("beginsNotAtC ")
noC = relation("noC")
U, V, W, X, Y, Z = variables("U", "V", "W", "X", "Y", "Z")
@toolz.curry
def is_result(engine, a_query, exp_result):
rs = do_query(engine, a_query)
return _equals(rs, exp_result)
def list_set(a_list: List) -> List:
result = []
for a in a_list:
if a not in result:
result.append(a)
return result