Paso el fin de línea a formato Unix (perdon tenia que verlo para estudiar :P).

[z.facultad/75.06/emufs.git] / emufs / tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index b7e5db44c6120233d736928c1fa7b207125f3d50..1f4138dd272d9b93c1ac75019c86fcdfa41893b9 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -78,6 +78,8 @@ static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, 
                void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
 
 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, 
                void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
 

+static void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque);
+

 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)
 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)


@@ -98,6 +100,8 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;

+       efs->modificar_registro= emufs_tipo1_modificar_registro;
+       efs->obtener_claves_raw= emufs_tipo1_obtener_claves_raw;

        efs->tam_reg = 0;
        return EMUFS_OK;
 }
        efs->tam_reg = 0;
        return EMUFS_OK;
 }


@@ -120,6 +124,8 @@ int emufs_tipo4_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;

+       efs->modificar_registro= emufs_tipo1_modificar_registro_plus;
+       efs->obtener_claves_raw= emufs_tipo1_obtener_claves_raw;

        efs->tam_reg = 0;
        return EMUFS_OK;
 }
        efs->tam_reg = 0;
        return EMUFS_OK;
 }


@@ -135,7 +141,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        INDICE_DATO dato;
        
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        INDICE_DATO dato;
        

-       if (efs->indices != NULL) {
+       if ((efs->indices != NULL) && (*err != 1)) {

                /* TODO : Verificar donde esta el indice primario */
                dato = efs->indices->existe_entrada(efs->indices, clave);
                block_id = dato.bloque;
                /* TODO : Verificar donde esta el indice primario */
                dato = efs->indices->existe_entrada(efs->indices, clave);
                block_id = dato.bloque;


@@ -143,6 +149,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,
        } else {
                reg_id = clave.i_clave;
                block_id = emufs_idx_buscar_registro(efs, reg_id);
        } else {
                reg_id = clave.i_clave;
                block_id = emufs_idx_buscar_registro(efs, reg_id);

+               if (*err == 1) *err = 0; /*hack!*/

        }
        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");
        }
        if (block_id == EMUFS_NOT_FOUND) {
                PERR("Registro no encontrado");


@@ -207,6 +214,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,
        } while (offset < efs->tam_bloque); /* registro está en el bloque */
 
        free(block);
        } while (offset < efs->tam_bloque); /* registro está en el bloque */
 
        free(block);

+       PERR("REGISTRO LEIDO; RETORNANDO");

        return registro;
 }
 
        return registro;
 }
 


@@ -720,7 +728,9 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,
                void *data, EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
 {
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,
                void *data, EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
 {

+       PERR("Tipo1 Modificar Borrando");

        emufs_tipo1_borrar_registro(efs, k, dato);
        emufs_tipo1_borrar_registro(efs, k, dato);

+       PERR("Tipo1 Modificar Agregando de nuevo");

        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 
        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 


@@ -767,12 +777,13 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
 
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
 

-int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
+EMUFS_REG_ID emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)

 {
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_REG_SIZE tam_reg, move_size;
 {
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_REG_SIZE tam_reg, move_size;

+       INDICE_DATO idx_data;

        INDEX_DAT query;
        EMUFS_FREE fs;
        char *bloque = 0, *aux, *new_bloque = 0;
        INDEX_DAT query;
        EMUFS_FREE fs;
        char *bloque = 0, *aux, *new_bloque = 0;


@@ -794,6 +805,8 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);

+       /*pido id nuevo*/
+       header.id = emufs_idx_get_new_id(emu, err);

        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
                return -1;
        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
                return -1;


@@ -806,7 +819,6 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        return -1;
                }
                memset(bloque, 0, emu->tam_bloque);
                        return -1;
                }
                memset(bloque, 0, emu->tam_bloque);

-               header.id = emufs_idx_get_new_id(emu, err);

                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                        free(bloque);
                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                        free(bloque);


@@ -830,10 +842,16 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
                if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);

-               /*agrego la clave al arbol*/
+               /*agrego la clave al arbol bpus*/

                emufs_b_plus_insertar(emu->indices, &query);
                emufs_b_plus_insertar(emu->indices, &query);

+               /*agrego el id a idx*/
+               emufs_idx_agregar(emu, header.id, query.num_bloque);
+               /*agrego a los demas arboles que no sean bplus*/
+               idx_data.id = header.id;
+               idx_data.bloque = query.num_bloque;
+               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                free(bloque);
                free(bloque);

-               return 0;
+               return header.id;

        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                /*leo el bloque correspondiente*/
                bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                /*leo el bloque correspondiente*/
                bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);


@@ -852,8 +870,11 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        PERR("GRABO ORDENADO");                 
                        grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
                        PERR("GRABO ORDENADO");                 
                        grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/

+                       idx_data.id = header.id;
+                       idx_data.bloque = query.num_bloque;
+                       emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                        free(bloque);
                        free(bloque);

-                       return 0;
+                       return header.id;

                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                        PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");
                        new_bloque = (char*)malloc(emu->tam_bloque);
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                        PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");
                        new_bloque = (char*)malloc(emu->tam_bloque);


@@ -872,7 +893,7 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
                        menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
                        memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
                        menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */

-                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, clave) ){
+                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, query.clave) ){

                                /* GRABO EN EL BLOQUE NUEVO */
                                /*actualizo la cant de registros del bloque original (footer)*/
                                memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
                                /* GRABO EN EL BLOQUE NUEVO */
                                /*actualizo la cant de registros del bloque original (footer)*/
                                memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));


@@ -884,9 +905,14 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                                query.num_bloque = emufs_create_new_block(emu);
                                /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
                                clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
                                query.num_bloque = emufs_create_new_block(emu);
                                /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
                                clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);

+                               /*actualizo los ids de idx*/
+                               b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);

                                /*actualizo el arbol con la nueva clave*/
                                query.clave = clave;
                                /*actualizo el arbol con la nueva clave*/
                                query.clave = clave;

+                               idx_data.id = header.id;
+                               idx_data.bloque = query.num_bloque;

                                emufs_b_plus_insertar(emu->indices, &query);
                                emufs_b_plus_insertar(emu->indices, &query);

+                               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                                /*grabo el bloque original*/
                                emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
                        } else {
                                /*grabo el bloque original*/
                                emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
                        } else {


@@ -904,11 +930,16 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                                query.num_bloque = emufs_create_new_block(emu);
                                /*grabo el bloque nuevo*/
                                emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
                                query.num_bloque = emufs_create_new_block(emu);
                                /*grabo el bloque nuevo*/
                                emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query.num_bloque, EMUFS_NOT_FOUND, err);

+                               /*actualizo los ids de idx del bloque nuevo*/
+                               b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);

                                /*grabo el registro en el bloque original*/
                                grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
                                /*actualizo el arbol con la menor clave del bloque nuevo*/
                                query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
                                /*grabo el registro en el bloque original*/
                                grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
                                /*actualizo el arbol con la menor clave del bloque nuevo*/
                                query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));

+                               idx_data.id = header.id;
+                               idx_data.bloque = query.num_bloque;

                                emufs_b_plus_insertar(emu->indices, &query);
                                emufs_b_plus_insertar(emu->indices, &query);

+                               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                        }
                        if(*err != 0){
                                PERR("NO SE PUDO GRABAR ORDENADO");
                        }
                        if(*err != 0){
                                PERR("NO SE PUDO GRABAR ORDENADO");


@@ -918,12 +949,12 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        }
                        free(new_bloque);
                        free(bloque);
                        }
                        free(new_bloque);
                        free(bloque);

-                       return 0;
+                       return header.id;

                }
        }
        if (new_bloque) free(new_bloque);
        if (bloque) free(bloque);
                }
        }
        if (new_bloque) free(new_bloque);
        if (bloque) free(bloque);

-       return 0;
+       return header.id;

 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/


@@ -984,6 +1015,8 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));

+       /*agrego el id a idx*/
+       emufs_idx_agregar(emu, header.id, num_bloque);

        free(new_bloque);
        return clave;
 }
        free(new_bloque);
        return clave;
 }


@@ -992,9 +1025,11 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
 {
        char *bloque, *aux;
        INDEX_DAT query;
 {
        char *bloque, *aux;
        INDEX_DAT query;

-       int result, iter, cant_reg, leidos;
+       INDICE_DATO idx_data;
+       int result, iter, cant_reg;

        EMUFS_REG_SIZE tam_reg;
        EMUFS_REG_SIZE tam_reg;

-       CLAVE clave_ajena;
+       EMUFS_REG_ID id;
+       CLAVE clave_ajena, ancla;

        int err = 0;
        
        /*cargo el query para buscar*/
        int err = 0;
        
        /*cargo el query para buscar*/


@@ -1016,31 +1051,27 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
                PERR("NO SE CARGO EL BLOQUE");
                return -1;
        }
                PERR("NO SE CARGO EL BLOQUE");
                return -1;
        }

+       /*me fijo si el que tengo que eliminar es el ancla del bloque*/
+       ancla = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));

        /*leo la cantidad de registros en el bloque*/
        memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
        /*busco y elimino*/
        iter = 0;
        aux = bloque;
        /*leo la cantidad de registros en el bloque*/
        memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
        /*busco y elimino*/
        iter = 0;
        aux = bloque;

-       /*me fijo si el que tengo que eliminar es el ancla del bloque*/
-       clave_ajena = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
-       if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
-               /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
-               /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
-       }
-       leidos = 0;

        while ( iter < emu->tam_bloque /*&& leidos < cant_reg*/){
                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
                        /*tengo que borrar este registro*/
        while ( iter < emu->tam_bloque /*&& leidos < cant_reg*/){
                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
                        /*tengo que borrar este registro*/

+                       /*leo el id*/
+                       memcpy(&id, aux, sizeof(EMUFS_REG_ID));

                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /*hay que reacomodar todo*/
                        /*me posiciono en el reg siguiente*/
                        iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                        break;/*ya borre, corto aca*/
                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /*hay que reacomodar todo*/
                        /*me posiciono en el reg siguiente*/
                        iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                        break;/*ya borre, corto aca*/

-               }
-               leidos++;
+               }               

                iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
        }
                iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
        }


@@ -1050,11 +1081,26 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
        cant_reg--;
        memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        /*grabo el bloque en el archivo*/
        cant_reg--;
        memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        /*grabo el bloque en el archivo*/

-       if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err) == EMUFS_NOT_FOUND ){
+       if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, &err) == EMUFS_NOT_FOUND ){

                PERR("NO SE PUDO GRABAR EL BLOQUE");
                free(bloque);
                return -1;
        }
                PERR("NO SE PUDO GRABAR EL BLOQUE");
                free(bloque);
                return -1;
        }

+       /*me fijo si el que tengo que eliminar es el ancla del bloque*/
+       if ( emufs_indice_es_igual(emu->indices, clave, ancla) ){
+               if ( cant_reg == 0 )
+                       emufs_b_plus_eliminar(emu->indices, clave, 0);
+               else {
+                       /*obtengo la nueva ancla del bloque*/
+                       query.clave = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+                       emufs_b_plus_reemplazar_clave(emu->indices, ancla, query, 0);
+               }
+       }
+       emufs_idx_borrar(emu, id);
+       /* Elimino la entrada de los restantes arboles */                               
+       idx_data.id = id;
+       idx_data.bloque = query.num_bloque;
+       emufs_indice_borrar(emu->indices->sig, clave, idx_data);

        free(bloque);
        return 0;
 }
        free(bloque);
        return 0;
 }


@@ -1113,3 +1159,71 @@ void *emufs_tipo1_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *si
        free(bloque);
        return reg;
 }
        free(bloque);
        return reg;
 }

+                       
+EMUFS_REG_ID emufs_tipo1_modificar_registro_plus(EMUFS *emu, CLAVE k, void *ptr , EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
+{
+       emufs_tipo1_eliminar_ordenado(emu, k, dato);
+       return emufs_tipo1_insertar_ordenado(emu, ptr, size, err);
+}
+
+B_PLUS_KEYBUCKET *emufs_tipo1_obtener_claves_raw(EMUFS *emu, int num_bloque)
+{
+       B_PLUS_KEYBUCKET *keys;
+       char *bloque, *aux;;
+       int err = 0, cant_reg, i;
+       EMUFS_REG_SIZE tam_reg;
+       
+       keys = (B_PLUS_KEYBUCKET*)malloc(sizeof(B_PLUS_KEYBUCKET));
+       if (keys == NULL){
+               PERR("NO SE PUDO CREAR EL BUCKET");
+               return NULL;
+       }
+       /*leo el bloque*/
+       bloque = emufs_tipo1_leer_bloque(emu, num_bloque, &err);
+       if ( bloque == NULL ){
+               PERR("NO SE PUDO LEER EL BLOQUE");
+               return NULL;
+       }
+       aux = bloque;
+       /*leo la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*ya se cuanto guardarle al vector*/
+       keys->claves = (CLAVE*)malloc(cant_reg*sizeof(CLAVE));
+       if (keys->claves == NULL){
+               PERR("NO SE PUDO CREAR EL ARRAY DE CLAVES");
+               free(bloque);
+               free(keys);
+               return NULL;
+       }
+       keys->cant_keys = cant_reg;
+       keys->current_key = 0;
+       for (i=0; i<cant_reg; i++){
+               memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+               keys->claves[i] = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+               bloque += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+       }
+       free(aux);
+       return keys;
+}
+
+void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque)
+{
+       EMUFS_REG_ID id;
+       int cant_reg,i;
+       EMUFS_REG_SIZE tam_reg;
+       char *aux;
+       /*leo la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*reemplazo todos los ids*/
+       aux = bloque;
+       for(i=0; i<cant_reg; i++){
+               /*leo id a reemplazar*/
+               memcpy(&id, aux, sizeof(EMUFS_REG_ID));
+               /*leo el tamanio del registro*/
+               memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+               /*reemplazo el id*/
+               emufs_idx_agregar(emu, id, num_bloque);
+               /*me muevo para la sig iteracion*/
+               aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+       }
+}