def RunQuery(
subQueryJoin, bindings, factGraph, vars=None, debug=False, symmAtomicInclusion=False, specialBNodeHandling=None
):
initialNs = hasattr(factGraph, "nsMap") and factGraph.nsMap or dict([(k, v) for k, v in factGraph.namespaces()])
if not subQueryJoin:
return False
if not vars:
vars = []
if bool(bindings):
# Apply a priori substitutions
openVars, conjGroundLiterals, bindings = normalizeBindingsAndQuery(set(vars), bindings, subQueryJoin)
vars = list(openVars)
else:
conjGroundLiterals = subQueryJoin
isGround = not vars
subquery = RDFTuplesToSPARQL(
conjGroundLiterals, factGraph, isGround, [v for v in vars], symmAtomicInclusion, specialBNodeHandling
)
rt = factGraph.query(subquery, initNs=initialNs) # ,
# DEBUG = debug)
projectedBindings = vars and project(bindings, vars) or bindings
if isGround:
if debug:
_debug(
"%s%s-> %s"
% (
subquery,
projectedBindings and " %s apriori binding(s)" % len(projectedBindings) or "",
rt.askAnswer[0],
)
)
return subquery, rt.askAnswer[0]
else:
rt = (
len(vars) > 1
and (
dict(
[
(vars[idx], specialBNodeHandling[-1](i) if specialBNodeHandling and isinstance(i, BNode) else i)
for idx, i in enumerate(v)
]
)
for v in rt
)
or (
dict([(vars[0], specialBNodeHandling[-1](v) if specialBNodeHandling and isinstance(v, BNode) else v)])
for v in rt
)
)
if debug:
_debug(
"%s%s-> %s"
% (
subquery,
projectedBindings and " %s apriori binding(s)" % len(projectedBindings) or "",
rt and "[]",
) # .. %s answers .. ]'%len(rt) or '[]')
)
return subquery, rt
def ground(self, mapping):
appliedVars = set()
for item in self.formulae:
if isinstance(item, Or):
for _item in item.formulae:
appliedVars.update(item.ground(mapping))
else:
appliedVars.update(item.ground(mapping))
self.bindings = project(self.bindings, appliedVars, True)
self.returnVars = self.getOpenVars()
return appliedVars
def ground(self,mapping):
appliedVars = set()
for item in self.formulae:
if isinstance(item,Or):
for _item in item.formulae:
appliedVars.update(item.ground(mapping))
else:
appliedVars.update(item.ground(mapping))
self.bindings = project(self.bindings,appliedVars,True)
self.returnVars = self.getOpenVars()
return appliedVars
def RunQuery(subQueryJoin,
bindings,
factGraph,
vars=None,
debug = False,
symmAtomicInclusion = False):
initialNs = hasattr(factGraph,'nsMap') and factGraph.nsMap or \
dict([(k,v) for k,v in factGraph.namespaces()])
if not subQueryJoin:
return False
if not vars:
vars=[]
if bool(bindings):
#Apply a priori substitutions
openVars,conjGroundLiterals,bindings = \
normalizeBindingsAndQuery(set(vars),
bindings,
subQueryJoin)
vars=list(openVars)
else:
conjGroundLiterals = subQueryJoin
isGround = not vars
subquery = RDFTuplesToSPARQL(conjGroundLiterals,
factGraph,
isGround,
[v for v in vars],
symmAtomicInclusion)
rt = factGraph.query(subquery,
initNs = initialNs)#,
#DEBUG = debug)
projectedBindings = vars and project(bindings,vars) or bindings
if isGround:
if debug:
print >>sys.stderr, "%s%s-> %s"%(
subquery,
projectedBindings and
" %s apriori binding(s)"%len(projectedBindings) or '',
rt.askAnswer[0])
return subquery,rt.askAnswer[0]
else:
rt = len(vars)>1 and ( dict([(vars[idx],i)
for idx,i in enumerate(v)])
for v in rt ) \
or ( dict([(vars[0],v)]) for v in rt )
if debug:
print >>sys.stderr, "%s%s-> %s"%(
subquery,
projectedBindings and
" %s apriori binding(s)"%len(projectedBindings) or '',
rt and '[]')# .. %s answers .. ]'%len(rt) or '[]')
return subquery,rt
def RunQuery(subQueryJoin,
bindings,
factGraph,
vars=None,
debug=False,
symmAtomicInclusion=False):
initialNs = hasattr(factGraph, 'nsMap') and factGraph.nsMap or \
dict([(k, v) for k, v in factGraph.namespaces()])
if not subQueryJoin:
return False
if not vars:
vars = []
if bool(bindings):
# Apply a priori substitutions
openVars, conjGroundLiterals, bindings = \
normalizeBindingsAndQuery(set(vars),
bindings,
subQueryJoin)
vars = list(openVars)
else:
conjGroundLiterals = subQueryJoin
isGround = not vars
subquery = RDFTuplesToSPARQL(conjGroundLiterals,
factGraph,
isGround,
[v for v in vars],
symmAtomicInclusion)
rt = factGraph.query(subquery,
initNs=initialNs) # DEBUG=debug)
projectedBindings = vars and project(bindings, vars) or bindings
if isGround:
if debug:
print("%s%s-> %s" % (
subquery,
projectedBindings and
" %s apriori binding(s)" % len(projectedBindings) or '',
rt.askAnswer[0]))
return subquery, rt.askAnswer[0]
else:
rt = len(vars) > 1 and (dict([(vars[idx], i)
for idx, i in enumerate(v)])
for v in rt) \
or (dict([(vars[0], v)]) for v in rt)
if debug:
print("%s%s-> %s" % (
subquery,
projectedBindings and
" %s apriori binding(s)" % len(projectedBindings) or '',
rt and '[]')) # .. %s answers .. ]'%len(rt) or '[]')
return subquery, rt
def normalizeBindingsAndQuery(vars, bindings, conjunct):
"""
Takes a query in the form of a list of variables to bind to
an a priori set of bindings and a conjunct of literals and applies the
bindings returning:
- The remaining variables that were not substituted
- The (possibly grounded) conjunct of literals
- The bindings minus mappings involving substituted variables
"""
_vars = set(vars)
bindingDomain = set(bindings.keys())
appliedBindings = False
if bindings:
# Apply a priori substitutions
for lit in conjunct:
substitutedVars = bindingDomain.intersection(lit.toRDFTuple())
lit.ground(bindings)
if substitutedVars:
appliedBindings = True
_vars.difference_update(substitutedVars)
return list(_vars), conjunct, project(bindings, _vars, inverse=True) if appliedBindings else bindings
def normalizeBindingsAndQuery(vars, bindings, conjunct):
"""
Takes a query in the form of a list of variables to bind to
an a priori set of bindings and a conjunct of literals and applies the bindings
returning:
- The remaining variables that were not substituted
- The (possibly grounded) conjunct of literals
- The bindings minus mappings involving substituted variables
"""
_vars = set(vars)
bindingDomain = set(bindings.keys())
appliedBindings = False
if bindings:
#Apply a priori substitutions
for lit in conjunct:
substitutedVars = bindingDomain.intersection(lit.toRDFTuple())
lit.ground(bindings)
if substitutedVars:
appliedBindings = True
_vars.difference_update(substitutedVars)
return list(_vars), conjunct, \
project(bindings, _vars, inverse=True) if appliedBindings else bindings
def accumulateBindings(self, bindings):
"""
"""
self.bindings.update(
project(bindings, self.getOpenVars(), inverse=True))
def RunQuery(subQueryJoin,
bindings,
factGraph,
vars=None,
debug=False,
symmAtomicInclusion=False,
specialBNodeHandling=None,
toldBNode=False):
initialNs = hasattr(factGraph,'nsMap') and factGraph.nsMap or \
dict([(k,v) for k,v in factGraph.namespaces()])
if not subQueryJoin:
return False
if not vars:
vars = []
if bool(bindings):
#Apply a priori substitutions
openVars,conjGroundLiterals,bindings = \
normalizeBindingsAndQuery(set(vars),
bindings,
subQueryJoin)
vars = list(openVars)
else:
conjGroundLiterals = subQueryJoin
isGround = not vars
subquery = RDFTuplesToSPARQL(conjGroundLiterals, factGraph, isGround,
[v for v in vars], symmAtomicInclusion,
specialBNodeHandling)
if toldBNode:
from rdflib.sparql.bison.Query import Prolog
from rdflib.sparql.parser import parse
parsedQuery = parse(subquery)
if not parsedQuery.prolog:
parsedQuery.prolog = Prolog(None, [])
parsedQuery.prolog.toldBNodes = True
subquery = ''
else:
parsedQuery = None
rt = factGraph.query(subquery, initNs=initialNs, parsedQuery=parsedQuery)
projectedBindings = vars and project(bindings, vars) or bindings
if isGround:
if debug:
print >> sys.stderr, "%s%s-> %s" % (
subquery, projectedBindings and " %s apriori binding(s)" %
len(projectedBindings) or '', rt.askAnswer[0])
return subquery, rt.askAnswer[0]
else:
rt = len(vars)>1 and (
dict([(vars[idx],
specialBNodeHandling[-1](i)
if specialBNodeHandling and isinstance(i,BNode)
else i)
for idx,i in enumerate(v)])
for v in rt ) \
or ( dict([(vars[0],
specialBNodeHandling[-1](v)
if specialBNodeHandling and isinstance(v,BNode) else v)
]) for v in rt )
if debug:
print >> sys.stderr, "%s%s-> %s" % (
subquery, projectedBindings
and " %s apriori binding(s)" % len(projectedBindings) or '', rt
and '[]') # .. %s answers .. ]'%len(rt) or '[]')
return subquery, rt
def accumulateBindings(self, bindings):
"""
"""
self.bindings.update(project(bindings,self.getOpenVars(),inverse=True))
def RunQuery(subQueryJoin,
bindings,
factGraph,
vars=None,
debug = False,
symmAtomicInclusion = False,
specialBNodeHandling = None,
toldBNode = False):
initialNs = hasattr(factGraph,'nsMap') and factGraph.nsMap or \
dict([(k,v) for k,v in factGraph.namespaces()])
if not subQueryJoin:
return False
if not vars:
vars=[]
if bool(bindings):
#Apply a priori substitutions
openVars,conjGroundLiterals,bindings = \
normalizeBindingsAndQuery(set(vars),
bindings,
subQueryJoin)
vars=list(openVars)
else:
conjGroundLiterals = subQueryJoin
isGround = not vars
subquery = RDFTuplesToSPARQL(conjGroundLiterals,
factGraph,
isGround,
[v for v in vars],
symmAtomicInclusion,
specialBNodeHandling)
if toldBNode:
from rdflib.sparql.bison.Query import Prolog
from rdflib.sparql.parser import parse
parsedQuery = parse(subquery)
if not parsedQuery.prolog:
parsedQuery.prolog = Prolog(None, [])
parsedQuery.prolog.toldBNodes = True
subquery = ''
else:
parsedQuery = None
rt = factGraph.query(subquery,
initNs = initialNs,
parsedQuery=parsedQuery)
projectedBindings = vars and project(bindings,vars) or bindings
if isGround:
if debug:
print >>sys.stderr, "%s%s-> %s"%(
subquery,
projectedBindings and
" %s apriori binding(s)"%len(projectedBindings) or '',
rt.askAnswer[0])
return subquery,rt.askAnswer[0]
else:
rt = len(vars)>1 and (
dict([(vars[idx],
specialBNodeHandling[-1](i)
if specialBNodeHandling and isinstance(i,BNode)
else i)
for idx,i in enumerate(v)])
for v in rt ) \
or ( dict([(vars[0],
specialBNodeHandling[-1](v)
if specialBNodeHandling and isinstance(v,BNode) else v)
]) for v in rt )
if debug:
print >>sys.stderr, "%s%s-> %s"%(
subquery,
projectedBindings and
" %s apriori binding(s)"%len(projectedBindings) or '',
rt and '[]')# .. %s answers .. ]'%len(rt) or '[]')
return subquery,rt
