def hybridPredQueryPreparation(self, tp):
lit = BuildUnitermFromTuple(tp)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op + '_derived'))
return lit.toRDFTuple()
else:
return tp
def hybridPredQueryPreparation(self, tp):
lit = BuildUnitermFromTuple(tp, newNss=self.nsBindings)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op + u'_derived'))
return lit.toRDFTuple()
else:
return tp
def SetupMetaInterpreter(tBoxGraph, goal, useThingRule=True):
from pprint import pprint
from FuXi.LP.BackwardFixpointProcedure import BackwardFixpointProcedure
from FuXi.Rete.Magic import SetupDDLAndAdornProgram # , PrettyPrintRule
from FuXi.Horn.PositiveConditions import BuildUnitermFromTuple # , Exists
from FuXi.Rete.TopDown import PrepareSipCollection
from FuXi.DLP import LloydToporTransformation, makeRule
from FuXi.Rete.SidewaysInformationPassing import GetOp
owlThingAppears = False
if useThingRule and OWL.Thing in tBoxGraph.all_nodes():
owlThingAppears = True
completionRules = HornFromN3(StringIO(RULES))
if owlThingAppears:
completionRules.formulae.extend(
HornFromN3(StringIO(CONDITIONAL_THING_RULE)))
reducedCompletionRules = set()
for rule in completionRules:
for clause in LloydToporTransformation(rule.formula):
rule = makeRule(clause, {})
# _debug(rule)
# PrettyPrintRule(rule)
reducedCompletionRules.add(rule)
network = SetupRuleStore(makeNetwork=True)[-1]
SetupDDLAndAdornProgram(
tBoxGraph,
reducedCompletionRules,
[goal],
derivedPreds=derivedPredicates,
ignoreUnboundDPreds=True,
hybridPreds2Replace=hybridPredicates)
lit = BuildUnitermFromTuple(goal)
op = GetOp(lit)
lit.setOperator(URIRef(op + '_derived'))
goal = lit.toRDFTuple()
sipCollection = PrepareSipCollection(reducedCompletionRules)
tBoxGraph.templateMap = {}
bfp = BackwardFixpointProcedure(
tBoxGraph,
network,
derivedPredicates,
goal,
sipCollection,
hybridPredicates=hybridPredicates,
debug=True)
bfp.createTopDownReteNetwork(True)
_debug(pformat(reducedCompletionRules))
rt = bfp.answers(debug=True)
_debug(pformat(rt))
_debug(bfp.metaInterpNetwork)
bfp.metaInterpNetwork.reportConflictSet(True, sys.stderr)
for query in bfp.edbQueries:
_debug("Dispatched query against dataset: %s" % query.asSPARQL())
_debug(pformat(list(bfp.goalSolutions)))
def SetupMetaInterpreter(tBoxGraph, goal, useThingRule=True):
from FuXi.LP.BackwardFixpointProcedure import BackwardFixpointProcedure
from FuXi.Rete.Magic import SetupDDLAndAdornProgram
from FuXi.Horn.PositiveConditions import BuildUnitermFromTuple
from FuXi.Rete.TopDown import PrepareSipCollection
from FuXi.DLP import LloydToporTransformation, makeRule
from FuXi.Rete.SidewaysInformationPassing import GetOp
owlThingAppears = False
if useThingRule and OWL.Thing in tBoxGraph.all_nodes():
owlThingAppears = True
completionRules = HornFromN3(StringIO(RULES))
if owlThingAppears:
completionRules.formulae.extend(
HornFromN3(StringIO(CONDITIONAL_THING_RULE)))
reducedCompletionRules = set()
for rule in completionRules:
for clause in LloydToporTransformation(rule.formula):
rule = makeRule(clause, {})
# log.debug(rule)
# PrettyPrintRule(rule)
reducedCompletionRules.add(rule)
network = SetupRuleStore(makeNetwork=True)[-1]
SetupDDLAndAdornProgram(
tBoxGraph,
reducedCompletionRules,
[goal],
derivedPreds=derivedPredicates,
ignoreUnboundDPreds=True,
hybridPreds2Replace=hybridPredicates)
lit = BuildUnitermFromTuple(goal)
op = GetOp(lit)
lit.setOperator(URIRef(op + u'_derived'))
goal = lit.toRDFTuple()
sipCollection = PrepareSipCollection(reducedCompletionRules)
tBoxGraph.templateMap = {}
bfp = BackwardFixpointProcedure(
tBoxGraph,
network,
derivedPredicates,
goal,
sipCollection,
hybridPredicates=hybridPredicates,
debug=True)
bfp.createTopDownReteNetwork(True)
log.debug(reducedCompletionRules)
rt = bfp.answers(debug=True)
log.debug(rt)
log.debug(bfp.metaInterpNetwork)
bfp.metaInterpNetwork.reportConflictSet(True, sys.stderr)
for query in bfp.edbQueries:
log.debug("Dispatched query against dataset: ", query.asSPARQL())
log.debug(list(bfp.goalSolutions))
def conjunctiveSipStrategy(self, goalsRemaining, factGraph, bindings=None):
"""
Given a conjunctive set of triples, invoke sip-strategy passing
on intermediate solutions to facilitate 'join' behavior
"""
bindings = bindings if bindings else {}
try:
tp = goalsRemaining.next()
assert isinstance(bindings, dict)
dPred = self.derivedPredicateFromTriple(tp)
if dPred is None:
baseEDBQuery = EDBQuery([BuildUnitermFromTuple(tp)],
self.edb,
bindings=bindings)
if self.DEBUG:
print >>sys.stderr,"Evaluating TP against EDB: ",\
baseEDBQuery.asSPARQL()
query, rt = baseEDBQuery.evaluate()
if isinstance(rt, bool) and rt:
yield bindings
elif not isinstance(rt, bool):
rt = list(rt)
remaining_goals = itertools.tee(goalsRemaining, len(rt))
for idx in range(len(rt)):
item = {}
item.update(rt[idx])
item.update(bindings)
if self.DEBUG:
print >> sys.stderr, "Solution from EDB query: ", item
for ansDict in self.conjunctiveSipStrategy(
remaining_goals[idx], factGraph, item):
yield ansDict
else:
queryLit = BuildUnitermFromTuple(tp)
currentOp = GetOp(queryLit)
queryLit.setOperator(currentOp)
query = EDBQuery([queryLit], self.edb, bindings=bindings)
if bindings:
tp = first(query.formulae).toRDFTuple()
if self.DEBUG:
print >> sys.stderr, "Goal/Query: ", query.asSPARQL()
tp = self.hybridPredQueryPreparation(tp)
SetupDDLAndAdornProgram(self.edb,
self.idb, [tp],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds=True,
nsBindings=self.nsBindings)
sipCollection = PrepareSipCollection(self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
print >> sys.stderr, sip
pprint(list(self.edb.adornedProgram), sys.stderr)
elif self.DEBUG:
print >> sys.stderr, "No SIP graph!"
for nextAnswer, ns in self.invokeDecisionProcedure(
tp, factGraph, bindings, self.DEBUG, sipCollection):
if isinstance(nextAnswer, dict):
#Recieved solutions to 'open' query, merge with given bindings
#and continue
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining, factGraph,
mergeMappings1To2(bindings, nextAnswer)):
yield ansDict
elif nextAnswer:
#we (successfully) proved a ground query, pass on bindings
assert isinstance(nextAnswer, bool)
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining, factGraph, bindings):
yield ansDict
except StopIteration:
yield bindings
def sparql_query(self,
queryString,
queryObj,
graph,
dataSetBase,
extensionFunctions,
initBindings={},
initNs={},
DEBUG=False):
"""
The default 'native' SPARQL implementation is based on sparql-p's expansion trees
layered on top of the read-only RDF APIs of the underlying store
"""
from rdflib.sparql.Algebra import TopEvaluate
from rdflib.QueryResult import QueryResult
from rdflib import plugin
from rdflib.sparql.bison.Query import AskQuery
_expr = self.isaBaseQuery(None,queryObj)
if isinstance(queryObj.query,AskQuery) and \
isinstance(_expr,BasicGraphPattern):
#This is a ground, BGP, involving IDB and can be solved directly
#using top-down decision procedure
#First separate out conjunct into EDB and IDB predicates
#(solving the former first)
from FuXi.SPARQL import EDBQuery
groundConjunct = []
derivedConjunct = []
for s,p,o,func in _expr.patterns:
if self.derivedPredicateFromTriple((s,p,o)) is None:
groundConjunct.append(BuildUnitermFromTuple((s,p,o)))
else:
derivedConjunct.append(BuildUnitermFromTuple((s,p,o)))
if groundConjunct:
baseEDBQuery = EDBQuery(groundConjunct,self.edb)
subQuery,ans = baseEDBQuery.evaluate(DEBUG)
assert isinstance(ans,bool),ans
if groundConjunct and not ans:
askResult = False
else:
askResult = True
for derivedLiteral in derivedConjunct:
goal = derivedLiteral.toRDFTuple()
#Solve ground, derived goal directly
SetupDDLAndAdornProgram(
self.edb,
self.idb,
[goal],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds = True,
hybridPreds2Replace=self.hybridPredicates)
if self.hybridPredicates:
lit = BuildUnitermFromTuple(goal)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op+u'_derived'))
goal = lit.toRDFTuple()
sipCollection=PrepareSipCollection(self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
print >>sys.stderr,sip
pprint(list(self.edb.adornedProgram),sys.stderr)
elif self.DEBUG:
print >> sys.stderr, "No SIP graph!"
rt,node = first(self.invokeDecisionProcedure(
goal,
self.edb,
{},
self.DEBUG,
sipCollection))
if not rt:
askResult = False
break
return plugin.get('SPARQLQueryResult',QueryResult)(askResult)
else:
rt = TopEvaluate(queryObj,
graph,
initBindings,
DEBUG=self.DEBUG,
dataSetBase=dataSetBase,
extensionFunctions=extensionFunctions)
return plugin.get('SPARQLQueryResult',QueryResult)(rt)
def conjunctiveSipStrategy(self,goalsRemaining,factGraph,bindings=None):
"""
Given a conjunctive set of triples, invoke sip-strategy passing
on intermediate solutions to facilitate 'join' behavior
"""
bindings = bindings if bindings else {}
try:
tp = goalsRemaining.next()
assert isinstance(bindings,dict)
dPred = self.derivedPredicateFromTriple(tp)
if dPred is None:
baseEDBQuery = EDBQuery([BuildUnitermFromTuple(tp)],
self.edb,
bindings=bindings)
if self.DEBUG:
print >>sys.stderr,"Evaluating TP against EDB: ",\
baseEDBQuery.asSPARQL()
query,rt = baseEDBQuery.evaluate()
# _vars = baseEDBQuery.returnVars
for item in rt:
bindings.update(item)
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining,
factGraph,
bindings):
yield ansDict
else:
queryLit = BuildUnitermFromTuple(tp)
currentOp = GetOp(queryLit)
queryLit.setOperator(currentOp)
query=EDBQuery([queryLit],
self.edb,
bindings=bindings)
if bindings:
tp=first(query.formulae).toRDFTuple()
if self.DEBUG:
print >>sys.stderr,"Goal/Query: ", query.asSPARQL()
SetupDDLAndAdornProgram(
self.edb,
self.idb,
[tp],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds = True,
hybridPreds2Replace=self.hybridPredicates)
if self.hybridPredicates:
lit = BuildUnitermFromTuple(tp)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op+u'_derived'))
tp = lit.toRDFTuple()
sipCollection=PrepareSipCollection(self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
print >>sys.stderr,sip
pprint(list(self.edb.adornedProgram),sys.stderr)
elif self.DEBUG:
print >> sys.stderr, "No SIP graph!"
for nextAnswer,ns in self.invokeDecisionProcedure(
tp,
factGraph,
bindings,
self.DEBUG,
sipCollection):
nonGroundGoal = isinstance(nextAnswer,dict)
if nonGroundGoal or nextAnswer:
#Either we recieved bindings from top-down evaluation
#or we (successfully) proved a ground query
if not nonGroundGoal:
#Attempt to prove a ground query, return the response
rt = nextAnswer
else:
#Recieved solutions to 'open' query, merge with given bindings
#and continue
rt = mergeMappings1To2(bindings,nextAnswer)
#either answers were provided (the goal wasn't grounded) or
#the goal was ground and successfully proved
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining,
factGraph,
rt):
yield ansDict
except StopIteration:
yield bindings
def conjunctiveSipStrategy(self, goalsRemaining, factGraph, bindings=None):
"""
Given a conjunctive set of triples, invoke sip-strategy passing
on intermediate solutions to facilitate 'join' behavior
"""
bindings = bindings if bindings else {}
try:
tp = next(goalsRemaining)
assert isinstance(bindings, dict)
dPred = self.derivedPredicateFromTriple(tp)
if dPred is None:
baseEDBQuery = EDBQuery([BuildUnitermFromTuple(tp)],
self.edb,
bindings=bindings)
if self.DEBUG:
_debug(
"Evaluating TP against EDB: %s" %
baseEDBQuery.asSPARQL())
query, rt = baseEDBQuery.evaluate()
if isinstance(rt, bool) and rt:
yield bindings
elif not isinstance(rt, bool):
rt = list(rt)
remaining_goals = itertools.tee(goalsRemaining, len(rt))
for idx in range(len(rt)):
item = {}
item.update(rt[idx])
item.update(bindings)
if self.DEBUG:
_debug("Solution from EDB query: %s" % item)
for ansDict in self.conjunctiveSipStrategy(
remaining_goals[idx],
factGraph,
item):
yield ansDict
else:
queryLit = BuildUnitermFromTuple(tp)
currentOp = GetOp(queryLit)
queryLit.setOperator(currentOp)
query = EDBQuery([queryLit],
self.edb,
bindings=bindings)
if bindings:
tp = first(query.formulae).toRDFTuple()
if self.DEBUG:
_debug("Goal/Query: %s" % query.asSPARQL())
tp = self.hybridPredQueryPreparation(tp)
SetupDDLAndAdornProgram(
self.edb,
self.idb,
[tp],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds=True)
sipCollection = PrepareSipCollection(self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
_debug(sip)
_debug(pformat(list(self.edb.adornedProgram)))
elif self.DEBUG:
_debug("No SIP graph.")
for nextAnswer, ns in self.invokeDecisionProcedure(
tp,
factGraph,
bindings,
self.DEBUG,
sipCollection):
if isinstance(nextAnswer, dict):
# Received solutions to 'open' query, merge with given
# bindings and continue
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining,
factGraph,
mergeMappings1To2(bindings,
nextAnswer)):
yield ansDict
elif nextAnswer:
# we (successfully) proved a ground query, pass on
# bindings
assert isinstance(nextAnswer, bool)
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining,
factGraph,
bindings):
yield ansDict
except StopIteration:
yield bindings
def sparql_query(self,
queryString,
queryObj,
graph,
dataSetBase,
extensionFunctions,
initBindings={},
initNs={},
DEBUG=False):
"""
The default 'native' SPARQL implementation is based on sparql-p's expansion trees
layered on top of the read-only RDF APIs of the underlying store
"""
from rdflib.sparql.Algebra import TopEvaluate
from rdflib.QueryResult import QueryResult
from rdflib import plugin
from rdflib.sparql.bison.Query import AskQuery
_expr = self.isaBaseQuery(None, queryObj)
if isinstance(queryObj.query, AskQuery) and \
_expr.name == 'BGP':
# isinstance(_expr, BasicGraphPattern):
#This is a ground, BGP, involving IDB and can be solved directly
#using top-down decision procedure
#First separate out conjunct into EDB and IDB predicates
#(solving the former first)
from FuXi.SPARQL import EDBQuery
groundConjunct = []
derivedConjunct = []
for s, p, o, func in _expr.patterns:
if self.derivedPredicateFromTriple((s, p, o)) is None:
groundConjunct.append(BuildUnitermFromTuple((s, p, o)))
else:
derivedConjunct.append(BuildUnitermFromTuple((s, p, o)))
if groundConjunct:
baseEDBQuery = EDBQuery(groundConjunct, self.edb)
subQuery, ans = baseEDBQuery.evaluate(DEBUG)
assert isinstance(ans, bool), ans
if groundConjunct and not ans:
askResult = False
else:
askResult = True
for derivedLiteral in derivedConjunct:
goal = derivedLiteral.toRDFTuple()
#Solve ground, derived goal directly
SetupDDLAndAdornProgram(
self.edb,
self.idb, [goal],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds=True,
hybridPreds2Replace=self.hybridPredicates)
if self.hybridPredicates:
lit = BuildUnitermFromTuple(goal)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op + u'_derived'))
goal = lit.toRDFTuple()
sipCollection = PrepareSipCollection(
self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
print(sip)
pprint(list(self.edb.adornedProgram))
elif self.DEBUG:
print("No SIP graph.")
rt, node = first(
self.invokeDecisionProcedure(goal, self.edb, {},
self.DEBUG,
sipCollection))
if not rt:
askResult = False
break
return plugin.get('SPARQLQueryResult', QueryResult)(askResult)
else:
rt = TopEvaluate(queryObj,
graph,
initBindings,
DEBUG=self.DEBUG,
dataSetBase=dataSetBase,
extensionFunctions=extensionFunctions)
return plugin.get('SPARQLQueryResult', QueryResult)(rt)
def conjunctiveSipStrategy(self, goalsRemaining, factGraph, bindings=None):
"""
Given a conjunctive set of triples, invoke sip-strategy passing
on intermediate solutions to facilitate 'join' behavior
"""
bindings = bindings if bindings else {}
try:
tp = next(goalsRemaining)
assert isinstance(bindings, dict)
dPred = self.derivedPredicateFromTriple(tp)
if dPred is None:
baseEDBQuery = EDBQuery([BuildUnitermFromTuple(tp)],
self.edb,
bindings=bindings)
if self.DEBUG:
print("Evaluating TP against EDB:%s" %
baseEDBQuery.asSPARQL())
query, rt = baseEDBQuery.evaluate()
# _vars = baseEDBQuery.returnVars
for item in rt:
bindings.update(item)
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining, factGraph, bindings):
yield ansDict
else:
queryLit = BuildUnitermFromTuple(tp)
currentOp = GetOp(queryLit)
queryLit.setOperator(currentOp)
query = EDBQuery([queryLit], self.edb, bindings=bindings)
if bindings:
tp = first(query.formulae).toRDFTuple()
if self.DEBUG:
print("Goal/Query: ", query.asSPARQL())
SetupDDLAndAdornProgram(
self.edb,
self.idb, [tp],
derivedPreds=self.derivedPredicates,
ignoreUnboundDPreds=True,
hybridPreds2Replace=self.hybridPredicates)
if self.hybridPredicates:
lit = BuildUnitermFromTuple(tp)
op = GetOp(lit)
if op in self.hybridPredicates:
lit.setOperator(URIRef(op + u'_derived'))
tp = lit.toRDFTuple()
sipCollection = PrepareSipCollection(self.edb.adornedProgram)
if self.DEBUG and sipCollection:
for sip in SIPRepresentation(sipCollection):
print(sip)
pprint(list(self.edb.adornedProgram), sys.stderr)
elif self.DEBUG:
print("No SIP graph.")
for nextAnswer, ns in self.invokeDecisionProcedure(
tp, factGraph, bindings, self.DEBUG, sipCollection):
nonGroundGoal = isinstance(nextAnswer, dict)
if nonGroundGoal or nextAnswer:
#Either we recieved bindings from top-down evaluation
#or we (successfully) proved a ground query
if not nonGroundGoal:
#Attempt to prove a ground query, return the response
rt = nextAnswer
else:
#Recieved solutions to 'open' query, merge with given bindings
#and continue
rt = mergeMappings1To2(bindings, nextAnswer)
#either answers were provided (the goal wasn't grounded) or
#the goal was ground and successfully proved
for ansDict in self.conjunctiveSipStrategy(
goalsRemaining, factGraph, rt):
yield ansDict
except StopIteration:
yield bindings
