diff --git a/database.db b/database.db
deleted file mode 100644
index 86ff8a4..0000000
Binary files a/database.db and /dev/null differ
diff --git a/src/db.c b/src/db.c
index ab4148f..81bb19a 100644
--- a/src/db.c
+++ b/src/db.c
@@ -10,6 +10,7 @@
 static void write_string(FILE *file, const char *str)
 {
     int len;
+
     len = (int)strlen(str) + 1;
     fwrite(&len, sizeof(int), 1, file);
     fwrite(str, sizeof(char), len, file);
@@ -73,7 +74,8 @@ char *trim_whitespace(char *str)
  */
 int validate_ipv4_address(const char *ip)
 {
-    int segments, ch_count;
+    int segments;
+    int ch_count;
     const char *ptr;
 
     segments = 0;
@@ -132,7 +134,9 @@ Database *create_db(void)
  */
 void free_database(Database *db)
 {
-    int i, j, r;
+    int iter1;
+    int iter2;
+    int row;
     Table *currTable;
     Column *currColumn;
 
@@ -141,19 +145,19 @@ void free_database(Database *db)
         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);
 
-        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);
 
-            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);
@@ -170,13 +174,13 @@ void free_database(Database *db)
  */
 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;
@@ -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)
 {
     Table *table;
+    Column *column;
+    int iter;
+    int column_index;
     char *vals_copy;
     char *token;
-    int col_index;
     char **values;
-    int i;
-    Column *col;
 
     table = find_table(db, table_name);
     if (table == NULL)
@@ -291,7 +295,7 @@ void insert_into_table(Database *db, const char *table_name, const char *values_
     }
 
     token = strtok(vals_copy, ",");
-    col_index = 0;
+    column_index = 0;
     values = malloc(sizeof(char*) * table->column_count);
     if (values == NULL)
     {
@@ -300,51 +304,51 @@ void insert_into_table(Database *db, const char *table_name, const char *values_
         return;
     }
 
-    while (token != NULL && col_index < table->column_count)
+    while (token != NULL && column_index < table->column_count)
     {
         token = trim_whitespace(token);
         /* 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))
             {
                 printf("Error: Invalid IPv4 address '%s'.\n", token);
                 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);
                 return;
             }
         }
-        values[col_index++] = strdup(token);
+        values[column_index++] = strdup(token);
         token = strtok(NULL, ",");
     }
     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);
-        for (i = 0; i < col_index; i++)
+        for (iter = 0; iter < column_index; iter++)
         {
-            free(values[i]);
+            free(values[iter]);
         }
         free(values);
         return;
     }
 
-    for (i = 0; i < table->column_count; i++)
+    for (iter = 0; iter < table->column_count; iter++)
     {
-        col = table->columns[i];
-        col->data = realloc(col->data, sizeof(char*) * (table->row_count + 1));
-        if (col->data == NULL)
+        column = table->columns[iter];
+        column->data = realloc(column->data, sizeof(char*) * (table->row_count + 1));
+        if (column->data == NULL)
         {
             printf("Error: Memory allocation failed while inserting row.\n");
             free(values);
             return;
         }
-        col->data[table->row_count] = values[i];
+        column->data[table->row_count] = values[iter];
     }
     free(values);
     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)
 {
     Table *table;
-    int i, c, r;
+    int iter;
+    int column;
+    int row;
 
     table = find_table(db, table_name);
     if (table == NULL)
@@ -366,17 +372,17 @@ void select_from_table(Database *db, const char *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");
 
-    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");
     }
@@ -387,9 +393,11 @@ void select_from_table(Database *db, const char *table_name)
 void save_database_to_file(Database *db, const char *filename)
 {
     FILE *file;
-    int i, j, r;
     Table *table;
     Column *col;
+    int iter1;
+    int iter2;
+    int row;
 
     file = fopen(filename, "wb");
     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);
-    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);
         fwrite(&table->column_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);
-            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;
     Database *new_db;
-    int table_count;
-    int i, j, r;
     Table *table;
     Column *col;
+    int table_count;
+    int iter1;
+    int iter2;
+    int row;
     char *cell;
 
     file = fopen(filename, "rb");
@@ -450,7 +460,7 @@ Database *load_database_from_file(Database *db, const char *filename)
 
     table_count = 0;
     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));
         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);
         table->columns = NULL;
 
-        for (j = 0; j < table->column_count; j++)
+        for (iter2 = 0; iter2 < table->column_count; iter2++)
         {
             col = malloc(sizeof(Column));
             if (col == NULL)
@@ -475,35 +485,35 @@ Database *load_database_from_file(Database *db, const char *filename)
             col->name = read_string(file);
             col->data = NULL;
 
-            for (r = 0; r < table->row_count; r++)
+            for (row = 0; row < table->row_count; row++)
             {
                 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)
                 {
                     printf("Error: Memory allocation failed while loading row data.\n");
                     free(cell);
                     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)
             {
                 printf("Error: Memory allocation failed while loading columns array.\n");
                 free(col);
                 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)
         {
             printf("Error: Memory allocation failed while adding table to database.\n");
             free(table);
             continue;
         }
-        new_db->tables[i] = table;
+        new_db->tables[iter1] = table;
         new_db->table_count++;
     }
     fclose(file);