X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/84522123b3e93279cdb2bebd54a134dce2cacd1f..4966fd10d0744e37a60255a9e53da3ddb7399e75:/emufs/indice_bplus.c?ds=sidebyside diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c index a30058b..036d4cc 100644 --- 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,16 +22,16 @@ 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); - return nodo; + return nodo; } /** 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,22 +64,22 @@ 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) { + int i,exitcode = 0; NODO_B_PLUS *nodo; nodo = b_plus_leer_nodo(idx,num_node); if (nodo == NULL) return 1; - int i = nodo->cant_claves - 1; - int exitcode = 0; - + i = nodo->cant_claves - 1; + /* 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); - emufs_b_plus_insertar(idx,query); + /*emufs_b_plus_insertar(idx,query); */ return -1; } else { @@ -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,10 +173,10 @@ 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; + int minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1; int numbrother,j = 0; int es_interno = 1; @@ -226,32 +227,34 @@ 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] ){ - nodo->claves[i+1] = nodo->claves[i]; - nodo->hijos[i+2] = nodo->hijos[i+1]; + /* Muevo siempre el encadenamiento */ + nodo->hijos[i+2] = nodo->hijos[i+1]; + /* Ahora muevo las claves y sus punteros a bloques del dat */ + while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ){ + nodo->claves[i+1] = nodo->claves[i]; 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 +266,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 +290,307 @@ int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query) return 0; } -int b_plus_get_num_nodo(INDEX *idx) +/** Busca una clave dentro del arbol e indica si existe o no + * Posibilidades: return 1 - Encontro la clave + * return 0 - No encontro la clave + * return -1 - Hubo falla de lectura de un nodo, Abortar + */ +int b_plus_existe_clave(INDICE *idx, INDEX_DAT *query, int num_node) +{ + int i,exitcode = 0; + NODO_B_PLUS *nodo; + nodo = b_plus_leer_nodo(idx,num_node); + if (nodo == NULL) return -1; + i = nodo->cant_claves - 1; + + /* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */ + if (nodo->nivel == 0) { + /* Vemos si esta la clave */ + while ( i >= 0 && query->clave.i_clave != nodo->claves[i].i_clave ) i--; + if (i < 0) + { + b_plus_destruir_nodo(nodo); + return 0; /* No encontre la clave */ + } else { + /* Encontre la clave, guardo el nodo donde esta! */ + query->num_bloque = num_node; + b_plus_destruir_nodo(nodo); + return 1; + } + } + else { + /* Buscamos por donde descender al siguiente nivel */ + while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) i--; + i++; + num_node = nodo->hijos[i]; + b_plus_destruir_nodo(nodo); + exitcode = b_plus_existe_clave(idx,query,num_node); + return exitcode; + } +} + +int b_plus_cant_claves_nodo(INDICE *idx, int num_node) +{ + NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node); + if (nodo == NULL) return -1; + return nodo->cant_claves; +} + +/* Search_Type: 0 - Predecesor, 1 - Sucesor + Exitcode: 1 - Encontre lo buscado, 0 - No lo encontre, -1 Error */ +int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepostkey, int search_type) +{ + int i = 0, exitcode = 0; + 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) { + while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i; + switch (search_type) { + /* Busco predecesor en la hoja */ + case 0: if (i <= 0) exitcode = 0; + else { + if (nodo->claves[i].i_clave == key.i_clave) { + prepostkey->clave = nodo->claves[i-1]; + prepostkey->num_bloque = nodo->hijos[i-1]; + } else { + prepostkey->clave = nodo->claves[i]; + prepostkey->num_bloque = nodo->hijos[i]; + } + exitcode = 1; + } + break; + /* Busco sucesor en la hoja */ + 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]; + exitcode = 1; + } + break; + } + } else { + /* Veo por que rama debo seguir buscando el pre o post */ + while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i; + if (search_type == 0) { + if (i < 0) exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type); + else { + /* Busco primero por la rama derecha, sino por la izquierda */ + exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type); + if (exitcode == 0) + exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i],prepostkey,search_type); + } + /* Handleo busqueda de clave menor o igual que todas */ + if (exitcode == 0) exitcode = -1; + } else { + /* Busco un sucesor, y funciona como getbloque... */ + 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) { + prepostkey->clave = nodo->claves[i+1]; + exitcode = 1; + } else exitcode = -1; + } + } + } + + /* Libero y devuelvo exitcode */ + b_plus_destruir_nodo(nodo); + return(exitcode); +} + +int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int num_node) +{ + NODO_B_PLUS *nodo; + int i; + INDEX_DAT auxquery; + auxquery.clave = key; + + /* Comienzo buscando la clave y obteniendo el nodo en donde esta */ + if (b_plus_existe_clave(idx,&auxquery,num_node) == 1) { + + /* Levanto el nodo y busco donde esta la clave */ + /*printf("El reemplazar encontro la clave %i y en el nodo %i\n",auxquery.clave.i_clave,(int)auxquery.num_bloque);*/ + nodo = b_plus_leer_nodo(idx,auxquery.num_bloque); + if (nodo == NULL) return -1; + i = nodo->cant_claves - 1; + + /* Busco la clave y reemplazo */ + while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i; + if (i < 0) return -1; /* Error, no esta la clave */ + + /* Cheque por las dudas si es hoja o interno, aunque deberia ser hoja */ + if (nodo->nivel > 0) { + nodo->claves[i] = query.clave; + } else { + nodo->claves[i] = query.clave; + nodo->hijos[i] = query.num_bloque; + } + b_plus_grabar_nodo(idx,nodo,auxquery.num_bloque); + b_plus_destruir_nodo(nodo); + return 0; + } + else return -1; +} + +int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) +{ + INDEX_DAT prepostkey; + int i = 0,j = 0,minclaves = 0, nivel_mayor1 = 0,cant_claves_child = 0; + int cant_claves_rsibling = 0, cant_claves_lsibling = 0, es_hoja = 0; + NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node); + NODO_B_PLUS *node_y,*node_z; + if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; } + i = nodo->cant_claves - 1; + minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1; + + /* Si es hoja, borro directamente la clave. No se producira underflow + pues lo asegura la recursividad del delete */ + if (nodo->nivel == 0) { + while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i; + if (i < 0) return -1; + /* Encontre la clave en la pos i, la borro */ + for (j = i; j < nodo->cant_claves-1; ++j) { + nodo->claves[j] = nodo->claves[j+1]; + nodo->hijos[j] = nodo->hijos[j+1]; + } + nodo->hijos[j] = nodo->hijos[j+1]; + nodo->cant_claves--; + + /* Grabo el nodo actualizado en disco */ + b_plus_grabar_nodo(idx,nodo,num_node); + b_plus_destruir_nodo(nodo); + return 0; + } else { + /* Me debo fijar si esta la clave en este nodo interno, sino busco */ + while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i; + if (i < 0) { + PERR("Entre caso 3 del eliminar"); + /* No esta en este nodo interno, caso 3. Determino en que rama debe estar */ + i = nodo->cant_claves - 1; + while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i; + i++; + cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]); + if (cant_claves_child > minclaves) emufs_b_plus_eliminar(idx,key,nodo->hijos[i]); + else { + /* 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); + if (cant_claves_rsibling > minclaves) { + /* El sibling derecho me dara una key mediante rotacion. Caso 3a */ + PERR("Entre caso 3a right sibling del eliminar"); + node_y = b_plus_leer_nodo(idx,nodo->hijos[i]); + node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]); + if (node_z->nivel == 0) es_hoja = 1; + /* Le bajo la del padre a NodeY y muevo el apropiado child de NodoZ a NodoY */ + node_y->claves[cant_claves_child] = nodo->claves[i]; + node_y->hijos[cant_claves_child+1] = node_y->hijos[cant_claves_child]; + node_y->hijos[cant_claves_child+1-es_hoja] = node_z->hijos[0]; + node_y->cant_claves++; + /* Le subo al padre desde el NodoZ, teniendo en cuenta si es hoja o no */ + nodo->claves[i] = node_z->claves[es_hoja]; + /* Hago shifting en el sibling para quitar la que subio */ + for (j = 0; j < node_z->cant_claves-1; ++j) { + node_z->claves[j] = node_z->claves[j+1]; + node_z->hijos[j] = node_z->hijos[j+1]; + } + node_z->hijos[j] = node_z->hijos[j+1]; + node_z->cant_claves--; + /* Grabo los cambios y listo */ + b_plus_grabar_nodo(idx,node_z,nodo->hijos[i+1]); + 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); + /* Borro recursivamente KEY entrando por Child que ahora tiene minclaves+1 */ + emufs_b_plus_eliminar(idx,key,nodo->hijos[i]); + } + else if (cant_claves_lsibling > minclaves) { + /* el sibling izquierdo me dara una key mediante rotacion Caso 3a */ + PERR("Entre caso 3a left sibling del eliminar"); + node_z = b_plus_leer_nodo(idx,nodo->hijos[i]); + node_y = b_plus_leer_nodo(idx,nodo->hijos[i-1]); + } else { + /* Caso 3b, debo bajar una clave y unificar con sibling disponible */ + PERR("Entre caso 3b del eliminar"); + } + } + } else { + /* Esta en el nodo interno, caso 2 */ + cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]); + if (cant_claves_child > minclaves) { + PERR("Entre caso 2a del eliminar"); + /* Caso 2a, comienzo buscando la clave previa inmediata */ + b_plus_buscar_prepost(idx,key,nodo->hijos[i],&prepostkey,0); + /* La elimino recursivamente */ + emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i]); /* CHEAT */ + /* Remplazo mi clave key por la encontrada prekey */ + nodo->claves[i] = prepostkey.clave; + b_plus_grabar_nodo(idx,nodo,num_node); + /* Remplazo la otra instancia de key en una hoja seguro por prekey */ + emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]); + } else { + cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i+1]); + if (cant_claves_child > minclaves) { + PERR("Entre caso 2b del eliminar"); + /* Caso 2b, comienzo buscando la clave sucesor inmediata */ + b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],&prepostkey,1); + /* La elimino recursivamente */ + emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i+1]); /* CHEAT */ + /* Remplazo mi clave key por la encontrada postkey */ + nodo->claves[i] = prepostkey.clave; + b_plus_grabar_nodo(idx,nodo,num_node); + /* Remplazo la otra instancia de key en una hoja seguro por postkey */ + emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]); + } else { + PERR("Entre caso 2c del eliminar"); + /* Caso 2c debo hacer un merge de la clave con hijo izq y der */ + node_y = b_plus_leer_nodo(idx,nodo->hijos[i]); + node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]); + /* Bajo la clave Key a NodoY y muevo todo lo de NodoZ a NodoY */ + /* Si es nivel mayor a 1, bajo clave pues no esta en NodoZ, otherwise no bajo */ + if (nodo->nivel > 1) { + nivel_mayor1 = 1; + node_y->claves[minclaves] = key; + } + for (j = 0; j < minclaves; ++j) node_y->claves[j+minclaves+nivel_mayor1] = node_z->claves[j]; + for (j = 0; j < minclaves+1; ++j) node_y->hijos[j+minclaves+nivel_mayor1] = node_z->hijos[j]; + node_y->cant_claves = minclaves*2+nivel_mayor1; + /* Shifteo en el nodo padre NODO, para quitar la que bajo */ + for (j = i; j < nodo->cant_claves-1; ++j) { + nodo->claves[j] = nodo->claves[j+1]; + nodo->hijos[j+1] = nodo->hijos[j+2]; + } + nodo->cant_claves--; + b_plus_grabar_nodo(idx,nodo,num_node); + b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]); + b_plus_destruir_nodo(node_y); + b_plus_destruir_nodo(node_z); + /* Elimino recursivamente Key de NodeY, entrando por ese subtree */ + emufs_b_plus_eliminar(idx,key,nodo->hijos[i]); + /* Caso muy particular, si hize un merge de la unica clave de una raiz con sus hijos */ + if ((nodo->nivel == 1) && (nodo->cant_claves == 0)) { + /* Debo establecer como nueva raiz, el NodoY */ + node_y = b_plus_leer_nodo(idx,nodo->hijos[i]); + b_plus_grabar_nodo(idx,node_y,0); + truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos); + } + } + } + } + /* Termine caso 2 o 3, libero el nodo */ + b_plus_destruir_nodo(nodo); + return 0; + } + + return -1; +} + +int b_plus_get_num_nodo(INDICE *idx) { FILE *fp; int num; @@ -295,8 +598,7 @@ int b_plus_get_num_nodo(INDEX *idx) fp = fopen(idx->filename, "ab"); if (fp == NULL) return -1; - num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos); - printf("Num Nodo Nuevo: %i\n",num); + num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos); fclose(fp); return num; }