def prioritizeNegatedLast_2(rid, subIDs, cursor):
posSubs = []
clockSubs = []
negSubs = []
# check if subgoal is negated
# branch on result.
for subID in subIDs:
cursor.execute("SELECT subgoalName,subgoalPolarity \
FROM Subgoals \
WHERE rid=='" + rid + "' AND \
sid=='" + subID + "'")
data = cursor.fetchall()
data = tools.toAscii_multiList(data)
name = data[0][0]
sign = data[0][1]
if name == "clock":
clockSubs.append(subID)
elif not sign == "notin":
posSubs.append(subID)
else:
negSubs.append(subID)
return posSubs, clockSubs, negSubs
def dump_clock(cursor):
logging.debug("...running dumpers_c4 dump_clock...")
formattedClockFactsList = []
#cursor.execute( "SELECT * FROM Clock" )
cursor.execute("SELECT src, dest, sndTime, delivTime FROM Clock")
clockFacts = cursor.fetchall()
clockFacts = tools.toAscii_multiList(clockFacts)
logging.debug("dump_clock: clockFacts = " + str(clockFacts))
for c in clockFacts:
logging.debug("c = " + str(c))
clockF = 'clock('
for i in range(0, len(c)):
currData = c[i]
if i < 2:
clockF += '"' + currData + '",'
else:
clockF += str(currData)
if i < len(c) - 1:
clockF += ","
clockF += ");" + "\n" # all clock facts end with a semicolon
formattedClockFactsList.append(clockF)
return formattedClockFactsList
def setAttTypes(self):
allDataList = self.getAttList() # ordered by appearance in program
allAttTypes = self.getTypeList(
allDataList) # ordered by appearance in program
#if self.getName() == "bcast" :
# print "allDataList = " + str( allDataList )
# print "allAttTypes = " + str( allAttTypes )
# tools.dumpAndTerm( self.cursor )
# set att types for this fact
# ordering is crucial
attID = 0
for attType in allAttTypes:
self.cursor.execute("UPDATE FactAtt SET attType=='" + attType +
"' WHERE fid=='" + self.fid + "' AND attID==" +
str(attID))
attID += 1
# dump table for debugging
if DEBUG:
self.cursor.execute("SELECT * FROM FactAtt")
res = self.cursor.fetchall()
res = tools.toAscii_multiList(res)
print "FACT :"
print self.display()
print "CONTENTS OF TABLE FactAtt"
for r in res:
print r
def addSubgoalsToRules(domainRuleName, newDMRIDList, cursor):
# -------------------------------------------- #
# get goal att list for the dom_not_whatever
# rule previously written in addDomainRules
# -------------------------------------------- #
# get rid for the domain rule
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" + domainRuleName +
"'")
rid = cursor.fetchone()
if not rid or rid == "":
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : writing domain subgoals, but no '" +
domainRuleName + "' rule exists. aborting...")
else:
rid = tools.toAscii_str(rid)
# get the goal attribute list for the domain rule
cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
rid + "'")
goalAttList = cursor.fetchall()
goalAttList = tools.toAscii_multiList(goalAttList)
for rid in newDMRIDList:
# ----------------------------------- #
# generate sid #
# ----------------------------------- #
sid = tools.getID()
# ----------------------------------- #
# fixed subgoal time arg to nothing #
# ----------------------------------- #
subgoalTimeArg = ""
# ----------------------------------- #
# insert subgoal metadata #
# ----------------------------------- #
cursor.execute("INSERT INTO Subgoals VALUES ('" + rid + "','" + sid +
"','" + domainRuleName + "','" + subgoalTimeArg + "')")
# ----------------------------------- #
# insert subgoal att data #
# ----------------------------------- #
attID = 0
for att in goalAttList:
attName = att[1]
attType = att[2]
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" +
sid + "','" + str(attID) + "','" + attName + "','" +
attType + "')")
attID += 1
def getClockTriggerRecordList(self):
# sanity check
# all clock records adhere to the same arity-4 schema: src, dest, SndTime, DelivTime
if not len(self.record) == 4:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : clock record does not adhere to clock schema(src,dest,SndTime,DelivTime) : \nself.record = "
+ str(self.record))
# get clock record data
src = self.record[0]
dest = self.record[1]
sndTime = self.record[2]
delivTime = self.record[3]
# get all matching (or partially matching, in the case of '_') clock records
# optimistic by default
qSRC = "src=='" + src + "'"
qDEST = " AND dest=='" + dest + "'"
qSNDTIME = " AND sndTime==" + sndTime + ""
qDELIVTIME = " AND delivTime==" + delivTime + ""
qInclusionBool = " AND simInclude=='True'"
# erase query components as necessary
if "_" in src:
qSRC = ""
if "_" in dest:
qDEST = ""
if "_" in sndTime:
qSNDTIME = ""
if "_" in delivTime:
qDELIVTIME = ""
# handle empty SRC
if qSRC == "" and not qDEST == "":
qDEST = qDEST.replace("AND", "")
elif qSRC == "" and qDEST == "" and not qSNDTIME == "":
qSNDTIME = qSNDTIME.replace("AND", "")
elif qSRC == "" and qDEST == "" and qSNDTIME == "" and not qDELIVTIME == "":
qDELIVTIME = qDELIVTIME.replace("AND", "")
elif qSRC == "" and qDEST == "" and qSNDTIME == "" and qDELIVTIME == "" and not qInclusionBool == "":
qInclusionBool = qInclusionBool.replace("AND", "")
# set query
query = "SELECT src,dest,sndTime,delivTime FROM Clock WHERE " + qSRC + qDEST + qSNDTIME + qDELIVTIME + qInclusionBool
if DEBUG:
print "query = " + str(query)
print query
# execute query
self.cursor.execute(query)
triggerRecordList = self.cursor.fetchall()
triggerRecordList = tools.toAscii_multiList(triggerRecordList)
return triggerRecordList
def test_toAscii_multiList_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_multiList(testmulti) == None)
def dump_crash(cursor):
if DUMPERS_C4_DEBUG:
print "...running dumpers_c4 dump_crash..."
formattedCrashFactsList = []
cursor.execute("SELECT src, dest, sndTime FROM Crash")
crashFacts = cursor.fetchall()
crashFacts = tools.toAscii_multiList(crashFacts)
if len(crashFacts) < 1:
#tools.bp( __name__, inspect.stack()[0][3], "FATAL ERROR : crash table is empty." )
cursor.execute(
"INSERT INTO Crash (src,dest,sndTime) VALUES ('NULL','NULL','99999999')"
)
cursor.execute("SELECT src, dest, sndTime FROM Crash")
crashFacts = cursor.fetchall()
crashFacts = tools.toAscii_multiList(crashFacts)
if DUMPERS_C4_DEBUG:
print "crashFacts = " + str(crashFacts)
if DUMPERS_C4_DEBUG:
print "dump_crash: crashFacts = " + str(crashFacts)
for c in crashFacts:
if DUMPERS_C4_DEBUG:
print "c = " + str(c)
crashF = 'crash('
for i in range(0, len(c)):
currData = c[i]
if i < 2:
crashF += '"' + currData + '",'
else:
crashF += str(currData)
if i < len(c) - 1:
crashF += ","
crashF += ");" + "\n" # all crash facts end with a semicolon
formattedCrashFactsList.append(crashF)
return formattedCrashFactsList
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 getGoalAttMaps(self, oridList):
ogattMap = []
# get the ordered list of goal attributes for each orid
oridAttLists = []
for orid in oridList:
self.cursor.execute(
"SELECT attID,attName FROM GoalAtt WHERE rid=='" + orid + "'")
attList = self.cursor.fetchall()
attList = tools.toAscii_multiList(attList)
attList = [aPair[1] for aPair in attList]
oridAttLists.append([orid, attList])
# for each orid:attList, connect atts to vals from seed record
for oridInfo in oridAttLists:
thisorid = oridInfo[0]
thisattList = oridInfo[1]
# sanity check
# the number of goal atts in the original rule must match
# the number of values in the seed record.
if (len(thisattList) < len(self.record)) or (len(thisattList) >
len(self.record)):
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : number of attributes in goal attribute list for "
+ self.name +
" does not match the number of values in the seed record:\nattribute list = "
+ str(thisattList) + "\nrecord = " + str(self.record))
# map atts to values from the seed record
thisAttValList = []
for i in range(0, len(thisattList)):
att = thisattList[i]
val = self.record[i]
thisAttValList.append([att, val])
ogattMap.append([thisorid, thisAttValList])
return ogattMap
def rewrite_to_datalog( argDict, factMeta, ruleMeta, cursor ) :
logging.debug( " REWRITE : running process..." )
settings_path = argDict[ "settings" ]
EOT = argDict[ "EOT" ]
for rule in ruleMeta :
rid = rule.rid
cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
goal_atts = cursor.fetchall()
logging.debug( " DEDT : len( goal_atts ) = " + str( len( goal_atts )) )
goal_atts = tools.toAscii_multiList( goal_atts )
logging.debug( " DEDT : len( goal_atts ) = " + str( len( goal_atts )) )
logging.debug( " DEDT : goal_atts (0) = " + str( goal_atts ) )
logging.debug( " DEDT : r = " + dumpers.reconstructRule( rid, cursor ) )
# ----------------------------------------------------------------------------- #
# dedalus rewrite
logging.debug( " REWRITE : calling dedalus rewrites..." )
allMeta = dedalusRewriter.rewriteDedalus( argDict, factMeta, ruleMeta, cursor )
factMeta = allMeta[0]
ruleMeta = allMeta[1]
# be sure to fill in all the type info for the new rule definitions
#setTypes.setTypes( cursor, argDict, ruleMeta )
for rule in ruleMeta :
rid = rule.rid
cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
goal_atts = cursor.fetchall()
goal_atts = tools.toAscii_multiList( goal_atts )
#logging.debug( " DEDT : goal_atts (1) = " + str( goal_atts ) )
logging.debug( " DEDT : rule.ruleData = " + str( rule.ruleData ) )
# ----------------------------------------------------------------------------- #
# other rewrites
# first get parameters for which rewrites to run.
# ========== WILDCARD ========== #
try :
rewriteWildcards = tools.getConfig( settings_path, "DEFAULT", "WILDCARD_REWRITES", bool )
except ConfigParser.NoOptionError :
logging.warning( "WARNING : no 'WILDCARD_REWRITES' defined in 'DEFAULT' section of " + settings_path + \
"...running without wildcard rewrites." )
rewriteWildcards = False
pass
# ========== DM ========== #
try :
RUN_DM = tools.getConfig( settings_path, "DEFAULT", "DM", bool )
except ConfigParser.NoOptionError :
logging.warning( "WARNING : no 'DM' defined in 'DEFAULT' section of " + settings_path + \
"...running without dm rewrites" )
RUN_DM = False
pass
# ========== NW_DOM_DEF ========== #
try :
NW_DOM_DEF = tools.getConfig( settings_path, "DEFAULT", "NW_DOM_DEF", str )
except ConfigParser.NoOptionError :
raise Exception( "no 'NW_DOM_DEF' defined in 'DEFAULT' section of " + settings_path + \
". aborting..." )
# ========== COMBO ========== #
try:
RUN_COMB = tools.getConfig( settings_path, "DEFAULT", "COMB", bool )
except ConfigParser.NoOptionError :
logging.info( "WARNING : no 'COMB' defined in 'DEFAULT' section of " + settings_path + \
"...running without combo rewrites" )
RUN_COMB = False
pass
# ========== IEDB ========== #
try :
RUN_IEDB_REWRITES = tools.getConfig( settings_path, "DEFAULT", "IEDB_REWRITES", bool )
except ConfigParser.NoOptionError :
logging.info( "WARNING : no 'IEDB_REWRITES' defined in 'DEFAULT' section of " + settings_path + \
"...running without iedb rewrites" )
RUN_IEDB_REWRITES = False
pass
# ----------------------------------------------------------------------------- #
# do wildcard rewrites
# always do wildcard rewrites in prep for negative writes.
if rewriteWildcards or \
( NW_DOM_DEF == "sip" and \
( argDict[ "neg_writes" ] == "dm" or \
argDict[ "neg_writes" ] == "combo" ) ) :
logging.debug( " REWRITE : calling wildcard rewrites..." )
ruleMeta = rewrite_wildcards.rewrite_wildcards( ruleMeta, cursor )
# for rule in ruleMeta :
# #logging.debug( "rule.ruleData = " + str( rule.ruleData ) )
# logging.debug( " REWRITE : (1) r = " + dumpers.reconstructRule( rule.rid, rule.cursor ) )
# #sys.exit( "blah2" )
# for rule in ruleMeta :
# logging.debug( " DEDT : rule.ruleData (2) = " + str( rule.ruleData ) )
# be sure to fill in all the type info for the new rule definitions
logging.debug( " REWRITE : running setTypes after wildcard rewrites." )
setTypes.setTypes( cursor, argDict, ruleMeta )
update_goal_types( ruleMeta )
else :
setTypes.setTypes( cursor, argDict, ruleMeta )
# ----------------------------------------------------------------------------- #
# iedb rewrites
if RUN_IEDB_REWRITES or \
( NW_DOM_DEF == "sip" and \
( argDict[ "neg_writes" ] == "dm" or \
argDict[ "neg_writes" ] == "combo" ) ) :
logging.debug( " REWRITE : calling iedb rewrites..." )
factMeta, ruleMeta = iedb_rewrites.iedb_rewrites( factMeta, \
ruleMeta, \
cursor, \
settings_path )
# for rule in ruleMeta :
# rid = rule.rid
# cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
# goal_atts = cursor.fetchall()
# goal_atts = tools.toAscii_multiList( goal_atts )
# logging.debug( " DEDT : goal_atts (3) = " + str( goal_atts ) )
#for rule in ruleMeta :
# print c4_translator.get_c4_line( rule.ruleData, "rule" )
#for fact in factMeta :
# print c4_translator.get_c4_line( fact.factData, "fact" )
#sys.exit( "asdf" )
# be sure to fill in all the type info for the new rule definitions
logging.debug( " REWRITE : running setTypes after iedb rewrites." )
setTypes.setTypes( cursor, argDict, ruleMeta )
# ----------------------------------------------------------------------------- #
# do dm rewrites
if argDict[ "neg_writes" ] == "dm" :
logging.debug( " REWRITE : calling dm rewrites..." )
factMeta, ruleMeta = dm.dm( factMeta, ruleMeta, cursor, argDict ) # returns new ruleMeta
logging.debug( " REWRITE : final dm program lines:" )
for rule in ruleMeta :
logging.debug( dumpers.reconstructRule( rule.rid, rule.cursor ) )
#sys.exit( "blah" )
# be sure to fill in all the type info for the new rule definitions
logging.debug( " REWRITE : running setTypes after dm rewrites." )
setTypes.setTypes( cursor, argDict, ruleMeta )
# ----------------------------------------------------------------------------- #
# do combo rewrites
if argDict[ "neg_writes" ] == "comb" :
# collect the results from the original program
original_prog = c4_translator.c4datalog( argDict, cursor )
results_array = c4_evaluator.runC4_wrapper( original_prog, argDict )
parsedResults = tools.getEvalResults_dict_c4( results_array )
# run the neg rewrite for combinatorial approach
# returns a new ruleMeta
logging.debug( " REWRITE : calling combo rewrites..." )
ruleMeta, factMeta = combitorialNegRewriter.neg_rewrite( cursor, \
argDict, \
settings_path,
ruleMeta, \
factMeta, \
parsedResults )
if argDict[ "neg_writes" ] == "combo" :
logging.debug( " REWRITE : calling combo rewrites..." )
factMeta, ruleMeta = combo.combo( factMeta, ruleMeta, cursor, argDict )
#for r in ruleMeta :
# print dumpers.reconstructRule( r.rid, r.cursor )
#sys.exit( "f**k" )
# for rule in ruleMeta :
# rid = rule.rid
# cursor.execute( "SELECT attID,attName FROM GoalAtt WHERE rid=='" + str( rid ) + "'" )
# goal_atts = cursor.fetchall()
# goal_atts = tools.toAscii_multiList( goal_atts )
# logging.debug( " DEDT : goal_atts (2) = " + str( goal_atts ) )
# ----------------------------------------------------------------------------- #
# provenance rewrites
#logging.debug( " REWRITE : before prov dump :" )
#for rule in ruleMeta :
# print rule
# logging.debug( " REWRITE : (0) r = " + printRuleWithTypes( rule.rid, cursor ) )
#sys.exit( "blah2" )
# add the provenance rules to the existing rule set
logging.debug( " REWRITE : calling provenance rewrites..." )
ruleMeta.extend( provenanceRewriter.rewriteProvenance( ruleMeta, cursor, argDict ) )
#for rule in ruleMeta :
# #logging.debug( "rule.ruleData = " + str( rule.ruleData ) )
# logging.debug( " REWRITE : (1) rid = " + str( rule.rid ) + " : " + dumpers.reconstructRule( rule.rid, rule.cursor ) )
#sys.exit( "blah2" )
# be sure to fill in all the type info for the new rule definitions
logging.debug( " REWRITE : running setTypes after provenance rewrites." )
setTypes.setTypes( cursor, argDict, ruleMeta )
# ----------------------------------------------------------------------------- #
# for rule in ruleMeta :
# logging.debug( "rule.ruleData = " + str( rule.ruleData ) )
# logging.debug( " REWRITE : (2) r = " + dumpers.reconstructRule( rule.rid, rule.cursor ) )
# sys.exit( "blah2" )
logging.debug( " REWRITE : ...done." )
return [ factMeta, ruleMeta ]
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 rewriteRule(rid, sid, attData, cursor):
print "#################################################################"
print " ... running REWRITE RULE from rewriteSubgoalsWithWildcards ... #"
print "#################################################################"
print "BEFORE : attData : " + str(attData)
# ------------------------------------------- #
# get name of sid
cursor.execute("SELECT subgoalName FROM Subgoals WHERE rid=='" + rid +
"' AND sid=='" + sid + "'")
subgoalName = cursor.fetchone()
subgoalName = tools.toAscii_str(subgoalName)
# ------------------------------------------- #
# branch on idb subgoals.
# if negated subgoal with wildcard is IDB, then ensure all attTypes are defined
# by pulling attTypes from the IDB goal attribute list.
if not tools.isFact_only(subgoalName, cursor):
# get rule id for the idb
cursor.execute("SELECT rid FROM Rule WHERE goalName=='" + subgoalName +
"'")
idbrid = cursor.fetchone()
idbrid = tools.toAscii_str(idbrid)
# get goal schema
cursor.execute(
"SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" + idbrid +
"'")
idbAttData = cursor.fetchall()
idbAttData = tools.toAscii_multiList(idbAttData)
print "idbAttData : " + str(idbAttData)
# fix original subgoal att list types
tmp = []
for i in range(0, len(idbAttData)):
idb_att = idbAttData[i]
orig_att = attData[i]
attID = orig_att[0]
attName = orig_att[1]
attType = idb_att[2]
tmp.append([attID, attName, attType])
attData = tmp
# ------------------------------------------- #
# generate new subgoal name
newSubgoalName = subgoalName + "_" + tools.getID_4() + "_wildcardrewrite"
# ------------------------------------------- #
# generate new subgoal att list
attNameList = []
newSubgoalAttList = []
attID = 0
for att in attData:
attName = att[1]
attType = att[2]
if not attName == "_" and attName not in attNameList:
newSubgoalAttList.append([attID, attName, attType])
attNameList.append(attName)
attID += 1
if True:
print ">> ORIG RULE <<"
print dumpers.reconstructRule(rid, cursor)
print ">>> <<<"
print "subgoalName = " + subgoalName
print "newSubgoalName = " + newSubgoalName
print "attData = " + str(attData)
print "newSubgoalAttList = " + str(newSubgoalAttList)
# ------------------------------------------- #
# update subgoal name
cursor.execute("UPDATE Subgoals SET subgoalName=='" + newSubgoalName +
"' WHERE rid=='" + rid + "' AND sid=='" + sid + "'")
# ------------------------------------------- #
# delete old subgoal att data
arity = len(attData)
for attID in range(0, arity):
cursor.execute("DELETE FROM SubgoalAtt WHERE rid=='" + rid +
"' AND sid=='" + sid + "' AND attID=='" + str(attID) +
"'")
# ------------------------------------------- #
# input new subgoal att data
for att in newSubgoalAttList:
attID = att[0]
attName = att[1]
attType = att[2]
cursor.execute("INSERT INTO SubgoalAtt VALUES ('" + rid + "','" + sid +
"'," + str(attID) + ",'" + attName + "','" + attType +
"')")
# ------------------------------------------- #
# add new rule
print "-------------------------------------"
print "subgoalName : " + subgoalName
print "newSubgoalName : " + newSubgoalName
print "attData : " + str(attData)
print "newSubgoalAttList : " + str(newSubgoalAttList)
#tools.bp( __name__, inspect.stack()[0][3], "asdf" )
newRule = addNewRule(subgoalName, newSubgoalName, attData,
newSubgoalAttList, cursor)
return newRule
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 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 get_program(table_list,
factMeta,
ruleMeta,
sip_ruleData=None,
sip_type_list=None):
program_lines = []
# get defines
defines = []
for rule in ruleMeta:
type_list = [t[1] for t in rule.goal_att_type_list]
rule_define = "define(" + \
rule.relationName + "," + \
"{" + ",".join( type_list ) + "});"
if not rule_define in defines:
defines.append(rule_define)
for fact in factMeta:
type_list = [t[1] for t in fact.dataListWithTypes]
fact_define = "define(" + \
fact.factData[ "relationName" ] + "," + \
"{" + ",".join( type_list ) + "});"
if not fact_define in defines:
defines.append(fact_define)
# get sip program line
if sip_ruleData and sip_type_list:
sip_line = c4_translator.get_c4_line(sip_ruleData, "rule")
sip_define = "define(" + \
sip_ruleData[ "relationName" ] + "," + \
"{" + ",".join( sip_type_list ) + "});"
# get program lines
rule_fact_lines = []
for rule in ruleMeta:
rule_fact_lines.append(c4_translator.get_c4_line(
rule.ruleData, "rule"))
for fact in factMeta:
rule_fact_lines.append(c4_translator.get_c4_line(
fact.factData, "fact"))
# build program
if sip_ruleData and sip_type_list:
defines.append(sip_define)
rule_fact_lines = [sip_line] + rule_fact_lines
if need_clocks(ruleMeta):
ruleMeta[0].cursor.execute(
"SELECT src,dest,sndTime,delivTime FROM Clock")
clock_facts = ruleMeta[0].cursor.fetchall()
clock_facts = tools.toAscii_multiList(clock_facts)
for cf in clock_facts:
rule_fact_lines.append( 'clock("' + cf[0] + \
'","' + cf[1] + \
'",' + str( cf[2] ) + \
',' + str( cf[3] ) + ');' )
defines.append("define(clock,{string,string,int,int});")
program_lines.extend(defines)
program_lines.extend(rule_fact_lines)
# get table list
# sever pointer to original table_list
if sip_ruleData and sip_type_list:
sip_table_list = table_list + [sip_ruleData["relationName"]]
return [program_lines, sip_table_list]
else:
return [program_lines, table_list]
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 get_domcomp( target_ruleSet, \
table_list, \
factMeta, \
ruleMeta, \
argDict, \
rid_to_rule_meta_map ) :
logging.debug(" GET DOMCOMP : target_ruleSet :")
for t in target_ruleSet:
logging.debug(" " + c4_translator.get_c4_line(t.ruleData, "rule"))
#sys.exit( "shit" )
cursor = ruleMeta[0].cursor # it's all the same db cursor
target_name = target_ruleSet[0].relationName
program_lines = []
domcomp_table_list = copy.deepcopy(table_list)
# get defines
defines = []
for rule in ruleMeta:
type_list = [t[1] for t in rule.goal_att_type_list]
rule_define = "define(" + \
rule.relationName + "," + \
"{" + ",".join( type_list ) + "});"
if not rule_define in defines:
defines.append(rule_define)
for fact in factMeta:
type_list = [t[1] for t in fact.dataListWithTypes]
fact_define = "define(" + \
fact.factData[ "relationName" ] + "," + \
"{" + ",".join( type_list ) + "});"
if not fact_define in defines:
defines.append(fact_define)
# check for user-defined not_ constraints
if user_constriaints_exist(target_name, factMeta):
pass
else:
# otherwise, build adom rules
adom_rule_meta = dm.buildAdom(factMeta, cursor)
for arm in adom_rule_meta:
program_lines.append(
c4_translator.get_c4_line(arm.ruleData, "rule"))
if arm.relationName == "adom_string":
arm_type = "string"
domcomp_table_list.append("adom_string")
else:
arm_type = "int"
domcomp_table_list.append("adom_int")
arm_define = "define(" + \
arm.ruleData[ "relationName" ] + "," + \
"{" + arm_type + "});"
if not arm_define in defines:
defines.append(arm_define)
# get domcomp rule
if user_constriaints_exist(target_name, factMeta):
domcomp_ruleData, domcomp_type_list = get_domcomp_rule( target_ruleSet, \
True, \
ruleMeta, \
rid_to_rule_meta_map )
else:
domcomp_ruleData, domcomp_type_list = get_domcomp_rule( target_ruleSet, \
False, \
ruleMeta, \
rid_to_rule_meta_map )
domcomp_define = "define(" + \
domcomp_ruleData[ "relationName" ] + "," + \
"{" + ",".join( domcomp_type_list ) + "});"
defines.append(domcomp_define)
program_lines.append(c4_translator.get_c4_line(domcomp_ruleData, "rule"))
domcomp_table_list.append("domcomp_not_" + target_name)
# add all other rules
rule_fact_lines = []
for rule in ruleMeta:
rule_fact_lines.append(c4_translator.get_c4_line(
rule.ruleData, "rule"))
for fact in factMeta:
rule_fact_lines.append(c4_translator.get_c4_line(
fact.factData, "fact"))
# deal with clocks.
if need_clocks(ruleMeta):
ruleMeta[0].cursor.execute(
"SELECT src,dest,sndTime,delivTime FROM Clock")
clock_facts = ruleMeta[0].cursor.fetchall()
clock_facts = tools.toAscii_multiList(clock_facts)
for cf in clock_facts:
rule_fact_lines.append( 'clock("' + cf[0] + \
'","' + cf[1] + \
'",' + str( cf[2] ) + \
',' + str( cf[3] ) + ');' )
defines.append("define(clock,{string,string,int,int});")
# run program
program_lines = defines + program_lines + rule_fact_lines
parsedResults = run_program_c4([program_lines, domcomp_table_list],
argDict)
return parsedResults["domcomp_not_" + target_name]
def collectUniversalBoundSubgoals(randomDMRID, parentRID, sidInParent, posName,
parentName, univAttData, cursor):
print
print "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
print "BUILDING UNIVERSAL BOUND SUBGOALS"
print "randomDMRID rule : " + dumpers.reconstructRule(randomDMRID, cursor)
print "parentRID rule : " + dumpers.reconstructRule(parentRID, cursor)
print "sidInParent : " + sidInParent
print "posName : " + posName
print "parentName : " + parentName
universalBoundSubgoals = []
# ===================================================================== #
# ===================================================================== #
# ----------------------------------- #
# build parent dom subgoal #
# ----------------------------------- #
parentSubgoalName = "dom_" + parentName + "_evalres"
print "parentSubgoalName : " + parentSubgoalName
# ---------------------------------------------- #
# get parent rule attribute list #
# ---------------------------------------------- #
cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
parentRID + "'")
parentGoalAttList = cursor.fetchall()
parentGoalAttList = tools.toAscii_multiList(parentGoalAttList)
# ---------------------------------------------- #
# get negated subgoal attribute list from parent #
# ---------------------------------------------- #
cursor.execute(
"SELECT attID,attName,attType FROM SubgoalAtt WHERE rid=='" +
parentRID + "' AND sid=='" + sidInParent + "'")
subAttDataInParent = cursor.fetchall()
subAttDataInParent = tools.toAscii_multiList(subAttDataInParent)
# --------------------------------------------------------------- #
# map parent goal att indexes to subgoal att indexes or wildcards #
# --------------------------------------------------------------- #
parentSubgoalAttIndexMap = {}
for paratt in parentGoalAttList:
pattID = paratt[0]
pattName = paratt[1]
subIndexes = []
for subatt in subAttDataInParent:
sattID = subatt[0]
sattName = subatt[1]
if pattName == sattName:
subIndexes.append(sattID)
parentSubgoalAttIndexMap[pattID] = subIndexes
# ------------------------------------------------------------------------------------------------------ #
# map parent subgoal att vars to the corresponding att vars in the uniform attribute set for the DM rule #
# ------------------------------------------------------------------------------------------------------ #
# get uniform attribute list
cursor.execute("SELECT attID,attName,attType FROM GoalAtt WHERE rid=='" +
randomDMRID + "'")
uniformAttList = cursor.fetchall()
uniformAttList = tools.toAscii_multiList(uniformAttList)
# populate map
subToUniformMap = {}
for i in range(0, len(subAttDataInParent)):
subatt = subAttDataInParent[i]
subAttName = subatt[1]
subToUniformMap[subAttName] = uniformAttList[i]
# ---------------------------------------------------------------------------------- #
# map parent goal att vars to vars from the uniform att list for the negated subgoal #
# ---------------------------------------------------------------------------------- #
parentSubgoalAttMap = {}
for parAttIndex in parentSubgoalAttIndexMap:
correspondingSubAttIndexList = parentSubgoalAttIndexMap[parAttIndex]
# this attribute in the parent goal does not appear in the negated subgoal att list.
# use a wildcard.
if correspondingSubAttIndexList == []:
parAttType = parentGoalAttList[parAttIndex][2]
parentSubgoalAttMap[parAttIndex] = [parAttIndex, "_", parAttType]
# this attribute in the parent goal appears in the negated subgoal att list.
# replace with the corresponding uniform attribute variable for the subgoal rewrite.
else:
for subAttIndex in correspondingSubAttIndexList:
parentRuleSubAttVar = subAttDataInParent[subAttIndex][1]
uniformVar = subToUniformMap[parentRuleSubAttVar]
parentSubgoalAttMap[
parAttIndex] = uniformVar # should be identical across subgoal indexes
# -------------------- #
# build parent subgoal #
# -------------------- #
# save subgoal contents in a dictionary
parentSubgoal = {}
parentSubgoal["sid"] = tools.getID()
parentSubgoal["subgoalName"] = parentSubgoalName
parentSubgoal["subgoalTimeArg"] = "" # default
parentSubgoal["subgoalAttDict"] = parentSubgoalAttMap
parentSubgoal["argName"] = ""
# ============================================================== #
# ============================================================== #
# ----------------------------------- #
# build original dom subgoal #
# ----------------------------------- #
negatedPositiveSubgoalName = "dom_" + posName + "_evalres"
# ----------------------------------------------- #
# map parent subgoal att vars to uniform att vars #
# ----------------------------------------------- #
# correctness depends upon the schemas of the positive and not_
# definitions of the targeted negated subgoal to be identical.
# this can only be guaranteed after the uniformity rewrite.
negatedPositiveSubgoalAttMap = {}
for att in subAttDataInParent:
attID = att[0]
attName = att[1]
if attName == "_":
attType = uniformAttList[attID][2]
negatedPositiveSubgoalAttMap[attID] = [attID, "_", attType]
else:
attName = uniformAttList[attID][1]
attType = uniformAttList[attID][2]
negatedPositiveSubgoalAttMap[attID] = [attID, attName, attType]
# ------------------------------ #
# build negated positive subgoal #
# ------------------------------ #
negatedPositiveSubgoal = {}
negatedPositiveSubgoal["sid"] = tools.getID()
negatedPositiveSubgoal["subgoalName"] = negatedPositiveSubgoalName
negatedPositiveSubgoal["subgoalTimeArg"] = "" # default
negatedPositiveSubgoal["subgoalAttDict"] = negatedPositiveSubgoalAttMap
negatedPositiveSubgoal["argName"] = "notin" # negated positive
# ============================================================== #
# ============================================================== #
# ----------------------------------- #
# build original dom subgoal #
# ----------------------------------- #
positivePositiveSubgoalName = "dom_" + posName + "_evalres"
# ----------------------------------------------- #
# map parent subgoal att vars to uniform att vars #
# ----------------------------------------------- #
# correctness depends upon the schemas of the positive and not_
# definitions of the targeted negated subgoal to be identical.
# this can only be guaranteed after the uniformity rewrite.
#
# the attributes in the positive domain subgoal for the targetted negated relation
# are exactly the in the negated domain subgoal relation in this rule
# minus the attributes incoporated into the parent domain subgoal of this rule.
parentEvalRes_atts_only = [
parentSubgoalAttMap[x][1] for x in parentSubgoalAttMap
]
positivePositiveSubgoalAttMap = {}
for att in univAttData:
attID = att[0]
attName = att[1]
attType = att[2]
if attName in parentEvalRes_atts_only:
attName = "_"
positivePositiveSubgoalAttMap[attID] = [attID, attName, attType]
# ------------------------------ #
# build negated positive subgoal #
# ------------------------------ #
positivePositiveSubgoal = {}
positivePositiveSubgoal["sid"] = tools.getID()
positivePositiveSubgoal["subgoalName"] = positivePositiveSubgoalName
positivePositiveSubgoal["subgoalTimeArg"] = "" # default
positivePositiveSubgoal["subgoalAttDict"] = positivePositiveSubgoalAttMap
positivePositiveSubgoal["argName"] = "" # positive positive
# ============================================================== #
# ============================================================== #
universalBoundSubgoals = []
if not allWildcardAtts(parentSubgoal):
universalBoundSubgoals.append(parentSubgoal)
if not allWildcardAtts(negatedPositiveSubgoal):
universalBoundSubgoals.append(negatedPositiveSubgoal)
if not allWildcardAtts(positivePositiveSubgoal):
universalBoundSubgoals.append(positivePositiveSubgoal)
print "DONE BUILDING UNIVERSAL BOUND SUBGOALS"
return universalBoundSubgoals
def mergeMaps(self, allIDPairs, ogattMaps):
pgattMaps = []
# get list of all prids
pridList = [aPair[1] for aPair in allIDPairs]
for prid in pridList:
# get the goal att list for this provenance rule
self.cursor.execute(
"SELECT attID,attName FROM GoalAtt WHERE rid=='" + prid + "'")
pgattList = self.cursor.fetchall()
pgattList = tools.toAscii_multiList(pgattList)
pgattList = [arr[1] for arr in pgattList]
# get corresponding original rule id
orid = self.getORID(prid, allIDPairs)
# ///////////////////////////////////////////////////////// #
# get map of goal atts for the original rule
# to seed record values.
# ------------------------------------------------------------- #
# Transform into dictionary for convenience
thisogattMap = self.getOGattMap(orid, ogattMaps)
ogattDict = {}
for arr in thisogattMap:
att = arr[0]
val = arr[1]
# sanity check
if att in ogattDict.keys() and not val == ogattDict[att]:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : multiple data values exist for the same attribute.\nattribute = "
+ att + "\nval = " + val + " and ogattDict[ att ] = " +
ogattDict[att])
else: # add to dictionary
ogattDict[att] = val
# ------------------------------------------------------------- #
# map provenance goal atts to values from the seed record based on
# the attribute mappings in the original rule.
# unspecified atts are mapped to None.
# WILDCARDs are mapped to None.
pattMapping = []
for patt in pgattList:
#if patt == "__WILDCARD__" :
if patt == "_":
pattMapping.append([patt, None])
elif patt in ogattDict.keys():
pattMapping.append([patt, ogattDict[patt]])
else:
pattMapping.append([patt, None])
pgattMaps.append([prid, pattMapping])
# ///////////////////////////////////////////////////////// #
if self.name == "bcast":
print "allIDPairs = " + str(allIDPairs)
print "ogattMaps = " + str(ogattMaps)
print "pgattMaps = " + str(pgattMaps)
#tools.bp( __name__, inspect.stack()[0][3], "f*****g with mergeMaps" )
return pgattMaps
def getAllIDPairs(self):
# ---------------------------------------------------------- #
# ORIG RULE DATA #
# ---------------------------------------------------------- #
# get all original rule ids associated with the name
self.cursor.execute("SELECT rid FROM Rule WHERE goalName='" +
self.name + "'")
origIDs = self.cursor.fetchall()
origIDs = tools.toAscii_multiList(origIDs)
# get the complete attList and subgoalList associated with each original rule
# store as arrays in an array [ rid, [attList], [subgoalList] ]
origInfo = []
for orid in origIDs:
orid = orid[0] # origIDs is a list of singular lists
# get attList
self.cursor.execute(
"SELECT attID,attName FROM SubgoalAtt WHERE rid='" + orid +
"'")
attList = self.cursor.fetchall()
attList = tools.toAscii_multiList(attList)
# get subgoalList
self.cursor.execute(
"SELECT subgoalName FROM Subgoals WHERE rid='" + orid + "'")
subgoalList = self.cursor.fetchall()
subgoalList = tools.toAscii_multiList(subgoalList)
origInfo.append([orid, attList, subgoalList])
# ---------------------------------------------------------- #
# PROV RULE DATA #
# ---------------------------------------------------------- #
# get all provenance rule ids associated with the name
# first, get all rule id, rule name pairs
self.cursor.execute("SELECT rid,goalName FROM Rule")
idNamePairs = self.cursor.fetchall()
idNamePairs = tools.toAscii_multiList(idNamePairs)
# next, collect the rids of goalnames starting with self.name+"_prov"
provIDs = []
for idName in idNamePairs:
currID = idName[0]
currName = idName[1]
if currName.startswith(self.name + "_prov"):
provIDs.append(currID)
# get the complete attList and subgoalList associated with each original rule
# store as arrays in an array [ rid, [attList], [subgoalList] ]
provInfo = []
for prid in provIDs:
# get attList
self.cursor.execute(
"SELECT attID,attName FROM SubgoalAtt WHERE rid='" + prid +
"'")
attList = self.cursor.fetchall()
attList = tools.toAscii_multiList(attList)
# get subgoalList
self.cursor.execute(
"SELECT subgoalName FROM Subgoals WHERE rid='" + prid + "'")
subgoalList = self.cursor.fetchall()
subgoalList = tools.toAscii_multiList(subgoalList)
provInfo.append([prid, attList, subgoalList])
# ---------------------------------------------------------- #
# MATCH #
# ---------------------------------------------------------- #
# match original rids with provenance rids by matching
# attLists and subgoals.
idPairs = []
for origIDInfo in origInfo:
orid = origIDInfo[0]
oAttList = origIDInfo[1]
oSubList = origIDInfo[2]
for provIDInfo in provInfo:
prid = provIDInfo[0]
pAttList = provIDInfo[1]
pSubList = provIDInfo[2]
if self.checkListEquality(oAttList,
pAttList) and self.checkListEquality(
oSubList, pSubList):
idPairs.append([orid, prid]) # save pair
return idPairs
def getSubgoalInfo(self, fullProvMap):
# ------------------------------------------------------------- #
# Transform the provAttMap into a dictionary for convenience.
fullProvDict = {}
for arr in fullProvMap:
att = arr[0]
val = arr[1]
# sanity check
if att in fullProvDict.keys() and not val == fullProvDict[att]:
tools.bp(
__name__,
inspect.stack()[0][3],
"FATAL ERROR : multiple data values exist for the same attribute.\nattribute = "
+ att + "\nval = " + val + " and ogattDict[ att ] = " +
fullProvDict[att])
else: # add to dictionary
fullProvDict[att] = val
# ------------------------------------------------------------- #
subgoalInfo = []
# get the list of subgoals
self.cursor.execute(
"SELECT sid,subgoalName FROM Subgoals WHERE rid=='" + self.prid +
"'")
subIDNameList = self.cursor.fetchall()
subIDNameList = tools.toAscii_multiList(subIDNameList)
# for each sid, grab the subgoal attribute list and the isNeg
for idNamePair in subIDNameList:
sid = idNamePair[0]
subname = idNamePair[1]
# get the attribute list for this subgoal
self.cursor.execute(
"SELECT attID,attName FROM SubgoalAtt WHERE rid=='" +
self.prid + "' AND sid=='" + sid + "'")
attList = self.cursor.fetchall()
attList = tools.toAscii_multiList(attList)
attList = [idNamePair[1] for idNamePair in attList]
# get the isNeg information
self.cursor.execute(
"SELECT argName FROM SubgoalAddArgs WHERE rid=='" + self.prid +
"' AND sid=='" + sid + "'")
isNeg = self.cursor.fetchone()
if isNeg:
isNeg = tools.toAscii_str(isNeg)
else:
isNeg = ""
# ///////////////////////////////////////////////////////// #
# Map each attribute to a value based on the mappings from
# the full provAttMap.
thisSubAttMap = []
for att in attList:
#if att == "__WILDCARD__" :
if att == "_":
thisSubAttMap.append([att, None])
elif att in fullProvDict.keys():
thisSubAttMap.append([att, fullProvDict[att]])
else:
thisSubAttMap.append([att, None])
subgoalInfo.append([subname, isNeg, thisSubAttMap])
# ///////////////////////////////////////////////////////// #
return subgoalInfo
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 get_pilot_program( domcomp_bindings_tup, \
target_ruleSet, \
target_domcomp, \
factMeta, \
ruleMeta ) :
logging.debug( " GET PILOT PROGRAM : domcomp_bindings_tup = " + \
str( domcomp_bindings_tup ) )
# collect the unidom facts associated with this test
test_unidom = []
# 0. build initial program.
# work with a new ruleData element called "sip_bindings",
# which is a list of binary lists matching attributes to
# sip binding values.
# [ { 'ruleData' : { <ruleData> },
# 'sip_bindings' : [ <data tuple> ],
# 'sub_colors' : [ <True | False> ] }, ... ]
all_pilot_rules = []
# [ { 'factData' : { <factData> }, ... ]
all_pilot_facts = []
for fact in factMeta:
new_fact = {}
new_fact["factData"] = fact.factData
all_pilot_facts.append(new_fact)
logging.debug(" GET PILOT PROGRAM : orig facts :")
for tup in all_pilot_facts:
logging.debug(" " + str(tup))
for rule in target_ruleSet:
a_pilot_rule = {}
if not rule.relationName.startswith( "exidom_" ) and \
not rule.relationName.startswith( "orig_" ) :
a_pilot_rule["ruleData"] = copy.deepcopy(rule.ruleData)
a_pilot_rule["sip_bindings"] = domcomp_bindings_tup
a_pilot_rule[ "sub_colors" ] = [ False for i in \
a_pilot_rule[ "ruleData" ][ "subgoalListOfDicts" ] ]
assert( len( a_pilot_rule[ "ruleData" ][ "subgoalListOfDicts" ] ) == \
len( a_pilot_rule[ "sub_colors" ] ) )
all_pilot_rules.append(a_pilot_rule)
# spawn any new edbs to support the bindings.
new_bound_facts = get_new_bound_facts(a_pilot_rule, factMeta,
ruleMeta)
logging.debug(" GET PILOT PROGRAM : initial new pilot facts :")
for tup in new_bound_facts:
logging.debug(" " + str(tup))
all_pilot_facts.extend(new_bound_facts)
test_unidom.extend(new_bound_facts)
# 1. push down domcomp bindings until no more bound idbs exist.
COUNTER = 0
while bound_idbs_still_exist( target_ruleSet[0].relationName, \
all_pilot_rules, \
ruleMeta ) :
# 1a. get info on a bound idb
target_bound_idb, pilot_rule, sub_index = get_bound_idb( target_ruleSet[0].relationName, \
all_pilot_rules, \
ruleMeta )
# 1b. get the rule corresponding to the bound idb
new_pilot_rules = get_defn( target_bound_idb[ "subgoalName" ], \
pilot_rule, \
sub_index, \
ruleMeta )
pilot_rule["sub_colors"][sub_index] = True
for npr in new_pilot_rules:
#all_pilot_rules.append( npr )
if not pilot_rule_already_exists(npr, all_pilot_rules):
all_pilot_rules.append(npr)
logging.debug( " GET NEW BOUND FACTS : adding '" + \
c4_translator.get_c4_line( npr[ "ruleData" ], "rule" ) + "'" )
else:
logging.debug( " GET NEW BOUND FACTS : not adding '" + \
c4_translator.get_c4_line( npr[ "ruleData" ], "rule" ) + "'" )
# 1c. push down tuple bindings to target rule edbs and save the new facts
for npr in new_pilot_rules:
# spawn any new edbs to support the bindings.
new_bound_facts = get_new_bound_facts(npr, factMeta, ruleMeta)
logging.debug(" GET NEW BOUND FACTS : while loop additions :")
for tup in new_bound_facts:
logging.debug(" " + str(tup))
all_pilot_facts.extend(new_bound_facts)
test_unidom.extend(new_bound_facts)
if COUNTER == 100:
for l in all_pilot_rules:
print c4_translator.get_c4_line(l["ruleData"], "rule")
print l["sip_bindings"]
print l["sub_colors"]
print bound_idbs_still_exist( target_ruleSet[0].relationName, \
all_pilot_rules, \
ruleMeta )
sys.exit("shit")
COUNTER += 1
# 2. convert program into a list of strings
rule_fact_lines = []
for r in all_pilot_rules:
line = c4_translator.get_c4_line(r["ruleData"], "rule")
if not line in rule_fact_lines:
rule_fact_lines.append(line)
#for l in program_lines :
# print l
#sys.exit( "shit" )
# 3. add the program facts
for f in all_pilot_facts:
rule_fact_lines.append(c4_translator.get_c4_line(
f["factData"], "fact"))
# 4. derive and all all the defines
table_list = []
defines = []
for pr in all_pilot_rules:
this_rule = None
for rule in ruleMeta:
if rule.relationName == pr["ruleData"]["relationName"]:
this_rule = rule
break
type_list = [t[1] for t in this_rule.goal_att_type_list]
rule_define = "define(" + \
rule.relationName + "," + \
"{" + ",".join( type_list ) + "});"
if not rule_define in defines:
defines.append(rule_define)
table_list.append(rule.relationName)
for fact in factMeta:
type_list = [t[1] for t in fact.dataListWithTypes]
fact_define = "define(" + \
fact.factData[ "relationName" ] + "," + \
"{" + ",".join( type_list ) + "});"
if not fact_define in defines:
defines.append(fact_define)
table_list.append(fact.factData["relationName"])
# deal with clocks.
if need_clocks(ruleMeta):
ruleMeta[0].cursor.execute(
"SELECT src,dest,sndTime,delivTime FROM Clock")
clock_facts = ruleMeta[0].cursor.fetchall()
clock_facts = tools.toAscii_multiList(clock_facts)
for cf in clock_facts:
rule_fact_lines.append( 'clock("' + cf[0] + \
'","' + cf[1] + \
'",' + str( cf[2] ) + \
',' + str( cf[3] ) + ');' )
defines.append("define(clock,{string,string,int,int});")
program_lines = defines + rule_fact_lines
#for l in program_lines :
# print l
#print table_list
#sys.exit( "f**k" )
return program_lines, table_list
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 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
