]> git.llucax.com Git - z.facultad/75.06/emufs.git/blobdiff - emufs/tipo3.c
Se agrega una razon más para elegir algoritmo de external sort.
[z.facultad/75.06/emufs.git] / emufs / tipo3.c
index 06bab34bea16b97b7e41bf96c94af04558dca361..0ebccc50becb63d831c93d21522ce8b58c895300 100644 (file)
@@ -44,7 +44,7 @@
 
 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);
 
 int emufs_tipo3_inicializar(EMUFS* efs)
 {
@@ -64,8 +64,8 @@ int emufs_tipo3_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;
-       efs->modificar_registro = emufs_tipo3_modificar_registro;
-       efs->tam_reg = 0;
+       efs->modificar_registro= emufs_tipo3_modificar_registro;
+       efs->obtener_claves_raw= emufs_tipo3_obtener_claves_raw;
        return EMUFS_OK;
 }
 
@@ -87,6 +87,8 @@ int emufs_tipo5_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;
+       efs->modificar_registro= emufs_tipo3_modificar_registro_plus;
+       efs->obtener_claves_raw= emufs_tipo3_obtener_claves_raw;
        return EMUFS_OK;
 }
 
@@ -113,7 +115,6 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                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.
@@ -223,6 +224,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
        char* bloque = NULL;
        int cant_bloques, resto, i=0;
        
+       PERR("TIPO3 GRABRAR REGISTRO");
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        
@@ -243,7 +245,10 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
 
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == EMUFS_NOT_FOUND) {
-               if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+               if ( (file = fopen(name_f,"a+"))==NULL ) {
+                       PERR("NO SE PUDO ABRIR ARCHIVO DE DATOS");
+                       return -1; /*ERROR*/
+               }
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);
                /* El free esta al final de la funcion! */
@@ -275,6 +280,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        if (i == 0) {
                                /* Tengo que agregar el primer bloque en IDX */
                                if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                       PERR("FALLO AGREGAR A IDX");
                                        free(bloque);
                                        return -1;
                                }
@@ -290,6 +296,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
                                fclose(file);
                                free(bloque);
+                               PERR("FALLO AGREGAR A IDX");
                                return -1;
                        }
                }
@@ -339,6 +346,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
                                        fclose(file);
                                        if (bloque) free(bloque);
+                                       PERR("FALLO AGREGAR A IDX");
                                        return -1;
                                }
                        } else {        
@@ -347,12 +355,14 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
                                        fclose(file);
                                        if (bloque) free(bloque);
+                                       PERR("FALLO AGREGAR A FSC");
                                        return -1;
                                }
                        }
                        if ( i == 0 ){
                                if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
                                        if (bloque) free(bloque);
+                                       PERR("FALLO AGREGAR A IDX");
                                        return -1;
                                }
                                idx_data.id = ID_aux;
@@ -362,6 +372,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                }
        }
        if (bloque) free(bloque);
+       PERR("GRABAR COMPLETO");
        return ID_aux;
 }
 
@@ -635,6 +646,7 @@ void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
 
 EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {
+       INDICE_DATO idx_data;
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_REG_ID header;
@@ -660,6 +672,7 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
        0 = Sin problemas, retorno bloque donde insertar
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
+       header = emufs_idx_get_new_id(emu, err);
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
@@ -673,7 +686,6 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        return -1;
                }
                memset(bloque, 0, emu->tam_bloque);
-               header = emufs_idx_get_new_id(emu, err);
                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                        free(bloque);
@@ -696,8 +708,14 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                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_tipo3_grabar_bloque(emu, bloque, query.num_bloque);
-               /*agrego la clave al arbol*/
+               /*agrego la clave al arbol bplus*/
                emufs_b_plus_insertar(emu->indices, &query);
+               /*agrego el id a idx*/
+               emufs_idx_agregar(emu, header, query.num_bloque);
+               /*actualizo los restantes arboles */
+               idx_data.id = header;
+               idx_data.bloque = query.num_bloque;
+               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);
                free(bloque);
                return header;
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
@@ -717,6 +735,9 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        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;
+                       idx_data.bloque = query.num_bloque;
+                       emufs_indice_agregar(emu->indices->sig, ptr, idx_data);
                        free(bloque);
                        return header;
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
@@ -734,10 +755,10 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));
                        /*borro lo que sobra en el bloque original, guardando el footer*/
                        memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
-                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
+                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));                   
                        /* 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) ){
-                               /* GRABO EN EL BLOQUE NUEVO */
+                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, query.clave) ){
+                               PERR("GRABO EN EL BLOQUE NUEVO"); 
                                /*actualizo la cant de registros del bloque original (footer)*/
                                memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
                                /*actualizo el footer del nuevo bloque*/
@@ -748,9 +769,14 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                                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*/
+                               idx_data.id = header;
+                               idx_data.bloque = query.num_bloque;
                                query.clave = clave;
-                               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_tipo3_grabar_bloque(emu, bloque, num_bloque);
                        } else {
@@ -768,10 +794,15 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                                query.num_bloque = emufs_create_new_block(emu);
                                /*grabo el bloque nuevo*/
                                emufs_tipo3_grabar_bloque(emu, new_bloque, query.num_bloque);
+                               /*actualizo los ids 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_REG_ID));
+                               idx_data.id = header;
+                               idx_data.bloque = query.num_bloque;
+                               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);
                                emufs_b_plus_insertar(emu->indices, &query);
                        }
                        if(*err != 0){
@@ -846,6 +877,7 @@ 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_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
+       emufs_idx_agregar(emu, header, num_bloque);
        free(new_bloque);
        return clave;
 }
@@ -853,9 +885,11 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
 int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
 {
        char *bloque, *aux;
+       INDICE_DATO idx_data;
        INDEX_DAT query;
        int result, iter, cant_reg;
        EMUFS_REG_SIZE tam_reg = emu->tam_reg;
+       EMUFS_REG_ID id;
        CLAVE clave_ajena, ancla;
        int err = 0;
 
@@ -888,14 +922,16 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
        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) ){
-                       /*tenngo que borrar este registro*/
+                       /*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_REG_ID));
                        /*hay que reacomodar todo*/
                        /*me posiciono en el reg siguiente*/
                        iter += tam_reg+sizeof(EMUFS_REG_ID);
                        break;/*ya borre, corto aca*/
-               }
+               }               
                iter += tam_reg+sizeof(EMUFS_REG_ID);
                aux += tam_reg+sizeof(EMUFS_REG_ID);
        }
@@ -920,6 +956,11 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
                        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;
 }
@@ -1022,3 +1063,23 @@ B_PLUS_KEYBUCKET *emufs_tipo3_obtener_claves_raw(EMUFS *emu, int num_bloque)
        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 = emu->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));
+               /*reemplazo el id*/
+               emufs_idx_agregar(emu, id, num_bloque);
+               /*me muevo para la sig iteracion*/
+               aux += tam_reg+sizeof(EMUFS_REG_ID);
+       }
+}