Caso 3a terminado, rotacion a izquierda, falta 3a rotacion derecha, 3b y listo Arbol...

[z.facultad/75.06/emufs.git] / emufs / indice_bplus.c

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index 50e65d33d3f5ce477395b64f827f0ced34cea45c..036d4cc612f6ad0b48dd4c80aa9705b52bbae081 100644 (file)
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -234,9 +234,11 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
     
     i = nodo->cant_claves-1; 
     if ( nodo->nivel == 0 ){
     
     i = nodo->cant_claves-1; 
     if ( nodo->nivel == 0 ){

+               /* Muevo siempre el encadenamiento */
+               nodo->hijos[i+2] = nodo->hijos[i+1];
+               /* Ahora muevo las claves y sus punteros a bloques del dat */

         while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ){
         while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ){

-            nodo->claves[i+1] = nodo->claves[i];
-                       nodo->hijos[i+2] = nodo->hijos[i+1];
+            nodo->claves[i+1] = nodo->claves[i];                       

                        nodo->hijos[i+1] = nodo->hijos[i];
             i--;
         }
                        nodo->hijos[i+1] = nodo->hijos[i];
             i--;
         }


@@ -361,9 +363,9 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
                                        break;                                  
                        /* Busco sucesor en la hoja */                                                          
                        case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;
                                        break;                                  
                        /* Busco sucesor en la hoja */                                                          
                        case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;

-                                       else {                                          
+                                       else {                                                                                          

                                                prepostkey->clave = nodo->claves[i+1];
                                                prepostkey->clave = nodo->claves[i+1];

-                                               prepostkey->num_bloque = nodo->hijos[i+i];
+                                               prepostkey->num_bloque = nodo->hijos[i+1];

                                                exitcode = 1;
                                        }
                                        break;
                                                exitcode = 1;
                                        }
                                        break;


@@ -410,7 +412,7 @@ int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int n
        if (b_plus_existe_clave(idx,&auxquery,num_node) == 1) {                                 
                
                /* Levanto el nodo y busco donde esta la clave */               
        if (b_plus_existe_clave(idx,&auxquery,num_node) == 1) {                                 
                
                /* Levanto el nodo y busco donde esta la clave */               

-               printf("El reemplazar encontro la clave %i y en el nodo %i\n",auxquery.clave.i_clave,(int)auxquery.num_bloque);
+               /*printf("El reemplazar encontro la clave %i y en el nodo %i\n",auxquery.clave.i_clave,(int)auxquery.num_bloque);*/

                nodo = b_plus_leer_nodo(idx,auxquery.num_bloque);
                if (nodo == NULL) return -1;
                i = nodo->cant_claves - 1;
                nodo = b_plus_leer_nodo(idx,auxquery.num_bloque);
                if (nodo == NULL) return -1;
                i = nodo->cant_claves - 1;


@@ -437,6 +439,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 {
        INDEX_DAT prepostkey;
        int i = 0,j = 0,minclaves = 0, nivel_mayor1 = 0,cant_claves_child = 0;
 {
        INDEX_DAT prepostkey;
        int i = 0,j = 0,minclaves = 0, nivel_mayor1 = 0,cant_claves_child = 0;

+       int cant_claves_rsibling = 0, cant_claves_lsibling = 0, es_hoja = 0;

        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        NODO_B_PLUS *node_y,*node_z;
        if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }
        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        NODO_B_PLUS *node_y,*node_z;
        if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }


@@ -464,7 +467,58 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                /* Me debo fijar si esta la clave en este nodo interno, sino busco */           
                while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
                if (i < 0) {
                /* Me debo fijar si esta la clave en este nodo interno, sino busco */           
                while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
                if (i < 0) {

-                       /* No esta en este nodo interno, caso 3 */
+                       PERR("Entre caso 3 del eliminar");                              
+                       /* No esta en este nodo interno, caso 3. Determino en que rama debe estar */
+                       i = nodo->cant_claves - 1;
+                       while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i;
+               i++;
+               cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]);
+                       if (cant_claves_child > minclaves) emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
+                       else {
+                               /* Vemos si estamos en caso 3a o 3b, mirando cant_claves de sus siblings */
+                               if (i < nodo->cant_claves) cant_claves_rsibling = b_plus_cant_claves_nodo(idx,nodo->hijos[i+1]);
+                               if (i > 0) cant_claves_lsibling = b_plus_cant_claves_nodo(idx,nodo->hijos[i-1]);
+                               printf ("El sibling derecho si existe tiene %i claves\n", cant_claves_rsibling);
+                               printf ("El sibling izquierdo si existe tiene %i claves\n", cant_claves_lsibling);      
+                               if (cant_claves_rsibling > minclaves) {
+                                       /* El sibling derecho me dara una key mediante rotacion. Caso 3a */
+                                       PERR("Entre caso 3a right sibling del eliminar");
+                                       node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
+                                       node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
+                                       if (node_z->nivel == 0) es_hoja = 1;
+                                       /* Le bajo la del padre a NodeY y muevo el apropiado child de NodoZ a NodoY */
+                                       node_y->claves[cant_claves_child] = nodo->claves[i];
+                                       node_y->hijos[cant_claves_child+1] = node_y->hijos[cant_claves_child];
+                                       node_y->hijos[cant_claves_child+1-es_hoja] = node_z->hijos[0];
+                                       node_y->cant_claves++;
+                                       /* Le subo al padre desde el NodoZ, teniendo en cuenta si es hoja o no */
+                                       nodo->claves[i] = node_z->claves[es_hoja];
+                                       /* Hago shifting en el sibling para quitar la que subio */
+                                       for (j = 0; j < node_z->cant_claves-1; ++j) {
+                                               node_z->claves[j] = node_z->claves[j+1];
+                                               node_z->hijos[j] = node_z->hijos[j+1];
+                                       }
+                                       node_z->hijos[j] = node_z->hijos[j+1];
+                               node_z->cant_claves--;
+                                       /* Grabo los cambios y listo */                                 
+                                       b_plus_grabar_nodo(idx,node_z,nodo->hijos[i+1]);
+                                       b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]);
+                                       b_plus_grabar_nodo(idx,nodo,num_node);
+                                       b_plus_destruir_nodo(node_y);
+                                       b_plus_destruir_nodo(node_z);
+                                       /* Borro recursivamente KEY entrando por Child que ahora tiene minclaves+1 */
+                                       emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
+                               }
+                               else if (cant_claves_lsibling > minclaves) {
+                                               /* el sibling izquierdo me dara una key mediante rotacion Caso 3a */
+                                               PERR("Entre caso 3a left sibling del eliminar");
+                                               node_z = b_plus_leer_nodo(idx,nodo->hijos[i]);  
+                                               node_y = b_plus_leer_nodo(idx,nodo->hijos[i-1]);
+                                       } else {
+                                               /* Caso 3b, debo bajar una clave y unificar con sibling disponible */
+                                               PERR("Entre caso 3b del eliminar");
+                                       }
+                       }

                } else {
                        /* Esta en el nodo interno, caso 2 */
                        cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]);
                } else {
                        /* Esta en el nodo interno, caso 2 */
                        cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]);


@@ -484,8 +538,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                if (cant_claves_child > minclaves) {
                                        PERR("Entre caso 2b del eliminar");
                                        /* Caso 2b, comienzo buscando la clave sucesor inmediata */
                                if (cant_claves_child > minclaves) {
                                        PERR("Entre caso 2b del eliminar");
                                        /* Caso 2b, comienzo buscando la clave sucesor inmediata */

-                                       b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],&prepostkey,1);
-                                       printf("Bloque .dat en prepostkey %i\n",prepostkey.num_bloque);                                 
+                                       b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],&prepostkey,1);                                  

                                        /* La elimino recursivamente */
                                        emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i+1]); /* CHEAT */
                                        /* Remplazo mi clave key por la encontrada postkey */
                                        /* La elimino recursivamente */
                                        emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i+1]); /* CHEAT */
                                        /* Remplazo mi clave key por la encontrada postkey */


@@ -494,6 +547,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                        /* Remplazo la otra instancia de key en una hoja seguro por postkey */
                                        emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]);                                     
                                } else {
                                        /* Remplazo la otra instancia de key en una hoja seguro por postkey */
                                        emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]);                                     
                                } else {

+                                       PERR("Entre caso 2c del eliminar");

                                        /* Caso 2c debo hacer un merge de la clave con hijo izq y der */
                                        node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
                                        node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
                                        /* Caso 2c debo hacer un merge de la clave con hijo izq y der */
                                        node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
                                        node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]);


@@ -515,16 +569,23 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                        b_plus_grabar_nodo(idx,nodo,num_node);
                                        b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]);
                                        b_plus_destruir_nodo(node_y);
                                        b_plus_grabar_nodo(idx,nodo,num_node);
                                        b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]);
                                        b_plus_destruir_nodo(node_y);

-                                       b_plus_destruir_nodo(node_z);
+                                       b_plus_destruir_nodo(node_z);                                   

                                        /* Elimino recursivamente Key de NodeY, entrando por ese subtree */
                                        /* Elimino recursivamente Key de NodeY, entrando por ese subtree */

-                                       emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
-                                       }
+                                       emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);                                  
+                                       /* Caso muy particular, si hize un merge de la unica clave de una raiz con sus hijos */
+                                       if ((nodo->nivel == 1) && (nodo->cant_claves == 0)) {
+                                               /* Debo establecer como nueva raiz, el NodoY */
+                                               node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
+                                               b_plus_grabar_nodo(idx,node_y,0);
+                                               truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
+                                       }                                                                               

                                }
                                }

-                       }                       
-                       /* Termine caso 2 o 3, libero el nodo */
-                       b_plus_destruir_nodo(nodo);
-                       return 0;                       
-               }
+                       }
+               }                       
+               /* Termine caso 2 o 3, libero el nodo */
+               b_plus_destruir_nodo(nodo);
+               return 0;                       
+       }

        
        return -1;
 }
        
        return -1;
 }


@@ -537,8 +598,7 @@ int b_plus_get_num_nodo(INDICE *idx)
        fp = fopen(idx->filename, "ab");
        if (fp == NULL) return -1;
     
        fp = fopen(idx->filename, "ab");
        if (fp == NULL) return -1;
     

-    num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
-       printf("Num Nodo Nuevo: %i\n",num);
+    num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);     

     fclose(fp);
     return num;
 }
     fclose(fp);
     return num;
 }