X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/65ec965b32ea1300412887755a368c2e62a16be8..644f5b4e0e4f92a88f1d9bd31272cac612cd480f:/emufs/indice_bplus.c?ds=inline

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index c693803..a1c0e0a 100644
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -1,4 +1,6 @@
 /** Arbol B+ */
+#include "tipo1.h"
+#include "tipo3.h"
 #include "indices.h"
 #include "indice_bplus.h"
 
@@ -75,7 +77,7 @@ int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
 	/* 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_clave ) 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);			
@@ -91,7 +93,7 @@ int emufs_b_plus_get_bloque(INDICE *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_clave ) 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);
@@ -237,7 +239,7 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
 		/* 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 && query->clave.i_clave < nodo->claves[i].i_clave ){
+        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--;
@@ -247,14 +249,15 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
         nodo->cant_claves++;
         b_plus_grabar_nodo(idx, nodo, num_nodo);
     } else { 
-        while ( i >= 0 && query->clave.i_clave < nodo->claves[i].i_clave ) 
+        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(CLAVE) ) {
             b_plus_split_child(idx, num_nodo, nodo, i, hijo);
-            if ( query->clave.i_clave > nodo->claves[i].i_clave )
+			/* 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);
@@ -306,7 +309,7 @@ int b_plus_existe_clave(INDICE *idx, INDEX_DAT *query, int num_node)
 	/* 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 && query->clave.i_clave != nodo->claves[i].i_clave ) i--;
+		while ( i >= 0 && !emufs_indice_es_igual(idx,query->clave,nodo->claves[i])) i--;
 		if (i < 0)
 		{
 			b_plus_destruir_nodo(nodo);
@@ -320,7 +323,7 @@ int b_plus_existe_clave(INDICE *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_clave ) 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);
@@ -341,17 +344,18 @@ int b_plus_cant_claves_nodo(INDICE *idx, int num_node)
 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);		
+	NODO_B_PLUS *child = NULL;
+	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 && key.i_clave < nodo->claves[i].i_clave ) --i;		
+		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 (nodo->claves[i].i_clave == key.i_clave)	{
+						if (emufs_indice_es_igual(idx,nodo->claves[i],key))	{
 							prepostkey->clave = nodo->claves[i-1];
 							prepostkey->num_bloque = nodo->hijos[i-1];
 						} else {
@@ -362,9 +366,9 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
 					}
 					break;					
 			/* Busco sucesor en la hoja */								
-			case 1: if ((nodo->claves[i].i_clave == key.i_clave) && (i == nodo->cant_claves-1)) exitcode = 0;
+			case 1: if (i == nodo->cant_claves-1) exitcode = 0;
 				 	else {												
-						prepostkey->clave = nodo->claves[i+1];
+						prepostkey->clave = nodo->claves[i+1];						
 						prepostkey->num_bloque = nodo->hijos[i+1];
 						exitcode = 1;
 					}
@@ -372,7 +376,7 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
 		}																
 	} else {
 		/* Veo por que rama debo seguir buscando el pre o post */
-		while ( i >= 0 && key.i_clave < nodo->claves[i].i_clave ) --i;		
+		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 {
@@ -384,12 +388,15 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
 			/* Handleo busqueda de clave menor o igual que todas */
 			if (exitcode == 0) exitcode = -1;
 		} else  {
-			/* Busco un sucesor, y funciona como getbloque... */			
+			/* Busco un sucesor como get bloque */			
 			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 (exitcode == 0) 
+			{
 				if (i < nodo->cant_claves-1) {
-					prepostkey->clave = nodo->claves[i+1];
+					child = b_plus_leer_nodo(idx,nodo->hijos[i+2]);					
+					prepostkey->clave = child->claves[0];
+					prepostkey->num_bloque = child->hijos[0];
 					exitcode = 1;
 				} else 	exitcode = -1;
 			}
@@ -418,7 +425,7 @@ int emufs_b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query, int n
 		i = nodo->cant_claves - 1;
 		
 		/* Busco la clave y reemplazo */
-		while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
+		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 */
@@ -440,8 +447,9 @@ 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;
+	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;
@@ -449,7 +457,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 	/* 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 && key.i_clave != nodo->claves[i].i_clave ) --i;
+		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) {
@@ -465,12 +473,12 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 		return 0;
 	} else {
 		/* Me debo fijar si esta la clave en este nodo interno, sino busco */		
-		while ( i >= 0 && key.i_clave != nodo->claves[i].i_clave ) --i;
+		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 && key.i_clave < nodo->claves[i].i_clave ) --i;
+			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]);
@@ -505,7 +513,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 					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);
+					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]);
 				}
@@ -549,9 +557,52 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 						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");
-					}
-			}
+						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]);
@@ -611,6 +662,7 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 						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);
 					}										
 				}
 			}
@@ -635,3 +687,99 @@ int b_plus_get_num_nodo(INDICE *idx)
     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);	
+		printf ("\nLa primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0]);						
+	} 
+	else {
+		/* Veo si ya devolvi la ultima */
+		if (idx->keybucket->current_key == idx->keybucket->cant_keys) {			
+			/* Debo obtener un nuevo bucket de claves */		
+			if (b_plus_buscar_prepost(idx,idx->keybucket->claves[0],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);	
+				printf ("\nLa primera clave del bucket que devuelvo es: %i\n",idx->keybucket->claves[0]);										
+				
+			}
+			else return key;
+		}
+	}
+		
+	/* Devuelvo el siguiente elemento del array */
+	if (idx->keybucket->current_key < idx->keybucket->cant_keys) {
+		i = idx->keybucket->current_key;
+		idx->keybucket->current_key++;		
+		return (idx->keybucket->claves[i]);
+	}
+	else return key;
+}