NET   2 Transforming between RDF and      XML with XSPARQL           Net2 Tutorial            Nuno Lopes           Decembe...
Integration of Heterogeneous Sources                           1 / 51
Integration of Heterogeneous Sources                                       SPARQL                           1 / 51
Integration of Heterogeneous Sources                                       SPARQL                           1 / 51
Integration of Heterogeneous Sources      XSLT/XQuery                                       SPARQL                        ...
Integration of Heterogeneous Sources      XSLT/XQuery                           Lowering                                  ...
Integration of Heterogeneous Sources      XSLT/XQuery                                                         SPARQL   Tra...
Why are such transformations needed? (I)   Standards in Health Care and Life Sciences                                  2 /...
Why are such transformations needed? (I)   Standards in Health Care and Life Sciences                                  2 /...
Why are such transformations needed? (I)   Standards in Health Care and Life Sciences   Possible solution for the heteroge...
Why are such transformations needed? (II)   Creating (X)HTML from an RDF backend (under development):   http://musicpath.o...
Why are such transformations needed? (II)   Creating (X)HTML from an RDF backend (under development):   http://musicpath.o...
Why are such transformations needed? (II)   Creating (X)HTML from an RDF backend (under development):   http://musicpath.o...
Toy example for the tutorial                knows                   knows                        knows                    ...
Toy example for the tutorial                knows                   knows                        knows                    ...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why XQuery/XSLT is not enough:      Different syntaxes and serialisations for the same RDF graph:      @prefix alice: <alic...
Why SPARQL is not enough:         Great for querying RDF! Easy to output Turtle or         SPARQL XML results format ...  ...
Why SPARQL is not enough:         Great for querying RDF! Easy to output Turtle or         SPARQL XML results format ...  ...
XSPARQL          Transformation language          XML and RDF formats (based on          XQuery and SPARQL)               ...
XSPARQL          Transformation language          XML and RDF formats (based on          XQuery and SPARQL)          Lifti...
Outline   Overview
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 ...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
XPath        XPath is used to locate nodes in XML trees        An XPath expression is a sequence of steps separated by /. ...
XPath        XPath is used to locate nodes in XML trees        An XPath expression is a sequence of steps separated by /. ...
XPath        XPath is used to locate nodes in XML trees        An XPath expression is a sequence of steps separated by /. ...
XPath        XPath is used to locate nodes in XML trees        An XPath expression is a sequence of steps separated by /. ...
XPath Steps   Step examples    /relations      Selects the root element relations   relations.xml   <relations>       <per...
XPath Steps   Step examples    /relations          Selects the root element relations    /relations/person   Selects all p...
XPath Steps   Step examples    /relations          Selects the root element relations    /relations/person   Selects all p...
XPath Predicates   Predicate examples    /relations/person[3]          Selects the third person child of relations   relat...
XPath Predicates   Predicate examples    /relations/person[3]              Selects the third person child of relations    ...
XPath Predicates   Predicate examples    /relations/person[3]              Selects the third person child of relations    ...
XQuery  XQuery       Query language for XML (different requirements than XSLT)            functional language            ty...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery           Prolog:   P   declare namespace prefix="namespace-URI "           Body:     F   for var ...
Schematic view on XQuery            Prolog:   P   declare namespace prefix="namespace-URI "            Body:     F   for va...
Positional variable at   Query example: add an id attribute to the relations data   for $person at $pos in doc("relations....
Positional variable at   Query example: add an id attribute to the relations data   for $person at $pos in doc("relations....
XQuery Formal semantics   Normalisation rules   Normalisation rules are rewriting rules that translate XQuery into a   sim...
XQuery Formal semantics   Normalisation rules   Normalisation rules are rewriting rules that translate XQuery into a   sim...
XQuery Formal semantics   Normalisation rules   Normalisation rules are rewriting rules that translate XQuery into a   sim...
XQuery Formal semantics   Normalisation rules   Normalisation rules are rewriting rules that translate XQuery into a   sim...
Semantics - Normalisation rules example   for Example   for $i in (1, 2),       $j in (3, 4)   return     <pair>{ ($i,$j) ...
Semantics - Normalisation rules example   for Example   for $i in (1, 2),       $j in (3, 4)   return     <pair>{ ($i,$j) ...
Semantics - Normalisation rules example   For Normalisation                                                           ...
Semantics - Static typing example    For Static Type Analysis                         statEnv Expr 1 : Type 1           st...
Semantics - Static typing example                                                  : means Expr 1 is                      ...
Semantics - Static typing example       + means extend                               : means Expr 1 is       the environme...
Semantics - Static typing example       + means extend                               : means Expr 1 is       the environme...
Semantics - Dynamic evaluation rules   Simple for example   for $i in (1, 2) return $i+1                                  ...
Semantics - Dynamic evaluation rules                                            For each result in                        ...
Semantics - Dynamic evaluation rules                                            For each result in                        ...
Semantics - Dynamic evaluation rules                                            For each result in                        ...
Semantics - Dynamic evaluation rules   Simple for example   for $i in (1, 2) return $i+1   For Dynamic Evaluation (Simplifi...
Semantics - Dynamic evaluation rules   Simple for example   for $i in (1, 2) return $i+1                ⇒ means Expr 1 eva...
Semantics - Dynamic evaluation rules   Simple for example  For each Itemi2)add Variable   for $i in (1, , return $i+1     ...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
SPARQL (in 3 slides)   SPARQL      Query language for RDF             SPARQL spec: http://www.w3.org/TR/rdf-sparql-query/....
SPARQL (in 3 slides)   SPARQL      Query language for RDF      RDF represents data as triples: Subject, Predicate, Object....
SPARQL (in 3 slides)   SPARQL      Query language for RDF      RDF represents data as triples: Subject, Predicate, Object....
SPARQL (in 3 slides)   SPARQL      Query language for RDF      RDF represents data as triples: Subject, Predicate, Object....
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
Schematic view on SPARQL                 Prolog:   P   prefix prefix: <namespace-URI >                 Head:     C   constr...
SPARQL select solutions      Solutions for SPARQL select queries are substitutions for      the variables present in the h...
SPARQL select solutions       Solutions for SPARQL select queries are substitutions for       the variables present in the...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
XSPARQL          Transformation language          Consume and generate XML and RDF               22 / 51
XSPARQL          Transformation language          Consume and generate XML and RDF          Syntactic extension of XQuery ...
XSPARQL          Transformation language          Consume and generate XML and RDF          Syntactic extension of XQuery ...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
XSPARQL: Combining XQuery with SPARQL             Prolog:   P    declare namespace prefix="namespace-URI "                 ...
XSPARQL: Combining XQuery with SPARQL prefix         Prolog:   P    declare namespace prefix="namespace-URI " declarations ...
XSPARQL: Combining XQuery with SPARQL               Prolog:   P    declare namespace prefix="namespace-URI "               ...
XSPARQL: Combining XQuery with SPARQL               Prolog:   P    declare namespace prefix="namespace-URI "               ...
XSPARQL: Combining XQuery with SPARQL XQuery or      Prolog:   P    declare namespace prefix="namespace-URI " SPARQL       ...
XSPARQL: Combining XQuery with SPARQL              Prolog:   P    declare namespace prefix="namespace-URI "                ...
XSPARQL: Combining XQuery with SPARQL               Prolog:   P    declare namespace prefix="namespace-URI "               ...
XSPARQL: Combining XQuery with SPARQL               Prolog:   P    declare namespace prefix="namespace-URI "               ...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   f...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";    ...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";    ...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   f...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";    ...
Query Example - Lifting   Convert our relations data into RDF   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   f...
Nesting in construct clauses   Nesting operators       {Expr} The result of evaluating Expr will be an RDF literal        ...
Nesting in construct clauses   Nesting operators       {Expr} The result of evaluating Expr will be an RDF literal      :{...
Query Example - Lifting (II)   Convert our relations data into RDF    declare namespace foaf="http://xmlns.com/foaf/0.1/";...
Query Example - Lifting (II)   Convert our relations data into RDF    declare namespace foaf="http://xmlns.com/foaf/0.1/";...
Query Example - Lifting (II)   Convert our relations data into RDF    declare namespace foaf="http://xmlns.com/foaf/0.1/";...
Query Example - Lifting (II)   Convert our relations data into RDF    declare namespace foaf="http://xmlns.com/foaf/0.1/";...
Query Example - Lifting (II)   Convert our relations data into RDF    declare namespace foaf="http://xmlns.com/foaf/0.1/";...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering   Convert FOAF RDF data into XML   declare namespace foaf = "http://xmlns.com/foaf/0.1/";   <rela...
Query Example - Lowering result   Query result   <relations>      <person name="Alice">         <knows>Charles</knows>    ...
Online Demo         Online Demo at: http://xsparql.deri.org/demo/                      Try it for yourself!               ...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
XSPARQL Formal Semantics     Extend the XQuery semantics     Adding the normalisation, static type and dynamic evaluation ...
Formal semantics types   Newly defined types      RDFTerm is the type of SPARQL variables, with the subtypes:              ...
Formal semantics types   Newly defined types      RDFTerm is the type of SPARQL variables, with the subtypes:              ...
Formal semantics types   Newly defined types      RDFTerm is the type of SPARQL variables, with the subtypes:              ...
SPARQL for - Static Type Analysis              statEnv + varType(Variable 1 ⇒ RDFTerm;                                ··· ...
SPARQL for - Static Type Analysis                statEnv + varType(Variable 1 ⇒ RDFTerm;       $Variable 1 · · · $Variable...
SPARQL for - Static Type Analysis                                               ∗ comes from                              ...
Example: Simple SPARQL for  Simple SPARQL for example   for $s $p $o   from <foaf.rdf> where { $s $p $o }   return ($s, $p...
Example: Simple SPARQL for                                              For each SPARQL                                   ...
Example: Simple SPARQL for                                              For each SPARQL                                   ...
Example: Simple SPARQL for                                              For each SPARQL                                   ...
SPARQL for - Dynamic Evaluation         dynEnv   fs:sparql(DatasetClause, GroupGraphPattern,                            So...
SPARQL for - Dynamic Evaluation              dynEnv  fs:sparql(DatasetClause, GroupGraphPattern,                          ...
SPARQL for - Dynamic Evaluation              dynEnv  fs:sparql(DatasetClause, GroupGraphPattern,                          ...
SPARQL for - Dynamic Evaluation              dynEnv  fs:sparql(DatasetClause, GroupGraphPattern,                          ...
SPARQL for - Dynamic Evaluation    fs:value selects               dynEnv fs:sparql(DatasetClause, GroupGraphPattern,    th...
SPARQL for - Dynamic Evaluation              dynEnv  fs:sparql(DatasetClause, GroupGraphPattern,                          ...
SPARQL for - Dynamic Evaluation              dynEnv   fs:sparql(DatasetClause, GroupGraphPattern,                         ...
construct expressions                   construct ConstructTemplate       Expr                                ==      retu...
construct expressions                                      [·]normaliseTemplate ex-                                       ...
construct expressions      fs:evalTemplate vali-      dates the created triples                   construct ConstructTempl...
Outline   Overview   XPath & XQuery     XPath     XQuery     XQuery Semantics   SPARQL   XSPARQL     Syntax     Semantics ...
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...
Lifting: Rewriting to XQuery   Convert our relations data into RDF   declare namespace foaf="http://xmlns.com/foaf/0.1/"; ...
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
XSPARQL Tutorial
Upcoming SlideShare
Loading in...5
×

XSPARQL Tutorial

4,370

Published on

Published in: Education
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
4,370
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
25
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

XSPARQL Tutorial

  1. 1. NET 2 Transforming between RDF and XML with XSPARQL Net2 Tutorial Nuno Lopes December, 2010
  2. 2. Integration of Heterogeneous Sources 1 / 51
  3. 3. Integration of Heterogeneous Sources SPARQL 1 / 51
  4. 4. Integration of Heterogeneous Sources SPARQL 1 / 51
  5. 5. Integration of Heterogeneous Sources XSLT/XQuery SPARQL 1 / 51
  6. 6. Integration of Heterogeneous Sources XSLT/XQuery Lowering SPARQL Lifting Transformations between XML and RDF are not easy, mainly due to the heterogeneity of RDF/XML serialisations 1 / 51
  7. 7. Integration of Heterogeneous Sources 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
  8. 8. Why are such transformations needed? (I) Standards in Health Care and Life Sciences 2 / 51
  9. 9. Why are such transformations needed? (I) Standards in Health Care and Life Sciences 2 / 51
  10. 10. 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
  11. 11. Why are such transformations needed? (II) Creating (X)HTML from an RDF backend (under development): http://musicpath.org/ 3 / 51
  12. 12. Why are such transformations needed? (II) Creating (X)HTML from an RDF backend (under development): http://musicpath.org/ 3 / 51
  13. 13. Why are such transformations needed? (II) Creating (X)HTML from an RDF backend (under development): http://musicpath.org/ 3 / 51
  14. 14. Toy example for the tutorial knows knows knows 4 / 51
  15. 15. Toy example for the tutorial knows knows knows 4 / 51
  16. 16. Why XQuery/XSLT is not enough: Different 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
  17. 17. Why XQuery/XSLT is not enough: Different 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> rtle <foaf:knows> Tu _:b1 rdf:type foaf:Person; foaf:knows _:b2. <foaf:Person foaf:name="Bob"/> </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
  18. 18. Why XQuery/XSLT is not enough: Different syntaxes and serialisations for the same RDF graph: @prefix alice: <alice/> . <rdf:RDF xmlns:foaf="...foaf/0.1/"> Tri plele @prefix foaf: <...foaf/0.1/> . <foaf:Person> urt sto e <foaf:knows> _:b1 rdf:type foaf:Person;r T foaf:knows _:b2. <foaf:Person foaf:name="Bob"/> </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
  19. 19. Why XQuery/XSLT is not enough: Different syntaxes and serialisations for the same RDF graph: @prefix alice: <alice/> . Tri RD <rdf:RDF xmlns:foaf="...foaf/0.1/"> plele @prefix foaf: <...foaf/0.1/> . <foaf:Person> F/ XM urt sto e <foaf:knows> _:b1 rdf:type foaf:Person;r T foaf:knows _:b2. <foaf:Person foaf:name="Bob"/> </foaf:knows> L _: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/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: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
  20. 20. Why XQuery/XSLT is not enough: Different syntaxes and serialisations for the same RDF graph: @prefix alice: <alice/> . Tri RD <rdf:RDF xmlns:foaf="...foaf/0.1/"> plele @prefix foaf: <...foaf/0.1/> . <foaf:Person> F/ XM urt sto e <foaf:knows> _:b1 rdf:type foaf:Person;r T foaf:knows _:b2. <foaf:Person foaf:name="Bob"/> </foaf:knows> L _: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/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:type <foaf:name>Bob</foaf:name> Any transformation needs to take rdf:resource=".../Person"/> <foaf:name>Bob</foaf:name> </rdf:Description> <rdf:Description rdf:nodeID="y"> </rdf:Description> <rdf:type rdf:resource=".../Person"/> into account the different RDF/XML </rdf:RDF> </rdf:Description> </rdf:RDF> representations 5 / 51
  21. 21. Why XQuery/XSLT is not enough: Different syntaxes and serialisations for the same RDF graph: @prefix alice: <alice/> . Tri RD <rdf:RDF xmlns:foaf="...foaf/0.1/"> plele @prefix foaf: <...foaf/0.1/> . <foaf:Person> F/ XM urt sto e <foaf:knows> _:b1 rdf:type foaf:Person;r T foaf:knows _:b2. <foaf:Person foaf:name="Bob"/> </foaf:knows> L _: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/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:type <foaf:name>Bob</foaf:name> rdf:resource=".../Person"/> </rdf:Description> <foaf:name>Bob</foaf:name> <rdf:Description rdf:nodeID="y"> Or: end up with different transfor- </rdf:Description> </rdf:RDF> <rdf:type rdf:resource=".../Person"/> </rdf:Description> </rdf:RDF> mations for the same RDF data 5 / 51
  22. 22. 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
  23. 23. 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 How to produce arbitrary XML??? 6 / 51
  24. 24. XSPARQL Transformation language XML and RDF formats (based on XQuery and SPARQL) 7 / 51
  25. 25. XSPARQL Transformation language XML and RDF formats (based on XQuery and SPARQL) Lifting and Lowering in a single language 7 / 51
  26. 26. Outline Overview
  27. 27. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics
  28. 28. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL
  29. 29. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  30. 30. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  31. 31. 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"> <knows>Charles</knows> </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
  32. 32. 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> relations node <person name="Alice"> is the root ele- <knows>Bob</knows> <knows>Charles</knows> ment </person> <person name="Bob"> <knows>Charles</knows> </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
  33. 33. 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> 3 child elements </person> <person name="Bob"> person with at- <knows>Charles</knows> tribute name </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
  34. 34. 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"> <knows>Charles</knows> Each person el- </person> ement can have <person name="Charles"/> knows childs </relations> Full spec at http://www.w3.org/TR/xpath20/. Tutorial at http://www.w3schools.com/xpath/default.asp. 8 / 51
  35. 35. XPath Steps Step examples /relations Selects the root element relations relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 9 / 51
  36. 36. XPath Steps Step examples /relations Selects the root element relations /relations/person Selects all person elements that are children of relations relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 9 / 51
  37. 37. XPath Steps Step examples /relations Selects the root element relations /relations/person Selects all person elements that are children of relations //knows Selects all knows elements (in all the document) relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 9 / 51
  38. 38. XPath Predicates Predicate examples /relations/person[3] Selects the third person child of relations relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 10 / 51
  39. 39. XPath Predicates Predicate examples /relations/person[3] Selects the third person child of relations /relations/person[position()<3] Selects the first two person children of relations relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 10 / 51
  40. 40. XPath Predicates Predicate examples /relations/person[3] Selects the third person child of relations /relations/person[position()<3] Selects the first two person children of relations //person[@name=’Alice’] Selects all person elements which the value of the name attribute is ’Alice’ relations.xml <relations> <person name="Alice"> <knows>Bob</knows> <knows>Charles</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 10 / 51
  41. 41. XQuery XQuery Query language for XML (different 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
  42. 42. Schematic view on XQuery Prolog: P declare namespace prefix="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
  43. 43. Schematic view on XQuery Prolog: P declare namespace prefix="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
  44. 44. Schematic view on XQuery Prolog: P declare namespace prefix="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
  45. 45. Schematic view on XQuery Prolog: P declare namespace prefix="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
  46. 46. Schematic view on XQuery Prolog: P declare namespace prefix="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
  47. 47. Schematic view on XQuery Prolog: P declare namespace prefix="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
  48. 48. Schematic view on XQuery Prolog: P declare namespace prefix="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
  49. 49. Schematic view on XQuery Prolog: P declare namespace prefix="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
  50. 50. Schematic view on XQuery Prolog: P declare namespace prefix="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
  51. 51. Schematic view on XQuery Prolog: P declare namespace prefix="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 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
  52. 52. 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
  53. 53. 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> <knows>Charles</knows> </person> <person id="2" name="Bob"> <knows>Charles</knows> </person> <person id="3" name="Charles"/> 13 / 51
  54. 54. XQuery Formal semantics Normalisation rules Normalisation rules are rewriting rules that translate XQuery into a simplified version (XQuery Core). 14 / 51
  55. 55. XQuery Formal semantics Normalisation rules Normalisation rules are rewriting rules that translate XQuery into a simplified version (XQuery Core). Rule application 1 Static Analysis: Apply normalisation rules and static type analysis 2 Dynamic Evaluation Rules: evaluate expressions 14 / 51
  56. 56. XQuery Formal semantics Normalisation rules Normalisation rules are rewriting rules that translate XQuery into a simplified version (XQuery Core). Rule application 1 Static Analysis: Apply normalisation rules and static type analysis 2 Dynamic Evaluation Rules: evaluate expressions Environments statEnv contains information needed for performing static type analysis. E.g. varType, funcType, . . . 14 / 51
  57. 57. XQuery Formal semantics Normalisation rules Normalisation rules are rewriting rules that translate XQuery into a simplified version (XQuery Core). Rule application 1 Static Analysis: Apply normalisation rules and static type analysis 2 Dynamic Evaluation Rules: evaluate expressions 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
  58. 58. Semantics - Normalisation rules example for Example for $i in (1, 2), $j in (3, 4) return <pair>{ ($i,$j) }</pair> 15 / 51
  59. 59. Semantics - Normalisation rules example for Example for $i in (1, 2), $j in (3, 4) return <pair>{ ($i,$j) }</pair> for Normalised example for $i in (1, 2) return for $j in (3, 4) return <pair>{ ($i,$j) }</pair> 15 / 51
  60. 60. Semantics - Normalisation rules example 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
  61. 61. 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 · quantifier(Type 1 ) 17 / 51
  62. 62. Semantics - Static typing example : means Expr 1 is of type Type 1 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 · quantifier(Type 1 ) 17 / 51
  63. 63. Semantics - Static typing example + means extend : means Expr 1 is the environment of type Type 1 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 · quantifier(Type 1 ) 17 / 51
  64. 64. Semantics - Static typing example + means extend : means Expr 1 is the environment of type Type 1 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 · quantifier(Type 1 ) quantifier estimates the number of solutions: *, + or ? 17 / 51
  65. 65. Semantics - Dynamic evaluation rules Simple for example for $i in (1, 2) return $i+1 18 / 51
  66. 66. Semantics - Dynamic evaluation rules For each result in the expression Simple for example for $i in (1, 2) return $i+1 18 / 51
  67. 67. Semantics - Dynamic evaluation rules For each result in the expression Simple for example Variable $i is as- for $i in (1, 2) return $i+1 signed the corre- sponding value 18 / 51
  68. 68. Semantics - Dynamic evaluation rules For each result in the expression Simple for example Variable $i is as- for $i in (1, 2) return $i+1 signed the corre- sponding value Return expresion is evaluated 18 / 51
  69. 69. Semantics - Dynamic evaluation rules Simple for example for $i in (1, 2) return $i+1 For Dynamic Evaluation (Simplified) dynEnv Expr 1 ⇒ Item1 , . . . , Itemn dynEnv + varValue(Variable ⇒ Item1 ) Expr 2 ⇒ Value 1 ··· dynEnv + varValue(Variable ⇒ Itemn ) Expr 2 ⇒ Value n for $Variable in Expr 1 dynEnv return Expr 2 ⇒ Value 1 , · · · , Value n 18 / 51
  70. 70. Semantics - Dynamic evaluation rules Simple for example for $i in (1, 2) return $i+1 ⇒ means Expr 1 eval- uates to the sequence Item1 , . . . , Itemn For Dynamic Evaluation (Simplified) dynEnv Expr 1 ⇒ Item1 , . . . , Itemn dynEnv + varValue(Variable ⇒ Item1 ) Expr 2 ⇒ Value 1 ··· dynEnv + varValue(Variable ⇒ Itemn ) Expr 2 ⇒ Value n for $Variable in Expr 1 dynEnv return Expr 2 ⇒ Value 1 , · · · , Value n 18 / 51
  71. 71. Semantics - Dynamic evaluation rules 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 For Dynamic Evaluation (Simplified) dynEnv Expr 1 ⇒ Item1 , . . . , Itemn dynEnv + varValue(Variable ⇒ Item1 ) Expr 2 ⇒ Value 1 ··· dynEnv + varValue(Variable ⇒ Itemn ) Expr 2 ⇒ Value n for $Variable in Expr 1 dynEnv return Expr 2 ⇒ Value 1 , · · · , Value n 18 / 51
  72. 72. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  73. 73. 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
  74. 74. SPARQL (in 3 slides) SPARQL Query language for RDF RDF represents data as triples: Subject, Predicate, Object. An RDF Graph is a set of triples. SPARQL spec: http://www.w3.org/TR/rdf-sparql-query/. SPARQL 1.1 Tutorial: http://polleres.net/presentations/20101019SPARQL1.1Tutorial.pdf. 19 / 51
  75. 75. SPARQL (in 3 slides) SPARQL Query language for RDF RDF represents data as triples: Subject, Predicate, Object. An RDF Graph is a set of triples. SPARQL queries RDF data by pattern matching: given a set of triple patterns, finds the corresponding triples in the input graph SPARQL spec: http://www.w3.org/TR/rdf-sparql-query/. SPARQL 1.1 Tutorial: http://polleres.net/presentations/20101019SPARQL1.1Tutorial.pdf. 19 / 51
  76. 76. SPARQL (in 3 slides) SPARQL Query language for RDF RDF represents data as triples: Subject, Predicate, Object. An RDF Graph is a set of triples. SPARQL queries RDF data by pattern matching: given a set of triple patterns, finds 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. SPARQL spec: http://www.w3.org/TR/rdf-sparql-query/. SPARQL 1.1 Tutorial: http://polleres.net/presentations/20101019SPARQL1.1Tutorial.pdf. 19 / 51
  77. 77. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  78. 78. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  79. 79. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  80. 80. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  81. 81. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  82. 82. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  83. 83. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  84. 84. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies 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.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  85. 85. Schematic view on SPARQL Prolog: P prefix prefix: <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 different RDF vocabularies prefix vc: <http://www.w3.org/2001/vcard-rdf/3.0#> prefix foaf: <http://xmlns.com/foaf/0.1/> select $X $FN from <vCard.ttl> where { $X vc:FN $FN .} order by $FN limit 1 offset 1 20 / 51
  86. 86. SPARQL select solutions Solutions for SPARQL select queries are substitutions for the variables present in the head (variableList) 21 / 51
  87. 87. 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
  88. 88. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  89. 89. XSPARQL Transformation language Consume and generate XML and RDF 22 / 51
  90. 90. XSPARQL Transformation language Consume and generate XML and RDF Syntactic extension of XQuery 22 / 51
  91. 91. XSPARQL Transformation language Consume and generate XML and RDF Syntactic extension of XQuery With a formally defined semantics (based on the XQuery semantics) 22 / 51
  92. 92. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  93. 93. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI > Body: F for var in XPath-expression L let var := XPath-expression W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  94. 94. XSPARQL: Combining XQuery with SPARQL prefix Prolog: P declare namespace prefix="namespace-URI " declarations or prefix prefix: <namespace-URI > Body: F for var in XPath-expression L let var := XPath-expression W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  95. 95. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI >Data input Body: F for var in XPath-expression L let var := XPath-expression(XML or RDF) W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  96. 96. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI > Body: F for var in XPath-expression L let var := XPath-expression W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0Data output Head: C construct { template (with nested XSPARQL) } or(XML or RDF) R return XML + nested XSPARQL 23 / 51
  97. 97. XSPARQL: Combining XQuery with SPARQL XQuery or Prolog: P declare namespace prefix="namespace-URI " SPARQL or prefix prefix: <namespace-URI > prefix Body: F for var in XPath-expression L let var := XPath-expression declarations W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  98. 98. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI > Any XQuery Body: F for var in XPath-expression L let var := XPath-expression query W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  99. 99. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI > Body: F for var in XPath-expression L let var := XPath-expression W where XPath-expression O order by expression or SPARQLForClause F’ for varlist D from / from named <dataset-URI > represents a W where {pattern } SPARQL query M order by expression limit integer > 0 offset integer > 0 Head: C construct { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  100. 100. XSPARQL: Combining XQuery with SPARQL Prolog: P declare namespace prefix="namespace-URI " or prefix prefix: <namespace-URI > Body: F for var in XPath-expression L let var := XPath-expression W where XPath-expression O order by expression or F’ for varlist D from / from named <dataset-URI > W where {pattern } M order by expression limit integer > 0 construct offset integer > 0 creates RDF Head: C construct output { template (with nested XSPARQL) } or R return XML + nested XSPARQL 23 / 51
  101. 101. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; for $person in doc("relations.xml")//person, $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
  102. 102. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; XQuery for for $person in doc("relations.xml")//person, data selec- $nameA in $person/@name, $nameB in $person/knows tion construct { [ foaf:name {data($nameA)}; a foaf:Person ] foaf:knows [ foaf:name {data($nameB)}; a foaf:Person ]. } 24 / 51
  103. 103. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; construct for $person in doc("relations.xml")//person, clause gen- $nameA in $person/@name, erates RDF $nameB in $person/knows construct { [ foaf:name {data($nameA)}; a foaf:Person ] foaf:knows [ foaf:name {data($nameB)}; a foaf:Person ]. } 24 / 51
  104. 104. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; for $person in doc("relations.xml")//person, $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
  105. 105. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; Nesting produces for $person in doc("relations.xml")//person, $nameA in $person/@name, an RDF literal $nameB in $person/knows construct { [ foaf:name {data($nameA)}; a foaf:Person ] foaf:knows [ foaf:name {data($nameB)}; a foaf:Person ]. } 24 / 51
  106. 106. Query Example - Lifting Convert our relations data into RDF declare namespace foaf = "http://xmlns.com/foaf/0.1/"; for $person in doc("relations.xml")//person, $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 ]. } 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
  107. 107. Nesting in construct clauses Nesting operators {Expr} The result of evaluating Expr will be an RDF literal 25 / 51
  108. 108. 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
  109. 109. Query Example - Lifting (II) Convert our relations data into RDF 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
  110. 110. Query Example - Lifting (II) Convert our relations data into RDF declare namespace foaf="http://xmlns.com/foaf/0.1/"; let $persons := doc("relations.xml")//person let $ids := data($persons/@name) Keep person iden- for $p in $persons let $id := fn:index-of($ids, $p/@name) tifiers 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
  111. 111. Query Example - Lifting (II) Convert our relations data into RDF declare namespace foaf="http://xmlns.com/foaf/0.1/"; let $persons := doc("relations.xml")//person let $ids := data($persons/@name) For each person for $p in $persons let $id := fn:index-of($ids, $p/@name) lookup their id 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
  112. 112. Query Example - Lifting (II) Convert our relations data into RDF declare namespace foaf="http://xmlns.com/foaf/0.1/"; let $persons := doc("relations.xml")//person let $ids := data($persons/@name) The same for each for $p in $persons let $id := fn:index-of($ids, $p/@name) person then know 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
  113. 113. Query Example - Lifting (II) Convert our relations data into RDF 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} } } } 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
  114. 114. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <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
  115. 115. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> where { $Person foaf:name $Name } order by $Name XML con- return <person name="{$Name}"> { for $FName from <relations.rdf> struction where { $Person foaf:knows $Friend . $Person foaf:name $Name. $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  116. 116. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> where { $Person foaf:name $Name } SPARQL for order by $Name query: “Give me return <person name="{$Name}"> { for $FName from <relations.rdf> persons and their where { $Person foaf:knows $Friend . names” $Person foaf:name $Name. $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  117. 117. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> where { $Person foaf:name $Name } SPARQL for order by $Name query: “Give me return <person name="{$Name}"> { for $FName from <relations.rdf> persons and their SPARQL variables where { $Person foaf:knows $Friend . names” are $-prefixedfoaf:name $Name. $Person $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  118. 118. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> where { $Person foaf:name $Name } order by $Name XML con- return <person name="{$Name}"> { for $FName from <relations.rdf> struction where { $Person foaf:knows $Friend . $Person foaf:name $Name. $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  119. 119. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> SPARQL for where { $Person foaf:name $Name } query: “Give me order by $Name return <person name="{$Name}"> the persons each { for $FName from <relations.rdf> one knows” where { $Person foaf:knows $Friend . $Person foaf:name $Name. $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  120. 120. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> SPARQL for where { $Person foaf:name $Name } query: “Give me order by $Name return <person name="{$Name}"> the persons each { for $FName from <relations.rdf> one knows” where { $Person foaf:knows $Friend . $Person and $Person foaf:name $Name. $Friend foaf:name $FName. } $Name instanti- return <knows> { $FName }</knows>} ated by the outer </person>} </relations> loop 27 / 51
  121. 121. Query Example - Lowering Convert FOAF RDF data into XML declare namespace foaf = "http://xmlns.com/foaf/0.1/"; <relations> { for $Person $Name from <relations.rdf> where { $Person foaf:name $Name } order by $Name XML con- return <person name="{$Name}"> { for $FName from <relations.rdf> struction where { $Person foaf:knows $Friend . $Person foaf:name $Name. $Friend foaf:name $FName. } return <knows> { $FName }</knows>} </person>} </relations> 27 / 51
  122. 122. Query Example - Lowering result Query result <relations> <person name="Alice"> <knows>Charles</knows> <knows>Bob</knows> </person> <person name="Bob"> <knows>Charles</knows> </person> <person name="Charles"/> </relations> 28 / 51
  123. 123. Online Demo Online Demo at: http://xsparql.deri.org/demo/ Try it for yourself! 29 / 51
  124. 124. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  125. 125. 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
  126. 126. Formal semantics types Newly defined types RDFTerm is the type of SPARQL variables, with the subtypes: uri bnode literal 31 / 51
  127. 127. Formal semantics types Newly defined types RDFTerm is the type of SPARQL variables, with the subtypes: uri bnode literal RDFGraph will be the type of construct expressions 31 / 51
  128. 128. Formal semantics types Newly defined types RDFTerm is the type of SPARQL variables, with the subtypes: uri bnode literal RDFGraph will be the type of construct expressions PatternSolution is a pair (variableName, RDFTerm) representing SPARQL variable bindings 31 / 51
  129. 129. 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 SolutionModifier return ReturnExpr : Type 2 ∗ 32 / 51
  130. 130. SPARQL for - Static Type Analysis statEnv + varType(Variable 1 ⇒ RDFTerm; $Variable 1 · · · $Variable n ··· ; are of type RDFTerm Variable n ⇒ RDFTerm ) ReturnExpr : Type 2 for $Variable 1 · · · $Variable n DatasetClause statEnv where GroupGraphPattern SolutionModifier return ReturnExpr : Type 2 ∗ 32 / 51
  131. 131. SPARQL for - Static Type Analysis ∗ comes from the sequence of statEnv + varType(Variable 1 ⇒ RDFTerm; results SPARQL ··· ; Variable n ⇒ RDFTerm ) ReturnExpr : Type 2 for $Variable 1 · · · $Variable n DatasetClause statEnv where GroupGraphPattern SolutionModifier return ReturnExpr : Type 2 ∗ 32 / 51
  132. 132. 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
  133. 133. Example: Simple SPARQL for For each SPARQL result Simple SPARQL for example for $s $p $o from <foaf.rdf> where { $s $p $o } return ($s, $p, $o) 33 / 51
  134. 134. Example: Simple SPARQL for For each SPARQL result Simple SPARQL for example Variables are as- for $s $p $o from <foaf.rdf> where { $s $p $o } signed values return ($s, $p, $o) 33 / 51
  135. 135. Example: Simple SPARQL for For each SPARQL result Simple SPARQL for example 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
  136. 136. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ 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 SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  137. 137. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ PS 1 , . . . , PS m dynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 ); ...; The results of Variable n ⇒ fs:value(PS 1 , Variable n ) the SPARQL ) ReturnExpr ⇒ Value 1 query . . . 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 SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  138. 138. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ PS 1 , . . . , PS m dynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 ); ...; The results of Variable n ⇒ fs:value(PS 1 , Variable n ) the SPARQL ) ReturnExpr ⇒ Value 1 query . . . dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 ); ...; fs:sparql evaluates Variable n ⇒ fs:value(PS m , Variable n ) a SPARQL query ) ReturnExpr ⇒ Value m for $Variable 1 · · · $Variable n dynEnv where GroupGraphPattern SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  139. 139. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ PS 1 , . . . , PS m dynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 ); ...; Variable n ⇒ fs:value(PS 1 , Variable n ) For each PS ) ReturnExpr ⇒ Value 1 add the values . . . of the variables dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 ); to dynEnv ...; Variable n ⇒ fs:value(PS m , Variable n ) ) ReturnExpr ⇒ Value m for $Variable 1 · · · $Variable n dynEnv where GroupGraphPattern SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  140. 140. SPARQL for - Dynamic Evaluation fs:value selects dynEnv fs:sparql(DatasetClause, GroupGraphPattern, the value of SolutionModifier ) ⇒ PS 1 , . . . , PS m VariabledynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 ); i from the PS ...; Variable n ⇒ fs:value(PS 1 , Variable n ) For each PS ) ReturnExpr ⇒ Value 1 add the values . . . of the variables dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 ); to dynEnv ...; Variable n ⇒ fs:value(PS m , Variable n ) ) ReturnExpr ⇒ Value m for $Variable 1 · · · $Variable n dynEnv where GroupGraphPattern SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  141. 141. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ PS 1 , . . . , PS m dynEnv + varValue(Variable 1 ⇒ fs:value(PS 1 , Variable 1 ); ...; Variable n ⇒ fs:value(PS 1 , Variable n ) For each PS ) ReturnExpr ⇒ Value 1 add the values . . . of the variables dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 ); to dynEnv ...; Variable n ⇒ fs:value(PS m , Variable n ) ) ReturnExpr ⇒ Value m for $Variable 1 · · · $Variable n dynEnv where GroupGraphPattern SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  142. 142. SPARQL for - Dynamic Evaluation dynEnv fs:sparql(DatasetClause, GroupGraphPattern, SolutionModifier ) ⇒ 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 . . . The result dynEnv + varValue(Variable 1 ⇒ fs:value(PS m , Variable 1 ); of ...; the expression Variable n ⇒ fs:value(PS m , Variable n ) is the sequence ) ReturnExpr ⇒ Value m of computed for $Variable 1 · · · $Variable n Value s dynEnv where GroupGraphPattern SolutionModifier return ReturnExpr ⇒ Value 1 , . . . , Value m 34 / 51
  143. 143. construct expressions construct ConstructTemplate Expr == return fs:evalTemplate [ConstructTemplate ]normaliseTemplate 35 / 51
  144. 144. construct expressions [·]normaliseTemplate ex- ] pands any Turtle short- construct ConstructTemplateits argument cuts in Expr == return fs:evalTemplate [ConstructTemplate ]normaliseTemplate 35 / 51
  145. 145. construct expressions fs:evalTemplate vali- dates the created triples construct ConstructTemplate Expr == return fs:evalTemplate [ConstructTemplate ]normaliseTemplate 35 / 51
  146. 146. Outline Overview XPath & XQuery XPath XQuery XQuery Semantics SPARQL XSPARQL Syntax Semantics Implementation XSPARQL Features Query examples
  147. 147. Implementation 36 / 51
  148. 148. Implementation Each XSPARQL query is rewritten into an XQuery 36 / 51
  149. 149. Implementation Each XSPARQL query is rewritten into an XQuery SPARQLForClauses are translated into SPARQL SELECT queries and executed using a SPARQL engine 36 / 51
  150. 150. Lifting: Rewriting to XQuery Convert our relations data into RDF 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} } } } 37 / 51
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×