Base de Datos Distribuidas Base de Datos en Múltiples Servidores

Curso:
Base de Datos Distribuidas
Unidad 2:
Base de Datos en Múltiples
Servidores
M. en C. José Mario Martínez Castro
Chilpancingo, Gro., Febrero del 2007
Bases de Datos Distribuidos
CONTENIDO
2.1. Diseño de la Base de Datos Distribuidas.
2.2. Consideraciones para Distribuir las Bases de Datos.
2.3.Procesamiento de Consultas Distribuidas
2
Bases de Datos Distribuidos
Diseño de base de datos distribuidas
Problema de diseño.
En un marco general.
Tomar decisiones acerca de la ubicación de los datos y los programas, en los
sitios de una red de computadoras, así como también posiblemente el diseño de
la propia red.
En los sistemas administradores de las Bases de Datos Distribuidas, la ubicación de las
aplicaciones supone
Ubicación del software de los sistemas administradores de las Bases de Datos
Distribuidas.
Ubicación de las aplicaciones que corren sobre la base de datos.
Diseño de la distribución.
Descendente
Principalmente en sistemas que inician de cero.
Principalmente en sistemas homogéneos.
Ascendente
Cuando las base de datos ya existen en los diferentes sitios.
Diseño descendente.
3
Bases de Datos Distribuidos
Análisis de
Requerimientos
Req. del sistema
(Odjetivos)
Entrada del Usuario
Diseño
Conceptual
Esq. Concep. Global
Integración de Vistas
Diseño de
Vistas
Información de
Acceso
Definición del
Esquema Externo
Diseño de la
Distribución
Esq. Concep. Local
Entrada del
Usuario
Diseño físico
Esquema Físico
Retroalimentación
Observ. Y Monit.
Retroalimentación
Problemática del diseño de la distribución
4
Bases de Datos Distribuidos
¿Por qué Fragmentar todo?
¿Cómo Fragmentar?
¿Cuánto Fragmentar?
¿Cómo probar la correctez?
¿Cómo ubicar los fragmentos?
¿Qué requerimientos de información?
Consideraciones para distribuir la base de datos
Requerimientos de información
Cuatro categorías
Información de la base datos.
Información de la aplicación
Información de la red de comunicaciones.
Información del sistema de cómputo.
1. Información de la base datos.
Selectividad de fragmentos.
Tamaño de un fragmento.
2. Información de la aplicación
Tipos de acceso y número.
Acceso a sitios.
5
Bases de Datos Distribuidos
3. Información de la red de comunicaciones
Ancho de banda.
Distancia entre sitios.
Sobrecarga de protocolos.
4. Información del sistema de cómputo
Unidad de costo de almacenar datos en un sitio.
Unidad de costo de procesar datos en un sitio.
Fragmentación.
Una relacion r estara fragmentada cuandos e divida en cierto numero de
fragmentos r1, r2, ..., rn.
Estos fragmentos contienen información suficiente para permitir la reconstrucción de la
relación original r.
Ejemplo:
E
ENO
E1
E2
E3
E4
E5
E6
E7
E8
J
G
ENAME
J.Doc
M.Smith
A.Lee
J. Miller
H. Casey
I. Chii
R.Davis
J.Jones
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
Syst. Anal.
Elect. Eng.
Mech. Eng.
Syst. Anal.
ENO
E1
E2
E2
E3
E3
E4
E5
E6
E7
E7
E8
JNO
J1
J1
J2
J3
J4
J2
J2
J4
J3
J3
J3
RESP
Manager
Analyst
Analyst
Consultant
Engineer
Programmer
Manager
Manager
Engineer
Engineer
Manager
DUR
12
24
6
10
48
18
24
48
36
23
40
S
6
Bases de Datos Distribuidos
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
BUDGET
150000
135000
250000
310000
500000
LOC
Montreal
New York
New York
Paris
Boston
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
SAL
40000
34000
27000
24000
Fragmentación
¿Podemos distribuir solo relaciones?
¿Cuál es la unidad razonable de distribución?
Relación.
¾ Las vistas son subconjuntos de relaciones (localmente).
¾ Comunicación extra.
Fragmentación de (sub-relación)
¾ Ejecución de un número de transacciones que acceden diferentes
porciones de una relación.
¾ Las vistas que no pueden ser definidas sobre un solo fragmento
requerirán procesamiento extra.
¾ El control de la semántica de datos (especialmente forzar la integridad)
es mas compleja.
7
Bases de Datos Distribuidos
Grado de fragmentación.
Numero finito de alternativas.
Tuplas o
Atributos
Relaciones
Encontrar el nivel adecuado de particionamiento dentro de este rango.
Correctez de la fragmentación.
Completez
¾ La descomposición de una relación R en fragmentos R1, R2, ..., Rn, es
completa si y solo si cada elemento de datos en R puede ser encontrado
en algún Ri.
Reconstrucción.
¾ Si la relación R se descompone en fragmentos R1, R2, ..., Rn, debiera
existir un operador relacional ∇ tal que R = ∇ Ri, Ri ∈FR.
Excluyente.
¾ Si la relación R se descompone en fragmentos R1, R2, ..., Rn, y datos del
elemento d1 están en Rj entonces d1 no debiera estar en algún otro
fragmento Rj (j≠k)
Tipos de fragmentación
Fragmentación horizontal (FH).
¾ Fragmentación horizontal primaria (FHP).
¾ Fragmentación horizontal derivada (FHD).
8
Bases de Datos Distribuidos
Fragmentación vertical (FV).
Fragmentación híbrida o mixta (FM).
Fragmentación horizontal
La relación r se divide en cierto numero de subconjuntos de tuplas r1, r2, ..., rn.
Se define como una selección de la relación global r, utilizando un predicado p1.
Ri = σp1(r)
Cada tupla de la relación r debe de pertenecer al menos a uno de los fragmentos.
Se puede reconstruir tomando la unión de todos los fragmentos.
r = r1 ∪ r2 ∪ …∪ rn.
Alternativas: fragmentación horizontal.
J
J1 Proyectos con presupuestos
Menor que $200,000.
J1 Proyectos con presupuestos
Mayor o igual que $200,000.
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
BUDGET
150000
135000
250000
310000
500000
LOC
Montreal
New York
New York
Paris
Boston
J1
JNO
JNAME
BUDGET LOC
J1 Instrumentation 150000 Montreal
J2 Database Develop 135000 New York
J1 = σBUDGET <200000 (J)
9
Bases de Datos Distribuidos
J2
JNO JNAME
J3 CAD CAM
J4 Maintenance
J5 CAD CAM
BUDGET LOC
250000 New York
310000 Paris
500000 Boston
J2 = σBUDGET ≥200000 (J)
FHP- Requerimientos información
Información de la Base de Datos.
¾ Relaciones
S
TITLE, SAL
L1
UNO, ENAME, TITLE
E
J JNO, JNAME, BUDGET, LOC
G
ENO, JNO, RESP, DUR L12
L3
¾ Cardinalidad De cada relación card(R)
Información de la aplicación.
¾ Predicados simple: dada R[A1, A2, ..., An], un predicado simple pj es:
Pj : A θ valor
Donde θ ∈{=, ≠, <, ≤, >, ≥}, Valor ∈ D, y D es el Dominio de A.
Ejemplo:
JNAME = ‘Maintenance’
Budget ≤ ‘200000’
10
Bases de Datos Distribuidos
¾ Predicados minterm: dado R, y Pr = {P1p, PValor, Pim}
define M1 = {mi1, mi2,, ..., miz} como
M1 = {mi1 !mij = Vpik∈ Pri Pik*}. ¡l ≤ k ≤ m. L ≤ j ≤ z
donde Pik* Pi o Pik* Pi.
Ejemplos de predicados minterm:
¾ M1 : JNAME =’Maintenance’ ∧ BUDGET ≤ 200000
¾ M1 : ¬ (JNAME =’Maintenance’) ∧ BUDGET ≤ 200000
¾ M1 : JNAME =’Maintenance’ ∧ ¬ (BUDGET ≤ 200000)
¾ M1 : ¬ (JNAME =’Maintenance’) ∧ ¬ (BUDGET ≤ 200000)
Información de la aplicación
¾ Selectividad de predicados minterm: self(mj)
¾ Numero de tuplas de la relación que son accesadas por una consulta de
usuario la cual esta especificada por un predicado minterm m1n dado.
¾ Frecuencia de acceso: acc (q1).
¾ Frecuencia con la cual la aplicación q1 accesa datos. Análogamente se puede
definir le frecuencia de acceso para un predicado minterm.
Fragmentación horizontal primaria
Definición:
Rij = σ Fj (Ri), l ≤ j ≤ w
Donde F es la formula de selección usada para obtener el fragmento Rij, el cual es
(preferiblemente) un predicado minterm.
11
Bases de Datos Distribuidos
Por lo tanto.
Una fragmentación horizontal R1 de una relación R cosiste de todas las tuplas de R
las cuales satisfacen un predicado minterm.
Dado un conjunto de predicados minterm M, hay tantas fragmentaciones
horizontales de la relación R como predicados minterm existan.
A los fragmentos horizontales se les llama fragmentos minterm.
FHP – Obtención de Predicados Simples
Datos: Una relación R, y el conjunto de predicados simples Pr.
Obtener: El conjunto de fragmentos de R={R1, R2,…, Rw} los cuales obedecen las reglas de
fragmentación.
Preliminares:
Pr debe ser completo.
Pr debe ser mínimo.
Completez de los Predicados Simples.
Se dice que un conjunto de predicados simples Pr es completo si sólo si el acceso a las
tuplas de los fragmentos minterm definidos sobre Pr requiere que dos tuplas del mismo
fragmento minterm tengan la misma probabilidad de ser acezadas por todas y cada una de las
aplicaciones.
Ejemplos:
12
Bases de Datos Distribuidos
Suponemos que J(JNO, JNAME, BUDGET, LOC) tiene dos aplicaciones definidas para
trabajar sobre J:
1. Encontrar los presupuestos de los proyectos en cada localidad.
2. Encontrar los proyectos con presupuesto menor que $200000.
De acuerdo a (1)
Pr = { LOC=”Montreal”, LOC=”New York”, LOC=”Paris”}
Lo cual no es complete con respecto a (2)
Si modificamos
Pr = {LOC=”Montreal”, LOC=”New York”, LOC=”Paris”,
BUDGET<= 200000, BUDGET>200000}
El cual es completo.
Minimalidad de los Predicados Simples
Si un predicado influye en cómo se ejecuta la fragmentación (v.g. provoca un
fragmento f se particione en nuevos fragmentos fi y fj), entonces debiera existir al
menos una aplicación que accese a fi y fj diferentemente.
En otras palabras el predicado simple deberá ser relevante en determinar una
fragmentación.
Si todos los predicados de un conjunto Pr son relevantes, entonces Pr es mínimo.
Relevancia de los Predicados Simples
13
Bases de Datos Distribuidos
Sean mi y mj dos predicados minterm idénticos en su definición, excepto que mi contiene
el predicado simple pi mientras que mj contiene –pi y sean fi y fj dos fragmentos definidos de
acuerdo a mi y mj , entonces pi es relevante si y sólo si la relación de acceso es relevante.
acc(mi) ≠ acc(mj)
card(fi) card(fj)
Minimalidad de los Predicados Simples
Ejemplo:
Pr = {LOC=”Montreal”, LOC=”New York”, LOC=”Paris”,
BUDGET<= 200000, BUDGET>200000}
Es mínimo además de ser completo.
Sin embargo, si agregamos JNAME = “Instrumentación” entonces Pr no es mínimo.
FHP- Ejemplo
Dos relaciones candidatas: S y J.
Fragmentación de la relación S:
¾ Aplicación: verificar salario y determinar aumento.
¾ Los registros de empleados se manipulan en dos sitios => la aplicación corre en
dos sitios.
¾ Predicados simples:
P1: SAL ≤ 30000
P2: SAL < 30000
Pr: {p1, p2} el cual es completo y mínimo Pr’= Pr
¾ Predicados minterm
14
Bases de Datos Distribuidos
M1 : (SAL ≤ 30000) ^ (SAL < 30000)
M1 : (SAL ≤ 30000) ^ ⌐(SAL < 30000)
M1 : ⌐ (SAL ≤ 30000) ^ (SAL < 30000)
M1 : ⌐ (SAL ≤ 30000) ^ ⌐(SAL < 30000)
¾ Implicaciones
I1:(SAL ≤ 30000) => ⌐(SAL < 30000)
I2: ⌐ (SAL ≤ 30000) => (SAL < 30000)
I3:(SAL > 30000) => ⌐(SAL ≤ 30000)
I4: ⌐ (SAL > 30000) => (SAL ≤ 30000)
¾ mi es conradictorio a i1, m1 es contradictorio a i1
S1
S2
TITLE
SAL
TITLE
SAL
Mech. Eng.
27000
Elect. Eng.
400000
Programmer
24000
Syst. Anal.
340000
Fragmentación de la relación J:
¾ Aplicaciones:
Encontrar el nombre y el presupuesto de los proyectos dado su número.
Estas consultas son emitidas en tres sitios.
Acceder la información del proyecto de acuerdo a su presupuesto.
¾ Predicados simples para la aplicación (1):
P1: LOC = “Montreal”
P2: LOC = “New York”
P3: LOC = “París”
¾ Predicados simples para la aplicación (2):
15
Bases de Datos Distribuidos
P4: BUDGET ≤ 200000
P5: BUDGET > 200000
¾ Pr = Pr’ = { p1, p2, p3, p4, p5}
¾ Fragmentos minterm después de la eliminación:
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)
JNO
J1
J1
JNAME
Instrumentación
BUDGET
150000
LOC
Montreal
BUDGET
1350000
LOC
New York
BUDGET
250000
LOC
New York
BUDGET
310000
LOC
Paris
J2
JNO
J1
JNAME
Database
Develop
J4
JNO
J1
JNAME
CAD/CAM
J6
JNO
J1
JNAME
Maintenances
16
Bases de Datos Distribuidos
Ejemplo 1
Dividir las tablas de trabajo (J) en función del proyecto de mantenimiento cuyos presupuestos
sean menores o iguales a 200,000
1) Tabla a Fragmentar
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
BUDGET
150000
135000
250000
310000
500000
LOC
Montreal
New York
New York
Paris
Boston
2) Predicados Simples
P1: úname =”MAintenance” | P1: Jname ≠ “Maintenance”
P2: Budget ≤ 200,000
3) Generar los productos minterm
M1 =P1 ∧ P2
M2 =P1 ∧ ¬P2
M3 =¬P1 ∧ P2
M4 =¬P1 ∧ ¬P2
Sustituyendo Terminos
M1 : Jname = “Maintenance” & budget ≤ 200,000
M2 : Jname = “Maintenance” & budget > 200,000
M3 : Jname ≠ “Maintenance” & budget ≤ 200,000
M4 : Jname ≠ “Maintenance” & budget > 200,000
4) Crear instrucciones de algebra relacional para identificar los fragmentos
J1 = σm1(J) = σJName =”Maintenance” and budget ≤ 200,000 (J)
17
Bases de Datos Distribuidos
J2 = σm2(J) = σJName =”Maintenance” and budget >200,000 (J)
J3 = σm3(J) = σJName ≠ ”Maintenance” and budget ≤ 200,000 (J)
J4 = σm4(J) = σJName ≠ ”Maintenance” and budget > 200,000 (J)
5) Crear los fragmentos
J1
JNo. JName Budget Loc
φ
φ
φ
φ
J2
JNo.
JName
Budget Loc
J4
Maintenance 310,000 París
J3
JNo.
JName
Budget
Loc
J1
Instrument 150,000 Montreal
J2 Data Develop 135,000 New York
J4
JNo. JName Budget
Loc
J3 CAD/CAM 250,000 New Cork
J5 CAD/CAM 500,000 Boston
6) Comprobar la correctez
6.1. Completo, cada elemento de R debe encontrarse en algún Ri
6.2. Reconstruible
J = J1∪J2∪J3∪J4∪J5
J1, J2, J3, J4,J5 = J1, J2, J3, J4,J5
6.3. Excluyente, cada elemento de R debe pertenecer a un fragmento
Ejemplo 2
18
Bases de Datos Distribuidos
Encontrar los datos de los proyectos en función de la localidad y el presupuesto (≤ 200,000).
1) Tabla a fragmentar
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
BUDGET
150000
135000
250000
310000
500000
LOC
Montreal
New York
New York
Paris
Boston
2) Encontrar predicados simples
P1: Loc = “Montreal”
P2: Loc = “New York”
P3: Loc = “París”
P4: Loc =”Boston”
P5: Budget ≤ 200,000
3) Encontrar predicados minterm
M1 =P1 ∧ P5
M2 =P1 ∧ ¬P5
M3 =P2 ∧ P5
M4 =P2 ∧ ¬P5
M5 =P3 ∧ P5
M6 =P3 ∧ ¬P5
M7 =P4 ∧ P5
M4 =P4 ∧ ¬P5
Sustituyendo Términos
M1 : Loc = “Montreal” & budget ≤ 200,000
M2 : Loc = “Montreal” & budget > 200,000
M3 : Loc = “New York” & budget ≤ 200,000
19
Bases de Datos Distribuidos
M4 : Loc = “New York” & budget > 200,000
M5 : Loc = “París” & budget ≤ 200,000
M6 : Loc = “París” & budget > 200,000
M7 : Loc = “Boston” & budget ≤ 200,000
M8 : Loc = “Boston” & budget > 200,000
4) Instrucciones de algebra relacional
J1 = σm1(J) = σLoc =”Montreal” and budget ≤ 200,000 (J)
J2 = σm2(J) = σLoc =”Montreal” and budget >200,000 (J)
J3 = σm3(J) = σ Loc = ”New York” and budget ≤ 200,000 (J)
J4 = σm4(J) = σLoc = ”New York” and budget > 200,000 (J)
J5 = σm5(J) = σLoc = ”París” and budget ≤ 200,000 (J)
J6 = σm6(J) = σLoc =”París” and budget >200,000 (J)
J7 = σm7(J) = σLoc = ”Boston” and budget ≤ 200,000 (J)
J8 = σm8(J) = σLoc = ”Boston” and budget > 200,000 (J)
5) Crear los fragmentos
J1
J2
JNo. JName Budget
Loc
J1 Instrument 150,000 Montreal
J3
JNo. JName Budget Loc
φ
φ
φ
φ
J4
JNo. JName Budget
Loc
J2 Data Base 150,000 New York
JNo. JName Budget
Loc
J3 CAD/CAM 250,000 New York
J5
20
Bases de Datos Distribuidos
J6
J7
J8
Derivada
JNo. JName Budget Loc
φ
φ
φ
φ
JNo.
JName
Budget Loc
J4 Maintenence 310,000 París
JNo. JName Budget Loc
φ
φ
φ
φ
JNo. JName Budget Loc
Fragmentación
J5 CAD/CAM 500,000 Boston
Horizontal
Definida sobre una relación miembro de una liga según una operación de selección
especificada sobre su relación propietaria.
¾ Cada enlace corresponde a una equireunión.
S
TITLE, SAL
L1
E
J
ENO, ENAME TITLE
JNO, JNAME, BUDGET, LOC
L2
L3
G
ENO, JNO, RESP, DUR
21
Bases de Datos Distribuidos
FHD – Definición
Dado un enlace L donde propietario (L)= S y miembro (L) = R, la fragmentación horizontal
derivada de R se define como
R i= R
SP 1 ≤ i ≤ w
Donde w es el número máximo de fragmentos que serán definidos en R1 y S1= σF1(S), donde F1 es
la formula mediante la cual se define la fragmentación horizontal primaria S1
FDH – Ejemplo
Dado el enlace L1, donde propietario (L1)=S y miembro (L1)=E
E1=E
E2=E
S1
S2
Donde:
S1=σSAL ≤ 300000(S)
S1=σSAL > 300000(S)
FHD – Correctez
Completez.
¾ Integridad referencial
¾ Sea R la relación miembro de un enlace cuyo propietario es la relación S la cual está
fragmentada como FS={S1, S2,…, Sw}. Además se A el atributo de la reunión entre Ry
S. Entonces para cada tupla t de R, debiera existir una tupla t’ de S tal que
t[A]= t’[A]
Reconstrucción
¾ Igual que la fragmentación horizontal primaria.
22
Bases de Datos Distribuidos
Exclusión.
¾ Si el grafo de la reunión entre el propietario y los fragmentos miembros
es posible.
Fragmentación Vertical
La relación R se divide en cierto número de subconjuntos de tuplas, R1, R2,… Rn
Se define como una descomposición de la relación R.
¾ ri=πRi
Se debe incluir la llave primaria en cada fragmento.
Cada atributo de la relación R debe pertenecer solo a uno de los fragmentos, a excepción de
la llave primaria.
Se puede reconstruir tomando la reunión natural de todos los fragmentos.
FV – Correctez
¾ r = r1
r2
rn
Una relación R, definida sobre un conjunto de atributos A y clave K, genera la
partición vertical FR={R1, R2,…, R1,}.
Completez. Lo siguiente debiera satisfacerse:
A=UA
Reconstrucción. La reconstrucción puede efectuarse mediante
R=
k RP
V Ri Є FR
Exclusión.
23
Bases de Datos Distribuidos
Los identificadores no se consideran para ser traslapados ya que son mantenidos por el
sistema.
Las llaves duplicadas no se consideran para ser traslapadas.
Ejemplo 1
Realizar la FHD de E en Función del Salario ≤ 30, 000
1) Tabla a fragmentar
ENO
E1
E2
E3
E4
E5
E6
E7
E8
ENAME
J.Doc
M.Smith
A.Lee
J. Miller
H. Casey
I. Chii
R.Davis
J.Jones
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
Syst. Anal.
Elect. Eng.
Mech. Eng.
Syst. Anal.
2) Criterio de Fragmentación (predicados)
P1: Sal ≤ 30, 000
El atributo no pertenece a la tabla
3) Identificación de las ligas de la tabla E (llave foránea)
L1 = S (title): E (Title)
El atributo (Sal) si pertenece a la tabla (S)
4) Realizar la FHP de la tabla (S)
P1: Sal ≤ 30, 000
M1 = P1= Sal≤ 30, 000
M2= ¬P1 = Sal >30,000
S1 =σm1 (S) =σSal≤30,000 (S)
24
Bases de Datos Distribuidos
S2 =σm2 (S) =σSal>30,000 (S)
5) Obtener los fragmentos de ( E) en función de los fragmentos de (S)
E1
Ri = R
Si
E1 = E
S1
E2 = E
S2
• Identificar las tuplas de R que se encuentren en S
• Conservando la estructura de atributos de la R
E2
ENO
E3
E4
E7
ENO
E1
E2
E5
E6
E8
ENAME
TITLE
A.Lee Mech. Eng.
J. Miller Programmer
R. Davis Mech. Eng.
ENAME
J.Doc
M.Smith
H. Casey
I. Chii
J.Jones
TITLE
Elect. Eng.
Syst. Anal.
Syst. Anal.
Elect. Eng.
Syst. Anal.
6) Identificar los fragmentos físicamente
S1
S2
TITLE
SAL
Mech. Eng. 27000
Programmer 24000
TITLE
SAL
Elect. Eng. 40000
Syst. Anal. 34000
7) FHD. Correctez
Completez. Cada tupla E debe estar al menos en un fragmento (Ei)
Reconstruible. Unir fragmentos que dará como resultado a la tabla
Excluyente. Cada tupla debe existir solo en un fragmento (Ei)
Ejemplo 2
25
Bases de Datos Distribuidos
Dadas las relaciones de las tablas, elabore la fragmentación de la tabla G en función del
presupuesto ≤ 200,000
1) Identificar la tabla a fragmentar G
ENO
E1
E2
E2
E3
E3
E4
E5
E6
E7
E7
E8
JNO
J1
J1
J2
J3
J4
J2
J2
J4
J3
J3
J3
RESP
Manager
Analyst
Analyst
Consultant
Engineer
Programmer
Manager
Manager
Engineer
Engineer
Manager
DUR
12
24
6
10
48
18
24
48
36
23
40
2) Criterio de fragmentación (predicados)
P1: Budget ≤ 200,000
3) Identificación de las ligas de la tabla G
L1= J (JNo): G(JNo)
4) Realizar la FHP de la tabla (J)
P1: Budget ≤ 200,000
M1 = P1 =Budget ≤ 200,000
M2 = ¬P2 = Budget > 200,000
J1=σm1 (J) =σBudget ≤ 200,000 (J)
J2=σm2 (J) =σBudget>200,000(J)
26
Bases de Datos Distribuidos
5) Obtener los fragmentos de (G) en función de los fragmentos de (J)
G1 = G
G2 = G
J1
J2
G1
ENO
E1
E2
E2
E4
E5
G2
JNO
J1
J1
J2
J2
J2
RESP
Manager
Analyst
Analyst
Programmer
Manager
DUR
12
24
6
18
24
ENO
E3
E3
E6
E7
E7
E8
JNO
J3
J4
J4
J3
J3
J3
RESP
Consultant
Engineer
Manager
Engineer
Engineer
Manager
DUR
10
48
48
36
23
40
6) Identificar los fragmentos físicamente
J1
J2
JNo.
JName
Budget
Loc
J1 Instrumentation 150,000 Montreal
J2 Database Dev. 135,000 New York
JNo.
JName
Budget
Loc
J3
CAD/CAM 250,000 New York
J4 Maintenance 310,000
París
J5
CAD/CAM 500,000 Boston
7) FHP. Correctez
Completez, cada tupla de G debe estar al menos una vez en un fragmento Gi
Reconstruible, G= G1∪ G2
Excluyente, cada tupla debe existir solo en un fragmento Gi
Fragmentación Vertical
27
Bases de Datos Distribuidos
Ha sido estudiada dentro del contexto centralizado.
ƒ Metodología de diseño.
ƒ Agrupamiento físico.
Más difícil que la horizontal, debido a que existen más alternativas.
Existen dos técnicas.
ƒ Agrupamiento de atributos en fragmentos.
ƒ División de la relación en fragmentos.
Traslape de fragmentos
ƒ Agrupamientos
Sin traslape de fragmentos.
ƒ División.
No se considera traslape en los atributos llave replicados. Ventaja: facilita hacer
cumplir las dependencias funcionales (para verificar integridad, etc.)
Ejemplo 1
Fragmentar la tabla de trabajo (J) en función de la información presupuestal.
1) Identificar la tabla J
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
BUDGET
150000
135000
250000
310000
500000
LOC
Montreal
New York
New York
Paris
Boston
28
Bases de Datos Distribuidos
2) Identificar los grupos de atributos y llaves primarias
R1 = budget
R2 = JName, Loc
Pk = JNo
3) Obtener las instrucciones de algebra relacional que definen los fragmentos
ri = ∏Pk+Ri (r)
J1 = ∏ JNo,budget (J)
J2 = ∏ JNo,JName,Loc (J)
4) Obtener físicamente los fragmentos
J1
J2
JNO
J1
J2
J3
J4
J5
BUDGET
150000
135000
250000
310000
500000
JNO
J1
J2
J3
J4
J5
JNAME
Instrumentation
Database Develop
CAD CAM
Maintenance
CAD CAM
LOC
Montreal
New York
New York
Paris
Boston
Ejemplo 2
Fragmentar la tabla de grupos en función de la duración del proyecto.
1) Identificar la tabla G
29
Bases de Datos Distribuidos
ENO
E1
E2
E2
E3
E3
E4
E5
E6
E7
E7
E8
JNO
J1
J1
J2
J3
J4
J2
J2
J4
J3
J3
J3
RESP
Manager
Analyst
Analyst
Consultant
Engineer
Programmer
Manager
Manager
Engineer
Engineer
Manager
DUR
12
24
6
10
48
18
24
48
36
23
40
2) Identificar los grupos de atributos y la llave primaria
R1 =Dur
R2 = Resp
Rk= ENo, JNo
3) Obtener las instrucciones de Algebra Relacional que definen los fragmentos
ri = ∏Pk + Ri ( r)
G1 = ∏ ENo, JNo, Dur (G)
G2 = ∏ ENo,JNo, Resp (G)
4) Obtener físicamente los fragmentos
30
Bases de Datos Distribuidos
G1
G2
ENO
E1
E2
E2
E3
E3
E4
E5
E6
E7
E7
E8
JNO
J1
J1
J2
J3
J4
J2
J2
J4
J3
J3
J3
DUR
12
24
6
10
48
18
24
48
36
23
40
ENO
E1
E2
E2
E3
E3
E4
E5
E6
E7
E7
E8
JNO
J1
J1
J2
J3
J4
J2
J2
J4
J3
J3
J3
RESP
Manager
Analyst
Analyst
Consultant
Engineer
Programmer
Manager
Manager
Engineer
Engineer
Manager
Ejemplo 3
Fragmentar la tabla de empleados separando los datos del titulo.
1) Identificar la tabla E
ENO
E1
E2
E3
E4
E5
E6
E7
E8
ENAME
J.Doc
M.Smith
A.Lee
J. Miller
H. Casey
I. Chii
R.Davis
J.Jones
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
Syst. Anal.
Elect. Eng.
Mech. Eng.
Syst. Anal.
2) Identificar los grupos de atributos y llave primaria
R1 =Title
R2 = EName
Rk =ENo
31
Bases de Datos Distribuidos
3) Obtener instrucciones de algebra relacional que definen los fragmentos
E1 = ∏ ENo,Title ( E )
E2 = ∏ ENo, EName ( E)
4) Obtener físicamente los fragmentos
E1
ENO
E1
E2
E3
E4
E5
E6
E7
E8
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
Syst. Anal.
Elect. Eng.
Mech. Eng.
Syst. Anal.
E2
ENO
E1
E2
E3
E4
E5
E6
E7
E8
ENAME
J.Doc
M.Smith
A.Lee
J. Miller
H. Casey
I. Chii
R.Davis
J.Jones
Ejemplo 3
Fragmentar la tabla de Salario separando los datos del sueldo
1) Identificar la tabla S
TITLE
Elect. Eng.
Syst. Anal.
Mech. Eng.
Programmer
SAL
40000
34000
27000
24000
2) Identificar los grupos de atributos y llave primaria
R1 =Sal
32
Bases de Datos Distribuidos
R2 =φ
Pk =Title
No es factible la fragmentación vertical
Factibilidad de la FV
No Superllave
Al menos 2 grupos de atributos no vacíos
Fragmentación Hibrida.
Distribución de Fragmentos.
Planteamiento del problema:
Dado
F={F1, F2, …, Fn} es el conjunto de fragmentos.
S={S1, S2, …, Sm} es el conjunto de sitios en la red, y
Q={q1, q2, …, qq} es el conjunto de aplicaciones,
33
Bases de Datos Distribuidos
Encontrar la distribución “optima” de F en S.
Distribución de Fragmentos.
Optimalidad
Costo mínimo.
• Comunicación + almacenamiento + procesamiento (lectura y
actualizaciones).
• Costo en términos de tiempo (usualmente).
Eficiencia.
• Tiempo de respuesta.
Restricciones.
Distribución.
• Restricciones por sitio (almacenaje y procesamiento).
Problema de distribución de archivos (FAP) vs. Problema de distribución de base de datos
(DAP).
Los fragmentos no pueden tratarse como archivos individuales.
Se tienen que tomar en cuenta sus relaciones.
El acceso a la base de datos es más complicado.
El modelo de acceso a archivos remotos no aplica.
Relación entre distribución y procesamiento de consultas.
El costo de mantener la integridad debe considerarse.
El costo de control de concurrencia debe considerarse.
Distribución – Requerimientos de Información.
34
Bases de Datos Distribuidos
Información de la base de datos
¾ Selectividad de fragmentos minterm.
¾ Tamaño de los fragmentos.
Información de las aplicaciones
¾ Número de acceso de lectura de una consulta a un fragmento.
¾ Número de accesos de actualización a un fragmento.
¾ Una matriz que indique cuales consultas actualizan qué fragmentos.
¾ Una matriz similar para las lecturas.
¾ Sitio de origen de cada consulta.
Información de los sitios
¾ Unidad de costo de almacenar datos en un sitio.
¾ Unidad de costo de procesar datos en un sitio.
Información de la red
¾ Costo de comunicación de una trama entre dos sitios.
¾ Tamaño de la trama.
Modelo de distribución.
35
Bases de Datos Distribuidos
Forma general.
min(costo total)
sujeto a
Restricciones de tiempo de respuesta.
Restricción de almacenaje.
Restricción de procesamiento.
Variables de decisión:
xij =
1 si el fragmento Fi se almacena en el sitio Sj
0 en caso contrario
Costo Total:
∑ todas las consultas costo reprocesamiento de consulta +
∑ todos los sitios ∑ todos los fragmentos costo de almacenaje de un frag. en un sitio.
Costo de almacenaje (del fargmento Fj en Sk):
(unidad de costo de almacenaje en Sk) * (tamaño de Fj) * xik
Costo de procesamiento de consulta:
Componente de procesamiento + componente de transmisión
Componente de procesamiento:
Costo de acceso + costo de mantenimiento de integridad +
Costo de control de concurrencia
Costo de acceso:
∑ todos los sitios ∑ todos los fragmentos (no. De accesos de actualización
+ no. De accesos de lectura) * xik
* costo de procesamiento local en un sitio
36
Bases de Datos Distribuidos
Los costos de mantenimiento de integridad y de control de concurrencia se pueden
formular de una manera similar.
Componente de Transmisión:
Costo de procesar actualizaciones + costo de procesar lecturas
Costo de actualizaciones:
∑ todos los sitios ∑ todos los fragmentos costo del mensaje de actualizar +
∑ todos los sitios ∑ todos los fragmentos costo de información
Costo de lecturas:
∑ todos los fragmentos min todos los sitios (costo del comando de recuperación +
Costo de enviar los resultados)
Restricciones:
¾ Tiempo de respuesta:
Tiempo de ejecución de la consulta
≤ max. Tiempo de resp. Permisible para esa consulta
¾ Almacenamiento:
∑ todos los fragmentos reqs. De almacenaje de un fragmento en ese sitio
≤ capacidad de almacenaje de ese sitio
¾ Procesamientos:
∑ todas las consultas carga de proa. De una consulta en ese sitio
≤ capacidad de procesamiento de ese sitio
Problema – Separación de los Pasos de Diseño
37
Bases de Datos Distribuidos
Alternativas de Asignación
No replicado.
¾ Particionada: cada fragmento reside en un solo sitio.
Replicado.
¾ Réplica completa: cada fragmento en cada sitio.
¾ Réplica parcial: cada fragmento en algunos de los sitios.
Regla del pulgar:
Si
Consultassólodelectura
Consultasparaactualizar
≥ 1 replicación es ventajosa,
de lo contrario la réplica puede causar problemas.
Comparación de Alternativas de Réplica
38
Bases de Datos Distribuidos
PROCESAMIENTO DE CONSULTAS DISTRIBUIDAS
39
Bases de Datos Distribuidos
Procesamiento de Consultas
Componentes del Procesamiento de Consultas
Lenguaje de consultas utilizado.
SQL “Intergalactic Dataspeak”.
Metodología de ejecución de consultas.
Los pasos necesarios para ejecutar una consulta de alto nivel
(declarativa).
Optimización de consultas.
¿Cómo determinar el “mejor” plan de ejecución?
Alternativas de Solución
SELECT
FROM
WHERE
AND
ENAME
E,G
E.ENO = G.ENO
DUR > 37
40
Bases de Datos Distribuidos
Estrategia 1
Estrategia 2
La estrategia 2 reduce el producto cartesiano, así que es “mejor”.
¿Cuál es el Problema?
Sitio 1
Sitio 2
Sitio 3
Sitio 4
Sitio 5
Estrategia 1
Estrategia 2
Alternativas de Costo
41
Bases de Datos Distribuidos
Suponer lo siguiente:
Tamaño (E) = 400, tamaño (G) = 100
Costo de acceso a tuplas = 1 unidad;
Costo de transferir una tupla = 10 unidades.
Estrategia 1.
1. Producir G’: 20*costo de acceso a tupla
1000
2. Transferir G’ a los lugares de E: 20*costo de transferir tupla
200
3. Producir E’: (400*20)*costo de acceso a tupla
8000
4. Transferir E a los lugares resultantes: 20*costo de transferir tupla
200
Costo total
9,400
Estrategia 2.
5. Transferir E al lugar 5: 400*costo de transferir tupla
4,000
6. Transferir E al lugar 5: 1,000*costo de transferir tupla
10,000
7. Producir G’: 1,000*costo de acceso a tupla
8. Reunión de E y G’: 400*20*costo de acceso a tupla
Costo total
1,000
8,000
23,000
Ejemplo 1
42
Bases de Datos Distribuidos
Dame los nombres de los empleados que laboren en proyectos >37 meses.
1. Obtener la consulta
Select Ename
from E, G
where E.ENo = G.ENo and Dur>37
2. Definir las estrategias de ejecución.
Estrategia 1
∏Ename (σE.ENo = G.ENo and Dur>37(E X G))
Estrategia 2
∏Ename (E ∞ E.ENo = G.ENo (σ Dur>37(G)))
3. Seleccionar la mejor estrategia
La mejor estrategia es la 2, debido a que reduce el número de tuplas a manejar
4. En base a la estrategia seleccionada especificar 2 o más formas de implementación
(esquema de ejecución)
Sitio 1
G’1=σE.ENo ≤ ’E3’(G)
Sitio 2
G’2=σE.ENo > ’E3’(G)
Sitio 3
E’1=σE.ENo ≤ ’E3’(G)
Sitio 4
E’2=σE.ENo > ’E3’(G)
Sitio 5
Resultado
Sitio 7
J’1=σJNo ≤ ’J3’(J)
Sitio 8
J’2=σJNo ≤ ’J3’(J)
43
Bases de Datos Distribuidos
Implementación 1
Implementación 2
Alternativas de costo
Especificar Constantes
¾ Tamaño de las tuplas
Tamaño ( E ) = 400 tuplas
Tamaño ( G ) = 1000 tuplas
¾ Costos
Costo (Acceso) = 1 unidad/tupla
Costo (Transferencia) = 10 unidades/tupla
Analizar las implementaciones
44
Bases de Datos Distribuidos
¾ Implementación 1
1) Producir G’ = Prod (G’1) + Prod (G’2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Resultado de la producción =20 tuplas
Tamaño (G’) = 20 t
2) Transferir G’ = Transf (G’1) + Transf (G’2)
= Tamaño (G) * Costo (Transferencia)
= 20 * 10 u/t
= 200 u
3) Producir E’ = Prod (E’1) + Prod (E’2)
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 20 t * 1 u/t
= 8000 u
Tamaño (E’) = 20 t
4) Transferir E’ = Transf (E’1) + Transf (E’2)
= Tamaño (E) * Costo (Transferencia)
= 20 * 10 u/t
= 200 u
5) Suma Resultado
1000 u
200 u
8000 u
200 u
9,400 u
Implementación 2
45
Bases de Datos Distribuidos
1) Transferir E = Transf (E1) + Transf (E2)
= Tamaño (E) * Costo (Transferencia)
= 400 * 10 u/t
= 4000 u
2) Transferir G = Transf (G1) + Transf (G2)
= Tamaño (G) * Costo (Transferencia)
= 1000 * 10 u/t
= 10,000 u
3) Producir G’ = Prod (G1) + Prod (G2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Tamaño G’ = 20 t
4) Producir E’ = Prod (E1) + Prod (E2)
= Reunión E ∞ G’
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 20 t * 1 u/t
= 8000 u
Tamaño E’ = 20 t
5) Sumar Resultados
4000 u
10,000 u
1,000 u
8,000 u
23,000 u
Comparar los valores de la implementación
La implementación 1 es la menos costosa
Ejemplo 2
46
Bases de Datos Distribuidos
Muestre los datos de los empleados del proyecto J1
1) Obtener la consulta
Select E.ENo , Ename, Title
From E, G
Where E.ENo = G.JNo and G.JNo = ‘J1’
2) Definir las estrategias de ejecución
Estrategia 1
∏ENo, Ename, Title (σE.ENo = G.ENo and G.JNo =’J1’ (E X G))
Estrategia 2
∏ENo, Ename, Title (E ∞ E.ENo = G.ENo (σ G.JNo = ‘J1’ (G)))
3) Seleccionar la mejor elección
La mejor estrategia es la 2
4) En base a la estrategia seleccionada especificar 2 o mas formas de implementación
(esquema de ejecución)
Implementación 1
Sitio 5
Resultado =E’1 U E’2
Sitio 3
E’1=E1 ∞ ENo G’1
Sitio 1
G’1=σG.JNo = ‘J1’(G1)
Sitio 4
E’2=E2 ∞ ENo G’2
Sitio 2
G’2=σG.JNo = ‘J1’(G2)
Implementación 2
47
Bases de Datos Distribuidos
Resultado = (E1 U E2) ∞ENo σG.JNo = ‘J1’ (G1 U G2)
S3
S4
S1
S2
Analizar las implementaciones
¾ Implementación 1
1) Producir G’ = Prod (G’1) + Prod (G’2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Tamaño G’= 10 t
2) Transferir G’ = Transf (G’1) + Transf (G’2)
= Tamaño (G’) * Costo (Transferencia)
= 10 * 10 u/t
= 100 u
3) Producir E’ = Prod (E’1) + Prod (E’2)
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 10 t * 1 u/t
= 4000 u
Tamaño (E’) = 20 t
4) Transferir E’ = Transf (E’1) + Transf (E’2)
= Tamaño (E) * Costo (Transferencia)
= 10 * 10 u/t
= 100 u
5) Suma Resultado
48
Bases de Datos Distribuidos
1000 u
100 u
4000 u
100 u
5,200 u
Implementación 2
1) Transferir E = Transf (E1) + Transf (E2)
= Tamaño (E) * Costo (Transferencia)
= 400 * 10 u/t
= 4000 u
2) Transferir G = Transf (G1) + Transf (G2)
= Tamaño (G) * Costo (Transferencia)
= 1000 * 10 u/t
= 10,000 u
3) Producir G’ = Prod (G1) + Prod (G2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Tamaño G’ = 10 t
4) Producir E’ = Prod (E1) + Prod (E2)
= Reunión E ∞ G’
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 10 t * 1 u/t
= 4000 u
Tamaño E’ = 10 t
5) Sumar Resultados
49
Bases de Datos Distribuidos
4000 u
10,000 u
1,000 u
4,000 u
19,000 u
Comparar los valores de la implementación
La implementación 1 es la menos costosa
Ejemplo 3
50
Bases de Datos Distribuidos
Muestre los datos de los empleados cuyo cargo sea de analista en los proyectos.
1) Obtener la consulta
Select E.ENo , Ename, Title
From E, G
Where E.ENo = G.JNo and G.Resp = ‘Analyst’
2) Definir las estrategias de ejecución
Estrategia 1
∏E.ENo, Ename, Title (σE.ENo = G.ENo and G.Resp =’Analyst’ (E X G))
Estrategia 2
∏E.ENo, Ename, Title (E ∞ E.ENo = G.ENo (σ G.Resp = ‘Analyst’ (G)))
3) Seleccionar la mejor elección
La mejor estrategia es la 2
4) En base a la estrategia seleccionada especificar 2 o mas formas de implementación
(esquema de ejecución)
Implementación 1
Sitio 5
Resultado =E’1 U E’2
Sitio 3
E’1=E1 ∞ ENo G’1
Sitio 1
G’1=σG.Resp = ‘Analyst’ (G1)
Sitio 4
E’2=E2 ∞ ENo G’2
Sitio 2
G’2=σG.Resp = ‘Analyst’(G2)
51
Bases de Datos Distribuidos
Implementación 2
Resultado = (E1 U E2) ∞ENo σG.Resp = ‘Analyst’ (G1 U G2)
S3
S4
S1
S2
Analizar las implementaciones
¾ Implementación 1
1) Producir G’ = Prod (G’1) + Prod (G’2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Tamaño G’= 30 t
2) Transferir G’ = Transf (G’1) + Transf (G’2)
= Tamaño (G’) * Costo (Transferencia)
= 30 * 10 u/t
= 300 u
3) Producir E’ = Prod (E’1) + Prod (E’2)
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 30 t * 1 u/t
= 12,000 u
Tamaño (E’) = 30 t
4) Transferir E’ = Transf (E’1) + Transf (E’2)
= Tamaño (E’) * Costo (Transferencia)
= 30 * 10 u/t
= 300 u
52
Bases de Datos Distribuidos
5) Suma Resultado
1000 u
300 u
12,000 u
300 u
13,600 u
Implementación 2
1) Transferir E = Transf (E1) + Transf (E2)
= Tamaño (E) * Costo (Transferencia)
= 400 * 10 u/t
= 4000 u
2) Transferir G = Transf (G1) + Transf (G2)
= Tamaño (G) * Costo (Transferencia)
= 1000 * 10 u/t
= 10,000 u
3) Producir G’ = Prod (G1) + Prod (G2)
= Tamaño (G) * Costo (Acceso)
= 1000 t * 1 u/t
= 1000 u
Tamaño G’ = 30 t
4) Producir E’ = Prod (E1) + Prod (E2)
= Reunión E ∞ G’
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 30 t * 1 u/t
= 12,000 u
Tamaño E’ = 30 t
53
Bases de Datos Distribuidos
5) Sumar Resultados
4000 u
10,000 u
1,000 u
12,000 u
27,000 u
Comparar los valores de la implementación
La implementación 1 es la menos costosa
Ejemplo 4
54
Bases de Datos Distribuidos
Muestre los datos de los empleados que trabajen en Montreal
1) Obtener la consulta
Select E.ENo , Ename, Title
From E, G, J
Where E.ENo = G.JNo and G.JNo = J.JNo and J.Loc = “Montreal”
2) Definir las estrategias de ejecución
Estrategia 1
∏E.ENo, Ename, Title (σE.ENo = G.ENo and G.JNo = J.JNo and J.Loc = “Montreal” (E X G X J))
Estrategia 2
∏E.ENo, Ename, Title (E ∞ E.ENo = G.ENo (G ∞ G.JNo = J.ENo (σ J.Loc = “Montreal” (J))))
3) Seleccionar la mejor elección
La mejor estrategia es la 2
4) En base a la estrategia seleccionada especificar 2 o mas formas de implementación
(esquema de ejecución)
Implementación 1
Sitio 5
Resultado =E’1 U E’2
Sitio 3
E’1=E1 ∞ ENo G’1
Sitio 1
G’1= G1 ∞ JNo (J1 U J2)
Sitio 7
J’1 = σ J.Loc =”Montreal” (J1)
Sitio 4
E’2=E2 ∞ ENo G’2
Sitio 2
G’2= G2 ∞ JNo (J1 U J2)
Sitio 8
J’2 = σ J.Loc =”Montreal” (J2)
55
Bases de Datos Distribuidos
Implementación 2
Resultado = (E1 U E2) ∞ENo ( (G1 U G2) ∞JNo (σJ.Loc = “Montreal” (J1 U J2)))
S3
S4
S1
S2
S2
S2
Analizar las implementaciones
Tamaño de las tablas
o Tamaño E = 400 tuplas
o Tamaño G = 1000 tuplas
o Tamaño J = 200 tuplas
Costos
o Costo de Acceso = 1 u/t
o Costo de Transferencia = 10 u/t
¾ Implementación 1
1) Producir J’ = Prod (J’1) + Prod (J’2)
= Tamaño (J) * Costo (Acceso)
= 200 t * 1 u/t
= 200 u
Tamaño J’= 30 t
2) Transferir J’ = Transf (J’1) + Transf (J’2)
= Tamaño (J’) * Costo (Transferencia) * No. Sitios destino c/ frag.
= 30 * 10 u/t *2
= 600 u
3) Producir G’ = Prod (G’1) + Prod (G’2)
= Tamaño (G) * Tamaño (J’) * Costo (Acceso)
= 1000 t * 30 t * 1 u/t
= 30,000 u
Tamaño G’= 30 t
56
Bases de Datos Distribuidos
4) Transferir G’ = Transf (G’1) + Transf (G’2)
= Tamaño (G’) * Costo (Transferencia)
= 30 * 10 u/t
= 300 u
5) Producir E’ = Prod (E’1) + Prod (E’2)
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 30 t * 1 u/t
= 12,000 u
Tamaño (E’) = 30 t
6) Transferir E’ = Transf (E’1) + Transf (E’2)
= Tamaño (E) * Costo (Transferencia)
= 30 * 10 u/t
= 300 u
7) Suma Resultado
200 u
600 u
30,000 u
300 u
12,000 u
43,400 u
57
Bases de Datos Distribuidos
Implementación 2
1) Transferir J = Transf (J1) + Transf (J2)
= Tamaño (J) * Costo (Transferencia)
= 200 * 10 u/t
= 2000 u
2) Transferir G = Transf (G1) + Transf (G2)
= Tamaño (G) * Costo (Transferencia)
= 1000 * 10 u/t
= 10,000 u
3) Transferir E = Transf (E1) + Transf (E2)
= Tamaño (E) * Costo (Transferencia)
= 400 * 10 u/t
= 4000 u
4) Producir J’ = Prod (J1) + Prod (J2)
= Tamaño (J) * Costo (Acceso)
= 200 t * 1 u/t
= 200 u
Tamaño J’ = 30 t
5) Producir G’ = Prod (G1) + Prod (G2)
= Tamaño (G) * Tamaño(J’) * Costo (Acceso)
= 1000 t * 30 t * 1 u/t
= 30,000 u
Tamaño G’ = 30 t
6) Producir E’ = Prod (E1) + Prod (E2)
= Reunión E ∞ G’
= Tamaño ( E ) * Tamaño (G’) * Costo (Acceso)
= 400 t * 30 t * 1 u/t
= 12,000 u
Tamaño E’ = 30 t
58
Bases de Datos Distribuidos
7) Sumar Resultados
200 u
10,000 u
4,000 u
200 u
30,000 u
12,000 u
56,400 u
Comparar los valores de la implementación
La implementación 1 es la menos costosa
Ejemplo 5
59
Bases de Datos Distribuidos
Muestre los proyectos donde los empleados ganen más de 30,000
1) Obtener la consulta
Select Jname
From E, G, J, S
Where E.ENo = G.JNo and G.JNo = J.JNo and E.Title=S.Title and S.Sal > 30,000
2) Definir las estrategias de ejecución
Estrategia 1
∏Jname (σE.ENo = G.ENo and G.JNo = J.JNo and E.Title=S.Title and S.Sal > 30,000 (E X G X J X S))
Estrategia 2
∏ Jname (J ∞ JNo G ∞ ENo (E ∞ Title (σ Sal > 30,000 (S)))
3) Seleccionar la mejor elección
La mejor estrategia es la 2
60
Bases de Datos Distribuidos
4) En base a la estrategia seleccionada especificar 2 o mas formas de implementación
(esquema de ejecución)
Implementación 1
Sitio 5
Resultado =J’1 U J’2
Sitio 8
Sitio 7
J’1=J1 ∞ JNo G’1
J’2=J2 ∞ JNo G’2
Sitio 1
Sitio 2
G’2= G2 ∞ ENo (E’1 U E’2)
G’1= G1 ∞ ENo (E’1 U E’2)
Sitio 3
Sitio 4
E’2 = E2 ∞ Title (S’)
E’1 = E1 ∞ Title (S’)
Sitio 6
S’ = σ Sal > 30,000 (S)
Implementación 2
Resultado = (J1 U J2) ∞JNo ((G1 U G2) ∞ENo ( (E1 U E2) ∞ Title (σ Sal > 30,000 (S))))
S7
S8
S1
S2
S3
S4
S6
61
Bases de Datos Distribuidos
Analizar las implementaciones
Tamaño de las tablas
o Tamaño E = 400 tuplas
o Tamaño G = 1000 tuplas
o Tamaño J = 200 tuplas
o Tamaño S = 100 tuplas
Costos
o Costo de Acceso = 1 u/t
o Costo de Transferencia = 10 u/t
¾ Implementación 1
1) Producir S’ = Prod (S’)
= Tamaño (S) * Costo (Acceso)
= 100 t * 1 u/t
= 100 u
Tamaño S’= 40 t
2) Transferir S’ = Transf (S’)
= Tamaño (S’) * Costo (Transferencia) * No. Sitios destino c/ frag.
= 40 * 10 u/t * 2
= 800 u
3) Producir E’ = Prod (E’1) + Prod (E’2)
= Tamaño (E) * Tamaño (S’) * Costo (Acceso)
= 400 t * 40 t * 1 u/t
= 16,000 u
Tamaño E’= 40 t
4) Transferir E’ = Transf (E’1) + Transf (E’2)
= Tamaño (E’) * Costo (Transferencia)
= 40 * 10 u/t
= 400 u
62
Bases de Datos Distribuidos
5) Producir G’ = Prod (G’1) + Prod (G’2)
= Tamaño (G) * Tamaño (E’) * Costo (Acceso)
= 1000 t * 40 t * 1 u/t
= 40,000 u
Tamaño G’= 40 t
6) Transferir G’ = Transf (G’1) + Transf (G’2)
= Tamaño (G’) * Costo (Transferencia) * No. Sitios destino c/ frag.
= 40 * 10 u/t * 2
= 800 u
7) Producir J’ = Prod (J’1) + Prod (J’2)
= Tamaño ( J ) * Tamaño (G’) * Costo (Acceso)
= 200 t * 40 t * 1 u/t
= 8,000 u
Tamaño (E’) = 40 t
8) Transferir J’ = Transf (J’1) + Transf (J’2)
= Tamaño (J’) * Costo (Transferencia)
= 40 * 10 u/t
= 400 u
9) Suma Resultado
100 u
400 u
16,000 u
400 u
40,000 u
800 u
8000 u
400 u
66,100 u
63
Bases de Datos Distribuidos
Implementación 2
1) Transferir S = Transf (S)
= Tamaño (S) * Costo (Transferencia)
= 100 t* 10 u/t
= 1000 u
2) Transferir E = Transf (E1) + Transf (E2)
= Tamaño (E) * Costo (Transferencia)
= 400 * 10 u/t
= 4000 u
3) Transferir G = Transf (G1) + Transf (G2)
= Tamaño (G) * Costo (Transferencia)
= 1000 * 10 u/t
= 10,000 u
4) Transferir J = Transf (J1) + Transf (J2)
= Tamaño (J) * Costo (Transferencia)
= 200 * 10 u/t
= 2000 u
5) Producir S’ = Prod (S)
= Tamaño (S) * Costo (Acceso)
= 100 t * 1 u/t
= 100 u
Tamaño S’ = 40 t
6) Producir E’ = Prod (E1) + Prod (E2)
= Tamaño (E) * Tamaño (S’) * Costo (Acceso)
= 400 t * 40 t * 1 u/t
= 16,000 u
Tamaño E’ = 40 t
64
Bases de Datos Distribuidos
7) Producir G’ = Prod (G1) + Prod (G2)
= Tamaño (G) * Tamaño(E’) * Costo (Acceso)
= 1000 t * 40 t * 1 u/t
= 40,000 u
Tamaño G’ = 40 t
8) Producir J’ = Prod (J1) + Prod (J2)
= Reunión E ∞ G’
= Tamaño ( J ) * Tamaño (G’) * Costo (Acceso)
= 200 t * 40 t * 1 u/t
= 8,000 u
Tamaño J’ = 40 t
9) Sumar Resultados
1000 u
4000 u
10,000 u
2000 u
100 u
16,000 u
40,000 u
8,000 u
81,100 u
Comparar los valores de la implementación
La implementación 1 es la menos costosa
65