memset(nodo->claves,-1,idx->size_claves);
memset(nodo->hijos,-1,idx->size_hijos);
- return nodo;
+ return nodo;
}
/** Crea el archivo indice B+ */
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 {
/* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
if (nodo->nivel == 0) {
- /* Vemos en que bloque deberia ir */
+ /* Vemos si esta la clave */
while ( i >= 0 && query->clave.i_clave != nodo->claves[i].i_clave ) i--;
- b_plus_destruir_nodo(nodo);
- if (i < 0) return 0; /* No encontre la clave */
- else return 1; /* Encontre la clave */
+ 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 */
/* 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, CLAVE *prepostkey, int search_type)
+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) {
- printf ("Entre en hoja nro %i\n",num_node);
+ if (nodo->nivel == 0) {
while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i;
- switch (search_type) {
-
+ 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 = nodo->claves[i-1];
- else *prepostkey = nodo->claves[i];
+ 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;
-
+ 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 = nodo->claves[i+1];
+ else {
+ prepostkey->clave = nodo->claves[i+1];
+ prepostkey->num_bloque = nodo->hijos[i+i];
exitcode = 1;
}
break;
/* Handleo busqueda de clave menor o igual que todas */
if (exitcode == 0) exitcode = -1;
} else {
- /* Busco un sucesor, y funciona como getbloque... */
- printf("Voy a buscar en hijo nro: %i\n",nodo->hijos[i+1]);
+ /* 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 (exitcode == 0) {
if (i < nodo->cant_claves-1) {
- *prepostkey = nodo->claves[i+1];
+ prepostkey->clave = nodo->claves[i+1];
exitcode = 1;
} else exitcode = -1;
+ }
}
}
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)
{
- int i = 0,j = 0,minclaves = 0, cant_claves_child = 0;
- NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
- if (nodo == NULL) return -1;
+ INDEX_DAT prepostkey;
+ int i = 0,j = 0,minclaves = 0, nivel_mayor1 = 0,cant_claves_child = 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;
/* 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) {
- /* No esta en este nodo interno, caso 3 */
+ /* No esta en este nodo interno, caso 3 */
} 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) {
- /* Caso 2a */
-
- } else {
+ 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) {
- /* Caso 2b */
-
+ 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);
+ printf("Bloque .dat en prepostkey %i\n",prepostkey.num_bloque);
+ /* 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 {
- /* Caso 2c */
-
+ /* 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]);
+ }
}
- }
-
-
- }
- }
+ }
+ /* Termine caso 2 o 3, libero el nodo */
+ b_plus_destruir_nodo(nodo);
+ return 0;
+ }
return -1;
}
projects / z.facultad / 75.06 / emufs.git / blobdiff