Introduction to query rewriting optimisation with dependencies

Dependencies
Making Ontology Based Data Access Work in Practice
Mariano Rodriguez-Muro and Diego Calvanese
{rodriguez,calvanese}@inf.unibz.it
KRDB Research Centre
Free University of Bozen Bolzano
July, 2011
Rodriguez-Muro and Calvanese (UNIBZ) APEX-Shanghai, 2011 July, 2011 1 / 33

The context

DL Ontologies
Description Logics:
• Formalisms for knowledge representation.
• Decidable fragments of FOL
• Base of OWL
• World is described by means of Concepts and Roles

DL Ontologies
Description Logics:
• Formalisms for knowledge representation.
• Decidable fragments of FOL
• Base of OWL
• World is described by means of Concepts and Roles
Ontologies
• Intentional knowledge: TBox T .
• Extensional knowledge: ABox A.

OBDA with DL-Lite
A family of light-weight ontology languages

OBDA with DL-Lite
• DL-LiteF concepts
B := A | ∃R

OBDA with DL-Lite
B := A | ∃R
• DL-LiteF roles
R := P | P−

OBDA with DL-Lite
B := A | ∃R
• DL-LiteF roles
R := P | P−
• DL-LiteF TBoxes
B B | B ¬B | (funct R)

Query Answering

Query Answering
TBox:
Man Person, Woman Person, Person ∃hasFather,
∃hasFather−
Person
ABox:
Man(mariano)
Queries:
q(x) ← Person(x), hasFather(x, y), Person(y)

Query Answering
TBox:
∃hasFather−
Person
ABox:
Man(mariano)
Queries:
Problem: Compute the certain answers of Q, denoted cert(Q, O).

Query Answering
TBox:
∃hasFather−
Person
ABox:
Man(mariano)
Queries:
Problem: Compute the certain answers of Q, denoted cert(Q, O).
The promise
We can do this as eﬃciently as answering DB queries, also in the virtual
setting.

Query Answering with PerfectRef (2005)

Query:

Query:
Reformulation:
q(x) ← Person(x), hasFather(x, y), hasFather(z, y)
q(x) ← Person(x), hasFather(x, y)
q(x) ← Person(x), Person(x)
q(x) ← Person(x)
q(x) ← Person(x), hasFather(x, y), Man(y)
q(x) ← Person(x), hasFather(x, y), Woman(y)
q(x) ← hasFather(x, m), hasFather(x, y), Person(y)
q(x) ← hasFather(x, m), hasFather(x, y), hasFather(z, y)
q(x) ← hasFather(x, m), hasFather(x, y)
q(x) ← hasFather(x, m), Person(x)
q(x) ← hasFather(x, m), hasFather(x, t)
q(x) ← hasFather(x, m)
q(x) ← hasFather(x, m), hasFather(x, y), Man(y)Rodriguez-Muro and Calvanese (UNIBZ) APEX-Shanghai, 2011 July, 2011 6 / 33

Alternatives

Alternatives
• Improved version of PerfectRef (2007-2011)
• RQR (Urbina et, al. 2007)

Alternatives
Too many unions, cannot execute!.

Alternatives
• PRESTO (Rosati et al., 2010)

Alternatives
Better, eventually it breaks.

Alternatives
• Combined Approach (Kontchakov et. al., 2010)

Alternatives
• Combined Approach (Kontchakov et. al., 2010)
Fast. But too much data and too much time.

What can we do?
?

Query Answering
It is not only about existential constants
Query:
q(x, y) ← Person(x), hasFather(x, y), Person(y)

Query Answering
It is not only about existential constants
Query:
Reformulation:
q(x, y) ← Person(x), hasFather(x, y), hasFather(z, y)
q(x, y) ← Person(x), hasFather(x, y), Man(y)
q(x, y) ← Person(x), hasFather(x, y), Woman(y)
q(x, y) ← hasFather(x, m), hasFather(x, y), Person(y)
q(x, y) ← hasFather(x, m), hasFather(x, y), hasFather(z, y)
q(x, y) ← hasFather(x, m), hasFather(x, y), Man(y)
q(x, y) ← hasFather(x, m), hasFather(x, y), Woman(y)
q(x, y) ← Man(x), hasFather(x, y), Person(y)
q(x, y) ← Man(x), hasFather(x, y), hasFather(z, y)
q(x, y) ← Man(x), hasFather(x, y), Man(y)
q(x, y) ← Man(x), hasFather(x, y), Woman(y)
q(x, y) ← Woman(x), hasFather(x, y), Person(y)

The full picture: Ontology Based Data
Access
SourceUser Source
User
Queries
Ontology
Mappings
Source
To deal with OBDA we need to consider:
• If in the backend we have RDBMSs, we cannot go beyond their
capabilities.
• All systems are composed by T , D = R, I , M.

First Observation
Is my data complete?

First Observation
Completeness of A
The TBox sais: Manager Employee

First Observation
Completeness of A
In the ABox: all Managers are already employees.

First Observation
Completeness of A
In any realistic scenario:

First Observation
Completeness of A
• We don’t use arbitrary sources;

First Observation
Completeness of A
• Intersection of semantics is reﬂected in completeness (e.g., no need to
chase, expand or rewrite)

First Observation
Completeness of A
• This happens a lot!

First Observation
Completeness of A
• This happens a lot!
Keyword
Redundancy

Second Observation
There are no ABoxes
THERE ARE NO ABOXES!

Second Observation
There are no ABoxes
THERE ARE NO ABOXES!
Any Ontology based query answering systems today:
• Uses relational DBs to store the ABox data;
• In such D, both, R and I can be manipulated;
• Implementors may choose any M for their system;
Opportunity
To complete an ABox we can do more than expansion.

How to approach the problem
Two level approach

Two level approach
How to approach OBDA in practice?

Two level approach
• Eﬃcient ways to deal with redundancy due to completeness.

Two level approach
• Eﬃcient ways to deal with redundancy due to completeness.
• Eﬃcient ways to complete (virtual) ABoxes.

Contributions
Dealing with redundancy

Characterizing completeness
ABox Dependencies
Deﬁnition
An assertion B A B that restricts valid ABoxes.
Syntax B2 A B2
Semantics: A |= Manager A Employee if Manager(x)∈ A implies
Employee(x)∈ A.

Characterizing completeness
ABox Dependencies
Deﬁnition
An assertion B A B that restricts valid ABoxes.
Syntax B2 A B2
Semantics: A |= Manager A Employee if Manager(x)∈ A implies
Employee(x)∈ A.
ABox dependencies are fundamentally diﬀerent than TBox assertions.
Think open world

Where to deal with redundancy?
Given a TBox T , an ABox A, a set of dependencies Σ and a query Q,
what do we do?

what do we do?
Available Options:

what do we do?
Available Options:
• Optimize the query reformulation algorithm to deal with Σ.

what do we do?
Available Options:
• Optimize the query reformulation algorithm to deal with Σ.
• Optimize the TBox T with respect to Σ.

When is an assertion redundant?

Direct Redundancy: Case 1
Let T be implied the following
hierarchy:
∃hasFather
Person
Human

hierarchy:
∃hasFather
Person
Human
Redundant if Σ is:
∃hasFather
Person
Human

hierarchy:
∃hasFather
Person
Human
Redundant if Σ is:
∃hasFather
Person
Human
Σ sais hasFather(mariano, ramon) ∈ A → Human(mariano) ∈ A.

Let T be the following TBox:
Person
∃hasFather−
∃hasFather
Man

Person
∃hasFather−
∃hasFather
Man
Redundant if Σ is:
Person
∃hasFather−
∃hasFather
Man

Person
∃hasFather−
∃hasFather
Man
Redundant if Σ is:
Person
∃hasFather−
∃hasFather
Man
Σ sais Man(ramon) ∈ A → ∃a | hasFather(ramon, a ) ∧ Person(a ) ∈ A.

Indirect Redundancy

Indirect Redundancy
Animal
Man Human

Indirect Redundancy
Animal
Man Human
Redundant if Σ is:
Animal
Man Human

Indirect Redundancy
Animal
Man Human
Redundant if Σ is:
Animal
Man Human
Σ sais Man(mariano) ∈ A then Animal(mariano) ∈ A.

Formalization: Redundancy
Given a TBox T and a set of dependencies Σ over T , the optimized version
of T w.r.t. Σ, denoted optim(T , Σ), is the set of inclusion assertions
{α ∈ sat(T ) | α is not redundant in sat(T ) w.r.t. sat(Σ)}
We can compute optim(T , Σ) in linear time.

Contributions
Completing ABoxes

General considerations
OBDA systems have no ABoxes, instead virtual ABoxes V = D, M with
D = R, I .

D = R, I .
If we that V |= A A B, we check make sure that mappings for B include
all the data coming from the mappings of A.

D = R, I .
Trade-oﬀ:
• Degree of completeness (# of dependencies),
• Cost of the procedure
• Performance of Query answering.

D = R, I .
Trade-oﬀ:
• Degree of completeness (# of dependencies),
• Cost of the procedure
• Performance of Query answering.
We can complete virtual ABoxes up to B ∃R without the need for new
data.

Semantic Index for OBDA
General Idea

General Idea
• To encode the semantics of T in numeric indexes and ranges for
concept names and roles.

General Idea
• Store the ABox in the database using those indexes and ranges.

General Idea
• Make mappings for the system that take the ranges into account.

General Idea
• Make mappings for the system that take the ranges into account.
We can do this by using the implied hierarchy of T to generate the index
and ranges!

Semantic Index Example
T = {B A, C A, C D}

T = {B A, C A, C D}
A
B C
D

T = {B A, C A, C D}
1
A
B
2
C
3
4
D

T = {B A, C A, C D}
1
A
B
2
C
3
4
D
We create a table TC with constant and idx columns. To insert the data
we use the indexes. e.g., B(mariano) ∈ A then we put (mariano, 2) ∈ TC

T = {B A, C A, C D}
1, {(1, 3)}
A
B
2, {(2, 2)}
C
3, {(3, 3)}
4, {(3, 4)}
D

T = {B A, C A, C D}
1, {(1, 3)}
A
B
2, {(2, 2)}
C
3, {(3, 3)}
4, {(3, 4)}
D
We create the mappings using the ranges, e.g., SELECT constant
FROM TC WHERE IDX ≥ 1 AND IDX ≤ 3; A(constant)

Experimentation I
The Resource Index features:
• Search over 22 document collections
• Semantics given by the hierarchies of 200 ontologies (SNOMED, GO)
Implementation in a nutshell:
(i) Understand documents with natural language processing and
annotate
Cervical Cancer( doc224 )
(ii) Expand the ABox
(iii) Pose queries that retrieve documents as
q(x) ← A1(x) ∧ · · · ∧ An(x)

Experimentation II
The challenge:
• ≈ 3 million concepts and ≈ 2.5 million is-a assertions
• Split second responses
• 150 GB of data
• Expansion data: 1.5 TB
The experimentation data:
• Clinical Trials.gov (CT)
• 181 million assertion (≈ 14 GB of data, ≈ 140 GB when expanded.)

Results
The query:
q(x) ← DNA Repair Gene(x) ∧ Antigen Gene(x) ∧ Cancer Gene(x)

Results
The query:
Results:
• Traditional reformulation: Union of 467874 SQL SPJ queries;
• Semantic Index: 1 SQL; execution 3.582s (0.082s if warm); Time
to compute semantic index: 1 min; Size of data: +≈ 4 GB.
• ABox expansion: 1 SQL; executing 3s (0.6s if warm); Expansion
time ≈ 7 days; Size of data +≈ 126 GB.

The Query
The query:
SELECT DISTINCT r0.element_id as element_id
FROM
RESOURCE_INDEX.CT_ANN r0 JOIN RESOURCE_INDEX.CT_ANN r1
ON r0.element_id = r1.element_id
JOIN RESOURCE_INDEX.CT_ANN r2
ON r1.element_id = r2.element_id
WHERE
((r0.idx >= 1783559 AND r0.idx <= 1783657)) AND
((r1.idx >= 1782996 AND r1.idx <= 1783029)) AND
((r2.idx >= 1783115 AND r2.idx <= 1783253));
Standard SQL query eﬃcient in ANY DBMS.

Conclusions
Contributions
• We indicated that eﬃcient OBDA requires to take into account more
than only T , A and Q.
• Provided means to deal with redundancy at the level of the TBox.
• We showed that expansion is not necessary that we can complete
ABoxes.
• We presented to eﬃcient ways to complete ABoxes, one for the
general OBDA setting and one for the virtual setting.

Conclusions
Contributions
• We indicated that eﬃcient OBDA requires to take into account more
than only T , A and Q.
• Provided means to deal with redundancy at the level of the TBox.
• We showed that expansion is not necessary that we can complete
ABoxes.
• We presented to eﬃcient ways to complete ABoxes, one for the
general OBDA setting and one for the virtual setting.
Future work
• Exploring more expressive languages.
• Exploring the RDFS/SPARQL setting.
• Handling updates of T and A.

Extra examples

First Observation (cont.)
Mappings will introduce dependencies over ABoxes

Let R be a DB schema with the relation schema employee with attributes
id, dept, and salary. Let M be the following mappings:
SELECT id,dept FROM employee ;q(id, dept) ← Employee(id) ∧
WORKS-FOR(id, dept)
SELECT id,dept FROM employee
WHERE salary > 1000
;q(id, dept) ← Manager(id)∧
MANAGES(id, dept)
Then for any instance I, if Manager(John) ∈ A we have that
Employee(John).

Let R be a DB schema with the relation schema employee with attributes
id, dept, and salary. Let M be the following mappings:
SELECT id,dept FROM employee ;q(id, dept) ← Employee(id) ∧
WORKS-FOR(id, dept)
SELECT id,dept FROM employee
WHERE salary > 1000
;q(id, dept) ← Manager(id)∧
MANAGES(id, dept)
Then for any instance I, if Manager(John) ∈ A we have that
Employee(John).
This is an indicator of completeness of all ABoxes A for M and R, e.g., A
is complete w.r.t. Manager A Employee.

Formalization: Chains
Let T be a TBox, B, C basic concepts, and Σ a set of dependencies over
T . A T -chain from B to C in T (resp., a Σ-chain from B to C in Σ) is a
sequence of concept inclusion assertions (Bi Bi )n
i=0 in T (resp., a
sequence of inclusion dependencies (Bi A Bi )n
i=0 in Σ), for some n ≥ 0,
such that:
1 B0 = B, Bn = C, and
2 for 1 ≤ i ≤ n, we have that Bi−1 and Bi are basic concepts s.t., either
(i) Bi−1 = Bi , or
(ii) Bi−1 = ∃R and Bi = ∃R−
, for some basic role R.

Formalization: Redundancy
Let T be a TBox, B, C basic concepts, and Σ a set of dependencies. The
concept inclusion assertion B C is directly redundant in T w.r.t. Σ if
(i) Σ |= B A C and
(ii) for every T -chain (Bi Bi )n
i=0 with Bn = B in T , there is a Σ-chain
(Bi A Bi )n
i=0.
Then, B C is redundant in T w.r.t. Σ if
(a) it is directly redundant, or
(b) there exists B = B s.t.
(i) T |= B C,
(ii) B C is not redundant in T w.r.t. Σ, and
(iii) B B is directly redundant in T w.r.t. Σ.

Introduction to query rewriting optimisation with dependencies

More Related Content

Viewers also liked (12)

Similar to Introduction to query rewriting optimisation with dependencies (20)

More from Mariano Rodriguez-Muro (20)

Recently uploaded (20)

Introduction to query rewriting optimisation with dependencies