def query(
self, strOrQuery, initBindings={},
initNs={}, base=None, DEBUG=False):
"""
Evaluate a query with the given initial bindings, and initial
namespaces. The given base is used to resolve relative URIs in
the query and will be overridden by any BASE given in the query.
"""
if not isinstance(strOrQuery, Query):
parsetree = parseQuery(strOrQuery)
query = translateQuery(parsetree, base, initNs)
else:
query = strOrQuery
return evalQuery(self.graph, query, initBindings, base)
def prepareQuery(queryString, initNs={}, base=None):
"""
Parse and translate a SPARQL Query
"""
return translateQuery(parseQuery(queryString), base, initNs)
def query_test(t):
uri, name, comment, data, graphdata, query, resfile, syntax = t
# the query-eval tests refer to graphs to load by resolvable filenames
rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True
if uri in skiptests:
raise SkipTest()
def skip(reason='(none)'):
print "Skipping %s from now on." % uri
f = open("skiptests.list", "a")
f.write("%s\t%s\n" % (uri, reason))
f.close()
try:
g = ConjunctiveGraph()
if data:
g.default_context.load(data, format=_fmt(data))
if graphdata:
for x in graphdata:
g.load(x, format=_fmt(x))
if not resfile:
# no result - syntax test
if syntax:
translateQuery(parseQuery(
open(query[7:]).read()), base=urljoin(query, '.'))
else:
# negative syntax test
try:
translateQuery(parseQuery(
open(query[7:]).read()), base=urljoin(query, '.'))
assert False, 'Query should not have parsed!'
except:
pass # it's fine - the query should not parse
return
# eval test - carry out query
res2 = g.query(open(query[7:]).read(), base=urljoin(query, '.'))
if resfile.endswith('ttl'):
resg = Graph()
resg.load(resfile, format='turtle', publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('rdf'):
resg = Graph()
resg.load(resfile, publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('srj'):
res = Result.parse(open(resfile[7:]), format='json')
elif resfile.endswith('tsv'):
res = Result.parse(open(resfile[7:]), format='tsv')
elif resfile.endswith('csv'):
res = Result.parse(open(resfile[7:]), format='csv')
# CSV is lossy, round-trip our own resultset to
# lose the same info :)
s = StringIO()
res2.serialize(s, format='csv')
s = StringIO(s.getvalue()) # hmm ?
res2 = Result.parse(s, format='csv')
else:
res = Result.parse(open(resfile[7:]), format='xml')
if not DETAILEDASSERT:
eq(res.type, res2.type, 'Types do not match')
if res.type == 'SELECT':
eq(set(res.vars), set(res2.vars), 'Vars do not match')
assert bindingsCompatible(
set(frozenset(x.iteritems())
for x in res.bindings),
set(frozenset(x.iteritems())
for x in res2.bindings)
), 'Bindings do not match'
elif res.type == 'ASK':
eq(res.askAnswer, res2.askAnswer, 'Ask answer does not match')
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(
res.graph, res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
else:
eq(res.type, res2.type,
'Types do not match: %r != %r' % (res.type, res2.type))
if res.type == 'SELECT':
eq(set(res.vars),
set(res2.vars), 'Vars do not match: %r != %r' % (
set(res.vars), set(res2.vars)))
assert bindingsCompatible(
set(frozenset(x.iteritems())
for x in res.bindings),
set(frozenset(x.iteritems())
for x in res2.bindings)
), 'Bindings do not match: %r != %r' % (
pp_binding(res.bindings),
pp_binding(res2.bindings))
elif res.type == 'ASK':
eq(res.askAnswer,
res2.askAnswer, "Ask answer does not match: %r != %r" % (
res.askAnswer, res2.askAnswer))
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(
res.graph, res2.graph), 'graphs are no isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
except Exception, e:
if isinstance(e, AssertionError):
failed_tests.append(uri)
fails[str(e)] += 1
else:
error_tests.append(uri)
errors[str(e)] += 1
if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL:
print "======================================"
print uri
print name
print comment
if not resfile:
if syntax:
print "Positive syntax test"
else:
print "Negative syntax test"
if data:
print "----------------- DATA --------------------"
print ">>>", data
print open(data[7:]).read()
if graphdata:
print "----------------- GRAPHDATA --------------------"
for x in graphdata:
print ">>>", x
print open(x[7:]).read()
print "----------------- Query -------------------"
print ">>>", query
print open(query[7:]).read()
if resfile:
print "----------------- Res -------------------"
print ">>>", resfile
print open(resfile[7:]).read()
try:
pq = parseQuery(open(query[7:]).read())
print "----------------- Parsed ------------------"
pprintAlgebra(translateQuery(pq, base=urljoin(query, '.')))
except:
print "(parser error)"
#import traceback
#traceback.print_exc()
print e.decode('string-escape')
import pdb
pdb.post_mortem()
#pdb.set_trace()
#nose.tools.set_trace()
raise
def query_test(t):
uri, name, comment, data, graphdata, query, resfile, syntax = t
# the query-eval tests refer to graphs to load by resolvable filenames
rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True
if uri in skiptests:
raise SkipTest()
def skip(reason='(none)'):
print "Skipping %s from now on." % uri
f = open("skiptests.list", "a")
f.write("%s\t%s\n" % (uri, reason))
f.close()
try:
g = ConjunctiveGraph()
if data:
g.default_context.load(data, format=_fmt(data))
if graphdata:
for x in graphdata:
g.load(x, format=_fmt(x))
if not resfile:
# no result - syntax test
if syntax:
translateQuery(parseQuery(open(query[7:]).read()),
base=urljoin(query, '.'))
else:
# negative syntax test
try:
translateQuery(parseQuery(open(query[7:]).read()),
base=urljoin(query, '.'))
assert False, 'Query should not have parsed!'
except:
pass # it's fine - the query should not parse
return
# eval test - carry out query
res2 = g.query(open(query[7:]).read(), base=urljoin(query, '.'))
if resfile.endswith('ttl'):
resg = Graph()
resg.load(resfile, format='turtle', publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('rdf'):
resg = Graph()
resg.load(resfile, publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('srj'):
res = Result.parse(open(resfile[7:]), format='json')
elif resfile.endswith('tsv'):
res = Result.parse(open(resfile[7:]), format='tsv')
elif resfile.endswith('csv'):
res = Result.parse(open(resfile[7:]), format='csv')
# CSV is lossy, round-trip our own resultset to
# lose the same info :)
# write bytes, read strings...
s = BytesIO()
res2.serialize(s, format='csv')
print s.getvalue()
s = StringIO(s.getvalue().decode('utf-8')) # hmm ?
res2 = Result.parse(s, format='csv')
else:
res = Result.parse(open(resfile[7:]), format='xml')
if not DETAILEDASSERT:
eq(res.type, res2.type, 'Types do not match')
if res.type == 'SELECT':
eq(set(res.vars), set(res2.vars), 'Vars do not match')
comp = bindingsCompatible(
set(frozenset(x.iteritems()) for x in res.bindings),
set(frozenset(x.iteritems()) for x in res2.bindings))
assert comp, 'Bindings do not match'
elif res.type == 'ASK':
eq(res.askAnswer, res2.askAnswer, 'Ask answer does not match')
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(res.graph,
res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
else:
eq(res.type, res2.type,
'Types do not match: %r != %r' % (res.type, res2.type))
if res.type == 'SELECT':
eq(
set(res.vars), set(res2.vars),
'Vars do not match: %r != %r' %
(set(res.vars), set(res2.vars)))
assert bindingsCompatible(
set(frozenset(x.iteritems()) for x in res.bindings),
set(frozenset(x.iteritems()) for x in res2.bindings)
), 'Bindings do not match: \n%s\n!=\n%s' % (_bindingsTable(
res.bindings), _bindingsTable(res2.bindings))
elif res.type == 'ASK':
eq(
res.askAnswer, res2.askAnswer,
"Ask answer does not match: %r != %r" %
(res.askAnswer, res2.askAnswer))
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(res.graph,
res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
except Exception, e:
if isinstance(e, AssertionError):
failed_tests.append(uri)
fails[str(e)] += 1
else:
error_tests.append(uri)
errors[str(e)] += 1
if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL:
print "======================================"
print uri
print name
print comment
if not resfile:
if syntax:
print "Positive syntax test"
else:
print "Negative syntax test"
if data:
print "----------------- DATA --------------------"
print ">>>", data
print open(data[7:]).read()
if graphdata:
print "----------------- GRAPHDATA --------------------"
for x in graphdata:
print ">>>", x
print open(x[7:]).read()
print "----------------- Query -------------------"
print ">>>", query
print open(query[7:]).read()
if resfile:
print "----------------- Res -------------------"
print ">>>", resfile
print open(resfile[7:]).read()
try:
pq = parseQuery(open(query[7:]).read())
print "----------------- Parsed ------------------"
pprintAlgebra(translateQuery(pq, base=urljoin(query, '.')))
except:
print "(parser error)"
print decodeStringEscape(unicode(e))
import pdb
pdb.post_mortem(sys.exc_info()[2])
# pdb.set_trace()
# nose.tools.set_trace()
raise
def prepareQuery(queryString):
"""
Parse and translate a SPARQL Query
"""
return translateQuery(parseQuery(queryString))
