Exemple #1
0
int load_data(char *filename, char *entidad){
  FILE * entity_file;
  FILE * block_file;
  struct record_t *record;
  struct file_header * file_header;
  struct block_t * current_block;
  char * buffer;
  int res;

  /* Entity file */
  entity_file = open_file_to_parse(filename);
  if (!entity_file){
    return BAD_NAME_FILE;
  }
  /* Block and header file */
  block_file = open_block_file(entidad, 1);
  if(!block_file){
    return BAD_NAME_FILE;
  }else{
    file_header = (struct file_header*) malloc(sizeof(struct file_header));
    if(!file_header)
      return ALLOCATE_FAIL;
    else{
      initialize_file_header(file_header);
      write_header(block_file, file_header);
    }
  }

  /* Allocate buffer and record */
  buffer = (char*) malloc (RECORD_MAX_SIZE);
  record = (struct record_t*) malloc(sizeof(struct record_t));
  current_block = (struct block_t *) malloc(sizeof(struct block_t));

  if(!buffer || !record || !current_block)
    return ALLOCATE_FAIL;

  initialize_buffer(buffer);
  initialize_block(current_block, 1);
  initialize_record(record);

  /* Read text file */
  while(fgets(buffer, RECORD_MAX_SIZE, entity_file) != NULL){
    res = parse_line(buffer, record, RECORD_MAX_SIZE);
    if(res == RES_OK){
      res = find_and_write_block(block_file, file_header, record, current_block);
      initialize_record(record);
      free(record->content);
    };
  };
  write_to_file(block_file, file_header, current_block);
  print_header(file_header);

  free(record);
  free(buffer);
  free(file_header);
  free(current_block);
  close_entity_file(entity_file);
  close_block_file(block_file);
  return res;
}
Exemple #2
0
int search_by_code(char* entidad, int code){
  FILE * block_file;
  struct record_t *record;
  struct block_t * current_block;
  struct file_header * file_header;
  int res, i = 1, j = 1, recs = 0;
  int current_pos = 0, encontrado = 1;

  block_file = open_block_file(entidad, 2);
  if(!block_file){
    return BAD_NAME_FILE;
  }

  /* Allocate buffer and record */
  record        = (struct record_t*) malloc(sizeof(struct record_t));
  current_block = (struct block_t *) malloc(sizeof(struct block_t));
  file_header   = (struct file_header*) malloc(sizeof(struct file_header));

  if(!record || !current_block || !file_header)
    return ALLOCATE_FAIL;

  initialize_record(record);
  initialize_block(current_block,1);
  read_header(block_file, file_header);

  while((i < file_header->total_blocks+1) && (encontrado == 1)){
    current_pos = 0;
    j = 1;
    res  = read_from_file(block_file, current_block, file_header, i);
    if(res == RES_OK){
      recs = current_block->total_reg;
      while((j < recs+1) && (encontrado == 1)){
        initialize_record(record);
        current_pos += read_block(current_block, record, current_pos);
        if(code == record->code){
          print_success_message(record);
          encontrado = 0;
        }
        free(record->content);
        j++;
      }
    }
    i++;
  }
  if(encontrado == 1){
    print_error_message(code);
  }
  free(record);
  free(file_header);
  free(current_block);
  fclose(block_file);
  return res;
}
Exemple #3
0
int list_data(char *filename){
  FILE * block_file;
  struct record_t *record;
  struct block_t * current_block;
  struct file_header * file_header;
  int res, i, j, recs, k;
  int current_pos = 0;

  block_file = open_block_file(filename, 2);
  if(!block_file)
    return BAD_NAME_FILE;

  /* Allocate buffer and record */
  record        = (struct record_t*) malloc(sizeof(struct record_t));
  current_block = (struct block_t *) malloc(sizeof(struct block_t));
  file_header   = (struct file_header*) malloc(sizeof(struct file_header));

  if(!record || !current_block || !file_header)
    return ALLOCATE_FAIL;

  initialize_record(record);
  initialize_block(current_block,1);
  read_header(block_file, file_header);

  printf("Listado de %s\n\n", filename);
  k=0;
  for(i=1;i<file_header->total_blocks+1; i++){
    current_pos = 0;
    res  = read_from_file(block_file, current_block, file_header, i);
    if(res == RES_OK){
      recs = current_block->total_reg;
      for(j=0; j < recs; j++){
        initialize_record(record);
        current_pos += read_block(current_block, record, current_pos);
        printf("%03d) %d, %s\n",k+1, record->code, record->content);
        k++;
        free(record->content);
      }
    }
  }
  printf("\n");
  free(record);
  free(file_header);
  free(current_block);
  fclose(block_file);
  return res;
}
void test_initialize_record(void) {
    record = NULL;

    initialize_record(&record, SIZE);
    int i;
    for (i = 0; i < SIZE; i++) {
        CU_ASSERT_EQUAL_FATAL(record->members[i], i + 1);
        CU_ASSERT_EQUAL_FATAL(record->index[i], i);
        CU_ASSERT_FALSE_FATAL(record->direction[i]);
    }
}
Exemple #5
0
int order(char * entidad, int (*fp)(struct record_t*, struct record_t*)){
  FILE * block_file;
  FILE * tmp_file;
  struct record_t *record;
  struct block_t * current_block;
  struct file_header * file_header;

  int res, j = 0;
  int current_pos = 0;
  int current_pos_freeze = 0;
  int registros_leidos = 0, bloques_leidos = 0;
  int todo_leido = 1, totales_leidos = 0;
  int registro_en_memoria = 1, registro_procesado = 0;
  int tmp_files = 1;
  char path[30];

  struct record_t buffer[TMP_BUFFER];
  struct record_t freeze_buffer[TMP_BUFFER];

  block_file = open_block_file(entidad, 2);

  if(!block_file){
    return BAD_NAME_FILE;
  }

  /* Allocate buffer and record */
  current_block = (struct block_t *) malloc(sizeof(struct block_t));
  file_header   = (struct file_header*) malloc(sizeof(struct file_header));
  record  = (struct record_t*) malloc(sizeof(struct record_t));

  if(!current_block || !file_header || !record)
    return ALLOCATE_FAIL;

  initialize_block(current_block,1);
  read_header(block_file, file_header);
  initialize_record(record);

  res  = read_from_file(block_file, current_block, file_header, 1);
  bloques_leidos++;

  if(res == RES_OK){

    /* Inicializo el buffer con registros */
    while(j<TMP_BUFFER && (todo_leido == 1)){
      if(registros_leidos < current_block->total_reg){
        current_pos += read_block(current_block, record, current_pos);
        memcpy(&buffer[j],record,sizeof(struct record_t));
        registros_leidos++;
        totales_leidos++;
        j++;
      }else{
        if((bloques_leidos < file_header->total_blocks+1) && (file_header->total_records > totales_leidos)){
          res = read_from_file(block_file, current_block, file_header, current_block->number+1);
          bloques_leidos++;
          registros_leidos = 0;
          current_pos = 0;
        }else{
          todo_leido = 0;
        }
      }
    }

    /* Creo el primer sort file */
    sprintf(path,"tmp/sort%d.txt",tmp_files);
    tmp_file = fopen(path, "w");

    if(file_header->total_records == totales_leidos)
      heapify(buffer,totales_leidos, fp);
    else
      heapify(buffer,TMP_BUFFER, fp);

    while((todo_leido == 1) && tmp_file){
      if(registros_leidos < current_block->total_reg){
        current_pos += read_block(current_block, record, current_pos);
        registros_leidos++;
        registro_en_memoria = 0;
        registro_procesado  = 1;
      }else{
        if(bloques_leidos < file_header->total_blocks){
          res  = read_from_file(block_file, current_block, file_header, current_block->number+1);
          bloques_leidos++;
          current_pos = 0;
          registros_leidos    = 0;
          registro_procesado  = 1;
          registro_en_memoria = 1;
        }else{
          todo_leido = 0;
        }
      }

      while((registro_procesado == 1) && (registro_en_memoria == 0)){
        if(fp(record,&buffer[0]) < 0){
          if(current_pos_freeze<TMP_BUFFER){
            memcpy(&freeze_buffer[current_pos_freeze],record,sizeof(struct record_t));
            current_pos_freeze++;
            registro_procesado  = 0;
            registro_en_memoria = 1;
          }
          else {
            /* vacio el buffer en el archivo */
            print_buffer_to_file(buffer, TMP_BUFFER, tmp_file, fp);
            /* cierro archivo y abro el siguiente */
            tmp_files++;
            fclose(tmp_file);
            sprintf(path,"tmp/sort%d.txt",tmp_files);
            tmp_file = fopen(path, "w");
            /* copio el freeze_buffer al buffer y creo el heap*/
            heapify(freeze_buffer,TMP_BUFFER, fp);
            memcpy(buffer,freeze_buffer,sizeof(struct record_t) * TMP_BUFFER);
            current_pos_freeze = 0;
            registro_procesado = 1;
          }
        }
        else{
          /* Guardo en el archivo, libero memoria */
          print_record_to_file(buffer, tmp_file);
          /* Guardo en el buffer el record leido */
          memcpy(&buffer[0],&buffer[TMP_BUFFER-1],sizeof(struct record_t));
          memcpy(&buffer[TMP_BUFFER-1],record,sizeof(struct record_t));
          registro_procesado  = 0;
          registro_en_memoria = 1;
          update(buffer, TMP_BUFFER, fp);
        }
      }
    }
    /* Guardo en el archivo*/
    if((file_header->total_records == totales_leidos) && (current_block->number == 1))
      print_buffer_to_file(buffer, totales_leidos, tmp_file, fp);
    else
      print_buffer_to_file(buffer, TMP_BUFFER, tmp_file, fp);

    fclose(tmp_file);

    /* Guardo lo que tenia en el freeze_buffer en otro archivo */
    if(current_pos_freeze > 1){
      tmp_files++;
      sprintf(path,"tmp/sort%d.txt",tmp_files);
      tmp_file = fopen(path, "w");
      print_buffer_to_file(freeze_buffer, current_pos_freeze, tmp_file, fp);
      fclose(tmp_file);
    }
  }

  free(record);
  free(current_block);
  free(file_header);
  fclose(block_file);

  /* Merge de los archivos generados */
  res = merge_files(tmp_files, fp);
  printf("\n");

  return res;
}
int main(int argc, char **argv){
  int i=0, res, free_space;
  char content[17] = "Esto es un test  ";
  FILE * block_file;
  struct file_header * fh;
  struct block_t * block;
  struct record_t * record;

  printf("Welcome to Carga Masiva Test\n\n");

  block_file = fopen("block_records_test.dat", "w");

  fh     = (struct file_header*) malloc(sizeof(struct file_header));
  record = (struct record_t*) malloc(sizeof(struct record_t));
  block  = (struct block_t *) malloc(sizeof(struct block_t));


  if(!record || !block || !fh)
    return -1;

  initialize_block(block, 1);
  initialize_record(record);
  initialize_file_header(fh);

  res = write_header(block_file, fh);
  if(res == 0){
    for(i=0;i<50;i++){

      record->content = (char*) malloc(strlen(content)+1);
      memcpy(record->content, content, strlen(content)+1);

      record->content[17] = '\0';
      record->code = i+1;
      record->size = (int)sizeof(record->size) + (int)sizeof(record->code) + (int) strlen(record->content) + 1;

      free_space = MAX_SIZE - block->space_occupied;


      if(free_space < record->size){
        write_to_file(block_file, fh, block);
        printf("(Bloque %d) \tOcupado: %d, Records: %d\n", block->number, block->space_occupied, block->total_reg);
        initialize_block(block, block->number+1);
      }
      write_block(block, fh, record);
      initialize_record(record);
      free(record->content);
    }
  }

  write_to_file(block_file, fh, block);
  printf("(Bloque %d) \tOcupado: %d, Records: %d\n", block->number, block->space_occupied, block->total_reg);
  printf("\nListo la carga de bloques\n");
  printf("---------------------------------------\n");
  print_header(fh);

  free(block);
  free(record);
  free(fh);

  fclose(block_file);
  return 0;
}