struct fs_objects leObjeto(char *nTabela){
FILE *dicionario;
char *tupla = (char *)malloc(sizeof(char)*TAMANHO_NOME_TABELA);
memset(tupla, '\0', TAMANHO_NOME_TABELA);
int cod;
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, "fs_object.dat");
dicionario = fopen(directory, "a+b"); // Abre o dicionario de dados.
struct fs_objects objeto;
if(!verificaNomeTabela(nTabela)){
printf("ERROR: relation \"%s\" was not found.\n", nTabela);
if (dicionario)
fclose(dicionario);
free(tupla);
return objeto;
}
if (dicionario == NULL) {
printf("ERROR: data dictionary was not found.\n\n");
free(tupla);
return objeto;
}
while(fgetc (dicionario) != EOF){
fseek(dicionario, -1, 1);
fread(tupla, sizeof(char), TAMANHO_NOME_TABELA , dicionario); //Lê somente o nome da tabela
if(objcmp(tupla, nTabela) == 0){ // Verifica se o nome dado pelo usuario existe no dicionario de dados.
strcpylower(objeto.nome, tupla);
fread(&cod,sizeof(int),1,dicionario); // Copia valores referentes a tabela pesquisada para a estrutura.
objeto.cod=cod;
fread(tupla,sizeof(char),TAMANHO_NOME_TABELA,dicionario);
strcpylower(objeto.nArquivo, tupla);
fread(&cod,sizeof(int),1,dicionario);
objeto.qtdCampos = cod;
free(tupla);
fclose(dicionario);
return objeto;
}
fseek(dicionario, 28, 1); // Pula a quantidade de caracteres para a proxima verificacao(4B do codigo, 20B do nome do arquivo e 4B da quantidade de campos).
}
free(tupla);
fclose(dicionario);
return objeto;
}
char connectDB(char *db_name) {
FILE *DB;
int i;
char vec_name [QTD_DB][LEN_DB_NAME],
vec_directory [QTD_DB][LEN_DB_NAME],
valid,
directory [LEN_DB_NAME*2] = "data/";
if((DB = fopen("data/DB.dat","rb")) == NULL) {
return ERRO_ABRIR_ARQUIVO;
}
for(i=0; fgetc (DB) != EOF; i++) {
fseek(DB, -1, 1);
fread(&valid ,sizeof(char), 1, DB);
fread(vec_name[i] ,sizeof(char), LEN_DB_NAME, DB);
fread(vec_directory[i] ,sizeof(char), LEN_DB_NAME, DB);
if(objcmp(vec_name[i], db_name) == 0) { //verifica se encontrou o banco
if(valid) {
strcat(directory, vec_directory[i]); // atualiza o diretorio do banco que esta conectado
strcpylower(connected.db_directory, directory);
fclose(DB);
return SUCCESS;
}
}
}
fclose(DB);
return DB_NOT_EXISTS;
}
void setColumnFKTableCreate(char **nome) {
GLOBAL_DATA.fkTable[GLOBAL_PARSER.col_count-1] = realloc(GLOBAL_DATA.fkTable[GLOBAL_PARSER.col_count-1], sizeof(char)*(strlen(*nome)+1));
strcpylower(GLOBAL_DATA.fkTable[GLOBAL_PARSER.col_count-1], *nome);
GLOBAL_DATA.fkTable[GLOBAL_PARSER.col_count-1][strlen(*nome)] = '\0';
GLOBAL_DATA.attribute[GLOBAL_PARSER.col_count-1] = FK;
GLOBAL_PARSER.step++;
}
void setCondition(char **cond){
int tam = sizeof(char)*((strlen(*cond)+1));
GLOBAL_DATA_SELECT.condition = malloc(tam);
strcpylower(GLOBAL_DATA_SELECT.condition, *cond);
GLOBAL_DATA_SELECT.condition[strlen(*cond)] = '\0';
}
void setColumnWhere2(char *nome, char type) {
GLOBAL_WHERE.columnWhere2 = malloc(sizeof(char)*(strlen(nome)+1));
strcpylower(GLOBAL_WHERE.columnWhere2, nome);
}
void setColumnInsert(char **nome) {
GLOBAL_DATA.columnName = realloc(GLOBAL_DATA.columnName, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count] = malloc(sizeof(char)*(strlen(*nome)+1));
strcpylower(GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count], *nome);
GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count][strlen(*nome)] = '\0';
GLOBAL_PARSER.col_count++;
}
void setValueAttr(char **nome){
int tam = sizeof(char)*((strlen(*nome)+1));
GLOBAL_DATA_SELECT.values = malloc(tam);
strcpylower(GLOBAL_DATA_SELECT.values, *nome);
GLOBAL_DATA_SELECT.values[strlen(*nome)] = '\0';
}
void setObjName(char **nome) {
if (GLOBAL_PARSER.mode != 0) {
GLOBAL_DATA.objName = malloc(sizeof(char)*((strlen(*nome)+1)));
strcpylower(GLOBAL_DATA.objName, *nome);
GLOBAL_DATA.objName[strlen(*nome)] = '\0';
GLOBAL_PARSER.step++;
} else
return;
}
void setValueColumn(char **nome){
int tam = sizeof(char)*((strlen(*nome)+1));
GLOBAL_DATA_SELECT.columnSelected = malloc(tam);
strcpylower(GLOBAL_DATA_SELECT.columnSelected, *nome);
GLOBAL_DATA_SELECT.columnSelected[strlen(*nome)] = '\0';
}
void setTableSelect(char **nome){
int tam = sizeof(char)*((strlen(*nome)+1));
GLOBAL_DATA_SELECT.objName = malloc(tam);
strcpylower(GLOBAL_DATA_SELECT.objName, *nome);
GLOBAL_DATA_SELECT.objName[strlen(*nome)] = '\0';
}
// CRIA TABELA
table *iniciaTabela(char *nome){
if(verificaNomeTabela(nome)){ // Se o nome já existir no dicionario, retorna erro.
return ERRO_NOME_TABELA_INVALIDO;
}
table *t = (table *)malloc(sizeof(table)*1);
memset(t,0,sizeof(table));
strcpylower(t->nome,nome); // Inicia a estrutura de tabela com o nome da tabela.
t->esquema = NULL; // Inicia o esquema da tabela com NULL.
return t; // Retorna estrutura para criação de uma tabela.
}
tp_table *procuraAtributoFK(struct fs_objects objeto){
FILE *schema;
int cod = 0, chave, i = 0;
char *tupla = (char *)malloc(sizeof(char) * 109);
tp_table *esquema = (tp_table *)malloc(sizeof(tp_table)*objeto.qtdCampos);
tp_table *vetEsqm = (tp_table *)malloc(sizeof(tp_table)*objeto.qtdCampos);
memset(vetEsqm, 0, sizeof(tp_table)*objeto.qtdCampos);
memset(esquema, 0, sizeof(tp_table)*objeto.qtdCampos);
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, "fs_schema.dat");
if((schema = fopen(directory, "a+b")) == NULL){
printf("ERROR: could not read schema.\n");
free(tupla);
free(esquema);
free(vetEsqm);
return ERRO_ABRIR_ESQUEMA;
}
while((fgetc (schema) != EOF) && i < objeto.qtdCampos){ // Varre o arquivo ate encontrar todos os campos com o codigo da tabela.
fseek(schema, -1, 1);
if(fread(&cod, sizeof(int), 1, schema)){ // Le o codigo da tabela.
if(cod == objeto.cod){
fread(tupla, sizeof(char), TAMANHO_NOME_CAMPO, schema);
strcpylower(esquema[i].nome,tupla); // Copia dados do campo para o esquema.
fread(&esquema[i].tipo , sizeof(char), 1 , schema);
fread(&esquema[i].tam , sizeof(int) , 1 , schema);
fread(&chave, sizeof(int) , 1 , schema);
vetEsqm[i].tipo = esquema[i].tipo;
vetEsqm[i].tam = esquema[i].tam;
fread(tupla, sizeof(char), TAMANHO_NOME_TABELA, schema);
strcpylower(esquema[i].tabelaApt,tupla);
fread(tupla, sizeof(char), TAMANHO_NOME_CAMPO, schema);
strcpylower(esquema[i].attApt,tupla);
strcpylower(vetEsqm[i].tabelaApt, esquema[i].tabelaApt);
strcpylower(vetEsqm[i].attApt, esquema[i].attApt);
strcpylower(vetEsqm[i].nome, esquema[i].nome);
vetEsqm[i].chave = chave;
i++;
} else {
fseek(schema, 109, 1);
}
}
}
free(tupla);
free(esquema);
fclose(schema);
return vetEsqm;
}
void connect(char *nome) {
int r;
r = connectDB(nome);
if (r == SUCCESS) {
connected.db_name = malloc(sizeof(char)*((strlen(nome)+1)));
strcpylower(connected.db_name, nome);
connected.conn_active = 1;
printf("You are now connected to database \"%s\" as user \"Ibetres\".\n", nome);
} else {
printf("ERROR: Failed to establish connection with database named \"%s\". (Error code: %d)\n", nome, r);
}
}
int finalizaTabela(table *t){
if(t == NULL)
return ERRO_DE_PARAMETRO;
FILE *esquema, *dicionario;
tp_table *aux;
int codTbl = quantidadeTabelas() + 1, qtdCampos = 0; // Conta a quantidade de tabelas já no dicionario e soma 1 no codigo dessa nova tabela.
char nomeArquivo[TAMANHO_NOME_ARQUIVO];
memset(nomeArquivo, 0, TAMANHO_NOME_ARQUIVO);
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, "fs_schema.dat");
if((esquema = fopen(directory,"a+b")) == NULL)
return ERRO_ABRIR_ARQUIVO;
for(aux = t->esquema; aux != NULL; aux = aux->next){ // Salva novos campos no esquema da tabela, fs_schema.dat
fwrite(&codTbl ,sizeof(codTbl) ,1,esquema); //Código Tabela
fwrite(&aux->nome ,sizeof(aux->nome) ,1,esquema); //Nome campo
fwrite(&aux->tipo ,sizeof(aux->tipo) ,1,esquema); //Tipo campo
fwrite(&aux->tam ,sizeof(aux->tam) ,1,esquema); //Tamanho campo
fwrite(&aux->chave ,sizeof(aux->chave) ,1,esquema); //Chave do campo
fwrite(&aux->tabelaApt ,sizeof(aux->tabelaApt) ,1,esquema); //Tabela Apontada
fwrite(&aux->attApt ,sizeof(aux->attApt) ,1,esquema); //Atributo apontado.
qtdCampos++; // Soma quantidade total de campos inseridos.
}
fclose(esquema);
strcpy(directory, connected.db_directory);
strcat(directory, "fs_object.dat");
if((dicionario = fopen(directory,"a+b")) == NULL)
return ERRO_ABRIR_ARQUIVO;
strcpylower(nomeArquivo, t->nome);
strcat(nomeArquivo, ".dat\0");
strcat(t->nome, "\0");
// Salva dados sobre a tabela no dicionario.
fwrite(&t->nome,sizeof(t->nome),1,dicionario);
fwrite(&codTbl,sizeof(codTbl),1,dicionario);
fwrite(&nomeArquivo,sizeof(nomeArquivo),1,dicionario);
fwrite(&qtdCampos,sizeof(qtdCampos),1,dicionario);
fclose(dicionario);
return SUCCESS;
}
void setColumnCreate(char **nome) {
GLOBAL_DATA.columnName = realloc(GLOBAL_DATA.columnName, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.attribute = realloc(GLOBAL_DATA.attribute, (GLOBAL_PARSER.col_count+1)*sizeof(int));
GLOBAL_DATA.fkColumn = realloc(GLOBAL_DATA.fkColumn, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.fkTable = realloc(GLOBAL_DATA.fkTable, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.values = realloc(GLOBAL_DATA.values, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.type = realloc(GLOBAL_DATA.type, (GLOBAL_PARSER.col_count+1)*sizeof(char *));
GLOBAL_DATA.values[GLOBAL_PARSER.col_count] = malloc(sizeof(char));
GLOBAL_DATA.fkTable[GLOBAL_PARSER.col_count] = malloc(sizeof(char));
GLOBAL_DATA.fkColumn[GLOBAL_PARSER.col_count] = malloc(sizeof(char));
GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count] = malloc(sizeof(char)*(strlen(*nome)+1));
strcpylower(GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count], *nome);
GLOBAL_DATA.columnName[GLOBAL_PARSER.col_count][strlen(*nome)] = '\0';
GLOBAL_DATA.type[GLOBAL_PARSER.col_count] = 0;
GLOBAL_DATA.attribute[GLOBAL_PARSER.col_count] = NPK;
GLOBAL_PARSER.col_count++;
GLOBAL_PARSER.step = 2;
}
// 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
strcpylower(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 excluirTabela(char *nomeTabela) {
struct fs_objects objeto, objeto1;
tp_table *esquema, *esquema1;
int x,erro, i, j, k, l, qtTable;
char str[20];
char dat[5] = ".dat";
memset(str, '\0', 20);
if (!verificaNomeTabela(nomeTabela)) {
printf("ERROR: table \"%s\" does not exist.\n", nomeTabela);
return ERRO_NOME_TABELA;
}
strcpylower(str, nomeTabela);
strcat(str, dat); //Concatena e junta o nome com .dat
abreTabela(nomeTabela, &objeto, &esquema);
qtTable = quantidadeTabelas();
char **tupla = (char **)malloc(sizeof(char **)*qtTable);
memset(tupla, 0, qtTable);
for (i=0; i < qtTable; i++) {
tupla[i] = (char *)malloc(sizeof(char)*TAMANHO_NOME_TABELA);
memset(tupla[i], '\0', TAMANHO_NOME_TABELA);
}
tp_table *tab2 = (tp_table *)malloc(sizeof(struct tp_table));
tab2 = procuraAtributoFK(objeto); //retorna o tipo de chave que e cada campo
FILE *dicionario;
char directory[LEN_DB_NAME*2];
memset(directory, '\0', LEN_DB_NAME*2);
strcpy(directory, connected.db_directory);
strcat(directory, "fs_object.dat");
if((dicionario = fopen(directory,"a+b")) == NULL)
return ERRO_ABRIR_ARQUIVO;
k=0;
while(fgetc (dicionario) != EOF){
fseek(dicionario, -1, 1);
//coloca o nome de todas as tabelas em tupla
fread(tupla[k], sizeof(char), TAMANHO_NOME_TABELA , dicionario);
k++;
fseek(dicionario, 28, 1);
}
fclose(dicionario);
for(i = 0; i < objeto.qtdCampos; i++){
if(tab2[i].chave == PK){
for(j=0; j<qtTable; j++) { //se tiver chave primaria verifica se ela e chave
if(objcmp(tupla[j], nomeTabela) != 0) { //estrangeira em outra tabela
abreTabela(tupla[j], &objeto1, &esquema1);
tp_table *tab3 = (tp_table *)malloc(sizeof(struct tp_table));
tab3 = procuraAtributoFK(objeto1);
for(l=0; l<objeto1.qtdCampos; l++) {
if(tab3[l].chave == FK) { //verifica se a outra tabela possui chave estrangeira. se sim, verifica se e da tabela anterior.
if(objcmp(nomeTabela, tab3[l].tabelaApt) == 0) {
printf("ERROR: cannot drop table \"%s\" because other objects depend on it.\n", nomeTabela);
return ERRO_CHAVE_ESTRANGEIRA;
}
}
}
free(tab3);
}
}
}
}
free(tab2);
tp_buffer *bufferpoll = initbuffer();
if(bufferpoll == ERRO_DE_ALOCACAO){
printf("ERROR: no memory available to allocate buffer.\n");
return ERRO_LEITURA_DADOS;
}
erro = SUCCESS;
for(x = 0; erro == SUCCESS; x++)
erro = colocaTuplaBuffer(bufferpoll, x, esquema, objeto);
if(procuraSchemaArquivo(objeto) != 0) {
free(bufferpoll);
return ERRO_REMOVER_ARQUIVO_SCHEMA;
}
if(procuraObjectArquivo(nomeTabela) != 0) {
free(bufferpoll);
return ERRO_REMOVER_ARQUIVO_OBJECT;
}
strcpy(directory, connected.db_directory);
strcat(directory, str);
remove(directory);
free(bufferpoll);
printf("DROP TABLE\n");
return SUCCESS;
}
void printTable(char *tbl){
if(tbl == NULL){ //mostra todas as tabelas do banco
FILE *dicionario;
printf(" List of Relations\n");
char *tupla = (char *)malloc(sizeof(char)*TAMANHO_NOME_TABELA);
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, "fs_object.dat");
if((dicionario = fopen(directory,"a+b")) == NULL){
free(tupla);
printf("ERROR: cannot open file\n");
return;
}
printf(" %-10s | %-15s | %-10s | %-10s\n", "Schema", "Name", "Type", "Owner");
printf("------------+-----------------+------------+-------\n");
int i=0;
while(fgetc (dicionario) != EOF){
fseek(dicionario, -1, 1);
fread(tupla, sizeof(char), TAMANHO_NOME_TABELA, dicionario);
printf(" %-10s | %-15s | %-10s | %-10s\n", "public", tupla, "tuple", "ibetres");
fseek(dicionario, 28, 1);
i++;
}
fclose(dicionario);
free(tupla);
printf("(%d %s)\n\n", i, (i<=1)? "row": "rows");
} else{ //mostra todos atributos da tabela *tbl
if(!verificaNomeTabela(tbl)) {
printf("Did not find any relation named \"%s\".\n", tbl);
return;
}
printf(" Table \"public.%s\"\n", tbl);
printf(" %-18s | %-12s | %-10s\n", "Column", "Type", "Modifiers");
printf("--------------------+--------------+-----------\n");
struct fs_objects objeto1;
tp_table *esquema1;
abreTabela(tbl, &objeto1, &esquema1);
tp_table *tab3 = (tp_table *)malloc(sizeof(struct tp_table));
tab3 = procuraAtributoFK(objeto1); //retorna tp_table
int l, ipk=0, ifk=0;
char **pk = (char**)malloc(objeto1.qtdCampos*sizeof(char**));
char **fkTable = (char**)malloc(objeto1.qtdCampos*sizeof(char**));
char **fkColumn = (char**)malloc(objeto1.qtdCampos*sizeof(char**));
char **refColumn = (char**)malloc(objeto1.qtdCampos*sizeof(char**));
memset(pk , 0, objeto1.qtdCampos);
memset(fkTable , 0, objeto1.qtdCampos);
memset(fkColumn , 0, objeto1.qtdCampos);
memset(refColumn, 0, objeto1.qtdCampos);
int i;
for(i=0; i<objeto1.qtdCampos; i++) {
pk[i] = (char*)malloc(TAMANHO_NOME_CAMPO*sizeof(char));
fkTable[i] = (char*)malloc(TAMANHO_NOME_CAMPO*sizeof(char));
fkColumn[i] = (char*)malloc(TAMANHO_NOME_CAMPO*sizeof(char));
refColumn[i] = (char*)malloc(TAMANHO_NOME_CAMPO*sizeof(char));
memset(pk[i] , '\0', TAMANHO_NOME_CAMPO);
memset(fkTable[i] , '\0', TAMANHO_NOME_CAMPO);
memset(fkColumn[i] , '\0', TAMANHO_NOME_CAMPO);
memset(refColumn[i] , '\0', TAMANHO_NOME_CAMPO);
}
for(l=0; l<objeto1.qtdCampos; l++) {
if(tab3[l].chave == PK){
strcpylower(pk[ipk++], tab3[l].nome);
}
else if(tab3[l].chave == FK){
strcpylower(fkTable[ifk] , tab3[l].tabelaApt);
strcpylower(fkColumn[ifk] , tab3[l].attApt);
strcpylower(refColumn[ifk++], tab3[l].nome);
}
printf(" %-17s |", tab3[l].nome);
if(tab3[l].tipo == 'S')
printf(" %-8s(%d) |", " varchar", tab3[l].tam);
else if(tab3[l].tipo == 'I')
printf(" %-10s |", " integer");
else if(tab3[l].tipo == 'C')
printf(" %-10s |", " char");
else if(tab3[l].tipo == 'D')
printf(" %-10s |", " double");
printf(" %-10s ", (tab3[l].chave == PK || tab3[l].chave == FK)? "not null": "null");
printf("\n");
}
if(ipk){ //printf PK's
printf("Indexes:\n");
for(l = 0; l < ipk; l++){
printf("\t\"%s_pkey\" PRIMARY KEY (%s)\n", tbl, pk[l]);
}
}
if(ifk){ //printf FK's
printf("Foreign-key constrains:\n");
for(l = 0; l < ifk; l++){
printf("\t\"%s_%s_fkey\" FOREIGN KEY (%s) REFERENCES %s(%s)\n",tbl, refColumn[l], refColumn[l], fkTable[l], fkColumn[l]);
}
}
free(pk);
free(fkTable);
free(fkColumn);
free(refColumn);
free(tab3);
printf("\n");
}
}
table *adicionaCampo(table *t,char *nomeCampo, char tipoCampo, int tamanhoCampo, int tChave, char *tabelaApt, char *attApt){
tp_table *e = NULL;
if(t == NULL) // Se a estrutura passada for nula, retorna erro.
return ERRO_ESTRUTURA_TABELA_NULA;
tp_table *aux;
if(t->esquema == NULL){ // Se o campo for o primeiro a ser adicionado, adiciona campo no esquema.
e = (tp_table *)malloc(sizeof(tp_table));
memset(e, 0, sizeof(tp_table));
if (e == NULL) {
return ERRO_DE_ALOCACAO;
}
e->next = NULL;
int n = strlen(nomeCampo)+1;
if (n > TAMANHO_NOME_CAMPO) {
n = TAMANHO_NOME_CAMPO;
}
strncpylower(e->nome, nomeCampo,n); // Copia nome do campo passado para o esquema
e->tipo = tipoCampo; // Copia tipo do campo passado para o esquema
e->tam = tamanhoCampo; // Copia tamanho do campo passado para o esquema
e->chave = tChave; // Copia tipo de chave passado para o esquema
if(strlen(tabelaApt) >= 1)
strcpylower(e->tabelaApt, tabelaApt); //Copia a Tabela Refenciada da FK de chave passado para o esquema;
if(strlen(attApt) >= 1)
strcpylower(e->attApt, attApt); //Copia o Atributo Refenciado da FK de chave passado para o esquema
t->esquema = e;
return t; // Retorna a estrutura
} else {
for(aux = t->esquema; aux != NULL; aux = aux->next){ // Anda até o final da estrutura de campos.
if(aux->next == NULL){ // Adiciona um campo no final.
e = (tp_table *)malloc(sizeof(tp_table));
memset(e, 0, sizeof(*e));
if (e == NULL) {
return ERRO_DE_ALOCACAO;
}
e->next = NULL;
int n = strlen(nomeCampo)+1;
if (n > TAMANHO_NOME_CAMPO) {
n = TAMANHO_NOME_CAMPO;
}
strncpylower(e->nome, nomeCampo,n); // Copia nome do campo passado para o esquema
e->tipo = tipoCampo; // Copia tipo do campo passado para o esquema
e->tam = tamanhoCampo; // Copia tamanho do campo passado para o esquema
e->chave = tChave; // Copia tipo de chave passado para o esquema
strcpylower(e->tabelaApt, tabelaApt); //Copia a Tabela Refenciada da FK de chave passado para o esquema;
strcpylower(e->attApt, attApt); //Copia o Atributo Refenciado da FK de chave passado para o esquema
aux->next = e; // Faz o campo anterior apontar para o campo inserido.
return t;
}
}
}
return t; //Retorna estrutura atualizada.
}
//
// LEITURA DE DICIONARIO E ESQUEMA
tp_table *leSchema (struct fs_objects objeto){
FILE *schema;
int i = 0, cod = 0;
char *tupla = (char *)malloc(sizeof(char)*TAMANHO_NOME_CAMPO);
memset(tupla, 0, TAMANHO_NOME_CAMPO);
char *tuplaT = (char *)malloc(sizeof(char)*TAMANHO_NOME_TABELA+1);
memset(tuplaT, 0, TAMANHO_NOME_TABELA+1);
tp_table *esquema = (tp_table *)malloc(sizeof(tp_table)*(objeto.qtdCampos+1)); // Aloca esquema com a quantidade de campos necessarios.
memset(esquema, 0, (objeto.qtdCampos+1)*sizeof(tp_table));
for (i = 0; i < objeto.qtdCampos+1; i++) {
esquema[i].next = NULL;
}
i = 0;
if(esquema == NULL){
free(tupla);
free(tuplaT);
return ERRO_DE_ALOCACAO;
}
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, "fs_schema.dat");
schema = fopen(directory, "a+b"); // Abre o arquivo de esquemas de tabelas.
if (schema == NULL){
free(tupla);
free(tuplaT);
free(esquema);
return ERRO_ABRIR_ESQUEMA;
}
while((fgetc (schema) != EOF) && (i < objeto.qtdCampos)){ // Varre o arquivo ate encontrar todos os campos com o codigo da tabela.
fseek(schema, -1, 1);
if(fread(&cod, sizeof(int), 1, schema)){ // Le o codigo da tabela.
if(cod == objeto.cod){ // Verifica se o campo a ser copiado e da tabela que esta na estrutura fs_objects.
fread(tupla, sizeof(char), TAMANHO_NOME_CAMPO, schema);
strcpylower(esquema[i].nome,tupla); // Copia dados do campo para o esquema.
fread(&esquema[i].tipo, sizeof(char),1,schema);
fread(&esquema[i].tam, sizeof(int),1,schema);
fread(&esquema[i].chave, sizeof(int),1,schema);
fread(tuplaT, sizeof(char), TAMANHO_NOME_TABELA, schema);
strcpylower(esquema[i].tabelaApt,tuplaT);
fread(tupla, sizeof(char), TAMANHO_NOME_CAMPO, schema);
strcpylower(esquema[i].attApt,tupla);
if (i > 0)
esquema[i-1].next = &esquema[i];
i++;
} else {
fseek(schema, 109, 1); // Pula a quantidade de caracteres para a proxima verificacao (40B do nome, 1B do tipo e 4B do tamanho,4B da chave, 20B do nome da Tabela Apontada e 40B do atributo apontado).
}
}
}
esquema[i].next = NULL;
free(tupla);
free(tuplaT);
fclose(schema);
return esquema;
}
void createDB(char *db_name) {
FILE *DB;
int i, len;
char vec_name [QTD_DB][LEN_DB_NAME],
vec_directory [QTD_DB][LEN_DB_NAME],
create [LEN_DB_NAME+6] = "mkdir data/",
*aux_name_tolower,
valid;
if((DB = fopen("data/DB.dat","a+b")) == NULL) {
printf("ERROR: cannot open file\n");
return;
}
if(strlen(db_name) >= LEN_DB_NAME-1) {
printf("WARNING: database name is too long, it will be truncated\n");
db_name[LEN_DB_NAME-1] = '\0';
}
for(i=0; fgetc (DB) != EOF; i++) {
fseek(DB, -1, 1);
fread(&valid ,sizeof(char), 1, DB);
fread(vec_name[i] ,sizeof(char), LEN_DB_NAME, DB);
fread(vec_directory[i] ,sizeof(char), LEN_DB_NAME, DB);
if(objcmp(vec_name[i], db_name) == 0) {
if(valid) {
fclose(DB);
if(objcmp(db_name, "ibetres") != 0) // banco de dados ja existe
printf("ERROR: database already exists\n");
return;
}
}
}
if(i >= QTD_DB) {
fclose(DB);
printf("ERROR: The amount of databases in this machine exceeded the limit.\n");
return;
}
data_base *SGBD;
SGBD = (data_base*)malloc(sizeof(data_base));
len = strlen(db_name);
memset(SGBD->db_name , 0, LEN_DB_NAME);
memset(SGBD->db_directory , 0, LEN_DB_NAME);
SGBD->valid = 1;
strcpylower(SGBD->db_name , db_name);
strcpylower(SGBD->db_directory , db_name);
strcat(SGBD->db_directory , "/");
SGBD->db_name[len] = '\0';
SGBD->db_directory[len+1] = '\0';
fwrite(SGBD ,sizeof(data_base), 1, DB);
aux_name_tolower = (char *)malloc(sizeof(char) * (strlen(db_name)+1));
strcpylower(aux_name_tolower, db_name);
strcat(create, aux_name_tolower);
free(aux_name_tolower);
if(system(create) == -1) { //verifica se foi possivel criar o diretorio
printf("ERROR: It was not possible to create the database\n");
fclose(DB);
return;
}
fclose(DB);
free(SGBD);
if(objcmp(db_name, "ibetres") != 0)
printf("CREATE DATABASE\n");
}
int verificaChaveFK(char *nomeTabela,column *c, char *nomeCampo, char *valorCampo, char *tabelaApt, char *attApt){
int x,j, erro, page;
char str[20];
char dat[5] = ".dat";
struct fs_objects objeto;
tp_table *tabela;
tp_buffer *bufferpoll;
column *pagina = NULL;
strcpylower(str, tabelaApt);
strcat(str, dat); //Concatena e junta o nome com .dat
erro = existeAtributo(nomeTabela, c);
/*if(erro != SUCCESS )
return ERRO_DE_PARAMETRO;*/
//if(existeAtributo(tabelaApt, c))
//return ERRO_CHAVE_ESTRANGEIRA;
if(iniciaAtributos(&objeto, &tabela, &bufferpoll, tabelaApt) != SUCCESS) {
free(bufferpoll);
free(tabela);
return ERRO_DE_PARAMETRO;
}
erro = SUCCESS;
for(x = 0; erro == SUCCESS; x++)
erro = colocaTuplaBuffer(bufferpoll, x, tabela, objeto);
for (page = 0; page < PAGES; page++) {
if (pagina) free(pagina);
pagina = getPage(bufferpoll, tabela, objeto, page);
if (!pagina) break;
for(j = 0; j < objeto.qtdCampos * bufferpoll[page].nrec; j++){
if (pagina[j].nomeCampo) {
if(objcmp(pagina[j].nomeCampo, attApt) == 0){
if(pagina[j].tipoCampo == 'S'){
if(objcmp(pagina[j].valorCampo, valorCampo) == 0){
free(pagina);
free(bufferpoll);
free(tabela);
return SUCCESS;
}
} else if(pagina[j].tipoCampo == 'I'){
int *n = (int *)&pagina[j].valorCampo[0];
if(*n == atoi(valorCampo)){
free(pagina);
free(bufferpoll);
free(tabela);
return SUCCESS;
}
} else if(pagina[j].tipoCampo == 'D'){
double *nn = (double *)&pagina[j].valorCampo[0];
if(*nn == atof(valorCampo)){
free(pagina);
free(bufferpoll);
free(tabela);
return SUCCESS;
}
} else if(pagina[j].tipoCampo == 'C'){
if(pagina[j].valorCampo == valorCampo){
free(pagina);
free(bufferpoll);
free(tabela);
return SUCCESS;
}
} else {
free(pagina);
free(bufferpoll);
free(tabela);
return ERRO_CHAVE_ESTRANGEIRA;
}
}
}
}
}
if (pagina) free(pagina);
free(bufferpoll);
free(tabela);
return ERRO_CHAVE_ESTRANGEIRA;
}