The Web of Data encourages organizations and companies to publish their data according to the Linked Data practices and offer SPARQL endpoints. On the other hand, the dominant standard for information exchange is XML. The SPARQL2XQuery Framework focuses on the automatic translation of SPARQL queries in XQuery expressions in order to access XML data across the Web. In this paper, we outline our ongoing work on supporting update queries in the RDF-XML integration scenario.
Introduction
Translating SPARQL Update Queries to XQuery This section describes the translation of SPARQL update operations into XQuery expressions using the XQuery Update Facility. We present how similar methods and algorithms previously developed in the SPARQL2XQuery Framework can be adopted for the update operation translation. For instance, graph pattern and triple pattern translation are also used in the update operation translation. Note that, due to space limitations, some issues are presented in a simplified way in the rest of this section and several details are omitted.
Table 1 presents the SPARQL update operations and summarizes their translation in XQuery. In particular, there are three main categories of SPARQL update operations a) Delete Data; b) Insert Data; and c) Delete/Insert. For each update operation, a simplified SPARQL syntax template is presented, as well as the corresponding XQuery expressions. In SPARQL context, we assume the following sets, let tr be an RDF triple set, tp a triple pattern set, trp a set of triples and/or triple patterns, and gp a graph pattern. Additionally, in XQuery, we denote as xEW, xEI and xED the sets of XQuery expressions (i.e., FLOWR expressions) that have resulted from the translation of the graph pattern included in the Where, Insert and Delete SPARQL clauses, respectively. Let xE be a set of XQuery expressions, xE($v1, $v2,… $vn) denote that xE are using (as input) the values assigned to XQuery variables $v1, $v2,… $vn. Finally, xn denotes an XML fragment, i.e., a set of XML nodes, and xp denotes an XPath expression. (a) D}}Wtgerplpehteer{e{ (c) }DIetnrlspeeter{t{ (allr)eeetttu$$rdwnehldeetreeel__egtgepp:n=:=oxdxEeEsDW($$dwelheetere__ggpp)
trp }Where{ (c) } gp tThreannstrlaatneslDaeteleItensWerhteWrehsearmeseaamse(aa)s, (b)
In the following examples, we assume that an RDF source has been mapped to an XML
source. In particular, we assume the example presented in [
Delete Data. The Delete Data SPARQL operation removes a set of triples from RDF
graphs. This SPARQL operation can be translated in XQuery using the Delete Nodes
XQuery operation. Specifically, using the predefined mappings, the set of triples tr
defined in the SPARQL Delete Data clause is transformed (using a similar approach such
as the BGP2XQuery algorithm [
In this example, two RDF triples are deleted from an RDF graph. In addition to the mappings described above, we assume that the person "http://rdf.gr/person1209" in RDF data has been mapped to the person "/Persons/Student[.@SSN=1209]" in XML data.
Delete data{ delete nodes collection("http://xml.gr")/Persons/Stu<http://rdf.gr/person1209> ns: FName "John" . dent[.@SSN=1209]/FirstName[.= "John"] <http://rdf.gr/person1209> ns:E-mail "john@smith.com". delete nodes collection("http://xml.gr")/Persons/Stu} dent[.@SSN=1209]/Email[.= "John@smith.com"] Insert Data. The Insert Data SPARQL operation, adds a set of new triples in RDF graphs. This SPARQL operation can be translated in XQuery using the Insert Nodes XQuery operation. In the Insert Data translation, the set of triples tr defined in SPARQL are transformed into XML node sets xni, using the predefined mappings. In particular, a set of Let XQuery clauses is used to build the XML nodes and define the appropriate node nesting and grouping. Then, the location of the XML node insertion can be easily determined considering the triples and the mappings. Finally, the constructed nodes are inserted in their location of insertion using the XQuery Insert nodes clause.
In this example, the RDF triples deleted in the previous example are reinserted in the RDF graph.
Insert data{ let $n1 := <FirstName>John</FirstName>
<http://rdf.gr/person1209> ns:FName "John" . let $n2 := <Email>john@smith.com</Email>
<http://rdf.gr/person1209> ns:E-mail "john@smith.com". let $data1 := ($n1, $n2)
} let $insert_location1 :=
collection("http://xml.gr")/Persons/Student[.@SSN=1209]
return insert nodes $data1 into $insert_location1
Insert / Delete. The Delete/Insert SPARQL operations are used to remove and/or add a
set of triples from/to RDF graphs, using the bindings that resulted from the evaluation
of the graph pattern defined in the Where clause. According to the SPARQL 1.1
semantics, the Where clause is the first one that is evaluated. Then, the Delete/Insert clause is
applied over the produced results. Especially, in case, that both Delete and Insert
operations exist, the deletion is performed before the insertion, and the Where clause is
evaluated once. The Delete and the Insert SPARQL operations can be translated to XQuery
using the Delete Nodes and Insert Nodes operations, respectively. In brief, initially the
graph pattern used in the Where clause is translated to XQuery expressions xEW
(similarly as in the GP2XQuery algorithm [
In this example, the Where clause selects all the students studying in a computer science (CS) department. Then, the Delete clause deletes all the triples that match with its triple patterns, using the ?student bindings determined from the Where clause. In particular, from all the retrieved students (i.e., CS students), the students which have as first name the name "John" should be deleted.
Delete{
?student ns:FName "John" . }Where{ ?student ns:Department "CS" .
let $where_gp := collection("http://xml.gr")/Persons/Student[./Dept="CS"] let $delete_gp := $where_gp[./FirstName="John"] return delete nodes $delete_gp }
In this example, the Where clause selects all the students studying in a CS department, as well as their first names. Then, the Insert clause creates new triples according to its triple patterns, using the ?student and ?name bindings determined from the Where clause. In particular, a new triple having as predicate “ns:GivenName” and as object the first name of the ?student, is inserted for each ?student.
Insert{
?student ns:GivenName ?name . }Where{ ?student ns:FName ?name . ?student ns:Department "CS" .
let $where_gp := collection(“http://xml.gr”)/Persons/Student[./Dept="CS"] let $insert_location1 := $where_gp for $it1 in $insert_location1 let $insert_gp1 := <GivenName>{fn:string($it1/FirstName)}</GivenName> return insert nodes $insert_gp1 into $it1