en los tree view ahora se puede pasar al hermano derecho de la hoja

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

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index aafc65b807ac7f2a909fb3b93f1f20e3928bbc9b..bdbbce0272fc061aa40cb384543b593c0ee23fa0 100644 (file)
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -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"
 


@@ -363,7 +365,7 @@ 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 (emufs_indice_es_igual(idx,nodo->claves[i],key) && (i == nodo->cant_claves-1)) exitcode = 0;
+                       case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;

                                        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];


@@ -507,7 +509,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]);
                                }


@@ -681,3 +683,99 @@ 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 break;             
+       }
+       
+       /* 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;
+       int num_child = 0, cant_claves = 0;
+       node = b_plus_leer_nodo(idx,0);
+       if (node == NULL) {
+               key.i_clave = -1;
+               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 return key;                
+       }
+       
+       /* Ahora estoy en la primer hoja del arbol, devuelvo la ultima clave */
+       key = node->claves[cant_claves-1];
+       b_plus_destruir_nodo(node);
+       
+       return key;
+}
+
+CLAVE emufs_b_plus_obtener_sig_clave(EMUFS *emu, CLAVE key) {
+       
+       INDICE *idx = emu->indices;
+       INDEX_DAT query;
+       int i = 0;
+       query.clave = key;
+       
+       /* Si aun no tengo un array, obtengo uno */
+       if (emu->indices->keybucket == NULL) {
+               /* 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);                                               
+               return (idx->keybucket->claves[0]);
+       } 
+       else {
+               /* Veo si la ultima clave retornada es la ultima del array */
+               if (idx->keybucket->current_key == idx->keybucket->cant_keys-1) {                       
+                       /* Debo obtener un nuevo bucket de claves */
+                       if (b_plus_buscar_prepost(idx,key,0,&query,1) != -1) {                          
+                               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);                               
+                       }
+                       else return key;
+               }
+       }
+               
+       /* Busco la clave en el array de atras hacia adelante. */
+       if (idx->keybucket->current_key < idx->keybucket->cant_keys-1) {
+               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;                
+               return (idx->keybucket->claves[i]);
+       }
+       else return key;
+}