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;
}
int verificaNomeTabela(char *nomeTabela) {
FILE *dicionario;
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);
return ERRO_ABRIR_ARQUIVO;
}
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, nomeTabela) == 0){ // Verifica se o nome dado pelo usuario existe no dicionario de dados.
free(tupla);
fclose(dicionario);
return 1;
}
fseek(dicionario, 28, 1);
}
fclose(dicionario);
free(tupla);
return 0;
}
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;
}
void dropDatabase(char *db_name) {
FILE *DB;
int i;
char vec_name [QTD_DB][LEN_DB_NAME],
vec_directory [QTD_DB][LEN_DB_NAME],
valid;
if(strcmp(db_name, connected.db_name) == 0) {
printf("ERROR: You can not delete the database that you are connected.\n");
return;
}
if((DB = fopen("data/DB.dat","r+b")) == NULL) {
printf("ERROR: cannot open file\n");
return;
}
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) {
valid = 0;
fseek(DB, ((LEN_DB_NAME*2+1)*i), SEEK_SET); // posiciona o cabecote sobre o byte de validade
fwrite(&valid ,sizeof(char), 1, DB); // do banco e apaga ele
char directory[LEN_DB_NAME*2] = "rm data/";
strcat(directory, vec_directory[i]);
strcat(directory, " -R\0");
system(directory);
fclose(DB);
printf("DROP DATABASE\n");
return;
}
}
}
fclose(DB);
printf("ERROR: database does not exist\n");
}
int existeAtributo(char *nomeTabela, column *c){
int erro, x, count;
struct fs_objects objeto;
memset(&objeto, 0, sizeof(struct fs_objects));
tp_table *tabela;
tp_buffer *bufferpoll;
column *aux = NULL;
column *pagina = NULL;
if(iniciaAtributos(&objeto, &tabela, &bufferpoll, nomeTabela) != SUCCESS)
return ERRO_DE_PARAMETRO;
erro = SUCCESS;
for(x = 0; erro == SUCCESS; x++)
erro = colocaTuplaBuffer(bufferpoll, x, tabela, objeto);
pagina = getPage(bufferpoll, tabela, objeto, 0);
if(pagina == NULL){
pagina = getPage(bufferpoll, tabela, objeto, 1);
}
if(pagina != NULL){
count = 0;
for(x = 0; x < objeto.qtdCampos; x++){
if (!pagina[x].nomeCampo) continue;
for(aux = c; aux != NULL; aux=aux->next) {
if (!aux->nomeCampo) continue;
if(objcmp(pagina[x].nomeCampo, aux->nomeCampo) == 0)
count++;
}
}
if(count != objeto.qtdCampos){
free(pagina);
free(bufferpoll);
free(tabela);
return ERRO_DE_PARAMETRO;
}
}
free(pagina);
free(bufferpoll);
free(tabela);
return SUCCESS;
}
char retornaTamanhoTipoDoCampo(char *nomeCampo, table *tab) {
char tipo = 0;
tp_table *temp = tab->esquema;
while(temp != NULL) {
if (objcmp(nomeCampo,temp->nome) == 0) {
tipo = temp->tipo;
return tipo;
}
temp = temp->next;
}
return tipo;
}
int retornaTamanhoValorCampo(char *nomeCampo, table *tab) {
int tam = 0;
tp_table *temp = tab->esquema;
while(temp != NULL) {
if (objcmp(nomeCampo,temp->nome) == 0) {
tam = temp->tam;
return tam;
}
temp = temp->next;
}
return tam;
}
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;
}
/*
* Call the appropriate user-defined routine to handle an object action.
* Returns the value that the routine returned.
*/
VALUE
objcall(int action, VALUE *v1, VALUE *v2, VALUE *v3)
{
FUNC *fp; /* function to call */
STATIC OBJECTACTIONS *oap; /* object to call for */
struct objectinfo *oip; /* information about action */
long index; /* index of function (negative if undefined) */
VALUE val; /* return value */
VALUE tmp; /* temp value */
char name[SYMBOLSIZE+1+1]; /* full name of user routine to call */
size_t namestr_len; /* length of the namestr() return string */
char *namestr_ret; /* namestr() return string */
size_t opi_name_len; /* length of the oip name */
/* initialize VALUEs */
val.v_subtype = V_NOSUBTYPE;
tmp.v_subtype = V_NOSUBTYPE;
if ((unsigned)action > OBJ_MAXFUNC) {
math_error("Illegal action for object call");
/*NOTREACHED*/
}
oip = &objectinfo[action];
if (v1->v_type == V_OBJ) {
oap = v1->v_obj->o_actions;
} else if (v2->v_type == V_OBJ) {
oap = v2->v_obj->o_actions;
} else {
math_error("Object routine called with non-object");
/*NOTREACHED*/
}
index = oap->oa_indices[action];
if (index < 0) {
namestr_ret = namestr(&objectnames, oap->oa_index);
if (namestr_ret == NULL) {
math_error("namestr returned NULL!!!");
/*NOTREACHED*/
}
namestr_len = strlen(namestr_ret);
opi_name_len = strlen(oip->name);
if (namestr_len > (size_t)SYMBOLSIZE-1-opi_name_len) {
math_error("namestr returned a strong too long!!!");
/*NOTREACHED*/
}
name[0] = '\0';
strncpy(name, namestr_ret, namestr_len+1);
strcat(name, "_");
strncat(name, oip->name, opi_name_len+1);
index = adduserfunc(name);
oap->oa_indices[action] = index;
}
fp = NULL;
if (index >= 0)
fp = findfunc(index);
if (fp == NULL) {
switch (oip->error) {
case ERR_PRINT:
objprint(v1->v_obj);
val.v_type = V_NULL;
break;
case ERR_CMP:
val.v_type = V_INT;
if (v1->v_type != v2->v_type) {
val.v_int = 1;
return val;
}
val.v_int = objcmp(v1->v_obj, v2->v_obj);
break;
case ERR_TEST:
val.v_type = V_INT;
val.v_int = objtest(v1->v_obj);
break;
case ERR_POW:
if (v2->v_type != V_NUM) {
math_error("Non-real power");
/*NOTREACHED*/
}
val = objpowi(v1, v2->v_num);
break;
case ERR_ONE:
val.v_type = V_NUM;
val.v_num = qlink(&_qone_);
break;
case ERR_INC:
tmp.v_type = V_NUM;
tmp.v_num = &_qone_;
val = objcall(OBJ_ADD, v1, &tmp, NULL_VALUE);
break;
case ERR_DEC:
tmp.v_type = V_NUM;
tmp.v_num = &_qone_;
val = objcall(OBJ_SUB, v1, &tmp, NULL_VALUE);
break;
case ERR_SQUARE:
val = objcall(OBJ_MUL, v1, v1, NULL_VALUE);
break;
case ERR_VALUE:
copyvalue(v1, &val);
break;
case ERR_ASSIGN:
copyvalue(v2, &tmp);
tmp.v_subtype |= v1->v_subtype;
freevalue(v1);
*v1 = tmp;
val.v_type = V_NULL;
break;
default:
math_error("Function \"%s\" is undefined",
namefunc(index));
/*NOTREACHED*/
}
return val;
}
switch (oip->args) {
case 0:
break;
case 1:
++stack;
stack->v_addr = v1;
stack->v_type = V_ADDR;
break;
case 2:
++stack;
stack->v_addr = v1;
stack->v_type = V_ADDR;
++stack;
stack->v_addr = v2;
stack->v_type = V_ADDR;
break;
case 3:
++stack;
stack->v_addr = v1;
stack->v_type = V_ADDR;
++stack;
stack->v_addr = v2;
stack->v_type = V_ADDR;
++stack;
stack->v_addr = v3;
stack->v_type = V_ADDR;
break;
default:
math_error("Bad number of args to calculate");
/*NOTREACHED*/
}
calculate(fp, oip->args);
switch (oip->retval) {
case A_VALUE:
return *stack--;
case A_UNDEF:
freevalue(stack--);
val.v_type = V_NULL;
break;
case A_INT:
if ((stack->v_type != V_NUM) || qisfrac(stack->v_num)) {
math_error("Integer return value required");
/*NOTREACHED*/
}
index = qtoi(stack->v_num);
qfree(stack->v_num);
stack--;
val.v_type = V_INT;
val.v_int = index;
break;
default:
math_error("Bad object return");
/*NOTREACHED*/
}
return val;
}
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;
}
int finalizaInsert(char *nome, column *c) {
column *auxC, *temp;
int i = 0, x = 0, t, erro, j = 0;
FILE *dados;
struct fs_objects objeto,dicio; // Le dicionario
tp_table *auxT ; // Le esquema
auxT = abreTabela(nome, &dicio, &auxT);
table *tab = (table *)malloc(sizeof(table));
tp_table *tab2 = (tp_table *)malloc(sizeof(struct tp_table));
memset(tab2, 0, sizeof(tp_table));
tab->esquema = abreTabela(nome, &objeto, &tab->esquema);
tab2 = procuraAtributoFK(objeto);
for(j = 0, temp = c; j < objeto.qtdCampos && temp != NULL; j++, temp = temp->next) {
switch(tab2[j].chave) {
case NPK:
erro = SUCCESS;
break;
case PK:
erro = verificaChavePK(nome, temp , temp->nomeCampo, temp->valorCampo);
if (erro == ERRO_CHAVE_PRIMARIA) {
printf("ERROR: duplicate key value violates unique constraint \"%s_pkey\"\nDETAIL: Key (%s)=(%s) already exists.\n", nome, temp->nomeCampo, temp->valorCampo);
free(auxT); // Libera a memoria da estrutura.
//free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_CHAVE_PRIMARIA;
}
if (erro == ERRO_CHAVE_PRIMARIA_NULA) {
printf("ERROR: null value in column '%s' violates not-null constraint \"%s_pkey\"\nDETAIL: Primary Key (%s) is null.\n",temp->nomeCampo,nome,temp->nomeCampo);
free(auxT); // Libera a memoria da estrutura.
//free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_CHAVE_PRIMARIA_NULA;
}
break;
case FK:
if (tab2[j].chave == 2 && strlen(tab2[j].attApt) != 0 && strlen(tab2[j].tabelaApt) != 0) {
erro = verificaChaveFK(nome, temp, tab2[j].nome, temp->valorCampo, tab2[j].tabelaApt, tab2[j].attApt);
if (erro != SUCCESS) {
printf("ERROR: invalid reference to \"%s.%s\". The value \"%s\" does not exist.\n", tab2[j].tabelaApt,tab2[j].attApt,temp->valorCampo);
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_CHAVE_ESTRANGEIRA;
}
}
break;
}
}
if (erro == ERRO_CHAVE_ESTRANGEIRA) {
printf("ERROR: unknown foreign key error.\n");
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_CHAVE_ESTRANGEIRA;
}
if (erro == ERRO_CHAVE_PRIMARIA) {
printf("ERROR: unknown primary key error.\n");
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_CHAVE_PRIMARIA;
}
if (erro == ERRO_DE_PARAMETRO) {
printf("ERROR: invalid parameter.\n");
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_DE_PARAMETRO;
}
char directory[LEN_DB_NAME*2];
strcpy(directory, connected.db_directory);
strcat(directory, dicio.nArquivo);
if((dados = fopen(directory,"a+b")) == NULL) {
printf("ERROR: cannot open file.\n");
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
return ERRO_ABRIR_ARQUIVO;
}
for(auxC = c, t = 0; auxC != NULL; auxC = auxC->next, t++) {
if (t >= dicio.qtdCampos)
t = 0;
if (auxT[t].tipo == 'S') { // Grava um dado do tipo string.
if (sizeof(auxC->valorCampo) > auxT[t].tam && sizeof(auxC->valorCampo) != 8) {
printf("ERROR: invalid string length.\n");
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
fclose(dados);
return ERRO_NO_TAMANHO_STRING;
}
if (objcmp(auxC->nomeCampo, auxT[t].nome) != 0) {
printf("ERROR: column name \"%s\" is not valid.\n", auxC->nomeCampo);
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
fclose(dados);
return ERRO_NOME_CAMPO;
}
char valorCampo[auxT[t].tam];
strncpy(valorCampo, auxC->valorCampo, auxT[t].tam);
strcat(valorCampo, "\0");
fwrite(&valorCampo,sizeof(valorCampo),1,dados);
} else if (auxT[t].tipo == 'I') { // Grava um dado do tipo inteiro.
i = 0;
while (i < strlen(auxC->valorCampo)) {
if (auxC->valorCampo[i] < 48 || auxC->valorCampo[i] > 57) {
printf("ERROR: column \"%s\" expectet integer.\n", auxC->nomeCampo);
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
//free(temp); // Libera a memoria da estrutura.
fclose(dados);
return ERRO_NO_TIPO_INTEIRO;
}
i++;
}
int valorInteiro = 0;
sscanf(auxC->valorCampo,"%d",&valorInteiro);
fwrite(&valorInteiro,sizeof(valorInteiro),1,dados);
} else if (auxT[t].tipo == 'D') { // Grava um dado do tipo double.
x = 0;
while (x < strlen(auxC->valorCampo)) {
if((auxC->valorCampo[x] < 48 || auxC->valorCampo[x] > 57) && (auxC->valorCampo[x] != 46)) {
printf("ERROR: column \"%s\" expect double.\n", auxC->nomeCampo);
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
fclose(dados);
return ERRO_NO_TIPO_DOUBLE;
}
x++;
}
double valorDouble = convertD(auxC->valorCampo);
fwrite(&valorDouble,sizeof(valorDouble),1,dados);
}
else if (auxT[t].tipo == 'C') { // Grava um dado do tipo char.
if (strlen(auxC->valorCampo) > (sizeof(char))) {
printf("ERROR: column \"%s\" expect char.\n", auxC->nomeCampo);
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
fclose(dados);
return ERRO_NO_TIPO_CHAR;
}
char valorChar = auxC->valorCampo[0];
fwrite(&valorChar,sizeof(valorChar),1,dados);
}
}
fclose(dados);
free(tab); // Libera a memoria da estrutura.
free(tab2); // Libera a memoria da estrutura.
free(auxT); // Libera a memoria da estrutura.
free(temp); // Libera a memoria da estrutura.
return SUCCESS;
}
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");
}
