From 84522123b3e93279cdb2bebd54a134dce2cacd1f Mon Sep 17 00:00:00 2001 From: Alan Kennedy Date: Thu, 27 May 2004 01:49:45 +0000 Subject: [PATCH] Blah..renaming.. --- emufs/indice_b_plus.h | 34 +++++ emufs/indice_bplus.c | 302 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 336 insertions(+) create mode 100644 emufs/indice_b_plus.h create mode 100644 emufs/indice_bplus.c diff --git a/emufs/indice_b_plus.h b/emufs/indice_b_plus.h new file mode 100644 index 0000000..7e88a2c --- /dev/null +++ b/emufs/indice_b_plus.h @@ -0,0 +1,34 @@ +#ifndef _B_PLUS_H_ +#define _B_PLUS_H_ +#include +#include +#include "emufs.h" +#include + +#define SIZE_B_PLUS_HEADER (sizeof(int)*2) + +typedef struct _index_dat_ { + EMUFS_BLOCK_ID num_bloque; + CLAVE clave; +} INDEX_DAT; + +/** Estructura que define un nodo B+. Para los nodos hojas, el ultimo valor de hijo, será el nro + * de nodo con el que se encadena el actual. (Lista de nodos a nivel hoja. Sequence Set). + */ +typedef struct nodo_b_plus { + int nivel; /** Nivel del nodo */ + int cant_claves; /** Cantidad de claves en el nodo */ + int *claves; /** Claves del nodo */ + int *hijos; /** Para nodo interno, ref nodos sucesores. Nodo hoja, ref a nro bloque en .dat */ +} NODO_B_PLUS; + +/** TODO */ +int emufs_b_plus_crear(INDEX *idx); +int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node); +int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query); +int emufs_b_plus_actualizar_nodo(INDEX_DAT *dataset); +int emufs_b_plus_buscar(); +int emufs_b_plus_destuir(); +NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num); + +#endif diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c new file mode 100644 index 0000000..a30058b --- /dev/null +++ b/emufs/indice_bplus.c @@ -0,0 +1,302 @@ +/** Arbol B+ */ +#include "b_plus.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_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); +/**#*#*#*#*#**#*#*#*#*#*FIN PROTOTYPES*#*#*#*#*#**#*#*#*#*#**#*#*#*#*#*/ + +/** Crea un nuevo nodo y lo inicializa */ +NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) { + + NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS)); + if (nodo == NULL) return NULL; + nodo->nivel = 0; + nodo->cant_claves = 0; + + /* Calculamos lo que ocupan las cadenas de bytes claves + hijos */ + nodo->claves = (int*)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; +} + +/** Crea el archivo indice B+ */ +int emufs_b_plus_crear(INDEXSPECS *idx) { + + FILE *fp; + NODO_B_PLUS *raiz; + int error = 0; + + /* Creamos el archivo que contendra el indice */ + fp = fopen(idx->filename, "w"); + PERR("Creando indice con nodo raiz"); + if (fp == NULL) { + PERR("Error al crear el archivo"); + return -1; + } + fclose(fp); + + /* Creamos el nodo raiz y lo guardamos el en indice */ + 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); + + return error; +} + + +/** Busca el nro de bloque donde se debe guardar un reg con clave X. + * Posibilidades: return 0 - Encontro un bloque potencial + * 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) { + + 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; + + /* 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--; + if (i < 0) { + /* La clave es menor que todas, debo insertarla */ + b_plus_destruir_nodo(nodo); + emufs_b_plus_insertar(idx,query); + return -1; + } + else { + /* 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--; + i++; + num_node = nodo->hijos[i]; + b_plus_destruir_nodo(nodo); + exitcode = emufs_b_plus_get_bloque(idx,query,num_node); + return exitcode; + } +} + +NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) { + + /*int i = 0;*/ + FILE *fp; + NODO_B_PLUS *memnode = b_plus_crearnodo(idx); + char *disknode = (char*)malloc(idx->tam_bloque); + + if (num_node < 0) { + PERR("Se intento leer nodo negativo!!\n"); + exit(1); + } + if (disknode == NULL) return NULL; + if (memnode == NULL) return NULL; + + /* Open up file */ + fp = fopen(idx->filename, "r+"); + if (fp == NULL) { + free(disknode); + b_plus_destruir_nodo(memnode); + return NULL; + } + + /* Intentamos leer un nodo, sino podemos error! */ + fseek(fp, num_node*idx->tam_bloque, SEEK_SET); + if (fread(disknode, idx->tam_bloque, 1, fp) != 1) { + free(disknode); + fclose(fp); + return NULL; + } + fclose(fp); + + /* 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_claves,idx->size_hijos); + free(disknode); + + /*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:"); + for (i = 0; i < idx->size_hijos/sizeof(int); ++i) printf(" %i",memnode->hijos[i]); + printf("\nEnd Dump\n"); */ + + return memnode; + +} + +int b_plus_grabar_nodo(INDEX *idx, NODO_B_PLUS *nodo, int num_node) +{ + FILE *fp; + + fp = fopen(idx->filename, "r+"); + if (fp == NULL) return -1; + + fseek(fp,num_node*(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos),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 b_plus_destruir_nodo(NODO_B_PLUS *nodo) +{ + free(nodo->claves); + free(nodo->hijos); + free(nodo); + return 0; +} + +int b_plus_split_child(INDEX *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 numbrother,j = 0; + int es_interno = 1; + + NODO_B_PLUS *brother = b_plus_crearnodo(idx); + brother->nivel = fullnode->nivel; /* Idem nivel que el que se parte */ + + /* Si estoy en una hoja, la parte derecha del partido tendra minclaves+1 */ + /* pues el ancla se debe repetir ademas de subir */ + if (brother->nivel == 0) { + brother->cant_claves = minclaves+1; + es_interno = 0; + } + else brother->cant_claves = minclaves; + + /* Copio las claves al brother derecho */ + for (j = 0; j < brother->cant_claves; ++j) + brother->claves[j] = fullnode->claves[j+minclaves+es_interno]; + + /* Copio los hijos ya sea para hoja o no hoja. */ + for (j = 0; j < brother->cant_claves+1; ++j) + brother->hijos[j] = fullnode->hijos[j+minclaves+es_interno]; + + /* Ahora me ocupo del nodo que se partio */ + fullnode->cant_claves = minclaves; + /* Obtengo numero de nodo para brother y encadeno si es hoja */ + numbrother = b_plus_get_num_nodo(idx); + if (fullnode->nivel == 0) fullnode->hijos[minclaves] = numbrother; + + /* Ahora fixeamos el padre, apuntando al nuevo hijo */ + for (j = parent->cant_claves; j > ithchild; --j) + parent->hijos[j+1] = parent->hijos[j]; + parent->hijos[ithchild+1] = numbrother; + + /* Idem pero subo la median key */ + for (j = parent->cant_claves-1; j >= ithchild; --j) + parent->claves[j+1] = parent->claves[j]; + parent->claves[ithchild] = fullnode->claves[minclaves]; + parent->cant_claves++; + + /* Grabo los nodos en disco */ + b_plus_grabar_nodo(idx,fullnode,parent->hijos[ithchild]); + b_plus_grabar_nodo(idx,brother,numbrother); + b_plus_grabar_nodo(idx,parent,numparent); + + b_plus_destruir_nodo(brother); + + return 0; +} + + +int b_plus_insert_nonfull(INDEX *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]; + nodo->hijos[i+1] = nodo->hijos[i]; + i--; + } + nodo->claves[i+1] = query->clave.i_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] ) + 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) ) { + b_plus_split_child(idx, num_nodo, nodo, i, hijo); + if ( query->clave.i_clave > nodo->claves[i] ) + i++; + } + if (hijo) b_plus_destruir_nodo(hijo); + hijo = b_plus_leer_nodo(idx, nodo->hijos[i]); + b_plus_insert_nonfull(idx, hijo, nodo->hijos[i], query); + if (hijo) b_plus_destruir_nodo(hijo); + } + + return 0; +} + +int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query) +{ + NODO_B_PLUS *raiz; + + raiz = b_plus_leer_nodo(idx, 0); + if ( raiz->cant_claves == idx->size_claves/sizeof(int) ) { + 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); + b_plus_grabar_nodo(idx, raiz, new_root->hijos[0]); + b_plus_grabar_nodo(idx, new_root, 0); + b_plus_split_child(idx, 0, new_root, 0, raiz); + b_plus_insert_nonfull(idx, new_root, 0, query); + b_plus_destruir_nodo(new_root); + } else + { + b_plus_insert_nonfull(idx, raiz, 0, query); + } + + b_plus_destruir_nodo(raiz); + + return 0; +} + +int b_plus_get_num_nodo(INDEX *idx) +{ + FILE *fp; + int num; + + 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); + fclose(fp); + return num; +} -- 2.43.0