Scripting the Semantic Web requires to access and transform RDF data. We present XSLT+SPARQL, a set of extension functions for XSLT which allow stylesheets to directly access RDF data, independently of any serialization syntax, by means of SPARQL queries. Using these functions, XSLT stylesheets can retrieve, query, merge and transform data from the semantic web. We illustrate the functionality of our proposal with an example script which creates XHTML pages from the contents of DBpedia.
The semantic web has adopted RDF as its preferred data model for resource
description. However, the document web is based on markup languages like XML
and HTML. Transforming data and gluing between the two worlds with the
current set of tools is not always easy. In particular, XSLT [
However, the inverse transformation, from RDF to XML, is insuciently covered by the current tool set. Most popular web scripting languages, such as Python and PHP, have their own non-standard APIs for accessing RDF data (conversely, there are standardized APIs for XML, such as DOM and SAX). This is an hindrance to the use of these scripting languages with RDF.
Unfortunately, standard languages such as XSLT and XQuery are
inappropriate for this task. Even if RDF data can be apparently addressed as XML through
its RDF/XML serialization syntax [
We propose XSLT+SPARQL, an extension to the XSLT function set to embed SPARQL SELECT and ASK queries in the XPath selection expressions. This makes it possible to process RDF data directly within the RDF model, i.e., regardless of any particular serialization syntax. We believe XSLT+SPARQL can contribute to the semantic web by providing a new platform for scripting and transforming RDF into XML, which is often the last processing step of many semantic web scripts. XSLT+SPARQL can easily produce XHTML reports, SVG graphs, SOAP messages or, more generally, any valid XSLT output format (XML or text documents). Moreover, developers can exploit the expressivity of XSLT to create complex scripts that combine, lter and transform data retrieved from dierent web sources or even from remote SPARQL endpoints.
The rest of the paper is organized as follows. Next section examines related work prior to the description of XSLT+SPARQL in Section 3. Implementation is briey discussed in Section 4, and a use case is presented in Section 5. The discussion in Section 6 concludes the paper. 2
After a number of proposals from dierent groups [
The most direct precedent to our work is [
More recently, XSPARQL [
XSLT+SPARQL exploits the extensibility mechanism provided by the host language, to introduce a number of extension functions. They are grouped in two dierent namespaces. 3.1
The core functionality of XSLT+SPARQL is provided by just two functions:
2. sparql:sparqlEndpoint(query, endpointUrl)
These functions execute a SELECT or ASK query (CONSTRUCT and DESCRIBE queries are not allowed because they return RDF/XML documents, which are notoriously dicult to handle in XSLT). The rst function executes the query locally, while the second one sends a request to a remote SPARQL endpoint and retrieves the results. The documents pointed by the (potentially empty) list of URLs are merged with the ones referred by the FROM clauses of the query to create the default graph. 3.2
Some applications may need to eciently execute multiple queries against the same dataset, or even to build custom datasets by merging multiple graphs. To address the requirements of these applications, a second set of extension functions is dened in a dierent namespace: 1. sparqlModel:parseString(serializedRdf [, serializationSyntax]) 2. sparqlModel:readModel(documentUrl [, serializationSyntax]) 3. sparqlModel:readModel(nodeset) 4. sparqlModel:mergeModels(firstModel, secondModel, ...) 5. sparqlModel:sparqlModel(query, model)
The rst three functions read RDF data from dierent sources: (1) a string;
(2) a document pointed by a URL; or (3) any fragment of the XSLT input tree,
the result tree only in XSLT 2.0 or even the XSLT stylesheet itself. When
the input is a string or a web document, an optional parameter selects the
RDF serialization syntax to be parsed (N3 [
The mergeModels function combines any number of input models into a new one. Due to the functional character of XSLT, it is not possible to do in-place modications of a model, therefore this function returns a new model with the result of combining the data. Consequently, scripts that require to merge data from a sequence of sources cannot iterate through the sequence, but have to be re-casted as recursive templates using well-known patterns from functional programming.
Finally, the fth function executes a SPARQL query over an in-memory model. Any FROM or FROM NAMED clause in the query is ignored.
Together, these advanced functions bring great exibility to the developer, and also a performance boost to execute multiple queries against the same dataset, avoiding the need for repeated parsing of the input documents. 4
We have implemented the above functions in Java as an extension for Apache
Xalan4, an open-source XSLT processor, although it should be easy to adapt
our code to other XSLT processors. Our implementation uses the Jena
framework [
A limitation of our current implementation concerns the sparql:sparql and sparqlModel:mergeModels functions, which do not accept an arbitrary number of arguments, due to the inability of Xalan 2.7 to access Java5 vararg methods using reectivity. Particularly, the former accepts zero or one document URLs, and the latter merges exactly two models. 5
Practical use of XSLT+SPARQL is demonstrated by a sample script (Figure 1)
that extracts data from DBpedia [
The functionality of XSLT+SPARQL goes far beyond this small example. More complex examples can be found in the project web page 5. 6
We presented XSLT+SPARQL, a simple extension for XSLT to embed SPARQL queries in XPath expressions, making it possible to process RDF data from
5 http://berrueta.net/research/xsltsparql <xsl:variable name="query">
PREFIX skos: <http://www.w3.org/2004/02/skos/core#> PREFIX cat: <http://dbpedia.org/resource/Category:> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name ?person ?img WHERE { ?person skos:subject cat:Spanish_actors .
?person rdfs:label ?name . ?person foaf:depiction ?img .
FILTER (lang(?name)="es") }
ORDER BY ?name </xsl:variable> <xsl:template match="/"> <html> <body> <h1>Spanish Actors</h1> <ul> <xsl:apply-templates select="sparql:sparqlEndpoint(
$query, ’http://dbpedia.org/sparql’)"/> </ul> </body> </html> </xsl:template> <xsl:template match="results:result"> <li> <xsl:value-of select="results:binding[@name=’name’]"/> <img> <xsl:attribute name="src">
<xsl:value-of select="results:binding[@name=’img’]"/> </xsl:attribute> </img> </li> </xsl:template>
XSLT stylesheets without bothering with the tricky RDF/XML serialization. XSLT+SPARQL is a new standards-based platform to write declarative scripts for the semantic web. It is straightforward to use for developers experienced in XML and RDF technologies because it does not require to learn a new language or processing model. Furthermore, it can be implemented by re-using current XSLT processors.
The usage of XSLT+SPARQL has been illustrated by means of a sample application to create XHTML reports from DBpedia data. We envisage the usage of XSLT+SPARQL in a wide variety of scenarios. They mainly involve transforming RDF data into other formats which are more suitable for human consumption. However, more complex semantic web agents can be developed as well. For instance, we are working on a semantic web crawler/browser that collects relevant information about a subject from dierent linked data sources and creates a comprehensive report in XHTML.
We are also considering new additions to the current set of functions. One area of particular interest would be to add support for RDFS and OWL reasoning.