int colocaTuplaBuffer(struct page *buffer, char *tupla, struct CAMPOS *campos, char *meta){
//Define a página que será incluida uma nova tupla
int i=0, found=0;
while (!found && i < BP)//Procura pagina com espaço para a tupla.
{
if(SIZE - buffer[i].position > tamTupla(campos, meta)){// Se na pagina i do buffer tiver espaço para a tupla, coloca tupla.
setTupla(buffer, tupla, tamTupla(campos, meta), i);
found = 1;
buffer[i].position += tamTupla(campos,meta); // Atualiza proxima posição vaga dentro da pagina.
buffer[i].nrec += 1;
return OKAY;
}
i++;// Se não, passa pra proxima página do buffer.
}
return BUFFER_CHEIO;
/*
if (!found)
{
printf("Buffer Cheio! Implementar a política de troca.\n");
return;
}
*/
}
int colocaTuplaBuffer(tp_buffer *buffer, int from, tp_table *campos, struct fs_objects objeto){//Define a página que será incluida uma nova tupla
char *tupla = getTupla(campos,objeto,from);
if(tupla == ERRO_DE_LEITURA)
return ERRO_LEITURA_DADOS;
int i=0, found=0;
while (!found && i < PAGES)//Procura pagina com espaço para a tupla.
{
if(SIZE - buffer[i].position > tamTupla(campos, objeto)){// Se na pagina i do buffer tiver espaço para a tupla, coloca tupla.
setTupla(buffer, tupla, tamTupla(campos, objeto), i);
found = 1;
buffer[i].position += tamTupla(campos, objeto); // Atualiza proxima posição vaga dentro da pagina.
buffer[i].nrec += 1;
break;
}
i++;// Se não, passa pra proxima página do buffer.
}
if (!found)
return ERRO_BUFFER_CHEIO;
return SUCCESS;
}
//---------------------------------------
// INSERE UMA TUPLA NO BUFFER!
char *getTupla(tp_table *campos,struct fs_objects objeto, int from){ //Pega uma tupla do disco a partir do valor de from
int tamTpl = tamTupla(campos, objeto);
char *linha=(char *)malloc(sizeof(char)*tamTpl);
FILE *dados;
from = from * tamTpl;
dados = fopen(objeto.nArquivo, "r");
if (dados == NULL)
return ERRO_DE_LEITURA;
fseek(dados, from, 1);
if(fgetc (dados) != EOF){
fseek(dados, -1, 1);
fread(linha, sizeof(char), tamTpl, dados); //Traz a tupla inteira do arquivo
}
else{ //Caso em que o from possui uma valor inválido para o arquivo de dados
fclose(dados);
return ERRO_DE_LEITURA;
}
fclose(dados);
return linha;
}
int showTupleBuffer(struct page *buffer, struct CAMPOS *campos, char *meta, int pg, int rg){
//mostra o registro de número "rg" da página "pg" do bufffer
int k, i, tam = tamTupla(campos,meta), qt=qtCampos(meta,campos[0].id);
char *linha = NULL;
int error;
if(pg < 0 || pg > BP)
return PAGE_INVALIDA;
else if(buffer[pg].nrec == 0)
return EMPTY_PAGE;
if(buffer[pg].position != 0){
for(i = 0; i< qt; i++)
printf("%-20s", campos[i].nome);
printf("\n--------------------------------------------------------------------------------------------\n");
for(k = 0; k < buffer[pg].nrec; k ++){
if(k == rg){
linha = strcop(buffer[pg].data, k, tam); //Função que devolve uma string para a impressão da tupla
if(!linha){
return OUT_OF_MEMORY;
}
error = leTupla(campos, meta, linha); //Mostra a string
if(error != OKAY)
return error;
printf("\n\n");
return OKAY;
}
}
return TUPLE_NOT_FOUND;
}
return GENERIC_ERROR;
}
int getTupla(char *linha,struct CAMPOS *campos, char *meta, struct OBJ *tabela, int from){
//Pega uma tupla do disco a partir do valor de from
int tamTpl = tamTupla(campos, meta);
FILE *dados;
char *arquivo;
if(!(arquivo = (char*)malloc(sizeof(char)* CONST))){
return OUT_OF_MEMORY;
}
//const 60, porque TAM de dir e nome fisico somados terá no max 60 bytes
arquivo[0] = '\0';
strcat(arquivo, tabela->dir);
strcat(arquivo, tabela->fnome);
if(!(dados = fopen(arquivo, "r"))){
return DATA_FILE_NOT_FOUND;
}
fseek(dados, from, 1);
if(fgetc (dados) != EOF){
fseek(dados, -1, 1);
fread(linha, sizeof(char), tamTpl, dados); //Traz a tupla inteira do arquivo
}
else{ //Caso em que o from possui uma valor inválido para o arquivo de dados
fclose(dados);
return GENERIC_ERROR;
}
fclose(dados);
return OKAY;
}
char *getTupla(struct CAMPOS *campos, char *meta, struct OBJ *tabela, int from){ //Pega uma tupla do disco a partir do valor de from
//int id;
int tamTpl = tamTupla(campos, meta);
char *linha=(char *)malloc(sizeof(char)*tamTpl);
FILE *dados;
char *arquivo = (char*)malloc(sizeof(char)* CONST); //const 60 porque concatenando dir e nome fisica terá no max 60 bytes
arquivo[0] = '\0';
strcat(arquivo, tabela->dir);
strcat(arquivo, tabela->fnome);
dados = fopen(arquivo, "r");
if (dados == NULL)
exit(0);
fseek(dados, from, 1);
if(fgetc (dados) != EOF){
fseek(dados, -1, 1);
fread(linha, sizeof(char), tamTpl, dados); //Traz a tupla inteira do arquivo
}
else{ //Caso em que o from possui uma valor inválido para o arquivo de dados
fclose(dados);
return NULL;
}
fclose(dados);
return linha;
}
// INSERE UMA TUPLA NO BUFFER!
char *getTupla(tp_table *campos,struct fs_objects objeto, int from){ //Pega uma tupla do disco a partir do valor de from
int tamTpl = tamTupla(campos, objeto);
char *linha=(char *)malloc(sizeof(char)*tamTpl);
memset(linha, '\0', tamTpl);
FILE *dados;
from = from * tamTpl;
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, objeto.nArquivo);
dados = fopen(directory, "r");
if (dados == NULL) {
free(linha);
return ERRO_DE_LEITURA;
}
fseek(dados, from, 1);
if(fgetc (dados) != EOF){
fseek(dados, -1, 1);
fread(linha, sizeof(char), tamTpl, dados); //Traz a tupla inteira do arquivo
} else { //Caso em que o from possui uma valor inválido para o arquivo de dados
fclose(dados);
free(linha);
return ERRO_DE_LEITURA;
}
fclose(dados);
return linha;
}
void carregaDados(struct page *buffer, char *data, char *meta, struct CAMPOS *campos){
//Traz todos os registros para o buffer
int i=1, tamTpl = tamTupla(campos, meta);
char *linha = getTupla(campos, meta, data, 0);
while(linha != NULL){ //Pega as tuplas e insere no buffer até que acabe o arquivo
colocaTuplaBuffer(buffer, linha, campos, meta);
linha = getTupla(campos, meta, data, i*tamTpl);
i++;
}
}
void carregaDados(struct page *buffer, char *meta, struct CAMPOS *campos, struct OBJ *tabela){
//Traz todos os registros para o buffer
//int id = 1;
int i=1, tamTpl = tamTupla(campos, meta); //tamTpl representa o tamanho total dos atributos
char *linha = getTupla(campos, meta, tabela, 0);
while(linha != NULL){ //Pega as tuplas e insere no buffer até que acabe o arquivo
colocaTuplaBuffer(buffer, linha, campos, meta);
linha = getTupla(campos, meta, tabela, i*tamTpl);
i++;
}
}
void showBuffer(struct page *buffer, struct CAMPOS *campos, char *meta){
//Mostra todas as páginas do buffer que contenham registros
int i, k, tam = tamTupla(campos,meta);
char *linha = NULL;
for(i = 0; i < BP; i++){
if(buffer[i].position != 0){
printf("Página %d:\n", i);
for(k = 0; k < buffer[i].nrec; k ++){
linha = strcop(buffer[i].data, k, tam);
leTupla(campos, meta, linha);
}
}
}
}
void showTupleBuffer(struct page *buffer, struct CAMPOS *campos, char *meta, int pg, int rg){
//mostra o registro de número "rg" da página "pg" do bufffer
int k, i, tam = tamTupla(campos,meta), qt=qtCampos(meta);
char *linha = NULL;
if(buffer[pg].position != 0){
for(i = 0; i< qt; i++)
printf("%-25s", campos[i].nome);
printf("\n--------------------------------------------------------------------------------------------\n");
for(k = 0; k < buffer[pg].nrec; k ++){
if(k == rg){
linha = strcop(buffer[pg].data, k, tam); //Função que devolve uma string para a impressão da tupla
leTupla(campos, meta, linha); //Mostra a string
return;
}
}
printf("Posição inválida!\n");
}
}
char *getTupla(struct CAMPOS *campos, char *meta, char *dado, int from){ //Pega uma tupla do disco a partir do valor de from
int tamTpl = tamTupla(campos, meta);
char *linha=(char *)malloc(sizeof(char)*tamTpl);
FILE *dados;
dados = fopen(dado, "r");
if (dados == NULL)
exit(0);
fseek(dados, from, 1);
if(fgetc (dados) != EOF){
fseek(dados, -1, 1);
fread(linha, sizeof(char), tamTpl, dados); //Traz a tupla inteira do arquivo
}
else{ //Caso em que o from possui uma valor inválido para o arquivo de dados
fclose(dados);
return NULL;
}
fclose(dados);
return linha;
}
int showBuffer(struct page *buffer, struct CAMPOS *campos, char *meta){
//Mostra todas as páginas do buffer que contenham registros
int i, k, tam = tamTupla(campos,meta);
char *linha = NULL;
int error;
for(i = 0; i < BP; i++){
if(buffer[i].position != 0){
printf("Página %d:\n", i);
for(k = 0; k < buffer[i].nrec; k ++){
linha = strcop(buffer[i].data, k, tam);
if(!linha)
return OUT_OF_MEMORY;
error = leTupla(campos, meta, linha);
if(error != OKAY)
return error;
}
}
}
return OKAY;
}
//----------------------------------------
// EXCLUIR TUPLA BUFFER
column * excluirTuplaBuffer(tp_buffer *buffer, tp_table *campos, struct fs_objects objeto, int page, int nTupla){
column *colunas = (column *)malloc(sizeof(column)*objeto.qtdCampos);
if(colunas == NULL)
return ERRO_DE_ALOCACAO;
if(buffer[page].nrec == 0) //Essa página não possui registros
return ERRO_PARAMETRO;
int i, tamTpl = tamTupla(campos, objeto), j=0, t=0;
i = tamTpl*nTupla; //Calcula onde começa o registro
while(i < tamTpl*nTupla+tamTpl){
t=0;
colunas[j].valorCampo = (char *)malloc(sizeof(char)*campos[j].tam); //Aloca a quantidade necessária para cada campo
colunas[j].tipoCampo = campos[j].tipo; // Guarda o tipo do campo
strcpy(colunas[j].nomeCampo, campos[j].nome); //Guarda o nome do campo
while(t < campos[j].tam){
colunas[j].valorCampo[t] = buffer[page].data[i]; //Copia os dados
t++;
i++;
}
j++;
}
j = i;
i = tamTpl*nTupla;
for(; i < buffer[page].position; i++, j++) //Desloca os bytes do buffer sobre a tupla excluida
buffer[page].data[i] = buffer[page].data[j];
buffer[page].position -= tamTpl;
buffer[page].nrec--;
return colunas; //Retorna a tupla excluida do buffer
}
int carregaDados(struct page *buffer, char *meta, struct CAMPOS *campos, struct OBJ *tabela){
//Traz todos os registros para o buffer
int i=1,tamTpl = (tamTupla(campos, meta)); //tamTpl representa o tamanho total dos atributos
char *linha;
if(!(tamTpl)){
return GENERIC_ERROR;
}
if(!(linha =(char *)malloc(sizeof(char)*tamTpl))){
return OUT_OF_MEMORY;
}
int error;
error = getTupla(linha,campos, meta, tabela, 0);
if(error == OKAY){
while(linha != NULL){ //Pega as tuplas e insere no buffer até que acabe o arquivo
error = colocaTuplaBuffer(buffer, linha, campos, meta);
free(linha);
linha =(char *)malloc(sizeof(char)*tamTpl);
if(error == OKAY){
error = getTupla(linha,campos, meta, tabela, i*tamTpl);
if( error != OKAY){
return OKAY;
}
i++;
}else return error;
}
}
else
return error;
return OKAY;
}
int drawline(tp_buffer *buffpoll, tp_table *s, struct fs_objects objeto, int p, int num_page){
if (num_page > PAGES || p > SIZE){
return ERRO_DE_PARAMETRO;
}
int *pos_ini, aux = (p * tamTupla(s,objeto)) , num_reg = objeto.qtdCampos;
pos_ini = &aux;
int count, pos_aux, bit_pos;
union c_double cd;
union c_int ci;
int x = 0;
count = pos_aux = bit_pos = 0;
for(count = 0; count < num_reg; count++){
pos_aux = *(pos_ini);
bit_pos = 0;
switch(s[count].tipo){
case 'S':
x = 0;
while(buffpoll[num_page].data[pos_aux] != '\0'){
printf("%c", buffpoll[num_page].data[pos_aux]);
if ((buffpoll[num_page].data[pos_aux++] & 0xc0) != 0x80) bit_pos++; //Conta apenas bits que possam ser impressos (UTF8)
x++;
}
cria_campo((TAMANHO_NOME_CAMPO - (bit_pos)), 0, (char*)' ', (30 - x));
break;
case 'I':
while(pos_aux < *(pos_ini) + s[count].tam){
ci.cnum[bit_pos++] = buffpoll[num_page].data[pos_aux++];
}
printf("%d", ci.num); //Controla o número de casas até a centena
cria_campo((TAMANHO_NOME_CAMPO - (bit_pos)), 0, (char*)' ', 28);
break;
case 'D':
while(pos_aux < *(pos_ini) + s[count].tam){
cd.double_cnum[bit_pos++] = buffpoll[num_page].data[pos_aux++]; // Cópias os bytes do double para área de memória da union
}
printf("%.3lf", cd.dnum);
cria_campo((TAMANHO_NOME_CAMPO - (bit_pos)), 0, (char*)' ', 24);
break;
case 'C':
printf("%c", buffpoll[num_page].data[pos_aux]);
if(s[count].tam < strlen(s[count].nome)){
bit_pos = strlen(s[count].nome);
}
else{
bit_pos = s[count].tam;
}
cria_campo((bit_pos - 1), 0, (char*)' ', 29);
break;
default:
return ERRO_IMPRESSAO;
break;
}
*(pos_ini) += s[count].tam;
}
printf("\n");
return SUCCESS;
}
