X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/22f4aa739f33817a7c47f08154b4742fce0c5c31..a666806d9361a2876a07941b8d2bb5c973e1557e:/emufs/indice_b.c diff --git a/emufs/indice_b.c b/emufs/indice_b.c index b119784..8f43582 100644 --- a/emufs/indice_b.c +++ b/emufs/indice_b.c @@ -42,11 +42,14 @@ static void b_pasar_clave_a_derecha(INDICE*, char*, int, char*, int, int, B_Nodo static void b_pasar_clave_a_izquierda(INDICE*, char*, int, char*, int, int, B_NodoEntry, int, int); /** Junta 2 nodos y hace uno solo */ static void b_fundir_nodo(INDICE *,char *, int, char *, int, char *, int, int); +/** Crea 3 nodos a partir de 2 llenos */ +static void b_partir_dos_nodos_en_tres(INDICE*, int nodo_izq, int nodo_der, int padre, B_NodoEntry nuevo_entry); static EMUFS_REG_ID b_insertar_dup_en_pos(INDICE *idx, INDICE_DATO pos, INDICE_DATO nuevo); static void abreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header); static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header); +int b_borrar_dup_clave(INDICE *idx, INDICE_DATO k, INDICE_DATO dato); void emufs_indice_b_crear(INDICE *idx) { @@ -102,12 +105,11 @@ int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, INDICE_DATO dato) return 0; } - /* TODO : Implementar carga de valor en clave duplicada! */ b_insertar_dup_en_pos(idx, claves[i].dato, dato); if (idx->tipo_dato == IDX_STRING) { /* Tengo que sacar el texto repetido del archivo de textos */ - idx->emu_string->borrar_registro(idx->emu_string, clave); + idx->emu_string->borrar_registro(idx->emu_string, clave, dummy); } return 1; } else { @@ -178,7 +180,7 @@ INDICE_DATO emufs_indice_b_buscar(INDICE *idx, CLAVE clave) return ret; } -int emufs_indice_b_borrar(INDICE *idx, CLAVE k) +int emufs_indice_b_borrar(INDICE *idx, CLAVE k, INDICE_DATO dato) { /* Busco el nodo que contiene la clave,si es que esta existe */ char *nodo; @@ -214,8 +216,19 @@ int emufs_indice_b_borrar(INDICE *idx, CLAVE k) if (encontrado) { PERR("Clave encontrada, borrando ..."); - fprintf(stderr, "La clave a borrar esta en el nodo %d\n", nodo_id); - b_borrar_clave(idx, nodo, nodo_id, k); + fprintf(stderr, "%s: La clave a borrar esta en el nodo %d\n", idx->nombre, nodo_id); + if (idx->funcion != IND_PRIMARIO) { + /* Debo borrar primero la clave desde el archivo de + * claves repetidas, y si recien ahi me quedo sin claves, + * borrar la clave del arbol + */ + PERR("Vamos a borrar duplicados"); + encontrado = b_borrar_dup_clave(idx, claves[i].dato, dato); + fprintf(stderr, "Listo, encontrado = %d\n", encontrado); + } + if (encontrado) { + b_borrar_clave(idx, nodo, nodo_id, k); + } } else { PERR("Clave no encontrada"); } @@ -259,8 +272,8 @@ char *b_leer_nodo(INDICE *idx, int id) { FILE *fp; char *out; - B_NodoHeader header; - B_NodoEntry *claves; + /*B_NodoHeader header; + B_NodoEntry *claves;*/ if (id < 0) return NULL; @@ -283,11 +296,11 @@ char *b_leer_nodo(INDICE *idx, int id) } /* Si estoy manejando string tengo que sacar las abreviaturas */ - if (idx->tipo_dato == IDX_STRING) { +/* if (idx->tipo_dato == IDX_STRING) { b_leer_header(out, &header); claves = b_leer_claves(out, &header); desabreviar_claves(idx, claves, &header); - } + }*/ fclose(fp); return out; } @@ -295,15 +308,15 @@ char *b_leer_nodo(INDICE *idx, int id) static void b_grabar_nodo(INDICE *idx, int id, char *data) { FILE *fp; - B_NodoHeader header; - B_NodoEntry *claves; + /*B_NodoHeader header; + B_NodoEntry *claves;*/ /* Si las claves son de tipo string debo abreviar antes de guardar */ - if (idx->tipo_dato == IDX_STRING) { +/* if (idx->tipo_dato == IDX_STRING) { b_leer_header(data, &header); claves = b_leer_claves(data, &header); abreviar_claves(idx, claves, &header); - } + }*/ fp = fopen(idx->filename, "r+"); fseek(fp, id*idx->tam_bloque, SEEK_SET); fwrite(data, 1, idx->tam_bloque, fp); @@ -350,11 +363,52 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, int n if (nodo_header.cant == CANT_HIJOS(idx)) { int total; - /* TODO: Si es B*, hay que chequear si alguno de los 2 - * nodos hermanos pueden prestarme espacio (y - * desplazar si es así). Si no pueden, hay que - * hacer un split de 2 nodos en 3. - * Si no es B*, hay que hacer lo que sigue: + /* + * TODO FIXME XXX TODO FIXME XXX TODO FIXME XXX + * + ******************************************************* + * Pseudocódigo que explica que hay que hacer si es B* + * + * OJO! Si el nodo en el cual estoy insertando es el + * raíz, se maneja exactamente igual que en el B común, + * así que el if sería algo como: + * if (idx->tipo == IND_B_ASC && !es_raiz(nodo_id)) + ******************************************************* + * + * nuevo_entry = new entry(clave, dato, hijo_der) + * padre = get_padre(nodo) + * + * // Veo si puedo pasar a derecha + * hijo_derecho = get_hijo_derecho(padre) + * if (hijo_derecho != NULL && hijo_derecho.cantidad_entries < MAX_ENTRIES) + * buffer = new entries[MAX_ENTRIES+1] + * copiar_entries(buffer, nodo) + * insertar_ordenado(buffer, nuevo_entry) + * entry_a_pasar = get_entry_extremo_derecho(buffer) + * b_pasar_clave_a_derecha(idx, hijo_derecho, hijo_derecho.id, padre, padre.id, padre.posicion, entry_a_pasar) + * SALIR + * + * // Veo si puedo pasar a izquierda + * hijo_izquierdo = get_hijo_izquierdo(padre) + * if (hijo_izquierdo != NULL && hijo_izquierdo.cantidad_entries < MAX_ENTRIES) + * buffer = new entries[MAX_ENTRIES+1] + * copiar_entries(buffer, nodo) + * insertar_ordenado(buffer, nuevo_entry) + * entry_a_pasar = get_entry_extremo_izquierdo(buffer) + * b_pasar_clave_a_izquierda(idx, hijo_izquierdo, hijo_izquierdo.id, padre, padre.id, padre.posicion, entry_a_pasar) + * SALIR + * + * // Parto 2 nodos en 3. + * if (hijo_izquierdo != NULL) + * b_partir_dos_nodos_en_tres(idx, hijo_izquierdo, nodo, padre, nuevo_entry) + * else // Siempre alguno tiene que existir. + * b_partir_dos_nodos_en_tres(idx, nodo, hijo_derecho, padre, nuevo_entry) + * + * SALIR + * + ********************************************************************************** + * Fin de pseudocódigo, si no es B* se sigue haciendo lo que dice a continuación. * + ********************************************************************************** */ nuevo = b_crear_nodo(idx, &nuevo_id); i=0; @@ -486,7 +540,6 @@ void b_insertar_en_nodo_con_lugar(INDICE *idx, CLAVE clave, INDICE_DATO dato, in claves[i-1].hijo_derecho = hijo_izq; claves[i].hijo_derecho = hijo_der; } - /*b_elegir_izquierdo(idx, nodo_header.hijo_izquierdo, hijo1);*/ b_actualizar_header(nodo, &nodo_header); b_grabar_nodo(idx, nodo_id, nodo); @@ -612,9 +665,6 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k) fprintf(stderr, "La clave esta en la pos = %d\n", pos); if (header.hijo_izquierdo != -1) { PERR("Nodo no es hoja, intercambio"); -/* if (pos == 0) { - actual = b_leer_nodo(idx, nodo_header.hijo_izquierdo); - else*/ actual = b_leer_nodo(idx, claves[pos].hijo_derecho); actual_id = claves[pos].hijo_derecho; p = claves[pos].hijo_derecho; @@ -655,7 +705,7 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k) /* Se cumple la condicion de hijos? */ PERR("Dejo todo consistente"); fprintf(stderr, "Condicion : %d >= %d\n", header_actual.cant, MIN_HIJOS(idx)); - if (header_actual.cant >= MIN_HIJOS(idx)) { + if ((header_actual.cant >= MIN_HIJOS(idx)) && (actual_id != 0)) { PERR("Borrar completo sin fundir"); return; } @@ -664,6 +714,7 @@ static void b_borrar_clave(INDICE *idx, char *nodo, int nodo_id, CLAVE k) /* Tengo que pasar datos o fundir nodos :-( */ do { padre_id = header.padre; + if (padre_id == -1) continue; padre = b_leer_nodo(idx, padre_id); b_leer_header(padre, &header_padre); claves_padre = b_leer_claves(padre, &header_padre); @@ -754,6 +805,7 @@ static void b_pedir_clave_derecha(char *der, int der_id, char *padre, int padre_ B_NodoHeader h_der, h_padre, h_nodo; B_NodoEntry *c_der, *c_padre, *c_nodo; + PERR("Derecha 1"); b_leer_header(nodo, &h_nodo); c_nodo = b_leer_claves(nodo, &h_nodo); b_leer_header(der, &h_der); @@ -761,13 +813,16 @@ static void b_pedir_clave_derecha(char *der, int der_id, char *padre, int padre_ b_leer_header(padre, &h_padre); c_padre = b_leer_claves(padre, &h_padre); + PERR("Derecha 2"); c_nodo[h_nodo.cant] = c_padre[pos_clave+1]; c_nodo[h_nodo.cant].hijo_derecho = -1; /* XXX */ + PERR("Derecha 3"); c_padre[pos_clave+1] = c_der[0]; c_padre[pos_clave+1].hijo_derecho = der_id; /* Muevo las claves de derecho */ + PERR("Derecha 4"); for(i=0; iemu_mult->modificar_registro(idx->emu_mult, k, leido, cant*sizeof(INDICE_DATO)+sizeof(int), - &error + &error, + dummy ); } /* Clean up! */ @@ -967,10 +1025,11 @@ static void abreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *heade * mas de 2 letras iguales, si no no gano nada y complica las cosas */ if (iguales > 1) { + INDICE_DATO dummy1; sprintf(salvar, "%d|%s", iguales, resto); free(actual); error = 0; - idx->emu_string->modificar_registro(idx->emu_string, array[i].clave, salvar, strlen(salvar)+1, &error); + idx->emu_string->modificar_registro(idx->emu_string, array[i].clave, salvar, strlen(salvar)+1, &error, dummy1); } else { free(primera); primera = actual; @@ -997,10 +1056,11 @@ static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *he } iguales = strtol(actual, &resto, 10); if ((iguales > 0) && (*resto == '|')) { + INDICE_DATO dummy2; strncpy(salvar, primera, iguales); salvar[iguales] = '\0'; strcat(salvar, resto+1); /* +1 para saltar el separador */ - idx->emu_string->modificar_registro(idx->emu_string, array[i].clave, salvar, strlen(salvar)+1, &error); + idx->emu_string->modificar_registro(idx->emu_string, array[i].clave, salvar, strlen(salvar)+1, &error, dummy2); free(actual); } else { free(primera); @@ -1011,3 +1071,237 @@ static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *he free(primera); } +static void b_partir_dos_nodos_en_tres(INDICE* idx, int nodo_izq, int nodo_der, int padre, B_NodoEntry nuevo_entry) +{ + /* + * PSEUDOCODIGO TODO FIXME XXX TODO FIXME XXX TODO FIXME XXX + * + * // Creo un buffer con todos los entries (las claves) de ambos nodos, mas el padre y la nueva, ordenadas + * buffer_size = 2*MAX_ENTRIES+2 + * buffer = new entries[buffer_size] + * copiar_entries(buffer, nodo_izq) + * concatenar_entries(buffer, padre) + * concatenar_entries(buffer, nodo_der) + * insertar_ordenado(buffer, nuevo_entry) + * // Borro los 2 nodos viejos para reutilizarlos y creo el tercero + * borrar_entries(nodo_izq) + * borrar_entries(nodo_der) + * nodo_nuevo = new nodo() + * // Copio de a tercios del buffer en los nuevos nodos, excluyendo las 2 claves 'limítrofes' para insertarlas luego en el padre + * copiar_algunos_entries(nodo_izq, buffer, 0, (buffer_size/3)-1) + * entry_promovido1 = buffer[buffer_size/3] + * copiar_algunos_entries(nodo_izq, buffer, (buffer_size/3)+1, 2*(buffer_size/3)) + * entry_promovido2 = buffer[(2*(buffer_size/3))+1] + * copiar_algunos_entries(nodo_nuevo, buffer, (2*(buffer_size/3))+2, buffer_size-1)) + * // Finalmente inserto (recursivamente, porque esta funcion es llamada desde b_insertar_en_nodo()) las claves promovidas en el padre + * b_insertar_en_nodo(idx, entry_promovido.clave, entry_promovido.dato, entry_promovido.id, entry_promovido, nodo_izq.id, nodo_der.id) + * b_insertar_en_nodo(idx, entry_promovido.clave, entry_promovido.dato, entry_promovido.id, entry_promovido, nodo_der.id, nodo_nuevo.id) + * + */ +} + +CLAVE emufs_indice_b_obtener_menor_clave(INDICE *idx) +{ + B_NodoHeader header; + B_NodoEntry *claves; + CLAVE k; + char *nodo; + + nodo = b_leer_nodo(idx, 0); + b_leer_header(nodo, &header); + /* Tengo que ir siempre a la izquierda hasta una hora */ + while (header.hijo_izquierdo != -1) { + free(nodo); + nodo = b_leer_nodo(idx, header.hijo_izquierdo); + b_leer_header(nodo, &header); + } + + /* Listo, ahora solo leo la primer clave */ + claves = b_leer_claves(nodo, &header); + k = claves[0].clave; + free(nodo); + return k; +} + +CLAVE emufs_indice_b_obtener_mayor_clave(INDICE *idx) +{ + B_NodoHeader header; + B_NodoEntry *claves; + CLAVE k; + int i; + char *nodo; + + nodo = b_leer_nodo(idx, 0); + b_leer_header(nodo, &header); + claves = b_leer_claves(nodo, &header); + /* Tengo que ir siempre a la izquierda hasta una hora */ + while (claves[header.cant-1].hijo_derecho != -1) { + i = claves[header.cant-1].hijo_derecho; + free(nodo); + nodo = b_leer_nodo(idx, i); + b_leer_header(nodo, &header); + claves = b_leer_claves(nodo, &header); + } + + /* Listo, ahora solo leo la primer clave */ + k = claves[header.cant-1].clave; + free(nodo); + return k; +} + +CLAVE emufs_indice_b_obtener_sig_clave(INDICE *idx, CLAVE k) +{ + int i; + B_NodoHeader header; + B_NodoEntry *claves; + char *nodo, *tmp; + int nodo_id; + CLAVE salida; + + /* Primero busco la clave pasada por parametro */ + nodo = b_leer_nodo(idx, 0); + nodo_id = 0; + while (nodo) { + b_leer_header(nodo, &header); + claves = b_leer_claves(nodo, &header); + i=0; + while ((iemu_mult->leer_registro(idx->emu_mult, k, &tam, &error); + + cant = *((int *)leido); + + /* Obtengo un nuevo lugar para el dato nuevo */ + array = (INDICE_DATO *)(leido+sizeof(int)); + + /* busco pos de dato en array */ + for(pos=0; posemu_mult->borrar_registro(idx->emu_mult, k, dummy1); + return 0; + } + + /* Quito el elemento */ + leido = realloc(leido, sizeof(int)+cant*sizeof(INDICE_DATO)); + + /* Actualizo la cantidad */ + (*((int *)leido)) = cant; + + error = 0; + idx->emu_mult->modificar_registro(idx->emu_mult, + k, + leido, + cant*sizeof(INDICE_DATO)+sizeof(int), + &error, + dummy1 + ); + + free(leido); + + return cant; +} +