X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/a29c2ba26fc37a7a01e916911f0a77cc9ccd02c5..4966fd10d0744e37a60255a9e53da3ddb7399e75:/emufs/indice_bplus.c

diff --git a/emufs/indice_bplus.c b/emufs/indice_bplus.c
index 06d3ee1..036d4cc 100644
--- a/emufs/indice_bplus.c
+++ b/emufs/indice_bplus.c
@@ -79,7 +79,7 @@ int emufs_b_plus_get_bloque(INDICE *idx, INDEX_DAT *query, int num_node) {
 		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 {
@@ -234,9 +234,11 @@ int b_plus_insert_nonfull(INDICE *idx, NODO_B_PLUS *nodo, int num_nodo, INDEX_DA
     
     i = nodo->cant_claves-1; 
     if ( nodo->nivel == 0 ){
+		/* 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 ){
-            nodo->claves[i+1] = nodo->claves[i];
-			nodo->hijos[i+2] = nodo->hijos[i+1];
+            nodo->claves[i+1] = nodo->claves[i];			
 			nodo->hijos[i+1] = nodo->hijos[i];
             i--;
         }
@@ -361,9 +363,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;
-				 	else {						
+				 	else {												
 						prepostkey->clave = nodo->claves[i+1];
-						prepostkey->num_bloque = nodo->hijos[i+i];
+						prepostkey->num_bloque = nodo->hijos[i+1];
 						exitcode = 1;
 					}
 					break;
@@ -399,18 +401,18 @@ int b_plus_buscar_prepost(INDICE *idx, CLAVE key, int num_node, INDEX_DAT *prepo
 	return(exitcode);		
 }
 
-int b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query)
+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;
+	auxquery.clave = key;	
 		
 	/* Comienzo buscando la clave y obteniendo el nodo en donde esta */
-	if (b_plus_existe_clave(idx,&auxquery,0) == 1) {					
+	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);
+		/*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;
@@ -435,10 +437,12 @@ int b_plus_reemplazar_clave(INDICE *idx, CLAVE key, INDEX_DAT query)
 
 int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 {
-	INDEX_DAT prekey;
-	int i = 0,j = 0,minclaves = 0, cant_claves_child = 0;
-	NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);		
-	if (nodo == NULL) return -1;
+	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;
+	NODO_B_PLUS *nodo = b_plus_leer_nodo(idx,num_node);
+	NODO_B_PLUS *node_y,*node_z;
+	if (nodo == NULL) { PERR("No leyo nodo bien"); return -1; }
 	i = nodo->cant_claves - 1;
 	minclaves = ceil(idx->size_hijos/sizeof(CLAVE)/2)-1;
 
@@ -463,30 +467,124 @@ int emufs_b_plus_eliminar(INDICE *idx, CLAVE key, int num_node)
 		/* 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;
 		if (i < 0) {
-			/* No esta en este nodo interno, caso 3 */
+			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;
+        	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 y listo */					
+					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]);
+					} else {
+						/* Caso 3b, debo bajar una clave y unificar con sibling disponible */
+						PERR("Entre caso 3b del eliminar");
+					}
+			}
 		} 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],&prekey,0);
+				b_plus_buscar_prepost(idx,key,nodo->hijos[i],&prepostkey,0);
 				/* La elimino recursivamente */
-				emufs_b_plus_eliminar(idx,prekey.clave,0);
+				emufs_b_plus_eliminar(idx,prepostkey.clave,nodo->hijos[i]); /* CHEAT */
 				/* Remplazo mi clave key por la encontrada prekey */
-				nodo->claves[i] = prekey.clave;
+				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,prekey.clave);*/
-			} else { 				
+				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) {
-					/* Caso 2b */
-					
+					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 {
-					/* Caso 2c */
-				
+					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);
+					}										
 				}
-			}			
-		}		
+			}
+		}			
+		/* Termine caso 2 o 3, libero el nodo */
+		b_plus_destruir_nodo(nodo);
+		return 0;			
 	}
 	
 	return -1;
@@ -500,8 +598,7 @@ int b_plus_get_num_nodo(INDICE *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;
 }