Distributed Database Design

TOPICS
Distributed database design concept,
objective of Data Distribution,
Data Fragmentation,
The allocation of fragment ,
Transparencies in Distributed Database Design

Design Problem
In the general setting :

Making decisions about the placement of data

and programs across the sites of a computer
network as well as possibly designing the
network itself.
In Distributed DBMS, the placement of

applications entails
placement of the distributed DBMS software; and
placement of the applications that run on the

database

Dimensions of the Problem

Access pattern behavior
dynamic
static

data
data +
program

Level of sharing

partial
information
Level of knowledge
complete
information

Distribution Design
Top-down
mostly in designing systems from scratch
mostly in homogeneous systems

Bottom-up
when the databases already exist at a

number of sites

Top-Down Design
Requirements
Analysis
Objectives
User Input
Conceptual
Design

View Integration

View Design

Access
Information

GCS

Distribution
Design
LCSs
Physical
Design
LISs

ESs

User Input

Distribution Design Issues

Why fragment at all?
How to fragment?
How much to fragment?
How to test correctness?
How to allocate?
Information requirements?

Fragmentation
Can't we just distribute relations?
What is a reasonable unit of distribution?
relation
views are subsets of relations locality
extra communication

fragments of relations (sub-relations)

concurrent execution of a number of transactions
that access different portions of a relation
views that cannot be defined on a single fragment
will require extra processing
semantic data control (especially integrity
enforcement) more difficult

Fragmentation Alternatives
Horizontal
PROJ

PROJ1 : projects with budgets less

than $200,000
PROJ2 : projects with budgets
greater than or equal to
$200,000
PROJ1
PNO

PNO

PNAME

BUDGET

P1 Instrumentation 150000
P2 Database Develop.135000
P3 CAD/CAM
250000
P4 Maintenance
310000
P5 CAD/CAM
500000

LOC
Montreal
New York
New York
Paris
Boston

PROJ2
PNAME

P1 Instrumentation

BUDGET

LOC

15000 Montreal
0
P2 Database Develop.135000 New York

PNO
P3

PNAME
CAD/CAM

BUDGET

LOC

250000 New York

P4 Maintenance

310000 Paris

P5

500000 Boston

CAD/CAM

Fragmentation Alternatives
Vertical
PROJ

PROJ1: information about

project budgets
PROJ2: information about
project names and
locations

PNO

PNAME

BUDGET

P1 Instrumentation 150000
P2 Database Develop.135000
P3
CAD/CAM
250000
P4 Maintenance
310000
P5
CAD/CAM
500000

PROJ1

PROJ2

PNO

BUDGET

PNO

P1
P2
P3
P4
P5

150000
135000
250000
310000
500000

PNAME

LOC

P1 Instrumentation Montreal
P2 Database Develop. New York
P3
CAD/CAM
New York
P4 Maintenance
Paris
P5 CAD/CAM
Boston

LOC
Montreal
New York
New York
Paris
Boston

Degree of Fragmentation
finite number of alternatives

tuples
or
attributes

relations

Finding the suitable level of partitioning within

this range

Correctness of Fragmentation
Completeness
Decomposition of relation R into fragments R1, R2, ...,

Rn is complete if and only if each data item in R can

also be found in some Ri
Reconstruction
If relation R is decomposed into fragments R1, R2, ...,

Rn, then there should exist some relational operator

such that
R = 1inRi

Disjointness
If relation R is decomposed into fragments R1, R2, ...,

Rn, and data item di is in Rj, then di should not be in

any other fragment Rk (k j ).

Allocation Alternatives
Non-replicated

partitioned : each fragment resides at only

one site

Replicated

fully replicated : each fragment at each site

partially replicated : each fragment at some

of the sites
If read-only queries << 1, replication is advantageous,
update queries

otherwise replication may cause problems

Rule of thumb:

Comparison of Replication
Alternatives
Full-replication

Partial-replication

Partitioning

QUERY
PROCESSING

Easy

Same Difficulty

DIRECTORY
MANAGEMENT

Easy or
Non-existant

Same Difficulty

CONCURRENCY
CONTROL

Moderate

Difficult

Easy

RELIABILITY

Very high

High

Low

Possible
application

Realistic

Possible
application

REALITY

Information Requirements
Four categories:

Database information

Application information

Communication network information

Computer system information

PHF Information Requirements

Database Information
relationship

SKILL
TITLE, SAL
L1

EMP
ENO, ENAME, TITLE

PROJ
PNO, PNAME, BUDGET, LOC

ASG
ENO, PNO, RESP, DUR

cardinality of each relation: card(R)

Application Information
1. Qualitative Information
. The fundamental qualitative information consists of the
predicates used in user queries.
. Analyze user queries based on 80/20 rule: 20% of user
queries account for 80% of the total data access.
One should investigate the more important queries
2. Quantitative Information
. Minterm Selectivity sel(mi): number of tuples that
would be accessed by a query specified according to
a given minterm predicate.
. Access Frequency acc(mi): the access frequency of a
given minterm predicate in a given period.

Fragmentation
Horizontal Fragmentation (HF)
Primary Horizontal Fragmentation

(PHF)
Derived Horizontal Fragmentation

(DHF)
Vertical Fragmentation (VF)
Hybrid Fragmentation (HF)

Primary Horizontal
Fragmentation
EMP table
Three branch

offices, with each

employee
working at only
one office

Create table MPLS_EMPS as

Select * From EMP Where Loc =
Minneapolis;
Create table LA_EMPS as
Select *From EMP Where Loc = LA;
Create table NY_EMPS as Select *
From EMP Where Loc = New York;

After fragmentation
Select * from MPLS_EMPS
Union
Select * from LA_EMPS)
Union
Select * from NY_EMPS;

Example 1
AP1:looking for those employees who work in Los
Angeles (LA).
Pr = {p1: Loc= LA}

M= {m1: Loc = LA, m2: Loc<>LA}

is a minimal and complete set of minterm predicates for AP1

Fragment F1: Create table LA_EMPS as

Select * from EMP Where Loc = "LA";

Fragment F2: Create table NON_LA_EMPS as
Select * from EMP Where Loc <> "LA";
Minimal :the rows are accessed differently by at least one
application.
Complete :the rows have the same probability of being
accessed by any application.

AP1:Exclude any employee whose salary was less

than or equal to 30000

Pr = {p1: Loc = "LA,p2: salary > 30000}
M = {m1: Loc = "LA" Sal > 30000,

m2: Loc = "LA" Sal <= 30000,

m3: Loc <>"LA" Sal > 30000,
m4: Loc <>"LA" Sal <= 30000}
Any fragmentation must satisfy the following rules as defined :
Rule 1: Completeness. Decomposition of R into R1, R2, . . . , Rn is complete if and only if

each data item in R can also be found in some Ri.

Rule 2: Reconstruction. If R is decomposed into R1, R2, . . . , Rn, then there should exist
some relational operator, , such that R = 1in Ri.
Rule 3: Disjointness. If R is decomposed into R1, R2, . . . , Rn, and di is a tuple in Rj, then
di should not be in any other fragment, such as Rk, where k = j.

NOTE: N simple predicates in Pr, M will have 2N minterm

predicates.

PHF - Information
Requirements
Application Information
simple predicates : Given R[A1, A2, , An], a simple

predicate pj is
pj : Ai Value

where {=,<,,>,,}, Value Di and Di is the domain

of Ai.
For relation R we define Pr = {p1, p2, ,pm}
Example :
PNAME = "Maintenance"
BUDGET 200000

minterm predicates : Given R and Pr = {p1, p2, ,pm}

define M = {m1,m2,,mr} as
M = { mi | mi =

pjPrpj* }, 1jm, 1iz

where pj* = pj or pj* = (pj).

PHF Information Requirements

Application Information
minterm selectivities: sel(mi)
The number of tuples of the relation that would be

accessed by a user query which is specified

according to a given minterm predicate mi.

access frequencies: acc(qi)

The frequency with which a user application qi

accesses data.
Access frequency for a minterm predicate can also be

defined.

Primary Horizontal Fragmentation

Definition :
Rj = Fj(R), 1 j w
where Fj is a selection formula, which is (preferably) a
minterm predicate.
Therefore,
A horizontal fragment Ri of relation R consists of all the
tuples of R which satisfy a minterm predicate mi.

Given a set of minterm predicates M, there are as many

horizontal fragments of relation R as there are minterm
predicates.
Set of horizontal fragments also referred to as minterm
fragments.

PHF Algorithm
Given: A relation R, the set of simple
predicates Pr
Output:The set of fragments of R = {R1, R2,
,Rw} which obey the fragmentation
rules.
Preliminaries :
Pr should be complete
Pr should be minimal

Completeness of Simple
Predicates
A set of simple predicates Pr is said to be

complete if and only if the accesses to the tuples

of the minterm fragments defined on Pr requires
that two tuples of the same minterm fragment
have the same probability of being accessed by
any application.
Example 2:
Assume PROJ[PNO,PNAME,BUDGET,LOC] has two

applications defined on it.

Find the budgets of projects at each location. (1)
Find projects with budgets less than $200000. (2)

Completeness of Simple Predicates

According to (1),
Pr={LOC=Montreal,LOC=New York,LOC=Paris}

which is not complete with respect to (2).

Modify
Pr ={LOC=Montreal,LOC=New York,LOC=Paris,
BUDGET200000,BUDGET>200000}

which is complete.

Find projects with budgets less than $200000. (2)

Minimality of Simple
Predicates
If a predicate influences how fragmentation

is performed, (i.e., causes a fragment f to

be further fragmented into, say, fi and fj)
then there should be at least one
application that accesses fi and fj
differently.
In other words, the simple predicate should
be relevant in determining a fragmentation.
If all the predicates of a set Pr are relevant,
then Pr is minimal.
acc(mi ) acc(mj )

card( fi ) card( fj )

Minimality of Simple
Predicates
Example :
Pr ={LOC=Montreal,LOC=New York,
LOC=Paris,
BUDGET200000,BUDGET>200000}

is minimal (in addition to being complete).

However, if we add
PNAME = Instrumentation

then Pr is not minimal.

COM_MIN Algorithm
Given: a relation R and a set of simple
predicates Pr
Output: a complete and minimal set of
simple predicates Pr' for Pr
Rule 1: a relation or fragment is partitioned
into at least two parts which are
accessed differently by at least one
application.

COM_MIN Algorithm
Initialization :
find a pi Pr such that pi partitions R according to
Rule 1
set Pr' = pi ; Pr Pr {pi} ; F {fi}
Iteratively add predicates to Pr' until it is complete
find a pj Pr such that pj partitions some fk defined
according to minterm predicate over Pr' according to
Rule 1
set Pr' = Pr' {pj }; Pr Pr {pj }; F F {fi}
if pk Pr' which is nonrelevant then
Pr' Pr {pk}
F F {fk}

PHORIZONTAL Algorithm
Makes use of COM_MIN to perform fragmentation.
Input: a relation R and a set of simple predicates
Pr
Output: a set of minterm predicates M according to
which relation R is to be fragmented
Pr' COM_MIN (R,Pr)
determine the set M of minterm predicates
determine the set I of implications among pi Pr
eliminate the contradictory minterms from M

PHF Example 3
Two candidate relations : PAY and PROJ.
Fragmentation of relation PAY
Application: Check the salary info and determine

raise.
Employee records kept at two sites application
run at two sites
Simple predicates
p1 : SAL 30000
p2 : SAL > 30000
Pr = {p1,p2} which is complete and minimal Pr'=Pr

Minterm predicates
m1 : (SAL 30000)
m2 : NOT(SAL 30000) (SAL > 30000)

PHF Example 3

PAY1
TITLE

PAY2
SAL

TITLE

SAL

Mech. Eng. 27000

Elect. Eng.

40000

Programmer 24000

Syst. Anal.

34000

PHF Example 3
Fragmentation of relation PROJ

Applications:
Find the name and budget of projects given their no.
Issued

at three sites

Access project information according to budget

one

site accesses 200000 other accesses >200000

Simple predicates
For application (1)

p1 : LOC = Montreal
p2 : LOC = New York
p3 : LOC = Paris

For application (2)

p4 : BUDGET 200000
p5 : BUDGET > 200000
Pr = Pr' = {p1,p2,p3,p4,p5}

PHF Example 3
Fragmentation of relation PROJ continued
Minterm fragments left

m1 : (LOC = Montreal) (BUDGET

200000)
m2 : (LOC = Montreal) (BUDGET > 200000)
m3 : (LOC = New York) (BUDGET 200000)
m4 : (LOC = New York) (BUDGET > 200000)
m5 : (LOC = Paris) (BUDGET 200000)
m6 : (LOC = Paris) (BUDGET > 200000)

PHF Example
PROJ2

PROJ1
PNO
P1

PNAME

BUDGET

Instrumentation150000

LOC
Montrea
l

PROJ4
PNO

PNAME

P3

CAD/CAM

PNO
P2

PNAME

BUDGET

LOC

Database
Develop.

135000 New York

PROJ6
BUDGET
250000

LOC
New
York

PNO
P4

PNAME

BUDGET

LOC

Maintenance

310000

Paris

PHF Correctness
Completeness
Since Pr' is complete and minimal, the selection predicates

are complete

Reconstruction
If relation R is fragmented into FR = {R1,R2,,Rr}
R =

Ri FR Ri

Disjointness
Minterm predicates that form the basis of fragmentation

should be mutually exclusive.

Derived Horizontal
Fragmentation
Defined on a member relation of a link according to a

selection operation specified on its owner.

Each link is an equijoin.
Equijoin can be implemented by means of semijoins.
SKILL
TITLE, SAL
L1
EMP

PROJ

ENO, ENAME, TITLE

L2

PNO, PNAME, BUDGET, LOC

L3

ASG
ENO, PNO, RESP, DUR

DHF Definition
Given a link L where owner(L)=S and
member(L)=R, the derived horizontal
fragments of R are defined as
Ri = R F Si, 1iw

where w is the maximum number of

fragments that will be defined on R and
Si = Fi(S)

where Fi is the formula according to which

the primary horizontal fragment Si is defined.

DHF Example
Given link L1 where owner(L1)=SKILL/PAY and member(L1)=EMP
Group engineers into two groups according to their salary: those making less
than or equal to $30,000, and those making more than $30,000.
EMP1 = EMP SKILL/PAY1
EMP2 = EMP SKILL/PAY2

where
SKILL/PAY1 = SAL30000(SKILL/PAY)
SKILL/PAY2 = SAL>30000(SKILL/PAY)

EMP1

EMP2

ENO

ENAME

E3
E4
E7

A. Lee
J. Miller
R. Davis

TITLE
Mech. Eng.
Programmer
Mech. Eng.

ENO

ENAME

TITLE

E1
E2
E5
E6
E8

J. Doe
M. Smith
B. Casey
L. Chu
J. Jones

Elect. Eng.
Syst. Anal.
Syst. Anal.
Elect. Eng.
Syst. Anal.

DHF Correctness

Completeness

Referential integrity
Let R be the member relation of a link whose owner is relation S which is fragmented

as FS = {S1, S2, ..., Sn}. Furthermore, let A be the join attribute between R and S. Then,
for each tuple t of R, there should be a tuple t' of S such that
t[A] = t' [A]

Reconstruction
Same as primary horizontal fragmentation.

Disjointness
Simple join graphs between the owner and the member fragments.

Vertical Fragmentation
Group the columns of a table into fragments.
Because each fragment contains a subset of the total set of columns in the table, VF can be

used to enforce security and/or privacy of data.

More difficult than horizontal, because more alternatives exist.
In the case of vertical partitioning, if a relation has m non-primary key attributes, the

number of possible fragments is equal to B(m), which is the mth Bell number
Two approaches :
grouping
attributes to fragments
first step creates as many vertical fragments as the number of non-key columns in the

table. Then grouping approach uses joins across the primary key, to group some of
these fragments together, and continues as needed
Not usually considered a valid approach
splitting
relation to fragments
placing each non-key column in one and only one fragment

Need to design affinity or closeness

If a table has 15 columns, then the number of

possible vertical fragments is 109 and

If the number of vertical fragments for a table
with 30 columns is 1023.
Evaluating is not practical.
Sol : Find the closeness/affinity between the
attributes to decide whether to group them into
same fragment or not

VF Information
Requirements
Application Information
Attribute affinities
a measure that indicates how closely related the attributes are
This is obtained by: access frequency + usage pattern
Access freq: how many times an application/query runs in a given
period of time at different sites
Usage pattern:Indicates whether a column is used by an
application/query.
Attribute usage values
Given a set of queries Q = {q1, q2,, qq} that will run on the

relation
R[A1 , A2,, An],
1 if attribute Aj is referenced by query qi
use(qi,Aj) =
0 otherwise

use(qi,) can be defined accordingly

VF Definition of use(qi,Aj)
Consider the following 4 queries for relation PROJ
q1: SELECT BUDGET q2: SELECT PNAME,BUDGET
FROM PROJ
FROM PROJ
WHERE
PNO=Value
q3: SELECT PNAMEq4: SELECT SUM(BUDGET)
FROM PROJ
FROM PROJ
WHERE
LOC=Value
WHERE
LOC=Value

Let A1= PNO, A2= PNAME, A3= BUDGET, A4=

LOC
A1

A2

A3

A4

q1

q2

q3

q4

VF Affinity Measure
af(Ai,Aj)
The attribute affinity measure between two
attributes Ai and Aj of a relation R[A1, A2, , An]
with respect to the set of applications Q = (q1, q2,
, qq) is defined as follows :

af (Ai, Aj)

(query access)

all queries that access A and A

i

query access

access
access frequency of a query
execution

all sites

VF Calculation of af(Ai, Aj)

Example: Assume each query in the previous example
accesses the attributes once during each execution.
S1 S2 S3
Also assume the access frequencies
q1

q1

q2

q2

q3

q3

q4

q4

15 20
5

10

25 25

25

Then
af(A1, A3) = 15*1 + 20*1+10*1
= 45

and the attribute affinity matrix AA is

A1
A2
A3
A4

A1 A2 A3 A4
45 0 45 0
5 75
0 80
45 5 53 3
3 78
0 75

VF Clustering Algorithm
Take the attribute affinity matrix AA and

reorganize the attribute orders to form

clusters where the attributes in each
cluster demonstrate high affinity to one
another.
Bond Energy Algorithm (BEA) has been
used for clustering of entities. BEA finds an
ordering of entities (in our case attributes)
such that the global affinity measure is
maximized.

Bond Energy Algorithm

Input: The AA affinity matrix
Output: The clustered affinity matrix CA which
is a perturbation of AA
Initialization: Place and fix one of the columns of
AA in CA.
Iteration: Place the remaining n-i columns in the
remaining i+1 positions in the CA matrix. For
each column, choose the placement that makes
the most contribution to the global affinity
measure.
Row order: Order the rows according to the
column ordering.

Bond Energy Algorithm

Best placement? Define contribution of a
placement:
cont(Ai, Ak, Aj) = 2bond(Ai, Ak)+2bond(Ak, Al)
2bond(Ai, Aj)
n

where
af(Az,Ax)af(Az,Ay)
bond(Ax,Ay
)=
z 1

BEA Example
Consider the following AA matrix and the corresponding CA matrix
where A1 and A2 have been placed. Place A3:

Ordering (0-3-1) :
cont(A0,A3,A1) = 2bond(A0 , A3)+2bond(A3 , A1)2bond(A0 , A1)
= 2* 0 + 2* 4410 2*0 = 8820

Ordering (1-3-2) :
cont(A1,A3,A2) = 2bond(A1 , A3)+2bond(A3 , A2)2bond(A1,A2)
= 2* 4410 + 2* 890 2*225 = 10150

Ordering (2-3-4) :
cont (A2,A3,A4)= 1780

BEA Example
Therefore, the CA matrix has the form

A1 A3 A2

45 45
0

5 80

45 53
0

3 75

When A is placed, the final form of the CA

4

matrix (after row

A1 A3 A2 A4
organization)
is 45 0 0
A1 45
A3 45 53

A2

5 80 75

A4

3 75 78

VF Algorithm
How can you divide a set of clustered attributes {A1, A2, , An} into two (or more) sets {A1, A2, , Ai} and {Ai, , An} such that there are no (or minimal)

applications that access both (or more than one) of the sets.
the function will produce fragments that are balanced.

For Best partitioning split the columns into a one-column BC and n 1 column TC first , and then repeatedly add columns from TC to BC until TC
is

left with only one column.

choose the splitting that has the highest Z value.

Z can be positive if total accesses to only one fragment are maximized while the total accesses to both fragments are minimized

Disadvantage :Not able to carve out an embedded or inner block of columns as a partition.

Sol: Overcome by adding a shift operation(moves the topmost row of the matrix to the bottom and then it moves the leftmost column of the matrix to the
extreme right)

A1 A2 A3 Ai Ai+1. . .Am
...

A1
A2

TA

Ai
...

Ai+1
Am

BA

SHIFT OPERATION

VF ALgorithm
Define
TQ = set of applications that access only TA(Top corner
attributes)
BQ = set of applications that access only BA
OQ = set of applications that access both TA and BA

and
CTQ = total number of accesses to attributes by applications
that access only TA
CBQ = total number of accesses to attributes by applications
that access only BA
COQ = total number of accesses to attributes by applications
that access both TA and BA

Then find the point along the diagonal that maximizes

Goal Function: Z =CTQCBQCOQ2

Example
1)

TC: all the applications that access one of the TC columns (C4, C1, or
C3) but do not access any BC
[i.e AP1, AP2, and AP4]

No application is BC-only.

AP3 accesses both TC and BC columns,

TCW = AFF(AP1) + AFF(AP2) + AFF(AP4) = 3 + 7 + 3 = 13

BCW = none = 0
BOCW = AFF(AP3) = 4
Z = 13*0 42 = 16
2) TC
TCW = AFF(AP1) + AFF(AP2) = 3 + 7 = 10
BCW = AFF(AP3) = 4
BOCW = AFF(AP4) = 3
Z = 4*10 32 = 40 9 = 31

Result :The two vertical fragments will be defined as VF1(C, C4) and
VF2(C, C1, C2, C3).

3)
TCW = AFF(AP2) = 7
BCW = AFF(AP3) + AFF(AP4) = 4 + 3 = 7
BOCW = AFF(AP1) = 3
Z = 7*7 32 = 49 9 = 40
4)
TCW = AFF(AP4) = 3
BCW = AFF(AP2) = 7
BOCW = AFF(AP1) + AFF(AP3) = 3 + 4 =
7
Z = 3*7 72 = 21 49 = 28

VF Algorithm
Two problems :
Cluster forming in the middle of the CA matrix
Shift a row up and a column left and apply the

algorithm to find the best partitioning point

Do this for all possible shifts
Cost O(m2)

More than two clusters

m-way partitioning
try 1, 2, , m1 split points along diagonal and try to

find the best point for each of these

Cost O(2m)

VF Correctness
A relation R, defined over attribute set A and key K,
generates the vertical partitioning FR = {R1, R2, , Rr}.
Completeness
The following should be true for A:
A=

AR i

Reconstruction
Reconstruction can be achieved by
R=

K Ri, Ri FR

Disjointness
TID's are not considered to be overlapping since they are

maintained by the system

Duplicated keys are not considered to be overlapping

Hybrid Fragmentation
R
HF

HF

R1

R2

VF

VF

R11

R12

VF

R21

VF

R22

VF

R23

Fragment Allocation
Problem Statement

Given
F = {F1, F2, , Fn}

fragments

S ={S1, S2, , Sm}

network sites

Q = {q1, q2,, qq}

applications

Find the "optimal" distribution of F to S.

Optimality

Minimal cost
Communication + storage + processing (read & update)
Cost in terms of time (usually)

Performance

Response time and/or throughput

Constraints

Per site constraints (storage & processing)

Information Requirements
Database information

selectivity of fragments
size of a fragment

Application information

access types and numbers

access localities

Communication network information

unit cost of storing data at a site
unit cost of processing at a site

Computer system information

bandwidth
latency
communication overhead

Allocation
File Allocation (FAP) vs Database Allocation
(DAP):
Fragments are not individual files
relationships have to be maintained

Access to databases is more complicated

remote file access model not applicable
relationship between allocation and query processing

Cost of integrity enforcement should be

considered
Cost of concurrency control should be

considered

Allocation Information
Requirements
Database Information
selectivity of fragments
size of a fragment

Application Information
number of read accesses of a query to a fragment
number of update accesses of query to a fragment
A matrix indicating which queries updates which fragments
A similar matrix for retrievals
originating site of each query

Site Information
unit cost of storing data at a site
unit cost of processing at a site

Network Information
communication cost/frame between two sites
frame size

Allocation Model
General Form
min(Total Cost)
subject to
response time constraint
storage constraint
processing constraint
Decision Variable
xij

1 if fragment Fi is stored at site Sj

0 otherwise

Allocation Model
Total Cost

query processing cost

all queries

cost of storing a fragment at a site

all sites all fragments

Storage Cost (of fragment Fj at Sk)

(unit storage cost at Sk) (size of Fj) xjk

Query Processing Cost (for one query)

processing component + transmission component

Allocation Model
Query Processing Cost

Processing component
access cost + integrity enforcement cost +
concurrency control cost

Access cost

(no. of update accesses+ no. of read accesses)

all sites all fragments

xij local processing cost at a site

Integrity enforcement and concurrency

control costs
Can be similarly calculated

Allocation Model
Query Processing Cost

Transmission component
cost of processing updates + cost of processing
retrievals

Cost of updates

update message cost

all sites all fragments

acknowledgment cost
all sites all fragments

Retrieval Cost

minall sites
(cost of retrieval command

all fragments

cost of sending back the result)

Allocation Model
Constraints
Response Time
execution time of query max. allowable response
time for that query

Storage Constraint (for a site)

storage requirement of a fragment at that

site at that site
storage capacity

all fragments

Processing constraint (for a site)

processing load of a query at that site

all queries

processing capacity of that site

Allocation Model
Solution Methods
FAP is NP-complete
DAP also NP-complete

Heuristics based on
single commodity warehouse location (for

FAP)
knapsack problem
branch and bound techniques
network flow

Allocation Model
Attempts to reduce the solution space
assume all candidate partitionings known;

select the best partitioning

ignore replication at first
sliding window on fragments