Date post: | 02-Jan-2016 |
Category: |
Documents |
Upload: | elfreda-oneal |
View: | 213 times |
Download: | 0 times |
Your Mediators need Data Conversion!*
Sophie Cluet, Claude Delobel, Jerome Simeon, K Smaga
By
Prapulla Bajjuri
Introduction
• Converts the data from one format to another
• It provides tools for the specification and the implementation of data conversions among heterogeneous data sources.
• YAT model uses graphs for representation
• YATL is rule-based
Translation Scenario
RDBMS OODBMS
SGML Files HTML files
YAT/relationalwrapper
YAT/SGMLwrapper
YAT/HTMLwrapper
YAT/ODMGwrapper
YATL translationrel + sgml ->odmg
YATL translationOdmg -> html
YAT Model
• Consists of set of patterns and variable domains
• Two kinds of variables
(i) Data Variables
(ii) Pattern Variables
• The domain of data variable is the set of all data constants and variable names
• The domain of pattern variable is the set of all its instance patterns.
• Ground pattern.
Yat:
Att
Ptype
Psup:Pcar:
Pclass:
The YAT model
S2:S1:C1:
The Golf GTI modelThe car schema model
The ODMG model
Ptype:
class
car
L & Yat L
*
Yat
VV
Class
Class_name
Ptype
*Att
Y: int V String..V Tuple V*
Z: (set, list, bag, array)
V &Pclass
Ptype
*
name
S1:str
desc suppliers
S2:str set
&Psup
*
&Pcar
… …class
car
name desc
“Golf” “The 1995 volksGolf GTI….”
suppliers
set
&s1 &s2
Model Instantiation
• It relies on pattern instantiation which itself relies on variable domain inclusion.
(i) Each pattern of the instance model must be an instance of some pattern of the source model
(ii) A variable can be instantiated either by a constant belonging to the variable’s domain or by a variable whose domain is a subset.
Pattern for car objects
Pcar: classcar(names1:string, descS2:string, suppliersset&Psup)
The YAT Language
• It is declarative and rule-based
• Deals with heterogeneity
• Deals with collections
• Detects cyclic programs
• Supports graphical interface
• Typing in YATL
Rule 1
Psup(SN) :Class supplier ( name SN, city C, zip Z)
Pbr :brochure( number Num, title T, model Year, desc D, suppls supplier ( name SN, address Add)),Year > 1975,C is city(Add),Z is zip(Add)
*
Rule 2
Pcar(pbr) :Class car ( name T, desc D, suppliers
set &Psup(SN) )
Pbr :brochure( number Num, title T, model Year, desc D, suppls supplier ( name SN, address Add)),{ }
*
Rule 1’
Psup(SN) :Class supplier ( name SN, city C, zip Z, sells set &Pcar(Pbr) )
Pbr :brochure( number Num, title T, model Year, desc D, suppls supplier ( name SN, address Add)),
C is city(Add),Z is zip(Add)
{ }
*
Dealing with heterogeneity
Suppliers Relational Database Schema
suppliers[sid: integer, name: string, city: string, address: string, tel: string]
Cars[cid: integer, broch_num: string]
Sales[sid: integer, cid: integer, year: integer, sold: integer]
Rule 3
Psup(SN) :Class car ( name T, desc D, suppliers set &Psup(Sid))
Pbr :brochure( number Num, title T, model Year, desc D, suppls supplier ( name SN, address Add)),Rsuppliers:Suppliers row (sid Sid, name SN, city C, addressAdd2, tel Tel).
Rcars:Cars row (cid Cid, broch_num Num),sameaddress(Add, C, Add2)
*
*
*
*
Dealing with collections
• YATL handles sets and lists.
• It provides one primitive for grouping and another for ordering.
• It allows to grouping on some criteria and ordering on others.
• Arrays can also be manipulated using YAT language.
Rule 4
Pallsups( ) :
list &Psup(SN)
Pbr :brochure( number Num, title T, model Year, desc D, suppls supplier ( name SN, address Add)),
*
[]SN
Rule 5
New (Id) : Id:
Mat Y X A Mat X Y A[]J []I I J
Mat:
Output Transposed MatrixInput Matrix
Mat:
110 22 20 300 330100
Polo golf polo golf polo golf
Paris nice caen
sales sales
Polo golf
Paris nice caen paris nice caen
100 22 300 110 20 330
Detecting cyclic programs
• Removing the & symbol in Rules 1’ and 2 introduces cycle in the program
• Statically detecting cycles in a YATL program is undecidable
• This can be done by constructing dependency graph of dereferenced functions
• It rejects conversion programs working by recursion on the input tree.
• Rejects programs that are not safe-recursive.
Typing in YATL
• Input and output models can easily be inferred by considering
(i) input and output patterns
(ii) predicate/function signatures
(iii) variable domains
Rule 1Psup(SN) :Class supplier ( name SN, city C, zip Z)
Pbr :brochure(…… suppls supplier ( name SN, address Add)),Year > 1975,C is city(Add),Z is zip(Add)
*
Customizing programs
• Converts any ODMG data into HTML• An object is converted into HTML page• An atomic value is converted into a string• A collection is converted into a list of HTML items• An object reference is converted into an HTML anchor
HtmlPage(Pclass) :Html( head title Classname, body(h1Classname, ul li, ( Att2, HtmlElement(Ptype))))
Pclass :class Classname Att Ptype, Att2 is concat(Att, “ : “)
Web 1
HtmlElement( Ptype) : S Ptype : Data, S is data_to_string(Data)
Web 2
•An object is converted into an HTML page
•An atomic value converted into a string
HtmlElement(Ptype) :ul li( Att2, HtmlElement(P2: Ptype))
Ptype :tuple Att P2:Ptype, Att2 is concat(Att, “ : “)
Web 3
HtmlElement( Ptype) : Ptype : ul li HtmlElement(P2:Ptype) X:{ set, bag} P2 : Ptype
Web 4
* *
**
• A collection is converted into a list of HTML elements.
•A tuple is converted into a list of HTML items
HtmlElement(Ptype) :
ol li HtmlElement(P2:Ptype))
Ptype :X : {list,array} P2:Ptype
Web 5
HtmlElement( Ptype) : Ptype : &Ptype,A( href & HtmlPage(Pclass), Pclass : cont Classname) class Classname P2:Ptype
Web 6
o(I)I
•A object reference is converted into an HTML anchor.
•A list or array is converted into a list of HTML elements.
HtmlPage(Pcar) :html( head title car, body(h1car, ul( li ( ”name:”, T1), li( ”age:”, D1), li( ”suppliers:”, ul li a ( href HtmlPage(Psup), cont Classname)))))
Pcar :Class car ( nameT, desc D, suppliers set &Psup), Psup: classClassnameP2:Ptype, T1 is data_to_string(T), D1 is data_to_string(D)
*
*
Example
Combining programs
• YATL interpreter organizes the set of rules of a program hierarchically.
• For a given input pattern, the more specific rules matching the input are applied first then less specific rules are tried.
• User may also enforce the rule hierarchy.
Composing programs
• Using YATL , it is possible to compose two programs and generate a more efficient program.
• Composition mechanism: It takes two programs and checks whether they are compatible and produces the new program by combining them.
• Here it takes SGMLODMG and ODMGHTML and produces SGMLHTML
YAT Architecture
• It does not provide the ability to query or update external sources.
• System is composed into three main parts
(i) The specification environment
(ii) The runtime environment
(iii) A library of programs and formats
YAT Architecture
Import wrapper
Import wrapper
Graphical User Interface
Specification Environment
Static Typing
YAT pattern/ YATL rules management module
YATL programInstantiation module
Library of programs and models
Exportwrapper
Target 1
Runtime environment
YAT Patterns/YATL rulesManagement module
Type checker
YATL interpreter External Functions &
Predicates evaluation
Source 1 Source 2