Agrego uso de indices primarios para grabra y recuperar en tipo1 y tipo2

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

diff --git a/emufs/indice_b.c b/emufs/indice_b.c
index f3fd08f0fa205d4813137c0873fc3c93fda18661..5097992fe6295e87837ef422fee270121a8eaf1a 100644 (file)
--- a/emufs/indice_b.c
+++ b/emufs/indice_b.c
@@ -1,5 +1,6 @@
 
 #include "indice_b.h"
+#include "common.h"
 
 /* Cantidad de claves por nodo */
 #define CANT_HIJOS(x) ((x->tam_bloque-sizeof(B_NodoHeader))/sizeof(B_NodoEntry))
@@ -14,7 +15,7 @@ static char *b_crear_nodo(INDICE *idx, int *i);
 static void b_leer_header(char *src, B_NodoHeader *header);
 static void b_actualizar_header(char *src, B_NodoHeader *header);
 static B_NodoEntry *b_leer_claves(char *src, B_NodoHeader *header);
-static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo_id, char *nodo, int hijo1, int hijo2);
+static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, int nodo_id, char *nodo, int hijo1, int hijo2);
 const int b_elegir_izquierdo(INDICE *idx, int a, int b);
 
 void emufs_indice_b_crear(INDICE *idx)
@@ -29,6 +30,12 @@ void emufs_indice_b_crear(INDICE *idx)
        header.hijo_izquierdo = -1;
 
        fp = fopen(idx->filename, "w");
+       PERR("Creando indice");
+       fprintf(stderr, "Archivo = (%s)\n", idx->filename);
+       if (fp == NULL) {
+               PERR("Error al crear el archivo");
+               return;
+       }
        
        /* Creo el archivo con el Nodo raiz */
        bloque = (char *)malloc(idx->tam_bloque);
@@ -40,7 +47,7 @@ void emufs_indice_b_crear(INDICE *idx)
        fclose(fp);
 }
 
-int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, int ubicacion)
+int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, INDICE_DATO dato)
 {
        int i, nodo_id, padre_id;
        B_NodoHeader header;
@@ -64,21 +71,11 @@ int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, int ubicacion)
                        return 0;
                } else {
                        if (i == 0) {
-                               if (header.nivel != 0) {
-                                       nodo = b_leer_nodo(idx, header.hijo_izquierdo);
-                                       nodo_id = header.hijo_izquierdo;
-                               } else {
-                                       nodo = NULL;
-                                       nodo_id = -1;
-                               }
+                               nodo = b_leer_nodo(idx, header.hijo_izquierdo);
+                               nodo_id = header.hijo_izquierdo;
                        } else {
-                               if (header.nivel != 0) {
-                                       nodo = b_leer_nodo(idx, claves[i-1].ubicacion);
-                                       nodo_id = claves[i-1].ubicacion;
-                               } else {
-                                       nodo = NULL;
-                                       nodo_id = -1;
-                               }
+                               nodo = b_leer_nodo(idx, claves[i-1].hijo_derecho);
+                               nodo_id = claves[i-1].hijo_derecho;
                        }
                }
        }
@@ -86,13 +83,14 @@ int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, int ubicacion)
        if (nodo) free(nodo);
        nodo = padre;
        nodo_id = padre_id;
-       b_insertar_en_nodo(idx, clave, ubicacion, nodo_id, nodo, -1, -1);
+       b_insertar_en_nodo(idx, clave, dato, nodo_id, nodo, -1, -1);
        return 1; /* Agregar OK! */
 }
 
-int emufs_indice_b_buscar(INDICE *idx, CLAVE clave)
+INDICE_DATO emufs_indice_b_buscar(INDICE *idx, CLAVE clave)
 {
-       int i, ret;
+       int i;
+       INDICE_DATO ret;
        B_NodoHeader header;
        B_NodoEntry *claves;
        char *nodo, *tmp;
@@ -105,7 +103,7 @@ int emufs_indice_b_buscar(INDICE *idx, CLAVE clave)
                i=0;
                while ((i<header.cant) && (emufs_indice_es_menor(idx, claves[i].clave, clave))) i++;
                if (emufs_indice_es_igual(idx, claves[i].clave, clave)) {
-                               ret = claves[i].ubicacion;
+                               ret = claves[i].dato;
                                free(nodo);
                                return ret;
                } else {
@@ -113,14 +111,15 @@ int emufs_indice_b_buscar(INDICE *idx, CLAVE clave)
                        if (i == 0) {
                                nodo = b_leer_nodo(idx, header.hijo_izquierdo);
                        } else {
-                               nodo = b_leer_nodo(idx, claves[i-1].ubicacion);
+                               nodo = b_leer_nodo(idx, claves[i-1].hijo_derecho);
                        }
                        free(tmp);
                }
        }
 
        /* Nodo no encontrado */
-       return -1;
+       ret.id = ret.bloque = -1;
+       return ret;
 }
 
 static int b_ultimo_id(INDICE *idx)
@@ -230,7 +229,7 @@ static B_NodoEntry *b_leer_claves(char *src, B_NodoHeader *header)
        return (B_NodoEntry *)(src+sizeof(B_NodoHeader));
 }
 
-static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo_id, char *nodo, int hijo1, int hijo2)
+static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, int nodo_id, char *nodo, int hijo1, int hijo2)
 {
        char *padre, *nuevo;
        int nuevo_id;
@@ -262,7 +261,9 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo
                                i++;
                        }
                        tmp_claves[i].clave = clave;
-                       tmp_claves[i].ubicacion = ubicacion;
+                       tmp_claves[i].dato = dato;
+                       tmp_claves[i].hijo_derecho = hijo1;
+                       tmp_claves[i+1].hijo_derecho = hijo2;
                        while (i < nodo_header.cant) {
                                tmp_claves[i+1] = claves[i];
                                i++;
@@ -289,7 +290,7 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo
 
                        if (nodo_id != 0) {
                                clave = tmp_claves[total/2].clave;
-                               ubicacion = nuevo_id;
+                               /* XXX dato.bloque = nuevo_id; */
 
                                b_grabar_nodo(idx, nodo_id, nodo);
                                b_grabar_nodo(idx, nuevo_id, nuevo);
@@ -312,7 +313,7 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo
                                nodo = tmp_nuevo;
        
                                clave = tmp_claves[total/2].clave;
-                               ubicacion = nuevo_id;
+                               /* XXX dato.bloque = nuevo_id; */
 
                                b_grabar_nodo(idx, nuevo_id+1, nodo);
                                b_grabar_nodo(idx, nuevo_id, nuevo);
@@ -349,7 +350,8 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, int ubicacion, int nodo
                        }
                        nodo_header.cant++;
                        claves[i].clave = clave;
-                       claves[i].ubicacion = ubicacion;
+                       claves[i].dato = dato;
+                       claves[i].hijo_derecho = hijo2;
                        nodo_header.hijo_izquierdo = b_elegir_izquierdo(idx, nodo_header.hijo_izquierdo, hijo1);
 
                        b_actualizar_header(nodo, &nodo_header);
@@ -410,3 +412,15 @@ const int b_elegir_izquierdo(INDICE *idx, int a, int b)
        return cual;
 }
 
+INDICE_DATO *emufs_indice_b_buscar_muchos(INDICE *idx, CLAVE clave, int *cant)
+{
+       /* Si el indice es primario no tiene sentido hacer nada */
+       if (idx->funcion == IND_PRIMARIO) {
+               *cant = 0;
+               return NULL;
+       }
+
+       /* TODO Implementar indices con repeticion */
+       return NULL;
+}
+