X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/65ec965b32ea1300412887755a368c2e62a16be8..6b529d1ba8dc30ef7437503567b537568391dc27:/emufs/indice_bplus.c?ds=sidebyside diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c index c693803..b147284 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); @@ -83,15 +85,15 @@ int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) { return -1; } else { - /* Encontre un bloque potencial */ - query->num_bloque = nodo->hijos[i]; + /* Encontre un bloque potencial */ + query->num_bloque = nodo->hijos[i]; b_plus_destruir_nodo(nodo); return 0; } } 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,17 @@ 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; + i = nodo->cant_claves - 1; + if (nodo->nivel == 0) { + 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 +365,20 @@ 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) { + /* Busco el primero del siguiente nodo del SQSET */ + num_node = nodo->hijos[nodo->cant_claves]; + if (num_node != -1) { + b_plus_destruir_nodo(nodo); + nodo = b_plus_leer_nodo(idx,num_node); + prepostkey->clave = nodo->claves[0]; + prepostkey->num_bloque = nodo->hijos[0]; + exitcode = 1; + } + else exitcode = -1; /* No hay mas */ + } else { - prepostkey->clave = nodo->claves[i+1]; + prepostkey->clave = nodo->claves[i+1]; prepostkey->num_bloque = nodo->hijos[i+1]; exitcode = 1; } @@ -372,7 +386,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,15 +398,8 @@ 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 (i < nodo->cant_claves-1) { - prepostkey->clave = nodo->claves[i+1]; - 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]); @@ -478,8 +486,8 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) /* 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); + /*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"); @@ -505,7 +513,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) 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]); } @@ -549,9 +557,52 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node) 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]); @@ -611,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); } } } @@ -635,3 +687,138 @@ 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 { + b_plus_destruir_nodo(node); + return key; + } + } + + /* 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; + B_PLUS_KEYBUCKET *bucket = NULL; + int num_child = 0, cant_claves = 0; + node = b_plus_leer_nodo(idx,0); + if (node == NULL) { + key.i_clave = -1; + b_plus_destruir_nodo(node); + 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 { + b_plus_destruir_nodo(node); + return key; + } + } + + /* Ahora estoy en la ultima hoja del arbol, devuelvo la ultima clave */ + bucket = idx->padre->obtener_claves_raw(idx->padre,node->hijos[cant_claves-1]); + key = bucket->claves[bucket->cant_keys-1]; + free(bucket->claves); + free (bucket); + b_plus_destruir_nodo(node); + + return key; +} + +CLAVE emufs_b_plus_obtener_sig_clave(INDICE *idx, CLAVE key) { + + INDEX_DAT query; + int i = 0; + query.clave = key; + + /* Si aun no tengo un array, obtengo uno */ + if (idx->keybucket == NULL) { + /* Busco el ancla para esta key */ + emufs_b_plus_get_bloque(idx,&query,0); + idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque); + /* Dejo el el iterador listo para la leer el siguiente, pues puede estar por el medio */ + 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; + /*printf ("\nLevante bloque nro: %i y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys); + printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave); */ + } + + /* Si me pide el siguiente de una clave que no esta en este bucket, pido un nuevo! */ + if (idx->keybucket != NULL) { + i = idx->keybucket->cant_keys - 1; + while (i >= 0 && !emufs_indice_es_igual(idx,key,idx->keybucket->claves[i])) --i; + if (i < 0) { + /* Debo obtener un nuevo bucket pues este debe ser de otro query viejo */ + free(idx->keybucket->claves); + free(idx->keybucket); + emufs_b_plus_get_bloque(idx,&query,0); + idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque); + /* Dejo el el iterador listo para la leer el siguiente, pues puede estar por el medio */ + 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; + /*printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave);*/ + } + } + + /* Veo si ya devolvi la ultima */ + if (idx->keybucket != NULL) + if (idx->keybucket->current_key == idx->keybucket->cant_keys) { + /* Debo obtener un nuevo bucket de claves */ + if (b_plus_buscar_prepost(idx,idx->keybucket->claves[0],0,&query,1) != -1) { + free(idx->keybucket->claves); + free(idx->keybucket); + idx->keybucket = idx->padre->obtener_claves_raw(idx->padre,query.num_bloque); + /*printf ("\nLevante bloque nro: %i y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys); + printf ("La primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0].i_clave);*/ + } + else { + /* No hay mas o hubo error, cortamos */ + key.i_clave = -1; + return key; + } + } + + /* Devuelvo el siguiente elemento del array solo si es mayor. Si es menor, lo skipeo */ + if (idx->keybucket->current_key < idx->keybucket->cant_keys) { + i = idx->keybucket->current_key; + idx->keybucket->current_key++; + return (idx->keybucket->claves[i]); + } + else return key; +}