Borro parte redundante.

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

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index c1a8059b41c80c4e600c1f645fdd7c6a87796344..b147284a6db3f0b3d91840c2206f034bda5a1c9a 100644 (file)
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -85,8 +85,8 @@ 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;
                }
                        b_plus_destruir_nodo(nodo);                     
                        return 0;
                }


@@ -347,9 +347,8 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
        NODO_B_PLUS *child = NULL;
        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        if (nodo == NULL) return -1;
        NODO_B_PLUS *child = NULL;
        NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
        if (nodo == NULL) return -1;

-       i = nodo->cant_claves - 1;
-       
-       if (nodo->nivel == 0) {         
+       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 */                       
                while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;          
                switch (search_type) {                  
                        /* Busco predecesor en la hoja */                       


@@ -366,7 +365,18 @@ 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 (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 {                                                                                          
                                                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];


@@ -390,16 +400,6 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
                } else  {
                        /* Busco un sucesor como get bloque */                  
                        exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
                } else  {
                        /* Busco un sucesor como get bloque */                  
                        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) {
-                                       child = b_plus_leer_nodo(idx,nodo->hijos[i+2]);                                 
-                                       prepostkey->clave = child->claves[0];
-                                       prepostkey->num_bloque = child->hijos[0];
-                                       exitcode = 1;
-                               } else  exitcode = -1;
-                       }

                }               
        }
        
                }               
        }
        


@@ -486,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");


@@ -706,7 +706,10 @@ CLAVE emufs_b_plus_obtener_menor_clave(INDICE *idx) {
                        b_plus_destruir_nodo(node);                     
                        node = b_plus_leer_nodo(idx,num_child);
                }
                        b_plus_destruir_nodo(node);                     
                        node = b_plus_leer_nodo(idx,num_child);
                }

-               else break;             
+               else {
+                       b_plus_destruir_nodo(node);
+                       return key;             
+               }

        }
        
        /* Ahora estoy en la primer hoja del arbol, devuelvo la primer clave */
        }
        
        /* Ahora estoy en la primer hoja del arbol, devuelvo la primer clave */


@@ -720,10 +723,12 @@ CLAVE emufs_b_plus_obtener_mayor_clave(INDICE *idx) {
        
        CLAVE key;
        NODO_B_PLUS *node;
        
        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;
        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;
        }
        
                return key;
        }
        


@@ -736,66 +741,78 @@ CLAVE emufs_b_plus_obtener_mayor_clave(INDICE *idx) {
                        node = b_plus_leer_nodo(idx,num_child);
                        cant_claves = node->cant_claves;
                }
                        node = b_plus_leer_nodo(idx,num_child);
                        cant_claves = node->cant_claves;
                }

-               else return key;                
+               else {
+                       b_plus_destruir_nodo(node);
+                       return key;             
+               }

        }
        
        }
        

-       /* Ahora estoy en la primer hoja del arbol, devuelvo la ultima clave */
-       key = node->claves[cant_claves-1];
+       /* 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;
 }
 
        b_plus_destruir_nodo(node);
        
        return key;
 }
 

-CLAVE emufs_b_plus_obtener_sig_clave(EMUFS *emu, CLAVE key) {
-       
-       INDICE *idx = emu->indices;
+CLAVE emufs_b_plus_obtener_sig_clave(INDICE *idx, CLAVE key) {
+               

        INDEX_DAT query;
        INDEX_DAT query;

-       int i = 0;
+       int i = 0;      

        query.clave = key;
        
        /* Si aun no tengo un array, obtengo uno */
        query.clave = key;
        
        /* Si aun no tengo un array, obtengo uno */

-       if (emu->indices->keybucket == NULL) {
+       if (idx->keybucket == NULL) {

                /* Busco el ancla para esta key */
                emufs_b_plus_get_bloque(idx,&query,0);          
                /* Busco el ancla para esta key */
                emufs_b_plus_get_bloque(idx,&query,0);          

-               idx->keybucket = emufs_tipo3_obtener_claves_raw(emu,query.num_bloque);
-               printf ("\nLevante bloque nro: %li 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);                                         
+               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;
        }
 
        /* 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(emu->indices,key,idx->keybucket->claves[i])) --i;
+               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);          
                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 = emufs_tipo3_obtener_claves_raw(emu,query.num_bloque);
+                       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;                        
                        /* 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: %li 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);                                         
+                       /*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) {                 
                }
        }               
        
        /* 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) {                            
+                       /* 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);
                                free(idx->keybucket->claves);
                                free(idx->keybucket);

-                               idx->keybucket = emufs_tipo3_obtener_claves_raw(emu,query.num_bloque);
-                               printf ("\nLevante bloque nro: %li 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);                                                                                                         
+                               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 return key;
-               }
-       
+                       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) {
                
        /* Devuelvo el siguiente elemento del array solo si es mayor. Si es menor, lo skipeo */                 
        if (idx->keybucket->current_key < idx->keybucket->cant_keys) {