def test_column_references_multiple_atoms(self):
"""Test column references occurring in multiple atoms in a rule."""
run = runtime.Runtime()
run.create_policy('nova')
schema = compile.Schema({
'q': ('id', 'name', 'status'),
'r': ('id', 'age', 'weight')
})
run.set_schema('nova', schema, complete=True)
# Multiple atoms
code = ("p(x) :- nova:q(id=x, 2=y), nova:r(id=x)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, y), nova:r(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms')
# Multiple atoms sharing column name but different variables
code = ("p(x) :- nova:q(id=x), nova:r(id=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, x1), nova:r(y, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms shared column name')
# Multiple atoms, same table
code = ("p(x) :- nova:q(id=x, 2=y), nova:q(id=x)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, y), nova:q(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms, same table')
def test_column_references_multiple_atoms(self):
"""Test column references occurring in multiple atoms in a rule."""
run = agnostic.Runtime()
run.create_policy('nova')
schema = compile.Schema({'q': ('id', 'name', 'status'),
'r': ('id', 'age', 'weight')})
run.set_schema('nova', schema, complete=True)
# Multiple atoms
code = ("p(x) :- nova:q(id=x, 2=y), nova:r(id=x)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, y), nova:r(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms')
# Multiple atoms sharing column name but different variables
code = ("p(x) :- nova:q(id=x), nova:r(id=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, x1), nova:r(y, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms shared column name')
# Multiple atoms, same table
code = ("p(x) :- nova:q(id=x, 2=y), nova:q(id=x)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, x0, y), nova:q(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms, same table')
def test_column_references_multiple_atoms(self):
"""Test column references occurring in multiple atoms in a rule."""
ms = compile.ModuleSchemas()
ms['nova'] = compile.Schema({'q': ('id', 'name', 'status'),
'r': ('id', 'age', 'weight')})
# Multiple atoms
code = ("p(x) :- nova:q(id=x, 2=y), nova:r(id=x)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, x0, y), nova:r(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms')
# Multiple atoms sharing column name but different variables
code = ("p(x) :- nova:q(id=x), nova:r(id=y)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, x0, x1), nova:r(y, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms shared column name')
# Multiple atoms, same table
code = ("p(x) :- nova:q(id=x, 2=y), nova:q(id=x)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, x0, y), nova:q(x, y0, y1)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple atoms, same table')
def check(code, correct, msg):
# We're interacting directly with the runtime's underlying
# theory b/c we haven't decided whether consequences should
# be a top-level API call.
run = self.prep_runtime()
run.insert(code, target=NREC_THEORY)
actual = run.theory[NREC_THEORY].consequences()
e = helper.datalog_same(helper.pol2str(actual), correct, msg)
self.assertTrue(e)
def check(code, correct, msg):
# We're interacting directly with the runtime's underlying
# theory b/c we haven't decided whether consequences should
# be a top-level API call.
run = self.prep_runtime()
run.insert(code, target=NREC_THEORY)
actual = run.theory[NREC_THEORY].consequences()
e = helper.datalog_same(helper.pol2str(actual), correct, msg)
self.assertTrue(e)
def check(query, code, tablenames, correct, msg, find_all=True):
# We're interacting directly with the runtime's underlying
# theory b/c we haven't yet decided whether Abduce should
# be a top-level API call.
run = self.prep_runtime()
run.insert(code, target=NREC_THEORY)
query = helper.str2form(query)
actual = run.theory[NREC_THEORY].abduce(query, tablenames=tablenames, find_all=find_all)
e = helper.datalog_same(helper.pol2str(actual), correct, msg)
self.assertTrue(e)
def check(query, code, tablenames, correct, msg, find_all=True):
# We're interacting directly with the runtime's underlying
# theory b/c we haven't yet decided whether Abduce should
# be a top-level API call.
run = self.prep_runtime()
run.insert(code, target=NREC_THEORY)
query = helper.str2form(query)
actual = run.theory[NREC_THEORY].abduce(
query, tablenames=tablenames, find_all=find_all)
e = helper.datalog_same(helper.pol2str(actual), correct, msg)
self.assertTrue(e)
def check(code, correct, msg):
actual = compile.parse1(code).eliminate_column_references(theories)
eq = helper.datalog_same(str(actual), correct)
self.assertTrue(eq, msg)
def check(code, correct, msg):
actual = compile.parse1(code).eliminate_column_references(theories)
eq = helper.datalog_same(str(actual), correct)
self.assertTrue(eq, msg)
def check(code, correct, msg, no_theory=False):
actual = compile.parse1(
code).eliminate_column_references_and_pad_positional(
{} if no_theory else theories)
eq = helper.datalog_same(str(actual), correct)
self.assertTrue(eq, msg)
def test_column_references_atom(self):
"""Test column references occurring in a single atom in a rule."""
run = agnostic.Runtime()
run.create_policy('nova')
nova_schema = compile.Schema({'q': ('id', 'name', 'status')})
run.set_schema('nova', nova_schema, complete=True)
# Multiple column names
code = ("p(x) :- nova:q(id=x, status=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column names')
# Multiple column numbers
code = ("p(x) :- nova:q(0=x, 1=y, 2=z)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column numbers')
# Mix column names and numbers
code = ("p(x) :- nova:q(id=x, 2=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Mix names and numbers')
# Object constants
code = ("p(x) :- nova:q(id=3, 2=2)")
actual = run.parse(code)
correct = "p(x) :- nova:q(3, w, 2)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Object constants')
# Out of order
code = ("p(x, y) :- nova:q(status=y, id=x)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order')
# Out of order with numbers
code = ("p(x, y) :- nova:q(1=y, 0=x)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order with numbers')
# Positional plus named
code = ("p(x, y) :- nova:q(x, status=y)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named')
# Positional plus named 2
code = ("p(x, y, z) :- nova:q(x, y, 2=z)")
actual = run.parse(code)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named 2')
# Pure positional (different since we are providing schema)
code = ("p(x, y, z) :- nova:q(x, y, z)")
actual = run.parse(code)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional')
# Pure positional (without schema)
code = ("p(x) :- nova:q(x, y, z)")
run.delete_policy('nova')
actual = run.parse(code)
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional without schema')
def test_column_references_atom(self):
"""Test column references occurring in a single atom in a rule."""
ms = compile.ModuleSchemas()
ms['nova'] = compile.Schema({'q': ('id', 'name', 'status')})
# Multiple column names
code = ("p(x) :- nova:q(id=x, status=y)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column names')
# Multiple column numbers
code = ("p(x) :- nova:q(0=x, 1=y, 2=z)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column numbers')
# Mix column names and numbers
code = ("p(x) :- nova:q(id=x, 2=y)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Mix names and numbers')
# Object constants
code = ("p(x) :- nova:q(id=3, 2=2)")
actual = compile.parse(code, ms)
correct = "p(x) :- nova:q(3, w, 2)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Object constants')
# Out of order
code = ("p(x, y) :- nova:q(status=y, id=x)")
actual = compile.parse(code, ms)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order')
# Out of order with numbers
code = ("p(x, y) :- nova:q(1=y, 0=x)")
actual = compile.parse(code, ms)
correct = "p(x, y) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order with numbers')
# Positional plus named
code = ("p(x, y) :- nova:q(x, status=y)")
actual = compile.parse(code, ms)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named')
# Positional plus named 2
code = ("p(x, y, z) :- nova:q(x, y, 2=z)")
actual = compile.parse(code, ms)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named 2')
# Pure positional (different since we are providing schema)
code = ("p(x, y, z) :- nova:q(x, y, z)")
actual = compile.parse(code, ms)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional')
# Pure positional (without schema)
code = ("p(x) :- nova:q(x, y, z)")
actual = compile.parse(code, compile.ModuleSchemas())
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional without schema')
def test_column_references_atom(self):
"""Test column references occurring in a single atom in a rule."""
run = runtime.Runtime()
run.create_policy('nova')
nova_schema = compile.Schema({'q': ('id', 'name', 'status')})
run.set_schema('nova', nova_schema, complete=True)
# Multiple column names
code = ("p(x) :- nova:q(id=x, status=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column names')
# Multiple column numbers
code = ("p(x) :- nova:q(0=x, 1=y, 2=z)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Multiple column numbers')
# Mix column names and numbers
code = ("p(x) :- nova:q(id=x, 2=y)")
actual = run.parse(code)
correct = "p(x) :- nova:q(x, w, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Mix names and numbers')
# Object constants
code = ("p(x) :- nova:q(id=3, 2=2)")
actual = run.parse(code)
correct = "p(x) :- nova:q(3, w, 2)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Object constants')
# Out of order
code = ("p(x, y) :- nova:q(status=y, id=x)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order')
# Out of order with numbers
code = ("p(x, y) :- nova:q(1=y, 0=x)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Out of order with numbers')
# Positional plus named
code = ("p(x, y) :- nova:q(x, status=y)")
actual = run.parse(code)
correct = "p(x, y) :- nova:q(x, z, y)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named')
# Positional plus named 2
code = ("p(x, y, z) :- nova:q(x, y, 2=z)")
actual = run.parse(code)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Positional plus named 2')
# Pure positional (different since we are providing schema)
code = ("p(x, y, z) :- nova:q(x, y, z)")
actual = run.parse(code)
correct = "p(x, y, z) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional')
# Pure positional (without schema)
code = ("p(x) :- nova:q(x, y, z)")
run.delete_policy('nova')
actual = run.parse(code)
correct = "p(x) :- nova:q(x, y, z)"
eq = helper.datalog_same(helper.pol2str(actual), correct)
self.assertTrue(eq, 'Pure positional without schema')
