Javier Reyes Estupin Eliezer Ramrez Cabrera Rodrigo Heredero Robayna

ndiceIntroduccin--------------------------------------------------------------------------------pag 3 Algoritmos Auxiliares--------------------------------------------------------------------pag 5 Algoritmo del clculo del cierre de un descriptor----------------------------pag 5 Algoritmo del clculo del recubrimiento minimal---------------------------pag 7 Nuevos conceptos. ------------------------------------------------------pag 7 Atributos Extraos------------------------------------------------------pag 8 Eliminacin de atributos extraos. .----------------------------------pag 9 Eliminacin de dependencias redundantes.--------------------------pag 11 Algoritmo completo del clculo de recubrimiento minimal.------pag 13 Algoritmo de Determinacin de claves. --------------------------------------pag 14 Algoritmo de Normalizacin -----------------------------------------------------------pag 17 Algoritmo de Sntesis------------------------------------------------------------pag 17 Algoritmos de descomposicin.------------------------------------------------pag 18 Algoritmos que determinan la forma normal en la que se encuentra un esquema relacional --------------------------------------pag 19 Determinacin 2FN---------------------------------------------pag 19 Determinacin 3FN---------------------------------------------pag 23 Determinacin FNBC------------------------------------------pag 24 Algoritmos de descomposicin de un esquema de relacin en esquemas en FNBC--------------------------------------------------pag 25 Descomposicin en esquemas FNBC------------------------pag 25 Proyeccin de un conjunto de dependencias sobre un conjunto de atributos---------------------------------pag 27 Algoritmo de descomposicin de esquemas FNBC que mejora la eficiencia----------------------------------------pag 28 Nuevo algoritmo que mejora la funcionalidad. -------------pag 31 Algoritmos que analizan si una descomposicin se hace sin prdidas de informacin. -----------------------------------------------pag 36 Determinacin de si una descomposicin es SPI-----------pag 36 Determinacin de si una descomposicin preserva las dependencias funcionales. ---------------------------------pag 40 Algoritmos Alternativos-------------------------------------------------------------------pag 42 Particionamiento Vertical. -------------------------------------------------------pag 42 Particionamiento Horizontal. ----------------------------------------------------pag 45 Conclusiones--------------------------------------------------------------------------------pag 46

IntroduccinTradicionalmente, el diseo de una base de datos de organiza en 3 niveles de abstraccin: Diseo conceptual: obtener una representacin de la realidad lo ms fidedigna posible, tambin llamado obtencin de la semntica de los datos. Diseo lgico: bajo un modelo concreto, se traduce el esquema conceptual, para generar un esquema lgico y un conjunto de transacciones sobre el mismo. Diseo Fsico: consiste en dar una representacin fsica (ficheros, tablas, etc) de los datos atendiendo a trminos de eficiencia y eficacia. En este tema nos vamos a centrar en el diseo lgico de la base de datos. A su vez, este nivel de diseo tiene su propia metodologa de desarrollo. Partiendo de un esquema conceptual (el Modelo Entidad Interrelacin), se desarrollan reglas de derivacin que permiten pasar de este modelo al Modelo Lgico Relacional (que representa la semntica de los datos mediante dependencias de tipo funcional, multivaluada, etc). El paso final es refinar este esquema obtenido con el simple uso de reglas de derivacin, con el fin de recoger la mayor semntica posible del universo de discurso que se trata de modelar. En este punto surgen, entre otras las formas normales ya vistas en aos pasados.

Esquema Conceptual:semntica de datos Modelo Entidad Interrelacin.

Esquema Lgico (I):Dependencias Funcionales Modelo Relacional

Esquema Lgico (II):refinamiento de los esquemas relacionales. Algoritmos para el refinamiento.

Pues bien, los algoritmos que vamos a presentar en este tema estn orientados a este ltimo punto de optimizacin de los esquemas lgicos relacionales. La posibilidad de generar algoritmos que faciliten la optimizacin y generacin por tanto de un esquema lgico se debe al tratamiento formal de las bases de datos, especialmente, al Modelo Relacional. La algoritmia permite en muchos casos facilitar la tarea al diseador de la Base de Datos, si bien no puede abarcar todo el diseo de la base de datos, ni siquiera en el nivel lgico. Un ejemplo es la deteccin de formas normales 5NF en un esquema relacional, para el que s existen algoritmos, pero que debido a su tiempo (exponencial) son impracticables en la realidad, recurrindose muchas veces a la heurstica como segunda alternativa. Vamos a organizar los algoritmos en funcin de su propsito dentro del refinamiento de esquemas relacionales. As, desde algoritmos auxiliares que definen procesos para obtener caractersticas del esquema relacional que nos ayuden a su vez a resolver otros algoritmos ms complejos (el resto), pasando por algoritmos de

Normalizacin con el fin de refinar los esquemas relacionales de forma lgica, y terminando con algoritmos alternativos que completen a la Normalizacin. Por ello, en este trabajo nos vamos a basar en los algoritmos que abordan los distintos problemas de la manera ms eficiente posible, descartando aquellos que, si bien, en algunos casos sirvieron como base para la consecucin de algoritmos ms modernos y eficientes, hoy da son pocas (por no decir ninguna) las bases de datos que los implementan.

Algoritmos AuxiliaresLa mayora de los algoritmos de anlisis y de sntesis exigen calcular previamente el recubrimiento irredundante y las claves del esquema de relacin, los cuales a su vez, se basan en el clculo del cierre de un descriptor a su vez. Inicialmente eran de orden exponencial, lo cual haca impracticables los algoritmos fundamentados en estos elementos bsicos. Por ello es fundamental el costo en estos algoritmos, ya que van a ser la base de otros algoritmos. Los algoritmos que se van a exponer a continuacin tienen como principal objetivo la reduccin del tiempo computacional respecto a los propuestos anteriormente y, por lo tanto, hacerlos operativos. Muchos de ellos se basan en un estudio previo de las dependencias del esquema de relacin que se desea normalizar, a fin de poder simplificar los clculos posteriores detectando, mediante este estudio previo dependencias redundantes y/o atributos extraos, descartndolos, y reduciendo as el nmero de dependencias y atributos a los que se aplica el algoritmo

Algoritmo de clculo del cierre de un descriptorY comenzamos por ste por ser un clculo bsico del que los algoritmos siguientes van a hacer uso. El que a continuacin vamos a detallamos, DIEDERICH (1988), se caracteriza por tener una complejidad lineal de O(n), siendo n el nmero de dependencias. Entrada: DF conjunto de dependencias funcionales. Salida: X+ cierre de X respecto a DF A continuacin vamos a describir el proceso basndonos, para entenderlo mejor, en el siguiente ejemplo: Dada la siguiente relacin: R ({CE, NE, P, G, CP, C}, DF) donde: DF = {CE NE, NE CE, P CE, G P, (CP, P) G,CE C, P C}

Calcular el cierre de (CP, P)+: Proceso: 1) X+ = X, ACTUAL = X(CP, P)+ = CP,P y ACTUAL = CP,P

2) Para cada dependencia funcional d de DF: contador (d) = n de atributos de la parte izquierda de d.contador (CE NE) = 1 contador (G P) = 1 contador (P C) = 1 contador (NE CE) = 1 contador (CP, P G) = 2 contador (P CE) = 1 contador (CE C) = 1

3) Para cada atributo A, construir: lista (A) = {(Y B) DF / Alista (CE) = {CE NE; CE lista (P) = {P CE; CP,P lista (CP) = {CP,P G}

Y}C} G; P C} lista (NE) = {NE CE} lista (G) = {G P} lista (C) = { }

4) Mientras ACTUAL 5) Seleccionar y eliminar un atributo A de ACTUALACTUAL = P (eliminamos CP)

6) Para cada dependencia d = Ylista (CP) = {CP,P G}

C de lista(A)

7) Decrementar el contador (d)contador (CP, P G) = 1

8) Si contador (d) = 0 entonces: Si C no est en X+ X+ = X+ {C} ACTUAL = ACTUAL {C}No es el caso. Volvemos al paso 4) y ahora ACTUAL = P En el 5) ACTUAL = En el 6) lista (P) = {P En el 7) para P En el 8) C CE CE X+ (eliminamos P) CE; CP,P G; P C}

contador (P X+ = {CP, P} G

CE) = 0 {CE} y ACTUAL = { } G) = 0 {CE} (ya lo habamos {G}

En el 7) para CP,P decrementado a 1) En el 8) C En el 7) para P En el 8) C C G X+ C X+

contador (CP,P

X+ = {CP,P,CE} contador (P

{G} y ACTUAL = {CE}

C) = 0 {C} y ACTUAL = {CE,G} {C}

X+ = {CP,P,CE,G}

Volvemos al paso 4) y ahora ACTUAL = {CE,G,C} En el 5) ACTUAL = {G,C} (eliminamos CE) En el 6) lista (CE) = {CE En el 7) para CE En el 8) C NE NE X+ NE; CE C} NE) = 0 {NE} y ACTUAL = {G,C} {NE}

contador (CE

X+ = {CP, P,CE,G,C}

En el 7) para CE En el 8) C

C

contador (CE X+

C) = 0

C que si

X+ = {CP,P,CE,G,C,NE} y ACTUAL = {CE,G,C,NE}

Volvemos al paso 4) y ahora ACTUAL = {C,NE} En el 5) ACTUAL = {C,NE} (eliminamos G) En el 6) lista (G) = {G En el 7) para G En el 8) C P P} contador (G X+ P) = 0

P que si

{CP,P,CE,G,C,NE} y ACTUAL = {C,NE}

Volvemos al paso 4) y ahora ACTUAL = {C,NE} En el 5) ACTUAL = {NE} (eliminamos C) En el 6) lista (C) = { } Volvemos al paso 4) y ahora ACTUAL = {NE} En el 5) ACTUAL = { } (eliminamos NE) En el 6) lista (NE) = {NE En el 7) para NE CE CE} contador (NE CE) = -1

Volvemos al paso 4) y ahora ACTUAL = { } Lo que implica que X+ (CP,P) + = {CP,P,CE,G,C,NE}

As puede verse que la idea principal en la que se basa esta algoritmo, es la de aadir la parte derecha de las dependencias al cierre slo cuando se tiene la certeza de que todos los atributos que forman la parte izquierda pertenecen a dicho cierre. De esta forma, cada dependencia es accedida una sola vez, por lo que la complejidad del algoritmo como ya se ha comentado es de O(n).

Algoritmo de clculo del recubrimiento minimalAntes de mostrar el algoritmo por completo es preciso aportar una serie de conceptos nuevos seguidos de procesos para la eliminacin de atributos extraos y de dependencias redundantes, algoritmos estos en los que se apoya el del clculo del recubrimiento minimal.

Nuevos conceptosDepForLHS (X) = {X A DF} DepForLHS (X) no contiene dependencias triviales ni duplicadas. LHS (DX) = {X / DepForLHS (X) } ro-atributo: A es ro-atributo si A aparece en la parte derecha de las dependencias. rl-atributo: B es rl-atributo si no es ro-atributo. ROx = {A / X RLx = {A / X A A DF y A es ro-atributo} DF y A es rl-atributo}

Rx = ROx

RLx

El r-cierre de X respecto a un conjunto de dependencias G, lo representamos como X ^G y es el conjunto de todos los atributos A tales que Y A pertenece a G e Y pertenece a X+G. Por lo tanto, X^G es el conjunto de todos los atributos de las partes derechas de las dependencias derivados de X respecto a G. As pues es fcil ver que X ^G est incluido en X+G y los nicos atributos que pueden no encontrarse en X^G son los que forman X. El r-cierre aporta ms informacin que el cierre transitivo de un descriptor y es especialmente til para la eliminacin de atributos extraos implicados y dependencias redundantes. Pero como es lgico esto se ve mejor con un ejemplo, de forma que ahora la relacin es: R ({CE, NE, P, CP, C}, DF) donde: DF = {CE,NE P, P CP, NE C, C CP}Para hacer coincidir teora y prctica vamos a hacer que DF G y que X (CE,NE), cuyo cierre transitivo hemos calculado previamente, de manera que:

X+G

(CE,NE) +DF = {CE,NE,P,CP,C}

Y volviendo a la teora, recordamos que debemos buscar los atributos A tales que: Y A G e Y

X+G

Empezamos por el primer atributo perteneciente a X+G, CE y vemos que no existe una dependencia tal que: CE A G ( DF) lo que significa que (por el estudio del atributo CE) CE

X^GPasamos al siguiente, NE y vemos que existe una dependencia que cumplen la condicin: NE C G lo que significa que C

X^G X^G

Seguimos con P y vemos que existe una dependencia: P CP CP G lo que significa que CP

El siguiente es CP y comprobamos que no existe:

X^G

A G ( DF) lo que significa que (por el estudio del atributo CP) CP (sin embargo este ya estaba incluido cuando estudiamos el atributo P)

El ltimo es C y vemos que existe una dependencia: C CP estudiar P) G lo que significa que CP

X^G (aunque eso ya lo sabamos al

De esta manera queda que:

X^G (CE,NE) ^DF = {CP,C}

Atributos extraosSe pueden dividir en dos tipos: Implicados B es un atributo extrao implicado en la dependencia X A, si B es atributo extrao y adems cumple que: si X = ZB, X B, entonces B pertenece a Z+DF.

R ({CE, NE, P, CP, C}, DF)

donde:DF = {CE,NE

P, P

CP, NE

C, C

CP}

En la dependencia CE,NE,C CE,NE P. Adems si X = ZB (Z que: B CE,NE y B

P el atributo C ( B) es extrao ya que C), X B (CE,NE,C CE,NE+DF, C), debe cumplirse

Z+DF o lo que es lo mismo, que C

cosa que resulta ser cierta puesto que, como ya se resolvi en el apartado anterior CE,NE+DF = (CE,NE,P,CP,C).

No implicados B es un atributo extrao no implicado en la dependencia X A, si B es atributo extrao y adems cumple que: si X = ZB, X B, entonces B no pertenece a Z+DF. La razn para una distincin as es que en una dependencia que contenga un atributo extrao no implicado se puede afirmar que, despus de la eliminacin del atributo extrao, la dependencia resultante es redundante.

Eliminacin de atributos extraosLa idea principal del algoritmo es eliminar todos los atributos extraos implicados para cada conjunto de dependencias con igual parte izquierda, de esta forma no se tratan dependencias individualmente.;;------ENTRADAS----DF conjunto de dependencias funcionales elementales. ;;------SALIDAS----H, conjunto de dependencias sin atributos extraos implicados. ;;------MAIN----Para cada DepForLHS(X). Si |X| > 1 1) 2) Calcular r-cierre(X) = (X RLx)^DF

Mientras |X| > 1 por cada B de X 2.1) Si B pertenece a X 2.2) Calcular X+ DF 2.2) Si B pertenece a X+ DF entonces X = X r-cierre(X) entonces X = X B

3)

Si X ha cambiado en el paso 2 Reemplazar X por el nuevo valor X en todas las dependencias de DepForLHS(X).

Ejemplo: Es preciso destacar que este ser el que utilicemos durante todo el proceso, es decir, como ya se ha comentado, para ejecutar el algoritmo del clculo del recubrimiento minimal es preciso eliminar del conjunto de dependencias los atributos extraos (cosa que haremos a continuacin) y posteriormente erradicar las dependencias redundantes (cosa que haremos en el siguiente subapartado, partiendo del resultado que obtengamos aqu). Una vez aclarado esto empecemos, dado el siguiente conjunto de dependencias DF:

ABC K AB D

BN H B A

AB E ABC D

B H AB G

AB F ABC J

B D

G A

Puesto que tendremos que tratar todas las DepForLHS(X) tal que |X| > 1, el listado sera el siguiente: DepForLHS(AB) DepForLHS(ABC) DepForLHS(BN) Empezamos por la primera: DepForLHS(AB). Calculamos el RLx RLAB y encontramos que existen 4 dependencias que tienen AB en la izqda. AB E AB F AB D AB C D)^DF es igual (tras y que slo D cumple que es rl-atributo, por lo que RLAB = D. Nos vamos al punto 1) y vemos que r-cierre (AB) = (AB haberlo calculado) a {A, H, G}.

Para el apartado 2) vemos que slo A puede ser un atributo extrao implicado en X = AB ya que: A+ = {A} y B+ = {B, H, G, A} B+DF, y si nos vamos a la definicin de atributo extrao implicado, slo A mientras que, por el contrario, B A+DF.. Nos vamos al punto 2.1) y comprobamos que A A=B Calculamos X+ DF AB {A, H, G}

AB = AB B+ DF

B+ DF = {B, H, G, A} y vemos que (apartado 2.3)) A

Por lo que segn el apartado 3) debemos reemplazar AB por B en todas las DepForLHS(AB). Seguimos con: DepForLHS(ABC). En el apartado 1) vemos que: r-cierre (ABC) = (ABC D)^DF = {D,E,F,G,A,H} Para el apartado 2) vemos que slo A puede ser un atributo extrao y A BC+DF, por lo tanto puede ser eliminado. Nos vamos al punto 2.1) y comprobamos que A = ABC A = BC Calculamos X+ DFDF

ABC

{D,E,F,G,A,H}

ABC B+

BC+ DF = {B, C, H, G, A, D, J, K} y vemos que (por 2.3)) A

Por lo que segn el apartado 3) debemos reemplazar ABC por BC en todas las DepForLHS(ABC). Continuamos con: DepForLHS(BN). En el apartado 1) vemos que: r-cierre (BN) = (BN )^DF = {D,E,F,G,A,H} Para el apartado 2) vemos que ningn atributo puede ser atributo extrao implicado (N es un atributo extrao no implicado). Por lo que no se produce ningn cambio. Por lo tanto, el conjunto de dependencias resultantes, despus de eliminar los atributos extraos implicados es: BC K B D BN H B A B E BC D B B H G B F BC J D A

Eliminacin de dependencias redundantesEl siguiente paso en el clculo del recubrimiento minimal, tras la eliminacin de los atributos extraos es la supresin de las dependencias redundantes, cuyo algoritmo se detalla a continuacin:

;;--ENTRADA------DF conjunto de dependencias sin atributos extraos implicados. ;;--SALIDA------H recubrimiento minimal de DF. Proceso: 0) 1) 2) H = DF Para cada DepForLHS(X) G = {H - DepForLHS(X)} crc(X) = Attr = X 3) Para cada dependencia X A de DepForLHS(X)

Si A pertenece a crc(X) entonces borrar X si no Si A es un rl-atributo Attr = Attr {A} crc(X) = Attr^G Si crc(X) = entonces crc(X) = X^G 4) 5) Para cada dependencia X Si A pertenece a crc(X) Si A es ro-atributo Si A es rl-atributo y A pertenece a X+ respecto H {X Borrar X A de H A de DepForLHS(X) H A de H

A} entonces

Ejemplo: Como ya se ha comentado partimos del ejemplo que hemos empezado en el apartado anterior y al cual hemos librado de atributos extraos quedando el conjunto de dependencias DF como sigue: BC K B D D A BN H B A B E BC D B B H G B F BC J

En el apartado 0) hacemos H = DF y empezamos en el 1), as que para DepForLHS(B). En el apartado 2) vemos que G = {H - DepForLHS(B)} por lo que eliminamos de H todas las dependencias que tengan a B como nico atributo en la parte izqda. quedando: DepForLHS(B) = {B G = {BC D, BC D, B J, BC A, B K, D E, B A, BN H, B H} F, B G}

crc(B) =

y Attr = {B}

Nos vamos al punto 3) y para cada dependencia de DepForLHS(B) entramos en sus subapartados: Para B que: D tenemos que D crc(B) y adems D es rl-atributo, por lo

Attr = {B}

{D} y crc(B) = Attr^G = {A} crc(B) por lo que dicha dependencia

Para B A tenemos que A debe ser eliminada de H

Para B E tenemos que E crc(B) y como E no es rl-atributo y crc(B) no debemos realizar ningn cambio. Para B H tenemos que H crc(B) y como H no es rl-atributo y crc(B) no debemos realizar ningn cambio. Para B F tenemos que F crc(B) y como F no es rl-atributo y crc(B) no debemos realizar ningn cambio. Para B G tenemos que G crc(B) y como G no es rl-atributo y crc(B) no debemos realizar ningn cambio. De forma que para el apartado 4) tenemos que: DepForLHS(B) crc (B) = {A} En el apartado 5) observamos que no existe ninguna dependencia que cumpla la condicin. Retornamos al apartado 1) con la siguiente: DepForLHS(BC). En el apartado 2) queda: DepForLHS(BC) = {BC G = {B D, B E, B crc(BC) = D, BC F, B J, BC G, B K} A, BN H} H, D H = {B D, B E, B H, B F, B G}

y Attr = {B, C}

Nos vamos al punto 3) y comprobamos que ninguna dependencia es eliminada quedando: crc(BC) = {D,E,F,G,H,A} De forma que para el apartado 4) tenemos que: DepForLHS(BC) H = DepForLHS(BC) En el apartado 5) slo la dependencia BC D es comprobada por si es redundante, para lo que es necesario calcular el cierre de BC respecto a H {BC D}, dando como resultado que es redundante y, por lo tanto, se elimina. Retornamos al apartado 1) con la siguiente: DepForLHS(BN). En el apartado 2) queda: DepForLHS(BN) = {BN G = {B D, B E, B crc(BN) = H} F, B G, B H, D A, BC J, BC K}

y Attr = {B, N}

Nos vamos al punto 3) y comprobamos que ninguna dependencia es eliminada quedando: crc(BN) = {D,E,F,G,H,A}

De forma que para el apartado 4) tenemos que: DepForLHS(BN) H = DepForLHS(BN) En el apartado 5) slo la dependencia BN H es comprobada por si es redundante, y se elimina sin necesidad de calcular el cierre de BN ya que H es ro-atributo. Retornamos al apartado 1) con la siguiente: DepForLHS(D). En el apartado 2) queda: DepForLHS(D) = {D G = {B crc(D) = D, B E, B A} F, B G, B H, BN H, BC J, BC K}

y Attr = {D}

Nos vamos al punto 3) y comprobamos que ninguna dependencia es eliminada quedando: crc(BN) = Los siguientes pasos no son necesarios puesto que crc(BN) = .

Por lo tanto, el conjunto de dependencias resultantes, despus de eliminar las redundantes es: B B D G B D E A B H BC J B F BC K

Adems como se ver al exponer el clculo del algoritmo de recubrimiento minimal, ya lo habremos obtenido con los pasos que hemos dado.

Algoritmo completo de clculo de recubrimiento minimalEl cual una vez vistos los anteriores resulta tremendamente sencillo:;;---ENTRADA---DF conjunto de dependencias elementales. ;;---SALIDA---H recubrimiento minimal de DF. ;;---MAIN---1) Aplicar el algoritmo de eliminacin de atributos extraos implicados. 2) Reconstruir los conjuntos DepForLHS(X), eliminando dependencias duplicadas. 3) Aplicar el algoritmo para eliminar las dependencias redundantes.

Algoritmo que hemos ido explicando con un ejemplo al que le hemos ido aplicando los diferentes apartados, de forma que, basta con retroceder hasta el punto Eliminacin de atributos extraos para seguirlo con ayuda del ejemplo que ah exponemos.

Algoritmo de determinacin de clavesSe basa en la idea de hacer que las superclaves contenidas en un conjunto de dependencias pasen a ser mnimas y, por lo tanto, se conviertan en claves. Sin embargo, antes de comenzar con la explicacin es necesario explicar lo que es una:

Matriz de implicacinSe emplea para representar un conjunto de dependencias y se construye de la siguiente forma: Dado el esquema R (A, DF), DF el cto. de dependencias funcionales formado por {Xi Yi}, el conjunto DF puede representarse mediante una matriz M en la que las columnas seran los elementos de A y las filas las Xi de DF. De tal forma que un elemento mij es: 1 si Ai pertenece a (Xi 0 si Ai no pertenece a (Xi Yi) donde AB C D G Yi)

De manera que, sea el siguiente esquema de relacin: R (A, B, C, D, E, G) BC CE D G BE C CG B C A D E

La matriz de implicacin correspondiente sera:

M: AB BC BE CG CE C D

A 1 0 0 0 0 1 0

B 1 1 1 1 0 0 0

C 1 1 1 1 1 1 0

D 0 1 0 0 0 0 1

E 0 0 1 0 1 0 1

F 0 0 0 1 1 0 1Puesto que A,B,C AB C (Xi Yi )

El cierre transitivo de M (M+), se calcula de la siguiente forma: 1) M+ = M 2) Repetir hasta que M+ no cambie Para todo Xi Xj de M+ Si para todo Ak de Xj mij = 1 entonces Copiar todas las entradas a 1 de la fila Xi en los lugares homlogos de la fila . XjY siguiendo el algoritmo obtenemos M+:

M: AB BC BE CG CE C D

A 1 1 1 1 1 1 0

B 1 1 1 1 1 0 0

C 1 1 1 1 1 1 0

D 1 1 1 1 1 0 1

E 1 1 1 1 1 0 1

F 1 1 1 1 1 0 1

Y ahora s, tras este necesario inciso, pasamos a la explicacin del algoritmo de determinacin de claves:

;;--ENTRADA-------

R (A, DF) esquema de relacin.;;--SALIDA

{Ki}n conjunto de claves del esquema.;;--MAIN---

1) 2) 3)

Calcular M+, a partir del conjunto de dependencias DF. M1 = Construir M1 M1 = {Xi Yi} para i = 1 m donde Yi son los atributos con entrada a 0 en la fila i

4)

Si con |Yi| < 2, |Yj| < 2 se tiene que (Xi Yi) (Xj Yj) para i j, borrar la entrada (Xj Yj) de M1.

5)

Si para las dems entradas de M1, |Yj| < 2, el algoritmo concluye, M1 contiene todas las claves. En caso contrario:

6)

Para todo i, con |Yi| aij = Yi (Xj

2 calcular Yj) para todo i j y |Yj| 1 aij) 0

7) 8) 9)

Para todo i, borrar ai1 si ai1 Sustituir las entradas (Xi

aij con j

Yi) con |Yi| > 2 por los nuevos (Xi

Si todas las entradas en M1 son de la forma (Xi Yi) con |Yi| 1, o no se han introducido nuevas entradas en el paso 8): Suprimir superconjuntos, y el conjunto M1 contiene todas las claves. En caso contrario, volver al 6).

Para el ejemplo vamos a emplear el esquema de relacin utilizado para explicar la matriz de implicacin, puesto que ya hemos calculado el valor de M+:De manera que en el paso 2) haremos M1 =

.BDEG, D ABC} a65 = E a74 = C

Y en el 3) tenemos que M1 = {AB, BC, BE, CG, CE, C Pasamos directamente al apartado 6) y vemos que: a61 = B a67 = BD a75 = C a62 = B a71 = AB a76 = CB 63 = BE a72 = BC

a64 = G a73 = B

En el paso 7) se eliminan por ser superconjuntos: a62, a63, a67, a71, a72, a75, a76 De tal forma que en el paso 8) M1 = {AB, BC, BE, CG, CE, CB, CG, CE, DB, DC} Y en el apartado 9) eliminamos los superconjuntos, quedando el M1 definitivo: { AB, BC, BE, CG, CE, DB, DC }

Algoritmos de normalizacinEstos algoritmos proponen un refinamiento de los esquemas relacinales en base a las dependencias funcionales. Pueden ser de dos tipos: De Sntesis: ensamblan esquemas relacionales en 3FN agrupando atributos afines. Veremos el algoritmo propuesto por Bernstein. De Descomposicin: rompen los esquemas relacionales en proyecciones independientes, para obtener esquemas relacionales en FNBC (aunque no siempre, este es el objetivo). Veremos algoritmos para determinar la forma normal del esquema relacional (2FN, 3FN, FNBC), para descomposicin de esquemas relacionales en FNBC sin prdida, para saber si las proyecciones de una descomposicin son SPI (sistemas de proyecciones independientes mediante el algoritmo de ULLMAN) y para saber si tras la descomposicin se conservan las Dependencias Funcionales

ALGORITMO DE SINTESIS BERSTEIN (1976) propone como alternativa el proceso de descomposicin. A partir de un conjunto de dependencias y un conjunto de atributos, construye relaciones de manera que: todas las relaciones estn en 3NF el conjunto de relaciones sea mnimo. El algoritmo es el siguiente:;;--ENTRADA------DF conjunto de dependencias funcionales. ;;--SALIDA------R (Ai, DFi) conjunto de esquemas en 3FN. ;;--MAIN------1) 2) 3) Calcular el recubrimiento minimal H de DF aplicando el algoritmo anterior y almacenar todos los crc(X) para todo X. Agrupar las dependencias con igual parte izquierda (construir DepForLHS(X), para todo X). Reagrupar las dependencias. J= Por cada implicante X que cumpla: X (X RLx)^G X+DF

determinar si X tiene una parte izquierda equivalente en H, es decir, si existe un Y que cumpla: Y Y+DF, Y

Si se encuentra un implicante Y equivalente Agrupar los grupos de dependencias de X e Y en uno slo. Aadir las dependencias X Borrar de H las dependencias X Y A, si A pertenece a Y B, si B pertenece a X Y, Y XaJ

4)

Eliminar dependencias redundantes. Por cada dependencia X A de H RLx)^G J) {X A}.

Si A es un rl-atributo y cumple que A pertenece a (X (o lo que es lo mismo A pertenece a crc(X)) Comprobar si X+

A es redundante en H

J, es decir, calcular el cierre de X respecto a (H

Si A pertenece a X . Eliminar la dependencia X A de H. Aadir cada dependencia de J a su grupo correspondiente. 5) Formar relaciones. Cada grupo de dependencias forma una relacin en 3FN, donde el conjunto de atributos de cada relacin es el resultado de la unin de los atributos que forman las dependencias.

Ejemplo: Partiendo del conjunto de dependencias conseguido en el apartado anterior ya tendramos cubierto el primer punto del algoritmo, por lo que no es necesario calcular el recubrimiento minimal, que sera este: B B D G B D E A B H BC J B F BC K

En el apartado 2) construimos todos los DepForLHS(X): DepForLHS (B) = {B DepForLHS (D) = {D DepForLHS (BC) = {BC D, B A} J, BC K} y realizamos la siguiente E, B H, B F, B G}

Nos vamos al apartado 3), hacemos J = comprobacin: X (X RLx)^G de tal forma que: (B (D (BC RLB)^G = {D,E,H,F,G} RLD)^G = {A} D (D BC RLBC)^G = {J,K} B

(B (BC

RLB)^G = RLBC)^G =

RLD)^G =

En el apartado 4) comprobamos que no existe ninguna relacin X A de H, en la cual A sea un rl-atributo y adems se verifique que A pertenece a (X RLx)^G Y ya en el punto 5) se nos dice que cada grupo de dependencias (las distintas DepForLHS(X)) forman relaciones en 3FN, por lo que, en este caso, el resultado final coincide con el conjunto de dependencias propuestas inicialmente.

ALGORITMOS DE DESCOMPOSICIN Vamos a usar la descomposicin como herramienta para normalizar los esquemas de relacin en este caso. Vamos por tanto a ramificar esta clase de algoritmos en tres tipos: determinan en que forma normal se encuentran los esquemas de relacin. descomponen un esquema de relacin no ptimo en esquemas FNBC. analizan si la descomposicin fue sin prdidas.

Algoritmos que determinan la forma normal en la que se encuentra un esquema de relacin.En esta seccin veremos algunos algoritmos que sirven para determinar la forma normal de un esquema relacional. Van a ser tres algoritmos de determinacin de forma normal; el primero comprobar si el algoritmo se encuentra en 2FN, el segundo comprobar si el esquema relacional est en 3FN y por ltimo un tercer algoritmo que determinar si el algoritmo se encuentra en FNBC.

Determinacin de 2NFComo ya sabemos, un esquema de relacin R(AT,DEP) se encuentra en segunda forma normal si adems de estar en 1NF, cada atributo no principal tiene dependencia funcional completa respecto de cada una de las claves de la relacin. El algoritmo de determinacin de 2NF se basa den la idea de que un esquema de relacin no se encuentra en 2FN, en cuanto que exista algn subconjunto propio de la(s) clave(s) del esquema en cuyo cierre transitivo aparezcan atributos no principales. El algoritmo generar todos los posibles subconjuntos de las claves candidatas, calcular su cierre transitivo y comprobar si en ese cierre transitivo existen atributos no principales. En caso de que en uno de los cierres transitivos calculados existan atributos no principales el algoritmo devolver como respuesta que el esquema relacional no se encuentra en 2NF. En caso contrario seguir comprobando cada uno de los cierres transitivos de los subconjuntos de la clave hasta encontrar un cierre transitivo donde se cumpla que ese cierre transitivo calculado contiene atributos no principales o hasta comprobar que para todos los subconjuntos de la clave ninguno de sus cierres transitivos contiene atributos no principales. Esta solucin es bastante ineficiente como se puede demostrar fcilmente. Por ejemplo, si tuviramos una clave candidata compuesta de 2 atributos, habra que calcular tan solo el cierre transitivo para dos atributos, los dos atributos que componen la clave candidata, puesto que el nmero de combinaciones sin repeticin de 2 elementos tomados de 1 en 1 (puesto que quiero seleccionar solo los subconjuntos de la clave para ser comprobados, no la clave entera). Si en lugar de 2, la clave candidata tuviera 3 atributos, habra que calcular el cierre transitivo para 5 subconjuntos de la clave, es decir: C3,2 + C3,1 = 2 + 3 = 5 siendo Cm,k las combinaciones sin repeticin de m elementos tomados de k en k. En el ejemplo anterior tenemos 2 conjuntos posibles de C3,2, puesto que son las combinaciones posibles sin repeticin de 3 elementos tomados de dos en dos.

Si la clave candidata estuviera conformada por 4 atributos, tendramos que: C4,3 + C4,2 + C4,1 = 4 + 6 + 4 = 14 Por ejemplo, supongamos que tenemos la siguiente clave candidata: CC{A,B,C,D} Las combinaciones sin repeticin que podramos hacer de esta clave candidata seran: C4,3 C4,2 C4,1 {A, B, C} {A, B, D} {A, B} {A, C} {A} {B} {C} {A, C, D} {B, C, D} {A, D} {B, C} {D} {B, D} {C, D}

Para cada una de estas combinaciones tendramos que calcular el cierre transitivo y comprobar si hay atributos no principales en l. Con este ltimo ejemplo, en el caso peor habra que ejecutar 14 cierres transitivos si en ninguno de los cierres anteriores hubieran aparecido atributos no principales. Es decir, que el tiempo que tarda en ejecutarse el algoritmo aumenta en los peores casos de forma exponencial. Para aliviar un poco esta carga algortmica, se realizarn antes de empezar a calcular los cierres transitivos unas comprobaciones sencillas que determinan automticamente si el esquema est o no en 2FN. Las comprobaciones previas son las siguientes: Si existe algn atributo que no es implicado ni implicante de ninguna dependencia, entonces el esquema no est en 2FN (paso 0 del algoritmo). Si el conjunto Q de atributos no principales es vaco, entonces el esquema de relacin est en 2FN (paso 5 del algoritmo). Si todas la claves del esquema de relacin tienen un solo atributo, entonces el esquema est en 2FN (paso 6 del algoritmo).

El algoritmo tendr la siguiente forma:

ALGORITMO 2NF;;------ENTRADA -----Un esquema de relacin R(AT,DEP). ;;-------SALIDA----------N(R). Forma Normal en la que est un esquema de relacin. ;;------MAIN-----------0.- Si (U Xi,Yi )i= 1..n

AT entonces

/* Si el conjunto unin de todos los implicados y los implicantes no son la totalidad de los atributos (es decir, estn contenidos, , en AT, pero no son todos los atributos que contiene el conjunto AT, lo que se indicara con el smbolo N(R)=1 Fin del algoritmo Fin_si 1.- DEP = Recubrimiento irredundante (DEP) 2,. N(R) = 2 3.- Obtener CLAVES 4.- Obtener los conjuntos P (atributos principales) y Q (atributos no principales) 5.- Si Q = entonces Fin del algoritmo Fin_si 6.- Si (nmero de atributos de cada una de las claves es 1) entonces k = n atributos de la clave C. Para j=k-1...1 hacer Mientras hay subconjuntos de C de longitud j Generar SUBj (subconjunto de longitud j). CIERRE = SUBj+DEP Si (CIERRE Q ) entonces /* Si el conjunto resultado de la interseccin entre el cierre transitivo y el conjunto de atributos no principales es no nulo, es decir, en el cierre estn contenidos atributos no principales, no se encontrar el esquema relacional en 2NF, y podemos dar por finalizado el algoritmo*/ N(R) = 1. Fin del algoritmo Fin_si Fin_mientras Fin_para Fin_para_cada_clave )*/

Como ejemplo de ejecucin podemos poner la salida del algoritmo con el esquema de relacin R(AT,DEP) donde: AT= {A,F,B,G,C,H,D,I,E} DEP= {A F, F A, B ABCD E}

G, G

B, C

H, H

C, D

I, I

D,

El paso 0 no se cumple, ya que todos los atributos pertenecen a un implicado o a un implicante, por lo tanto, el algoritmo contina. En el paso 1 se calcula el recubrimiento irredundante del conjunto DEP, la salida es el propio conjunto DEP. Del paso 3 se obtienen 16 claves candidatas de este esquema, que son: CC = {ABCD,ABCI,ABHD,ABHI,AGCD,AGCI,AGHD,AGHI,FBCD,FBCI,FBHD,FBHI,F GCD,FGCO,FGHD,FGHI} En el paso 4 se calculan los conjuntos P y Q que son: P = {A, F, B, G, C, H, D, I} Q = {E} La condicin impuesta en el paso 5 no se cumple, el conjunto Q de atributos no principales es no vaco, por lo tanto, el algoritmo contina. La condicin impuesta en el paso 6 tampoco se cumple, las claves candidatas del esquema de relacin tienen ms de un atributo, por lo tanto, el algoritmo contina En el paso7 se generan los subconjuntos de cada clave. Para la primera de ellas, habra que calcular 14 cierres transitivos (C4,3 + C4,2 + C4,1). Para el resto de las claves, y puesto que las claves estn solapadas, no hay que calcular los 14 cierres por cada una de ellas, puesto que algunos de ellos ya habrn sido generados y comprobados con la clave anterior. En realidad slo sera necesario hacer las comprobaciones para los subconjuntos de una nica clave, ya que el resto de los atributos principales son equivalentes a los que forman parte de la clave. No se encuentra ningn subconjunto de las claves en cuyo cierre aparezcan atributos no principales. El algoritmo finaliza y el esquema de relacin evaluado est en 2FN.

Determinacin de 3FNAntes de meternos a explicar el algoritmo para determinar si un modelo relacional est en 3NF recordaremos la definicin de tercera forma normal: Para que un esquema relacional R(AT, DEP) se encuentre en 3NF se ha de cumplir que est en 2NF, y que cualquier atributo no principal del esquema relacional est implicado no transitivamente por una clave candidata. Un esquema relacional no estar en 3NF si no se cumple una de las dos siguientes condiciones: No se encuentra en 2NF, es decir, existe algn atributo que no depende de forma completa de la clave. Posee algn atributo que depende transitivamente de alguna de sus claves.

El algoritmo que se expondr a continuacin est basado en la definicin anterior. Este algoritmo comprobar a la vez si el esquema se encuentra en 2NF y en 3NF. El algoritmo es el siguiente:

ALGORITMO 3NF;;--------ENTRADA-------Un esquema de relacin R(AT, DEP) ;;----------SALIDA----------S o No para indicar si el esquema est o no en 3FN. ;;----------MAIN-------------1.- DEP = Recubrimiento_irredundante 2.- Calcular claves de R(AT, DEP) 3.- P = conjunto de atributos principales Q= conjunto de atributos no principales RESULTADO = SI 4.- Para toda X Y DEP

Si X no es superclave entonces Si Y Q RESULTADO = NO Fin del algoritmo Fin_si Fin_si Fin_para_todo

La salida del algoritmo para el siguiente esquema relacional es: Entrada: AT = {A, B, C, D, E} DEP = {AB C, A D, D

A, C

E}

En el paso 1 se calcula el recubrimiento irredundante del conjunto DEP, la salida es el propio conjunto DEP. En el paso 2 se calculan las claves del esquema, que son AB Y DB. En el paso 3 se calculan los conjuntos de atributos principales y no principales, que son: P = {A, B, D} y Q = {C, E} Analizando cada una de las dependencias del esquema, vemos que para la dependencia C E, se cumple que el implicante C no es clave (o superclave) y el atributo E es no principal. Por lo tanto, se encuentra una dependencia que viola la definicin de 3FN. El esquema no est en 3FN.

Determinacin de FNBCUn esquema relacional est en FNBC si todo determinante de ese esquema relacional es una clave candidata del mismo. Por lo tanto, en un esquema FNBC las nicas dependencias no triviales que se pueden dar (recordamos que las dependencias triviales son las dependencias en las que el atributo implicado es un subconjunto del conjunto de atributos que lo implican, normalmente, estas dependencias son implcitas al esquema y no se tienen en cuenta en la normalizacin) son aquellas en las que el determinante sea una clave candidata. Ullman (1982) describi un algoritmo para determinar si un esquema relacional se encontraba en FNBC, pero este algoritmo calculaba cules eran claves candidatas del esquema para posteriormente determinar si cada uno de los atributos implicados tena como determinante una clave candidata, y como ya sabemos, el algoritmo para determinar cules son las claves candidatas es un algoritmo muy costoso. Es por ello que Manila (1992) propuso un nuevo algoritmo para determinar si un esquema relacional estaba o no en FNBC que se basa en determinar si todo atributo no principal est determinado por una clave, pero se decidir si un implicante es una clave candidata si su cierre transitivo es el conjunto de todos los atributos del esquema, que en definitiva, es la definicin de clave candidata. El algoritmo es el siguiente:

ALGORITMO FNBC;;--------ENTRADA-------Un esquema de relacin R(AT,DEP) ;;--------SALIDA-------Una decisin sobre si el esquema de relacin est o no en FNBC. ;;--------MAIN-------0.- DEP = Recubrimiento irredundante. 1. RESULTADO = SI 2. Para toda X Y de DEP CIERRE = X+DEP. Si (CIERRE AT) AT

RESULTADO = NO Fin del algoritmo Fin para toda

La complejidad de este algoritmo es polinomial al nmero de dependencia definidas en el esquema. Como se puede ver, no se calculan las claves sino los cierres transitivos de los determinantes. Este es un algoritmo bastante sencillo de determinacin de forma normal de Boyce Codd, ya que lo nico que hace es calcular el cierre transitivo de los determinantes para comprobar que son claves candidatas. Si lo son, el esquema se encontrar en BCNF. En caso de que algn determinante no posea en su cierre transitivo a todos los atributos del esquema, el esquema no se encontrar en BCNF.

ALGORITMOS DE DESCOMPOSICIN DE UN ESQUEMA DE RELACIN EN ESQUEMAS EN FNBC. Descomposicin en esquemas FNBC.El algoritmo de descomposicin que se presenta a continuacin es el algoritmo propuesto por Manila (1992). En l vamos a analizar un esquema relacional. Si existen dependencias que no cumplen la definicin, proyectaremos el esquema en otros dos esquemas relacionales. A continuacin seguiremos aplicando iterativamente este algoritmo a cada uno de los esquemas resultantes para seguir proyectndolos si hiciera falta.

ALGORITMO DESC_1;;------ENTRADA -----Esquema de relacin R = (AT,DEP) ;;------SALIDA -----ESQ = R1..Rn conjunto de esquemas de relacin en FNBC.. ;;------MAIN -----0) Si (R est en FNBC) entonces ESQ = (R). Fin del algoritmo Fin_si 1) 2) ESQ = {} DEP = recubrimiento_irredudante(DEP). Calcular las claves del esquema DEP3) Mientras (existan dependencias X 3.1 ATi = X U Y 3.2 AT = AT Y 3.3 PRi = Proyeccin de DEP sobre ATi 3.4 DEP = Proyeccin de DEP sobre AT 3.5 Ri = (ATi, PRi) 3.6 ESQ = ESQ U {Ri} Fin_mientras Y DEP | X no es superclave )

El algoritmo finalizar cuando todos los esquemas generados estn en FNBC. Puede observarse que en el caso de que existan varias dependencias que violan la FNBC (paso 3), el algoritmo no dice nada acerca de cul es la dependencia que se debe elegir y, por tanto, se puede elegir cualquiera. Ms adelante veremos que segn cual sea la dependencia elegida en cada momento, la descomposicin final ser distinta, siendo en unos casos mejor que en otros. Podemos ver en el algoritmo expuesto como aplicamos Proyecciones de DEP sobre el conjunto de atributos ATi. En la siguiente seccin veremos un algoritmo que explica como realizar esta proyeccin.

Proyeccin de un conjunto de dependencias sobre un conjunto de atributos.Cuando hacemos una proyeccin de un esquema relacional en otros dos, es tan importante saber cules son los atributos que conforman los dos nuevos esquemas como las dependencias asociadas a stos. Al conjunto de dependencias de cada uno de los nuevos esquemas de relacin proyectados se le conoce como proyeccin del conjunto DEP de dependencias de partida sobre el conjunto de atributos X del nuevo esquema. Definicin: La proyeccin de un conjunto DEP de dependencias funcionales sobre un conjunto de atributos X, denotado como DEP[X] es el conjunto de dependencias Y de DEP para las que se cumple que YZ X. Es decir: DEP[X] = {Y Z | DEP|= Y Z y YZ X}

Z

Es decir, para que una dependencia funcional que pertenezca al conjunto DEP, pertenezca a la proyeccin del conjunto DEP sobre otro conjunto de atributos X, tanto su implicante como su implicado tienen que pertenecer al conjunto X. Dicho de otra forma, todos los atributos que participan en esa dependencia deben pertenecer al conjunto X. Una vez definida la proyeccin, vamos a ver el algoritmo propuesto por Manila (1992) para calcularlo.

ALGORITMO DE PROYECCION;;------ENTRADA -----Un conjunto DEP de dependencias funcionales sobre un conjunto AT de atributos. Un subconjunto X AT. ;;------SALIDA-----Un recubrimiento irredundante (DEP). ;;-------MAIN -----1) 2) 3) G = Recubrimiento irredundante (DEP) W = AT X. Mientras (W ) 3.1) A = cualquier atributo de W. 3.2) W = W A 3.3) H = {ZY B | las dependencias Z,A BYY A estn en G}.

3.4) Eliminar las dependencias triviales de H. 3.5) G = G {f Fin_mientras DEP[X] = G G | A ocurre en f} U H

4)

Veamos el siguiente ejemplo de ejecucin de este algoritmo para la proyeccin. AT = {C, D, E, I, J, K, L} DEP = {C D, E J, I

J, J

K, K

J, DK

L}

La proyeccin de DEP sobre X = {C, E, I, L} se calcula como sigue: 1) G = {C D, E J, I 2) W = {D, J, K} 3) Mientras (W ) 1 Iteracin A=D W = {J, K} H = {CK L} G = G {C D, DK 2 Iteracin A=J W=K H = {I K, E K} G = G {E J, I J, J 3 Iteracin A=K W = {} H = {CI L, CE L} G = G { CK L , I K, E 4) DEP[C, E, I, L] = {CI L, CE L} J, J K, K J, DK L}

L} U {CK

L}

K, K

J } U {I

K, E

K}

K} U {CI

L, CE

L}

El algoritmo finaliza despus de |AT| - |X|

Algoritmo de descomposicin de esquemas FNBC que mejora la eficiencia.Manila (1992) propone una mejora en la eficiencia del algoritmo consistente en considerar del conjunto de dependencias DEP slo aquellas que realmente intervienen en el clculo de la proyeccin. La determinacin de este conjunto est basada en el concepto de antecedentes de un descriptor.

Definicin: Se el esquema de relacin R(AT,DEP) y sea X AT. Se definen los antecedentes de X y se denota como X-DEP el conjunto de atributos de AT, que pueden ser usados para derivar una dependencia donde algn conjunto de estos atributos determina un atributo de X. El clculo de este conjunto se define iterativamente de la siguiente forma: 1) Asignar a un conjunto inicial X, el conjunto de atributos del que queremos determinar sus antecedentes. 2) Mientras el conjunto de atributos Xi-1 obtenidos en la anterior iteracin no sea igual al conjunto de atributos obtenidos en la iteracin actual, Xi, el proceso seguir. Lo que se realizar en la iteracin ser asignarle al conjunto de atributos que ya tenemos, Xi, los atributos del conjunto AT que impliquen a algn subconjunto de atributos del conjunto Xi. En el siguiente ejemplo se puede ver fcilmente lo que son los antecedentes. Sea el esquema de relacin R(AT,DEP) donde: AT = {A, B, C, D, E, F} DEP = {A B, C D, B,D

E, E

F}

El clculo de los antecedentes del atributo E (E-) ser: E0- = {E} E1- = {E}U{B,D} E2- = {E,B,D} U{A,C} E3- = E2- = {E,B,D,A,C} Podemos ver como a partir de la iteracin n 3 el conjunto E- ya no se modificar ms. Es por eso que a partir de la iteracin 3 ya no har falta que sigamos calculando los antecedentes. Basado en el concepto de antecedentes de un descriptor, se puede afirmar que para calcular un recubrimiento de DEP[X] basta con considerar slo las dependencias de DEP de la forma Y B tales que para algn Z con B Z y Y Z DEP, se cumple que YB X+DEP X-DEP. Por lo tanto en el algoritmo PROY se incluye un paso inicial que es la seleccin del conjunto de dependencias que realmente interviene en el clculo de la proyeccin, evitando as comprobar las dependencias que no aportan nada al clculo. A continuacin veremos un ejemplo de descomposicin para el algoritmo de descomposicin a FNBC visto antes.

Como ya sabemos, no siempre que descomponemos un esquema relacional hasta la forma normal FNBC podremos conservar las dependencias funcionales, aunque s que conservaremos toda la informacin. Si tenemos el siguiente esquema de relacin R(AT,DEP): AT = {A, B, C, D, E, F, X} DEP = {A X, X A, AB

C, AB

D, D

E, E

F}

En el paso 2 del algoritmo se calcula el recubrimiento irredundante del conjunto DEP, el resultado es el propio conjunto DEP. Las claves de este esquema son AB y BX. Existen en este esquema varias dependencias cuyo implicante no es superclave. stas son: A X, X A, D E y E F. A continuacin comenzamos la descomposicin del esquema por cualquiera de las dependencias citadas. La nica restriccin que impone el algoritmo antes descrito para elegir la dependencia funcional es la de que el implicante de la dependencia elegida no sea superclave del esquema (ya que cumplira las restricciones de la forma normal de Boyce-Codd). Vamos a comenzar por la dependencia D E. Los esquemas resultantes sern: R1 (AT1, DEP1) AT1 = {D, E} DEP1 = {D E} R2(AT2, DEP2) AT2 = {A, B, C, D, F, X} DEP2 = {A X, X A, AB AB D, D F}

C,

Ahora, tendremos dos esquemas de relacin, R1 y R2. El esquema R1 estar en BCNF pero el esquema R2 tendr descriptores que no son claves del esquema. Continuaremos el proceso de descomposicin con el esquema R2. El proceso seguido se puede ver en la siguiente figura:R(AT,DEP) AT = {A, B, C, D, E, F, X} DEP = {A X, X A, AB

C, AB

D, D

E, E

F}

R1(AT1,DEP1) AT1 = {D, E } DEP1 = {D E}

R2(AT2,DEP2) AT2 = {A, B, C, D, F, X} DEP2 = {A X, X A, AB

C, AB

D, D

F}

R3(AT3,DEP3) AT3 = { D, F} DEP3 = {D F}

R4(AT4,DEP4) AT4 = {A, B, C, D, X} DEP4 = {A X, X A, AB

C, AB

D}

R5(AT5,DEP5) AT5 = {A, X} DEP5 = {A X, X

A}

R6(AT6,DEP6) AT6 = {A, B, C, D } DEP6 = { AB C, AB D}

El esquema R2 no est en BCNF, por lo que volvemos a descomponer en R3 y en R4. Podemos elegir entre las siguientes dependencias, una para realizar la proyeccin: {A X, X A, D F} Elegimos, por ejemplo la dependencia D F para llevar a cabo la descomposicin en los esquemas de relacin R3 y r4 como se muestra en la figura anterior. El esquema R3 ya est en FNBC, pero el esquema R4 no. Tenamos dos opciones, elegir A X o X A. Elegimos A X, el esquema R4 se descompone como se ve en la figura anterior. De la descomposicin de R4 aparecen la R5 y la R6. Estas dos ltimas descomposiciones se encontrarn en la forma normal de Boyce-Codd. La descomposicin ser sin prdida de informacin (SPI), pero la dependencia E F, se ha perdido en la descomposicin. Y no existir ninguna otra descomposicin que no provoque prdidas de dependencias funcionales? Como ya sabemos, pasar a la forma FNBC conlleva el riesgo de perder dependencias funcionales, aunque no informacin. Aunque ms adelante veremos que, aunque no siempre se puede pasar a la forma normal de Boyce-Codd sin la prdida de dependencias funcionales, hay algunos casos en los que escogiendo en otro orden las dependencias para realizar la descomposicin, se puede llegar a esquemas FNBC que no hayan sufrido la prdida de dependencias.

Nuevo algoritmo de descomposicin que mejora la funcionalidad.Antes hemos visto como descomponamos un esquema en varios esquemas BCNF. En esa descomposicin perdamos la dependencia E F. En esta seccin de los apuntes, veremos que hacer para que, en la medida de lo posible podamos solucionar el problema de la prdida de dependencias funcionales y qu anlisis previo debemos hacer del esquema para averiguar por donde deberamos empezar a descompones. Como veamos antes, en el algoritmo DESC_1, que era el algoritmo de descomposicin de un esquema relacional, para descomponer un esquema relacional en varios esquema relacionales escogamos de entre un grupo de dependencias que no cumplieran la restriccin de FNBC una dependencia al azar para empezar a descomponer. En este caso vamos a intentar seguir unos criterios de seleccin de dependencias para intentar evitar en la medida de lo posible la prdida de dependencias funcionales al descomponer un esquema relacional en un esquema relacional en FNBC. Los criterios que vamos a imponer para evitar que se produzca prdida de semntica en una descomposicin afectan a dos grupos de dependencias. stos son:

a) Dependencias que definen equivalencia entre atributos no principales. Sea R(AT,DEP) un esquema de relacin: AT = {CT, CA, NA, DT, E, I, O, HO} DEP = {CT CA, CA CT, CT NA, NA NA, I O, EI HO, A B, B C, C D, D

CT, CT C}

DT, DT

CT, E

Los atributos equivalentes son CT, CA, NA y DT. Dichos atributos son no principales, pues la clave del esquema es I,D,E y adems son implicados en otras dependencias. Podramos elegir por pasos sucesivos las dependencias que definen la equivalencia de atributos (por ejemplo CT CA, CT NA, CT DT) durante cada fase del proceso de descomposicin. Cada vez que vayamos a descomponer el esquema relacional tendremos que eliminar el atributo implicado en la dependencia a partir de la que queremos descomponer el esquema del esquema relacional. Para ello tendremos que renombrar, en las dependencias en las que aparezca este atributo en el esquema relacional principal, por otro atributo equivalente a ste. As seguiramos sucesivamente para todas estas dependencias, hasta que al final lleguemos a la ltima de estas dependencias (CT DT) en la que nos encontramos que todas las dependencias cuyo implicado era alguno de estos atributos equivalentes, tendrn ahora el mismo atributo como implicado debido a los renombramientos sucesivos que ha sufrido. Este atributo que aparece en todas estas dependencias es el atributo que vamos a descomponer, por lo tanto tendremos que desaparecern aquellas dependencias en las cuales apareca este atributo. Para arreglar este problema, la propuesta es realizar una nica descomposicin, en lugar de varias sucesivas, en la que en la descomposicin obtengamos dos esquemas relacionales en los que en el primer esquema relacional tengamos, no slo los atributos de la dependencia por la que se descompone, sino todos los atributos equivalentes con las dependencias que lo definen. De esta forma, para nuestro ejemplo tendramos para la primera de estas dependencias (CT CA) n primer esquema relacional formado por los atributos CT y CA y por los equivalentes a stos, DT y NA, y por las dependencias funcionales: { CT CA, CA CT, CT NA, NA CT, CT DT, DT CT }.

b) Dependencias cuyos implicados no son implicantes de otra dependencias. Cuando tenemos una dependencia cuyo implicado no es implicante de ningn otro atributo en el esquema relacional, la mejor opcin para realizar la descomposicin es elegir la dependencia donde se encuentra este atributo y descomponer en base a ella. Al descomponer, este atributo implicado desaparecer del esquema relacional principal y pasar a formar parte del nuevo esquema relacional, junto a la dependencia

en la que se encontraba, por lo que la dependencia en la que se encontraba no se transformar. Siempre que sea posible, las primeras dependencias que se elijan para la descomposicin sern las dependencias cuyos implicados no son implicantes de otra dependencia.

A continuacin veremos como trata el algoritmo SELECCIONA estos casos.

SELECCIONA;;------ENTRADA -----Un conjunto DEP de dependencias funcionales que violan la FNBC. ;;------SALIDA -----D dependencia seleccionada. TIPO: Tipo de la dependencia seleccionada ;;-------MAIN -----0) 1) CONJUNTO 1 = Dependencias que definen atributos equivalentes no principales. Si CONJUNTO1 = entonces D = Cualquier dependencia de CONJUNTO1 TIPO = 1 Fin_algoritmo 2) 3) IMPLICANTES = Para toda X Y de DEP Implicantes = Implicantes U X Fin_para_toda 4) CANDIDATAS = Para toda X Y e DEP

Si Y no pertenece a Implicantes entonces CANDIDATAS = CANDIDATAS U (X Fin_para_toda 5) Si CANDIDATAS = entonces D = Cualquier dependencia de CANDIDATAS En caso contrario D = Cualquier dependencia de DEP Fin_s

Y)

Este algoritmo realiza una seleccin de una dependencia de entre las dependencias funcionales que no cumplen la FNBC que se le pasan por parmetros, para seleccionar la dependencia funcional a partir e la cual se debera hacer la prxima descomposicin. Si entre esas dependencias funcionales de entrada hay dependencias funcionales con implicados que no sean implicantes devolver que el tipo de dependencia seleccionado es 1 y la dependencia seleccionada, ya que este tipo de dependencias

funcionales tendrn prioridad para la descomposicin frente a las dependencias que definen los atributos equivalentes. Si por el contrario, no hay ninguna dependencia funcional en la que haya un implicado que no sea implicante, devolver que el tipo es cualquier otra cosa excepto 1 (no se define una asignacin para esta variable en ese caso) y devolver una dependencia funcional para la descomposicin cualquiera.

Anteriormente veamos un algoritmo denominado DESC_1 en el que descomponamos un esquema relacional en varios esquemas relacionales en FNBC. Como ya hemos advertido, el principal problema de este algoritmo es que selecciona una dependencia al azar de entre las que no cumplen las restricciones de la forma normal de Boyce-Codd. Esto puede producir que se produzcan prdidas de dependencias funcionales en el conjunto final de esquemas partiendo de un esquema inicial en el que fuera posible obtener un conjunto final de esquemas relacionales en los que no se produzca prdida de dependencias funcionales. A continuacin se propone una modificacin del algoritmo DESC_1 en el que se incluye el algoritmo SELECCIONA que permite seleccionar la dependencia funcional adecuada con la que descomponer el esquema relacional.

ALGORITMO DESC_2;;------ENTRADA -----Esquema de relacin R = {AT,DEP} ;;------ENTRADA -----ESQUEMAS = r1, ..Rn conjunto de esquemas de relacin en FNBC. ;;------ENTRADA -----0) Si R est en FNBC entonces ESQ = {R} Fin del algoritmo

Fin_si1) 2) ESQ = {} DEP = Recubrimiento irredundante (DEP)

Calcular las claves del esquema DEP3) Mientras existan dependencias X Y DEP|X no es superclave 3.1) X Y O Salida del algoritmos SELECCIONA 3.2) Si (TIPO=1) entonces AT1 = X U Y Y {Atributos equivalentes} En caso contrario AT1 = X U Y Fin_si 3.3) AT = AT X 3.4) PRi = Proyeccin de DEP sobre ATi 3.5) DEP = Proyeccin de DEP sobre AT 3.6) Ri = {ATi,PRi} 3.7) ESQ = ESQ U {Ri} Fin_mientras 4) ESQUEMAS = ESQ

Veamos un ejemplo Tenemos el siguiente esquema de relacin: AT = {A, B, D, E, F, X} DEP = {A X, X A, AB

C, AB

D, D E, E F }

Siguiendo el algoritmo DESC_2, este algoritmo hara lo siguiente con este esquema relacional:R(AT,DEP) AT = {A, B, C, D, E, F, X} DEP = {A X, X A, AB

C, AB

D, D

E, E

F}

R1(AT1,DEP1) AT1 = {E, F } DEP1 = {E F}

R2(AT2,DEP2) AT2 = {A, B, C, D, E, X} DEP2 = {A X, X A, AB

C, AB

D, D

E}

R3(AT3,DEP3) AT3 = { D, E} DEP3 = {D E}

R4(AT4,DEP4) AT4 = {A, B, C, D, X} DEP4 = {A X, X A, AB

C, AB

D}

R5(AT5,DEP5) AT5 = {A, X} DEP5 = {A X, X

A}

R6(AT6,DEP6) AT6 = {A, B, C, D } DEP6 = { AB C, AB

D}

Lo que ocurre en este algoritmo es: Se le aplica el algoritmo SELECCIONA al conjuntote dependencias: E F, D E, A X, X A. Como se puede observar fcilmente, la dependencia E F es la nica que contiene un implicado que no sea implicante. Por ello se escoge esta dependencia para llevar a cabo la descomposicin, dando como resultado R2 y R3. R1 ya ser un esquema FNCB. No as el esquema R2 que tendr las dependencias {A X, X A, D E} para las que no se cumplen las restricciones del esquema FNBC. En este conjunto de dependencias existe una dependencia, la dependencia D E, en la que el implicado no es implicante en ninguna otra dependencia, por lo tanto seleccionaremos esta dependencia y realizaremos la descomposicin a travs de ella. Los esquemas resultantes de cada una de las descomposiciones son R3 y R4. Volvemos a comprobar que R3 se encuentra en FNBC, mientras que R4 no se encuentra en BCNF, ya que las dependencias que no cumplen las propiedades de los esquemas BCNF son: A X, y X A.

En este caso vemos que no existe ningn implicando que no sea implicante, pero s se produce que existen dependencias que definen atributos equivalentes, que son las dos dependencias que no cumplen las restricciones de la FNBC. Por lo tanto, el algoritmo SELECCIONA seleccionar una de las dos dependencias funcionales 1y descompondr en base a esta dependencia funcional. La dependencia funcional escogida para la descomposicin es la X esquemas relacionales resultantes son el R5 y el R6. A. Los

Como se puede ver, la descomposicin es SPI (sin prdida de informacin) y adems conserva todas las dependencias del esquema de partida.

Algoritmos que analizan si una descomposicin se hace sin prdidas de informacin.En el proceso de normalizacin, vemos que si un esquema posee redundancias, ambigedades, etc, podemos hacer que alcance las formas normales deseadas mediante descomposicin en proyecciones. El mayor problema que se presenta con este mtodo de erradicar los vicios de nuestro esquema relacional es que se pierda informacin como efecto de proyectar un esquema relacional en varios esquemas relacionales. La prdida de informacin puede ser desde prdida de atributos hasta prdida de semntica de datos (perder dependencias funcionales, multivaluadas, de combinacin, etc).

Determinacin de si una descomposicin es SPIRISSANEN (1979) introduce el trmino de proyecciones independientes, que es un mtodo sencillo de comprobar que la descomposicin de un esquema en 2 no posee prdida de informacin. Por tanto, si un sistema de esquemas relacionales es un Sistema de Proyecciones Independientes (SPI), no hay prdida de informacin. ULLMAN (1982) propone un algoritmo que permita, dado un esquema relacional, y el conjunto de las proyecciones en las que se descompone ste, comprobar si ese conjunto de proyecciones es un SPI o no lo es. Vase que Ullman propone un esquema de carcter general, para cualquier nmero de esquemas, aunque en realidad el trmino de Proyecciones Independientes se aplique solo a descomposiciones de esquema en dos partes. Este algoritmo es el siguiente:

;;---- ENTRADAS ---R = (Atributos, DepFunc) PROY = R1 ... Rn ;;----- SALIDAS -----True False ;; ---- MAIN -----1. 2. 3.

;; Atributos =Conjunto de Atributos del esquema original R ;; DepFunc = Conjunto de Dependencias Funcionales del esquema R ;;PROY= conjunto de proyecciones en que se descompone R

;; PROY es un SPI ;; PROY no es un SPI

NCOL = nmero de atributos de R NFIL = nmero de esquemas en que se descompone R (n esquemas en PROY, o sea, n) Construir Matriz = - Filas NFIL (cada fila i representa al esquema proyectado Ri) - Columnas NCOL (cada columna j representa al atributo j del esquema R) Para todo elemento de la matriz Matiz * si el Atributo j est en la proyeccin Ri, se le asigna aj * si el Atributo j no est en la proyeccin Ri, se le asigna bij Mientras la Matriz cambie, y no haya una fila de la matriz con todos sus valores a: Opcin A: Para toda X Y perteneciente a DepFunc en cualquier orden. Opcin B: 4.1 Orden(DepFunc) 4.2 Para toda XY perteneciente a DepFunc ordenado mediante Orden.

4.

Seleccionar las Filas [1], tal que los elementos de la columna que coincide con el Atributo X implicante en XY seleccionado, sean iguales. Para las filas seleccionadas, modificar los valores de la columna que coincide con el atributo Y en la XY seleccionada, de la siguiente manera: Si hay algn ai entre esos valores Poner todos los valores a ai. En caso contrario poner todos los valores a un bij cualquiera. Fin para toda X Y Fin Mientras 5. Si en alguna fila de la matriz, todos los valores son as, devolver TRUE, FALSE en caso contrario.

Vase que en azul se plantean dos maneras de elegir las Dependencias funcionales del conjunto DepFunc: una sin orden ninguno (fue la primera versin del algoritmo) y otra segn un determinado orden (versin propuesta por LOPEZ por motivos de eficiencia). Para entender este algoritmo, vamos a proponer un ejemplo sencillo, considerando que se toman las dependencias XY sin orden alguno del conjunto DepFunc (opcin A). Despus veremos en que consiste la funcin Orden(DepFunc) propuesta por LOPEZ. Ejemplo: R = ({ A, B, C, D} {AB, BC , CD}) PROY = (R1, R2, R3) (3 proyecciones) 1.- NCOL = 4 2.- NFIL = 3 3.- MAT3x4 = R1 = ({A,B} {AB}) R2 = ({B,C} {BC}) R3 = ({C,D} {CD})D b14 b24 a4

R1 R2 R3

A a1 b21 b31

B a2 a2 b32

C b13 a3 a3

4.- Si elijo como orden de testeo de las dependencias funcionales el siguiente: 1 CD, 2 BC, 3 AB, resulta:

CD : Filas en las que MATi3 = MATj3. A a1 b21 b31 B a2 a2 b32 C b13 a3 a3 D b14 b24 a4 A a1 b21 b31 B a2 a2 b32 C b13 a3 a3 D b14 a4 a4

R1 R2 R3

R1 R2 R3

BC : Filas en las que MATi2 = MATj2. A a1 b21 b31 B a2 a2 b32 C b13 a3 a3 D b14 a4 a4 A a1 b21 b31 B a2 a2 b32 C a3 a3 a3 D b14 a4 a4

R1 R2 R3

R1 R2 R3

AB : Filas en las que MATi2 = MATj2. A a1 b21 b31 B a2 a2 b32 C a3 a3 a3 D b14 a4 a4 C D A B R1 a1 a2 a3 b14 R2 b21 a2 a3 a4 R3 b31 b32 a3 a4 (ninguna fila coincide en el elemento A)

R1 R2 R3

No se ha llegado a una fila todo a a, y la matriz si se ha modificado en esta iteracin, por tanto otra iteracin del mientras.CD : Filas en las que MATi2 = MATj2. A a1 b21 b31 B a2 a2 b32 C a3 a3 a3 D b14 a4 a4 A a1 b21 b31 B a2 a2 b32 C a3 a3 a3 D a4 a4 a4

R1 R2 R3

R1 R2 R3

Como vemos, la primera fila correspondiente a R1 tiene todos los elementoscomo as, por ello, elsistema de proyecciones si es SPI. Fin de algoritmo. Sin embargo, esto mismo se ha podido hacer con solo tres dependencias funcionales (3 iteraciones), si se hubieran ordenado de la forma AB, BC, CD. Por ello, LOPEZ propuso la modificacin hecha en la OpcinB: ordenar las dependencias previo a las evaluaciones del mientras, de forma que el orden sea lo ms eficiente posible (menor nmero de iteraciones). Por ejemplo: si un implicante X es compuesto de dos atributos, tienen que coincidir en esos dos atributos las filas en [1] para que sean seleccionadas y modificadas. Si X2 no fuese compuesto, solo tienen que coincidir las filas en 1 atributo (menos restricciones, ms posibilidades de cambio). Si la dependencia de X2 la empleamos antes, ms se modifica la matriz y antes llegar a su fin el algoritmo. Basado en reglas como estas, Orden(DepFunc) opera de la siguiente manera para ordenar de la forma ms eficiente las dependencias en DepFunc:

;;--------- ENTRADAS --------DepFunc ;; conjunto de dependencias funcionales ;; --------- SALIDAS --------ORDEN ;; --------- MAIN--------1. Agrupar las dependencias funcionales de DepFunc en funcin del nmero de atributos que forma el implicante (CONJUNTO1 = 1 atrib. implicante; CONJUNTO2= 2 atrib. implicantes.) Para cada CONJUNTOi , desde 1 hasta n, hacer: Para cada dependencia XY perteneciente a CONJUNTOi VAL=0 CONJUNTOXY = (Atributos de X) UNION (Atributos de Y) Para cada AT, siendo AT un atributo de CONJUNTOXY: Caso AT: AT siempre implicante en CONJUNTOi => VAL= VAL + 0 AT como implicante e implicado en CONJUNTOi => VAL= VAL + 1 AT siempre como implicado en CONJUNTOi => VAL= VAL + 2 Fin Para cada AT VALOR(DEP) =VAL Fin para cada dependencia Aadir al final del conjunto ORDEN cada una de las dependencias DFk pertenecientes a CONJUNTOi, ordenada en funcin de su VALOR VALOR(DFk). [2] Fin Para todo CONJUNTOi

;; conjunto de dependencias funcionales ordenadas eficientemente.

2.

Por ejemplo: Sea DepFunc = {AC, CD, BC, CEA, DEC} 1. CONJUNTO1 = {AC, CD, BC} CONJUNTO2 = {CEA, DEC}CONJUNTO1 Valor 1(AC) Valor (CD) Valor (BC)

2.

CONJUNTO2 Valor 3(CEA) Valor (DEC)

3 1

1

3. Ordenar dependencias, de forma que salgan antes las que son de un conjunto menor, y dentro de estas, la que tenga menor valor:CONJUNTO1 CONJUNTO2

ORDEN= {AC, BC, CD, DEC, CEA}

Determinacin de si una descomposicin preserva las Dependencias FuncionalesEl algoritmo anterior se basa en la definicin de proyecciones independientes, que parte de la descomposicin de un esquema en 2 proyecciones. Cuando un esquema se descompone en mayor nmero de proyecciones, cmo aplicar las condiciones de proyecciones independientes?. Se puede hacer de 2 en 2 (para lo que surge el problema de Qu combinaciones de esquemas usar para hacer parejas?), pero puede ser que una descomposicin sea SPI, y sin embargo, al aplicar el mtodo por parejas resulte darnos que no es SPI. Dadas estas limitaciones, ULLMAN (1982) propone un algoritmo no basado en el clculo del cierre de un conjunto de dependencias funcionales, y por tanto, no es exponencial, sino que es polinomial su coste con respecto al nmero de dependencias funcionales.

;; ---------ENTRADAS--------R= (Atributos, DepFunc) PROY= R1Rn ;; --------- SALIDAS --------RESULTADO = TRUE RESULTADO = FALSE ;; --------- MAIN --------1. G= DEP [Ri]i = 1 .. n

;;Atributos: atributos del esquema original R ;;DepFunc: dependencias funcionales del esquema original R ;;PROY: conjunto de proyecciones de R

;; PROY es una descomposicin que preserva dependencias de R ;; PROY no es una descomposicin que preserva dependencias de R

;; En G se meten todas las dependencias que hay en las distintas ;; proyecciones, desde la primera (R1) hasta la ltima (Rn).

2. RESULTADO = TRUE 3. Para toda XY que pertenece a DepFunc Z=X Mientras Z cambie Para i= 1..n hacer Z=Z ((Z Ri)+ Fin Para Fin mientras Si Y Fin si Fin para toda XY perteneciente a DepFunc Z entonces RESULADO =FALSE

;; para toda dependencia funcional del R de partida

Ri)

Si nos damos cuenta, en el punto 3 lo que hace es: calcular el cierre transitivo del implicante X ( Z= X+G) con respecto al total de dependencias funcionales que hay en las proyecciones, o sea, en G. Una vez obtenido este cierre, que son todos los atributos que pueden ser determinados por X (directa o indirectamente) a travs de las dependencias que se dan en las proyecciones, si la Y est contenida en ste (Z = X+G), entonces significa que XY se puede deducir a travs de las dependencias en las proyecciones, por tanto se conserva esa dependencia funcional del esquema original. Si no est la Y en el cierre X+G, entonces no se puede deducir XY a partir de las proyecciones, por tanto se perdieron dependencias funcionales(devuelve FALSE).

Por ejemplo: R=({A,B,C,D} {AB, BC, CD, DA}) PROY= [ R1=({A, B} {AB, BA}) R2=({B, C} {BC, CB}) R3=({C, D} {CD, DC})

] De las dependencias originales, parece que falta la dependencia DA. Apliquemos el algoritmo tomando esa dependencia directamente (las otras daran que RESULTADO=TRUE) 1.- G = (AB, BA, BC, CB, CD, DC) 2.- Como tomamos DA del conjunto inicial de R Z={D} Z sobre R1 Z= {A,B,C,D} 3.Z sobre R1 Z= {D}Z sobre R2 Z= {D} Z sobre R3 Z= {C, D} Z sobre R1 Z= {C, D} Z sobre R2 Z= {B, C , D} Z sobre R3 Z= {B, C, D} Z sobre R2 Z= {A,B,C,D} Z sobre R3 Z= {A,B,C,D} Z sobre R1 Z= {A,B,C,D} Z sobre R2 Z= {A,B,C,D} Z sobre R3 Z= {A,B,C,D}

4.- Como en el cierre transitivo de D+G se encuentra A, quiere decir que se puede deducir DA a partir de las dependencias de las proyecciones, por tanto, se han conservado todas las dependencias funcionales del esquema inicial.

Algoritmos ALTERNATIVOSPor ahora hemos trabajado con el diseo lgico de la base de datos, refinando un primer esquema relacional mediante el concepto de las formas normales y las proyecciones independientes. Sin embardo, la normalizacin no es el nico mtodo de refinamiento de la base de datos, ni puede conseguir todos sus objetivos (que es representar un mundo real lo ms fidedigna posible).

Particionamiento VerticalEn este mbito, aparece el Particionamiento Vertical como una metodologa de refinamiento de la base de datos, pero ya no solo a nivel lgico, sino a caballo entre el nivel lgico y el fsico. Por tanto, el objetivo de esta metodologa es la eficiencia. Para ello, va a descomponer un esquema relacional en conjuntos de atributos que sean accedidos en conjunto por gran nmero de transacciones. Que se presenten en la misma proyeccin permite realizar menor nmero de accesos a disco para traer los datos a memoria principal. Previo a ver el algoritmo grfico, vamos a definir unos trminos: Matriz de utilizacin de atributos: las columnas son los atributos de la relacin que se va a particionar. Las filas son las transacciones respecto a las cuales se particionar. En cada posicin ij de la columna va un 1 si el atributo j correspondiente es usado por la transaccin i correspondiente, cero en caso contrario. Matriz de afinidad: Se enfrenta cada atributo (columnas) con todos los atributos de la relacin (fila), de manera que el resultado de la casilla ij es, de las transacciones comunes en las que aparece tanto el atributo i como el j, el tiempo de acceso por cada transaccin coincidente. * Mide Fuerza de enlace entre atributos en la misma transaccin. * En la diagonal ( un atributo consigo mismo) se mide la fuerza del atributo debida a su utilizacin por el conjunto de transacciones. Grafo de Afinidad: representar la matriz de afinidad mediante un grafo, donde los nodos son los atributos, y los arcos entre un nodo i y un nodo j, es la fuerza de enlace entre los atributos i y j de la matriz dicha. Ciclo primitivo: cualquier ciclo del grafo Nodo Ciclo: nodo del arco que completa el ciclo Ciclo de Afinidad: un ciclo primitivo que no tiene arco anterior, o si lo tiene, su peso es menor o igual que el peso de todos los arcos del ciclo.

-

-

-

-

Arco anterior: arco seleccionado entre el ltimo corte y el nodo ciclo. Extensin de un ciclo: ciclo que se extiende pivotando en un nodo ciclo. La condicin para extender un ciclo es que el peso del arco considerado o del arco que completa sea mayor o igual que cualquiera de los arcos que forman el ciclo.

El algoritmo para el Particionamiento vertical es el siguiente:

;; --------- ENTRADAS--------AT ;; conjunto de atributos ;; --------- SALIDAS --------PROY ;; --------- MAIN --------1.- Construir Grafo de afinidad 2.- Empezar por cualquier nodo 3.- Seleccionar un arco, tal que est linealmente conectado al arbol construido hasta ahora, y posea el valor mayor de afinidad de los arcos de los extremos del rbol. Esta iteracin acaba cuando se seleccionan todos los nodos. 4.- Si ese siguiente arco forma un ciclo: * Si el nodo ciclo no existe, verificar las posibilidades de un ciclo de afinidad, y si se cumplen, marcarlo como un ciclo de afinidad y considerarlo particin candidata. * Si el nodo ciclo ya existe, descartar este arco y volver a 3. 5.- Si el siguiente arco no forma un ciclo y existe una particin candidata *Si no existe un arco anterior, verificar si se puede extender. Si no se puede, cortar el arco y considerar el ciclo como una particin ( ya no es candidata, ya es real). *Si existe un arco anterior, cambiar el nodo ciclo al nodo donde se extendi el arco, y verificar la posibilidad de extensin del ciclo con el arco anterior. Si no hay posibilidad, cortar el arco anterior y considerar el ciclo como una particin, Ir al paso 3.

;;conjunto de esquemas en los que se divide el esquema original con atributos AT.

Vamos a poner un ejemplo sencillo del Particionamiento vertical: Ejemplo:Partimos del esquema LIBRO, con los atributos cdigo, ttulo, idioma, lema, nmero, ao, editorial, precio, editor, observaciones. Obtenemos el grafo de la manera siguiente:

Ejemplos de transacciones con sus retardos

Matriz de afinidad

Grafo de afinidades

Comenzamos por Cdigo. A partir de aqu tomamos arcos con mayor afinidad. El siguiente es Cdigo-Ttulo, el siguiente mayor del rbol ya formado es Ttulo-ao, y el siguiente ao-editorial. Aqu tenemos que parar, puse se ha formado un ciclo (editorial-cdigo). Estamos en el caso 4, la primera opcin ( no existe nodo ciclo), por tanto, como cumple condiciones del ciclo de afinidad (no hay arco anterior), es un ciclo de afinidad y por tanto particin candidata= Cdigo, Titulo, Ao, Editorial. Cdigo se convierte en nodo ciclo. El siguiente arco de extremos con mayor afinidad es editorial-editor. Estamos antes el caso 5 debido a este arco, y como no existe arco anterior, comprobamos que no se puede extender, pues el arco nuevo editorial-editor y el que completa el ciclo editor-cdigo tiene valor 25, menor que cualquier arco de la particin candidata. Se debe cortar por este arco y considerar el ciclo como particin definitivamente (ya no hay particin candidata). El siguiente arco escogido es editor-idioma. No hay ciclo ni particin candidata, por tanto seguimos cogiendo el mayor, tomando idioma-tema, y finalmente editor-tema. Se ha formado un ciclo, por lo que estamos en 4, y como se cumplen condiciones de ciclo de afinidad ( pues no hay arcos anteriores) esta se convierte en una particin candidata= Editor,Idioma,Tema. El siguiente arco es cdigo-observaciones. Nos sita en el caso 5, la primera opcin (pues no hay arco anterior), y como no se cumple condicin de extensin de ciclo (pues tema,idioma observacin, no incluye al nodo ciclo) se produce corte entre cdigo-observaciones, y se considera la particin candidata como particin final. Finalmente, a partir de observaciones se obtiene la particin candidata =Observaciones, Nmero, Precio, que como no hay mas nodos, se completa como particin. Por tanto, finalmente hemos descompuesto LIBRO en las particiones: LIBRO1={Cdigo, ttulo, editorial, ao}; LIBRO2={Cdigo,editor,idioma,tema} LIBRO3= {Cdigo, observaciones ,precio, nmero}. Vase que en cada particin se incluye el nodo ciclo correspondiente, que en este caso es el mismo para los tres.

15Observ.

Nmero

5 15Cdigo

5Precio

40 30Editorial

Ttulo

35Ao

35Editor

25

15Tema

15Idioma

15

Particionamiento HorizontalEs un mtodo de estructuracin lgica, fuera de la normalizacin, que suprime los valores nulos de riesgo que pueden aparecer en las relaciones, bien por que no se ha detectado subtipos de una entidad, o bien por haber reunido tipos y subtipos en una sola relacin en el paso del modelo E/I al modelo R. Por ejemplo: Se da el esquema relacional PERSONA, que se define de la forma PERSONA: {Nombre, Apellido1, Apellido2, Nacionalidad, DNI } Si una persona es de Nacionalidad extranjera, no espaola, no puede tener DNI, por ello DNI debe aceptar nulos (No es aplicable a extranjeros). Sin embargo, no puede haber un espaol que no tenga DNI. Vase que DNI es obligadamente nulo para personas de Nacionalidad extranjera, y obligatoriamente no nulo para espaoles. Esto genera problemas de mantenimiento de la Base de Datos: nadie me impide insertar un extranjero con un DNI, ni un espaol sin DNI, puesto que DNI debe aceptar nulos para coger ambos casos. Algo similar sucede con Apellido2, que no puede aparecer por ejemplo en un americano (vamos a suponer que los espaoles son los nicos en el mundo que usan dos apellidos), al no ser aplicable a extranjeros. El problema radica en que al generar la base de datos, no hemos sabido reconocer que en realidad se daba un supertipo PERSONA, con un nombre, Apellido1 y dos subtipos: EXTRANJEROS, con una Nacionalidad, adems del nombre y apellido1 que hereda de PERSONA, y ESPAOLES, con un Apellido2 y DNI, adems de lo heredado de PERSONA.PERSONA Nombre, Apellido1

EXTRANJEROS Nombre, Apellido1, Nacionalidad

ESPAOLES Nombre, Apellido1, Apellido2, DNI

Este es el Particionamiento horizontal.

ConclusionesEn el Diseo lgico de una Base de datos, la simple aplicacin de las reglas de transformacin para pasar del esquema conceptual (diagramas Entidad /Interrelacin) al esquema relacional es insuficiente, ya que resulta un conjunto de esquemas relacionales redundantes y que no refleja adecuadamente la semntica de los datos. Esto implica una fase de refinamiento del esquema relacional obtenido inicialmente. Dado el carcter sistemtico de este refinamiento, y su estructura secuencial, la mejor manera de realizarla es algortmicamente, lo cual implica: - Mtodo sistemtico. - Facilmente implementable. - Su implementacin software permite una automatizacin. - Diseador de la Base de Datos puede centrarse en otros aspectos del diseo. La desventaja de los algoritmos, y el handicap en la generacin de algoritmos para este fin, es el tiempo de costo de los mismos, ya que de nada sirve una herramienta que no se puede usar en la prctica. Otra desventaja es que estos algoritmos no tienen en cuenta la semntica de datos, por lo que en muchas ocasiones se llegan a resultados absurdos semnticamente, pero tericamente correctos (ya que las transformaciones de datos son de carcter sintctico). Hoy en da, el uso de estos algoritmos se dan sobre todo en procesos de rediseos o ampliaciones de bases de datos, ya que se hace muy costoso comprobar manualmente el impacto de la variacin de las dependencias del esquema relacional.

En general, la eficiencia de estos algoritmos est en funcin del conjunto de dependencias del esquema del que se parte.