def typeMatch(self, cursor, programData):
# grab all rules type information
cursor.execute("SELECT rid FROM Rule")
rids = cursor.fetchall()
rids = tools.toAscii_list(rids)
ruleTypes = {}
for rid in rids:
r = dumpers.singleRuleAttDump(rid, cursor)
ruleTypes[r['goalName']] = r
# grab all facts
cursor.execute("SELECT fid FROM Fact")
fids = cursor.fetchall()
fids = tools.toAscii_list(fids)
factTypes = {}
for fid in fids:
# working out the fact match still
continue
# loop through and check matches between goals and subgoals
for rid, rule in ruleTypes.iteritems():
for subgoal in rule['subgoalAttData']:
if subgoal[1] not in ruleTypes.keys():
# working out the fact matching still
continue
matchingGoal = ruleTypes[subgoal[1]]
for i in range(0, len(subgoal[2])):
attr = subgoal[2][i]
matchingAttr = matchingGoal['goalAttData'][i]
self.assertEqual(attr[2], matchingAttr[2])
def rewriteNegativeSubgoalsWithWildcards(cursor):
newRuleMeta = []
# ------------------------------------------- #
# get all rids
cursor.execute("SELECT rid FROM RUlE")
rids = cursor.fetchall()
rids = tools.toAscii_list(rids)
for rid in rids:
cursor.execute("SELECT sid FROM Subgoals WHERE rid=='" + rid + "'")
sids = cursor.fetchall()
sids = tools.toAscii_list(sids)
# ------------------------------------------- #
# examine all subgoals per rule
for sid in sids:
cursor.execute("SELECT argName FROM SubgoalAddArgs WHERE rid=='" +
rid + "' AND sid=='" + sid + "'")
sign = cursor.fetchone()
if sign:
sign = tools.toAscii_str(sign)
else:
sign = ""
if sign == "notin":
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ rid + "' AND sid=='" + sid + "'")
attData = cursor.fetchall()
attData = tools.toAscii_multiList(attData)
# ------------------------------------------- #
# examine all atts per subgoal per rule
for att in attData:
attID = att[0]
attName = att[1]
attType = att[2]
if attName == "_":
newRule = rewriteRule(rid, sid, attData, cursor)
newRuleMeta.append(newRule)
break
else:
continue
return newRuleMeta
def dumpSingleFact_c4(fid, cursor):
fact = ""
cursor.execute("SELECT name FROM Fact WHERE fid == '" + fid +
"'") # get fact name
factName = cursor.fetchone()
factName = tools.toAscii_str(factName)
# get list of attribs in fact
factList = cursor.execute("SELECT data FROM FactData WHERE fid == '" +
fid + "'") # list of fact atts
factList = cursor.fetchall()
factList = tools.toAscii_list(factList)
# get fact time arg
#factTimeArg = ""
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid == '" + fid + "'" )
#factTimeArg = cursor.fetchone()
#factTimeArg = tools.toAscii_str( factTimeArg )
# convert fact info to pretty string
fact += factName + "("
for j in range(0, len(factList)):
if j < (len(factList) - 1):
fact += factList[j] + ","
else:
fact += factList[j]
#if not factTimeArg == "" :
# fact += "," + factTimeArg
fact += ");" + "\n" # end all facts with a semicolon
return fact
def dumpIR(cursor, db_dump_save_path):
# get facts
cursor.execute("SELECT fid FROM Fact")
fid_all = cursor.fetchall()
fid_all = tools.toAscii_list(fid_all)
full_facts = []
for fid in fid_all:
full_facts.append(dumpSingleFact_c4(fid, cursor))
# get rules
cursor.execute("SELECT rid FROM Rule")
rid_all = cursor.fetchall()
rid_all = tools.toAscii_list(rid_all)
full_rules = []
for rid in rid_all:
full_rules.append(dumpSingleRule_c4(rid, cursor))
# get clock
full_clock = dump_clock(cursor)
if db_dump_save_path:
if DUMPERS_C4_DEBUG:
print "...DUMPING IR..."
print full_facts
print full_rules
print full_clock
# save to file
fo = open(db_dump_save_path, "w")
for fact in full_facts: # write facts
fo.write(fact)
for rule in full_rules: # write rules
fo.write(rule)
for clock in full_clock: # write clock facts
fo.write(clock)
fo.close()
print "IR DUMP SAVED TO : " + db_dump_save_path
else:
print "...DUMPING IR..."
print full_facts
print full_rules
print full_clock
def getGoallAtts(cursor, rid):
''' collects goalAtts '''
cursor.execute('''SELECT ga.attName,
ga.attType
FROM GoalAtt ga
WHERE ga.rid = "''' + rid + '"')
goalAtt = cursor.fetchall()
return tools.toAscii_list(goalAtt)
def getDeductiveRuleIDs(cursor):
# deductive rules are not next or async
cursor.execute(
"SELECT rid FROM Rule WHERE (NOT goalTimeArg == 'next') AND (NOT goalTimeArg == 'async') AND (NOT goalTimeArg == 'rewritten')"
)
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
return ridList
def getSubGoalAttList(cursor, rid, sid):
''' Collects infomration to create the subgoalAttList '''
cursor.execute('''
SELECT sa.attName
FROM SubgoalAtt sa
WHERE sa.rid = "''' + rid + '" AND sid = "' + str(sid) + '"')
subGoalAtts = cursor.fetchall()
return tools.toAscii_list(subGoalAtts)
def getName(self):
self.cursor.execute("SELECT name FROM Fact WHERE fid = '" + self.fid +
"'")
nameList = self.cursor.fetchall()
nameList = tools.toAscii_list(nameList)
if not nameList == None:
if len(nameList) == 1:
return nameList[0]
else:
sys.exit("ERROR: Fact possesses more than 1 name: " + nameList)
def test_toAscii_list_tools(self):
unitestfile = testPath + "/testfiles/unicodetest.txt"
with open(unitestfile, "r") as f:
line = f.readlines()[0][6:]
x = 0
testmulti = []
while x != 5:
testmulti.append(line)
x = x + 1
self.assertFalse(tools.toAscii_list(testmulti) == None)
def getTimeArg(self):
self.cursor.execute("SELECT timeArg FROM Fact WHERE fid = '" +
self.fid + "'")
timeArgList = self.cursor.fetchall()
timeArgList = tools.toAscii_list(timeArgList)
if not timeArgList == None:
if len(timeArgList) == 1:
return timeArgList[0]
else:
sys.exit("ERROR: Fact possesses more than 1 timeArg: " +
timeArgList)
def printRuleWithTypes( rid, cursor ) :
logging.debug( " PRINT RULE WITH TYPES : running process..." )
printLine = ""
# ----------------------------------------- #
# get relation name
cursor.execute( "SELECT goalName FROM Rule WHERE rid=='" + str( rid ) + "'" )
goalName = cursor.fetchone()
goalName = tools.toAscii_str( goalName )
# ----------------------------------------- #
# get goal att names and types
cursor.execute( "SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
gattData = cursor.fetchall()
gattData = tools.toAscii_multiList( gattData )
# build head for printing
goal = goalName + "("
for gatt in gattData :
gattName = gatt[1]
gattType = gatt[2]
goal += "[" + gattName + "," + gattType + "]"
goal += ")"
printLine += goal + " :- "
# ----------------------------------------- #
# get all subgoal ids
cursor.execute( "SELECT sid FROM Subgoals WHERE rid=='" + str( rid ) + "'" )
sidList = cursor.fetchall()
sidList = tools.toAscii_list( sidList )
# ----------------------------------------- #
# iterate over sids
for sid in sidList :
# ----------------------------------------- #
# get subgoal name
cursor.execute( "SELECT subgoalName FROM Subgoals WHERE rid=='" + str( rid ) + "' AND sid=='" + str( sid ) + "'" )
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str( subgoalName )
# ----------------------------------------- #
# get subgoal att names and types
cursor.execute( "SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='" + str( rid ) + "' AND sid=='" + str( sid ) + "'" )
sattData = cursor.fetchall()
sattData = tools.toAscii_multiList( sattData )
# ----------------------------------------- #
# build subgoal for printing
subgoal = subgoalName + "("
for satt in sattData :
sattName = satt[1]
sattType = satt[2]
subgoal += "[" + sattName + "," + sattType + "]"
subgoal += ")"
printLine += subgoal + ","
return printLine[:-1]
def collectExistentialBoundSubgoals(universalBoundSubgoals, posNameRIDs,
cursor):
print
print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
print "BUILDING EXISTENTIAL BOUND SUBGOALS"
print "universalBoundSubgoals : "
for sub in universalBoundSubgoals:
print sub
print "posNameRIDs :"
for r in posNameRIDs:
print dumpers.reconstructRule(r, cursor)
existentialBoundSubgoals = []
# -------------------------- #
# extract all universal vars #
# -------------------------- #
univars = []
for subgoalDict in universalBoundSubgoals:
subgoalAttDict = subgoalDict["subgoalAttDict"]
for subindex in subgoalAttDict:
attData = subgoalAttDict[subindex]
attVar = attData[1]
if not attVar in univars and not attVar == "_":
univars.append(attVar)
# ---------------------------------------------------------------------------------------- #
# collect all subgoals from pos rules with all universal variables replaced with wildcards #
# ---------------------------------------------------------------------------------------- #
for posrid in posNameRIDs:
print "<><> posNameRIDs rule : " + dumpers.reconstructRule(
posrid, cursor)
# get all sids
cursor.execute("SELECT sid FROM Subgoals WHERE rid=='" + posrid + "'")
sidList = cursor.fetchall()
sidList = tools.toAscii_list(sidList)
for possid in sidList:
# ---------------- #
# get subgoal name #
# ---------------- #
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisSubgoalName = cursor.fetchone()
exisSubgoalName = tools.toAscii_str(exisSubgoalName)
# ------------------------- #
# get subgoal time argument #
# ------------------------- #
cursor.execute("SELECT subgoalTimeArg FROM Subgoals WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisSubgoalTimeArg = cursor.fetchone()
exisSubgoalTimearg = tools.toAscii_str(exisSubgoalTimeArg)
if type(exisSubgoalTimeArg) is tuple:
exisSubgoalTimeArg = exisSubgoalTimeArg[0]
# ------------------- #
# get subgoal att map #
# ------------------- #
# ====================================== #
# CASE : subgoal is an EDB #
# ====================================== #
if tools.isFact_only(exisSubgoalName, cursor):
if exisSubgoalName == "clock":
# just need to get the data for one clock fact
cursor.execute(
"SELECT src,dest,sndTime,delivTime FROM Clock")
fact = cursor.fetchall()
fact = tools.toAscii_multiList(fact)
fact = fact[0]
factData = {}
attID = 0
for d in fact:
attName = d
if type(d) is int:
attType = "int"
elif d.isdigit():
attType = "int"
else:
attType = "string"
factData[attID] = [attID, attName, attType]
attID += 1
#tools.bp( __name__, inspect.stack()[0][3], "factData : " + str( factData ) )
else:
# get an fid for this edb
cursor.execute("SELECT fid FROM Fact WHERE name=='" +
exisSubgoalName + "'")
thisSubgoalEDBFID = cursor.fetchone()
thisSubgoalEDBFID = tools.toAscii_str(thisSubgoalEDBFID)
# get fact data
cursor.execute(
"SELECT attID,attName,attType FROM FactAtt WHERE fid=='"
+ thisSubgoalEDBFID + "'")
factData = cursor.fetchall()
factData = tools.toAscii_multiList(factData)
# get subgoal attribute data
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ posrid + "' AND sid=='" + possid + "'")
subAttData = cursor.fetchall()
subAttData = tools.toAscii_multiList(subAttData)
# map subgoal attributes to att types from the corresponding fact schema
attData = {}
for i in range(0, len(factData)):
fact = factData[i]
subatt = subAttData[i]
attID = fact[0]
attName = subatt[1]
attType = fact[2]
attData[attID] = [attID, attName, attType]
# ====================================== #
# CASE : suboal is an IDB #
# ====================================== #
else:
# get original name
orig_name = exisSubgoalName.split("_from")
orig_name = orig_name[0] # remove stuff from _from and after
if orig_name.startswith("not_"):
orig_name = orig_name[4:]
print "orig_name = " + str(orig_name)
# get an rid for this idb
#cursor.execute( "SELECT rid FROM Rule WHERE goalName=='" + exisSubgoalName + "'" )
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" +
orig_name + "'")
thisSubgoalIDBRID = cursor.fetchone()
thisSubgoalIDBRID = tools.toAscii_str(thisSubgoalIDBRID)
# get att data from IDB definition
cursor.execute(
"SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
thisSubgoalIDBRID + "'")
orig_subgoalAttList = cursor.fetchall()
orig_subgoalAttList = tools.toAscii_multiList(
orig_subgoalAttList)
# get att data from subgoal from positive rule
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='"
+ posrid + "' AND sid=='" + possid + "'")
subgoal_subgoalAttList = cursor.fetchall()
subgoal_subgoalAttList = tools.toAscii_multiList(
subgoal_subgoalAttList)
attData = {}
for i in range(0, len(orig_subgoalAttList)):
orig_att = orig_subgoalAttList[i]
sub_att = subgoal_subgoalAttList[i]
attID = orig_att[0]
attName = sub_att[1]
attType = orig_att[2]
attData[attID] = [attID, attName, attType]
print "attData : " + str(attData)
exisSubgoalAttMap = {}
for attID in attData:
att = attData[attID]
attID = att[0]
attName = att[1]
attType = att[2]
if attName in univars and not attName == "_":
attName = "_"
exisSubgoalAttMap[attID] = [attID, attName, attType]
# ------------------- #
# get subgoal add arg #
# ------------------- #
cursor.execute("SELECT argName FROM SubgoalAddArgs WHERE rid=='" +
posrid + "' AND sid=='" + possid + "'")
exisAddArg = cursor.fetchone()
if exisAddArg:
exisAddArg = tools.toAscii_str(exisAddArg)
else:
exisAddArg = ""
# ------------------------------ #
# build negated positive subgoal #
# ------------------------------ #
exisSubgoal = {}
exisSubgoal["sid"] = tools.getID()
exisSubgoal["subgoalName"] = exisSubgoalName
exisSubgoal["subgoalTimeArg"] = exisSubgoalTimeArg
exisSubgoal["subgoalAttDict"] = exisSubgoalAttMap
exisSubgoal["argName"] = exisAddArg
existentialBoundSubgoals.append(exisSubgoal)
print "DONE BUILDING EXISTENTIAL BOUND SUBGOALS"
return existentialBoundSubgoals
def dumpSingleRule_c4(rid, cursor):
rule = ""
# -------------------------------------------------------------- #
# GOAL #
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid == '" + rid +
"'") # get goal name
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# get list of attribs in goal
goalList = cursor.execute("SELECT attName FROM GoalAtt WHERE rid == '" +
rid + "'") # list of goal atts
goalList = cursor.fetchall()
goalList = tools.toAscii_list(goalList)
# get goal time arg
goalTimeArg = ""
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" + rid + "'")
goalTimeArg = cursor.fetchone()
goalTimeArg = tools.toAscii_str(goalTimeArg)
# convert goal info to pretty string
rule += goalName + "("
for j in range(0, len(goalList)):
if j < (len(goalList) - 1):
rule += goalList[j] + ","
else:
rule += goalList[j] + ")"
if not goalTimeArg == "":
#rule += "@" + goalTimeArg + " :- "
sys.exit("ERROR: leftover timeArg in goal: " + rule + "@" +
goalTimeArg)
else:
rule += " :- "
# --------------------------------------------------------------- #
# SUBGOALS #
# get list of sids for the subgoals of this rule
cursor.execute("SELECT sid FROM Subgoals WHERE rid == '" + str(rid) +
"'") # get list of sids for this rule
subIDs = cursor.fetchall()
subIDs = tools.toAscii_list(subIDs)
# prioritize dom subgoals first.
subIDs = prioritizeDoms(rid, subIDs, cursor)
# prioritize negated subgoals last.
subIDs = prioritizeNegatedLast(rid, subIDs, cursor)
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(subIDs)):
newSubgoal = ""
s = subIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid == '" +
str(rid) + "' AND sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
if DUMPERS_C4_DEBUG:
print "subgoalName = " + subgoalName
# get subgoal attribute list
subAtts = cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
#if goalName == "pre" and subgoalName == "bcast" :
# print "............................................"
# print dumpers.reconstructRule( rid, cursor )
# print "subgoalName = " + subgoalName
# print "subAtts = " + str( subAtts )
# print "subTimeArg = " + str( subTimeArg )
# tools.bp( __name__, inspect.stack()[0][3], "stuff" )
# get subgoal additional args
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAddArg = cursor.fetchone() # assume only one additional arg
if not subAddArg == None:
subAddArg = tools.toAscii_str(subAddArg)
subAddArg += " "
newSubgoal += subAddArg
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(subIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# --------------------------------------------------------------- #
# EQUATIONS #
# get list of sids for the subgoals of this rule
cursor.execute(
"SELECT eid FROM Equation") # get list of eids for this rule
eqnIDs = cursor.fetchall()
eqnIDs = tools.toAscii_list(eqnIDs)
for e in range(0, len(eqnIDs)):
currEqnID = eqnIDs[e]
# get associated equation
if not currEqnID == None:
cursor.execute("SELECT eqn FROM Equation WHERE rid == '" + rid +
"' AND eid == '" + str(currEqnID) + "'")
eqn = cursor.fetchone()
if not eqn == None:
eqn = tools.toAscii_str(eqn)
# convert eqn info to pretty string
rule += "," + str(eqn)
# add SndTime eqn (only works for one subgoal time annotation)
#if not subTimeArg == None and not subTimeArg == "" :
# rule += ",SndTime==" + str( subTimeArg )
# --------------------------------------------------------------- #
rule += " ;" + "\n" # end all rules with a semicolon
# .................................. #
#if goalName == "pre" :
# tools.bp( __name__, inspect.stack()[0][3], "rule = " + rule )
# .................................. #
return rule
def addDomainEDBs(original_prog, cursor):
# --------------------------------------------------- #
# run original program and grab results dictionary #
# --------------------------------------------------- #
results_array = c4_evaluator.runC4_wrapper(original_prog)
parsedResults = tools.getEvalResults_dict_c4(results_array)
# --------------------------------------------------- #
# save results as edb facts in IR db #
# --------------------------------------------------- #
for relationName in parsedResults:
print ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"
print "relationName : " + relationName
# build fact name
newEDBName = "dom_" + relationName + "_evalres"
print "newEDBName : " + newEDBName
# ---------------------------------------------------------- #
# no evaluation data exists for this relation
if parsedResults[relationName] == []:
# set fact info
fid = tools.getID()
timeArg += 1
print ">>> INSERT INTO Fact VALUES ('" + fid + "','" + newEDBName + "','" + str(
timeArg) + "')"
cursor.execute("INSERT INTO Fact VALUES ('" + fid + "','" +
newEDBName + "','" + str(timeArg) + "')")
# get fact schema
# observe a relation defined in a dedalust program can only be empty in this context if it is an IDB
# because c4 define statements are derived from relations defined in the dedalus program only.
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" +
relationName + "'")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
pickedRID = ridList[0]
cursor.execute(
"SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
pickedRID + "'")
attData = cursor.fetchall()
attData = tools.toAscii_multiList(attData)
# set fact data
fattID = 0
for att in attData:
attID = att[0]
attName = att[1]
attType = att[2]
if attType == "string":
d = '"___DEFAULTSTR___"'
else:
d = 9999999999
print ">>> INSERT INTO FactAtt (" + fid + "," + str(
fattID) + "," + str(d) + "," + attType + ")"
cursor.execute("INSERT INTO FactAtt VALUES ('" + fid + "','" +
str(fattID) + "','" + str(d) + "','" +
str(attType) + "')")
fattID += 1
#tools.bp( __name__, inspect.stack()[0][3], "blah" )
# ---------------------------------------------------------- #
# evaluation data exists for this relation
else:
for dataTup in parsedResults[relationName]:
# build fact id
fid = tools.getID()
# default time arg to 1. domain edb facts are true starting at time 1.
timeArg = 1
# set fact info
print ">>> INSERT INTO Fact VALUES ('" + fid + "','" + newEDBName + "','" + str(
timeArg) + "')"
cursor.execute("INSERT INTO Fact VALUES ('" + fid + "','" +
newEDBName + "','" + str(timeArg) + "')")
fattID = 0
for d in dataTup:
# get data type for d
if d.isdigit():
attType = "int"
else:
attType = "string"
# modify string data with quotes
if attType == "string":
d = '"' + d + '"'
# set fact data
print ">>> INSERT INTO FactAtt (" + fid + "," + str(
fattID) + "," + str(d) + "," + attType + ")"
cursor.execute("INSERT INTO FactAtt VALUES ('" + fid +
"','" + str(fattID) + "','" + str(d) +
"','" + str(attType) + "')")
fattID += 1
def getAttList(self):
self.cursor.execute("SELECT attName,attID FROM FactAtt WHERE fid = '" +
self.fid + "'")
attList = self.cursor.fetchall()
attList = tools.toAscii_list(attList)
return attList
def setGoal(rid, goalName, randomDMRID, newDMRIDList, cursor):
# --------------------------------- #
# set defaults #
# --------------------------------- #
goalTimeArg = ""
rewritten = True
# --------------------------------- #
# save goal info #
# --------------------------------- #
cursor.execute("INSERT INTO Rule VALUES ('" + rid + "','" + goalName +
"','" + goalTimeArg + "','" + str(rewritten) + "')")
# --------------------------------- #
# collect all universal atts #
# --------------------------------- #
# the set of existential attributes in the domain rule is exactly the
# set of goal attributes for the not_ DM rules.
cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
randomDMRID + "'")
univAttData = cursor.fetchall()
univAttData = tools.toAscii_multiList(univAttData)
# ----------------------------------- #
# collect all existential atts #
# ----------------------------------- #
# iterate over all new not_ rules and collect all variables per rule
# not appearing in the list of goal attributes.
goalAttList = [x[1] for x in univAttData]
exisAttList = [
] # collect previously appended existential att names here to avoid duplicates
exisAttData = []
for dmrid in newDMRIDList:
allSubgoalAtts = []
# get all sids for this rule
cursor.execute("SELECT sid FROM Subgoals WHERE rid=='" + dmrid + "'")
sidList = cursor.fetchall()
sidList = tools.toAscii_list(sidList)
for sid in sidList:
# get all subgoal att data
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='" +
dmrid + "' AND sid=='" + sid + "'")
subgoalAttData = cursor.fetchall()
subgoalAttData = tools.toAscii_multiList(subgoalAttData)
for att in subgoalAttData:
# grab all existential atts
attName = att[1]
# existential atts do not exist in the goal attribute list
# do not duplicate existential atts in the collection structure
# wildcards are not existential atts
if not attName in goalAttList and not attName in exisAttList and not attName == "_":
exisAttData.append(att)
exisAttList.append(attName)
# ----------------------------------- #
# save goal attributes #
# ----------------------------------- #
allAttData = univAttData + exisAttData
for att in allAttData:
attID = att[0]
attName = att[1]
attType = att[2]
print "INSERT INTO GoalAtt VALUES ('" + rid + "','" + str(
attID) + "','" + attName + "','" + attType + "')"
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid + "','" +
str(attID) + "','" + attName + "','" + attType + "')")
return univAttData
def setNewRules( parentName, ruleName, simplified_negFmla, predicateToID_map, cursor ) :
if NEGATIVEWRITES_DEBUG :
print " ... running set new rules ..."
#print "simplified_negFmla = " + str( simplified_negFmla )
#tools.dumpAndTerm( cursor )
# -------------------------------------------------------------------- #
# initialize local data collection structures #
# -------------------------------------------------------------------- #
newName = "not_" + ruleName + "_from_" + parentName
newGoalAtts = [] # populate with a uniform set of variables and propogate the set among all DM rules.
newRIDs = [] # list of the rids for the new DM rules.
goalAttMapper = {} # maintain a consistent set of goal attribute strings across all DM rules.
# -------------------------------------------------------------------- #
# populate goal attribute mapper with uniform attribute strings.
# get an rid for this rule
cursor.execute( "SELECT rid FROM Rule WHERE goalName='" + ruleName + "'" )
ridList = cursor.fetchall()
ridList = tools.toAscii_list( ridList )
pickedRID = ridList[0]
# get original attribute list. This is authoratative b/c
# setting uniform variable scheme prior to applying DeMorgan's rewrites.
cursor.execute( "SELECT attID,attName,attType FROM GoalAtt WHERE rid='" + pickedRID + "'" )
origAttList = cursor.fetchall()
origAttList = tools.toAscii_multiList( origAttList )
# fill goalAttMapper with attID : uniform string
for att in origAttList :
attID = att[0]
attName = att[1]
goalAttMapper[ attID ] = attName
# -------------------------------------------------------------------- #
# get all clauses for this rule #
# -------------------------------------------------------------------- #
negated_simplified_fmla_str = str( simplified_negFmla )
negated_simplified_fmla_str = negated_simplified_fmla_str.translate( None, string.whitespace)
negated_simplified_fmla_str = negated_simplified_fmla_str.replace( "(", "" )
negated_simplified_fmla_str = negated_simplified_fmla_str.replace( ")", "" )
clauses = negated_simplified_fmla_str.split( "|" )
# -------------------------------------------------------------------- #
# get predicate (subgoal) ID mapping for this rule #
# predicateToID_map[ predID ] = [ rid, [ sign, sid ] ] #
# -------------------------------------------------------------------- #
predMap = predicateToID_map
# -------------------------------------------------------------------- #
# spawn one new not_ rule per clause #
# -------------------------------------------------------------------- #
for c in clauses :
# get an id for the new rule
newRID = tools.getID()
newRIDs.append( newRID )
# grab the list of literals in this clause
literalList = c.split( "&" )
# iterate over literal list to construct the string representation
for literal in literalList :
# remove negation from string and record a notin for this subgoal.
if "~" in literal :
predicate = literal.replace( "~", "" )
addArg = "notin"
# no negation means do nothing.
else :
predicate = literal
addArg = None
# grab the parent rid, sign, and sid for this subgoal
# represented by this literal in the Boolean formula.
predData = predMap[ predicate ]
rid = predData[0]
sign = predData[1][0]
sid = predData[1][1]
# grab info regarding the original rule.
origRule = Rule.Rule( rid, cursor )
origRule_typeMap = origRule.getAllAttTypes()
origRule_goalAttList = origRule.getGoalAttList()
# -------------------------------------------- #
# get subgoal info #
# -------------------------------------------- #
# get name and time arg for this subgoal from the original rule.
cursor.execute( "SELECT subgoalName,subgoalTimeArg FROM Subgoals WHERE rid='" + rid + "' AND sid='" + sid + "'" )
data = cursor.fetchone()
data = tools.toAscii_list( data )
subgoalName = data[0]
try :
subgoalTimeArg = data[1]
except IndexError :
subgoalTimeArg = ""
#print "here"
#tools.dumpAndTerm( cursor )
# get subgoal attribute list
cursor.execute( "SELECT attID,attName,attType FROM SubgoalAtt WHERE rid='" + rid + "' AND sid='" + sid + "'" )
subgoalAtts = cursor.fetchall()
subgoalAtts = tools.toAscii_multiList( subgoalAtts )
# -------------------------------------------- #
# save subgoal with the rid of the new rule #
# -------------------------------------------- #
# create new sid
newSID = tools.getID()
# save subgoal name and time arg
cursor.execute( "INSERT INTO Subgoals VALUES ('" + newRID + "','" + newSID + "','" + subgoalName.lower() + "','" + subgoalTimeArg + "')" )
# save subgoal attributes
for att in subgoalAtts :
attID = att[0]
attName = att[1]
attType = att[2]
goalAttNames = [ x[0] for x in newGoalAtts ]
# ----------------------------------------------------- #
# check if atts appear in goal atts #
# if so, get the corresponding attID from goal att list #
# ----------------------------------------------------- #
goalAttID = None
if attName in origRule_goalAttList :
goalAttID = origRule_goalAttList.index( attName )
# ----------------------------------------------------- #
if attName == "_" :
# insert
cursor.execute( "INSERT INTO SubgoalAtt VALUES ('" + newRID + "','" + newSID + "','" + str( attID ) + "','" + attName + "','" + attType + "')" )
continue
if not attType == "UNDEFINEDTYPE" and not attName in goalAttNames :
newGoalAtts.append( [ goalAttID, attName, attType ] )
elif not attName in goalAttNames :
if not attType == "UNDEFINEDTYPE" :
newGoalAtts.append( [ goalAttID, attName, attType ] )
else :
print "origRule_typeMap : " + str( origRule_typeMap )
attType = origRule_typeMap[ attName ]
newGoalAtts.append( [ goalAttID, attName, attType ] )
# replace with uniform goal att str, if applicable
if not goalAttID == None :
attName = goalAttMapper[ goalAttID ]
# insert
cursor.execute( "INSERT INTO SubgoalAtt VALUES ('" + newRID + "','" + newSID + "','" + str( attID ) + "','" + attName + "','" + attType + "')" )
#print "completed insert"
#print "--------------------"
#print "c = " + str( c )
#print "origRule : " + dumpers.reconstructRule( rid, cursor )
#print "subgoalName = " + subgoalName
#print "subgoalTimeArg = " + subgoalTimeArg
#print "subgoalAtts = " + str( subgoalAtts )
#print "origRule_goalAttList = " + str( origRule_goalAttList )
#print "att = " + str( att )
#print "goalAttID = " + str( goalAttID )
#tools.bp( __name__, inspect.stack()[0][3], "breakhere." )
# save subgoal additional args
if addArg :
cursor.execute("INSERT INTO SubgoalAddArgs VALUES ('" + newRID + "','" + newSID + "','" + str( addArg ) + "')")
else :
cursor.execute("INSERT INTO SubgoalAddArgs VALUES ('" + newRID + "','" + newSID + "','')")
# -------------------------------------------- #
# save new goal data
for newRID in newRIDs :
# save new goal name and rewritten status
timeArg = ""
rewrittenFlag = True
cursor.execute( "INSERT INTO Rule (rid, goalName, goalTimeArg, rewritten) VALUES ('" + newRID + "','" + newName + "','" + timeArg + "','" + str(rewrittenFlag) + "')" )
# save new goal attributes
#prevInserts = []
#for attData in newGoalAtts :
# goalAttID = attData[0]
# attName = attData[1]
# attType = attData[2]
# if not attName == "_" and not goalAttID == None and not goalAttID in prevInserts :
# cursor.execute( "INSERT INTO GoalAtt VALUES ('" + newRID + "','" + str(goalAttID) + "','" + goalAttMapper[goalAttID ] + "','" + attType + "')" )
# prevInserts.append( goalAttID )
for attData in origAttList :
goalAttID = attData[0]
attName = attData[1]
attType = attData[2]
cursor.execute( "INSERT INTO GoalAtt VALUES ('" + newRID + "','" + str(goalAttID) + "','" + attName + "','" + attType + "')" )
# --------------------------------------------------------------------- #
return newRIDs
def c4datalog( cursor ) :
goalName = None
provGoalNameOrig = None
tableListStr = "" # collect all table names delmited by a single comma only.
tableListArray = []
# ----------------------------------------------------------- #
# create goal defines
# get all rids
cursor.execute( "SELECT rid FROM Rule" )
ridList = cursor.fetchall()
ridList = tools.toAscii_list( ridList )
definesNames = []
definesList = []
# ////////////////////////////////////////////////////////// #
# populate defines list for rules
for rid in ridList :
newDefine = ""
# get goal name
cursor.execute( "SELECT goalName FROM Rule WHERE rid = '" + rid + "'" )
goalName = cursor.fetchone()
goalName = tools.toAscii_str( goalName )
# if it's a prov rule, get the original goal name
provGoalNameOrig = None
if "_prov" in goalName :
provGoalNameOrig = goalName.split( "_prov" )
provGoalNameOrig = provGoalNameOrig[0]
# populate table information collection structures
tableListStr += goalName + ","
tableListArray.append( goalName )
# ////////////////////////////////////////////////////////// #
# populate defines list for rule goals
if C4_TRANSLATOR_DEBUG :
print "In c4datalog: definesList = " + str(definesList)
if not existingDefine( goalName, definesNames ) : # prevent duplicates
# get goal attribute list
cursor.execute( "SELECT attID,attType From GoalAtt WHERE rid = '" + rid + "'" )
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList( goalAttList )
if C4_TRANSLATOR_DEBUG_1 :
print "* goalName = " + goalName + ", goalAttList " + str( goalAttList )
# populate type list for rule
typeList = []
for k in range(0,len(goalAttList)) :
att = goalAttList[ k ]
attID = att[0]
attType = att[1]
typeList.append( attType )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += goalName
newDefine += ",{"
for i in range(0,len(typeList)) :
newDefine += typeList[i]
if i < len(typeList) - 1 :
newDefine += ","
else :
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList :
definesNames.append( goalName )
definesList.append( newDefine )
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# create fact defines
# get all fact ids
cursor.execute( "SELECT fid FROM Fact" )
fidList = cursor.fetchall()
fidList = tools.toAscii_list( fidList )
for fid in fidList :
# get goal name
cursor.execute( "SELECT name FROM Fact WHERE fid = '" + fid + "'" )
factName = cursor.fetchone()
factName = tools.toAscii_str( factName )
if C4_TRANSLATOR_DEBUG :
print "**> factName = " + factName
if C4_TRANSLATOR_DEBUG :
print "In c4datalog: definesList = " + str(definesList)
if not existingDefine( factName, definesNames ) : # prevent duplicates
# populate table string
tableListStr += factName + ","
tableListArray.append( factName )
# get goal attribute list
cursor.execute( "SELECT attID,attType From FactAtt WHERE fid = '" + fid + "'" )
factAttList = cursor.fetchall()
factAttList = tools.toAscii_multiList( factAttList )
if C4_TRANSLATOR_DEBUG_1 :
print "* factName = " + factName + ", factAttList " + str( factAttList )
# populate type list for fact
typeList = []
for k in range(0,len(factAttList)) :
att = factAttList[ k ]
attID = att[0]
attType = att[1]
typeList.append( attType )
# check for time argument
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid='" + fid + "'" )
#timeArg = cursor.fetchone()
#timeArg = tools.toAscii_str( timeArg )
#if timeArg :
# typeList.append( "int" )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += factName
newDefine += ",{"
for i in range(0,len(typeList)) :
newDefine += typeList[i]
if i < len(typeList) - 1 :
newDefine += ","
else :
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList :
definesNames.append( factName )
definesList.append( newDefine )
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# add clock define
definesList.append( "define(clock,{string,string,int,int});\n" )
tableListStr += "clock,"
tableListArray.append( "clock" )
# ----------------------------------------------------------- #
# add not_clock define
#definesList.append( "define(not_clock,{string,string,int,int});\n" )
#tableListStr += "not_clock,"
#tableListArray.append( "not_clock" )
# ----------------------------------------------------------- #
# add facts
cursor.execute( "SELECT fid FROM Fact" )
fidList = cursor.fetchall()
fidList = tools.toAscii_list( fidList )
factList = []
for fid in fidList :
newFact = dumpers_c4.dumpSingleFact_c4( fid, cursor )
factList.append( newFact )
# ----------------------------------------------------------- #
# add clock facts
clockFactList = dumpers_c4.dump_clock( cursor )
if C4_TRANSLATOR_DEBUG :
print "c4_translator: clockFactList = " + str( clockFactList )
# ----------------------------------------------------------- #
# add rules
cursor.execute( "SELECT rid FROM Rule" )
ridList = cursor.fetchall()
ridList = tools.toAscii_list( ridList )
ruleList = []
for rid in ridList :
# verify data type compatibility for rules with equations
verificationResults = tools.checkDataTypes( rid, cursor ) # returns array
yesCompatible = verificationResults[0]
offensiveEqn = verificationResults[1]
lhsType = verificationResults[2]
rhsType = verificationResults[3]
if yesCompatible :
newRule = dumpers_c4.dumpSingleRule_c4( rid, cursor )
ruleList.append( newRule )
else : # data types are incompatible
# throw error and abort
tools.bp( __name__, inspect.stack()[0][3], "FATAL ERROR: DATA TYPE INCOMPATABILITY\nAttempting to evaluate an equation in which variables possess incomparable types.\nERROR in line: " + dumpers_c4.dumpSingleRule_c4( rid, cursor )+ "\nERROR in eqn: " + offensiveEqn + "\nlhs is of type " + lhsType + " and rhs is of type " + rhsType )
# ----------------------------------------------------------- #
# save table list
if C4_TRANSLATOR_DEBUG :
print "*******************************************"
print "table list str :"
print tableListStr
print "table list array :"
print tableListArray
# ----------------------------------------------------------- #
# collect program statements
if C4_TRANSLATOR_DEBUG :
print "*******************************************"
print "definesList :"
print definesList
print "*******************************************"
print "factList :"
print factList
print "*******************************************"
print "ruleList :"
print ruleList
listOfStatementLists = [ definesList, factList, ruleList, clockFactList ]
program = tools.combineLines( listOfStatementLists )
# break down into list of individual statements
allProgramLines = []
for group in listOfStatementLists :
for statement in group :
allProgramLines.append( statement.rstrip() )
# remove duplicates
tableListArray = set( tableListArray )
tableListArray = list( tableListArray )
return [ allProgramLines, tableListArray ]
def getAllFactIDs(cursor):
cursor.execute("SELECT fid FROM Fact")
fids = cursor.fetchall()
fids = tools.toAscii_list(fids)
return fids
def getAsynchronousRuleIDs(cursor):
cursor.execute("SELECT rid FROM Rule WHERE goalTimeArg == 'async'")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
return ridList
def getInductiveRuleIDs(cursor):
cursor.execute("SELECT rid FROM Rule WHERE goalTimeArg == 'next'")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
return ridList
def rewriteAsynchronous(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running asynchronous rewrite ... "
# grab all existing next rule ids
asynchronousRuleIDs = getAsynchronousRuleIDs(cursor)
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "asynchronousRuleIDs = " + str(asynchronousRuleIDs)
for r in asynchronousRuleIDs:
print "<><><><><><><><><><><><><><><>"
print " DUMPING ASYNC RULES "
print dumpers.reconstructRule(r, cursor)
print "<><><><><><><><><><><><><><><>"
# add attribute 'DelivTime' to head
for rid in asynchronousRuleIDs:
#print "*******************************"
#print "old rule : " + str( dumpers.reconstructRule(rid, cursor) )
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
cursor.execute(
'''SELECT MAX(attID) FROM GoalAtt WHERE GoalAtt.rid == "''' +
rid + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid + "','" +
str(newAttID) + "','" + timeAtt_deliv + "','int')")
# add attribute 'SndTime' to all subgoals and add clock subgoal
for rid in asynchronousRuleIDs:
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
for s in sids:
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
s + "'," + str(newAttID) + ",'" + timeAtt_snd +
"','int')")
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '" +
s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if firstAtt:
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
# add clock subgoal
cursor.execute("SELECT attName FROM GoalAtt WHERE GoalAtt.rid == '" +
rid + "' AND GoalAtt.attID == '" + str(0) + "'")
secondAtt = cursor.fetchone()
secondAtt = tools.toAscii_str(secondAtt)
clockTools.addClockSubgoal_async(rid, firstSubgoalAtts, secondAtt,
timeAtt_snd, timeAtt_deliv, cursor)
# remove time arg from rule goals
for rid in asynchronousRuleIDs:
cursor.execute("UPDATE Rule SET goalTimeArg='' WHERE rid='" + rid +
"'")
#print "new rule : " + str( dumpers.reconstructRule(rid, cursor) )
#print "-------------------------------"
#tools.bp( __name__, inspect.stack()[0][3], "breakhere" )
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "Dump all rules from async : "
dumpers.ruleDump(cursor)
#dumpers.factDump( cursor )
if DEDALUSREWRITER_DEBUG:
print " ... done asynchronous rewrite ... "
return None
def rewriteInductive(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running inductive rewrite ... "
# grab all existing next rule ids
inductiveRuleIDs = getInductiveRuleIDs(cursor)
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "inductiveRuleIDs = " + str(inductiveRuleIDs)
print "<><><><><><><><><><><><><><><>"
print " DUMPING INDUCTIVE RULES "
for r in inductiveRuleIDs:
print dumpers.reconstructRule(r, cursor)
print "<><><><><><><><><><><><><><><>"
# add attribute 'SndTime+1' to head
for rid in inductiveRuleIDs:
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
# grab maximum attribute id
cursor.execute("SELECT MAX(attID) FROM GoalAtt WHERE rid == '" +
rid + "'")
rawMaxID = cursor.fetchone()
rawMaxID = rawMaxID[0] # extract from tuple
# .................................. #
#cursor.execute( "SELECT goalName FROM Rule WHERE rid=='" + rid + "'" )
#goalName = cursor.fetchone()
#goalName = tools.toAscii_str( goalName )
#print "___ goalName = " + str(goalName)
#if goalName == "clients" :
# print "rawMaxID = " + str( rawMaxID )
# sys.exit()
# .................................. #
if rawMaxID or (rawMaxID == 0):
newAttID = int(rawMaxID + 1) # the att id for SndTime
# check if add arg is a specific time
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" +
rid + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
# add attribute 'SndTime+1' to head
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid + "','" +
str(newAttID) + "','" + timeAtt_snd + "+1" +
"','int')")
else:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : current rule goal has no attributes:\n" +
dumpers.reconstructRule(rid, cursor))
if DEDALUSREWRITER_DEBUG:
print "inductive: rawMaxID = " + str(rawMaxID)
print "inductive: rawMaxID[0] = " + str(rawMaxID[0])
# add attribute 'SndTime' to all subgoals
for rid in inductiveRuleIDs:
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
for s in sids:
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone()
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
s + "'," + str(newAttID) + ",'" + timeAtt_snd +
"','int')")
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE SubgoalAddArgs.rid == '"
+ rid + "' AND SubgoalAddArgs.sid == '" + s + "'")
addArg = cursor.fetchone()
if not addArg == None:
addArg = tools.toAscii_str(addArg)
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '" +
s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if (not firstAtt == None) and (not addArg == "notin"):
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
else:
if DEDALUSREWRITER_DEBUG:
print "firstAtt = " + str(firstAtt)
# add clock subgoal
clockTools.addClockSubgoal_inductive(rid, firstSubgoalAtts,
timeAtt_snd, timeAtt_deliv,
cursor)
# remove time arg from rule goals
for rid in inductiveRuleIDs:
cursor.execute("UPDATE Rule SET goalTimeArg='' WHERE rid='" + rid +
"'")
# check for bugs
if DEDALUSREWRITER_DUMPS_DEBUG:
print "Dump all rules from inductive : "
dumpers.ruleDump(cursor)
if DEDALUSREWRITER_DEBUG:
print "... done rewriteInductive ..."
return None
def dumpSingleRule_c4(rid, cursor):
rule = ""
# -------------------------------------------------------------- #
# GOAL #
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid == '" + rid +
"'") # get goal name
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# get list of attribs in goal
goalList = cursor.execute("SELECT attName FROM GoalAtt WHERE rid == '" +
rid + "'") # list of goal atts
goalList = cursor.fetchall()
goalList = tools.toAscii_list(goalList)
# get goal time arg
goalTimeArg = ""
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" + rid + "'")
goalTimeArg = cursor.fetchone()
goalTimeArg = tools.toAscii_str(goalTimeArg)
# convert goal info to pretty string
rule += goalName + "("
for j in range(0, len(goalList)):
if j < (len(goalList) - 1):
rule += goalList[j] + ","
else:
rule += goalList[j] + ")"
#KD
if not goalTimeArg == "":
rule += "@" + goalTimeArg + " :- "
#sys.exit( "ERROR: leftover timeArg in goal: " + rule + "@" + goalTimeArg )
else:
rule += " :- "
# --------------------------------------------------------------- #
# SUBGOALS #
# get list of sids for the subgoals of this rule
cursor.execute("SELECT sid FROM Subgoals WHERE rid == '" + str(rid) +
"'") # get list of sids for this rule
subIDs = cursor.fetchall()
subIDs = tools.toAscii_list(subIDs)
# prioritize dom subgoals first.
subIDs = prioritizeDoms(rid, subIDs, cursor)
# prioritize negated subgoals last.
#subIDs = prioritizeNegatedLast( rid, subIDs, cursor )
subIDs, clockSubIDs, negSubIDs = prioritizeNegatedLast_2(
rid, subIDs, cursor)
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(subIDs)):
newSubgoal = ""
s = subIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid == '" +
str(rid) + "' AND sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute(
"SELECT subgoalPolarity FROM Subgoals WHERE rid == '" + rid +
"' AND sid == '" + s + "'")
subPolarity = cursor.fetchone() # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
if subPolarity == "notin":
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(subIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# cap with comma
if len(subIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
# EQUATIONS #
# get list of sids for the subgoals of this rule
cursor.execute(
"SELECT eid FROM Equation") # get list of eids for this rule
eqnIDs = cursor.fetchall()
eqnIDs = tools.toAscii_list(eqnIDs)
# if len( subIDs ) > 0 and \
# ( len( eqnIDs ) > 0 or \
# len( clockSubIDs ) > 0 or \
# len( negSubIDs ) > 0 ):
# rule += ","
for e in range(0, len(eqnIDs)):
currEqnID = eqnIDs[e]
# get associated equation
if not currEqnID == None:
cursor.execute("SELECT eqn FROM Equation WHERE rid == '" + rid +
"' AND eid == '" + str(currEqnID) + "'")
eqn = cursor.fetchone()
if not eqn == None:
eqn = tools.toAscii_str(eqn)
# convert eqn info to pretty string
rule += "," + str(eqn)
# if len( eqnIDs ) > 0 and len( clockSubIDs ) > 0 :
# rule += ","
# add SndTime eqn (only works for one subgoal time annotation)
#if not subTimeArg == None and not subTimeArg == "" :
# rule += ",SndTime==" + str( subTimeArg )
# cap with comma
if len(eqnIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
if len(clockSubIDs) > 0:
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(clockSubIDs)):
newSubgoal = ""
s = clockSubIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName \
FROM Subgoals \
WHERE rid == '" + str(rid) + "' AND \
sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute("SELECT attName \
FROM SubgoalAtt \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute("SELECT subgoalTimeArg \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute("SELECT subgoalPolarity \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subPolarity = cursor.fetchone(
) # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(clockSubIDs) - 1:
newSubgoal += ","
rule += newSubgoal
#if len( clockSubIDs ) > 0 and len( negSubIDs ) > 0 :
# rule += ","
# cap with comma
if len(clockSubIDs) > 0:
rule += ","
# --------------------------------------------------------------- #
if len(negSubIDs) > 0:
subTimeArg = None
# iterate over subgoal ids
for k in range(0, len(negSubIDs)):
newSubgoal = ""
s = negSubIDs[k]
# get subgoal name
cursor.execute("SELECT subgoalName \
FROM Subgoals \
WHERE rid == '" + str(rid) + "' AND \
sid == '" + str(s) + "'")
subgoalName = cursor.fetchone()
if not subgoalName == None:
subgoalName = tools.toAscii_str(subgoalName)
logging.debug("subgoalName = " + subgoalName)
# get subgoal attribute list
subAtts = cursor.execute("SELECT attName \
FROM SubgoalAtt \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subAtts = cursor.fetchall()
subAtts = tools.toAscii_list(subAtts)
# get subgoal time arg
cursor.execute("SELECT subgoalTimeArg \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subTimeArg = cursor.fetchone() # assume only one time arg
subTimeArg = tools.toAscii_str(subTimeArg)
# get subgoal polarity
cursor.execute("SELECT subgoalPolarity \
FROM Subgoals \
WHERE rid == '" + rid + "' AND \
sid == '" + s + "'")
subPolarity = cursor.fetchone(
) # assume only one additional arg
subPolarity = tools.toAscii_str(subPolarity)
subPolarity += " "
newSubgoal += subPolarity
# all subgoals have a name and open paren
newSubgoal += subgoalName + "("
# add in all attributes
for j in range(0, len(subAtts)):
currAtt = subAtts[j]
# replace SndTime in subgoal with subTimeArg, if applicable
if not subTimeArg == "" and "SndTime" in currAtt:
currAtt = str(subTimeArg)
if j < (len(subAtts) - 1):
newSubgoal += currAtt + ","
else:
newSubgoal += currAtt + ")"
# cap with a comma, if applicable
if k < len(negSubIDs) - 1:
newSubgoal += ","
rule += newSubgoal
# --------------------------------------------------------------- #
if rule.endswith(","):
rule = rule[:-1]
rule += " ;" + "\n" # end all rules with a semicolon
rule = rule.replace(" ,", "")
rule = rule.replace(",,", ",")
rule = rule.translate(None, string.whitespace)
rule = rule.replace(",;", ";")
rule = rule.replace("notin", "notin ")
logging.debug(" >>> rule = " + rule)
return rule
def iedb_rewrites(factMeta, ruleMeta, cursor, settings_path):
logging.debug(" IEDB REWRITES : running process...")
# ----------------------------------------- #
# generate a dictionary mapping
# relation names to lists of fact ids.
cursor.execute("SELECT goalName FROM Rule")
idb_rel_list = cursor.fetchall()
idb_rel_list = tools.toAscii_list(idb_rel_list)
logging.debug(" IEDB REWRITES : idb_rel_list = " + str(idb_rel_list))
# initialize dictionary
rel_name_to_fact_obj_map = {}
for rel_name in idb_rel_list:
rel_name_to_fact_obj_map[rel_name] = []
logging.debug(" IEDB REWRITES : rel_name_to_fact_obj_map = " +
str(rel_name_to_fact_obj_map))
# collect fids
for f in factMeta:
if f.relationName in idb_rel_list:
rel_name_to_fact_obj_map[f.relationName].append(f)
logging.debug(" IEDB REWRITES : rel_name_to_fact_obj_map = " +
str(rel_name_to_fact_obj_map))
# ----------------------------------------- #
# append "_edb" to all fact names
for rel_name in rel_name_to_fact_obj_map:
fact_obj_list = rel_name_to_fact_obj_map[rel_name]
logging.debug(" IEDB REWRITES : rel_name = " + rel_name)
logging.debug(" IEDB REWRITES : fact_obj_list = " +
str(fact_obj_list))
for fact_obj in fact_obj_list:
logging.debug(" IEDB REWRITES : fact_obj.cursor = " +
str(fact_obj.cursor))
logging.debug(" IEDB REWRITES : fact_obj.factData = " +
str(fact_obj.factData))
fact_obj.relationName += "_edb"
fact_obj.saveFactInfo()
fact_obj.factData[
"relationName"] += "_edb" # reflect the change in the factData
logging.debug(" IEDB REWRITES : after:")
logging.debug(" IEDB REWRITES : fact_obj.factData = " +
str(fact_obj.factData))
cursor.execute("SELECT name FROM Fact WHERE fid=='" +
str(fact_obj.fid) + "'")
name = cursor.fetchone()
name = tools.toAscii_str(name)
logging.debug(" IEBD REWRITES : name = " + str(name))
#sys.exit( "foo" )
# ----------------------------------------- #
# add a new rule with the original goal
# predicated on the new _edb goal name
for rel_name in rel_name_to_fact_obj_map:
logging.debug(" IEDB REWRITES : rel_name = " + rel_name)
logging.debug( " IEDB REWRITEs : len( rel_name_to_fact_obj_map[ " + rel_name + " ] ) = " + \
str( len( rel_name_to_fact_obj_map[ rel_name ] ) ) )
if len(rel_name_to_fact_obj_map[rel_name]) > 0:
new_ruleData = {}
new_ruleData["relationName"] = rel_name
new_ruleData["goalTimeArg"] = ""
new_ruleData["eqnDict"] = {}
# build the goal attribute list
new_goalAttList = []
representative_factData = rel_name_to_fact_obj_map[rel_name][
0].factData # just pick one
representative_dataList = representative_factData["dataList"]
logging.debug(" representative_factData = " +
str(representative_factData))
logging.debug(" representative_dataList = " +
str(representative_dataList))
arity = len(representative_dataList)
for i in range(0, arity):
new_goalAttList.append("A" + str(i))
new_ruleData["goalAttList"] = new_goalAttList
# build the subgoal
new_subgoal_dict = {}
new_subgoal_dict["subgoalName"] = rel_name + "_edb"
new_subgoal_dict["subgoalAttList"] = new_goalAttList
new_subgoal_dict["polarity"] = ""
new_subgoal_dict["subgoalTimeArg"] = ""
new_ruleData["subgoalListOfDicts"] = [new_subgoal_dict]
# generate a new rid
rid = tools.getIDFromCounters("rid")
logging.debug(" IEDB REWRITES : new_ruleData = " +
str(new_ruleData))
# save the new rule
new_rule = copy.deepcopy(Rule.Rule(rid, new_ruleData, cursor))
new_rule.cursor = cursor # need to do this again for some reason???
ruleMeta.append(new_rule)
# set the types!
#setTypes.setTypes( cursor, argDict )
logging.debug(" IEDB REWRITES : done on rel_name = " + rel_name)
# ----------------------------------------- #
logging.debug(" IEDB REWRITES : ...done.")
return factMeta, ruleMeta
def getRewrittenRuleIDs(cursor):
cursor.execute("SELECT rid FROM Rule WHERE goalTimeArg == 'rewritten'")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
return ridList
def c4datalog(argDict, cursor):
logging.debug(" C4 DATALOG : running process...")
goalName = None
provGoalNameOrig = None
tableListStr = "" # collect all table names delmited by a single comma only.
tableListArray = []
# ----------------------------------------------------------- #
# create goal defines
# get all rids
cursor.execute("SELECT rid FROM Rule")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
definesNames = []
definesList = []
# ////////////////////////////////////////////////////////// #
# populate defines list for rules
for rid in ridList:
newDefine = ""
# get goal name
cursor.execute("SELECT goalName FROM Rule WHERE rid = '" + rid + "'")
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# if it's a prov rule, get the original goal name
provGoalNameOrig = None
if "_prov" in goalName:
provGoalNameOrig = goalName.split("_prov")
provGoalNameOrig = provGoalNameOrig[0]
# populate table information collection structures
tableListStr += goalName + ","
tableListArray.append(goalName)
# ////////////////////////////////////////////////////////// #
# populate defines list for rule goals
logging.debug("In c4datalog: definesList = " + str(definesList))
if not existingDefine(goalName, definesNames): # prevent duplicates
# get goal attribute list
cursor.execute("SELECT attID,attType From GoalAtt WHERE rid = '" +
rid + "'")
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList(goalAttList)
logging.debug("* goalName = " + goalName + ", goalAttList " +
str(goalAttList))
# populate type list for rule
typeList = []
for k in range(0, len(goalAttList)):
att = goalAttList[k]
attID = att[0]
attType = att[1]
typeList.append(attType)
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += goalName
newDefine += ",{"
for i in range(0, len(typeList)):
newDefine += typeList[i]
if i < len(typeList) - 1:
newDefine += ","
else:
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList:
definesNames.append(goalName)
definesList.append(newDefine)
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# create fact defines
# get all fact ids
cursor.execute("SELECT fid FROM Fact")
fidList = cursor.fetchall()
fidList = tools.toAscii_list(fidList)
for fid in fidList:
# get goal name
cursor.execute("SELECT name FROM Fact WHERE fid = '" + fid + "'")
factName = cursor.fetchone()
factName = tools.toAscii_str(factName)
logging.debug("**> factName = " + factName)
logging.debug("In c4datalog: definesList = " + str(definesList))
if not existingDefine(factName, definesNames): # prevent duplicates
# populate table string
tableListStr += factName + ","
tableListArray.append(factName)
# get goal attribute list
cursor.execute(
"SELECT dataID,dataType From FactData WHERE fid = '" + fid +
"'")
factAttList = cursor.fetchall()
factAttList = tools.toAscii_multiList(factAttList)
logging.debug("* factName = " + factName + ", factAttList " +
str(factAttList))
# populate type list for fact
typeList = []
for k in range(0, len(factAttList)):
att = factAttList[k]
attID = att[0]
attType = att[1]
typeList.append(attType)
# check for time argument
#cursor.execute( "SELECT timeArg FROM Fact WHERE fid='" + fid + "'" )
#timeArg = cursor.fetchone()
#timeArg = tools.toAscii_str( timeArg )
#if timeArg :
# typeList.append( "int" )
# populate new c4 define statement
newDefine = ""
newDefine += "define("
newDefine += factName
newDefine += ",{"
for i in range(0, len(typeList)):
newDefine += typeList[i]
if i < len(typeList) - 1:
newDefine += ","
else:
newDefine += "});" + "\n"
# save new c4 define statement
if not newDefine in definesList:
definesNames.append(factName)
definesList.append(newDefine)
# ////////////////////////////////////////////////////////// #
# ----------------------------------------------------------- #
# add clock define
definesList.append("define(clock,{string,string,int,int});\n")
tableListStr += "clock,"
tableListArray.append("clock")
# ----------------------------------------------------------- #
# add not_clock define
#definesList.append( "define(not_clock,{string,string,int,int});\n" )
#tableListStr += "not_clock,"
#tableListArray.append( "not_clock" )
# ----------------------------------------------------------- #
# add crash define
definesList.append("define(crash,{string,string,int,int});\n")
tableListStr += "crash,"
tableListArray.append("crash")
# ----------------------------------------------------------- #
# add facts
cursor.execute("SELECT fid FROM Fact")
fidList = cursor.fetchall()
fidList = tools.toAscii_list(fidList)
factList = []
for fid in fidList:
newFact = dumpers_c4.dumpSingleFact_c4(fid, cursor)
factList.append(newFact)
# ----------------------------------------------------------- #
# add clock facts
clockFactList = dumpers_c4.dump_clock(cursor)
logging.debug("c4_translator: clockFactList = " + str(clockFactList))
# ----------------------------------------------------------- #
# add crash facts
crashFactList = dumpers_c4.dump_crash(cursor)
#crashFactList = []
#print crashFactList
#tools.bp( __name__, inspect.stack()[0][3], "blah" )
#logging.debug( "c4_translator: crashFactList = " + str( crashFactList ) )
# ----------------------------------------------------------- #
# add rules
cursor.execute("SELECT rid FROM Rule")
ridList = cursor.fetchall()
ridList = tools.toAscii_list(ridList)
ruleList = []
for rid in ridList:
# verify data type compatibility for rules with equations
#verificationResults = tools.checkDataTypes( rid, cursor ) # returns array
#yesCompatible = verificationResults[0]
#offensiveEqn = verificationResults[1]
#lhsType = verificationResults[2]
#rhsType = verificationResults[3]
#if yesCompatible :
if True:
newRule = dumpers_c4.dumpSingleRule_c4(rid, cursor)
ruleList.append(newRule)
else: # data types are incompatible
# throw error and abort
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR: DATA TYPE INCOMPATABILITY\nAttempting to evaluate an equation in which variables possess incomparable types.\nERROR in line: "
+ dumpers_c4.dumpSingleRule_c4(rid, cursor) +
"\nERROR in eqn: " + offensiveEqn + "\nlhs is of type " +
lhsType + " and rhs is of type " + rhsType)
# ------------------------------------------------------ #
# grab the next rule handling method
try:
NEXT_RULE_HANDLING = tools.getConfig( argDict[ "settings" ], \
"DEFAULT", \
"NEXT_RULE_HANDLING", \
str )
except ConfigParser.NoOptionError:
logging.info(
"WARNING : no 'NEXT_RULE_HANLDING' defined in 'DEFAULT' section of settings file."
)
tools.bp( __name__, inspect.stack()[0][3], \
"FATAL ERROR : NEXT_RULE_HANDLING parameter not specified in DEFAULT section of settings file. use 'USE_AGGS', 'SYNC_ASSUMPTION', or 'USE_NEXT_CLOCK' only." )
# sanity check next rule handling value
if NEXT_RULE_HANDLING == "USE_AGGS" or \
NEXT_RULE_HANDLING == "SYNC_ASSUMPTION" or \
NEXT_RULE_HANDLING == "USE_NEXT_CLOCK" :
pass
else:
tools.bp( __name__, inspect.stack()[0][3], \
"FATAL ERROR : unrecognized NEXT_RULE_HANDLING value '" + NEXT_RULE_HANDLING + "'. use 'USE_AGGS', 'SYNC_ASSUMPTION', or 'USE_NEXT_CLOCK' only." )
# ----------------------------------------------------------- #
# add next_clock, if necessary
if NEXT_RULE_HANDLING == "USE_NEXT_CLOCK":
# ------------------------------------------------------ #
# add define
definesList.append("define(next_clock,{string,string,int,int});\n")
tableListStr += "next_clock,"
tableListArray.append("next_clock")
# ------------------------------------------------------ #
# add next_clock facts for all synchronous facts appearing clock
next_clock_factList = []
for cfact in clockFactList:
if isSynchronous(cfact):
next_clock_fact = "next_" + cfact
next_clock_factList.append(next_clock_fact)
# ----------------------------------------------------------- #
# save table list
logging.debug("*******************************************")
logging.debug("table list str :\n" + str(tableListStr))
logging.debug("table list array :\n" + str(tableListArray))
# ----------------------------------------------------------- #
# collect program statements
logging.debug("*******************************************")
logging.debug("definesList :\n" + str(definesList))
logging.debug("*******************************************")
logging.debug("factList :\n" + str(factList))
logging.debug("*******************************************")
logging.debug("ruleList :\n" + str(ruleList))
# NOTE: listOfStatementLists controls the ordering of statements
# in the final c4 program.
if NEXT_RULE_HANDLING == "USE_NEXT_CLOCK":
listOfStatementLists = [ definesList, \
ruleList, \
factList, \
crashFactList, \
next_clock_factList, \
clockFactList ]
else:
#listOfStatementLists = [ definesList, \
# factList, \
# ruleList, \
# clockFactList ]
listOfStatementLists = [ definesList, \
ruleList, \
factList, \
crashFactList, \
clockFactList ]
program = tools.combineLines(listOfStatementLists)
# break down into list of individual statements
allProgramLines = []
for group in listOfStatementLists:
for statement in group:
allProgramLines.append(statement.rstrip())
# remove duplicates
tableListArray = set(tableListArray)
tableListArray = list(tableListArray)
logging.debug(" C4 DATALOG : ...done.")
return [allProgramLines, tableListArray]
def doDeMorgans( parentRID, ruleRIDs, cursor ) :
print "==========================================="
print "... running DO DEMORGANS from deMorgans ..."
print "==========================================="
# ----------------------------------------------------------- #
# get data for naming stuff
# ----------------------------------------------------------- #
# parent name
cursor.execute( "SELECT goalName FROM Rule WHERE rid='" + parentRID + "'" )
parentName = cursor.fetchall()
parentName = tools.toAscii_str( parentName[0] )
# this IDB name
cursor.execute( "SELECT goalName FROM Rule WHERE rid='" + ruleRIDs[0] + "'" )
thisIDBName = cursor.fetchall()
thisIDBName = tools.toAscii_str( thisIDBName[0] )
# ----------------------------------------------------------- #
# combine all rules for each rule name into a single
# sympy formula string
# ----------------------------------------------------------- #
# associate each subgoal per rule for this IDB definition with an identifier
# and map to [ rid, [ sign, sid ] ] arrays
predicateToID_map = {}
# map rids,sid pairs to predicate identifiers (essentially the reverse of the above mapping)
ridSidToPredicate_map = {}
# ////////////////////////////////////////// #
# get all rule data
for rid in ruleRIDs :
# get list of all sids for this rid
# filter out sids for domain subgoals
cursor.execute( "SELECT sid FROM Subgoals WHERE rid=='" + rid + "' AND NOT subgoalName LIKE 'dom_%'" )
sidList = cursor.fetchall()
sidList = tools.toAscii_list( sidList )
# map sids to sign for this rule
signMap = {}
for sid in sidList :
cursor.execute( "SELECT argName FROM SubgoalAddArgs WHERE rid='" + rid + "' AND sid='" + sid + "'" )
sign = cursor.fetchone()
if sign :
sign = tools.toAscii_str( sign )
signMap[ sid ] = sign
for sid in sidList :
sign = signMap[ sid ]
# get a random identifier string
predID = tools.getID()
# map predIDs to rids and sids
predicateToID_map[ predID ] = [ rid, [ sign, sid ] ]
# map rids and sids to predIDs
if sign == "notin" :
key = rid + ",_NEG_" + sid
else :
key = rid + "," + sid
ridSidToPredicate_map[ key ] = predID
# ----------------------------------------------------------- #
# simplify DNF
simplified_negFmla = getDNFFmla_v1( ridSidToPredicate_map )
#simplified_negFmla = getDNFFmla_v2( ridSidToPredicate_map )
# ----------------------------------------------------------- #
# save a new rule to IR db per disjunct
newDMRIDList = setNewRules( parentName, thisIDBName, simplified_negFmla, predicateToID_map, cursor )
# ----------------------------------------------------------- #
return newDMRIDList
def rewriteDeductive(cursor):
if DEDALUSREWRITER_DEBUG:
print " ... running deductive rewrite ..."
# grab all existing non-next and non-async rule ids
deductiveRuleIDs = getDeductiveRuleIDs(cursor)
# add attribute 'SndTime' to head as the new rightmost attribute
for rid in deductiveRuleIDs:
# ......................................... #
cursor.execute("SELECT goalName FROM Rule WHERE rid =='" + rid + "'")
goalName = cursor.fetchone()
goalName = tools.toAscii_str(goalName)
# ......................................... #
#print "*******************************"
#print "old rule : " + str( dumpers.reconstructRule(rid, cursor) )
if not tools.checkIfRewrittenAlready(rid, cursor):
# set rule as rewritten
cursor.execute("UPDATE Rule SET rewritten='" + rewrittenFlag +
"' WHERE rid=='" + rid + "'")
# grab maximum attribute id
cursor.execute("SELECT MAX(attID) FROM GoalAtt WHERE rid == '" +
rid + "'")
rawMaxID = cursor.fetchone()
rawMaxID = rawMaxID[0] # extract from tuple
if rawMaxID or (rawMaxID == 0):
newAttID = int(rawMaxID + 1) # the att id for SndTime
# check if add arg is a specific time
cursor.execute("SELECT goalTimeArg FROM Rule WHERE rid == '" +
rid + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
if timeArg.isdigit():
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid +
"','" + str(newAttID) + "','" + timeArg +
"','int')")
else:
cursor.execute("INSERT INTO GoalAtt VALUES ('" + rid +
"','" + str(newAttID) + "','" +
timeAtt_snd + "','int')")
else:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : current rule goal has no attributes:\n" +
dumpers.reconstructRule(rid, cursor))
# add attribute 'Time' to all subgoals
sids = getSubgoalIDs(cursor, rid) # get all subgoal ids
sids = tools.toAscii_list(sids)
firstSubgoalAtts = []
# iterate over rule subgoals
for s in sids:
# ......................................... #
cursor.execute(
"SELECT subgoalName FROM Subgoals WHERE rid=='" + rid +
"' AND sid=='" + s + "'")
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str(subgoalName)
# ......................................... #
addArg = None
# get time arg for subgoal
cursor.execute(
"SELECT subgoalTimeArg FROM Subgoals WHERE rid = '" + rid +
"' AND sid = '" + s + "'")
timeArg = cursor.fetchone()
timeArg = tools.toAscii_str(timeArg)
# add Time as a subgoal attribute
cursor.execute(
'''SELECT MAX(attID) FROM SubgoalAtt WHERE SubgoalAtt.sid == "'''
+ s + '''"''')
rawMaxID = cursor.fetchone() # int type
newAttID = int(rawMaxID[0] + 1)
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid +
"','" + s + "'," + str(newAttID) + ",'" +
timeAtt_snd + "','int')")
# replace subgoal time attribute with numeric time arg
if timeArg.isdigit():
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE sid = '" + s +
"'")
satts = cursor.fetchall()
satts = tools.toAscii_list(satts)
# ......................................... #
#if goalName == "pre" :
# if subgoalName == "bcast" :
# print " timeArg = " + str(timeArg)
# print " satts = " + str(satts)
# tools.bp( __name__, inspect.stack()[0][3], "___ASDFASLKDHFWER" )
# ......................................... #
for i in range(0, len(satts)):
if satts[i] == timeAtt_snd:
cursor.execute("UPDATE SubgoalAtt SET attName='" +
timeArg + "' WHERE rid = '" + rid +
"' AND sid = '" + s +
"' AND attID = '" + str(i) + "'")
# collect the additional argument (aka notin for c4)
cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE SubgoalAddArgs.rid == '"
+ rid + "' AND SubgoalAddArgs.sid == '" + s + "'")
addArg = cursor.fetchone()
if addArg:
addArg = tools.toAscii_str(addArg)
# while we're here, collect the first attribute of this subgoal
cursor.execute(
"SELECT attName FROM SubgoalAtt WHERE SubgoalAtt.sid == '"
+ s + "' AND SubgoalAtt.attID == '" + str(0) + "'")
firstAtt = cursor.fetchone()
if (not firstAtt == None) and (
not addArg
== "notin"): # need branch on notin for safety
firstAtt = tools.toAscii_str(firstAtt)
firstSubgoalAtts.append(firstAtt)
else:
if DEDALUSREWRITER_DEBUG:
print "firstAtt = " + str(firstAtt)
# sanity checking branch
if len(firstSubgoalAtts) > 0:
pass
# add clock subgoal
#clockTools.addClockSubgoal_deductive( rid, firstSubgoalAtts, timeAtt_snd, timeAtt_deliv, cursor )
else:
print dumpers.reconstructRule(rid, cursor)
tools.bp(
__name__,
inspect.stack()[0][3],
"We've got major probs, mate. The subgoals of this rule have no attributes.\nfirstSubgoalAtts = "
+ str(firstSubgoalAtts) + "\nMake sure the rule is safe.")
#tools.bp( __name__, inspect.stack()[0][3], "new rule : " + str(dumpers.reconstructRule(rid, cursor)) )
# check for bugs
if DEDALUSREWRITER_DEBUG:
print "Rule :"
cursor.execute('''SELECT * FROM Rule''')
for i in cursor.fetchall():
print i
print "GoalAtt"
cursor.execute("SELECT * FROM GoalAtt")
for s in cursor.fetchall():
print s
print "Subgoals"
cursor.execute("SELECT * FROM Subgoals")
for s in cursor.fetchall():
print s
print "SubgoalAtt"
cursor.execute("SELECT * FROM SubgoalAtt")
for s in cursor.fetchall():
print s
