/**
* @author Krunoslav Bilić
* @brief Function for selection operator testing
*
*/
void AK_op_selection_test2() {
AK_PRO;
printf("\n********** SELECTION TEST 2**********\n");
struct list_node *expr = (struct list_node *) AK_malloc(sizeof(struct list_node));
Ak_Init_L3(&expr);
char *srcTable = "student";
char *destTable = "selection_test2";
char num = 23;
strcpy(expr->table,destTable);
Ak_InsertAtEnd_L3(TYPE_ATTRIBS, "year", sizeof ("year"), expr);
Ak_InsertAtEnd_L3(TYPE_INT, &num, sizeof (int), expr);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, ">", sizeof (">"), expr);
Ak_InsertAtEnd_L3(TYPE_ATTRIBS, "firstname", sizeof ("firstname"), expr);
Ak_InsertAtEnd_L3(TYPE_VARCHAR, "Mislav", sizeof ("Mislav"), expr);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, "=", sizeof ("="), expr);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, "OR", sizeof ("OR"), expr);
printf("\nQUERY: SELECT * FROM student WHERE year > 2023 OR firstname = 'Mislav';\n\n");
AK_selection(srcTable, destTable, expr);
//AK_print_table("selection_test");
Ak_DeleteAll_L3(&expr);
AK_free(expr);
AK_EPI;
}
/**
* @author Matija Šestak, updated by Dino Laktašić,Nikola Miljancic
* @brief Function for selection operator testing
*
*/
void AK_op_selection_test() {
AK_PRO;
printf("\n********** SELECTION TEST **********\n");
struct list_node *expr = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&expr);
char *srcTable = "student";
char *destTable = "selection_test";
int num = 2010;
strcpy(expr->table,destTable);
Ak_InsertAtEnd_L3(TYPE_ATTRIBS, "year", sizeof ("year"), expr);
Ak_InsertAtEnd_L3(TYPE_INT, &num, sizeof (int), expr);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, ">", sizeof (">"), expr);
Ak_InsertAtEnd_L3(TYPE_ATTRIBS, "firstname", sizeof ("firstname"), expr);
Ak_InsertAtEnd_L3(TYPE_VARCHAR, "Robert", sizeof ("Robert"), expr);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, "=", sizeof ("="), expr);
//Ak_InsertAtEnd_L3(TYPE_OPERATOR, "OR", sizeof ("OR"), expr);
Ak_InsertAtEnd_L3( TYPE_OPERATOR, "AND", sizeof("AND"), expr );
printf("\nQUERY: SELECT * FROM student WHERE year > 2010 AND firstname = 'Robert';\n\n");
AK_selection(srcTable, destTable, expr);
Ak_DeleteAll_L3(&expr);
AK_free(expr);
struct list_node *expr1 = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&expr1);
char *srcTable1 = "student";
char *destTable1 = "selection_test1";
float weight = 83.750;
strcpy(expr1->table,destTable1);
Ak_InsertAtEnd_L3( TYPE_ATTRIBS, "weight", sizeof("weight"), expr1 );
Ak_InsertAtEnd_L3( TYPE_FLOAT, &weight, sizeof(float), expr1 );
Ak_InsertAtEnd_L3( TYPE_OPERATOR, ">", sizeof(">"), expr1 );
Ak_InsertAtEnd_L3(TYPE_ATTRIBS, "firstname", sizeof ("firstname"), expr1);
Ak_InsertAtEnd_L3(TYPE_VARCHAR, "Dino", sizeof ("Robert"), expr1);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, "=", sizeof ("="), expr1);
Ak_InsertAtEnd_L3(TYPE_OPERATOR, "OR", sizeof ("OR"), expr1);
printf("\nQUERY: SELECT * FROM student WHERE weight > 83.750 OR firstname = 'Dino';\n\n");
AK_selection(srcTable1, destTable1, expr1);
printf("\n Test is successful :) \n");
Ak_DeleteAll_L3(&expr1);
AK_free(expr1);
AK_EPI;
}
/**
* @author Mislav Čakarić edited by Ljubo Barać
* @brief Function for renaming table and/or attribute in table (moved from rename.c)
* @param old_table_name old name of the table
* @param new_table_name new name of the table
* @param old_attr name of the attribute to rename
* @param new_attr new name for the attribute to rename
* @return EXIT_ERROR or EXIT_SUCCESS
*/
int AK_rename(char *old_table_name, char *old_attr, char *new_table_name, char *new_attr) {
AK_PRO;
table_addresses *adresses = (table_addresses *) AK_get_table_addresses(old_table_name);
int tab_addresses[MAX_NUM_OF_BLOCKS];
int num_extents = 0, num_blocks = 0;
register int i, j;
AK_mem_block *mem_block;
if (strcmp(old_attr, new_attr) != 0) {
//SEARCH FOR ALL BLOCKS IN SEGMENT
i = 0;
while (adresses->address_from[i]) {
for (j = adresses->address_from[i]; j <= adresses->address_to[i]; j++) {
tab_addresses[num_blocks] = j;
num_blocks++;
}
num_extents++;
i++;
}
AK_header newHeader[MAX_ATTRIBUTES];
mem_block = (AK_mem_block *) AK_get_block(tab_addresses[0]);
memcpy(&newHeader, mem_block->block->header, sizeof (mem_block->block->header));
for (i = 0; i < MAX_ATTRIBUTES; i++) {
if (strcmp(newHeader[i].att_name, old_attr) == 0) {
Ak_dbg_messg(HIGH, REL_OP, "AK_rename: the attribute names are the same at position %d!\n", i);
memset(&newHeader[i].att_name, 0, MAX_ATT_NAME);
memcpy(&newHeader[i].att_name, new_attr, strlen(new_attr));
break;
} else if (strcmp(newHeader[i].att_name, "\0") == 0) { //if there is no more attributes
Ak_dbg_messg(MIDDLE, REL_OP, "AK_rename: ERROR: atribute: %s does not exist in this table\n", old_attr);
AK_EPI;
return (EXIT_ERROR);
}
}
//replacing old headers with new ones
for (i = 0; i < num_blocks; i++) {
mem_block = AK_get_block(tab_addresses[i]);
memcpy(&mem_block->block->header, newHeader, sizeof (AK_header) * MAX_ATTRIBUTES);
AK_mem_block_modify(mem_block, BLOCK_DIRTY);
}
}
if (strcmp(old_table_name, new_table_name) != 0) {//new name is different than old, and old needs to be replaced
struct list_node *expr;
expr = 0;
AK_selection(old_table_name, new_table_name, expr);
AK_delete_segment(old_table_name, SEGMENT_TYPE_TABLE);
}
AK_EPI;
return EXIT_SUCCESS;
}
/**
* @author Mario Kolmacic updated by Ivan Pusic and Tomislav Ilisevic
* @brief Function for executing given commands (SELECT, UPDATE, DELETE AND INSERT)
* @param komande Commands array to execute
* @param brojkomandi Number of commands in array
*/
int AK_command(command * komande, int brojkomandi) {
int i;
AK_PRO;
for (i = 0; i < brojkomandi; ++i) {
switch(komande[i].id_command){
case SELECT:
printf("***SELECT***\n");
char *ext = "_selection_tmp_table";
char *dest_table = AK_malloc(strlen(ext) + strlen(komande[i].tblName)+1);
strcpy(dest_table, komande[i].tblName);
strcat(dest_table, ext);
if(AK_selection(komande[i].tblName, dest_table, (struct list_node*)komande[i].parameters) == EXIT_ERROR){ // unutar funkcije je ispis privremene tablice
AK_EPI;
return EXIT_ERROR;
}
break;
case UPDATE:
printf("***UPDATE***\n");
if(Ak_update_row( ((struct list_node *) (komande[i].parameters))) == EXIT_ERROR){
AK_EPI;
return EXIT_ERROR;
}
AK_print_table(komande[i].tblName);
break;
case DELETE:
printf("***DELETE***\n");
if(Ak_delete_row( ((struct list_node *) (komande[i].parameters))) == EXIT_ERROR){
AK_EPI;
return EXIT_ERROR;
}
AK_print_table(komande[i].tblName);
break;
case INSERT:
printf("***INSERT***\n");
if(Ak_insert_row( ((struct list_node *) (komande[i].parameters))) == EXIT_ERROR){
AK_EPI;
return EXIT_ERROR;
}
AK_print_table(komande[i].tblName);
break;
default:
break;
}
}
AK_EPI;
return EXIT_SUCCESS;
}
/**
* @author Luka Rajcevic
* @brief Function for selection operator on one table
+ @param src_table - name of the source table
+ @param dest_table - table in which selection will be stored
* @param sel_query - array of operators, operands and attributes (postfix query)
* @param _num - number of attributes
* @param _type - array of attribute types (eg. TYPE_INT, TYPE_VARCHAR, etc.)
* @return EXIT_SUCCESS if ok, EXIT_ERROR otherwise
*
*/
int selection_test(char* src_table, char* dest_table, char** sel_query, int _num, int* _type){
AK_PRO;
printf("==================== SELECTION_TEST =====================\n");
struct list_node *expr = (struct list_node *) AK_malloc(sizeof (struct list_node));
Ak_Init_L3(&expr);
// TYPE_OPERAND 10
// TYPE_OPERATOR 11
// TYPE_ATTRIBS 12
strcpy(expr->table,dest_table);
int i;
for (i = 0; i < _num; i++){
if (_type[i] == TYPE_INT){
int val = atoi(sel_query[i]);
Ak_InsertAtEnd_L3(_type[i], (char*) &val, sizeof(int), expr);
}
if (_type[i] == TYPE_FLOAT){
float val = atof(sel_query[i]);
Ak_InsertAtEnd_L3(_type[i], (char *) &val, sizeof(float), expr);
}
if (_type[i] == TYPE_OPERATOR || _type[i] == TYPE_ATTRIBS || _type[i] == TYPE_VARCHAR){
Ak_InsertAtEnd_L3(_type[i], sel_query[i], strlen(sel_query[i]), expr);
}
}
if (AK_selection(src_table, dest_table, expr) == EXIT_SUCCESS){
Ak_DeleteAll_L3(&expr);
AK_free(expr);
AK_EPI;
return 1;
}
AK_EPI;
return 0;
}
