static EMUFS_REG_ID b_insertar_dup_en_pos(INDICE *idx, INDICE_DATO pos, INDICE_DATO nuevo);
+static void abreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header);
+static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header);
+
void emufs_indice_b_crear(INDICE *idx)
{
FILE *fp;
i=0;
while ((i<header.cant) && (emufs_indice_es_menor(idx, claves[i].clave, clave))) i++;
if ((i<header.cant) && (emufs_indice_es_igual(idx, claves[i].clave, clave))) {
- if (idx->tipo == IND_PRIMARIO) {
+ if (idx->funcion == IND_PRIMARIO) {
PERR("Indice primario no puede contener claves duplicadas!");
+ PERR(idx->nombre);
return 0;
}
/* TODO : Implementar carga de valor en clave duplicada! */
b_insertar_dup_en_pos(idx, claves[i].dato, dato);
-
+
+ if (idx->tipo_dato == IDX_STRING) {
+ /* Tengo que sacar el texto repetido del archivo de textos */
+ PERR("Eliminando string duplicado");
+ idx->emu_string->borrar_registro(idx->emu_string, clave);
+ }
return 1;
} else {
if (i == 0) {
nodo = padre;
nodo_id = padre_id;
- if (idx->tipo != IND_PRIMARIO) {
+ if (idx->funcion != IND_PRIMARIO) {
/* Agrego el DATO real al archivo de claves repetiras
* y me guardo el ID para poner en el indice
*/
dummy.id = -1;
dato.id = b_insertar_dup_en_pos(idx, dummy, dato);
- fprintf(stderr, "Agrege un coso duplicado por primera vez en id=%d\n", dato.id);
+ if (dato.id != -1)
+ PERR("NODO INSERTADO EN POS GENERADA NUEVA");
+ PERR("Ahora inserto");
+ fprintf(stderr, "Nombre del coso = %s\n", idx->nombre);
}
b_insertar_en_nodo(idx, clave, dato, nodo_id, nodo, -1, -1);
B_NodoEntry *claves;
char *nodo, *tmp;
- if (idx->tipo != IND_PRIMARIO) {
- /* SOLO SE PUEDE BUSCAR CON CLAVE UNICA! */
- ret.id = ret.bloque = -1;
- return ret;
- }
-
/* Leo la raiz */
nodo = b_leer_nodo(idx, 0);
while (nodo) {
claves = b_leer_claves(nodo, &header);
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)) {
+ if ((i<header.cant) && (emufs_indice_es_igual(idx, claves[i].clave, clave))) {
ret = claves[i].dato;
free(nodo);
return ret;
{
FILE *fp;
char *out;
+ B_NodoHeader header;
+ B_NodoEntry *claves;
if (id < 0) return NULL;
return NULL;
}
+ /* Si estoy manejando string tengo que sacar las abreviaturas */
+ if (idx->tipo_dato == IDX_STRING) {
+ b_leer_header(out, &header);
+ claves = b_leer_claves(out, &header);
+ desabreviar_claves(idx, claves, &header);
+ }
fclose(fp);
return out;
}
static void b_grabar_nodo(INDICE *idx, int id, char *data)
{
FILE *fp;
+ B_NodoHeader header;
+ B_NodoEntry *claves;
-/* if (id > b_ultimo_id()) {
- printf("AGREGANDO AL FINAL\n");
- fp = fopen(FILENAME, "a");
- if (fp == NULL) {
- _("No se pudo abrir archivo\n");
- return;
- }
- } else {
- fp = fopen(FILENAME, "w");
- if (fp == NULL) {
- _("No se pudo abrir archivo\n");
- return;
- }
- fseek(fp, id*BLOCK_SIZE, SEEK_SET);
- printf("SOLO GUARDO DATA\n");
- }*/
-
+ /* Si las claves son de tipo string debo abreviar antes de guardar */
+ if (idx->tipo_dato == IDX_STRING) {
+ b_leer_header(data, &header);
+ claves = b_leer_claves(data, &header);
+ abreviar_claves(idx, claves, &header);
+ }
fp = fopen(idx->filename, "r+");
fseek(fp, id*idx->tam_bloque, SEEK_SET);
fwrite(data, 1, idx->tam_bloque, fp);
tmp_claves[i].clave = clave;
tmp_claves[i].dato = dato;
tmp_claves[i].hijo_derecho = hijo1;
- tmp_claves[i+1].hijo_derecho = hijo2;
+ if (i<nodo_header.cant)
+ tmp_claves[i+1].hijo_derecho = hijo2;
while (i < nodo_header.cant) {
tmp_claves[i+1] = claves[i];
i++;
/* Si el indice es primario no tiene sentido hacer nada */
if (idx->funcion == IND_PRIMARIO) {
*cant = 0;
+ PERR("INDICE PRIMARIO NO SOPORTA BUSQUEDA MULTIPLE");
return NULL;
}
/* Busco la clave en el arbol */
dato = emufs_indice_b_buscar(idx, clave);
+ if (dato.id == -1) {
+ PERR("CLAvE NO ENCONTRADA EN EL ARBOL!");
+ }
/* Leo el contenido actual */
k.i_clave = dato.id;
+ error = 0;
leido = (char *)idx->emu_mult->leer_registro(idx->emu_mult, k, &tam, &error);
/* Incremento en 1 la cantidad */
ret = malloc(sizeof(INDICE_DATO)*(*cant));
memcpy(ret, leido+sizeof(int), (*cant)*sizeof(INDICE_DATO));
free(leido);
+ fprintf(stderr, "TENGO QUE ESTA CLAVE TIENE %d ITEMS\n", *cant);
return ret;
}
/* Leo el contenido actual */
k.i_clave = pos.id;
+ error = 0;
leido = (char *)idx->emu_mult->leer_registro(idx->emu_mult, k, &tam, &error);
/* Incremento en 1 la cantidad */
if (k.i_clave == -1) {
/* Creo uno nuevo */
error = 0;
+ PERR("GRABADO REGISTRO NUEVO");
k.i_clave = idx->emu_mult->grabar_registro(idx->emu_mult,
- leido,
- cant*sizeof(INDICE_DATO)+sizeof(int),
- &error
- );
+ leido,
+ cant*sizeof(INDICE_DATO)+sizeof(int),
+ &error
+ );
+ if (k.i_clave == -1) PERR("ALGO NO GRABO BIEN!!");
} else {
/* Modifico el que ya existia! */
+ PERR("MODIFICANDO REGISTRO EXISTENTE");
error = 0;
idx->emu_mult->modificar_registro(idx->emu_mult,
- k.i_clave,
- leido,
- cant*sizeof(INDICE_DATO)+sizeof(int),
- &error
- );
+ k.i_clave,
+ leido,
+ cant*sizeof(INDICE_DATO)+sizeof(int),
+ &error
+ );
}
/* Clean up! */
free(leido);
return k.i_clave;
}
+char *abreviar(char *primera, char *actual, int *iguales)
+{
+ (*iguales) = 0;
+ while (((*primera) != '\0') && ((*actual) != '\0')) {
+ if ((*primera) == (*actual)) {
+ primera++;
+ actual++;
+ (*iguales)++;
+ } else {
+ /* No coinciden mas! */
+ break;
+ }
+ }
+
+ return actual;
+}
+
+static void abreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header)
+{
+ char *primera, *actual, *resto, salvar[100];
+ EMUFS_REG_SIZE size;
+ int error, i;
+ int iguales;
+
+ /* Agarro la primer clave entera como referencia */
+ primera = (char *)idx->emu_string->leer_registro(idx->emu_string, array[0].clave, &size, &error);
+ for(i=1; i<header->cant; i++) {
+ actual = (char *)idx->emu_string->leer_registro(idx->emu_string, array[i].clave, &size, &error);
+ resto = abreviar(primera, actual, &iguales);
+ /* Para que tenga sentido abreviar tengo que tener
+ * mas de 2 letras iguales, si no no gano nada y complica las cosas
+ */
+ if (iguales > 1) {
+ sprintf(salvar, "%d|%s", iguales, resto);
+ free(actual);
+ error = 0;
+ idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);
+ } else {
+ free(primera);
+ primera = actual;
+ }
+ }
+
+ free(primera);
+}
+
+static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *header)
+{
+ char *primera, *actual, *resto, salvar[100];
+ EMUFS_REG_SIZE size;
+ int error, i;
+ int iguales;
+
+ /* Agarro la primer clave entera como referencia */
+ primera = (char *)idx->emu_string->leer_registro(idx->emu_string, array[0].clave, &size, &error);
+ for(i=1; i<header->cant; i++) {
+ actual = (char *)idx->emu_string->leer_registro(idx->emu_string, array[i].clave, &size, &error);
+ iguales = strtol(actual, &resto, 10);
+ if ((iguales > 0) && (*resto == '|')) {
+ fprintf(stderr, "%s %s %d\n", primera, actual, iguales);
+ strncpy(salvar, primera, iguales);
+ salvar[iguales] = '\0';
+ strcat(salvar, resto+1); /* +1 para saltar el separador */
+ idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);
+ free(actual);
+ } else {
+ free(primera);
+ primera = actual;
+ }
+ }
+
+ free(primera);
+}
+
projects / z.facultad / 75.06 / emufs.git / blobdiff