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_TestUnstratifiable1(): program = [ p() <= ~q(), q() <= ~p(), ] with pytest.raises(DatalogValidationException): match_relations(program, None, None)
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_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_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 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_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_testMultiLayeredNegation(): program = [ p() <= ~q(), q() <= ~r(), r() <= ~s(), ] assert match_relations(program, p(), [p()])
def test_testNegatedAtomFirst(): n = relation("n") e = relation("e") unreach = relation("unreach") program = [ n(a), n(b), n(c), e(a, b), e(b, c), r(X, Y) <= e(X, Y), r(X, Y) <= [e(X, Z), r(Z, Y)], unreach(X, Y) <= [~r(X, Y), n(X), n(Y)], ] assert match_relations( program, unreach(X, Y), [ unreach(b, a), unreach(c, b), unreach(c, a), unreach(a, a), unreach(b, b), unreach(c, c), ], )
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_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 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_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 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_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_TestStratifiable_1(): program = [ edge(a, b), edge(b, c), tc(a, c), tc(X, Y) <= edge(X, Y), tc(X, Y) <= [tc(X, Z), tc(Z, Y)], node(X) <= edge(X, _), node(X) <= edge(_, X), not_tc(X, Y) <= [node(X), node(Y), ~tc(X, Y)], ] ans = match_relations(program) assert ans(tc(X, Y), [tc(a, b), tc(b, c), tc(a, c)])
def test_testRuleThatEndsInAGroundAtom(): edge = relation("edge") tc = relation(("tc")) trigger = relation("trigger") program = [ edge(0, 1), edge(1, 2), edge(2, 3), tc(X, Y) <= edge(X, Y), tc(X, Y) <= [edge(X, Z), tc(Z, Y), trigger()], ] ans = match_relations(program) assert ans(tc(X, Y), [tc(0, 1), tc(1, 2), tc(2, 3)]) program = program + [trigger()] ans = match_relations(program) assert ans( tc(X, Y), [tc(0, 1), tc(0, 2), tc(0, 3), tc(1, 2), tc(1, 3), tc(2, 3)])
def test_queryNestedPredicates(): one = relation("1") two = relation("2") three = relation("3") four = relation("4") five = relation("5") program = [ one(X, Y, Z) <= two(X, Y, Z), two(X, Y, Z) <= three(X, Y, Z), three(X, Y, Z) <= four(X, Y, Z), four(X, Y, Z) <= five(X, Y, Z), five("a", "b", "c"), ] assert match_relations(program, one(X, Y, Z), [one("a", "b", "c")])
def test_testRulesWithBinaryUnifiers(): program = [ tc(X, Y) <= edge(X, Y), tc(X, Y) <= [edge(X, Z), tc(Z, Y)], edge(a, b), edge(b, c), edge(c, c), edge(c, d), cycle(X) <= [eq(X, Y), tc(X, Y)], beginsAtC(X, Y) <= [tc(X, Y), eq(c, X)], ] ans = match_relations(program) assert ans(cycle(X), [cycle(c)]) assert ans(beginsAtC(X, Y), [beginsAtC(c, c), beginsAtC(c, d)])
def test_testRulesWithBinaryDisunifiers(): program = [ tc(X, Y) <= edge(X, Y), tc(X, Y) <= [edge(X, Z), tc(Z, Y)], edge(a, b), edge(b, c), edge(c, c), edge(c, d), noncycle(X, Y) <= [not_eq(X, Y), tc(X, Y)], beginsNotAtC(X, Y) <= [tc(X, Y), not_eq(c, X)], noC(X, Y) <= [edge(X, Y), not_eq(X, c), not_eq(Y, c)], noC(X, Y) <= [noC(X, Z), noC(Z, Y)], ] ans = match_relations(program) assert ans( noncycle(X, Y), [ noncycle(a, b), noncycle(a, c), noncycle(a, d), noncycle(b, c), noncycle(b, d), noncycle(c, d), ], ) assert ans( beginsNotAtC(X, Y), [ beginsNotAtC(a, b), beginsNotAtC(a, c), beginsNotAtC(a, d), beginsNotAtC(b, c), beginsNotAtC(b, d), ], ) assert ans(noC(X, Y), [noC(a, b)])
def testImpossibleBinaryUnification1(): assert match_relations([p() <= eq(a, b)], 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_testRelated2(): from tests.data.abcdatalog.related2 import related_data as program, _exp_ancestors ans = match_relations(program) assert ans(check(X, Y), []) assert ans( siblings(X, Y), [ siblings(carson, deidra), siblings(deidra, carson), siblings(harley, gonzalo), siblings(gonzalo, harley), siblings(eldon, fern), siblings(fern, eldon), siblings(noe, odell), siblings(odell, noe), siblings(reanna, sona), siblings(sona, reanna), siblings(terra, ursula), siblings(ursula, terra), ], ) assert ans(ancestor(X, Y), _exp_ancestors) assert ans( same_generation(gonzalo, Y), [ same_generation(gonzalo, harley), same_generation(gonzalo, eldon), same_generation(gonzalo, fern), ], ) assert ans( same_generation(X, reanna), [ same_generation(sona, reanna), same_generation(terra, reanna), same_generation(ursula, reanna), ], ) assert ans( unrelated(adria, Y), [ unrelated(adria, barrett), unrelated(adria, ignacia), unrelated(adria, kati), unrelated(adria, lauretta), unrelated(adria, mayra), unrelated(adria, noe), unrelated(adria, odell), unrelated(adria, reanna), unrelated(adria, sona), unrelated(adria, terra), unrelated(adria, ursula), unrelated(adria, virgilio), ], ) assert ans( unrelated(X, odell), [ unrelated(adria, odell), unrelated(barrett, odell), unrelated(carson, odell), unrelated(harley, odell), unrelated(gonzalo, odell), unrelated(deidra, odell), unrelated(eldon, odell), unrelated(fern, odell), ], )
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_testExplicitUnification2(): program = [p() <= [~q(X, b), not_eq(X, a)]] with pytest.raises(DatalogValidationException): match_relations(program, p(), [])
def test_testExplicitUnification1(): program = [p() <= [~q(X, b), eq(X, a)]] assert match_relations(program, p(), [p()])
def test_testBinaryDisunificationFail1(): program = [p() <= [~q(a, b), not_eq(X, _)]] with pytest.raises(DatalogValidationException): match_relations(program, p(), [])
def test_testNegatedUnboundVariable3(): with pytest.raises(DatalogValidationException): match_relations([p() <= [~q(X, a), ~r(X)]], p(), [])
def test_testImpossibleBinaryUnification2(): assert match_relations([p() <= [eq( Z, b), eq(X, Y), eq(a, X), eq(Z, Y)]], 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), [])