Integrating Databases into the Semantic Web through an Ontologybased Framework

1
Integrating Databases into the Semantic Web
through an Ontology-based Framework

• Dejing Dou, Paea LePendu, Shiwoong Kim
• Computer and Information Science, University of
  Oregon, USA
• Peishen Qi
• Computer Science Department, Yale University, USA
  
• April, 2006 _at_ SWDB06

2
Outline

• Introduction
• The status of the Semantic Web
• Realizing SW needs existing databases
• OntoGrate An Ontology-based Information
  Integration Framework
• Some previous work
• Modules in OntoGrate Architecture
• Case Study for integrating Databases into SW
• Without an existing domain ontology
• With an existing domain ontology
• Conclusion and Future Work

3
The Semantic Web

• One major goal of the Semantic Web is that
  web-based agents can process and understand
  data Berners-Lee etal01.
• Ontologies formally describe the semantics of
  data and web-based agents can take SW documents
  (e.g. in RDF/OWL) as a set of assertions (true
  statements) and draw inferences from them.

Web-based agents
human
SW
4
What we have now?

• DAMLOIL ? OWL (Web ontology language)
• More and more domain ontologies are defined in
  DAMLOIL/OWL, even for some specific domains
  (e.g., GO)
• We are developing some tools, agents, services

See http//www.semwebcentral.org,
http//knowledgeweb.semanticweb.org/
http//www.daml.org/
5
Two things are important

• Real Data for sharing
• relational databases (may be the biggest
  resource)
• Other kinds of databases
• WWW/XML data
• Some knowledge bases
• Better Semantic Web Services/Agents

6
Semantic Annotation for Data?

• It is good for small size data resources
• It is not that good for large size data resources
  (relational databases)
• Redundant copies
• Time consuming for query answering.
• E.g. it currently works as loading OWL data into
  a knowledge base then answering queries with DL
  ABox reasoning. (Can it compete with existing
  DBMS which has well developed indexing and query
  optimization techniques?)
• It is better that relational databases can be
  accessed/queried directly by SW agents/services

7
The difficulties
The Semantic Web
The Relational DBs
Ontologies define the semantics of data
Schemas define the structure and integrity
constraints
8
A more general question

• How can we make databases, SW resources, WWW/XML
  data, KBs work together?
• The problem is similar
• SW resources and KBs are defined by ontologies,
  which are more expressive and focus on semantics
• Databases and XML documents are defined by
  schemas, which focus on structure
• Syntax difference (e.g., OWL vs. SQL)

9
OntoGrate An Ontology-based Information
Integration System
10
Some Previous Work

• Schemas (e.g., stores7 DB in IBM informix),

11
Some Previous Work

• Schemas, Ontologies and Web-PDDL

Relation ? Type/Class Attribute ?
Predicate/Property Integrity Constrain ?
Axiom/Rule Primary Key ? Fact/Instance
12
Some Previous Work

• Merging Ontologies with Bridging Axioms

13
Some Previous Work

• The Bridge Axiom/mapping on
• customerfname/customerlname
• vs.
• customercontactname
• (forall (c - _at_stores7Customer f l -
  _at_sqlvarchar)
• (if (and (_at_stores7customerfname c f)
  
• (_at_stores7customerlname c
  l))
• (_at_nwindcustomercontactname c
  
• 
  (_at_sqlconcat f l))))

14
Some Previous Work

• The Bridge Axiom/mapping on
• customerregion
• vs.
• customerstatecode/statename/statecode
• (forall (x - _at_nwindCustomer y - _at_sqlvarchar)
• (if (_at_nwindcustomerregion x y)
• (exists (z - _at_stores7State t -
  _at_sqlvarchar)
• (and (_at_stores7customerstatecode x
  t)
• (_at_stores7statename z y)
• (_at_stores7statecode z t)))))

15
Some Previous Work

• Inferential Data Integration with OntoEngine
• Data Translation
• View data as true statements, e.g., (statecode
  S28 OR)
• (Ms_t ?s) D ?t only if (Ms_t
  ?s) ?t
• (Ms_t ?s) D ?t ? (Ms_t ?s) ?t ?(Ms_t
  ?s) ?t
• Query Translation
• (Ms_t ?s) Q ?t only if (Ms_t ? (?t)) ?
  (?s)
• (Ms_t ?s) Q ?t ? (Ms_t ? (?t)) ?
  (?s)
• ?(Ms_t ? (?t))
  ? (?s)

16
OntoGrate Architecture Revisited
17
Modules in OntoGrate Architecture

• The Syntax Translators (Wrappers)
• e.g., PDDSQL (SQL?Web-PDDL),
• PDDOWL(OWL ?Web-PDDL)
• The Matching (correspondence) Generation
• e.g., name, structure (tree, graph)
  similarity,synonyms and is-a (part of)
  relationships using thesauri and dictionary, such
  as Wordnet
• The Data Mining Module
• The Machine Learning Module
• The Inference Engine (OntoEngine)
• The User Interface

18
Learning the mappings from domain experts
(forall (x - _at_A1Invertebrate) (if
(is _at_A1Insect x) (and
(_at_A2legs x 6)
(_at_A2bodySegments x 3))))
19
Mining the mappings from large datasets

• For example, two Medical databases in the same
  hospital DB1 list blood pressure of patients
  with nominal values, such as low, normal, at
  risk, and high, while the other DB2 may record
  the exact numerical values for systolic and
  diastolic pressure.
• By association rule mining, we may get the
  rule/mapping like
• _at_DB2SystolicPressure ? 140 ? _at_DB2DiastolicPressu
  re ? 90
• _at_DB2BloodPressure High
• (support 40, confidence 90)

20
Case Study in Two Scenarios

• Integrating DBs into SW without an existing
  domain ontology
• Integrating DBs into SW with an existing domain
  ontology

21
Without an existing domain ontology
22
Generating OWL ontologies from DB Schemas

• SQL schema ? Web-PDDL (by using PDDSQL)
• Web-PDDL ? OWL (by using PDDOWL)
• E.g., Stores7.sql ? Stores7.pddl ? Stores7.owl
• ...
• ltowlClass rdfID"Customer"gt
• ltrdfssubClassOf
• rdfresourcehttp//www.cs.uoregon.edu/paea
  /sqlRelation"/gt
• lt/owlClassgt
• ltowlDatatypeProperty rdfID"customercity"gt
• ltrdfsdomain rdfresource"Customer"/gt
• ltrdfsrange rdfresource"String"/gt
• lt/owlDatatypePropertygt
• ...

23
An OWL-QL query based on Stores7.owl

• ltowl-qlquery xmlnsowl-qlhttp//www.w3.org/2003
  /10/owl-ql-syntax"...gt
• ltowl-qlpremisegt
• ltrdfRDFgt
• ltrdfDescription rdfabout"C"gt
• ltrdftype rdfresource"Customer"/gt
• ltcustomercity rdfresource"Eugene"/gt
• lt/rdfDescriptiongt
• lt/rdfRDFgt
• lt/owl-qlpremisegt
• ltowl-qlqueryPatterngt
• ltrdfRDFgt
• ltrdfDescription rdfabout"C"gt
• ltcustomerfname rdfresource"http//www.
  w3.org/2003/10/ owl-ql-variables x"/gt
• ltcustomerlname rdfresource"
  http//www.w3.org/2003/10/ owl-ql-variablesy"/gt
• lt/rdfDescriptiongt
• lt/rdfRDFgt
• lt/owl-qlqueryPatterngt
• ltowl-qlanswerKBPatterngt
• ltowl-qlkbRef rdfresource"...stores7.owl"/
  gt

24
The corresponding Web-PDDL and SQL queries
PDDOWL
(and (customercity ?C - Customer "Eugene")
(customerfname ?C - Customer ?x - String)
(customerlname ?C - Customer ?y - String))
PDDSQL
SELECT C.customerfname, C.customerlname FROM
Customer C WHERE C.customercity "Eugene"
25
Getting Answers from Stores7 DB
(1000/100,000/3secs)
?x/Paea, ?y/LePendu ?x/Dejing,
?y/Dou ?x/Shiwoong, ?y/Kim
PDDSQL
ltowl-qlanswerBundle xmlnsowl-ql"
http//www.w3.org/2003/10/ owl-ql-syntax" ...gt
ltowl-qlanswergt ltowl-qlbinding-setgt
ltvarx rdfresource"Paea"/gt ltvary
rdfresource"LePendu"/gt lt/owl-qlbinding-setgt
ltowl-qlanswerPatternInstancegt ltrdfRDFgt
ltrdfDescription rdfabout"C"gt
ltcustomerfname rdfresource"Paea"/gt
PDDOWL
(1000 bindings/3 secs)
26
With an existing domain ontology
Order ontology http//www.dayf.de/2004/owl/order.
owl
27
An OWL-QL query based on order.owl

• ltowl-qlquery xmlnsowl-qlhttp//www.w3.org/2003
  /10/owl-ql-syntax"...gt
• ltowl-qlpremisegt
• ltrdfRDFgt
• ltltrdftype rdfresource"Person"/gt
• lthasAddress rdfresource"A"/gt
• lt/rdfDescriptiongt
• ltrdfDescription rdfabout"A"gt
• ltrdftype rdfresource"Address"/gt
• ltCity rdfresource"Eugene"/gt
• lt/rdfDescriptiongt
• lt/rdfDescriptiongt
• lt/rdfRDFgt
• ltowl-qlqueryPatterngt
• ltrdfRDFgt
• ltrdfDescription rdfabout"C"gt
• ltFirstName rdfresource"http//www.w3.o
  rg/2003/10/ owl-ql-variables x"/gt
• ltLastNname rdfresource"
  http//www.w3.org/2003/10/ owl-ql-variablesy"/gt
• ltowl-qlkbRef rdfresource"
  http//www.dayf.de/2004/owl/order.owl"/gt

28
The Bridging Axioms/Mappings between
Stores7.pddl and Order.pddl
(T-gt _at_stores7Customer _at_orderPerson) (forall (P
- _at_orderPerson A - _at_orderAddress z - String)
(if (and (_at_orderhasAddress P A)
(_at_orderCity A z)) (_at_stores7customercity
P z))) (forall (C - _at_stores7Customer z -
String) (if (_at_stores7customercity P z)
(exists (A - _at_orderAddress)
(and (_at_orderhasAddress P A)
(_at_orderCity A z)))))
29
The Bridging Axioms/Mappings between
Stores7.pddl and Order.pddl
(T-gt _at_stores7Customer _at_orderPerson) (forall (C
- _at_stores7Customer x - String) (iff
(_at_stores7customerfname C x)
(_at_orderFirstName C x))) (forall (C -
_at_stores7Customer y - String) (iff
(_at_stores7customerlname C y)
(_at_orderLastName C y)))
30
The Query Translation between Stores7 and Order
OWL-QL query in order.owl
PDDOWL
(and (hasAddress ?C - Person ?A - Address)
(City ?A "Eugene") (FirstName ?C -
Person ?x - String) (LastName ?C - Person
?y - String))
Bridging Axioms
OntoEngine ( lt 1 sec)
(and (customercity ?C - Customer "Eugene")
(customerfname ?C - Customer ?x - String)
(customerlname ?C - Customer ?y - String))
31
Final Answers in the order ontology
(customerfname C1 Paea) (customerlname C2
LePendu) (customerfname C1 Dejing)
PDDSQL
Bridging Axioms
ltowl-qlanswergt ltowl-qlbinding-setgt ltvarx
rdfresource"Paea"/gt ltvary
rdfresource"LePendu"/gt lt/owl-qlbinding-setgt
ltowl-qlanswerPatternInstancegt ltrdfRDFgt
ltrdfDescription rdfabout"C"gt
ltFirstName rdfresource"Paea"/gt
ltLastName rdfresource"LePendu"/gt
OntoEngine (40,000facts/30 secs)
(FirstName C1 Paea) (LastName C2
LePendu) (FirstName C1 Dejing)
PDDOWL (10,000 facts/11 secs)
32
Some related work

• Semantic Annotation
• Stojanovic etal_at_SAC02 maps relational model to
  frame logic/RDF.
• DOGMAVerheyden etal_at_SWDB04 translates a
  ontology query to SQL
• Schema and Ontology mapping
• Similarity matching, machine learning useful for
  generating candidate matchings
• Semi-automatic tool (Clio)
• Data integration and query answering
• Federated databasesShethLarson 90, data
  warehouse, peer to peer management Halevy
  etal_at_ICDE03 , MiniCon PottingerLevy_at_VLDB00
  uses query rewriteing at GLV
• Logic and Databases
• Reiters reconstruction of relational model in
  FOL.
• Carnot, SIMS, Information Manifold by using a
  global ontology, DL or Datalog

33
Conclusion and Future work

• We applied OntoGrate, an ontology-based
  information integration framework, to integrate
  relational databases with the Semantic Web. The
  testing result based on two scenarios is
  promising.
• We are developing other modules (e.g.,
  learning/mapping/UI) in OntoGrate.
• The scalability and efficiency need to be
  investigated in larger-size data resources.
• Extending the current work to integrate XML
  (with/without XML schemas or DTD) and the
  Semantic Web.

34
Thank you for your attention !