X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/4966fd10d0744e37a60255a9e53da3ddb7399e75..a65b9b7ad55913630bdf1806887a6df84bb802b6:/emufs/indice_bplus.c diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c index 036d4cc..7d2891c 100644 --- a/emufs/indice_bplus.c +++ b/emufs/indice_bplus.c @@ -1,4 +1,6 @@ /** Arbol B+ */ +#include "tipo1.h" +#include "tipo3.h" #include "indices.h" #include "indice_bplus.h" @@ -75,7 +77,7 @@ int emufs_b_plus_get_bloque(INDICE *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_clave ) i--; + while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--; if (i < 0) { /* La clave es menor que todas, debo insertarla */ b_plus_destruir_nodo(nodo); @@ -91,7 +93,7 @@ int emufs_b_plus_get_bloque(INDICE *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_clave ) i--; + while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--; i++; num_node = nodo->hijos[i]; b_plus_destruir_nodo(nodo); @@ -237,7 +239,7 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA /* 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 ){ + while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])){ nodo->claves[i+1] = nodo->claves[i]; nodo->hijos[i+1] = nodo->hijos[i]; i--; @@ -247,14 +249,15 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA nodo->cant_claves++; b_plus_grabar_nodo(idx, nodo, num_nodo); } else { - while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) + while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) 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(CLAVE) ) { b_plus_split_child(idx, num_nodo, nodo, i, hijo); - if ( query->clave.i_clave > nodo->claves[i].i_clave ) + /* OjO Utilizo el menor pero con el proposito de clave > nodo->clave) */ + if (emufs_indice_es_menor(idx,nodo->claves[i],query->clave)) i++; } if (hijo) b_plus_destruir_nodo(hijo); @@ -306,7 +309,7 @@ int b_plus_existe_clave(INDICE *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 si esta la clave */ - while ( i >= 0 && query->clave.i_clave != nodo->claves[i].i_clave ) i--; + while ( i >= 0 && !emufs_indice_es_igual(idx,query->clave,nodo->claves[i])) i--; if (i < 0) { b_plus_destruir_nodo(nodo); @@ -320,7 +323,7 @@ int b_plus_existe_clave(INDICE *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_clave ) i--; + while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--; i++; num_node = nodo->hijos[i]; b_plus_destruir_nodo(nodo); @@ -341,17 +344,18 @@ int b_plus_cant_claves_nodo(INDICE *idx, int num_node) 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); + NODO_B_PLUS *child = NULL; + 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; + while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --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) { + if (emufs_indice_es_igual(idx,nodo->claves[i],key)) { prepostkey->clave = nodo->claves[i-1]; prepostkey->num_bloque = nodo->hijos[i-1]; } else { @@ -362,9 +366,9 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo } break; /* Busco sucesor en la hoja */ - case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0; + case 1: if (i == nodo->cant_claves-1) exitcode = 0; else { - prepostkey->clave = nodo->claves[i+1]; + prepostkey->clave = nodo->claves[i+1]; prepostkey->num_bloque = nodo->hijos[i+1]; exitcode = 1; } @@ -372,7 +376,7 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo } } else { /* Veo por que rama debo seguir buscando el pre o post */ - while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i; + while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i; if (search_type == 0) { if (i < 0) exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type); else { @@ -384,12 +388,15 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo /* Handleo busqueda de clave menor o igual que todas */ if (exitcode == 0) exitcode = -1; } else { - /* Busco un sucesor, y funciona como getbloque... */ + /* Busco un sucesor como get bloque */ 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 (exitcode == 0) + { if (i < nodo->cant_claves-1) { - prepostkey->clave = nodo->claves[i+1]; + child = b_plus_leer_nodo(idx,nodo->hijos[i+2]); + prepostkey->clave = child->claves[0]; + prepostkey->num_bloque = child->hijos[0]; exitcode = 1; } else exitcode = -1; } @@ -418,7 +425,7 @@ int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int n i = nodo->cant_claves - 1; /* Busco la clave y reemplazo */ - while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i; + while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i; if (i < 0) return -1; /* Error, no esta la clave */ /* Cheque por las dudas si es hoja o interno, aunque deberia ser hoja */ @@ -440,8 +447,9 @@ 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; + int leftoffset = 0; NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node); - NODO_B_PLUS *node_y,*node_z; + NODO_B_PLUS *node_y,*node_z,*mergenode,*siblingnode; if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; } i = nodo->cant_claves - 1; minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1; @@ -449,7 +457,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) /* 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; + while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i; if (i < 0) return -1; /* Encontre la clave en la pos i, la borro */ for (j = i; j < nodo->cant_claves-1; ++j) { @@ -465,12 +473,12 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) 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; + while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --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; + while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --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]); @@ -500,12 +508,12 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) } node_z->hijos[j] = node_z->hijos[j+1]; node_z->cant_claves--; - /* Grabo los cambios y listo */ + /* Grabo los cambios */ 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); + 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]); } @@ -513,12 +521,88 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) /* 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]); + node_y = b_plus_leer_nodo(idx,nodo->hijos[i-1]); + if (node_z->nivel == 0) es_hoja = 1; + /* Hago lugar en NodoZ para la clave que bajara desde el padre */ + /* Muevo el ultimo y restantes claves/punteros */ + j = node_z->cant_claves - 1; + node_z->hijos[j+2] = node_z->hijos[j+1]; + while (j >= 0){ + node_z->claves[j+1] = node_z->claves[j]; + node_z->hijos[j+1] = node_z->hijos[j]; + j--; + } + /* Hago la rotacion final segun sea hoja o no */ + if (es_hoja) { + nodo->claves[i-1] = node_y->claves[cant_claves_lsibling-1]; + node_z->claves[0] = node_y->claves[cant_claves_lsibling-1]; + node_z->hijos[0] = node_y->hijos[cant_claves_lsibling-1]; + node_y->hijos[cant_claves_lsibling-1] = node_y->hijos[cant_claves_lsibling]; /* cadena */ + node_y->cant_claves--; + node_z->cant_claves++; + } else { + node_z->claves[0] = nodo->claves[i-1]; + node_z->hijos[0] = node_y->hijos[cant_claves_lsibling]; + nodo->claves[i-1] = node_y->claves[cant_claves_lsibling-1]; + node_y->cant_claves--; + node_z->cant_claves++; + } + /* Grabo los cambios */ + b_plus_grabar_nodo(idx,node_y,nodo->hijos[i-1]); + b_plus_grabar_nodo(idx,node_z,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 { /* Caso 3b, debo bajar una clave y unificar con sibling disponible */ - PERR("Entre caso 3b del eliminar"); - } - } + PERR("Entre caso 3b del eliminar"); + if (cant_claves_lsibling == minclaves) { + PERR("Hago merge con sibling izquierdo"); + leftoffset = 1; + siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i]); /* Este es el root de la rama! */ + mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-1]); /* Aca va todo */ + } else { + PERR("Hago merge con sibling derecho"); + leftoffset = 0; + mergenode = b_plus_leer_nodo(idx,nodo->hijos[i]); + siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i+1]); + } + + /* Bajo una clave del Padre Nodo a MergeNode y muevo todo lo SiblingNode a MergeNode */ + /* Si es nivel mayor a 1, bajo clave, otherwise no bajo pues se repetiria */ + nivel_mayor1 = 0; + if (nodo->nivel > 1) { + nivel_mayor1 = 1; + mergenode->claves[minclaves] = nodo->claves[i-leftoffset]; + } + for (j = 0; j < minclaves; ++j) mergenode->claves[j+minclaves+nivel_mayor1] = siblingnode->claves[j]; + for (j = 0; j < minclaves+1; ++j) mergenode->hijos[j+minclaves+nivel_mayor1] = siblingnode->hijos[j]; + mergenode->cant_claves = minclaves*2+nivel_mayor1; + + /* Shifteo en el nodo padre NODO, para quitar la que bajo */ + for (j = i-leftoffset; 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,mergenode,nodo->hijos[i-leftoffset]); + b_plus_destruir_nodo(mergenode); + b_plus_destruir_nodo(siblingnode); + /* Elimino recursivamente Key de la rama apropiada segun el Merge que se hizo */ + emufs_b_plus_eliminar(idx,key,nodo->hijos[i-leftoffset]); + /* 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 */ + mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-leftoffset]); + b_plus_grabar_nodo(idx,mergenode,0); + truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos); + } + /* End 3b */ + } + } } else { /* Esta en el nodo interno, caso 2 */ cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]); @@ -578,6 +662,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) 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); + b_plus_destruir_nodo(node_y); } } } @@ -602,3 +687,100 @@ int b_plus_get_num_nodo(INDICE *idx) 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,idx->keybucket->claves[0],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); + printf ("\nLa primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0]); + } + 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; +}