enty8080/SimpleDB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed declarations for clarity.

Browse Source
This commit is contained in:
Gigachad 2025-03-02 23:41:35 +00:00
parent 127d1e1917
commit 5880b399d1
2 changed files with 63 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
database.db
View File

Binary file not shown.

116
src/db.c
View File

@ -10,6 +10,7 @@
static void write_string(FILE *file, const char *str) static void write_string(FILE *file, const char *str)
{ {
int len; int len;
len = (int)strlen(str) + 1; len = (int)strlen(str) + 1;
fwrite(&len, sizeof(int), 1, file); fwrite(&len, sizeof(int), 1, file);
fwrite(str, sizeof(char), len, file); fwrite(str, sizeof(char), len, file);
@ -73,7 +74,8 @@ char *trim_whitespace(char *str)
*/ */
int validate_ipv4_address(const char *ip) int validate_ipv4_address(const char *ip)
{ {
int segments, ch_count; int segments;
int ch_count;
const char *ptr; const char *ptr;
segments = 0; segments = 0;
@ -132,7 +134,9 @@ Database *create_db(void)
*/ */
void free_database(Database *db) void free_database(Database *db)
{ {
int i, j, r; int iter1;
int iter2;
int row;
Table *currTable; Table *currTable;
Column *currColumn; Column *currColumn;
@ -141,19 +145,19 @@ void free_database(Database *db)
return; return;
} }
for (i = 0; i < db->table_count; i++) for (iter1 = 0; iter1 < db->table_count; iter1++)
{ {
currTable = db->tables[i]; currTable = db->tables[iter1];
free(currTable->name); free(currTable->name);
for (j = 0; j < currTable->column_count; j++) for (iter2 = 0; iter2 < currTable->column_count; iter2++)
{ {
currColumn = currTable->columns[j]; currColumn = currTable->columns[iter2];
free(currColumn->name); free(currColumn->name);
for (r = 0; r < currTable->row_count; r++) for (row = 0; row < currTable->row_count; row++)
{ {
free(currColumn->data[r]); free(currColumn->data[row]);
} }
free(currColumn->data); free(currColumn->data);
free(currColumn); free(currColumn);
@ -170,13 +174,13 @@ void free_database(Database *db)
*/ */
Table *find_table(Database *db, const char *table_name) Table *find_table(Database *db, const char *table_name)
{ {
int i; int iter;
for (i = 0; i < db->table_count; i++) for (iter = 0; iter < db->table_count; iter++)
{ {
if (strcmp(db->tables[i]->name, table_name) == 0) if (strcmp(db->tables[iter]->name, table_name) == 0)
{ {
return db->tables[i]; return db->tables[iter];
} }
} }
return NULL; return NULL;
@ -269,12 +273,12 @@ void create_table(Database *db, const char *table_name, const char *columns_str)
void insert_into_table(Database *db, const char *table_name, const char *values_str) void insert_into_table(Database *db, const char *table_name, const char *values_str)
{ {
Table *table; Table *table;
Column *column;
int iter;
int column_index;
char *vals_copy; char *vals_copy;
char *token; char *token;
int col_index;
char **values; char **values;
int i;
Column *col;
table = find_table(db, table_name); table = find_table(db, table_name);
if (table == NULL) if (table == NULL)
@ -291,7 +295,7 @@ void insert_into_table(Database *db, const char *table_name, const char *values_
} }
token = strtok(vals_copy, ","); token = strtok(vals_copy, ",");
col_index = 0; column_index = 0;
values = malloc(sizeof(char*) * table->column_count); values = malloc(sizeof(char*) * table->column_count);
if (values == NULL) if (values == NULL)
{ {
@ -300,51 +304,51 @@ void insert_into_table(Database *db, const char *table_name, const char *values_
return; return;
} }
while (token != NULL && col_index < table->column_count) while (token != NULL && column_index < table->column_count)
{ {
token = trim_whitespace(token); token = trim_whitespace(token);
/* Validate IPv4 address if required */ /* Validate IPv4 address if required */
if (strcmp(table->columns[col_index]->name, "IPv4") == 0) if (strcmp(table->columns[column_index]->name, "IPv4") == 0)
{ {
if (!validate_ipv4_address(token)) if (!validate_ipv4_address(token))
{ {
printf("Error: Invalid IPv4 address '%s'.\n", token); printf("Error: Invalid IPv4 address '%s'.\n", token);
free(vals_copy); free(vals_copy);
for (i = 0; i < col_index; i++) for (iter = 0; iter < column_index; iter++)
{ {
free(values[i]); free(values[iter]);
} }
free(values); free(values);
return; return;
} }
} }
values[col_index++] = strdup(token); values[column_index++] = strdup(token);
token = strtok(NULL, ","); token = strtok(NULL, ",");
} }
free(vals_copy); free(vals_copy);
if (col_index != table->column_count) if (column_index != table->column_count)
{ {
printf("Error: Column count mismatch for table '%s'.\n", table_name); printf("Error: Column count mismatch for table '%s'.\n", table_name);
for (i = 0; i < col_index; i++) for (iter = 0; iter < column_index; iter++)
{ {
free(values[i]); free(values[iter]);
} }
free(values); free(values);
return; return;
} }
for (i = 0; i < table->column_count; i++) for (iter = 0; iter < table->column_count; iter++)
{ {
col = table->columns[i]; column = table->columns[iter];
col->data = realloc(col->data, sizeof(char*) * (table->row_count + 1)); column->data = realloc(column->data, sizeof(char*) * (table->row_count + 1));
if (col->data == NULL) if (column->data == NULL)
{ {
printf("Error: Memory allocation failed while inserting row.\n"); printf("Error: Memory allocation failed while inserting row.\n");
free(values); free(values);
return; return;
} }
col->data[table->row_count] = values[i]; column->data[table->row_count] = values[iter];
} }
free(values); free(values);
table->row_count++; table->row_count++;
@ -356,7 +360,9 @@ void insert_into_table(Database *db, const char *table_name, const char *values_
void select_from_table(Database *db, const char *table_name) void select_from_table(Database *db, const char *table_name)
{ {
Table *table; Table *table;
int i, c, r; int iter;
int column;
int row;
table = find_table(db, table_name); table = find_table(db, table_name);
if (table == NULL) if (table == NULL)
@ -366,17 +372,17 @@ void select_from_table(Database *db, const char *table_name)
} }
printf("Table: %s\n", table->name); printf("Table: %s\n", table->name);
for (i = 0; i < table->column_count; i++) for (iter = 0; iter < table->column_count; iter++)
{ {
printf("%s\t", table->columns[i]->name); printf("%s\t", table->columns[iter]->name);
} }
printf("\n"); printf("\n");
for (r = 0; r < table->row_count; r++) for (row = 0; row < table->row_count; row++)
{ {
for (c = 0; c < table->column_count; c++) for (column = 0; column < table->column_count; column++)
{ {
printf("%s\t", table->columns[c]->data[r]); printf("%s\t", table->columns[column]->data[row]);
} }
printf("\n"); printf("\n");
} }
@ -387,9 +393,11 @@ void select_from_table(Database *db, const char *table_name)
void save_database_to_file(Database *db, const char *filename) void save_database_to_file(Database *db, const char *filename)
{ {
FILE *file; FILE *file;
int i, j, r;
Table *table; Table *table;
Column *col; Column *col;
int iter1;
int iter2;
int row;
file = fopen(filename, "wb"); file = fopen(filename, "wb");
if (file == NULL) if (file == NULL)
@ -399,20 +407,20 @@ void save_database_to_file(Database *db, const char *filename)
} }
fwrite(&db->table_count, sizeof(int), 1, file); fwrite(&db->table_count, sizeof(int), 1, file);
for (i = 0; i < db->table_count; i++) for (iter1 = 0; iter1 < db->table_count; iter1++)
{ {
table = db->tables[i]; table = db->tables[iter1];
write_string(file, table->name); write_string(file, table->name);
fwrite(&table->column_count, sizeof(int), 1, file); fwrite(&table->column_count, sizeof(int), 1, file);
fwrite(&table->row_count, sizeof(int), 1, file); fwrite(&table->row_count, sizeof(int), 1, file);
for (j = 0; j < table->column_count; j++) for (iter2 = 0; iter2 < table->column_count; iter2++)
{ {
col = table->columns[j]; col = table->columns[iter2];
write_string(file, col->name); write_string(file, col->name);
for (r = 0; r < table->row_count; r++) for (row = 0; row < table->row_count; row++)
{ {
write_string(file, col->data[r]); write_string(file, col->data[row]);
} }
} }
} }
@ -427,10 +435,12 @@ Database *load_database_from_file(Database *db, const char *filename)
{ {
FILE *file; FILE *file;
Database *new_db; Database *new_db;
int table_count;
int i, j, r;
Table *table; Table *table;
Column *col; Column *col;
int table_count;
int iter1;
int iter2;
int row;
char *cell; char *cell;
file = fopen(filename, "rb"); file = fopen(filename, "rb");
@ -450,7 +460,7 @@ Database *load_database_from_file(Database *db, const char *filename)
table_count = 0; table_count = 0;
fread(&table_count, sizeof(int), 1, file); fread(&table_count, sizeof(int), 1, file);
for (i = 0; i < table_count; i++) for (iter1 = 0; iter1 < table_count; iter1++)
{ {
table = malloc(sizeof(Table)); table = malloc(sizeof(Table));
if (table == NULL) if (table == NULL)
@ -464,7 +474,7 @@ Database *load_database_from_file(Database *db, const char *filename)
fread(&table->row_count, sizeof(int), 1, file); fread(&table->row_count, sizeof(int), 1, file);
table->columns = NULL; table->columns = NULL;
for (j = 0; j < table->column_count; j++) for (iter2 = 0; iter2 < table->column_count; iter2++)
{ {
col = malloc(sizeof(Column)); col = malloc(sizeof(Column));
if (col == NULL) if (col == NULL)
@ -475,35 +485,35 @@ Database *load_database_from_file(Database *db, const char *filename)
col->name = read_string(file); col->name = read_string(file);
col->data = NULL; col->data = NULL;
for (r = 0; r < table->row_count; r++) for (row = 0; row < table->row_count; row++)
{ {
cell = read_string(file); cell = read_string(file);
col->data = realloc(col->data, sizeof(char*) * (r + 1)); col->data = realloc(col->data, sizeof(char*) * (row + 1));
if (col->data == NULL) if (col->data == NULL)
{ {
printf("Error: Memory allocation failed while loading row data.\n"); printf("Error: Memory allocation failed while loading row data.\n");
free(cell); free(cell);
continue; continue;
} }
col->data[r] = cell; col->data[row] = cell;
} }
table->columns = realloc(table->columns, sizeof(Column*) * (j + 1)); table->columns = realloc(table->columns, sizeof(Column*) * (iter2 + 1));
if (table->columns == NULL) if (table->columns == NULL)
{ {
printf("Error: Memory allocation failed while loading columns array.\n"); printf("Error: Memory allocation failed while loading columns array.\n");
free(col); free(col);
continue; continue;
} }
table->columns[j] = col; table->columns[iter2] = col;
} }
new_db->tables = realloc(new_db->tables, sizeof(Table*) * (i + 1)); new_db->tables = realloc(new_db->tables, sizeof(Table*) * (iter1 + 1));
if (new_db->tables == NULL) if (new_db->tables == NULL)
{ {
printf("Error: Memory allocation failed while adding table to database.\n"); printf("Error: Memory allocation failed while adding table to database.\n");
free(table); free(table);
continue; continue;
} }
new_db->tables[i] = table; new_db->tables[iter1] = table;
new_db->table_count++; new_db->table_count++;
} }
fclose(file); fclose(file);