XSPARQL Tutorial

NET 2

Transforming between RDF and
XML with XSPARQL
Net2 Tutorial
Nuno Lopes
December, 2010

Integration of Heterogeneous Sources

1 / 51


SPARQL

1 / 51


XSLT/XQuery

SPARQL

1 / 51


XSLT/XQuery
Lowering
SPARQL

Lifting

Transformations between XML and RDF are not easy, mainly
due to the heterogeneity of RDF/XML serialisations

1 / 51


XSLT/XQuery

SPARQL

Transformations between XML and RDF are not easy, mainly
due to the heterogeneity of RDF/XML serialisations
Objective: language capable of integrating heterogeneous
sources for the Semantic Web

1 / 51

Why are such transformations needed? (I)

Standards in Health Care and Life Sciences

2 / 51

Why are such transformations needed? (I)

Standards in Health Care and Life Sciences

Possible solution for the heterogeneous message formats
Store your data in RDF
Convert it to the required XML format when necessary

2 / 51

Why are such transformations needed? (II)

Creating (X)HTML from an RDF backend (under development):
http://musicpath.org/

3 / 51

Toy example for the tutorial

knows knows

knows

4 / 51

Why XQuery/XSLT is not enough:

Diﬀerent syntaxes and serialisations for the same RDF graph:

@prefix alice: <alice/> . <rdf:RDF xmlns:foaf="...foaf/0.1/">
@prefix foaf: <...foaf/0.1/> . <foaf:Person>
<foaf:knows>
_:b1 rdf:type foaf:Person; <foaf:Person foaf:name="Bob"/>
foaf:knows _:b2. </foaf:knows>
_:b2 rdf:type foaf:Person; </foaf:Person>
foaf:name "Bob". </rdf:RDF>

<rdf:RDF xmlns:foaf="...foaf/0.1/"
<rdf:RDF xmlns:foaf="...foaf/0.1/" xmlns:rdf="...rdf-syntax-ns#">
xmlns:rdf="...rdf-syntax-ns#"> <rdf:Description rdf:nodeID="x">
<rdf:Description rdf:nodeID="b1"> <foaf:knows rdf:nodeID="y"/>
<rdf:type </rdf:Description>
rdf:resource=".../Person"/> <rdf:Description rdf:nodeID="x">
<foaf:knows rdf:nodeID="b2"/> <rdf:type rdf:resource=".../Person"/>
</rdf:Description> </rdf:Description>
<rdf:Description rdf:nodeID="b2"> <rdf:Description rdf:nodeID="y">
<rdf:type <foaf:name>Bob</foaf:name>
rdf:resource=".../Person"/> </rdf:Description>
<foaf:name>Bob</foaf:name> <rdf:Description rdf:nodeID="y">
</rdf:Description> <rdf:type rdf:resource=".../Person"/>
</rdf:RDF> </rdf:Description>
</rdf:RDF>

5 / 51



rtle <foaf:knows>
Tu
_:b1 rdf:type foaf:Person;
foaf:knows _:b2.
<foaf:Person foaf:name="Bob"/>
</foaf:knows>

</rdf:RDF>

5 / 51



Tri
plele

urt sto e
<foaf:knows>
_:b1 rdf:type foaf:Person;r
T
foaf:knows _:b2.
</foaf:knows>

</rdf:RDF>

5 / 51



@prefix alice: <alice/> .
Tri RD
<rdf:RDF xmlns:foaf="...foaf/0.1/">
plele
F/
XM
urt sto e
<foaf:knows>
T
foaf:knows _:b2.
</foaf:knows> L

rdf:resource=".../Person"/>
RDF/XML
<foaf:knows rdf:nodeID="b2"/> X ML
<rdf:Description rdf:nodeID="x">
<rdf:type rdf:resource=".../Person"/>
</rdf:Description> F/
</rdf:Description>
<rdf:Description rdf:nodeID="b2"> RD
<rdf:Description rdf:nodeID="y">
</rdf:RDF>

5 / 51



Tri RD
plele
F/
XM
urt sto e
<foaf:knows>
T
foaf:knows _:b2.
</foaf:knows> L

RDF/XML
</rdf:Description>
Any transformation needs to take
<foaf:name>Bob</foaf:name>
</rdf:Description>
into account the diﬀerent RDF/XML
</rdf:RDF>

representations
5 / 51



Tri RD
plele
F/
XM
urt sto e
<foaf:knows>
T
foaf:knows _:b2.
</foaf:knows> L

RDF/XML
</rdf:Description>
Or: end up with diﬀerent transfor-
</rdf:Description>
</rdf:RDF>
</rdf:Description>
</rdf:RDF>
mations for the same RDF data
5 / 51

Why SPARQL is not enough:

Great for querying RDF! Easy to output Turtle or
SPARQL XML results format ...

prefix vc: <http://www.w3.org/2001/vcard-rdf/3.0#>
prefix foaf: <http://xmlns.com/foaf/0.1/>

construct { $X foaf:name $FN.}
from <vCard.rdf>
where { $X vc:FN $FN .}

... but

6 / 51

Why SPARQL is not enough:

Great for querying RDF! Easy to output Turtle or
SPARQL XML results format ...


from <vCard.rdf>

... but

How to produce arbitrary XML???

6 / 51

XSPARQL

Transformation language
XML and RDF formats (based on
XQuery and SPARQL)

7 / 51

XSPARQL

XML and RDF formats (based on
XQuery and SPARQL)
Lifting and Lowering in a single
language

7 / 51

Outline

Overview

XPath & XQuery
XPath
XQuery
XQuery Semantics

Outline

Overview

XPath & XQuery
XPath
XQuery
XQuery Semantics

SPARQL

Outline

Overview

XPath & XQuery
XPath
XQuery
XQuery Semantics

SPARQL

XSPARQL
Syntax
Semantics
Implementation
XSPARQL Features
Query examples

XPath

XPath is used to locate nodes in XML trees
An XPath expression is a sequence of steps separated by /.
Each step evaluates to a sequence of nodes.

relations.xml
<relations>
<person name="Alice">
<knows>Bob</knows>
<knows>Charles</knows>
</person>
<person name="Bob">
</person>
<person name="Charles"/>
</relations>

Full spec at http://www.w3.org/TR/xpath20/.
Tutorial at http://www.w3schools.com/xpath/default.asp.

8 / 51

XPath


relations.xml
<relations> relations node
<person name="Alice"> is the root ele-
<knows>Bob</knows>
<knows>Charles</knows> ment
</person>
<person name="Bob">
</person>
</relations>


8 / 51

XPath


relations.xml
<relations>
<knows>Bob</knows>
<knows>Charles</knows> 3 child elements
</person>
<person name="Bob"> person with at-
<knows>Charles</knows> tribute name
</person>
</relations>


8 / 51

XPath


relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
Each person el-
</person> ement can have
<person name="Charles"/> knows childs
</relations>


8 / 51

XPath Steps

Step examples
/relations Selects the root element relations

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

9 / 51

XPath Steps

Step examples
/relations/person Selects all person elements that are children of relations

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

9 / 51

XPath Steps

Step examples
/relations/person Selects all person elements that are children of relations
//knows Selects all knows elements (in all the document)

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

9 / 51

XPath Predicates

Predicate examples
/relations/person[3] Selects the third person child of relations

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

10 / 51

XPath Predicates

Predicate examples
/relations/person[position()<3] Selects the ﬁrst two person children of relations

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

10 / 51

XPath Predicates

Predicate examples
/relations/person[position()<3] Selects the ﬁrst two person children of relations
//person[@name=’Alice’] Selects all person elements which the value of the
name attribute is ’Alice’

relations.xml
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

10 / 51

XQuery

XQuery
Query language for XML (diﬀerent requirements than XSLT)
functional language
typed language
Superset of XPath
Overview of the formal semantics (Normalisation rules, Static
Typing and Dynamic Evaluation)

XQuery spec: http://www.w3.org/TR/xquery/.
XQuery and XPath Formal Semantics: http://www.w3.org/TR/xquery-semantics/.

11 / 51

Schematic view on XQuery

Prolog: P declare namespace preﬁx="namespace-URI "
Body: F for var in XPath-expression
L let var := XPath-expression
W where XPath-expression
O order by XPath-expression
Head: R return XML + nested XQuery

Query Example: Convert our relations data into RDF/XML
declare namespace foaf = "http://xmlns.com/foaf/0.1/";

for $person in doc("relations.xml")//person,
$nameA in $person/@name
where $nameA = "Alice"
return <foaf:Person>{$nameA,
for $nameB in $person/knows
let $friend := <foaf:Person name="{$nameB}"/>
order by $nameB
return <foaf:knows>{$friend}</foaf:knows>
}</foaf:Person>

12 / 51

Schematic view on XQuery

O order by XPath-expression
Head: R return XML + nested XQuery

Query result
<foaf:Person xmlns:foaf="http://xmlns.com/foaf/0.1/" name="Alice">
<foaf:knows>
<foaf:Person name="Bob"/>
</foaf:knows>
<foaf:knows>
<foaf:Person name="Charles"/>
</foaf:knows>
</foaf:Person>

12 / 51

Positional variable at

Query example: add an id attribute to the relations data
for $person at $pos in doc("relations.xml")//person
return <person id="{$pos}">
{$person/@*, $person/*}
</person>

$pos refers to the position of $person in the for expression

13 / 51

Positional variable at

Query example: add an id attribute to the relations data
for $person at $pos in doc("relations.xml")//person
return <person id="{$pos}">
{$person/@*, $person/*}
</person>

$pos refers to the position of $person in the for expression
Query result
<person id="1" name="Alice">
<knows>Bob</knows>
</person>
<person id="2" name="Bob">
</person>
<person id="3" name="Charles"/>

13 / 51

XQuery Formal semantics

Normalisation rules
Normalisation rules are rewriting rules that translate XQuery into a
simpliﬁed version (XQuery Core).

14 / 51


Normalisation rules

Rule application
1 Static Analysis: Apply normalisation rules and static type
analysis
2 Dynamic Evaluation Rules: evaluate expressions

14 / 51


Normalisation rules

Rule application
analysis

Environments
statEnv contains information needed for performing static
type analysis. E.g. varType, funcType, . . .

14 / 51


Normalisation rules

Rule application
analysis

Environments
statEnv contains information needed for performing static
type analysis. E.g. varType, funcType, . . .
dynEnv contains information needed for the evaluation of
expressions. E.g. varValue, . . .

14 / 51

Semantics - Normalisation rules example

for Example
for $i in (1, 2),
$j in (3, 4)
return
<pair>{ ($i,$j) }</pair>

15 / 51


for Example
for $i in (1, 2),
$j in (3, 4)
return

for Normalised example
for $i in (1, 2) return
for $j in (3, 4) return

15 / 51


For Normalisation
 
for $VarName 1 in Expr 1 , · · · ,
 $VarName n in Expr n 
ReturnClause Expr
==
for $VarName 1 in [Expr 1]Expr return
···
for $VarName n in [Expr n]Expr [ReturnClause]Expr
]

16 / 51

Semantics - Static typing example

For Static Type Analysis
statEnv Expr 1 : Type 1
statEnv + varType(Variable ⇒ Type 1 ) Expr 2 : Type 2
for $Variable in Expr 1
statEnv
return Expr 2 : Type 2 · quantiﬁer(Type 1 )

17 / 51


: means Expr 1 is
of type Type 1

statEnv

17 / 51


+ means extend : means Expr 1 is
the environment of type Type 1

statEnv

17 / 51


+ means extend : means Expr 1 is
the environment of type Type 1

statEnv

quantifier estimates the
number of solutions: *, +
or ?

17 / 51

Semantics - Dynamic evaluation rules

Simple for example
for $i in (1, 2) return $i+1

18 / 51

For each result in
the expression
Simple for example

18 / 51

For each result in
the expression
Simple for example Variable $i is as-
signed the corre-
sponding value

18 / 51

For each result in
the expression
Simple for example Variable $i is as-
signed the corre-
sponding value
Return expresion
is evaluated

18 / 51


Simple for example

For Dynamic Evaluation (Simpliﬁed)

dynEnv Expr 1 ⇒ Item1 , . . . , Itemn
dynEnv + varValue(Variable ⇒ Item1 ) Expr 2 ⇒ Value 1
···
dynEnv + varValue(Variable ⇒ Itemn ) Expr 2 ⇒ Value n
dynEnv
return Expr 2 ⇒ Value 1 , · · · , Value n

18 / 51


Simple for example
for $i in (1, 2) return $i+1 ⇒ means Expr 1 eval-
uates to the sequence
Item1 , . . . , Itemn

···
dynEnv

18 / 51


Simple for example
For each Itemi2)add Variable
for $i in (1, , return $i+1 ⇒ means Expr 1 eval-
⇒ Itemi to dynEnv and uates to the sequence
evaluate Expr 2 Item1 , . . . , Itemn

···
dynEnv

18 / 51

SPARQL (in 3 slides)

SPARQL
Query language for RDF

SPARQL spec: http://www.w3.org/TR/rdf-sparql-query/.
SPARQL 1.1 Tutorial:
http://polleres.net/presentations/20101019SPARQL1.1Tutorial.pdf.

19 / 51


SPARQL
RDF represents data as triples: Subject, Predicate, Object.
An RDF Graph is a set of triples.


19 / 51


SPARQL
SPARQL queries RDF data by pattern matching: given a set
of triple patterns, ﬁnds the corresponding triples in the input
graph


19 / 51


SPARQL
SPARQL queries RDF data by pattern matching: given a set
of triple patterns, ﬁnds the corresponding triples in the input
graph
Actually, matched against the scoping graph: a graph
equivalent to the input graph but does not share any blank
nodes with it or the query.


19 / 51

Schematic view on SPARQL

Prolog: P prefix preﬁx: <namespace-URI >
Head: C construct { template }
select variableList
Body: D from / from named <dataset-URI >
W where { pattern }
M order by expression
limit integer > 0
offset integer > 0

Query Example: Convert between diﬀerent RDF vocabularies

from <vCard.ttl>
order by $FN
limit 1 offset 1

20 / 51

Schematic view on SPARQL

Prolog: P prefix preﬁx: <namespace-URI >
Head: C construct { template }
select variableList
Body: D from / from named <dataset-URI >
W where { pattern }
limit integer > 0
offset integer > 0

Query Example: Convert between diﬀerent RDF vocabularies

select $X $FN
from <vCard.ttl>
order by $FN
limit 1 offset 1

20 / 51

SPARQL select solutions

Solutions for SPARQL select queries are substitutions for
the variables present in the head (variableList)

21 / 51

SPARQL select solutions

Solutions for SPARQL select queries are substitutions for
the variables present in the head (variableList)
Can be represented as XML

SPARQL XML Results Format (previous query)
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="X"/>
<variable name="FN"/>
</head>
<results>
<result>
<binding name="X"><bnode>b0</bnode></binding>
<binding name="FN"><literal>Nuno Lopes</literal></binding>
</result>
</results>
</sparql>

21 / 51

XSPARQL

Consume and generate XML and RDF

22 / 51

XSPARQL

Syntactic extension of XQuery

22 / 51

XSPARQL

Syntactic extension of XQuery
With a formally deﬁned semantics
(based on the XQuery semantics)

22 / 51

XSPARQL: Combining XQuery with SPARQL

or prefix preﬁx: <namespace-URI >
O order by expression or
F’ for varlist
D from / from named <dataset-URI >
W where {pattern }
limit integer > 0
offset integer > 0
Head: C construct
{ template (with nested XSPARQL) } or
R return XML + nested XSPARQL

23 / 51


prefix Prolog: P declare namespace preﬁx="namespace-URI "
declarations or prefix preﬁx: <namespace-URI >
F’ for varlist
W where {pattern }
limit integer > 0
offset integer > 0
Head: C construct

23 / 51


Data input Body: F for var in XPath-expression
(XML or RDF) W where XPath-expression
F’ for varlist
W where {pattern }
limit integer > 0
offset integer > 0
Head: C construct

23 / 51


F’ for varlist
W where {pattern }
limit integer > 0
offset integer > 0

Data output Head: C construct
(XML or RDF) R return XML + nested XSPARQL

23 / 51


XQuery or Prolog: P declare namespace preﬁx="namespace-URI "
SPARQL or prefix preﬁx: <namespace-URI >
prefix Body: F for var in XPath-expression
declarations W where XPath-expression
F’ for varlist
W where {pattern }
limit integer > 0
offset integer > 0
Head: C construct

23 / 51


Any XQuery Body: F for var in XPath-expression
query W where XPath-expression
F’ for varlist
W where {pattern }
limit integer > 0
offset integer > 0
Head: C construct

23 / 51


SPARQLForClause F’ for varlist
represents a W where {pattern }
SPARQL query M order by expression
limit integer > 0
offset integer > 0
Head: C construct

23 / 51


F’ for varlist
W where {pattern }
limit integer > 0
construct offset integer > 0
creates RDF Head: C construct
output { template (with nested XSPARQL) } or

23 / 51

Query Example - Lifting

Convert our relations data into RDF

$nameA in $person/@name,
$nameB in $person/knows
construct { [ foaf:name {data($nameA)}; a foaf:Person ] foaf:knows
[ foaf:name {data($nameB)}; a foaf:Person ]. }

24 / 51


XQuery for
for $person in doc("relations.xml")//person, data selec-
tion

24 / 51


construct
for $person in doc("relations.xml")//person, clause gen-
$nameA in $person/@name, erates RDF

24 / 51


Nesting produces
$nameA in $person/@name, an RDF literal

24 / 51




Query result
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
[ foaf:name "Alice"; a foaf:Person; foaf:knows
[ foaf:name "Bob"; a foaf:Person ] ].
[ foaf:name "Alice"; a foaf:Person; foaf:knows
[ foaf:name "Charles"; a foaf:Person ] ].
[ foaf:name "Bob"; a foaf:Person; foaf:knows
[ foaf:name "Charles"; a foaf:Person ] ].

24 / 51

Nesting in construct clauses

Nesting operators
{Expr} The result of evaluating Expr will be an RDF literal

25 / 51

Nesting in construct clauses

Nesting operators
{Expr} The result of evaluating Expr will be an RDF literal
:{Expr} Same but for RDF blank nodes
<{Expr}> and IRIs

25 / 51

Query Example - Lifting (II)

declare namespace foaf="http://xmlns.com/foaf/0.1/";
let $persons := doc("relations.xml")//person
let $ids := data($persons/@name)
for $p in $persons
let $id := fn:index-of($ids, $p/@name)
construct { _:b{$id} a foaf:Person; foaf:name {data($p/@name)}.
{ for $k in $p/knows
let $kid := fn:index-of($ids, $k)
construct { _:b{$id} foaf:knows _:b{$kid} } } }

26 / 51


let $ids := data($persons/@name) Keep person iden-
for $p in $persons
let $id := fn:index-of($ids, $p/@name) tiﬁers

26 / 51


let $ids := data($persons/@name) For each person
for $p in $persons
let $id := fn:index-of($ids, $p/@name) lookup their id

26 / 51


let $ids := data($persons/@name) The same for each
for $p in $persons
let $id := fn:index-of($ids, $p/@name) person then know

26 / 51


for $p in $persons

Query result (reformatted output)
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:b1 a foaf:Person; foaf:name "Alice"; foaf:knows _:b2, _:b3 .
_:b2 a foaf:Person; foaf:name "Bob"; foaf:knows _:b3 .
_:b3 a foaf:Person; foaf:name "Charles" .

26 / 51

Query Example - Lowering

Convert FOAF RDF data into XML
<relations>
{ for $Person $Name from <relations.rdf>
where { $Person foaf:name $Name }
order by $Name
return <person name="{$Name}">
{ for $FName from <relations.rdf>
where { $Person foaf:knows $Friend .
$Person foaf:name $Name.
$Friend foaf:name $FName. }
return <knows> { $FName }</knows>}
</person>}
</relations>

27 / 51


<relations>
where { $Person foaf:name $Name }
order by $Name XML con-
{ for $FName from <relations.rdf> struction
</person>}
</relations>

27 / 51


<relations>
where { $Person foaf:name $Name } SPARQL for
order by $Name query: “Give me
{ for $FName from <relations.rdf> persons and their
where { $Person foaf:knows $Friend . names”
</person>}
</relations>

27 / 51


<relations>
where { $Person foaf:name $Name } SPARQL for
order by $Name query: “Give me
{ for $FName from <relations.rdf> persons and their
SPARQL variables
where { $Person foaf:knows $Friend . names”
are $-preﬁxedfoaf:name $Name.
$Person
</person>}
</relations>

27 / 51


<relations>
{ for $Person $Name from <relations.rdf> SPARQL for
where { $Person foaf:name $Name } query: “Give me
order by $Name
the persons each
{ for $FName from <relations.rdf> one knows”
</person>}
</relations>

27 / 51


<relations>
{ for $Person $Name from <relations.rdf> SPARQL for
where { $Person foaf:name $Name } query: “Give me
order by $Name
the persons each
{ for $FName from <relations.rdf> one knows”
where { $Person foaf:knows $Friend . $Person and
$Friend foaf:name $FName. } $Name instanti-
return <knows> { $FName }</knows>} ated by the outer
</person>}
</relations> loop

27 / 51

Query Example - Lowering result

Query result
<relations>
<knows>Bob</knows>
</person>
<person name="Bob">
</person>
</relations>

28 / 51

Online Demo

Online Demo at: http://xsparql.deri.org/demo/

Try it for yourself!

29 / 51

XSPARQL Formal Semantics

Extend the XQuery semantics
Adding the normalisation, static type and dynamic evaluation
rules for the new expressions:
SPARQL for clause
construct clause

30 / 51

Formal semantics types

Newly deﬁned types
RDFTerm is the type of SPARQL variables, with the subtypes:
uri
bnode
literal

31 / 51


uri
bnode
literal
RDFGraph will be the type of construct expressions

31 / 51


uri
bnode
literal
RDFGraph will be the type of construct expressions
PatternSolution is a pair (variableName, RDFTerm)
representing SPARQL variable bindings

31 / 51

SPARQL for - Static Type Analysis

statEnv + varType(Variable 1 ⇒ RDFTerm;
··· ;
Variable n ⇒ RDFTerm
) ReturnExpr : Type 2
for $Variable 1 · · · $Variable n DatasetClause
statEnv where GroupGraphPattern SolutionModiﬁer
return ReturnExpr : Type 2 ∗

32 / 51


statEnv + varType(Variable 1 ⇒ RDFTerm;
$Variable 1 · · · $Variable n
··· ;
are of type RDFTerm Variable n ⇒ RDFTerm

32 / 51


∗ comes from
the sequence of
statEnv + varType(Variable 1 ⇒ RDFTerm; results
SPARQL
··· ;
Variable n ⇒ RDFTerm

32 / 51

Example: Simple SPARQL for

Simple SPARQL for example
for $s $p $o
from <foaf.rdf> where { $s $p $o }
return ($s, $p, $o)

33 / 51


For each SPARQL
result
for $s $p $o
from <foaf.rdf> where { $s $p $o }
return ($s, $p, $o)

33 / 51


For each SPARQL
result
Variables are as-
for $s $p $o
from <foaf.rdf> where { $s $p $o } signed values
return ($s, $p, $o)

33 / 51


For each SPARQL
result
Variables are as-
for $s $p $o
from <foaf.rdf> where { $s $p $o } signed values
return ($s, $p, $o)
Return expresion
is evaluated

33 / 51

SPARQL for - Dynamic Evaluation

dynEnv fs:sparql(DatasetClause, GroupGraphPattern,
SolutionModiﬁer ) ⇒ PS 1 , . . . , PS m
dynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 );
...;
Variable n ⇒ fs:value(PS 1 , Variable n )
) ReturnExpr ⇒ Value 1
.
.
.
dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 );
...;
Variable n ⇒ fs:value(PS m , Variable n )
) ReturnExpr ⇒ Value m
for $Variable 1 · · · $Variable n
dynEnv where GroupGraphPattern SolutionModiﬁer
return ReturnExpr ⇒ Value 1 , . . . , Value m

34 / 51


...;
The results of
the SPARQL ) ReturnExpr ⇒ Value 1
query .
.
.
...;

34 / 51


...;
The results of
the SPARQL ) ReturnExpr ⇒ Value 1
query .
.
.
...;
fs:sparql evaluates Variable n ⇒ fs:value(PS m , Variable n )
a SPARQL query ) ReturnExpr ⇒ Value m

34 / 51


...;
For each PS ) ReturnExpr ⇒ Value 1
add the values .
.
.
of the variables
to dynEnv ...;

34 / 51


fs:value selects
the value of SolutionModiﬁer ) ⇒ PS 1 , . . . , PS m
VariabledynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 );
i from
the PS ...;
For each PS ) ReturnExpr ⇒ Value 1
add the values .
.
.
of the variables
to dynEnv ...;

34 / 51


...;
) ReturnExpr ⇒ Value 1
.
.
.
The result dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 );
of
...;
the expression
is the sequence ) ReturnExpr ⇒ Value m
of computed
Value s

34 / 51

construct expressions

construct ConstructTemplate Expr
==
return fs:evalTemplate [ConstructTemplate ]normaliseTemplate

35 / 51


[·]normaliseTemplate ex-
]
pands any Turtle short-
construct ConstructTemplateits argument
cuts in
Expr
==

35 / 51


fs:evalTemplate vali-
dates the created triples
construct ConstructTemplate Expr
==

35 / 51

Implementation

36 / 51

Implementation

Each XSPARQL query is rewritten into an XQuery

36 / 51

Implementation

Each XSPARQL query is rewritten into an XQuery
SPARQLForClauses are translated into SPARQL SELECT
queries and executed using a SPARQL engine

36 / 51

Lifting: Rewriting to XQuery

for $p in $persons

37 / 51

Convert our relations data into RDF (partial)

Rewritten XQuery (and re-rewritten for presentation purposes)
for $k at $k_pos in $p/knows
let $kid := fn:index-of( $ids, $k )
return
let $_rdf8 := _xsparql:_binding_term( "_:b", $id, "", "" )
let $_rdf9 := _xsparql:_binding_term( "_:b", $kid, "", "" )
return _xsparql:_serialize((
if (_xsparql:_validSubject($_rdf8) and _xsparql:_validObject($_rdf9))
then
($_rdf8, " foaf:knows ", _xsparql:_rdf_term( $_rdf9 ), " .
")
else "")
) ) )

37 / 51

Convert our relations data into RDF (partial)

Rewritten XQuery (and re-rewritten for presentation purposes)
for $k at $k_pos in $p/knows
let $kid := fn:index-of( $ids, $k )
return
let $_rdf8 := _xsparql:_binding_term( "_:b", $id, "", "" )
let $_rdf9 := _xsparql:_binding_term( "_:b", $kid, "", "" )
return _xsparql:_serialize((
Create (_xsparql:_validSubject($_rdf8) and _xsparql:_validObject($_rdf9))
if variables of
then
type RDFTerm " foaf:knows ", _xsparql:_rdf_term( $_rdf9 ), " .
")
($_rdf8, for
eachelse "")
constructed
) ) )
term

37 / 51

XSPARQL Tutorial

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (7)

Ähnlich wie XSPARQL Tutorial

Ähnlich wie XSPARQL Tutorial (20)

Mehr von net2-project

Mehr von net2-project (10)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

XSPARQL Tutorial