http://horos.rdsor.ro/ijcccv3n4Draft.pdf


Int. J. of Computers, Communications & Control, ISSN 1841-9836, E-ISSN 1841-9844

Vol. III (2008), No. 4, pp. 384-394

Redistributing Fragments into a Distributed Database

Leon Ţâmbulea, Manuela Horvat-Petrescu

Abstract: A distributed system database performance is strongly related to the frag-
ment allocation in the nodes of the network. An heuristic algorithm for redistributing
the fragments is proposed. The algorithm uses the statistical information relative to
the requests send to a distributed database. This algorithm minimizes the size of the
data transferred for solving a request. Assuming that a distribution of the fragments
in the nodes of a network is known, the algorithm generates a plan to transfer data
fragments, plan that will be used to evaluate a request.
Keywords: distributed database, fragment allocation, allocation algorithm, transfer
cost, heuristic algorithm, redistribution algorithm

1 Introduction

Let’s consider a distributed database C, formed by n nodes (sites) Si, 0 <= i <m. Each node contains
a local database and has the capability to evaluate requests. The distributed database C contains a set of
n fragments F j, 0 <= j <n. Each F j fragment has a specific dimension dim(F j) - the dimension can be
measured in bytes, pages, so on. Different fragments noted with L j can be stored in a Si node.

Let’s assume that a user is sending a request q (a select, an update, a query). For solving this request,
are necessary a set of fragments r(q) and for each fragment an access right (read/write - depending of the
request) is required.

The great majority of requests received by a distributed database are requests used for data retrieving.
The fragments that should be transferred between the nodes of the network are required when evaluating
a request. An optimal allocation of the fragments in the nodes of the network is necessary for the
request evaluation time to be minimum. In [1, 3, 4, 7, 9, 10, 11] are mentioned other solutions for
solving the allocation problem. Because of the complexity of this problem (NP-complete problem) more
heuristic algorithms were proposed, algorithms with a lower complexity that provide only an approximate
solution. In [8] is described a model that propose a dynamic redistribution of the fragments using the
statistical information gathered in a specific period of time. Queries and information about the performed
fragment transfer can be obtained for a specific period of time in a distributed database. Using this data
obtained over a longer period of time, a redistribution of the fragments can be performed for minimizing
the size of the data transfer.

This article is organized as follows: In section 2 is described the model for evaluating a query, and
also the useful information that can be obtained when evaluating this query. The third section describes
the problem of redistributing the fragments in the nodes of a distributed database. For solving this
problem is proposed an heuristic algorithm that minimizes the size of the data transferred between the
network nodes. In section 4 is proposed an algorithm for generating a transfer plan of the fragments
when evaluating a query. This transfer plan is obtained using the query evaluation plan and the fragments
distribution in the nodes of the network. In the final section of the paper is presented a conclusion section.

2 Query Evaluation

An execution plan can be determined for each request q. In centralized databases, lots of studies
regarding how to find an execution plan with a minimum cost were performed, and some results were
implemented in commercial database management systems.

Copyright © 2006-2008 by CCC Publications



Redistributing Fragments into a Distributed Database 385

Using the execution plan, a request q can be split in a number of sub requests { qi, i ∈ Iq}, and each
sub request qi corresponds to an operator in the relational algebra. An operator requires one fragment (if
it’s an unary operator) or two fragments (if is a binary operator). These arguments (fragments) can be
stored in a node in the distributed database or can be the result of evaluating other operators.

In a distributed system, a request q can be evaluated as follows [5, 6]:

• Centralized, in a specific node S from the network. All the fragments r(q) necessary for solving
the request q should be transferred in this node S. The node S in which the evaluation is performed
can be determined as the total fragments r(q) transfer cost to be minimum.

• Distributed: each sub request qi is evaluated in a separate node S j in the network and in the S j
node should be found only the r(qi) fragments. The r(qi) fragments can be fragments stored in the
S j node, can be the result of a previous evaluation in this node, or can be transferred from other
node of the network.

In order to evaluate the cost of a request q, there has to be evaluated the cost of the operators and the
cost of the fragments transfer to the nodes where these operators are evaluated ([5, 6]). In this section as
in the next one, we will analyze the fragment redistribution problem in the nodes of a distributed database
in order to obtain a minimum cost for data fragments transfer when evaluating requests.

Let’s note with ci, j the cost of the transferring a data unit from the node Si to the node S j. For
a fragment F (that is stored in the node or is a fragment resulted from evaluating previous requests)
transferred from node Si to the node S j the total cost is ci j * dim(F). Because the ci j cost is relative but
the difference between them (in absolute terms) is relatively small, we’ll suppose in this paper that they
are constants; ci, j =1, 0 <= i, j <m. This assumption simplifies the solution for the proposed problem.

A request q can be split into elementary queries (operations) that execute over different fragments
stored in the node N. If such an elementary request (a join operator for example) uses fragments that are
not stored in the same node, than all the fragments should be transferred to the same node.

In the following example, the distributed database is composed by two relations: A and B, and has
horizontal fragmentation, such as:

A = A1 ∪ A2 ; B = B1 ∪ B2 ;

The request/query q for this database is:

q = A * σ c(B)

where c is a condition and "*" represents a join operator.

If all the fragments are stored in the same node than the request q can be evaluated in the node with-
out requiring other data transfers. If all the fragments (A1, A2, B1 and B2 ) are stored in different nodes
(noted with S0, S1, S2 and S3) then evaluation of the request q implies a data transfer cost. We’ll consider
that the requests q is required in a node S different from the previous mentioned nodes (S0, S1, S2 and S3)
where the data fragments are stored. Two evaluation strategies can be considered:

1. The evaluation is performed in the node S, so each required fragment is transferred from the node
where is stored into the S node. The size of the whole transfer is:

dim(A1) + dim(A2) + dim(B1) + dim(B2).

2. The evaluation is performed in a distributed manner: for this case the request q can be transformed
as follows:



386 Leon Ţâmbulea, Manuela Horvat-Petrescu

q = A * σ c (B) = (A1 ∪A2 )* σ c (B1 ∪ B2) =
= [A1 * σ c (B1 ∪ B2)] ∪[A2 * σ c (B1 ∪ B2] =

= [A1 * ( σ c (B1) ∪σ c (B2))] ∪[A2 * (σ c (B1) ∪σ c (B2))]

The request q can be evaluated using the following graph, where we consider that the result of eval-
uating σ c (Bi) will have a size/dimension di smaller that dim(Bi), i=1,2.

Let’s note with B’i = σ c (Bi), i=1,2 the results of the selection from the S2 and S3 nodes and d3
= dim(B’1 ), d4 = dim(B’2).

In the nodes of the following graph (the nodes of the graph represent the nodes of the network) are
presented the operators (unary and binary) that are evaluated and on the links are shown the data transfers
required in the evaluation process.

The total cost of the transfer will be 2 (d1 + d2 + d3 ) + d4.

In a distributed database the fragments can be replicated - a fragment can be stored in more than one
site/node. For the distributed database presented above, we’ll exemplify for two fragment distribution
plans the corresponding execution plan.

3.
Node S0 S1 S2 S3

Fragments A1 , A2 B1 , B2 A1 , B1 A2 , B2

4.
Node S0 S1 S2 S3

Fragments A1 , B1 A1 , B2 A2 , B1 A2 , B2



Redistributing Fragments into a Distributed Database 387

3 Redistribution of the fragments

Let’s assume the following situation: in a distributed database for a specific period of time T is
required to obtain the answers to a set of requests Q. The problem raised is the redistribution of the
fragments as the size of the data transfers between the nodes for the same set of requests Q (if they are
repeated) to be decreased. The size of the transfer will be zero if the database in completed distributed
(so each fragment is stored in each node).

We’ll assume that the size of each node in the network is limited by a maximum value noted with
DMax, and the number of the replica r j for a fragment F j is between two limits:
1 <= r j <= RMax j , 0 <= j <n.

The problem of optimal redistribution of the fragments is quite difficult as the optimization performed
by the query optimizer must be taken into account and also must be taken into account the size of the
data transfer between the nodes. Due to the complexity of this problem, more heuristic algorithms were
proposed (for example [1, 3, 4, 7, 9, 10, 11]). We describe a new and much simpler algorithm which
offers an approximate solution for the proposed problem.

The result of generating an execution plan for a query q is a list of operators that should be evaluated:
op1(X) - for an unary operator or op2(X, Y) in case of binary operators, where X and Y are fragments
stored in the database or are the result of evaluating previous operators. If is an unary operator, then the
evaluation can be performed in the node where the operand is stored and no data transfer is required. In
case of a binary operator op2(X, Y), the evaluation can be performed in the node where the X fragment is
stored or is determined, or where the Y fragment is stored or is determined. The node is chosen in order
to minimize the data transfer size.

From the information obtained when evaluating the set of requests Q, in a fragment redistribution is
used only the information related to the data transfer: "the fragment X (or the fragment obtained from an
evaluation in a node where the fragment X is stored) is transferred in a node where is stored the fragment
Y (or the fragment obtained from an evaluation in a node where the fragment Y is stored)".

The data transfers occur only when evaluating binary operators. For example, for the evaluation
strategy b from the previous section the following transfers occur:



388 Leon Ţâmbulea, Manuela Horvat-Petrescu

Binary operator Data Fragment Observations
R’1 = A1 * B’1 B1, A1, d1 The meaning of the first line is: d1 is transferred

from a node where B1 is stored to a node where A1
is stored

R’2 = A1 * B’2 B2, A1, d1
R"1 = A2 * B’1 B1, A2, d1
R"2 = A2 * B’2 B2, A2, d2
R’ = R’1 ∪ R"2 A1, A1, d3 Does not require transfer
R" = R"1 ∪ R"2 A2, A2, d4 Does not require transfer
R = R’ ∪ R" A1, A2, d3

The final result where the fragment A2 with size d3 + d4 is stored must be transferred to the node S.

For a set of requests Q that were evaluated in a period of time, a journal with two types of information
can be created:

1. A set of tuples: T1 = { ( Fi, F j, di ), i ∈ I }, where a tuple t = (Fi, F j, di) has the meaning that
from a node that stores the Fi fragment, some data with size di is transferred in a node where the
fragment F j is stored.

2. A set of tuples: T2 = { ( Fq, Sq, dq ), q ∈ Q}, where a tuple t = (Fq, Sq, dq) corresponds to a query
q ∈ Q and has the following meaning: from the node where the fragment Fq is stored (and where
the query evaluation was finalized) some data with size dq are transferred in the node Sq where the
result for the query q is required.

The algorithm has two phases:

First phase: the distribution of the fragments in the virtual nodes is performed such as the total size
of the data transfer to be minimum.

Second phase: the m virtual nodes created in the first phase are associated with the real nodes in such
a manner as the size of the data transfer involved in answering the queries to be minimum.

A pair of fragments Fi and F j can be found in more than one tuple from T1 set, and can correspond
to a set of binary operators required by the queries from the set Q. If these two fragments are stored in
the same node, than there is no data transfer for neither one of the binary operators. In the proposed
algorithm, a matrix V = (vi, j) , 0 <= i, j <n will be determined. The vi, j represents the size/dimension
of the data fragments that don’t have to be transferred when evaluating the queries from Q in the case
when the fragments Fi and F j are stored in the same node.

The V matrix can be easily determined using the following algorithm:

1. vi, j = 0, 0 <= i, j <n;

2. For each t = (Fi, F j, di) ∈ T1: vi, j = vi, j + di;

3. For each 0 <= i <n, 0 <= j <i: w = vi, j + v j,i ; vi, j = w, v j,i = w

The V matrix is symmetrical and the values have the mentioned significance. The values: vi, j , 0 <=
j <= i <n represent the inferior block of the matrix V.

These values will be sorted in a descending order and will be used (in this order) to generate a new
data fragments distribution in the distributed database.

The proposed algorithm is given in the next paragraph and contains four phases:



Redistributing Fragments into a Distributed Database 389

1. For each node Si , 0 <= i <m the following initializations will be performed:

(a) si = 0; ( the size/dimension used by the node Si)

(b) Li =Φ; ( the set of the fragments stored in the node Si)

(c) For each fragment F j, 0 <= j <n: r j = 0; (the number of replicas of the fragment F j)

2. The values from the V matrix are retrieved in a descending order. A tuple t = (Fi, F j, vi, j)
corresponding to a value vi, j from the V matrix represents a gain obtained for the total transfer
size/dimension if the fragments Fi and F j are stored in the same node. For this tuple t will be
determined the node that offers the best advantage in the case that the mentioned fragments will
be added there. For finding this node, the algorithm will compute the gain ck obtained if these
fragments are attached to the node Sk, and will keep track of an indicator sitk. The value from sitk
is referring to the state of the fragments {Fi, F j } relative to the set Lk , for 0 <=k <m. (Lk is the
set of the nodes existing in Sk).

(a) If Fi ∈ Lk and F j ∈ Lk, (the fragments Fi, F j are already added to the node Sk, then:
ck = 0; sitk = 1;

(b) If Fi ∈ Lk and F j /∈ Lk, then:
If r j <RMax j and Sk + dim(F j) <= DMax, then

sitk = 2, ck = 0;

For Fp ∈ Lk : ck = ck + v j p;
Note: the fragment F j can be added to the node Sk and the gain obtained will be ck;

Else sitk = 1, ck = 0;

(c) If Fi /∈ Lk and F j ∈ Lk, then:
If ri <RMaxi and Sk + dim(Fi) <= DMax, then

sitk = 3, ck = 0;

For Fp ∈ Lk : ck = ck + vi p;
Else sitk = 1, ck = 0;

(d) If Fi /∈ Lk and F j /∈ Lk, then:
If ri <RMaxi and r j <RMax j, and Sk + dim(Fi) + dim(F j) <= DMax, then

sitk = 4, ck = vi j;

For Fp ∈ Lk : ck = ck + vi p+ v j p;
Else sitk = 1, ck = 0;

A node Sk with ck maxim will be determined. Depending on the value sitk the following data are
modified: Lk, Sk, ri, r j.

3. If a fragment Fi was not used in the binary operators obtained from Q in the period of time T
used to analyze and to evaluate the requests from set Q, then the result in the precedent step will
be ri = 0, and that means that the fragment Fi was not stored in the nodes of the network. In this
case, a node from the network with enough space to store the fragment Fi without removing other
fragments will be selected.

(a) sit = 0;

(b) For each 0 <= k <n:

If Sk + dim (Fi) <= DMax, then

Fi is added to the node Sk, (Sk, Lk will change; ri = 1);



390 Leon Ţâmbulea, Manuela Horvat-Petrescu

sit = 1;

Endif

If ind=0 after running the previous algorithm it means that the fragment Fi could not be
added to a node then other fragment Gk ∈ Lk will be searched for. The fragment Gk is chosen
as the node Sk will have the smaller lost when removing it:

(c) For 0 <= k <m:

ck =∞;

For each Fp ∈ Lk:
cc = ∑ vi, j; F j ∈ Lk, j 6= p
If cc <ck then ck = cc, Gk = Fp

(d) Is determined the Sk node having a minimum value for ck. In the Sk node the Gk fragment is
replaced by the Fi fragment. The value from Lk, ri, and r position corresponding to Gk will
be updated.

4. The Ri set containing the nodes where the fragment Fi is stored is computed for each fragment Fi.
(Ri is the set of the Fi replicas)

At the end of this algorithm were determined the value of Lk for each node Sk, 0 <= k <n. The virtual
nodes can be allocated to the real nodes using the information obtained from the set of requests Q. The
virtual nodes can be allocated to the real nodes according to the node where evaluation is required. This
allocation will be done using a second set of tuples: T2 = {(Fq, Sq, dq), q ∈ Q} . For a request q, if the
fragment Fq is stored in the node Sq (Sq is the node where the answer to the request q is required) then
the data with the size dq are not transferred.

We’ll assume that the virtual nodes where the fragments are allocated are S k, 0 <= k <m, and the
real nodes from the distributed database are SR k, 0 <= k <m.
With ci, j is noted the total gain obtained when transferring the answers of the requests from Q if the
virtual node Si is stored in the real node SR j. (ci, j is the size of the data from all the answers for all the
requests that are transferred from Si to SR j.) The ci, j values can be computed as follows:

ci, j = 0; 0 <= i , j <m;

For each t = (Fi, SR j, d) ∈ T2,

For each Sk ∈ Ri (the nodes containing Fi replicas):
ck, j = ck, j + d

Is build a graph with the nodes Sk, SRk, 0 <= k <m, and the value ci, j will be associated to the line
from Si to SR j. For this graph is determined the maximum cupling with the maximum value [2]. Using
this coupling, a virtual node Si will correspond to a real node SR j where the Li replicas are stored. Using
this redistribution the Ri set could be recomputed.

4 Fragments transfer plan when evaluating requests

A request q is split by the execution plan in as set of operators {op0, ... opn−1}. The result of the
request q is the result of evaluating the last operator, as the other operators generate intermediate results.
Evaluation plans can be created for each operator, these plans detailing all the data transfers required in
the evaluation process and the size of the transfers. If more than one evaluation plan (that evaluates in
the same manner) can be created for an operator, than the plan that requires less data (in terms of size)



Redistributing Fragments into a Distributed Database 391

for transfer will be used.

Coming next is an evaluation plan for a request showing the data transfers. The plan can be noted
with:

P = ( evaluationList; dim),

where "evaluationList" is a succession of actual evaluation of the operators:

evaluationList : (nodi, op1, nod f ) [, (nodi’, op2, nod f ’)]...

A tuple (nodi, op1, nod f ) has the following meaning: the operator "op1" is evaluated in the "nod f "
after a data transfer from "nodi". If nodi = nod f then there is no data transfer when the operator is evalu-
ated (the unary operators always encounter this situation). The fragments used from the nodes nodi and
nod f are effectively stored in the nodes or are the result of previous evaluations performed in these nodes.

"dim" is the total size/dimension of the data transferred in order to evaluate the plan from the evalu-
ationList. This size can represent:
a) the number of the transfers involved in evaluation
b) an average size/dimension of the transferred data. The average size can be found by using values v’i, j
computed in the same time with the values vi, j from section 3. (v’i, j would be the average size of the
data transferred between the node Si and S j when the request set Q is evaluated.)

In the following algorithm will be used for simplicity the first meaning of the "dim" (explained in the
paragraph a) from above).

We will note with P(op) the set of evaluation plans for an operator op. If p = (t0, t1, .... tn−1; d) ∈
P(op) where ti = (S1 i, opi, S

2
i), then the following notations can be used:

dim(p) = d;

plan(p) = t 0, t 1, .... t n− 1 = the transfers list required by the plan p
result(p) = S2 n − 1 = the node where can be found the result of the plan p evaluation

An algorithm for generating the plan P(op) is presented in the following paragraph (the data transfers
are taken into consideration).

1. If "op" is an unary operator, so it has the form op(x) then:

(a) If x is a fragment stored in the distributed database then
P(op) = {((S, op, s); o)|S ∈ R(X )},
where R(X) represents the set of the nodes where the fragment x is stored.

(b) If x is a fragment obtain from a previous evaluation of an operator op’ then:
P(op) = {(plan(p), (result(p), op, result(p)); dim(p))|p ∈ P(op)}

2. If "op" is a binary operator, so it has the form op(x,y) then:

(a) If x and y are fragments stored in the distributed database then:
P(op) = { ( (S1, op, S2) ; 1) where S1 ∈ R(X) - R(Y) , S2 ∈ R(Y)}
∪ { ( (S1, op, S2) ; 1) where S1 ∈ R(Y) - R(X) , S2 ∈ R(X)}
∪ { ( (S1, op, S1) ; 0) where S1 ∈ R(X) ∩ R(Y)}.

The evaluation of the operator "op" can be made in a node where the fragment x is stored
and fragment y is transferred, or in a node where the fragment y is stored and fragment x is



392 Leon Ţâmbulea, Manuela Horvat-Petrescu

transferred, or in a node where both fragments are stored.

(b) If x is a fragment stored in the distributed database and y is a fragment obtained from a pre-
vious evaluation of a op’ operator, then:

P(op) = P1(op) ∪ P2(op) ∪ P3(op) where:
P1(op) = {(plan (p), (result(p), op, S); dim(p) + 1)

where p ∈ P(op’), S ∈ R(X) - { result(p) }}

P2(op) = {(plan (p), (S, op, result(p)); dim(p) + 1)}

where p ∈ P(op’), S ∈ R(X) - { result(p) }}

P3(op) = {(plan(p), ( result(p), op, result(p)); dim(p))

where p ∈ P(op’), if result(p) in R(X)}
The evaluation of the operator "op’" can be made in:
- a node where the fragment x is stored by transferring the result from a node where op’ can
be evaluated
- in a node where op’ is evaluated by transferring the x fragment
- a node there op’ can be evaluated and where the fragment x is stored

(c) If x is a fragment obtained from a previous evaluation of a op’ operator and y is a fragment
stored in the distributed database, the plan is build as in b2.

(d) If x and y are the results of evaluation the operators op1 and op2 then:

P(op) = P1(op) ∪ P2(op) ∪ P3(op) where:
P1(op) = {(plan (p1), plan (p2), (result(p1), op, result(p2)); dim(p1) + dim(p2) + 1)

where p1 ∈ P(op1), p2 ∈ P(op2), result(p1) 6= result(p2)}

P2(op) = ∪ {(plan(p1), plan(p2), (result(p2), op, result(p1)); dim(p1) + dim(p2) +1)
where p1 ∈ P(op1), p2 ∈ P(op2), result(p1) 6= result(p2)}

P3(op) = ∪ {(plan(p1), plan(p2), (result(p1), op, result(p1)); dim(p1) + dim(p2))
where p1 ∈ P(op1), p2 ∈ P(op2), result(p1) = result(p2)}.

After the plans were generated in the cases a2, b2, b3, b4 there is the chance to obtain for an operator
two different plans p1 6= p2 but with the same final evaluation node f inal(p1) = f inal(p2). In this case
is chosen the plan with smaller dim. Using this transformation an operator will have maximum one plan
for a final node.

Example: Considering the following distribution of the fragments:

Node S1 S2 S3
Fragments A B A, C

Assuming the request: q = (A * σ c (B)) ∪ C.
The operator’s plans are:



Redistributing Fragments into a Distributed Database 393

P(σ c ) = {(( S2, σ c, S2); 0 )}

P( * ) = {(( S2, σ c, S2), (S2, *, S1); 1), ((S2, σ c, ,S2), (S2, *, S3); 1),

((S2, σ c, S2), (S1, *, S3); 1), ((S2, σ c, S2), (S3, *, S2); 1)}

P( ∪) = {((S2, σ c, S2), (S2, *, S1), (S1, ∪, S3 ); 2),

(( S2, σ c, S2), ( S2, *, S3); ( S3, ∪, S3 ); 1),
........ }

In the previous example can be noticed that exists a request evaluation plan with only one transferred
fragment.

5 Conclusion

In section 3 is proposed an algorithm for redistribution of the fragments of a distributed database. The
algorithm uses the request execution plan and some information that can be obtained when evaluating
the relational determinant operators from the execution plan. This algorithm minimizes the size of the
data transferred between the nodes of the network when the requests are evaluated.

For evaluating a request several fragments are needed, the fragments are stored in the nodes of a
distributed database. An algorithm that determines an execution plan which minimizes the number of
the fragments transferred between the nodes is proposed in section s4.

The results can be extended as follows:
-In the data transfer take into consideration the cost of the transfer instead of the size of the transferred
data.
-In redistribution algorithm use a maximum size/dimension for each node instead a unique maximum
size for all nodes.
-In the algorithm that finds the transfer plan between the nodes (algorithm used to evaluate a request) use
a transfer cost instead of the number of the tranferred fragments.

Bibliography

[1] C.H. Cheng, W.K. Lee, K.F. Wong, "A Genetic Algorithm-Based Clustering Approach for Database Partition-
ing", IEEE Transactions on Systems Man and Cybernetics Part C-Applications and Reviews, 32: 215-230,
2002.

[2] R. Diestel, "Graph Theory", Springer-Verlag, Heidelberg 2000, Electronic Edition.

[3] J. Graham, "Efficient Allocation in Distributed Object Oriented Databases", Proceedings of the ISCA 16th
International Conference on parallel and Distributed Computing Systems , Reno Nevada, August 2003.

[4] Y. Huang, J. Chen, "Fragment Allocation in Distributed Database Design", Fragment Allocation in Distributed
Database Design, Journal Of Information Science And Engineering, 17, 491-506 (2001).

[5] I. Lungu, A. G. Fodor, "Optimizing Queries in Distributed Systems," Revista Informatica Economica nr. 1
(37), 67-72, 2006.

[6] M. T. Õzsu and P. Valduriez, "Principles of Distributed Database Systems", 2nd ed., Prentice-Hall Interna-
tional Editions, 1999.



394 Leon Ţâmbulea, Manuela Horvat-Petrescu

[7] A. Sleit, W. AlMobaideen, S. Al-Areqi, A. Yahya, "A Dynamic Object Fragmentation and Replication Algo-
rithm In Distributed Database Systems", American Journal of Applied Sciences 4 (8), 613-618, 2007.

[8] L. Tâmbulea, M. Horvat, "Dynamic Distribution Model in Distributed Database", Int. J. of Computers, Com-
munications & Control, ISSN 1841-9836, E-ISSN 1841-9844, Vol. III (2008), Suppl. issue: Proceedings of
ICCCC 2008, pp. 512-515.

[9] T. Ulus, M. Uysal, "Heuristic Approach to Dynamic Data Allocation in Distributed Database Systems", Pak-
istan Journal of Information and Technology 2 (3) , 231-239, 2003.

[10] S. Upadhyaya, S. Lata, "Task allocation in Distributed computing VS distributed database systems: A Com-
parative study", IJCSNS International Journal of Computer Science and Network Security , VOL.8 No.3,
March 2008.

[11] O. Wolfson, S. Jajodia, "An Algorithm for Dynamic Data Distribution", Proceedings of the 2nd Workshop
on the Management of Replicated Data (WMRD-II) , Monterey, CA, Nov. 1992.

Leon Ţâmbulea
Babeş Bolyai University, Cluj-Napoca

Faculty of Mathematics and Computer Science
Department of Computer Science

M.Kogãlniceanu No.1
E-mail: leon@cs.ubbcluj.ro

Manuela Horvat
Babeş Bolyai University, Cluj-Napoca

Faculty of Mathematics and Computer Science
Department of Computer Science

M.Kogãlniceanu No.1
E-mail: manuela.petrescu@gmail.ro

ManuelaHorvat-Petrescu is a PhD.C. in Computer Science De-
partment at Faculty of Mathematics and Computer Science of
Babes Bolyai university of Cluj-Napoca.She received the Batch-
elor Degree in Computer Science, Master Degree in Component
Based Programming and is working now as a Software Engineer
in Montran Corporation.