/**
* @author Matija Šestak.
* @brief Function that fetches a value in some row and column
* @param row zero-based row index
* @param column zero-based column index
* @param *tblName table name
* @return value in the list
*/
struct list_node *AK_get_tuple(int row, int column, char *tblName) {
AK_PRO;
int num_rows = AK_get_num_records(tblName);
int num_attr = AK_num_attr(tblName);
if (row >= num_rows || column >= num_attr){
AK_EPI;
return NULL;
}
table_addresses *addresses = (table_addresses*) AK_get_table_addresses(tblName);
struct list_node *row_root = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&row_root);
int i, j, k, counter;
char data[ MAX_VARCHAR_LENGTH ];
i = 0;
counter = -1;
while (addresses->address_from[ i ] != 0)
{
for (j = addresses->address_from[ i ]; j < addresses->address_to[ i ]; j++)
{
AK_mem_block *temp = (AK_mem_block*) AK_get_block(j);
if (temp->block->last_tuple_dict_id == 0) break;
for (k = 0; k < DATA_BLOCK_SIZE; k += num_attr)
{
if (temp->block->tuple_dict[k].size > 0)
counter++;
if (counter == row)
{
struct list_node *next;
int type = temp->block->tuple_dict[ k + column ].type;
int size = temp->block->tuple_dict[ k + column ].size;
int address = temp->block->tuple_dict[ k + column ].address;
memcpy(data, &(temp->block->data[address]), size);
data[ size ] = '\0';
Ak_InsertAtEnd_L3(type, data, size, row_root);
AK_free(addresses);
next = Ak_First_L2(row_root); //store next
AK_free(row_root); //now we can free base
AK_EPI;
//returns next in row_root leaving base of the list allocated, so we made some corrections
//return (struct list_node *) Ak_First_L2(row_root);
return next; //returns next
}
}
}
i++;
}
AK_free(addresses);
Ak_DeleteAll_L3(&row_root);
AK_free(row_root);
AK_EPI;
return NULL;
}
/**
* @author Jurica Hlevnjak, updated by Tomislav Ilisevic
* @brief Help function for checking if the element(view, function, sequence, user ...) exist in system catalog table
* @param tblName name of table, index view, function, trigger, sequence, user, group or constraint
* @param sys_table name of system catalog table
* @return if element exist in system catalog returns 1, if not returns 0
*/
int AK_if_exist(char *tblName, char *sys_table) {
AK_PRO;
int num_rows = AK_get_num_records(sys_table);
int a;
struct list_node *el;
for (a = 0; a < num_rows; a++)
{
el = AK_get_tuple(a, 1, sys_table);
if (!strcmp(tblName, el->data))
{
Ak_DeleteAll_L3(&el);
AK_free(el);
return 1; // exist
}
Ak_DeleteAll_L3(&el);
AK_free(el);
}
AK_EPI;
return 0; // not exist
}
/**
* @author Matija Šestak, modified for indexes by Lovro Predovan
* @brief Function examines whether there is a table with the name "tblName" in the system catalog (AK_relation)
* @param tblName table name
* @return returns 1 if table exist or returns 0 if table does not exist
*/
int AK_index_table_exist(char *indexTblName) {
AK_PRO;
char *index_table = "AK_index";
int exists = 0;
int num_rows = AK_get_num_records(index_table);
int a;
if(num_rows==0){
return exists;
}
for (a = 0; a < num_rows; a++) {
struct list_node *el;
el = AK_get_tuple(a, 1, index_table);
if (strcmp(indexTblName, el->data)==0) {
exists = 1;
break;
}
}
AK_EPI;
return exists;
}
/**
* @author Jurica Hlevnjak
* @brief Function that examines whether there is a table with the name "tblName" in the system catalog (AK_relation)
* @param tblName table name
* @return returns 1 if table exist or returns 0 if table does not exist
*/
int AK_table_exist(char *tblName) {
AK_PRO;
char *sys_table = "AK_relation";
int num_rows = AK_get_num_records(sys_table);
int a;
int exist = 0;
struct list_node *el;
for (a = 0; a < num_rows; a++)
{
el = AK_get_tuple(a, 1, sys_table);
if (!strcmp(tblName, el->data))
{
exist = 1;
Ak_DeleteAll_L3(&el);
AK_free(el);
break;
}
Ak_DeleteAll_L3(&el);
AK_free(el);
}
AK_EPI;
return exist;
}
/**
* @author Dino Laktašić and Mislav Čakarić (replaced old print table function by new one)
* update by Luka Rajcevic
* @brief Function that prints a table
* @param *tblName table name
* @return No return value
* update by Anto Tomaš (corrected the Ak_DeleteAll_L3 function)
*/
void AK_print_table_to_file(char *tblName) {
char* FILEPATH = "table_test.txt";
FILE *fp;
AK_PRO;
fp = fopen(FILEPATH, "a");
table_addresses *addresses = (table_addresses*) AK_get_table_addresses(tblName);
if (addresses->address_from[0] == 0) {
fprintf(fp, "Table %s does not exist!\n", tblName);
} else {
AK_header *head = AK_get_header(tblName);
int i, j, k, l;
int num_attr = AK_num_attr(tblName);
int num_rows = AK_get_num_records(tblName);
int len[num_attr]; //max length for each attribute in row
int length = 0; //length of spacer
//store lengths of header attributes
for (i = 0; i < num_attr; i++) {
len[i] = strlen((head + i)->att_name);
}
//for each header attribute iterate through all table rows and check if
//there is longer element than previously longest and store it in array
for (i = 0; i < num_attr; i++) {
for (j = 0; j < num_rows; j++) {
struct list_node *el = AK_get_tuple(j, i, tblName);
switch (el->type) {
case TYPE_INT:
length = AK_chars_num_from_number(*((int *) (el)->data), 10);
if (len[i] < length) {
len[i] = length;
}
break;
case TYPE_FLOAT:
length = AK_chars_num_from_number(*((float *) (el)->data), 10);
if (len[i] < length) {
len[i] = length;
}
break;
case TYPE_VARCHAR:
default:
if (len[i] < el->size) {
len[i] = el->size;
}
break;
}
}
}
//num_attr is number of char | + space in printf
//set offset to change the box size
length = 0;
for (i = 0; i < num_attr; length += len[i++]);
length += num_attr * TBL_BOX_OFFSET + 2 * num_attr + 1;
fprintf(fp, "Table: %s\n", tblName);
if (num_attr <= 0 || num_rows <= 0) {
fprintf(fp, "Table is empty.\n");
} else {
//print table header
fclose(fp);
AK_print_row_spacer_to_file(len, length);
fp = fopen(FILEPATH, "a");
fprintf(fp, "\n|");
for (i = 0; i < num_attr; i++) {
//print attributes center aligned inside box
k = (len[i] - (int) strlen((head + i)->att_name) + TBL_BOX_OFFSET + 1);
if (k % 2 == 0) {
k /= 2;
fprintf(fp, "%-*s%-*s|", k, " ", k + (int) strlen((head + i)->att_name), (head + i)->att_name);
} else {
k /= 2;
fprintf(fp, "%-*s%-*s|", k, " ", k + (int) strlen((head + i)->att_name) + 1, (head + i)->att_name);
}
//print attributes left aligned inside box
//printf(" %-*s|", len[i] + MAX_TABLE_BOX_OFFSET, (head + i)->att_name);
}
fprintf(fp, "\n");
fclose(fp);
AK_print_row_spacer_to_file(len, length);
struct list_node *row_root = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&row_root);
i = 0;
int type, size, address;
while (addresses->address_from[i] != 0) {
for (j = addresses->address_from[i]; j < addresses->address_to[i]; j++) {
AK_mem_block *temp = (AK_mem_block*) AK_get_block(j);
if (temp->block->last_tuple_dict_id == 0)
break;
for (k = 0; k < DATA_BLOCK_SIZE; k += num_attr) {
if (temp->block->tuple_dict[k].size > 0) {
for (l = 0; l < num_attr; l++) {
type = temp->block->tuple_dict[k + l].type;
size = temp->block->tuple_dict[k + l].size;
address = temp->block->tuple_dict[k + l].address;
Ak_InsertAtEnd_L3(type, &(temp->block->data[address]), size, row_root);
}
AK_print_row_to_file(len, row_root);
AK_print_row_spacer_to_file(len, length);
Ak_DeleteAll_L3(&row_root);
}
}
}
i++;
}
fp = fopen(FILEPATH, "a");
fprintf(fp, "\n");
}
}
fclose(fp);
AK_EPI;
}
/**
* @author Dino Laktašić and Mislav Čakarić (replaced old print table function by new one)
* @brief Function for printing table
* @param *tblName table name
* @return No return value
*/
void AK_print_table(char *tblName) {
AK_PRO;
table_addresses *addresses = (table_addresses*) AK_get_table_addresses(tblName);
// || (AK_table_exist(tblName) == 0)
if ((addresses->address_from[0] == 0) || (AK_table_exist(tblName) == 0)) {
printf("Table %s does not exist!\n", tblName);
AK_free(addresses);
} else {
AK_header *head = AK_get_header(tblName);
int i, j, k, l;
int num_attr = AK_num_attr(tblName);
int num_rows = AK_get_num_records(tblName);
int len[num_attr]; //max length for each attribute in row
int length = 0; //length of spacer
clock_t t;
//store lengths of header attributes
for (i = 0; i < num_attr; i++) {
len[i] = strlen((head + i)->att_name);
}
//for each header attribute iterate through all table rows and check if
//there is longer element than previously longest and store it in array
for (i = 0; i < num_attr; i++) {
for (j = 0; j < num_rows; j++)
{
struct list_node *el = AK_get_tuple(j, i, tblName);
switch (el->type)
{
case TYPE_INT:
length = AK_chars_num_from_number(*((int *) (el)->data), 10);
if (len[i] < length)
{
len[i] = length;
}
break;
case TYPE_FLOAT:
length = AK_chars_num_from_number(*((float *) (el)->data), 10);
if (len[i] < length)
{
len[i] = length;
}
break;
case TYPE_VARCHAR:
default:
if (len[i] < el->size)
{
len[i] = el->size;
}
break;
}
//we don't need this linked list anymore (starting from tupple first to the end
//see comment above in function AK_get_tuple - Elvis Popovic
Ak_DeleteAll_L3(&el);
AK_free(el);
}
}
//num_attr is number of char | + space in printf
//set offset to change the box size
length = 0;
for (i = 0; i < num_attr; length += len[i++]);
length += num_attr * TBL_BOX_OFFSET + 2 * num_attr + 1;
//start measuring time
t = clock();
printf("Table: %s\n", tblName);
if (num_attr <= 0 || num_rows <= 0) {
printf("Table is empty.\n");
} else {
//print table header
AK_print_row_spacer(len, length);
printf("\n|");
for (i = 0; i < num_attr; i++) {
//print attributes center aligned inside box
k = (len[i] - (int) strlen((head + i)->att_name) + TBL_BOX_OFFSET + 1);
if (k % 2 == 0) {
k /= 2;
printf("%-*s%-*s|", k, " ", k + (int) strlen((head + i)->att_name), (head + i)->att_name);
} else {
k /= 2;
printf("%-*s%-*s|", k, " ", k + (int) strlen((head + i)->att_name) + 1, (head + i)->att_name);
}
//print attributes left aligned inside box
//printf(" %-*s|", len[i] + MAX_TABLE_BOX_OFFSET, (head + i)->att_name);
}
AK_free(head);
printf("\n");
AK_print_row_spacer(len, length);
struct list_node *row_root = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&row_root);
i = 0;
int type, size, address;
while (addresses->address_from[i] != 0) {
for (j = addresses->address_from[i]; j < addresses->address_to[i]; j++) {
AK_mem_block *temp = (AK_mem_block*) AK_get_block(j);
if (temp->block->last_tuple_dict_id == 0)
break;
for (k = 0; k < DATA_BLOCK_SIZE; k += num_attr) {
if (temp->block->tuple_dict[k].size > 0 /*&& k / num_attr < num_rows*/) {
for (l = 0; l < num_attr; l++) {
type = temp->block->tuple_dict[k + l].type;
size = temp->block->tuple_dict[k + l].size;
address = temp->block->tuple_dict[k + l].address;
Ak_InsertAtEnd_L3(type, &temp->block->data[address], size, row_root);
}
AK_print_row(len, row_root);
AK_print_row_spacer(len, length);
Ak_DeleteAll_L3(&row_root);
}
}
}
i++;
}
printf("\n");
t = clock() - t;
if ((((double) t) / CLOCKS_PER_SEC) < 0.1) {
printf("%i rows found, duration: %f μs\n", num_rows, ((double) t) / CLOCKS_PER_SEC * 1000);
} else {
printf("%i rows found, duration: %f s\n", num_rows, ((double) t) / CLOCKS_PER_SEC);
}
AK_free(row_root);
}
AK_free(addresses);
}
AK_EPI;
}
/**
* @author Unknown
* @brief Function for testing table abstraction
* @return No return value
@update by Ana-Marija Balen - added getRow function to the test
*/
TestResult AK_table_test() {
AK_PRO;
printf("table.c: Present!\n");
printf("\n********** TABLE ABSTRACTION TEST by Matija Šestak **********\n\n");
printf("Table \"student\":AK_print_table\n");
AK_print_table("student");
printf("\n");
printf("Table \"student\": AK_table_empty: ");
if (AK_table_empty("student"))
printf("true\n");
else
printf("false\n");
printf("\n");
printf("Table \"student\": AK_num_attr: ");
printf("%d\n", AK_num_attr("student"));
printf("\n");
int get_num_records;
printf("Table \"student\": AK_get_num_records: ");
printf("%d\n", get_num_records = AK_get_num_records("student"));
printf("\n");
printf("Table \"student\": AK_get_row: ");
int i;
AK_header *head = AK_get_header("student");
int num_attr = AK_num_attr("student");
int len[num_attr];
for (i = 0; i < num_attr; i++) {
len[i] = strlen((head + i)->att_name);
}
AK_print_row(len, AK_get_row(0,"student"));
printf("\n");
printf("Table \"student\": AK_get_attr_name for index 3: ");
int get_attr_name;
printf("%s\n", get_attr_name = AK_get_attr_name("student", 3));
printf("\n");
int get_attr_index;
printf("Table \"student\": AK_get_attr_index of \"year\": ");
printf("%d\n", get_attr_index = AK_get_attr_index("student", "year"));
printf("\n");
int tuple_to_string;
printf("Table \"student\": AK_get_tuple for row=0, column=1:");
printf("%s\n", tuple_to_string = AK_tuple_to_string(AK_get_tuple(0, 1, "student")));
if (get_num_records != EXIT_WARNING & get_attr_name != NULL & get_attr_index != EXIT_WARNING & tuple_to_string != NULL) {
printf("\nTest succeeded!\n");
}
else{
printf("\nTest failed!\n");
}
AK_EPI;
return TEST_result(0,0);
}
