]> git.llucax.com Git - z.facultad/75.06/emufs.git/blobdiff - emufs/indice_bplus.c
Ultimas correcciones.
[z.facultad/75.06/emufs.git] / emufs / indice_bplus.c
index c693803e21ff4ec8d43da9820a75562f8f806f69..b147284a6db3f0b3d91840c2206f034bda5a1c9a 100644 (file)
@@ -1,4 +1,6 @@
 /** Arbol B+ */
 /** Arbol B+ */
+#include "tipo1.h"
+#include "tipo3.h"
 #include "indices.h"
 #include "indice_bplus.h"
 
 #include "indices.h"
 #include "indice_bplus.h"
 
@@ -75,7 +77,7 @@ int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
        /* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
        if (nodo->nivel == 0) {
         /* Vemos en que bloque deberia ir */
        /* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
        if (nodo->nivel == 0) {
         /* Vemos en que bloque deberia ir */
-               while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--;
+               while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
                if (i < 0) {
                        /* La clave es menor que todas, debo insertarla */
                        b_plus_destruir_nodo(nodo);                     
                if (i < 0) {
                        /* La clave es menor que todas, debo insertarla */
                        b_plus_destruir_nodo(nodo);                     
@@ -83,15 +85,15 @@ int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
                        return -1;
                }
                else {
                        return -1;
                }
                else {
-                       /* Encontre un bloque potencial */
-                       query->num_bloque = nodo->hijos[i];
+                       /* Encontre un bloque potencial */                      
+                       query->num_bloque = nodo->hijos[i];                     
                        b_plus_destruir_nodo(nodo);                     
                        return 0;
                }
        }
        else {
                /* Buscamos por donde descender al siguiente nivel */
                        b_plus_destruir_nodo(nodo);                     
                        return 0;
                }
        }
        else {
                /* Buscamos por donde descender al siguiente nivel */
-               while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--;
+               while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
         i++;
         num_node = nodo->hijos[i];
                b_plus_destruir_nodo(nodo);
         i++;
         num_node = nodo->hijos[i];
                b_plus_destruir_nodo(nodo);
@@ -237,7 +239,7 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
                /* Muevo siempre el encadenamiento */
                nodo->hijos[i+2] = nodo->hijos[i+1];
                /* Ahora muevo las claves y sus punteros a bloques del dat */
                /* 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 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])){
             nodo->claves[i+1] = nodo->claves[i];                       
                        nodo->hijos[i+1] = nodo->hijos[i];
             i--;
             nodo->claves[i+1] = nodo->claves[i];                       
                        nodo->hijos[i+1] = nodo->hijos[i];
             i--;
@@ -247,14 +249,15 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
         nodo->cant_claves++;
         b_plus_grabar_nodo(idx, nodo, num_nodo);
     } else { 
         nodo->cant_claves++;
         b_plus_grabar_nodo(idx, nodo, num_nodo);
     } else { 
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave 
+        while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])
             i--;
         i++;
         num_nodo_hijo = nodo->hijos[i];
         hijo = b_plus_leer_nodo(idx, num_nodo_hijo);
         if ( hijo->cant_claves == idx->size_claves/sizeof(CLAVE) ) {
             b_plus_split_child(idx, num_nodo, nodo, i, hijo);
             i--;
         i++;
         num_nodo_hijo = nodo->hijos[i];
         hijo = b_plus_leer_nodo(idx, num_nodo_hijo);
         if ( hijo->cant_claves == idx->size_claves/sizeof(CLAVE) ) {
             b_plus_split_child(idx, num_nodo, nodo, i, hijo);
-            if ( query->clave.i_clave > nodo->claves[i].i_clave )
+                       /* OjO Utilizo el menor pero con el proposito de clave > nodo->clave) */
+            if (emufs_indice_es_menor(idx,nodo->claves[i],query->clave))
                 i++;
         }
                if (hijo) b_plus_destruir_nodo(hijo);
                 i++;
         }
                if (hijo) b_plus_destruir_nodo(hijo);
@@ -306,7 +309,7 @@ int b_plus_existe_clave(INDICE *idx, INDEX_DAT *query, int num_node)
        /* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
        if (nodo->nivel == 0) {
         /* Vemos si esta la clave */
        /* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
        if (nodo->nivel == 0) {
         /* Vemos si esta la clave */
-               while ( i >= 0 && query->clave.i_clave != nodo->claves[i].i_clave ) i--;
+               while ( i >= 0 && !emufs_indice_es_igual(idx,query->clave,nodo->claves[i])) i--;
                if (i < 0)
                {
                        b_plus_destruir_nodo(nodo);
                if (i < 0)
                {
                        b_plus_destruir_nodo(nodo);
@@ -320,7 +323,7 @@ int b_plus_existe_clave(INDICE *idx, INDEX_DAT *query, int num_node)
        }
        else {
                /* Buscamos por donde descender al siguiente nivel */
        }
        else {
                /* Buscamos por donde descender al siguiente nivel */
-               while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--;
+               while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
         i++;
         num_node = nodo->hijos[i];
                b_plus_destruir_nodo(nodo);
         i++;
         num_node = nodo->hijos[i];
                b_plus_destruir_nodo(nodo);
@@ -341,17 +344,17 @@ int b_plus_cant_claves_nodo(INDICE *idx, int num_node)
 int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepostkey, int search_type)
 {
        int i = 0, exitcode = 0;
 int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepostkey, int search_type)
 {
        int i = 0, exitcode = 0;
-       NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);             
+       NODO_B_PLUS *child = NULL;
+       NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        if (nodo == NULL) return -1;
        if (nodo == NULL) return -1;
-       i = nodo->cant_claves - 1;
-       
-       if (nodo->nivel == 0) {         
-               while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i;          
+       i = nodo->cant_claves - 1;      
+       if (nodo->nivel == 0) {                         
+               while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;          
                switch (search_type) {                  
                        /* Busco predecesor en la hoja */                       
                        case 0: if (i <= 0) exitcode = 0;
                                        else {                                          
                switch (search_type) {                  
                        /* Busco predecesor en la hoja */                       
                        case 0: if (i <= 0) exitcode = 0;
                                        else {                                          
-                                               if (nodo->claves[i].i_clave == key.i_clave)     {
+                                               if (emufs_indice_es_igual(idx,nodo->claves[i],key))     {
                                                        prepostkey->clave = nodo->claves[i-1];
                                                        prepostkey->num_bloque = nodo->hijos[i-1];
                                                } else {
                                                        prepostkey->clave = nodo->claves[i-1];
                                                        prepostkey->num_bloque = nodo->hijos[i-1];
                                                } else {
@@ -362,9 +365,20 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
                                        }
                                        break;                                  
                        /* Busco sucesor en la hoja */                                                          
                                        }
                                        break;                                  
                        /* Busco sucesor en la hoja */                                                          
-                       case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;
+                       case 1: if (i == nodo->cant_claves-1) {
+                                               /* Busco el primero del siguiente nodo del SQSET */
+                                               num_node = nodo->hijos[nodo->cant_claves];
+                                               if (num_node != -1) {
+                                                       b_plus_destruir_nodo(nodo);
+                                                       nodo = b_plus_leer_nodo(idx,num_node);
+                                                       prepostkey->clave = nodo->claves[0];
+                                                       prepostkey->num_bloque = nodo->hijos[0];
+                                                       exitcode = 1;                                                   
+                                               } 
+                                               else exitcode = -1; /* No hay mas */
+                                       }
                                        else {                                                                                          
                                        else {                                                                                          
-                                               prepostkey->clave = nodo->claves[i+1];
+                                               prepostkey->clave = nodo->claves[i+1];                                          
                                                prepostkey->num_bloque = nodo->hijos[i+1];
                                                exitcode = 1;
                                        }
                                                prepostkey->num_bloque = nodo->hijos[i+1];
                                                exitcode = 1;
                                        }
@@ -372,7 +386,7 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
                }                                                                                                                               
        } else {
                /* Veo por que rama debo seguir buscando el pre o post */
                }                                                                                                                               
        } else {
                /* Veo por que rama debo seguir buscando el pre o post */
-               while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i;          
+               while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;          
                if (search_type == 0) {
                        if (i < 0) exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
                        else {
                if (search_type == 0) {
                        if (i < 0) exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
                        else {
@@ -384,15 +398,8 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
                        /* Handleo busqueda de clave menor o igual que todas */
                        if (exitcode == 0) exitcode = -1;
                } else  {
                        /* Handleo busqueda de clave menor o igual que todas */
                        if (exitcode == 0) exitcode = -1;
                } else  {
-                       /* Busco un sucesor, y funciona como getbloque... */                    
+                       /* Busco un sucesor como get bloque */                  
                        exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
                        exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
-                       /* Veo si tengo que devolver la clave izquierda del padre del que acabo de buscar */
-                       if (exitcode == 0) {
-                               if (i < nodo->cant_claves-1) {
-                                       prepostkey->clave = nodo->claves[i+1];
-                                       exitcode = 1;
-                               } else  exitcode = -1;
-                       }
                }               
        }
        
                }               
        }
        
@@ -418,7 +425,7 @@ int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int n
                i = nodo->cant_claves - 1;
                
                /* Busco la clave y reemplazo */
                i = nodo->cant_claves - 1;
                
                /* Busco la clave y reemplazo */
-               while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
+               while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
                if (i < 0) return -1; /* Error, no esta la clave */
                
                /* Cheque por las dudas si es hoja o interno, aunque deberia ser hoja */
                if (i < 0) return -1; /* Error, no esta la clave */
                
                /* Cheque por las dudas si es hoja o interno, aunque deberia ser hoja */
@@ -440,8 +447,9 @@ 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;
        int cant_claves_rsibling = 0, cant_claves_lsibling = 0, es_hoja = 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;
+       int leftoffset = 0;
        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
-       NODO_B_PLUS *node_y,*node_z;
+       NODO_B_PLUS *node_y,*node_z,*mergenode,*siblingnode;
        if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }
        i = nodo->cant_claves - 1;
        minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1;
        if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }
        i = nodo->cant_claves - 1;
        minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1;
@@ -449,7 +457,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
        /* Si es hoja, borro directamente la clave. No se producira underflow
        pues lo asegura la recursividad del delete */   
        if (nodo->nivel == 0) {         
        /* Si es hoja, borro directamente la clave. No se producira underflow
        pues lo asegura la recursividad del delete */   
        if (nodo->nivel == 0) {         
-               while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
+               while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
                if (i < 0) return -1;
                /* Encontre la clave en la pos i, la borro */
                for (j = i; j < nodo->cant_claves-1; ++j) {
                if (i < 0) return -1;
                /* Encontre la clave en la pos i, la borro */
                for (j = i; j < nodo->cant_claves-1; ++j) {
@@ -465,12 +473,12 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                return 0;
        } else {
                /* Me debo fijar si esta la clave en este nodo interno, sino busco */           
                return 0;
        } else {
                /* 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;
+               while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
                if (i < 0) {
                        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;
                if (i < 0) {
                        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;
+                       while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --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]);
                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]);
@@ -478,8 +486,8 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                /* 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]);
                                /* 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);      
+                               /*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");
                                if (cant_claves_rsibling > minclaves) {
                                        /* El sibling derecho me dara una key mediante rotacion. Caso 3a */
                                        PERR("Entre caso 3a right sibling del eliminar");
@@ -505,7 +513,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                        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_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);
+                                       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]);
                                }
                                        /* Borro recursivamente KEY entrando por Child que ahora tiene minclaves+1 */
                                        emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
                                }
@@ -549,9 +557,52 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                                emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);                                          
                                        } else {
                                                /* Caso 3b, debo bajar una clave y unificar con sibling disponible */
                                                emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);                                          
                                        } else {
                                                /* Caso 3b, debo bajar una clave y unificar con sibling disponible */
-                                               PERR("Entre caso 3b del eliminar");
-                                       }
-                       }
+                                               PERR("Entre caso 3b del eliminar");                                             
+                                               if (cant_claves_lsibling == minclaves) {
+                                                       PERR("Hago merge con sibling izquierdo");
+                                                       leftoffset = 1;
+                                                       siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i]);     /* Este es el root de la rama! */
+                                                       mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-1]); /* Aca va todo */
+                                               } else {
+                                                       PERR("Hago merge con sibling derecho");
+                                                       leftoffset = 0;
+                                                       mergenode = b_plus_leer_nodo(idx,nodo->hijos[i]);
+                                                       siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
+                                               }
+                                               
+                                               /* Bajo una clave del Padre Nodo a MergeNode y muevo todo lo SiblingNode a MergeNode */
+                                               /* Si es nivel mayor a 1, bajo clave, otherwise no bajo pues se repetiria */
+                                               nivel_mayor1 = 0;
+                                               if (nodo->nivel > 1) {
+                                                       nivel_mayor1 = 1;
+                                                       mergenode->claves[minclaves] = nodo->claves[i-leftoffset];                                                      
+                                               }               
+                                               for (j = 0; j < minclaves; ++j) mergenode->claves[j+minclaves+nivel_mayor1] = siblingnode->claves[j];
+                                               for (j = 0; j < minclaves+1; ++j) mergenode->hijos[j+minclaves+nivel_mayor1] = siblingnode->hijos[j];
+                                               mergenode->cant_claves = minclaves*2+nivel_mayor1;                                      
+                                               
+                                               /* Shifteo en el nodo padre NODO, para quitar la que bajo */
+                                               for (j = i-leftoffset; j < nodo->cant_claves-1; ++j) {
+                                                       nodo->claves[j] = nodo->claves[j+1];
+                                                       nodo->hijos[j+1] = nodo->hijos[j+2];
+                                               }
+                                               nodo->cant_claves--;
+                                               b_plus_grabar_nodo(idx,nodo,num_node);
+                                               b_plus_grabar_nodo(idx,mergenode,nodo->hijos[i-leftoffset]);                                                                                                                                            
+                                               b_plus_destruir_nodo(mergenode);
+                                               b_plus_destruir_nodo(siblingnode);                                      
+                                               /* Elimino recursivamente Key de la rama apropiada segun el Merge que se hizo */
+                                               emufs_b_plus_eliminar(idx,key,nodo->hijos[i-leftoffset]);
+                                               /* 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 */
+                                                       mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-leftoffset]);
+                                                       b_plus_grabar_nodo(idx,mergenode,0);
+                                                       truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
+                                               }
+                                               /* End 3b */                                            
+                                               }
+                                       }                       
                } 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]);
@@ -611,6 +662,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
                                                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);
                                                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);
+                                               b_plus_destruir_nodo(node_y);
                                        }                                                                               
                                }
                        }
                                        }                                                                               
                                }
                        }
@@ -635,3 +687,138 @@ int b_plus_get_num_nodo(INDICE *idx)
     fclose(fp);
     return num;
 }
     fclose(fp);
     return num;
 }
+
+CLAVE emufs_b_plus_obtener_menor_clave(INDICE *idx) {
+       
+       CLAVE key;
+       NODO_B_PLUS *node;
+       int num_child = 0;
+       node = b_plus_leer_nodo(idx,0);
+       if (node == NULL) {
+               key.i_clave = -1;
+               return key;
+       }
+       
+       while (node->nivel > 0) {
+               /* Deciendo por la rama de mas hacia la izquierda */            
+               if (node->cant_claves > 0) {
+                       num_child = node->hijos[0];
+                       b_plus_destruir_nodo(node);                     
+                       node = b_plus_leer_nodo(idx,num_child);
+               }
+               else {
+                       b_plus_destruir_nodo(node);
+                       return key;             
+               }
+       }
+       
+       /* Ahora estoy en la primer hoja del arbol, devuelvo la primer clave */
+       key = node->claves[0];
+       b_plus_destruir_nodo(node);
+       
+       return key;
+}
+         
+CLAVE emufs_b_plus_obtener_mayor_clave(INDICE *idx) {
+       
+       CLAVE key;
+       NODO_B_PLUS *node;
+       B_PLUS_KEYBUCKET *bucket = NULL;
+       int num_child = 0, cant_claves = 0;
+       node = b_plus_leer_nodo(idx,0);
+       if (node == NULL) {
+               key.i_clave = -1;
+               b_plus_destruir_nodo(node);
+               return key;
+       }
+       
+       cant_claves = node->cant_claves;
+       while (node->nivel > 0) {
+               /* Deciendo por la rama de mas hacia la derecha */              
+               if (node->cant_claves > 0) {
+                       num_child = node->hijos[cant_claves];
+                       b_plus_destruir_nodo(node);                     
+                       node = b_plus_leer_nodo(idx,num_child);
+                       cant_claves = node->cant_claves;
+               }
+               else {
+                       b_plus_destruir_nodo(node);
+                       return key;             
+               }
+       }
+       
+       /* Ahora estoy en la ultima hoja del arbol, devuelvo la ultima clave */         
+       bucket = idx->padre->obtener_claves_raw(idx->padre,node->hijos[cant_claves-1]);
+       key = bucket->claves[bucket->cant_keys-1];
+       free(bucket->claves);
+       free (bucket);  
+       b_plus_destruir_nodo(node);
+       
+       return key;
+}
+
+CLAVE emufs_b_plus_obtener_sig_clave(INDICE *idx, CLAVE key) {
+               
+       INDEX_DAT query;
+       int i = 0;      
+       query.clave = key;
+       
+       /* Si aun no tengo un array, obtengo uno */
+       if (idx->keybucket == NULL) {
+               /* Busco el ancla para esta key */
+               emufs_b_plus_get_bloque(idx,&query,0);          
+               idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque);
+               /* Dejo el el iterador listo para la leer el siguiente, pues puede estar por el medio */
+               i = idx->keybucket->cant_keys - 1;
+               while (i >= 0 && emufs_indice_es_menor(idx,key,idx->keybucket->claves[i])) --i;
+               i++;
+               idx->keybucket->current_key = i;
+               /*printf ("\nLevante bloque nro: %i y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys);      
+               printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave);                                         */
+       }
+
+       /* Si me pide el siguiente de una clave que no esta en este bucket, pido un nuevo! */
+       if (idx->keybucket != NULL) {
+               i = idx->keybucket->cant_keys - 1;
+               while (i >= 0 && !emufs_indice_es_igual(idx,key,idx->keybucket->claves[i])) --i;
+               if (i < 0) {
+                       /* Debo obtener un nuevo bucket pues este debe ser de otro query viejo */
+                       free(idx->keybucket->claves);
+                       free(idx->keybucket);
+                       emufs_b_plus_get_bloque(idx,&query,0);          
+                       idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque);
+                       /* Dejo el el iterador listo para la leer el siguiente, pues puede estar por el medio */
+                       i = idx->keybucket->cant_keys - 1;
+                       while (i >= 0 && emufs_indice_es_menor(idx,key,idx->keybucket->claves[i])) --i;
+                       i++;
+                       idx->keybucket->current_key = i;                        
+                       /*printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave);*/
+               }
+       }               
+       
+       /* Veo si ya devolvi la ultima */
+       if (idx->keybucket != NULL)             
+               if (idx->keybucket->current_key == idx->keybucket->cant_keys) {                 
+                       /* Debo obtener un nuevo bucket de claves */                                    
+                       if (b_plus_buscar_prepost(idx,idx->keybucket->claves[0],0,&query,1) != -1) {                                                                                            
+                               free(idx->keybucket->claves);
+                               free(idx->keybucket);
+                               idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque);                                                           
+                               /*printf ("\nLevante bloque nro: %i y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys);      
+                               printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave);*/
+                       }
+                       else {
+                               /* No hay mas o hubo error, cortamos */
+                               key.i_clave = -1;
+                               return key;
+                       }
+               }                       
+               
+       /* Devuelvo el siguiente elemento del array solo si es mayor. Si es menor, lo skipeo */                 
+       if (idx->keybucket->current_key < idx->keybucket->cant_keys) {
+               i = idx->keybucket->current_key;
+               idx->keybucket->current_key++;          
+               return (idx->keybucket->claves[i]);
+       }
+       else return key;
+}