integrating heterogeneous data by extending semantic web standards

Integrating Heterogeneous Data by ExtendingSemantic Web Standards

Nuno Lopes

26 November, 2012

Data Integration: Pizza Delivery Company

Clients/ Ordersperson addressNuno Galway

Deliveries

Clients/ Orders

<address>Dublin</address>

</person>

How many pizzas were delivered toNuno’s home during his PhD?

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Deliveries

Clients/ Orders

</person>

From 2008 to 2012

1 / 24

Using Query Languages for Data Integration

SQLselect address from clients

where person = "Nuno"

SPARQLselect $lat $long

from <geonames.org/..>

where { $point geo:lat $lat;

geo:long $long }

XQueryfor $person in doc("eat.ie/..")

return $person//name

relation

solution sequence

sequence of items

2 / 24

geo:long $long }

relation

solution sequence

sequence of items

2 / 24

geo:long $long }

relation

solution sequence

sequence of items

2 / 24

geo:long $long }

relation

solution sequence

sequence of items

2 / 24

geo:long $long }

relation

solution sequence

sequence of items

2 / 24

geo:long $long }

relation

solution sequence

sequence of items

2 / 24

How to represent context information in RDF?

RDF triples:nuno :address :Galway .

:nuno :address :Dublin .

Domain vocabulary/ontology:address1 a :AddressRecord;

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

Reification:address1 rdf:type rdf:Statement

rdf:subject :nuno;

rdf:predicate :address ;

rdf:object :Dublin ;

:loc <http://eat.ie/> .

Named Graphs

3 / 24

:nuno :address :Dublin .Not enough!

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

rdf:subject :nuno;

Named Graphs

3 / 24

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

rdf:subject :nuno;

Named Graphs

3 / 24

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

rdf:subject :nuno;

Named Graphs

3 / 24

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

rdf:subject :nuno;

Named Graphs

3 / 24

:person :nuno;

:address :Galway;

:start "2008" ;

:end "2012" .

No definedsemantics!

rdf:subject :nuno;

No definedsemantics!

Named Graphs

3 / 24

Hypothesis and Research Questions

Hypothesis

Efficient data integration over heterogenous data sources can beachieved by

a combined query language that accesses heterogenous data inits original sources

optimisations for efficient query evaluation for this language

an RDF-based format with support for context information

Research Questions

How to design a query language that bridges the differentformats?

Can we reuse existing optimisations from other query languages?

How to adapt RDF and SPARQL for context information?

4 / 24

Hypothesis

Research Questions

4 / 24

Hypothesis

Research Questions

4 / 24

Hypothesis

Research Questions

4 / 24

Hypothesis

Research Questions

4 / 24

Hypothesis

Research Questions

4 / 24

Hypothesis

Research Questions

4 / 24

Outline and Contributions

XSPARQLSyntax & SemanticsImplementationEvaluation

[JoDS2012],[EPIA2011]

Annotated RDF(S)Annotated RDF(S)AnQL: Annotated SPARQLArchitecture

[AAAI2010],[ISWC2010],[JWS2012]

[JoDS2012],[EPIA2011]

[AAAI2010],[ISWC2010],[JWS2012]

[JoDS2012],[EPIA2011]

[AAAI2010],[ISWC2010],[JWS2012]

XSPARQL

SPA QLML

RTransformation language between RDB,XML, and RDF

Syntactic extension of XQuery

Semantics based on XQuery’s semantics

Why based on XQuery?

Expressive language

Use as scripting language

Arbitrary Nesting of expressions

5 / 24

XSPARQL

SPA QLML

Expressive language

5 / 24

XSPARQL

SPA QLML

Expressive language

5 / 24

XSPARQL

SPA QLML

Expressive language

5 / 24

XSPARQL

SPA QLML

Expressive language

5 / 24

Same Language for each Format

XSPARQLfor address as $address from clients

return $address

XSPARQLfor $lat $long from <geonames.org/..>

geo:long $long }

return $lat

for $person in doc("eat.ie/..")

for var in Expr

let var := Expr

where Expr

order by Expr

return Expr

for SelectSpecfrom RelationListwhere WhereSpecListreturn Expr

for varlistfrom DatasetClausewhere { pattern }return Expr

6 / 24

return $address

geo:long $long }

return $lat

for var in Expr

let var := Expr

where Expr

order by Expr

return Expr

6 / 24

return $address

geo:long $long }

return $lat

XSPARQLfor $person in doc("eat.ie/..")

for var in Expr

let var := Expr

where Expr

order by Expr

return Expr

6 / 24

return $address

geo:long $long }

return $lat

for var in Expr

let var := Expr

where Expr

order by Expr

return Expr

6 / 24

return $address

geo:long $long }

return $lat

for var in Expr

let var := Expr

where Expr

order by Expr

return Expr

6 / 24

Creating RDF with XSPARQL

Convert online orders into RDFprefix : <http://pizza-vocab.ie/>

for $person in doc("eat.ie/..")//name

construct { :meal a :FoodOrder; :author {$person} } construct

clause generatesRDF

Arbitrary XSPARQLexpressions in subject,predicate, and object

Query result@prefix : <http://pizza-vocab.ie/> .

:meal a :FoodOrder .

:meal :author "Nuno" .

7 / 24

clause generatesRDF

7 / 24

clause generatesRDF

7 / 24

clause generatesRDF

7 / 24

Integration Query Example

“Display pizza deliveries in Google Maps using KML”

for $person in doc("eat.ie/...")//name

for address as $address from clients

where person = $person

let $uri := fn:concat(

"api.geonames.org/search?q=", $address)

for $lat $long from $uri

where { $point geo:lat $lat; geo:long $long }

return <kml>

</kml>

More involved XSPARQL queries: RDB2RDF

Direct Mapping: ∼130 LOC

R2RML: ∼290 LOC

8 / 24

return <kml>

</kml>

R2RML: ∼290 LOC

8 / 24

return <kml>

</kml>

R2RML: ∼290 LOC

8 / 24

return <kml>

</kml>

R2RML: ∼290 LOC

8 / 24

return <kml>

</kml>

R2RML: ∼290 LOC

8 / 24

return <kml>

</kml>

R2RML: ∼290 LOC

8 / 24

Language Semantics

Extension of the XQuery Evaluation Semantics

for add variables and values to the dynamic environment

Reuse semantics of original languages for the new expressions

return <kml>

</kml>

dynEnv.varValue ⇒relation

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

dynEnv.varValue ⇒SPARQL sol. seq.

eval(SPARQL SELECT)

solutions compatible

dynEnv.varValue

dynEnv.globalPosition =(

Pos1, · · · , Pos j)

dynEnv ` fs:dataset(DatasetClause)⇒ Dataset

dynEnv ` fs:sparql

(Dataset ,WhereClause,SolutionModifier

)⇒ µ1 , . . . , µm

dynEnv + globalPosition((

Pos1, · · · , Pos j , 1))

+ activeDataset(Dataset)

+ varValue

Var1 ⇒ fs:value(µ1 , Var1

. . . ;Varn ⇒ fs:value

(µ1 , Varn

) ` ExprSingle⇒ Value1

Pos1, · · · , Pos j ,m))

+ varValue

Var1 ⇒ fs:value(µm, Var1

(µm, Varn

) ` ExprSingle⇒ Valuem

dynEnv `for $Var1 · · · $Varn DatasetClauseWhereClause SolutionModifierreturn ExprSingle

⇒ Value1, . . . , Valuem

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Semantics

return <kml>

</kml>

person”nuno”

eval(SQL SELECT)

on dynEnv.varValue

eval(SPARQL SELECT)

dynEnv.varValue

Pos1, · · · , Pos j)

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

Pos1, · · · , Pos j , 1))

+ varValue

(µ1 , Varn

Pos1, · · · , Pos j ,m))

+ varValue

(µm, Varn

dynEnv ` fs:sparql

)⇒ µ1 , . . . , µm

9 / 24

Language Implementation

Reuse components (SPARQL engine, Relational Database)

Implemented XSPARQL by rewriting to XQuery

Semantics implemented by substitution of bound variables

Bound Variable Substitution

Bound variables are replaced by their value at runtime

Implemented in the generated XQuery

Pushing the variable bindings into the respective query engine

where person = $personfn:concat(

"SELECT address from clients

where person = ", $person)

10 / 24

Implementation

XMLXML RDFRDF

QueryRewriter

XQueryquery

EnhancedXQueryengine

XSPARQLquery

XML RDFRDB

Custom XQuery func-tions implemented asJava methods

XQuerySQL SPARQL

XML /RDF

XSPARQL

11 / 24

Implementation

XMLXML RDFRDF

QueryRewriter

XQueryquery

XSPARQLquery

XML RDFRDB

XQuerySQL SPARQL

XML /RDF

XSPARQL

11 / 24

Implementation

XMLXML RDFRDF

QueryRewriter

XQueryquery

XSPARQLquery

XML RDFRDB

XQuerySQL SPARQL

XML /RDF

XSPARQL

11 / 24

Implementation

XMLXML RDFRDF

QueryRewriter

XQueryquery

XSPARQLquery

XML RDFRDB

XQuerySQL SPARQL

XML /RDF

XSPARQL

11 / 24

XSPARQL Evaluation

XMark XMarkRDF XMarkRDB

Experimental Results

Compared to native XQuery (XMark)

RDB and RDF: same order of magnitude for most queries

Except on RDF nested queries (self joining data)

several orders of magnitude slowerdue to the number of calls to the SPARQL engine

12 / 24

XSPARQL Evaluation

12 / 24

XSPARQL Evaluation

12 / 24

XSPARQL Evaluation

12 / 24

XSPARQL Evaluation

12 / 24

Rewriting techniques for Nested Queries

Q8: “List the names of persons and the number of items they bought.”

for $person $name from <input.rdf>

where { $person foaf:name $name }

return <item person="{$name}">

{count(

for * from <input.rdf>

where { $ca :buyer $person .}

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

"SELECT * from <input.rdf>

where { $ca :buyer ", $person,

" .}")

let $aux := sparqlQuery(

fn:concat(

where { $ca :buyer $person .}" )

Join in XQuery

Nested Loop rewriting

fn:concat(

Applied to related language:SPARQL2XQuery [SAC2008]Other optimisations:Join in SPARQL

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

{count(

return $ca

</item>

Returns

nuno,axel,

sparqlQuery(

fn:concat(

" .}")

fn:concat(

Join in XQuery

fn:concat(

13 / 24

Evaluation of different rewritings - XMarkRDFQ8

1 2 5 10 20 50 100

102XSPARQLRDF

Nested Loop

SPARQL rewrite

Dataset size in MB (log scale)

Optimised rewritings show promising results

Best Results: SPARQL-based

Results included in [JoDS2012]

14 / 24

Evaluation of different rewritings - XMarkRDBQ8

1 2 5 10 20 50 100

XSPARQLRDB

Nested Loop

Dataset size in MB (log scale)

Not so effective for RDB, requires different optimisations

Due to schema representation?

Additional Results for this thesis

15 / 24

Clients/ Orders

Deliveries

Clients/ Orders

SPA QLML

person addressNuno Galway

</person>

From 2008 to 2012

16 / 24

Clients/ Orders

Deliveries

Clients/ Orders

SPA QLML

person addressNuno Galway

</person>

From 2008 to 2012

16 / 24

Use Annotated RDF(S)!

Annotations refer to a specific domain

Temporal:

:nuno :address :Galway . [2008,2012]

Fuzzy:

:nuno :address :Dublin . 0.9

Provenance:

:nuno :address :Dublin . <http://eat.ie>

Representation for the values of each annotation domain

17 / 24

Temporal:

Fuzzy:

Provenance:

17 / 24

Temporal:

Fuzzy:

Provenance:

17 / 24

Temporal:

Fuzzy:

Provenance:

17 / 24

Temporal:

Fuzzy:

Provenance:

17 / 24

Annotated RDF(S) Inference example

Inference rules are independent of the annotation domain

RDFS subPropertyOf (“sp”) rule:

?Prop1 sp ?Prop2 .

?x ?Prop1 ?y .

⇒ ?x ?Prop2 ?y .

:address sp foaf:based near .

:nuno :address :Galway .

⇒ :nuno foaf:based near :Galway .

Extra rule to group annotations triples (⊕):

:nuno :address :Galway . [2009,+∞]

18 / 24

RDFS subPropertyOf (“sp”) rule:

?Prop1 sp ?Prop2 .

?x ?Prop1 ?y .

⇒ ?x ?Prop2 ?y .

:address sp foaf:based near .

:nuno :address :Galway .

18 / 24

Annotated RDFS subPropertyOf (“sp”) rule:

?Prop1 sp ?Prop2 . ?v1?x ?Prop1 ?y . ?v2

⇒ ?x ?Prop2 ?y .

:address sp foaf:based near . [2009,+∞]

18 / 24

⇒ ?x ?Prop2 ?y . ?v1 ⊗ ?v2

⇒ :nuno foaf:based near :Galway . [2009,+∞]⊗[2008,2012]

18 / 24

⇒ ?x ?Prop2 ?y . ?v1 ⊗ ?v2

18 / 24

⇒ ?x ?Prop2 ?y . ?v1 ⊗ ?v2

⇒ :nuno :address :Galway . [2009,+∞]⊕[2008,2012]

18 / 24

⇒ ?x ?Prop2 ?y . ?v1 ⊗ ?v2

⇒ :nuno :address :Galway . [2009,+∞]⊕[2008,2012]

18 / 24

Operations on Annotations Elements

[−∞,+∞]

[2008,+∞]

[2009,+∞]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2009,+∞]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2009,+∞]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2009,+∞]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2009,+∞]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2000, 2005]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2008,+∞]

[2000, 2005]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

[2000, 2005], [2008, 2012]

[2000, 2005]

[2008, 2012]

[2009, 2012]

⊕⊕

19 / 24

[−∞,+∞]

{[2000, 2005], [2008, 2012]}

{[2000, 2005]} {[2008, 2012]}

{[2009, 2012]}

⊕⊕

19 / 24

AnQL: Annotated SPARQL

Extension of SPARQL Syntax

triple pattern

annotated triple pattern is a triple pattern plus

annotation termannotation variable

Basic Annotated Patterns (BAP) are sets of annotated triplepatterns

Example?person a foaf:Person .

Combine BAPs using AND(.), OPTIONAL, UNION, FILTER

20 / 24

triple pattern

annotation term

annotation variable

Example

?person a foaf:Person . [−∞, +∞]

20 / 24

triple pattern

annotation term; orannotation variable

Example

?person a foaf:Person .

?person :address ?address . ?l

20 / 24

triple pattern

Example

{ ?person a foaf:Person . [−∞, +∞]

20 / 24

triple pattern

Example

{ ?person a foaf:Person . [−∞, +∞]

20 / 24

Evaluation of SPARQL OPTIONALs

“List my address, time interval and optionally people living in the samecity at the same time.”

SELECT ?city ?t ?person

WHERE { :nuno :address ?city . ?t

OPTIONAL { ?person :address ?city . ?t } }

Sample input:

:nuno :address :Galway . [2008, 2012]:axel :address :Galway . [2005, 2010]

Answers:

S1 = {?city → :Galway, ?t → [2008, 2012]}S2 = {?city → :Galway, ?t → [2008, 2010], ?person→ :axel}

OPTIONAL provide more information maybe restricting annotation values

21 / 24

Sample input:

Answers:

S1 = {?city → :Galway, ?t → [2008, 2012]}

S2 = {?city → :Galway, ?t → [2008, 2010], ?person→ :axel}

21 / 24

Sample input:

Answers:

21 / 24

Sample input:

Answers:

21 / 24

Annotated RDF(S) Domains

Temporal:

Fuzzy:

:nuno :address :Galway . 0.9

Provenance:

:nuno :address :Dublin . http://eat.ie

Combining domains: Included in [JWS2012]

:nuno :address :Dublin . (http://eat.ie, [2012,2012])

Access Control: Presented at [ICLP2012]

:nuno :address :Galway . [nl]

22 / 24

Temporal:

Fuzzy:

Provenance:

22 / 24

Temporal:

Fuzzy:

Provenance:

22 / 24

Architecture combining XSPARQL and AnQL

AnnotatedRDF

ReasonerAccessControl

FuzzyTemporal

Prove-nance

Domains

CustomRules

RDFS(ρdf)

Annotated RDFS

AnQLQuery

AnnotatedRDF

XSPARQL

Data convertedto RDF usingXSPARQL

Implementation inSWI Prolog

Each domain is adifferent Prologmodule

Rules specified asProlog predicates

23 / 24

AnnotatedRDF

FuzzyTemporal

Prove-nance

Domains

CustomRules

RDFS(ρdf)

Annotated RDFS

AnQLQuery

AnnotatedRDF

XSPARQL

23 / 24

AnnotatedRDF

FuzzyTemporal

Prove-nance

Domains

CustomRules

RDFS(ρdf)

Annotated RDFS

AnQLQuery

AnnotatedRDF

XSPARQL

23 / 24

AnnotatedRDF

FuzzyTemporal

Prove-nance

Domains

CustomRules

RDFS(ρdf)

Annotated RDFS

AnQLQuery

AnnotatedRDF

XSPARQL

23 / 24

AnnotatedRDF

FuzzyTemporal

Prove-nance

Domains

CustomRules

RDFS(ρdf)

Annotated RDFS

AnQLQuery

AnnotatedRDF

XSPARQL

23 / 24

Conclusions

1 a combined query language that accesses heterogenous data inits original sources

XSPARQL can integrate heterogeneous sources

2 optimisations for efficient query evaluation for this language

rewriting techniques for nested queries for our implementation ofXSPARQL

3 an RDF-based format with support for context information

Annotated RDFS: inferences and query over context informationUse XSPARQL to create Annotated RDF representing theintegrated data

Thank you! Questions?

24 / 24

Conclusions

Efficient data integration over heterogenous data sources can beachieved by1 a combined query language that accesses heterogenous data in

its original sources

24 / 24

Conclusions

24 / 24

Conclusions

24 / 24

Conclusions

24 / 24

Conclusions

24 / 24

Bibliography I

Stefan Bischof, Stefan Decker, Thomas Krennwallner, NunoLopes, and Axel Polleres.Mapping between RDF and XML with XSPARQL.Journal on Data Semantics, 1:147–185, 2012.

Sven Groppe, Jinghua Groppe, Volker Linnemann, DirkKukulenz, Nils Hoeller, and Christoph Reinke.Embedding SPARQL into XQuery/XSLT.In Roger L. Wainwright and Hisham Haddad, editors,Proceedings of the 2008 ACM Symposium on AppliedComputing (SAC), Fortaleza, Ceara, Brazil, March 16-20,2008, pages 2271–2278. ACM, 2008.

Bibliography II

Nuno Lopes, Stefan Bischof, Stefan Decker, and Axel Polleres.On the Semantics of Heterogeneous Querying of Relational,XML and RDF Data with XSPARQL.In Paulo Moura and Vitor Beires Nogueira, editors,Proceedings of the 15th Portuguese Conference on ArtificialIntelligence (EPIA2011) – Computational Logic withApplications Track, Lisbon, Portugal, October 2011.

Nuno Lopes, Sabrina Kirrane, Antoine Zimmermann, AxelPolleres, and Alessandra Mileo.A Logic Programming approach for Access Control over RDF.In Agostino Dovier and Vıtor Santos Costa, editors, TechnicalCommunications of the 28th International Conference on LogicProgramming (ICLP’12), volume 17 of Leibniz InternationalProceedings in Informatics (LIPIcs), pages 381–392, Dagstuhl,

Bibliography III

Germany, 2012. Schloss Dagstuhl–Leibniz-Zentrum fuerInformatik.

Nuno Lopes, Axel Polleres, Umberto Straccia, and AntoineZimmermann.AnQL: SPARQLing Up Annotated RDFS.In International Semantic Web Conference (1), pages 518–533,2010.

Umberto Straccia, Nuno Lopes, Gergely Lukacsy, and AxelPolleres.A General Framework for Representing and Reasoning withAnnotated Semantic Web Data.In Maria Fox and David Poole, editors, Proceedings of theTwenty-Fourth AAAI Conference on Artificial Intelligence,AAAI 2010, Atlanta, Georgia, USA, July 11-15, 2010. AAAIPress, July 2010.

Bibliography IV

Antoine Zimmermann, Nuno Lopes, Axel Polleres, andUmberto Straccia.A General Framework for Representing, Reasoning andQuerying with Annotated Semantic Web Data.Web Semantics: Science, Services and Agents on the WorldWide Web, 11(0):72–95, 2012.

integrating heterogeneous data by extending semantic web standards

Technology