/** * @author Matija Šestak. * @brief Function that fetches attribute name for some zero-based index * @param *tblName table name * @param index zero-based index * @return attribute name */ char *AK_get_attr_name(char *tblName, int index) { AK_PRO; int num_attr = AK_num_attr(tblName); if (index >= num_attr){ AK_EPI; return NULL; } else { AK_header *header = AK_get_header(tblName); AK_EPI; return (header + index)->att_name; } AK_EPI; }
char* AK_get_table_atribute_types(char* tblName){ int len_attr, num_attr, next_attr, attr_type; int next_address = 0; char attr_buffer[4]; AK_PRO; num_attr = AK_num_attr(tblName); if (num_attr == EXIT_WARNING) { AK_EPI; return NULL; } char *attr = (char *) AK_calloc(1, sizeof (char)); AK_header *table_header = (AK_header *) AK_get_header(tblName); for (next_attr = 0; next_attr < num_attr; next_attr++) { attr_type = (table_header + next_attr)->type; len_attr = sprintf(attr_buffer,"%d",attr_type); attr = (char *) AK_realloc(attr, len_attr + next_address + 1); memcpy(attr + next_address, attr_buffer, len_attr); next_address += len_attr; if (next_attr < num_attr - 1) { memcpy(attr + next_address, ATTR_DELIMITER, 1); next_address++; } else { memcpy(attr + next_address, "\0", 1); } } AK_free(table_header); if (next_address > 0) { AK_EPI; return attr; } else { AK_free(attr); AK_EPI; return NULL; } AK_EPI; }
/** * @author Dino Laktašić. * @brief Get attributes for a given table and store them to the char array * <ol> * <li>Get the number of attributes in a given table</li> * <li>If there is no attributes return NULL</li> * <li>Get the table header for a given table</li> * <li>Initialize struct list_node</li> * <li>For each attribute in table header, insert attribute in the array</li> * <li>Delimit each new attribute with ";" (ATTR_DELIMITER)</li> * <li>return pointer to char array</li> * </ol> * @param *tblName name of the table * @result pointer to char array */ char *AK_rel_eq_get_atrributes_char(char *tblName) { int len_attr, num_attr, next_attr; int next_address = 0; char *attr_name; AK_PRO; num_attr = AK_num_attr(tblName); if (num_attr == -1) { AK_EPI; return NULL; } char *attr = (char *) AK_calloc(1, sizeof (char)); AK_header *table_header = (AK_header *) AK_get_header(tblName); for (next_attr = 0; next_attr < num_attr; next_attr++) { attr_name = (table_header + next_attr)->att_name; len_attr = strlen(attr_name); attr = (char *) AK_realloc(attr, len_attr + next_address + 1); memcpy(attr + next_address, attr_name, len_attr); next_address += len_attr; if (next_attr < num_attr - 1) { memcpy(attr + next_address, ATTR_DELIMITER, 1); next_address++; } else { memcpy(attr + next_address, "\0", 1); } } AK_free(table_header); if (next_address > 0) { AK_EPI; return attr; } else { AK_free(attr); AK_EPI; return NULL; } }
/** * @author Matija Šestak. * @brief Function that fetches zero-based index for atrribute * @param *tblName table name * @param *attrName attribute name * @return zero-based index */ int AK_get_attr_index(char *tblName, char *attrName) { AK_PRO; if (tblName == NULL || attrName == NULL){ AK_EPI; return EXIT_WARNING; } int num_attr = AK_num_attr(tblName); AK_header *header = AK_get_header(tblName); int index = 0; while (index < num_attr) { if (strcmp(attrName, (header + index)->att_name) == 0) { AK_free(header); AK_EPI; return index; } index++; } AK_free(header); AK_EPI; return EXIT_WARNING; }
/** * @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); }
//int AK_selection(char *srcTable, char *dstTable, AK_list *expr) { int AK_selection(char *srcTable, char *dstTable, struct list_node *expr) { AK_PRO; AK_header *t_header = (AK_header *) AK_get_header(srcTable); int num_attr = AK_num_attr(srcTable); int startAddress = AK_initialize_new_segment(dstTable, SEGMENT_TYPE_TABLE, t_header); if (startAddress == EXIT_ERROR) { AK_EPI; return EXIT_ERROR; } Ak_dbg_messg(LOW, REL_OP, "\nTABLE %s CREATED from %s!\n", dstTable, srcTable); table_addresses *src_addr = (table_addresses*) AK_get_table_addresses(srcTable); /* AK_list_elem row_root = (AK_list_elem) AK_malloc(sizeof (AK_list)); Ak_Init_L3(&row_root); */ struct list_node * row_root = (struct list_node *) AK_malloc(sizeof(struct list_node)); Ak_Init_L3(&row_root); int i, j, k, l, type, size, address; char data[MAX_VARCHAR_LENGTH]; for (i = 0; src_addr->address_from[i] != 0; i++) { for (j = src_addr->address_from[i]; j < src_addr->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].type == FREE_INT) break; 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; memcpy(data, &(temp->block->data[address]), size); data[size] = '\0'; Ak_Insert_New_Element(type, data, dstTable, t_header[l].att_name, row_root); } if (AK_check_if_row_satisfies_expression(row_root, expr)) Ak_insert_row(row_root); Ak_DeleteAll_L3(&row_root); } } } AK_free(src_addr); AK_free(t_header); AK_free(row_root); AK_print_table(dstTable); Ak_dbg_messg(LOW, REL_OP, "SELECTION_TEST_SUCCESS\n\n"); AK_EPI; return EXIT_SUCCESS; }