def testSelectFromAndFromNamed(self):
parsed_query = configure_query_dataset(parseQuery(self.query_both), [], [])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 2)
self.assertEqual(
parsed_query[1]['datasetClause'][0]['default'], URIRef('http://example.org/default/'))
self.assertEqual(
parsed_query[1]['datasetClause'][1]['named'], URIRef('http://example.org/named/'))
parsed_query = configure_query_dataset(parseQuery(self.query_both), ['urn:default'], [])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 1)
self.assertEqual(parsed_query[1]['datasetClause'][0]['default'], URIRef('urn:default'))
parsed_query = configure_query_dataset(parseQuery(self.query_both), [], ['urn:named'])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 1)
self.assertEqual(parsed_query[1]['datasetClause'][0]['named'], URIRef('urn:named'))
parsed_query = configure_query_dataset(parseQuery(self.query_both), ['urn:default'], ['urn:named'])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 2)
self.assertEqual(parsed_query[1]['datasetClause'][0]['default'], URIRef('urn:default'))
self.assertEqual(parsed_query[1]['datasetClause'][1]['named'], URIRef('urn:named'))
def test_functions__functional_forms(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
test = Test(
test_number=1,
tc_desc=
'Test if functional forms are properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
try:
self.rdf_engine.get_data(self.query_from_query_from_algebra,
yn_timestamp_query=False)
except Exception as e:
print(e)
print(
"The query must be executable. Otherwise, the test has failed."
)
return Test(test_number=test.test_number,
tc_desc=test.tc_desc,
expected_result="0",
actual_result="not_executable")
return test
def test_other__service2(self):
tc_desc = 'Test if "service" along with its service string is properly translated ' \
'into the query text. ' \
'The query must also be executable and shall not violate any SPARQL query syntax.'
try:
query_tree = parser.parseQuery(self.query_text)
except Exception as e:
print(e)
return Test(test_number=25,
tc_desc=tc_desc,
expected_result="0",
actual_result=
"Not executable. Error returned from parseQuery().")
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(test_number=25,
tc_desc=tc_desc,
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_property_path__negated_property_set(self):
tc_desc = 'Test if a negated property set gets properly translated into the query text. ' \
'The query must also be executable and shall not violate any SPARQL query syntax.'
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
try:
self.query_from_algebra = translateAlgebra(query_algebra)
except TypeError as e:
print(e)
return Test(
test_number=29,
tc_desc=tc_desc,
expected_result="0",
actual_result=
"Not executable. n3() method of NegatedPath class should be fixed. "
)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(test_number=29,
tc_desc=tc_desc,
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_other__service1(self):
tc_desc = (
"Test if a nested service pattern is properly translated "
"into the query text. "
"The query must also be executable and shall not violate any SPARQL query syntax."
)
try:
query_tree = parser.parseQuery(self.query_text)
except Exception as e:
print(e)
return Test(
test_number=24,
tc_desc=tc_desc,
expected_result="0",
actual_result="Not executable. Error returned from parseQuery",
)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=24,
tc_desc=tc_desc,
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra,
)
return test
def __init__(self, callback, sparql_query):
"""Creates a SPARQL filter for RDF triples."""
if sparql_query.strip()[:3].lower() != 'ask':
raise ZtreamyException('Only ASK queries are allowed '
'in SPARQLFilter')
super(SPARQLFilter, self).__init__(callback)
self.query = parseQuery(sparql_query)
def parse_query(query, dataset, default_graph, server_url):
"""Parse a regular SPARQL query into a query execution plan"""
logical_plan = translateQuery(parseQuery(query)).algebra
cardinalities = list()
iterator = parse_query_node(logical_plan, dataset, [default_graph],
server_url, cardinalities)
return iterator, cardinalities
def extract_bgps(q, cache=None, init_ns={}):
from agora.graph.evaluate import traverse_part
from rdflib.plugins.sparql.algebra import translateQuery
from rdflib.plugins.sparql.parser import parseQuery
from rdflib.plugins.sparql.sparql import Query
if cache is not None and q in cache:
return cache[q]
if not isinstance(q, Query):
parsetree = parseQuery(q)
query = translateQuery(parsetree, None, init_ns)
else:
query = q
part = query.algebra
filters = {}
bgps = []
for p in traverse_part(part, filters):
bgps.append(p)
if cache is not None:
cache[q] = bgps, filters
return bgps, filters
def GetSPOfromQuery(q, getBlankNode=False):
pq = parser.parseQuery(q)
form = GetQueryForm(pq)
# using function in rdflib to absolutize/resolve prefixes
prologue = translatePrologue(pq[0], None)
pq[1] = traverse(pq[1],
visitPost=functools.partial(translatePName,
prologue=prologue))
# using function in rdflib to simplify filter
inner_traverse(pq[1], inner_simplifyFilters)
# using function in rdflib to translate path
if 'where' in pq[1].keys():
pq[1]['where'] = traverse(pq[1]['where'], visitPost=translatePath)
if form == 'DescribeQuery':
triples, graph, bind, values, service, filter_info, describe_var = proQueryForm(
pq)
else:
triples, graph, bind, values, service, filter_info = proQueryForm(pq)
so = GetSOFromTriple(triples, getBlankNode=getBlankNode)
p = GetPFromTriple(triples, getBlankNode=getBlankNode)
if form == 'DescribeQuery':
so = so + describe_var
return list(set(so + p))
def test_stringify_select(self) -> None:
tree = parseQuery("""
PREFIX : <http://people.example/>
SELECT ?y ?minName
WHERE {
:alice :knows ?y .
{
SELECT ?y (MIN(?name) AS ?minName)
WHERE {
?y :name ?name .
} GROUP BY ?y
}
}
""")
res = stringify(tree)
expect = """PREFIX : <http://people.example/>
SELECT ?y ?minName
WHERE {
:alice :knows ?y .
{
SELECT ?y (MIN(?name) AS ?minName)
WHERE {
?y :name ?name .
}
GROUP BY ?y
}
}"""
self.assertEqual(res.strip(), expect)
def prepareQuery(queryString, initNs={}, base=None):
"""
Parse and translate a SPARQL Query
"""
ret = translateQuery(parseQuery(queryString), base, initNs)
ret._original_args = (queryString, initNs, base)
return ret
def parse_query(query: str, dataset: Dataset,
default_graph: str) -> Tuple[PreemptableIterator, dict]:
"""Parse a read-only SPARQL query into a physical query execution plan.
For parsing SPARQL UPDATE query, please refers to the `parse_update` method.
Args:
* query: SPARQL query to parse.
* dataset: RDF dataset on which the query is executed.
* default_graph: URI of the default graph.
Returns: A tuple (`iterator`, `cardinalities`) where:
* `iterator` is the root of a pipeline of iterators used to execute the query.
* `cardinalities` is the list of estimated cardinalities of all triple patterns in the query.
Throws: `UnsupportedSPARQL` is the SPARQL query contains features not supported by the SaGe query engine.
"""
# transaction timestamp
start_timestamp = datetime.now()
# rdflib has no tool for parsing both read and update query,
# so we must rely on a try/catch dirty trick...
try:
logical_plan = translateQuery(parseQuery(query)).algebra
cardinalities = list()
iterator = parse_query_alt(logical_plan,
dataset, [default_graph],
cardinalities,
as_of=start_timestamp)
return iterator, cardinalities
except ParseException:
return parse_update(query,
dataset,
default_graph,
as_of=start_timestamp)
def test_query_optional(self):
q = """
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX schema: <http://schema.org/>
PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX dbo: <http://dbpedia.org/ontology/>
SELECT ?leader ?label ?leaderobj
WHERE {
?leader rdfs:label ?label.
?leader rdf:type schema:Person.
OPTIONAL {?leaderobj dbo:leader ?leader}
}
"""
start_time = time()
pq = parser.parseQuery(q)
logging.debug ('parsing took %fs' % (time() - start_time))
logging.debug(pq)
tq = algebra.translateQuery(pq)
self.sas.debug_log_algebra (tq)
logging.debug(tq.algebra.__class__)
def test_stringify_construct(self) -> None:
tree = parseQuery("""
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX : <http://dbpedia.org/resource/>
CONSTRUCT { ?person foaf:name ?name . }
WHERE {
?person a dbo:MusicalArtist .
?person dbo:birthPlace :Berlin .
?person foaf:name ?name .
FILTER (LANG(?description) = 'en') .
} ORDER BY ?name
""")
res = stringify(tree)
expect = """PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX : <http://dbpedia.org/resource/>
CONSTRUCT {?person foaf:name ?name .}
WHERE {
?person <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> dbo:MusicalArtist .
?person dbo:birthPlace :Berlin .
?person foaf:name ?name .
FILTER ( LANG(?description) = "en" ) .
}
ORDER BY ?name"""
self.assertEqual(res.strip(), expect)
def prepareQuery(queryString, initNs={}, base=None):
"""
Parse and translate a SPARQL Query
"""
ret = translateQuery(parseQuery(queryString), base, initNs)
ret._original_args = (queryString, initNs, base)
return ret
def __init__(self, callback, sparql_query):
"""Creates a SPARQL filter for RDF triples."""
if sparql_query.strip()[:3].lower() != 'ask':
raise ZtreamyException('Only ASK queries are allowed '
'in SPARQLFilter')
super(SPARQLFilter, self).__init__(callback)
self.query = parseQuery(sparql_query)
def hasParseError_rdflib(q, parse_path=True):
"""
if has parse error, return true.
input:
q, the same as GetSPO_rdflib, one row from DataFrame with key: query
output:
boolean
"""
try:
# from ipdb import set_trace; set_trace()
pq = parser.parseQuery(q['query'])
if parse_path:
# using function in rdflib to absolutize/resolve prefixes
# may cause prefix error
prologue = translatePrologue(pq[0], None)
# using function in rdflib to simplify filter
inner_traverse(pq[1], inner_simplifyFilters)
pq[1] = traverse(pq[1],
visitPost=functools.partial(translatePName,
prologue=prologue))
# using function in rdflib to translate path
if 'where' in pq[1].keys():
pq[1]['where'] = traverse(pq[1]['where'],
visitPost=translatePath)
return False
except:
#from ipdb import set_trace; set_trace()
return True
def GetSPO_rdflib(q, pattern, predicate=True):
"""
get spo list.
input:
q1, one raw in DataFrame, keys: ip, time, query
pattern: result from GetPattern function
output:
a list of SPO
"""
fo = open('error_query_now.txt', 'w')
pq = parser.parseQuery(q['query'])
# write the query cannot be processed now.
try:
fo.write(q['query'])
fo.write('\n')
fo.write(str(pq))
fo.write('\n')
except:
pass
form = GetQueryForm(pq)
# using function in rdflib to absolutize/resolve prefixes
prologue = translatePrologue(pq[0], None)
pq[1] = traverse(pq[1],
visitPost=functools.partial(translatePName,
prologue=prologue))
# using function in rdflib to translate path
if 'where' in pq[1].keys():
pq[1]['where'] = traverse(pq[1]['where'], visitPost=translatePath)
# write the query cannot be processed now.
try:
fo.write(str(pq))
fo.write('\n')
except:
pass
if form == 'DescribeQuery':
triples, graph, bind, values, service, filter_info, describe_var = proQueryForm(
pq)
else:
triples, graph, bind, values, service, filter_info = proQueryForm(pq)
so = GetSOFromTriple(triples)
if predicate:
p = GetPFromTriple(triples)
else:
p = []
if form == 'DescribeQuery':
so = so + describe_var
fo.close()
return list(set(so + p))
def __init__(self, source, expression):
super(FilterIterator, self).__init__()
self._source = source
self._raw_expression = expression
# compile the expression using rdflib
compiled_expr = parseQuery("SELECT * WHERE {?s ?p ?o FILTER(" +
expression + ")}")
compiled_expr = translateQuery(compiled_expr)
self._compiled_expression = compiled_expr.algebra.p.p.expr
def __init__(self, source: PreemptableIterator, expression: str, context: dict):
super(FilterIterator, self).__init__()
self._source = source
self._raw_expression = expression
# compile the expression using rdflib
compiled_expr = parseQuery(f"SELECT * WHERE {{?s ?p ?o . FILTER({expression})}}")
compiled_expr = translateQuery(compiled_expr)
self._prologue = compiled_expr.prologue
self._compiled_expression = compiled_expr.algebra.p.p.expr
def test_functions__functional_forms_not_exists(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=2,
tc_desc=
'Test if the not exists form is properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def NormalizeGoals(goals):
if isinstance(goals, (list, set)):
for goal in goals:
yield goal, {}
elif isinstance(goals, tuple):
yield sparqlQuery, {}
else:
query = RenderSPARQLAlgebra(parseQuery(goals))
for pattern in query.patterns:
yield pattern[:3], query.prologue.prefixBindings
def test_other__values(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=26,
tc_desc=
'Test if "values" gets properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_solution_modifiers__slice(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=37,
tc_desc="Test if slice get properly translated into the limit and offset. "
"The query must also be executable and shall not violate any SPARQL query syntax.",
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra,
)
return test
def test_property_path__alternative_path(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=27,
tc_desc="Test if an alternative path gets properly translated into the query text. "
"The query must also be executable and shall not violate any SPARQL query syntax.",
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra,
)
return test
def test_property_path__zero_or_one_path(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=33,
tc_desc=
'Test if a zeroOrOne path gets properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def NormalizeGoals(goals):
if isinstance(goals, (list, set)):
for goal in goals:
yield goal, {}
elif isinstance(goals, tuple):
yield sparqlQuery, {}
else:
query = RenderSPARQLAlgebra(parseQuery(goals))
for pattern in query.patterns:
yield pattern[:3], query.prologue.prefixBindings
def test_operators__conditional_or(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=21,
tc_desc=
'Test if "conditional ors (||)" are properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_solution_modifiers__to_multiset(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=38,
tc_desc=
'Test if subqueries get properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_graph_patterns__left_join(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=16,
tc_desc=
'Test if "left join" gets properly translated into "OPTIONAL {...}" in the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_graph_patterns__bgp(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=9,
tc_desc=
'Test if basic graph patterns are properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_graph_patterns__aggregate_join(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=8,
tc_desc='Test if aggregate join including all aggregation functions '
'are properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def test_functions__functions_on_dates_and_time(self):
query_tree = parser.parseQuery(self.query_text)
query_algebra = algebra.translateQuery(query_tree)
self.query_from_algebra = translateAlgebra(query_algebra)
query_tree_2 = parser.parseQuery(self.query_from_algebra)
query_algebra_2 = algebra.translateQuery(query_tree_2)
self.query_from_query_from_algebra = translateAlgebra(query_algebra_2)
_pprint_query(self.query_from_query_from_algebra)
test = Test(
test_number=7,
tc_desc=
'Test if functions on dates and time are properly translated into the query text. '
'The query must also be executable and shall not violate any SPARQL query syntax.',
expected_result=self.query_from_algebra,
actual_result=self.query_from_query_from_algebra)
return test
def query(self, query_object, processor='sparql',
result='sparql', initNs=None, initBindings=None,
use_store_provided=True, **kwargs):
"""
Query this graph.
A type of 'prepared queries' can be realised by providing
initial variable bindings with initBindings
Initial namespaces are used to resolve prefixes used in the query,
if none are given, the namespaces from the graph's namespace manager
are used.
:returntype: rdflib.query.QueryResult
"""
if isinstance(query_object, Query):
sparql, initNS, _ = query_object._original_args
algebra = query_object.algebra
else:
sparql = query_object
algebra = parseQuery(query_object)
if algebra[1].datasetClause:
raise ValueError('PrefixConjunctiveView does not support '
'FROM or FROM NAMED clauses in SPARQL')
if use_store_provided and self._store_can_query:
# not actually used for the moment
# (_store_can_query is always False)
# below is a tentative implementation,
# but it will not scale if the number of included graphs is too high.
if algebra[1].name == ('ConstructQuery'):
cend = CONSTRUCT.search(sparql).end()
wspan = WHERE.search(sparql[cend:]).span()
prefix = sparql[:cend+wspan[0]]
suffix = sparql[cend+wspan[1]:]
else:
prefix, _, suffix = WHERE.split(sparql, 1)
processed_sparql = ''.join([
prefix, self.sparql_declaration, '{', suffix
])
return self.store.query(
processed_sparql,
initNs or dict(self.namespaces()),
initBindings or {},
'__UNION__',
**kwargs)
else:
return super(PrefixConjunctiveView, self).query(
query_object, processor, result, initNs, initBindings, False, **kwargs
)
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 parse_query_type(query, base=None, default_graph=[], named_graph=[]):
"""Parse a query and add default and named graph uri if possible."""
try:
parsed_query = parseQuery(query)
parsed_query = configure_query_dataset(parsed_query, default_graph, named_graph)
translated_query = translateQuery(parsed_query, base=base)
except ParseException:
raise UnSupportedQuery()
except SparqlProtocolError as e:
raise e
if base is not None and not isAbsoluteUri(base):
raise NonAbsoluteBaseError()
if not is_valid_query_base(parsed_query):
raise NonAbsoluteBaseError()
return translated_query.algebra.name, translated_query
def sanitize_select(statement):
"""
Take a select statement and transform it into a select query that
will return the graph component associated with the term.
"""
try:
parsed = parser.parseQuery(statement)
except ParseException:
return None
part = parsed[1]['where'].get('part')
if not part:
# Looks like a null query, not supported.
return None
if len(part) > 1:
# Multiple parts currently not supported. If we can easily use
# pyparsing to manipulate AND generate the result back into a
# string this would have been trivial, but it does not do this
# by default
return None
projections = {str(s['var']) for s in parsed[1]['projection']}
if part[0].name == 'GraphGraphPattern':
projection = str(part[0].term)
if projection not in projections:
# retry after adding.
return sanitize_select(_add_graph_projection(statement,
projection))
# return the graph token built-in and the statement.
return projection, statement
projection = None
if projection in projections:
# just abort for now.
return None
projection = '_g' + str(randint(0, 100000))
return sanitize_select(_add_graph_graph_pattern(statement, projection))
def isaBaseQuery(self, queryString, queryObj=None):
"""
If the given SPARQL query involves purely base predicates
it returns it (as a parsed string), otherwise it returns a SPARQL algebra
instance for top-down evaluation using this store
>>> graph=Graph()
>>> topDownStore = TopDownSPARQLEntailingStore(graph.store, graph, derivedPredicates=[RDFS.seeAlso], nsBindings={u"rdfs": str(RDFS)})
>>> rt=topDownStore.isaBaseQuery("SELECT * { [] rdfs:seeAlso [] }")
>>> isinstance(rt,(BasicGraphPattern, AlgebraExpression))
True
>>> rt=topDownStore.isaBaseQuery("SELECT * { [] a [] }")
>>> isinstance(rt,(Query, basestring)) #doctest: +SKIP
True
>>> rt=topDownStore.isaBaseQuery("SELECT * { [] a [] OPTIONAL { [] rdfs:seeAlso [] } }")
>>> isinstance(rt,(BasicGraphPattern, AlgebraExpression))
True
"""
from rdflib.plugins.sparql.query import Prologue
from rdflib.plugins.sparql.parser import parseQuery
from rdflib.plugins.sparql import sparql as sparqlModule
if queryObj:
query = queryObj
else:
query = parseQuery(queryString)
if not query.prologue:
query.prologue = Prologue(None, [])
query.prologue.prefixBindings.update(self.nsBindings)
else:
for prefix, nsInst in list(self.nsBindings.items()):
if prefix not in query.prologue.prefixBindings:
query.prologue.prefixBindings[prefix] = nsInst
sparqlModule.prologue = query.prologue
algebra = RenderSPARQLAlgebra(query, nsMappings=self.nsBindings)
return first(self.getDerivedPredicates(algebra, sparqlModule.prologue)) and algebra or query
def testSelect(self):
parsed_query = configure_query_dataset(parseQuery(self.query), [], [])
self.assertEqual(len(parsed_query[1]), 1)
self.assertTrue('where' in parsed_query[1])
parsed_query = configure_query_dataset(parseQuery(self.query), None, None)
self.assertEqual(len(parsed_query[1]), 1)
self.assertTrue('where' in parsed_query[1])
parsed_query = configure_query_dataset(parseQuery(self.query), [], None)
self.assertEqual(len(parsed_query[1]), 1)
self.assertTrue('where' in parsed_query[1])
parsed_query = configure_query_dataset(parseQuery(self.query), None, [])
self.assertEqual(len(parsed_query[1]), 1)
self.assertTrue('where' in parsed_query[1])
parsed_query = configure_query_dataset(parseQuery(self.query), ['urn:default'], [])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 1)
self.assertEqual(parsed_query[1]['datasetClause'][0]['default'], URIRef('urn:default'))
parsed_query = configure_query_dataset(parseQuery(self.query), [], ['urn:named'])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 1)
self.assertEqual(parsed_query[1]['datasetClause'][0]['named'], URIRef('urn:named'))
parsed_query = configure_query_dataset(parseQuery(self.query), ['urn:default'], ['urn:named'])
self.assertEqual(len(parsed_query[1]), 2)
self.assertTrue('where' in parsed_query[1])
self.assertTrue('datasetClause' in parsed_query[1])
self.assertEqual(len(parsed_query[1]['datasetClause']), 2)
self.assertEqual(parsed_query[1]['datasetClause'][0]['default'], URIRef('urn:default'))
self.assertEqual(parsed_query[1]['datasetClause'][1]['named'], URIRef('urn:named'))
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 = Dataset()
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(res),
set(res2)
)
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(res),
set(res2)
), 'Bindings do not match: \n%s\n!=\n%s' % (
res.serialize(format='txt', namespace_manager=g.namespace_manager),
res2.serialize(format='txt', namespace_manager=g.namespace_manager))
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 _parseQuery(sparql):
return parseQuery(sparql)
if not isinstance(p, CompValue):
print p
return
print "%s(" % (p.name, )
for k in p:
print "%s%s =" % (ind, k,),
pp(p[k], ind + " ")
print "%s)" % ind
try:
pp(q.algebra)
except AttributeError:
# it's update, just a list
for x in q:
pp(x)
if __name__ == '__main__':
import sys
from rdflib.plugins.sparql import parser
import os.path
if os.path.exists(sys.argv[1]):
q = file(sys.argv[1])
else:
q = sys.argv[1]
pq = parser.parseQuery(q)
print pq
tq = translateQuery(pq)
print pprintAlgebra(tq)
u'math': URIRef("http://www.w3.org/2000/10/swap/math#"),
}
MANIFEST_QUERY = u"""\
SELECT ?status ?premise ?conclusion ?feature ?descr
WHERE {
[
a otest:PositiveEntailmentTest;
otest:feature ?feature;
rtest:description ?descr;
rtest:status ?status;
rtest:premiseDocument ?premise;
rtest:conclusionDocument ?conclusion
]
}"""
PARSED_MANIFEST_QUERY = parseQuery(MANIFEST_QUERY)
Features2Skip = [
URIRef('http://www.w3.org/2002/07/owl#sameClassAs'),
]
NonNaiveSkip = [
'OWL/oneOf/Manifest002.rdf', # see Issue 25
'OWL/unionOf/Manifest002.rdf', # support for disjunctive horn logic
]
MagicTest2Skip = [
'OWL/oneOf/Manifest002.rdf', # needs 2nd order predicate derivation
'OWL/oneOf/Manifest003.rdf', # needs 2nd order predicate derivation
'OWL/disjointWith/Manifest001.rdf' # needs 2nd order predicate derivation
]
def why(options, factGraph, network, nsBinds, ruleSet, workingMemory):
if options.builtinTemplates:
builtinTemplateGraph = Graph().parse(options.builtinTemplates,
format='n3')
else:
builtinTemplateGraph = Graph()
factGraph.templateMap = dict([
(pred, template) for pred, _ignore, template in
builtinTemplateGraph.triples((None, TEMPLATES.filterTemplate, None))])
network.nsMap['pml'] = PML
network.nsMap['gmp'] = GMP_NS
network.nsMap['owl'] = OWL_NS
nsBinds.update(network.nsMap)
network.nsMap = nsBinds
query = parseQuery(options.why)
translateQuery(query, initNs=nsBinds)
goals = sum([triple_block['triples'] for triple_block
in query[1].where['part']], [])
defaultBasePreds = []
defaultDerivedPreds = set()
hybridPredicates = []
mapping = dict(factGraph.namespace_manager.namespaces())
for edb in options.edb:
pref, uri = edb.split(':')
defaultBasePreds.append(URIRef(mapping[pref] + uri))
noMagic = []
for pred in options.noMagic:
pref, uri = pred.split(':')
noMagic.append(URIRef(mapping[pref] + uri))
if options.ddlGraph:
ddlGraph = Graph().parse(options.ddlGraph, format='n3')
# @TODO: should also get hybrid predicates from DDL graph
defaultDerivedPreds = IdentifyDerivedPredicates(
ddlGraph, Graph(), ruleSet)
else:
for idb in options.idb:
pref, uri = idb.split(':')
defaultDerivedPreds.add(URIRef(mapping[pref] + uri))
defaultDerivedPreds.update(
set([p == RDF.type and o or p for s, p, o in goals]))
for hybrid in options.hybridPredicate:
pref, uri = hybrid.split(':')
hybridPredicates.append(URIRef(mapping[pref] + uri))
if options.method == 'gms':
gms(goals, noMagic, factGraph, ruleSet, defaultBasePreds,
defaultDerivedPreds, network, workingMemory,
nameMap[options.strictness])
if options.output == 'rif':
print("Rules used for bottom-up evaluation")
if network.rules:
for clause in network.rules:
print(clause)
else:
for clause in factGraph.adornedProgram:
print(clause)
if options.output == 'conflict':
network.reportConflictSet()
elif options.method == 'bfp':
bfp(defaultDerivedPreds, options, factGraph, ruleSet, network,
hybridPredicates)
