emufs/b_plus.c

   1 /** Arbol B+ */
   2 #include "b_plus.h"
   3
   4 /* Private prototypes */
   5 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node);
   6
   7 /** Crea un nuevo nodo y lo inicializa */
   8 NODO_B_PLUS *emufs_b_plus_crearnodo(INDEXSPECS *idx, int es_hoja) {
   9
  10         NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
  11         nodo->es_hoja = es_hoja;
  12         nodo->nivel = 0;
  13         nodo->cant_claves = 0;
  14
  15     /* Calculamos lo que ocupan las cadenas de bytes claves + hijos */
  16         nodo->claves = (int*)malloc(idx->size_claves);
  17         nodo->hijos = (int*)malloc(idx->size_hijos);
  18         memset(nodo->claves,-1,idx->size_claves);
  19         memset(nodo->hijos,-1,idx->size_hijos);
  20
  21     return nodo;
  22 }
  23
  24 /** Crea el archivo indice B+ */
  25 int emufs_b_plus_crear(INDEXSPECS *idx) {
  26
  27         FILE *fp;
  28         NODO_B_PLUS *raiz;
  29
  30         /* Creamos el archivo que contendra el indice */
  31         fp = fopen(idx->filename, "w");
  32         PERR("Creando indice");
  33         fprintf(stderr, "Archivo = (%s)\n", idx->filename);
  34         if (fp == NULL) {
  35                 PERR("Error al crear el archivo");
  36                 return -1;
  37         }
  38
  39         /* Creamos el nodo raiz y lo guardamos el en indice */
  40         raiz = emufs_b_plus_crearnodo(idx,1);
  41         fwrite(raiz,SIZE_B_PLUS_HEADER,1,fp);
  42         fwrite(raiz->claves,idx->size_claves,1,fp);
  43         fwrite(raiz->hijos,idx->size_hijos,1,fp);
  44         fclose(fp);
  45
  46         /* Liberamos areas de memoria reservadas */
  47         free(raiz->claves);
  48         free(raiz->hijos);
  49         free(raiz);
  50
  51         return 0;
  52 }
  53
  54 /** Busca el nro de bloque donde se debe guardar un reg con clave X */
  55 int emufs_b_plus_get_bloque(INDEXSPECS *idx, INDEX_DAT *query) {
  56
  57     NODO_B_PLUS *curnode;
  58
  59         /* Comienzo leyendo la raiz, entry point de toda funcion */
  60         printf ("Buscando donde insertar clave: %i\n",query->clave.i_clave);
  61         curnode = b_plus_leer_nodo(idx,0);
  62         if (curnode == NULL) return -1;
  63
  64         /* Mientras no encontre la hoja con la clave, busco.. */
  65         while ((curnode->es_hoja == 0) && curnode)
  66         {
  67
  68         }
  69
  70         return 0;
  71 }
  72
  73 NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node) {
  74
  75         int i = 0;
  76         FILE *fp;
  77         NODO_B_PLUS *memnode = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
  78         char *disknode = (char*)malloc(sizeof(idx->tam_bloque));
  79
  80         if (disknode == NULL) return NULL;
  81         if (memnode == NULL) return NULL;
  82
  83     /* Open up file */
  84         fp = fopen(idx->filename, "r");
  85         if (fp == NULL) {
  86                 free(disknode);
  87                 free(memnode);
  88                 return NULL;
  89         }
  90
  91         /* Intentamos leer un nodo, sino podemos error! */
  92         fseek(fp, num_node*idx->tam_bloque, SEEK_SET);
  93         if (fread(disknode, idx->tam_bloque, 1, fp) != 1) {
  94                 free(disknode);
  95                 fclose(fp);
  96                 return NULL;
  97         }
  98         fclose(fp);
  99
 100         /* Pudimos leer un nodo de disco, ahora lo transformamos a nodo mem */
 101         memcpy(memnode,disknode,SIZE_B_PLUS_HEADER);
 102         memcpy(memnode->claves,disknode+SIZE_B_PLUS_HEADER,idx->size_claves);
 103         memcpy(memnode->hijos,disknode+SIZE_B_PLUS_HEADER,idx->size_hijos);
 104         free(disknode);
 105
 106         printf("Dumping nodo leido...\n");
 107         printf("Nivel: %i  Cant Claves: %i  Es Hoja: %i\n",memnode->nivel,memnode->cant_claves,memnode->es_hoja);
 108         printf("Claves:");
 109         for (i = 0; i < idx->size_claves/sizeof(int); ++i) printf(" %i",memnode->claves[i]);
 110         printf("\nHijos:");
 111         for (i = 0; i < idx->size_hijos/sizeof(int); ++i) printf(" %i",memnode->hijos[i]);
 112         printf("\nEnd Dump\n");
 113
 114         return memnode;
 115
 116 }