X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/84522123b3e93279cdb2bebd54a134dce2cacd1f..c52c97783d6e747849a0f3dbef223c18fcff99a8:/emufs/indice_bplus.c?ds=sidebyside

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index a30058b..bdbbce0 100644
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -1,19 +1,22 @@
 /** Arbol B+ */
-#include "b_plus.h"
+#include "tipo1.h"
+#include "tipo3.h"
+#include "indices.h"
+#include "indice_bplus.h"
 
 /**#*#*#*#*#**#*#*#*#*#* Private prototypes*#*#*#*#*#**#*#*#*#*#**#*#*#*/
-int b_plus_grabar_nodo(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_node);
-NODO_B_PLUS *b_plus_leer_nodo(INDEXSPECS *idx, int num_node);
-NODO_B_PLUS *b_plus_crearnodo(INDEXSPECS *idx);
+int b_plus_grabar_nodo(INDICE *idx, NODO_B_PLUS *nodo, int num_node);
+NODO_B_PLUS *b_plus_leer_nodo(INDICE *idx, int num_node);
+NODO_B_PLUS *b_plus_crearnodo(INDICE *idx);
 int b_plus_destruir_nodo(NODO_B_PLUS *nodo);
-int b_plus_split_child(INDEXSPECS *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode);
-int b_plus_insert_nonfull(INDEXSPECS *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query);
-int b_plus_insertar(INDEXSPECS *idx, INDEX_DAT *query);
-int b_plus_get_num_nodo(INDEXSPECS *idx);
+int b_plus_split_child(INDICE *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode);
+int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query);
+int b_plus_insertar(INDICE *idx, INDEX_DAT *query);
+int b_plus_get_num_nodo(INDICE *idx);
 /**#*#*#*#*#**#*#*#*#*#*FIN PROTOTYPES*#*#*#*#*#**#*#*#*#*#**#*#*#*#*#*/
 
 /** Crea un nuevo nodo y lo inicializa */
-NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) {
+NODO_B_PLUS *b_plus_crearnodo(INDICE *idx) {
 	
 	NODO_B_PLUS *nodo = (NODO_B_PLUS*)malloc(sizeof(NODO_B_PLUS));
 	if (nodo == NULL) return NULL;
@@ -21,16 +24,16 @@ NODO_B_PLUS *b_plus_crearnodo(INDEX *idx) {
 	nodo->cant_claves = 0;
 
     /* Calculamos lo que ocupan las cadenas de bytes claves + hijos */
-	nodo->claves = (int*)malloc(idx->size_claves);
+	nodo->claves = (CLAVE*)malloc(idx->size_claves);
 	nodo->hijos = (int*)malloc(idx->size_hijos);
 	memset(nodo->claves,-1,idx->size_claves);
 	memset(nodo->hijos,-1,idx->size_hijos);
 	
-    return nodo;	
+    return nodo;
 }
 
 /** Crea el archivo indice B+ */
-int emufs_b_plus_crear(INDEXSPECS *idx) {
+int emufs_b_plus_crear(INDICE *idx) {
 	
 	FILE *fp;
 	NODO_B_PLUS *raiz;
@@ -63,22 +66,22 @@ int emufs_b_plus_crear(INDEXSPECS *idx) {
  *                 return -1 - No hay clave, inserto clave de nuevo bloques
  *                 return 1 - Hubo falla de lectura de un nodo, Abortar
  */
-int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
+int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
 
+	int i,exitcode = 0;
 	NODO_B_PLUS *nodo;
 	nodo = b_plus_leer_nodo(idx,num_node);
 	if (nodo == NULL) return 1;
-	int i = nodo->cant_claves - 1;
-	int exitcode = 0;
-	
+	i = nodo->cant_claves - 1;
+		
 	/* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
 	if (nodo->nivel == 0) {
         /* Vemos en que bloque deberia ir */
-		while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) i--;
+		while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
 		if (i < 0) {
 			/* La clave es menor que todas, debo insertarla */
 			b_plus_destruir_nodo(nodo);			
-			emufs_b_plus_insertar(idx,query);			
+			/*emufs_b_plus_insertar(idx,query);	*/
 			return -1;
 		}
 		else {
@@ -90,7 +93,7 @@ int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
 	}
 	else {
 		/* Buscamos por donde descender al siguiente nivel */
-		while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) i--;
+		while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
         i++;
         num_node = nodo->hijos[i];
 		b_plus_destruir_nodo(nodo);
@@ -99,7 +102,7 @@ int emufs_b_plus_get_bloque(INDEX *idx, INDEX_DAT *query, int num_node) {
 	}
 }
 
-NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
+NODO_B_PLUS *b_plus_leer_nodo(INDICE *idx, int num_node) {
 
 	/*int i = 0;*/
 	FILE *fp;
@@ -139,7 +142,7 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
 	/*printf("Dumping Node_%i\n",num_node);
 	printf("Nivel: %i  Cant Claves: %i\n",memnode->nivel,memnode->cant_claves);
 	printf("Claves:");
-	for (i = 0; i < idx->size_claves/sizeof(int); ++i) printf(" %i",memnode->claves[i]);
+	for (i = 0; i < idx->size_claves/sizeof(CLAVE); ++i) printf(" %i",memnode->claves[i].i_clave);
 	printf("\nHijos:");
 	for (i = 0; i < idx->size_hijos/sizeof(int); ++i) printf(" %i",memnode->hijos[i]);
 	printf("\nEnd Dump\n");	*/
@@ -148,7 +151,7 @@ NODO_B_PLUS *b_plus_leer_nodo(INDEX *idx, int num_node) {
 	
 }
 
-int b_plus_grabar_nodo(INDEX *idx, NODO_B_PLUS *nodo, int num_node)
+int b_plus_grabar_nodo(INDICE *idx, NODO_B_PLUS *nodo, int num_node)
 {
 	FILE *fp;
 	
@@ -172,10 +175,10 @@ int b_plus_destruir_nodo(NODO_B_PLUS *nodo)
 	return 0;
 }
 
-int b_plus_split_child(INDEX *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode)
+int b_plus_split_child(INDICE *idx, int numparent, NODO_B_PLUS *parent, int ithchild, NODO_B_PLUS *fullnode)
 {
 	/* locals */
-	int minclaves = ceil(idx->size_hijos/sizeof(int)/2)-1;
+	int minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1;
 	int numbrother,j = 0;
 	int es_interno = 1;
 	
@@ -226,32 +229,35 @@ int b_plus_split_child(INDEX *idx, int numparent, NODO_B_PLUS *parent, int ithch
 }
 
 
-int b_plus_insert_nonfull(INDEX *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query)
+int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT *query)
 {
     int i, num_nodo_hijo;
     NODO_B_PLUS *hijo;
     
     i = nodo->cant_claves-1; 
     if ( nodo->nivel == 0 ){
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ){
-            nodo->claves[i+1] = nodo->claves[i];
-			nodo->hijos[i+2] = nodo->hijos[i+1];
+		/* Muevo siempre el encadenamiento */
+		nodo->hijos[i+2] = nodo->hijos[i+1];
+		/* Ahora muevo las claves y sus punteros a bloques del dat */
+        while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])){
+            nodo->claves[i+1] = nodo->claves[i];			
 			nodo->hijos[i+1] = nodo->hijos[i];
             i--;
         }
-        nodo->claves[i+1] = query->clave.i_clave;
+        nodo->claves[i+1] = query->clave;
 		nodo->hijos[i+1] = query->num_bloque;
         nodo->cant_claves++;
         b_plus_grabar_nodo(idx, nodo, num_nodo);
     } else { 
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i] ) 
+        while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) 
             i--;
         i++;
         num_nodo_hijo = nodo->hijos[i];
         hijo = b_plus_leer_nodo(idx, num_nodo_hijo);
-        if ( hijo->cant_claves == idx->size_claves/sizeof(int) ) {
+        if ( hijo->cant_claves == idx->size_claves/sizeof(CLAVE) ) {
             b_plus_split_child(idx, num_nodo, nodo, i, hijo);
-            if ( query->clave.i_clave > nodo->claves[i] )
+			/* OjO Utilizo el menor pero con el proposito de clave > nodo->clave) */
+            if (emufs_indice_es_menor(idx,nodo->claves[i],query->clave))
                 i++;
         }
 		if (hijo) b_plus_destruir_nodo(hijo);
@@ -263,12 +269,12 @@ int b_plus_insert_nonfull(INDEX *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DAT
 	return 0;
 }    
 
-int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query)
+int emufs_b_plus_insertar(INDICE *idx, INDEX_DAT *query)
 {
     NODO_B_PLUS *raiz;
     
     raiz = b_plus_leer_nodo(idx, 0);
-    if ( raiz->cant_claves == idx->size_claves/sizeof(int) ) {
+    if ( raiz->cant_claves == idx->size_claves/sizeof(CLAVE) ) {
         NODO_B_PLUS *new_root = b_plus_crearnodo(idx);
         new_root->nivel = raiz->nivel + 1;
         new_root->hijos[0] = b_plus_get_num_nodo(idx);
@@ -287,7 +293,385 @@ int emufs_b_plus_insertar(INDEX *idx, INDEX_DAT *query)
     return 0;
 }
 
-int b_plus_get_num_nodo(INDEX *idx)
+/** Busca una clave dentro del arbol e indica si existe o no
+ *  Posibilidades: return 1 - Encontro la clave
+ *                 return 0 - No encontro la clave
+ *                 return -1 - Hubo falla de lectura de un nodo, Abortar
+ */
+int b_plus_existe_clave(INDICE *idx, INDEX_DAT *query, int num_node)
+{
+	int i,exitcode = 0;
+	NODO_B_PLUS *nodo;
+	nodo = b_plus_leer_nodo(idx,num_node);
+	if (nodo == NULL) return -1;
+	i = nodo->cant_claves - 1;
+		
+	/* Si es un hoja, busco dentro de la hoja, otherwise, busco la hoja */
+	if (nodo->nivel == 0) {
+        /* Vemos si esta la clave */
+		while ( i >= 0 && !emufs_indice_es_igual(idx,query->clave,nodo->claves[i])) i--;
+		if (i < 0)
+		{
+			b_plus_destruir_nodo(nodo);
+			return 0; /* No encontre la clave */
+		} else 	{
+			/* Encontre la clave, guardo el nodo donde esta! */
+			query->num_bloque = num_node;
+			b_plus_destruir_nodo(nodo);
+			return 1;
+		}
+	}
+	else {
+		/* Buscamos por donde descender al siguiente nivel */
+		while ( i >= 0 && emufs_indice_es_menor(idx,query->clave,nodo->claves[i])) i--;
+        i++;
+        num_node = nodo->hijos[i];
+		b_plus_destruir_nodo(nodo);
+		exitcode = b_plus_existe_clave(idx,query,num_node);
+		return exitcode;
+	}
+}
+
+int b_plus_cant_claves_nodo(INDICE *idx, int num_node)
+{
+	NODO_B_PLUS *nodo =	b_plus_leer_nodo(idx,num_node);
+	if (nodo == NULL) return -1;
+	return nodo->cant_claves;
+}
+
+/* Search_Type: 0 - Predecesor, 1 - Sucesor
+   Exitcode: 1 - Encontre lo buscado, 0 - No lo encontre, -1 Error */
+int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepostkey, int search_type)
+{
+	int i = 0, exitcode = 0;
+	NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);		
+	if (nodo == NULL) return -1;
+	i = nodo->cant_claves - 1;
+	
+	if (nodo->nivel == 0) {		
+		while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;		
+		switch (search_type) {			
+			/* Busco predecesor en la hoja */			
+			case 0: if (i <= 0) exitcode = 0;
+					else {						
+						if (emufs_indice_es_igual(idx,nodo->claves[i],key))	{
+							prepostkey->clave = nodo->claves[i-1];
+							prepostkey->num_bloque = nodo->hijos[i-1];
+						} else {
+							prepostkey->clave = nodo->claves[i];
+							prepostkey->num_bloque = nodo->hijos[i];
+						}
+						exitcode = 1;
+					}
+					break;					
+			/* Busco sucesor en la hoja */								
+			case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;
+				 	else {												
+						prepostkey->clave = nodo->claves[i+1];
+						prepostkey->num_bloque = nodo->hijos[i+1];
+						exitcode = 1;
+					}
+					break;
+		}																
+	} else {
+		/* Veo por que rama debo seguir buscando el pre o post */
+		while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;		
+		if (search_type == 0) {
+			if (i < 0) exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
+			else {
+				/* Busco primero por la rama derecha, sino por la izquierda */
+				exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
+				if (exitcode == 0) 			
+					exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i],prepostkey,search_type);
+			}
+			/* Handleo busqueda de clave menor o igual que todas */
+			if (exitcode == 0) exitcode = -1;
+		} else  {
+			/* Busco un sucesor, y funciona como getbloque... */			
+			exitcode = b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],prepostkey,search_type);
+			/* Veo si tengo que devolver la clave izquierda del padre del que acabo de buscar */
+			if (exitcode == 0) {
+				if (i < nodo->cant_claves-1) {
+					prepostkey->clave = nodo->claves[i+1];
+					exitcode = 1;
+				} else 	exitcode = -1;
+			}
+		}		
+	}
+	
+	/* Libero y devuelvo exitcode */
+	b_plus_destruir_nodo(nodo);
+	return(exitcode);		
+}
+
+int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int num_node)
+{
+	NODO_B_PLUS *nodo;
+	int i;
+	INDEX_DAT auxquery;
+	auxquery.clave = key;	
+		
+	/* Comienzo buscando la clave y obteniendo el nodo en donde esta */
+	if (b_plus_existe_clave(idx,&auxquery,num_node) == 1) {					
+		
+		/* Levanto el nodo y busco donde esta la clave */		
+		/*printf("El reemplazar encontro la clave %i y en el nodo %i\n",auxquery.clave.i_clave,(int)auxquery.num_bloque);*/
+		nodo = b_plus_leer_nodo(idx,auxquery.num_bloque);
+		if (nodo == NULL) return -1;
+		i = nodo->cant_claves - 1;
+		
+		/* Busco la clave y reemplazo */
+		while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
+		if (i < 0) return -1; /* Error, no esta la clave */
+		
+		/* Cheque por las dudas si es hoja o interno, aunque deberia ser hoja */
+		if (nodo->nivel > 0) {			
+			nodo->claves[i] = query.clave;
+		} else {
+			nodo->claves[i] = query.clave;
+			nodo->hijos[i] = query.num_bloque;
+		}
+		b_plus_grabar_nodo(idx,nodo,auxquery.num_bloque);
+		b_plus_destruir_nodo(nodo);
+		return 0;
+	}
+	else return -1;
+}
+
+int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
+{
+	INDEX_DAT prepostkey;
+	int i = 0,j = 0,minclaves = 0, nivel_mayor1 = 0,cant_claves_child = 0;
+	int cant_claves_rsibling = 0, cant_claves_lsibling = 0, es_hoja = 0;
+	int leftoffset = 0;
+	NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
+	NODO_B_PLUS *node_y,*node_z,*mergenode,*siblingnode;
+	if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }
+	i = nodo->cant_claves - 1;
+	minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1;
+
+	/* Si es hoja, borro directamente la clave. No se producira underflow
+       pues lo asegura la recursividad del delete */	
+	if (nodo->nivel == 0) {		
+		while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
+		if (i < 0) return -1;
+		/* Encontre la clave en la pos i, la borro */
+		for (j = i; j < nodo->cant_claves-1; ++j) {
+			nodo->claves[j] = nodo->claves[j+1];
+			nodo->hijos[j] = nodo->hijos[j+1];
+		}
+		nodo->hijos[j] = nodo->hijos[j+1];
+        nodo->cant_claves--;
+		
+		/* Grabo el nodo actualizado en disco */
+		b_plus_grabar_nodo(idx,nodo,num_node);
+		b_plus_destruir_nodo(nodo);
+		return 0;
+	} else {
+		/* Me debo fijar si esta la clave en este nodo interno, sino busco */		
+		while ( i >= 0 && !emufs_indice_es_igual(idx,key,nodo->claves[i])) --i;
+		if (i < 0) {
+			PERR("Entre caso 3 del eliminar");				
+			/* No esta en este nodo interno, caso 3. Determino en que rama debe estar */
+			i = nodo->cant_claves - 1;
+			while ( i >= 0 && emufs_indice_es_menor(idx,key,nodo->claves[i])) --i;
+        	i++;
+        	cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]);
+			if (cant_claves_child > minclaves) emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
+			else {
+				/* Vemos si estamos en caso 3a o 3b, mirando cant_claves de sus siblings */
+				if (i < nodo->cant_claves) cant_claves_rsibling = b_plus_cant_claves_nodo(idx,nodo->hijos[i+1]);
+				if (i > 0) cant_claves_lsibling = b_plus_cant_claves_nodo(idx,nodo->hijos[i-1]);
+				printf ("El sibling derecho si existe tiene %i claves\n", cant_claves_rsibling);
+				printf ("El sibling izquierdo si existe tiene %i claves\n", cant_claves_lsibling);	
+				if (cant_claves_rsibling > minclaves) {
+					/* El sibling derecho me dara una key mediante rotacion. Caso 3a */
+					PERR("Entre caso 3a right sibling del eliminar");
+					node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
+					node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
+					if (node_z->nivel == 0) es_hoja = 1;
+					/* Le bajo la del padre a NodeY y muevo el apropiado child de NodoZ a NodoY */
+					node_y->claves[cant_claves_child] = nodo->claves[i];
+					node_y->hijos[cant_claves_child+1] = node_y->hijos[cant_claves_child];
+					node_y->hijos[cant_claves_child+1-es_hoja] = node_z->hijos[0];
+					node_y->cant_claves++;
+					/* Le subo al padre desde el NodoZ, teniendo en cuenta si es hoja o no */
+					nodo->claves[i] = node_z->claves[es_hoja];
+					/* Hago shifting en el sibling para quitar la que subio */
+					for (j = 0; j < node_z->cant_claves-1; ++j) {
+						node_z->claves[j] = node_z->claves[j+1];
+						node_z->hijos[j] = node_z->hijos[j+1];
+					}
+					node_z->hijos[j] = node_z->hijos[j+1];
+        			node_z->cant_claves--;
+					/* Grabo los cambios */					
+					b_plus_grabar_nodo(idx,node_z,nodo->hijos[i+1]);
+					b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]);
+					b_plus_grabar_nodo(idx,nodo,num_node);
+					b_plus_destruir_nodo(node_y);
+					b_plus_destruir_nodo(node_z);					
+					/* Borro recursivamente KEY entrando por Child que ahora tiene minclaves+1 */
+					emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);
+				}
+				else if (cant_claves_lsibling > minclaves) {
+						/* el sibling izquierdo me dara una key mediante rotacion Caso 3a */
+						PERR("Entre caso 3a left sibling del eliminar");
+						node_z = b_plus_leer_nodo(idx,nodo->hijos[i]);	
+						node_y = b_plus_leer_nodo(idx,nodo->hijos[i-1]);					
+						if (node_z->nivel == 0) es_hoja = 1;
+					    /* Hago lugar en NodoZ para la clave que bajara desde el padre */						
+						/* Muevo el ultimo y restantes claves/punteros */
+						j = node_z->cant_claves - 1;												
+						node_z->hijos[j+2] = node_z->hijos[j+1];
+        				while (j >= 0){
+            				node_z->claves[j+1] = node_z->claves[j];			
+							node_z->hijos[j+1] = node_z->hijos[j];
+            				j--;
+        				}						
+						/* Hago la rotacion final segun sea hoja o no */
+						if (es_hoja) {
+							nodo->claves[i-1] = node_y->claves[cant_claves_lsibling-1];
+							node_z->claves[0] = node_y->claves[cant_claves_lsibling-1];
+							node_z->hijos[0] = node_y->hijos[cant_claves_lsibling-1];
+							node_y->hijos[cant_claves_lsibling-1] = node_y->hijos[cant_claves_lsibling]; /* cadena */
+							node_y->cant_claves--;
+							node_z->cant_claves++;
+						} else {
+							node_z->claves[0] = nodo->claves[i-1];
+							node_z->hijos[0] = node_y->hijos[cant_claves_lsibling];
+							nodo->claves[i-1] = node_y->claves[cant_claves_lsibling-1];
+							node_y->cant_claves--;
+							node_z->cant_claves++;
+						}
+						/* Grabo los cambios */						
+						b_plus_grabar_nodo(idx,node_y,nodo->hijos[i-1]);
+						b_plus_grabar_nodo(idx,node_z,nodo->hijos[i]);
+						b_plus_grabar_nodo(idx,nodo,num_node);
+						b_plus_destruir_nodo(node_y);
+						b_plus_destruir_nodo(node_z);					
+						/* Borro recursivamente KEY entrando por Child que ahora tiene minclaves+1 */
+						emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);						
+					} else {
+						/* Caso 3b, debo bajar una clave y unificar con sibling disponible */
+						PERR("Entre caso 3b del eliminar");						
+						if (cant_claves_lsibling == minclaves) {
+							PERR("Hago merge con sibling izquierdo");
+							leftoffset = 1;
+							siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i]);	/* Este es el root de la rama! */
+							mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-1]); /* Aca va todo */
+						} else {
+							PERR("Hago merge con sibling derecho");
+							leftoffset = 0;
+							mergenode = b_plus_leer_nodo(idx,nodo->hijos[i]);
+							siblingnode = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
+						}
+						
+						/* Bajo una clave del Padre Nodo a MergeNode y muevo todo lo SiblingNode a MergeNode */
+						/* Si es nivel mayor a 1, bajo clave, otherwise no bajo pues se repetiria */
+						nivel_mayor1 = 0;
+						if (nodo->nivel > 1) {
+							nivel_mayor1 = 1;
+							mergenode->claves[minclaves] = nodo->claves[i-leftoffset];							
+						}		
+						for (j = 0; j < minclaves; ++j) mergenode->claves[j+minclaves+nivel_mayor1] = siblingnode->claves[j];
+						for (j = 0; j < minclaves+1; ++j) mergenode->hijos[j+minclaves+nivel_mayor1] = siblingnode->hijos[j];
+						mergenode->cant_claves = minclaves*2+nivel_mayor1;					
+						
+						/* Shifteo en el nodo padre NODO, para quitar la que bajo */
+						for (j = i-leftoffset; j < nodo->cant_claves-1; ++j) {
+							nodo->claves[j] = nodo->claves[j+1];
+							nodo->hijos[j+1] = nodo->hijos[j+2];
+						}
+						nodo->cant_claves--;
+						b_plus_grabar_nodo(idx,nodo,num_node);
+						b_plus_grabar_nodo(idx,mergenode,nodo->hijos[i-leftoffset]);																		
+						b_plus_destruir_nodo(mergenode);
+						b_plus_destruir_nodo(siblingnode);					
+						/* Elimino recursivamente Key de la rama apropiada segun el Merge que se hizo */
+						emufs_b_plus_eliminar(idx,key,nodo->hijos[i-leftoffset]);
+						/* Caso muy particular, si hize un merge de la unica clave de una raiz con sus hijos */
+						if ((nodo->nivel == 1) && (nodo->cant_claves == 0)) {
+							/* Debo establecer como nueva raiz, el NodoY */
+							mergenode = b_plus_leer_nodo(idx,nodo->hijos[i-leftoffset]);
+							b_plus_grabar_nodo(idx,mergenode,0);
+							truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
+						}
+						/* End 3b */						
+						}
+					}			
+		} else {
+			/* Esta en el nodo interno, caso 2 */
+			cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i]);
+			if (cant_claves_child > minclaves) {
+				PERR("Entre caso 2a del eliminar");				
+				/* Caso 2a, comienzo buscando la clave previa inmediata */
+				b_plus_buscar_prepost(idx,key,nodo->hijos[i],&prepostkey,0);
+				/* La elimino recursivamente */
+				emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i]); /* CHEAT */
+				/* Remplazo mi clave key por la encontrada prekey */
+				nodo->claves[i] = prepostkey.clave;
+				b_plus_grabar_nodo(idx,nodo,num_node);
+				/* Remplazo la otra instancia de key en una hoja seguro por prekey */
+				emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]);
+			} else { 
+				cant_claves_child = b_plus_cant_claves_nodo(idx,nodo->hijos[i+1]);
+				if (cant_claves_child > minclaves) {
+					PERR("Entre caso 2b del eliminar");
+					/* Caso 2b, comienzo buscando la clave sucesor inmediata */
+					b_plus_buscar_prepost(idx,key,nodo->hijos[i+1],&prepostkey,1);					
+					/* La elimino recursivamente */
+					emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i+1]); /* CHEAT */
+					/* Remplazo mi clave key por la encontrada postkey */
+					nodo->claves[i] = prepostkey.clave;
+					b_plus_grabar_nodo(idx,nodo,num_node);
+					/* Remplazo la otra instancia de key en una hoja seguro por postkey */
+					emufs_b_plus_reemplazar_clave(idx,key,prepostkey,nodo->hijos[i+1]);					
+				} else {
+					PERR("Entre caso 2c del eliminar");
+					/* Caso 2c debo hacer un merge de la clave con hijo izq y der */
+					node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
+					node_z = b_plus_leer_nodo(idx,nodo->hijos[i+1]);
+					/* Bajo la clave Key a NodoY y muevo todo lo de NodoZ a NodoY */
+					/* Si es nivel mayor a 1, bajo clave pues no esta en NodoZ, otherwise no bajo */
+					if (nodo->nivel > 1) {
+						nivel_mayor1 = 1;
+						node_y->claves[minclaves] = key;
+					}		
+					for (j = 0; j < minclaves; ++j) node_y->claves[j+minclaves+nivel_mayor1] = node_z->claves[j];
+					for (j = 0; j < minclaves+1; ++j) node_y->hijos[j+minclaves+nivel_mayor1] = node_z->hijos[j];
+					node_y->cant_claves = minclaves*2+nivel_mayor1;					
+					/* Shifteo en el nodo padre NODO, para quitar la que bajo */
+					for (j = i; j < nodo->cant_claves-1; ++j) {
+						nodo->claves[j] = nodo->claves[j+1];
+						nodo->hijos[j+1] = nodo->hijos[j+2];
+					}
+					nodo->cant_claves--;
+					b_plus_grabar_nodo(idx,nodo,num_node);
+					b_plus_grabar_nodo(idx,node_y,nodo->hijos[i]);
+					b_plus_destruir_nodo(node_y);
+					b_plus_destruir_nodo(node_z);					
+					/* Elimino recursivamente Key de NodeY, entrando por ese subtree */
+					emufs_b_plus_eliminar(idx,key,nodo->hijos[i]);					
+					/* Caso muy particular, si hize un merge de la unica clave de una raiz con sus hijos */
+					if ((nodo->nivel == 1) && (nodo->cant_claves == 0)) {
+						/* Debo establecer como nueva raiz, el NodoY */
+						node_y = b_plus_leer_nodo(idx,nodo->hijos[i]);
+						b_plus_grabar_nodo(idx,node_y,0);
+						truncate(idx->filename,SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
+						b_plus_destruir_nodo(node_y);
+					}										
+				}
+			}
+		}			
+		/* Termine caso 2 o 3, libero el nodo */
+		b_plus_destruir_nodo(nodo);
+		return 0;			
+	}
+	
+	return -1;
+}
+
+int b_plus_get_num_nodo(INDICE *idx)
 {
 	FILE *fp;
 	int num;
@@ -295,8 +679,103 @@ int b_plus_get_num_nodo(INDEX *idx)
 	fp = fopen(idx->filename, "ab");
 	if (fp == NULL) return -1;
     
-    num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);
-	printf("Num Nodo Nuevo: %i\n",num);
+    num = ftell(fp)/(SIZE_B_PLUS_HEADER+idx->size_claves+idx->size_hijos);	
     fclose(fp);
     return num;
 }
+
+CLAVE emufs_b_plus_obtener_menor_clave(INDICE *idx) {
+	
+	CLAVE key;
+	NODO_B_PLUS *node;
+	int num_child = 0;
+	node = b_plus_leer_nodo(idx,0);
+	if (node == NULL) {
+		key.i_clave = -1;
+		return key;
+	}
+	
+	while (node->nivel > 0) {
+		/* Deciendo por la rama de mas hacia la izquierda */		
+		if (node->cant_claves > 0) {
+			num_child = node->hijos[0];
+			b_plus_destruir_nodo(node);			
+			node = b_plus_leer_nodo(idx,num_child);
+		}
+		else break;		
+	}
+	
+	/* Ahora estoy en la primer hoja del arbol, devuelvo la primer clave */
+	key = node->claves[0];
+	b_plus_destruir_nodo(node);
+	
+	return key;
+}
+	  
+CLAVE emufs_b_plus_obtener_mayor_clave(INDICE *idx) {
+	
+	CLAVE key;
+	NODO_B_PLUS *node;
+	int num_child = 0, cant_claves = 0;
+	node = b_plus_leer_nodo(idx,0);
+	if (node == NULL) {
+		key.i_clave = -1;
+		return key;
+	}
+	
+	cant_claves = node->cant_claves;
+	while (node->nivel > 0) {
+		/* Deciendo por la rama de mas hacia la derecha */		
+		if (node->cant_claves > 0) {
+			num_child = node->hijos[cant_claves];
+			b_plus_destruir_nodo(node);			
+			node = b_plus_leer_nodo(idx,num_child);
+			cant_claves = node->cant_claves;
+		}
+		else return key;		
+	}
+	
+	/* Ahora estoy en la primer hoja del arbol, devuelvo la ultima clave */
+	key = node->claves[cant_claves-1];
+	b_plus_destruir_nodo(node);
+	
+	return key;
+}
+
+CLAVE emufs_b_plus_obtener_sig_clave(EMUFS *emu, CLAVE key) {
+	
+	INDICE *idx = emu->indices;
+	INDEX_DAT query;
+	int i = 0;
+	query.clave = key;
+	
+	/* Si aun no tengo un array, obtengo uno */
+	if (emu->indices->keybucket == NULL) {
+		/* Busco el ancla para esta key */
+		emufs_b_plus_get_bloque(idx,&query,0);		
+		idx->keybucket = emufs_tipo3_obtener_claves_raw(emu,query.num_bloque);
+		printf ("\nLevante bloque nro: %li y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys);						
+		return (idx->keybucket->claves[0]);
+	} 
+	else {
+		/* Veo si la ultima clave retornada es la ultima del array */
+		if (idx->keybucket->current_key == idx->keybucket->cant_keys-1) {			
+			/* Debo obtener un nuevo bucket de claves */
+			if (b_plus_buscar_prepost(idx,key,0,&query,1) != -1) {				
+				idx->keybucket = emufs_tipo3_obtener_claves_raw(emu,query.num_bloque);
+				printf ("\nLevante bloque nro: %li y obtuve un bucket con %i keys\n",query.num_bloque,idx->keybucket->cant_keys);				
+			}
+			else return key;
+		}
+	}
+		
+	/* Busco la clave en el array de atras hacia adelante. */
+	if (idx->keybucket->current_key < idx->keybucket->cant_keys-1) {
+		i = idx->keybucket->cant_keys - 1;
+		while (i >= 0 && emufs_indice_es_menor(idx,key,idx->keybucket->claves[i])) --i;
+		++i;
+		idx->keybucket->current_key = i;		
+		return (idx->keybucket->claves[i]);
+	}
+	else return key;
+}