* 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 92ab3850a52f24c075153b3344815bc7fb1ce56e..1aa1664630016af6c644b08c9ea5f07fa40cd4c8 100644 (file)
--- a/emufs/b_plus.c
+++ b/emufs/b_plus.c
@@ -2,13 +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_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 */
 
 /** Crea un nuevo nodo y lo inicializa */

-NODO_B_PLUS *emufs_b_plus_crearnodo(INDEXSPECS *idx, int es_hoja) {
+NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx) {

        
        NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
        
        NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));

-       nodo->es_hoja = es_hoja;
+       if (nodo == NULL) return NULL;

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


@@ -26,28 +38,32 @@ int emufs_b_plus_crear(INDEXSPECS *idx) {
        
        FILE *fp;
        NODO_B_PLUS *raiz;
        
        FILE *fp;
        NODO_B_PLUS *raiz;

+       int error = 0;

                
        /* Creamos el archivo que contendra el indice */
        fp = fopen(idx->filename, "w");
                
        /* Creamos el archivo que contendra el indice */
        fp = fopen(idx->filename, "w");

-       PERR("Creando indice");
-       fprintf(stderr, "Archivo = (%s)\n", idx->filename);
+       PERR("Creando indice con nodo raiz");

        if (fp == NULL) {
                PERR("Error al crear el archivo");
                return -1;
        }
        if (fp == NULL) {
                PERR("Error al crear el archivo");
                return -1;
        }

+       fclose(fp);

        
        /* Creamos el nodo raiz y lo guardamos el en indice */
        
        /* Creamos el nodo raiz y lo guardamos el en indice */

-       raiz = emufs_b_plus_crearnodo(idx,1);
-       fwrite(raiz,SIZE_B_PLUS_HEADER,1,fp);
-       fwrite(raiz->claves,idx->size_claves,1,fp);
-       fwrite(raiz->hijos,idx->size_hijos,1,fp);
-       fclose(fp);
+       raiz = b_plus_crearnodo(idx);
+       error = b_plus_grabar_nodo(idx,raiz,0);

        
        /* Liberamos areas de memoria reservadas */
        free(raiz->claves);
        free(raiz->hijos);
        free(raiz);
        
        
        /* Liberamos areas de memoria reservadas */
        free(raiz->claves);
        free(raiz->hijos);
        free(raiz);
        

+       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;
 }
 
        return 0;
 }
 


@@ -55,18 +71,97 @@ int emufs_b_plus_crear(INDEXSPECS *idx) {
 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query) {
 
     NODO_B_PLUS *curnode;
 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 */
        /* Comienzo leyendo la raiz, entry point de toda funcion */

-       printf ("Buscando donde insertar clave: %i\n",query->clave.i_clave);
+       printf ("Buscando donde insertar clave: %i\n\n",query->clave.i_clave);

        curnode = b_plus_leer_nodo(idx,0);      
        if (curnode == NULL) return -1;
        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->es_hoja == 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;
+                       }
+               }
+       }
+
+       if (curnode) free(curnode);

        return 0;
 }
 
        return 0;
 }
 


@@ -74,14 +169,14 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node) {
 
        int i = 0;
        FILE *fp;
 
        int i = 0;
        FILE *fp;

-       NODO_B_PLUS *memnode = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
-       char *disknode = (char*)malloc(sizeof(idx->tam_bloque));
+       NODO_B_PLUS *memnode = b_plus_crearnodo(idx);   
+       char *disknode = (char*)malloc(idx->tam_bloque);

        
        if (disknode == NULL) return NULL;
        if (memnode == NULL) return NULL;
        
     /* Open up file */
        
        if (disknode == NULL) return NULL;
        if (memnode == NULL) return NULL;
        
     /* Open up file */

-       fp = fopen(idx->filename, "r");
+       fp = fopen(idx->filename, "r+");

        if (fp == NULL) {
                free(disknode);
                free(memnode);
        if (fp == NULL) {
                free(disknode);
                free(memnode);


@@ -100,11 +195,11 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node) {
        /* Pudimos leer un nodo de disco, ahora lo transformamos a nodo mem */
        memcpy(memnode,disknode,SIZE_B_PLUS_HEADER);
        memcpy(memnode->claves,disknode+SIZE_B_PLUS_HEADER,idx->size_claves);
        /* Pudimos leer un nodo de disco, ahora lo transformamos a nodo mem */
        memcpy(memnode,disknode,SIZE_B_PLUS_HEADER);
        memcpy(memnode->claves,disknode+SIZE_B_PLUS_HEADER,idx->size_claves);

-       memcpy(memnode->hijos,disknode+SIZE_B_PLUS_HEADER,idx->size_hijos);
+       memcpy(memnode->hijos,disknode+SIZE_B_PLUS_HEADER+idx->size_claves,idx->size_hijos);

        free(disknode);
        
        free(disknode);
        

-       printf("Dumping nodo leido...\n");
-       printf("Nivel: %i  Cant Claves: %i  Es Hoja: %i\n",memnode->nivel,memnode->cant_claves,memnode->es_hoja);
+       printf("Dumping Node_%i\n",num_node);
+       printf("Nivel: %i  Cant Claves: %i\n",memnode->nivel,memnode->cant_claves);

        printf("Claves:");
        for (i = 0; i < idx->size_claves/sizeof(int); ++i) printf(" %i",memnode->claves[i]);
        printf("\nHijos:");
        printf("Claves:");
        for (i = 0; i < idx->size_claves/sizeof(int); ++i) printf(" %i",memnode->claves[i]);
        printf("\nHijos:");


@@ -114,3 +209,24 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node) {
        return memnode;
        
 }
        return memnode;
        
 }

+
+int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node)
+{
+       FILE *fp;
+       
+       fp = fopen(idx->filename, "r+");
+       if (fp == NULL) return -1;
+               
+       fseek(fp,num_node*sizeof(NODO_B_PLUS),SEEK_SET);        
+       fwrite(nodo,SIZE_B_PLUS_HEADER,1,fp);
+       fwrite(nodo->claves,idx->size_claves,1,fp);
+       fwrite(nodo->hijos,idx->size_hijos,1,fp);
+       fclose(fp);
+       
+       return 0;
+}
+
+int emufs_b_plus_insertar_clave(INDEX_DAT *dataset)
+{
+       return 0;
+}