# MappingTables Definition1 Given a set of attributes U, t is a

Document Sample

```					Mapping Data in Peer-to-Peer Systems:
Semantics and Algorithmic Issues
By A. Kementsietsidis, M. Arenas and R.J. Miller

Presented by
Md. Anisur Rahman: 3558643
Anahit Martirosyan: 100628480
LianXiang Qiu: 3603336

University Of Ottawa
Winter 2004
Outline

 P2P Data-Sharing-System
 Mapping Table
 Alternative Semantics for Mapping Tables
 Mapping Tables as Constraints
 An algorithm for checking consistency of the
existing mappings and inferring new mappings
from them
 Conclusion and Future work
Peer-to-Peer Data-Sharing System
What is a Mapping Table?

GDB_id   Gene_Name   SwissProt_id   Protein_ name   GDB_id   SwissProt_id
G1          NF1         P9             NF1          G1          P9
G2          NF2         P40           MERL          G1          Q62
G3         NGFB                                     G2          P40
Relation SwissProt         G3          P38
Relation GDB
Mapping Table

A mapping table m from a set of attributes X to a set
of attributes Y is a finite set of mappings over X  Y
Alternative Semantics for Mapping Tables

Closed-Closed-World Semantics
Closed-Open-World Semantics

GDB_id     SwissProt_id
GDB_id   SwissProt_id
G2          P40
G2         P40
v - {G2}    v’ - {P40}
Valuation over a mapping table

 A valuation p over mapping table m is a function that maps
 each constant value in m to itself and
 each variable v of m to a value of the domain of the attribute where v
appears
 If v appears in the expression of the form v-S , then p(v)S

Attr1         Attr2                                  p(a) = a
dom(Attr1)={a, b, c, d}     p(3) = 3
a             3                                      p(v) = c
dom(Attr2)={1, 2, 3}
p(v) = d
b             2
v-{a,b}       1
Mapping table m
Mapping Constraint

GDB_id    Gene_Name
SwissProt_id    Protein_ name   GDB_id      SwissProt_id
G1         NF1
P9              NF1            G2          P40
G2         NF2                                         v - {G2}    v’ - {P40}
P40            MERL
G3        NGFB

Relation GDB             Relation SwissProt          Mapping table m
m
Mapping Constraint      : GDB _ id  Swiss Pr ot _ id

GDB_id   GENE_Name    Swissprot_id   Protein_ Name
G1         NF1           P9             NF1
G2         NF2           P40           MERL
G3        NGFB           P9             NF1
G2         NF2           P9             NF1

A relation having attributes from both GDB and SwissProt
Extension of a mapping constraint
m
 Given a mapping constraint  : X  Y
ext () = {(t) | t  m and  is a valuation over m }

Attr1    Attr2                                  Attr1   Attr2
dom(Attr1)={a, b, c, d}
a       3
a        3        dom(Attr2)={1, 2, 3}
b       2
b        2
m                   c       1
v-{a,b} 1          : Attr1  Attr2
d       1
Mapping table m
ext(µ)
Cover of a set of mapping constraints

m
    A mapping constraint  : X  Y is called the

cover of a set of mapping constraints  if
  is consistent if and only if there exists t ext()
m'
 For every mapping constraint       ': X  Y , ╞ ’ if
and only if ext()  ext(’)
Example of Cover

A1       A2             B1       B2               C1    C2
m2
p        x              px       1                 a    i               2 : B1  C1 , C2

m1
q        y              qy       2                 b    j               1 : A1 , A2  B1
r       z              rz       3                 c    k                    ={1, 2}
Relation r1             rx       4
Relation r3                         m
Relation r2                                       : A1 , A2  C1 , C2

A1           A2       B1               B1         C1         C2              A1 A2 C1 C2
p           x        px               px         a            i             p x a i
q           y        qy               qy         b            j             q y b j
v-{p,q}        v’   v’’-{px,qy}       v-{px,qy}     v’       v’’-{I,j}
Mapping table m
Mapping table m1                    Mapping table m2
The Algorithm

 Input
 A path  = P1, P2,…., Pn of peers
 A set  of mapping constraints over path 
 Two sets of attributes X and Y in peers P1 and Pn
 Output:
m
 A mapping constraint  : X  Y that is a cover of 
How is the Algorithm useful?

 To check whether ╞ ’
 Run the algorithm to find the cover 
 Check whether ext()  ext(’).
 To check whether  is consistent
 Run the algorithm to find the cover 
 Check whether ext() is nonempty
An Example

P1                       P2                    P3              P4
{A1, A2,.., A6}            {B1, B2,.., B6}      {C1,C2,C3,C4}      {D3, D4}

1 : A1 m B1
1
               7 : B1 , B2  C1
m7
10 : C 3  D3
m
10

 2 : A1 , A2 m2 B1 , B2
            8 : B3  C 2
8 m         11 : C 4  D4
m11

 3 : A3 m3 B2 , B3

 4 : A4 m4 B4
               9 : B5  C 3
9 m

 5 : A5 m5 B5

 6 : A6 m6 B6
               =P1, P2, P3, P4
 = {µ1, µ2,…, µ11}
Partitions

1 : A1 m B1
1

 2 : A1 , A2 m2 B1 , B2
                   µ2                 µ4         µ6
 3 : A3 m3 B2 , B3

 4 : A4 m4 B4

 5 : A5 m5 B5
               µ1               µ3              µ5
 6 : A6  B6
m6

2            
A4 m4 B4

A1 m1 B1
1      A1 , A2 m2 B1 , B2
                3            
A5 m5 B5

A3 m3 B2 , B3
4            
A6 m6 B6
Inferred Partitions

Peer P1                      Peer P2        Inferred partition over
P1 and P2
A1 m1
 B1           5          
B1 , B2 m7 C1
1    A1 , A2 m2 B1 , B2
                                            
A1 m1 B1
6 B3  C 2
m8
A3 m3 B2 , B3
                                                  
A1 , A2 m2 B1 , B2
7 B5  C 3
m9

A3 m3 B2 , B3
2        
A4 m4 B4                                               
A4 m4 B4

A5 m5 B5                   1             3             
B1 , B4 m7 C1
3

B3 m8 C 2
4        
A6 m6 B6              5        6        7        
A5 m5 B5

B5 m9 C 3
2              4              
A6 m6 B6

 While computing the cover, partitioning
reduces computational cost as fewer
constraints are considered at a time.
 Different partitions can be processed in
parallel.
Description of the Algorithm

 The algorithm has two phases
 The Information gathering Phase
 The Computation Phase
Information Gathering Phase

P1                     P2                    P3           P4

Compute partitions     Compute own          Compute own
For each partition     partitions            partitions
send to P2 the set of   Compute              Compute inferred
attributes in the       inferred partitions   partitions using the
partition               using the             information of
information of        propagated inferred
partitions of P1      partitions from P2
Computation Phase

P1                         P2                         P3           P4

Uses the              Determines with which       Using the local
incoming stream of     of its own partitions the    constraints of the inferred
mappings to            incoming stream of           partition , computes a
generate a cover       mapping should be            cover between P3 and P4
between its own        associated                   The mappings belonging
attributes and those    With this information it   to the cover are streamed
of peer P4             generates a cover            to peer P2.
between itself and P4
Conclusion and Future Scope

 This paper showed that by treating mapping
tables as constraints on the exchange of
information between peers it is possible to
reason about them and check their
consistency.
 There is scope for investigating the use of
mapping tables in support of query answering.
Thank You

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 5 posted: 7/6/2012 language: pages: 21