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)