* Mas de claves duplicadas. En teoria "esta completa", hay que ver si con el

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

diff --git a/emufs/b_plus.c b/emufs/b_plus.c
index 0e84bcd6df9a618c027bc8057ab2ddac68762192..1aa1664630016af6c644b08c9ea5f07fa40cd4c8 100644 (file)
--- a/emufs/b_plus.c
+++ b/emufs/b_plus.c
@@ -2,15 +2,25 @@
 #include "b_plus.h"
 
 /* Private prototypes */
 #include "b_plus.h"
 
 /* Private prototypes */

+/* numerando los bloques */
+static int nuevo_bloque = -1;
+int get_new_block_number();

 int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node);
 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node);
 NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx);
 
 int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node);
 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node);
 NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx);
 

+/** Me devuelve un numero de bloque nuevo */
+int get_new_block_number()
+{
+       nuevo_bloque++;
+       return nuevo_bloque;
+}

 
 /** Crea un nuevo nodo y lo inicializa */
 NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx) {
        
        NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
 
 /** Crea un nuevo nodo y lo inicializa */
 NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx) {
        
        NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));

+       if (nodo == NULL) return NULL;

        nodo->nivel = 0;
        nodo->cant_claves = 0;
 
        nodo->nivel = 0;
        nodo->cant_claves = 0;
 


@@ -51,24 +61,107 @@ int emufs_b_plus_crear(INDEXSPECS *idx) {
        return error;
 }
 
        return error;
 }
 

+/* Inserta un nuevo nodo y reestructura el arbol para que quede como debe */
+int b_plus_actualizar(NODO_B_PLUS *padre, NODO_B_PLUS *new_nodo)
+{
+       return 0;
+}
+

 /** Busca el nro de bloque donde se debe guardar un reg con clave X */
 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query) {
 
     NODO_B_PLUS *curnode;
 /** Busca el nro de bloque donde se debe guardar un reg con clave X */
 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query) {
 
     NODO_B_PLUS *curnode;

-       
+       int i, prox_nodo;

        /* Comienzo leyendo la raiz, entry point de toda funcion */
        printf ("Buscando donde insertar clave: %i\n\n",query->clave.i_clave);
        curnode = b_plus_leer_nodo(idx,0);      
        if (curnode == NULL) return -1;
        /* Comienzo leyendo la raiz, entry point de toda funcion */
        printf ("Buscando donde insertar clave: %i\n\n",query->clave.i_clave);
        curnode = b_plus_leer_nodo(idx,0);      
        if (curnode == NULL) return -1;

+       /* Me fijo si la raiz esta vacia */
+       if ( curnode->cant_claves == 0 ){ /* entra la clave en la raiz */ 
+               /* ojo que este es un caso muy particular */
+               /* aumento la cant de claves*/
+               curnode->cant_claves++;
+               /* inserto la clave en el nodo, como es la primera no hace falta ordenar nada*/
+               *(curnode->claves) = query->clave.i_clave;
+               /* Debo obtener un numero de bloque para devolverle al query!!! */
+               /* por ahora el nuevo bloque se va incrementando, sin recuperacion de vacios FIX*/
+               query->num_bloque = get_new_block_number();
+               /* Le asigno al nodo del arbol el mismo numero que devolvi */
+               *(curnode->hijos) = query->num_bloque;
+               /* Cargado el query salgo de la func, luego habra que actualizar el .dat 
+                  y luego volver a grabar el nodo en el arbol*/                
+               /*grabo el nodo en el archivo*/
+               b_plus_grabar_nodo(idx, curnode, 0);
+               /* librero el nodo */
+               free(curnode);
+               return 0;
+       } 

        
        /* Mientras no encontre la hoja con la clave, busco.. */
        
        /* Mientras no encontre la hoja con la clave, busco.. */

-       while ((curnode->nivel > 0) && curnode)
-       {
-               
+       /* RECORDAR QUE LAS CLAVES DEBEN ESTAR ORDENADAS PARA QUE ESTO FUNCIONE !! */ 
+       while (curnode->nivel > 0 && curnode)
+       {       /*recorro las claves hasta encontrar la primera mayor a la que quiero insertar*/
+               for(i=0; i<curnode->cant_claves; i++){ 
+                       /* me fijo que si es mayor */
+                       if ( (query->clave.i_clave > curnode->claves[i])) {
+                               if ( curnode->cant_claves != i ) /* si no es la ultima clave del nodo */
+                                       continue; /*paso a la siguiente*/
+                               else {  /* si era la ultima, la clave deberia ir ahi */
+                                       /*cargo el proximo nodo*/
+                                       prox_nodo = curnode->hijos[i+1];
+                                       break; /*salgo del for*/
+                               }
+                       } else {  /*si no es mayor o igual es menor*/
+                               prox_nodo = curnode->hijos[i];
+                               break;
+                       }
+               }
+               free(curnode);
+               curnode = b_plus_leer_nodo(idx, prox_nodo);
+       } 
+       
+       /*cuando salgo de aca deberia tener cargado en curnode el nodo hoja que busque*/
+       for (i=0; i<curnode->cant_claves-1; i++){
+               if ( query->clave.i_clave >= curnode->claves[i] ){
+                       if ( curnode->cant_claves != i ) /* si no es la ultima clave */
+                               continue;
+                       else {   /* si era la ultima */
+                               /* cargo en query el numero del bloque donde deberia ir la nueva clave */
+                               query->num_bloque = curnode->hijos[i];
+                               free(curnode);
+                               return 0;
+                       }
+               } else {  /* si no era mayor, era menor */
+                       /* guardo el bloque anterior porque me pase.. */
+                       if ( i == 0 ){ 
+                               /*CREAR UN NODO NUEVO PARA METER UNA CLAVE MENOR A TODAS */
+                               /* EL NUEVO NODO VA A SER UNA HOJA */
+                               NODO_B_PLUS *new_nodo = b_plus_crearnodo(idx);
+                               if (new_nodo == NULL){
+                                       PERR("NO SE PUDO CREAR EL NUEVO NODO");
+                                       return -1;
+                               }
+                               /* aumento la cantidad de claves */
+                               new_nodo->cant_claves++;
+                               /* inserto la clave en el nuevo nodo (es la primera)*/
+                               new_nodo->claves[0] = query->clave.i_clave;
+                               /* inserto la referencia al nuevo bloque, con un n */
+                               new_nodo->hijos[0] = query->num_nuevo_bloque;
+                               /* no le cambio el nivel porque es hoja ( por default == 0)*/
+                               /* Aca viene la papota.. hay que hacer una funcion que meta un nodo 
+                                * en el arbol y lo reestructure correctamente.
+                                * Ademas hay que grabar el registro en el .dat*/
+                               b_plus_actualizar(curnode, new_nodo);  /* le mando el padre.. seguro que lo voy a necesitar */
+                               return 0;
+                       } else {
+                               query->num_bloque = curnode->hijos[i-1];
+                               free(curnode);
+                               return 0;
+                       }
+               }

        }
        }

-       
-       free(curnode);
-       
+
+       if (curnode) free(curnode);

        return 0;
 }
 
        return 0;
 }
 


@@ -132,3 +225,8 @@ int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node)
        
        return 0;
 }
        
        return 0;
 }

+
+int emufs_b_plus_insertar_clave(INDEX_DAT *dataset)
+{
+       return 0;
+}