si esto llega a andar me como una cebolla cruda

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

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index a30058bd9f9a4f1575a4d5876fe6687638809e51..10c7330089fef8d2ea7128e877428a6691ce3c52 100644 (file)
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -1,19 +1,20 @@
 /** Arbol B+ */
-#include "b_plus.h"
+#include "indices.h"
+#include "indice_bplus.h"
 
 /**#*#*#*#*#**#*#*#*#*#* Private prototypes*#*#*#*#*#**#*#*#*#*#**#*#*#*/
-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(INDICE *idx, NODO_B_PLUS *nodo, int num_node);
+NODO_B_PLUS *b_plus_leer_nodo(INDICE *idx, int num_node);
+NODO_B_PLUS *b_plus_crearnodo(INDICE *idx);
 int b_plus_destruir_nodo(NODO_B_PLUS *nodo);
-int b_plus_split_child(INDEXSPECS *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode);
-int b_plus_insert_nonfull(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query);
-int b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query);
-int b_plus_get_num_nodo(INDEXSPECS *idx);
+int b_plus_split_child(INDICE *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode);
+int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query);
+int b_plus_insertar(INDICE *idx, INDEX_DAT *query);
+int b_plus_get_num_nodo(INDICE *idx);
 /**#*#*#*#*#**#*#*#*#*#*FIN PROTOTYPES*#*#*#*#*#**#*#*#*#*#**#*#*#*#*#*/
 
 /** Crea un nuevo nodo y lo inicializa */
-NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) {
+NODO_B_PLUS *b_plus_crearnodo(INDICE *idx) {
        
        NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
        if (nodo == NULL) return NULL;
@@ -21,7 +22,7 @@ NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) {
        nodo->cant_claves = 0;
 
     /* Calculamos lo que ocupan las cadenas de bytes claves + hijos */
-       nodo->claves = (int*)malloc(idx->size_claves);
+       nodo->claves = (CLAVE*)malloc(idx->size_claves);
        nodo->hijos = (int*)malloc(idx->size_hijos);
        memset(nodo->claves,-1,idx->size_claves);
        memset(nodo->hijos,-1,idx->size_hijos);
@@ -30,7 +31,7 @@ NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) {
 }
 
 /** Crea el archivo indice B+ */
-int emufs_b_plus_crear(INDEXSPECS *idx) {
+int emufs_b_plus_crear(INDICE *idx) {
        
        FILE *fp;
        NODO_B_PLUS *raiz;
@@ -63,7 +64,7 @@ int emufs_b_plus_crear(INDEXSPECS *idx) {
  *                 return -1 - No hay clave, inserto clave de nuevo bloques
  *                 return 1 - Hubo falla de lectura de un nodo, Abortar
  */
-int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
+int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
 
        NODO_B_PLUS *nodo;
        nodo = b_plus_leer_nodo(idx,num_node);
@@ -74,7 +75,7 @@ int emufs_b_plus_get_bloque(INDEX *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 */
-               while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) i--;
+               while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--;
                if (i < 0) {
                        /* La clave es menor que todas, debo insertarla */
                        b_plus_destruir_nodo(nodo);                     
@@ -90,7 +91,7 @@ int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
        }
        else {
                /* Buscamos por donde descender al siguiente nivel */
-               while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) i--;
+               while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--;
         i++;
         num_node = nodo->hijos[i];
                b_plus_destruir_nodo(nodo);
@@ -99,7 +100,7 @@ int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
        }
 }
 
-NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
+NODO_B_PLUS *b_plus_leer_nodo(INDICE *idx, int num_node) {
 
        /*int i = 0;*/
        FILE *fp;
@@ -139,7 +140,7 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
        /*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]);
+       for (i = 0; i < idx->size_claves/sizeof(CLAVE); ++i) printf(" %i",memnode->claves[i].i_clave);
        printf("\nHijos:");
        for (i = 0; i < idx->size_hijos/sizeof(int); ++i) printf(" %i",memnode->hijos[i]);
        printf("\nEnd Dump\n"); */
@@ -148,7 +149,7 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
        
 }
 
-int b_plus_grabar_nodo(INDEX *idx, NODO_B_PLUS *nodo, int num_node)
+int b_plus_grabar_nodo(INDICE *idx, NODO_B_PLUS *nodo, int num_node)
 {
        FILE *fp;
        
@@ -172,7 +173,7 @@ int b_plus_destruir_nodo(NODO_B_PLUS *nodo)
        return 0;
 }
 
-int b_plus_split_child(INDEX *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode)
+int b_plus_split_child(INDICE *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode)
 {
        /* locals */
        int minclaves = ceil(idx->size_hijos/sizeof(int)/2)-1;
@@ -226,32 +227,32 @@ int b_plus_split_child(INDEX *idx, int numparent, NODO_B_PLUS *parent, int ithch
 }
 
 
-int b_plus_insert_nonfull(INDEX *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query)
+int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query)
 {
     int i, num_nodo_hijo;
     NODO_B_PLUS *hijo;
     
     i = nodo->cant_claves-1; 
     if ( nodo->nivel == 0 ){
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ){
+        while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ){
             nodo->claves[i+1] = nodo->claves[i];
                        nodo->hijos[i+2] = nodo->hijos[i+1];
                        nodo->hijos[i+1] = nodo->hijos[i];
             i--;
         }
-        nodo->claves[i+1] = query->clave.i_clave;
+        nodo->claves[i+1] = query->clave;
                nodo->hijos[i+1] = query->num_bloque;
         nodo->cant_claves++;
         b_plus_grabar_nodo(idx, nodo, num_nodo);
     } else { 
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) 
+        while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) 
             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(int) ) {
+        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] )
+            if ( query->clave.i_clave > nodo->claves[i].i_clave )
                 i++;
         }
                if (hijo) b_plus_destruir_nodo(hijo);
@@ -263,12 +264,12 @@ int b_plus_insert_nonfull(INDEX *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT
        return 0;
 }    
 
-int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query)
+int emufs_b_plus_insertar(INDICE *idx, INDEX_DAT *query)
 {
     NODO_B_PLUS *raiz;
     
     raiz = b_plus_leer_nodo(idx, 0);
-    if ( raiz->cant_claves == idx->size_claves/sizeof(int) ) {
+    if ( raiz->cant_claves == idx->size_claves/sizeof(CLAVE) ) {
         NODO_B_PLUS *new_root = b_plus_crearnodo(idx);
         new_root->nivel = raiz->nivel + 1;
         new_root->hijos[0] = b_plus_get_num_nodo(idx);
@@ -287,7 +288,7 @@ int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query)
     return 0;
 }
 
-int b_plus_get_num_nodo(INDEX *idx)
+int b_plus_get_num_nodo(INDICE *idx)
 {
        FILE *fp;
        int num;