def test_testMultiLayeredNegation():
program = [
p() <= ~q(),
q() <= ~r(),
r() <= ~s(),
]
assert match_relations(program, p(), [p()])
def test_TestUnstratifiable1():
program = [
p() <= ~q(),
q() <= ~p(),
]
with pytest.raises(DatalogValidationException):
match_relations(program, None, None)
def test_queryZeroAryPredicates():
program = [p() <= q(), r() <= [p(), s()], q(), s()]
ans = match_relations(program)
assert ans(q(), [q()])
assert ans(p(), [p()])
assert ans(s(), [s()])
assert ans(r(), [r()])
def test_testRulesWithTrue():
a = "a"
true = relation("true")
false = relation("false")
assert match_relations([false()], true(), [])
assert match_relations([p(X) <= q(X), q(a)], true(), [])
def test_queryNonRecursiveIDBPredicate():
db = facts([p("a", "b"), p("b", "c"), p("c", "d")])
rules = [q(X, Y) <= [p(X, Z), p(Z, Y)]]
ans = match3(db, rules)
ans(q(X, Y), [(a, c), (b, d)])
ans(q(X, c), [(a, )])
ans(q("x", b), [])
def test_testRulesWithNoVariables():
program = [p() <= q("a", "b"), q("a", "b")]
ans = match_relations(program)
assert ans(p(), [p()])
program = [p() <= [q("a", "b"), r("c", "d")], q("a", "b"), r("c", "d")]
ans = match_relations(program)
assert ans(p(), [p()])
def test_queryEDBPredicate():
a_q1 = q("a", "b", "c", "d", "e")
a_q2 = q("e", "d", "c", "b", "a")
db = [p(), a_q1, a_q2]
assert match_relations(db, p(), [p()])
ans = match3(facts(db), [])
ans(q(V, W, X, Y, Z), [(a, b, c, d, e), (e, d, c, b, a)])
ans(q(W, "b", X, Y, Z), [(a, c, d, e)])
ans(q(W, X, "d", Y, Z), [])
def test_querymutuallyrecursivepredicates():
program = [
p(X, Y, Z) <= q(X, Y, Z),
q(X, Y, Z) <= p(Z, Y, X),
p(X, Y, Z) <= r(X, Y, Z),
r("a", "b", "c"),
]
ans = match_relations(program)
assert ans(p(X, Y, Z), [p("a", "b", "c"), p("c", "b", "a")])
assert ans(p(X, "b", Y), [p("a", "b", "c"), p("c", "b", "a")])
assert ans(p("a", X, "c"), [p("a", "b", "c")])
assert ans(p(X, "c", Y), [])
def test_queryLinearlyRecursiveIDBPredicate():
# // Acyclic transitive closure.
db = facts([
p("a", "b"),
p("b", "c"),
p("c", "d"),
])
rules = [
q(X, Y) <= p(X, Y),
q(X, Y) <= [p(X, Z), q(Z, Y)],
]
ans = match3(db, rules)
ans(q(X, Y), [(a, b), (a, c), (a, d), (b, c), (b, d), (c, d)])
ans(q("a", X), [(b, ), (c, ), (d, )])
def test_transitive_closure_with_a_cycle():
# // Transitive closure with a cycle.
db = facts([
p("a", "b"),
p("b", "c"),
p("c", "d"),
p("d", "c"),
])
rules = [q(X, Y) <= p(X, Y), q(X, Y) <= [p(X, Z), q(Z, Y)]]
ans = match3(db, rules)
ans(
q(X, Y),
[(a, b), (a, c), (a, d), (b, c), (b, d), (c, c), (c, d), (d, c),
(d, d)],
)
def test_queryNonLinearlyRecursiveIDBPredicate_withCycle():
# // Transitive closure with a cycle.
db = facts([
p("a", "b"),
p("b", "c"),
p("c", "d"),
p("d", "c"),
])
rules = [
q(X, Y) <= p(X, Y),
q(X, Y) <= [q(X, Z), q(Z, Y)],
]
ans = match3(db, rules)
ans(
q(X, Y),
[(a, b), (a, c), (a, d), (b, c), (b, d), (c, c), (c, d), (d, c),
(d, d)],
)
def test_testBinaryDisunificationFail2():
program = [p(X) <= [q(X), not_eq(Y, _)], q(a)]
with pytest.raises(DatalogValidationException):
match_relations(program, p(X), [])
# def test_gt():
# age = relation("age")
# senior = relation("senior")
# program = [
# age("John", 28),
# age("Mary", 40),
# age("Dad", 60),
# age("Mom", 70),
# senior(X, Y) <= [age(X, Y), gt(Y, 59)]
# ]
# ans = match_relations(program)
# assert ans(senior(X, Y), [age("Dad", 60), age("Mom", 70)])
def test_queryIDBPredicatesWithConstants():
program = [p("a", X) <= q(X, X), q("a", "a"), q("b", "b"), q("c", "d")]
ans = match_relations(program)
assert ans(p(Z, W), [p("a", "a"), p("a", "b")])
assert ans(p("a", X), [p("a", "a"), p("a", "b")])
program = [p(X, X) <= q(X, "a"), q("a", "a"), q("b", "b"), q("c", "d")]
ans = match_relations(program)
assert ans(p("a", X), [p("a", "a")])
assert ans(p(X, "a"), [p("a", "a")])
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()])
def test_testRulesWithRepeatedVariablesInAnAtom():
program = [
p(X) <= q(X, X),
q("a", "a"),
q("a", "b"),
q("b", "b"),
]
ans = match_relations(program)
assert ans(p(X), [p("a"), p("b")])
program = [
p(X, Y) <= q(Y, X, Y, X),
q("a", "a", "a", "a"),
q("a", "a", "a", "b"),
q("a", "a", "b", "b"),
q("a", "b", "b", "b"),
q("b", "b", "b", "b"),
]
ans = match_relations(program)
assert ans(p(X, Y), [p("a", "a"), p("b", "b")])
def test_testBinaryUnificationNoAtom():
program = [
p(X, b) <= eq(X, a),
p(b, Y) <= eq(Y, a),
p(X, Y) <= [eq(X, c), eq(Y, d)],
p(X, X) <= eq(X, c),
p(X, Y) <= [eq(X, d), eq(Y, X)],
p(X, Y) <= [eq(X, Y), eq(X, e)],
]
ans = match_relations(program)
assert ans(p(X, Y), [p(a, b), p(b, a), p(c, d), p(c, c), p(d, d), p(e, e)])
program = program + [q(X, Y) <= p(X, Y)]
ans = match_relations(program)
assert ans(q(X, Y), [q(a, b), q(b, a), q(c, d), q(c, c), q(d, d), q(e, e)])
def test_queryNonLinearlyRecursiveIDBPredicate():
db = facts([
p("a", "b"),
p("b", "c"),
p("c", "d"),
])
rules = [
q(X, Y) <= p(X, Y),
q(X, Y) <= [q(X, Z), q(Z, Y)],
]
ans = match3(db, rules)
ans(q(X, Y), [(a, b), (a, c), (a, d), (b, c), (b, d), (c, d)])
ans(q(a, X), [(b, ), (c, ), (d, )])
def test_testExplicitUnification1():
program = [p() <= [~q(X, b), eq(X, a)]]
assert match_relations(program, p(), [p()])
def test_testNegatedUnboundVariable3():
with pytest.raises(DatalogValidationException):
match_relations([p() <= [~q(X, a), ~r(X)]], p(), [])
def testUselessBinaryUnification():
program = [p(X) <= [q(X), eq(X, Y)], q(a), p(b) <= eq(X, _)]
ans = match_relations(program)
with pytest.raises(DatalogValidationException):
ans(p(X), [])
def test_querymutuallyrecursivepredicates_no_facts():
program = [p(X, Y, Z) <= q(X, Y, Z), q(X, Y, Z) <= p(X, Y, Z)]
ans = match_relations(program)
assert ans(p(X, Y, Z), [])
assert ans(q(X, Y, Z), [])
def test_testImpossibleBinaryDisunification3():
program = [p() <= [q(X), eq(X, X)]]
ans = match_relations(program)
assert ans(p(), [])
def test_testBinaryDisunificationNoAtom():
program = [p() <= not_eq(a, b), q() <= [not_eq(X, Y), eq(X, a), eq(Y, b)]]
ans = match_relations(program)
assert ans(p(), [p()])
assert ans(q(), [q()])
def test_queryIDBPredicateWithExplicitIDBFact():
# // Note that q is defined by a rule, but we also give an explicit fact.
db = facts([r("a", "b"), q("b", "c")])
rules = [q(X, Y) <= r(X, Y)]
ans = match3(db, rules)
ans(q(X, Y), [(a, b), (b, c)])
def test_queryUndefinedPredicate():
db1 = facts([p()])
match3(db1, [], q(), [])
def test_testExplicitUnification2():
program = [p() <= [~q(X, b), not_eq(X, a)]]
with pytest.raises(DatalogValidationException):
match_relations(program, p(), [])
def test_testNegatedNoPositiveAtom():
program = [p(a) <= ~q(a), p(b) <= [~q(X), eq(X, b)]]
assert match_relations(program, p(X), [p(a), p(b)])
def test_testBinaryDisunificationFail1():
program = [p() <= [~q(a, b), not_eq(X, _)]]
with pytest.raises(DatalogValidationException):
match_relations(program, p(), [])
def test_TestUnstratifiable2():
edb = relation("edb")
program = [p(X) <= [~q(X), edb(X)], q(X) <= [~p(X), edb(X)], edb(a)]
with pytest.raises(DatalogValidationException):
match_relations(program, None, None)
def test_testUnboundVariable1():
a = "a"
b = "b"
with pytest.raises(DatalogValidationException):
match_relations([p(X, b)], p(X, Y), [])
match_relations([q(X, Y) <= p(X, b), p(a, b)], q(X, Y), [])
