Piloteado de mini bug que pudiera existir en insertar ordenado, siempre se devuelve...

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

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 435e86cad5923e1474a8fdb14f1affebee6a3eaa..4973603c17356889ce74c8f6b4f19b20b698dd16 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -45,6 +45,50 @@
 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);
 

+
+int emufs_tipo3_inicializar(EMUFS* efs)
+{
+       /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
+        * (una relación 1/2 entre datos e info de control ya es lo suficientemente
+        * mala */
+       if (efs->tam_bloque < (sizeof(EMUFS_REG_ID) * 2)) {
+               PERR("bloque demasiado chico");
+               return EMUFS_ERROR_BLOCK_TOO_SMALL;
+       }
+       /* Asigna punteros a funciones. */
+       efs->leer_bloque       = emufs_tipo3_leer_bloque;
+       efs->leer_bloque_raw   = emufs_tipo3_leer_bloque_raw;
+       efs->grabar_registro   = emufs_tipo3_grabar_registro;
+       efs->borrar_registro   = emufs_tipo3_borrar_registro;
+       efs->leer_registro     = emufs_tipo3_leer_registro;
+       efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
+       efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
+       efs->compactar         = emufs_tipo3_compactar;
+       efs->tam_reg = 0;
+       return EMUFS_OK;
+}
+
+int emufs_tipo5_inicializar(EMUFS* efs)
+{
+       /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
+        * (una relación 1/2 entre datos e info de control ya es lo suficientemente
+        * mala */
+       if (efs->tam_bloque < (sizeof(EMUFS_REG_ID) * 2)) {
+               PERR("bloque demasiado chico");
+               return EMUFS_ERROR_BLOCK_TOO_SMALL;
+       }
+       /* Asigna punteros a funciones. */
+       efs->leer_bloque       = emufs_tipo3_leer_bloque;
+       efs->leer_bloque_raw   = emufs_tipo3_leer_bloque_raw;
+       efs->grabar_registro   = emufs_tipo3_insertar_ordenado;
+       efs->borrar_registro   = emufs_tipo3_eliminar_ordenado;
+       efs->leer_registro     = emufs_tipo3_leer_registro_plus;
+       efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
+       efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
+       efs->compactar         = emufs_tipo3_compactar;
+       return EMUFS_OK;
+}
+

 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                EMUFS_REG_SIZE* reg_size, int* err)
 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                EMUFS_REG_SIZE* reg_size, int* err)


@@ -68,6 +112,7 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                block = dato.bloque;
                ID = dato.id;
                PERR("Use indice");
                block = dato.bloque;
                ID = dato.id;
                PERR("Use indice");

+               fprintf(stderr, "Datos leidos : id=%ld, bloque=%ld\n", ID, block);

        } else {
                /* Si no tengo claves, uso el campo entero para pasar un ID
                 * directamente.
        } else {
                /* Si no tengo claves, uso el campo entero para pasar un ID
                 * directamente.


@@ -75,6 +120,7 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                PERR("Use directo");
                ID = clave.i_clave;
                block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
                PERR("Use directo");
                ID = clave.i_clave;
                block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/

+               if (*err == 1) *err = 0;

        }
        if ( block == EMUFS_NOT_FOUND ){
                PERR("No se encontro el bloque");
        }
        if ( block == EMUFS_NOT_FOUND ){
                PERR("No se encontro el bloque");


@@ -586,7 +632,7 @@ void emufs_tipo3_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_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
+EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)

 {
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
 {
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 


@@ -652,7 +698,7 @@ int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);
                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);

-               return 0;
+               return header;

        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                /*leo el bloque correspondiente*/
                bloque = emufs_tipo3_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_tipo3_leer_bloque(emu, query.num_bloque, err);


@@ -671,7 +717,7 @@ int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        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*/
                        free(bloque);
                        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*/
                        free(bloque);

-                       return 0;
+                       return header;

                } 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);


@@ -735,12 +781,12 @@ int emufs_tipo3_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;

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

-       return 0;
+       return header;

 }
 
 /*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*/


@@ -803,13 +849,14 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
        return clave;
 }
 
        return clave;
 }
 

-int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
+int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)

 {
        char *bloque, *aux;
        INDEX_DAT query;
        int result, iter, cant_reg;
        EMUFS_REG_SIZE tam_reg = emu->tam_reg;
 {
        char *bloque, *aux;
        INDEX_DAT query;
        int result, iter, cant_reg;
        EMUFS_REG_SIZE tam_reg = emu->tam_reg;

-       CLAVE clave_ajena;
+       CLAVE clave_ajena, ancla;
+       int err = 0;

 
        /*cargo el query para buscar*/
        query.num_bloque = 0;
 
        /*cargo el query para buscar*/
        query.num_bloque = 0;


@@ -825,22 +872,18 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
                return -1;
        }
        /*cargo el bloque que corresponde*/
                return -1;
        }
        /*cargo el bloque que corresponde*/

-       bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
+       bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, &err);

        if ( bloque == NULL ){
                PERR("NO SE CARGO EL BLOQUE");
                return -1;
        }
        if ( bloque == NULL ){
                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_REG_ID));

        /*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_REG_ID));
-       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*/
-       }

        while ( iter < emu->tam_bloque ){
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
        while ( iter < emu->tam_bloque ){
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){


@@ -866,6 +909,115 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
                free(bloque);
                return -1;
        }
                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_REG_ID));
+                       emufs_b_plus_reemplazar_clave(emu->indices, ancla, query, 0);
+               }
+       }

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

+
+void *emufs_tipo3_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *size, int *err)
+{
+       CLAVE clave_ajena;
+       char *reg = NULL; 
+       char *bloque, *aux;
+       INDEX_DAT query;
+       int result, cant_reg, i;
+       EMUFS_REG_SIZE tam_reg;
+       
+       tam_reg = emu->tam_reg;
+       /*cargo el query*/
+       query.clave = clave;
+       query.num_bloque = 0;
+       /*hago la consulta*/
+       
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if (result == -1){
+               PERR("NO EXISTE EL BLOQUE");
+               return NULL;
+       }
+       if (result == 1){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL");
+               return NULL;
+       }
+       /*leo el bloque*/
+       bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
+       /*busco el registro en el bloque*/
+       /*copio la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       aux = bloque;
+       for (i=0; i<cant_reg; i++){
+               /*leo la clave*/
+               clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
+               if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+                       reg = (char*)malloc(tam_reg);
+                       if (reg == NULL){
+                               PERR("NO SE PUDO CARGAR EL REGISTRO");
+                               *err = -1;
+                               free(bloque);
+                               return NULL;
+                       }
+                       /*copio el registro*/
+                       memcpy(reg, aux+sizeof(EMUFS_REG_ID), tam_reg);
+                       *size = tam_reg;
+                       break; /*ya lo encontre, corto el for*/
+               }
+               aux += tam_reg+sizeof(EMUFS_REG_ID); /*paso al proximo*/
+       }
+       if ( i == cant_reg ) *err=-1;
+       free(bloque);
+       return reg;
+}
+
+
+EMUFS_REG_ID emufs_tipo3_modificar_registro_plus(EMUFS *emu, CLAVE k, void *ptr , EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
+{
+       emufs_tipo3_eliminar_ordenado(emu, k, dato);
+       return emufs_tipo3_insertar_ordenado(emu, ptr, size, err);
+}
+
+B_PLUS_KEYBUCKET *emufs_tipo3_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 = emu->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_tipo3_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(keys);
+               return NULL;
+       }
+       keys->cant_keys = cant_reg;
+       keys->current_key = 0;
+       
+       for (i=0; i<cant_reg; i++){
+               keys->claves[i] = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_REG_ID));
+               bloque += tam_reg+sizeof(EMUFS_REG_ID);
+       }
+       free(aux);
+       return keys;
+}