Merge branch 'dev-WhereClauseIssue'

Author: Jairik

connectEngine.c

@@ -70,21 +70,28 @@ struct whereClauseS* convert_conditions(ParsedSQL *parsed) {
 
     for (int i = 0; i < parsed->num_conditions; i++) {
         struct whereClauseS *node = malloc(sizeof(struct whereClauseS));
-        node->attribute = parsed->conditions[i].column;
-        node->operator = get_operator_string(parsed->conditions[i].op);
-        node->value = parsed->conditions[i].value;
 
-        // Simple type inference for the test
-        if (parsed->conditions[i].is_numeric) {
-            node->value_type = 0; // Integer/Number
+        if (parsed->conditions[i].is_nested && parsed->conditions[i].nested_sql) {
+            node->attribute = NULL;
+            node->operator = NULL;
+            node->value = NULL;
+            node->value_type = 0;
+            node->sub = convert_conditions(parsed->conditions[i].nested_sql);
         } else {
-            node->value_type = 1; // String
+            node->attribute = parsed->conditions[i].column;
+            node->operator = get_operator_string(parsed->conditions[i].op);
+            node->value = parsed->conditions[i].value;
+            
+            // Simple type inference for the test
+            if (parsed->conditions[i].is_numeric) {
+                node->value_type = 0; // Integer/Number
+            } else {
+                node->value_type = 1; // String
+            }
+            node->sub = NULL;
         }
 
-        // TODO - Handle sub-expressions and nested conditions
-        // Note: Nested conditions are not currently supported by the test
         node->next = NULL;
-        node->sub = NULL;
 
         // Set logical operator for the *previous* node to connect to this one
         // The parser stores logic ops between conditions. logic_ops[0] is between cond[0] and cond[1]
@@ -120,7 +127,7 @@ void run_test_query(struct engineS *engine, const char *query, int max_rows) {
     // Print query for testing
     printf("Executing Query: %s\n", query);
 
-    // Tokenize
+    // Tokenize the provided query
     Token tokens[MAX_TOKENS];
     int num_tokens = tokenize(query, tokens, MAX_TOKENS);
     if (num_tokens <= 0) {
@@ -142,13 +149,15 @@ void run_test_query(struct engineS *engine, const char *query, int max_rows) {
         }
     }
 
-    // Handle non-SELECT commands here and return early
+    // Execute based on command type
     switch (parsed.command) {
         case CMD_INSERT: {
             if (parsed.num_values != 12) {
                 printf("Error: INSERT requires exactly 12 values.\n");
                 return;
             }
+
+            // Assign arguments to a record struct
             record r;
             r.command_id = strtoull(parsed.insert_values[0], NULL, 10);
             safe_copy(r.raw_command, sizeof(r.raw_command), parsed.insert_values[1]);
@@ -166,30 +175,56 @@ void run_test_query(struct engineS *engine, const char *query, int max_rows) {
             safe_copy(r.host_name, sizeof(r.host_name), parsed.insert_values[10]);
             r.risk_level = atoi(parsed.insert_values[11]);
 
+            // Execute Insert
+            clock_t insertStart = clock();  // Start timer for benchmarking
             if (executeQueryInsertSerial(engine, parsed.table, &r)) {
-                printf("Insert successful.\n\n");
+                printf("Insert successful. Execution Time: %ld\n\n", (clock() - insertStart) / CLOCKS_PER_SEC);
             } else {
-                printf("Insert failed.\n\n");
+                printf("Insert failed. Execution Time: %ld\n\n", (clock() - insertStart) / CLOCKS_PER_SEC);
             }
+
             return;
         }
 
         case CMD_DELETE: {
+            // Get the WHERE clause from arguments
             struct whereClauseS *whereClause = convert_conditions(&parsed);
+            
+            // Execute delete
+            clock_t deleteStart = clock();  // Start timer for benchmarking
             struct resultSetS *result = executeQueryDeleteSerial(engine, parsed.table, whereClause);
+
             if (result) {
-                printf("Delete successful. Rows affected: %d\n", result->numRecords);
+                printf("Delete successful. Rows affected: %d. Execution Time: %ld\n\n", result->numRecords, ((clock() - deleteStart) / CLOCKS_PER_SEC));
                 freeResultSet(result);
             } else {
-                printf("Delete failed.\n");
+                printf("Delete failed. Execution Time: %ld\n\n", ((clock() - deleteStart) / CLOCKS_PER_SEC));
             }
+
             free_where_clause_list(whereClause);
             return;
         }
 
         case CMD_SELECT: {
-            // Handled below
-            break;
+            // Get the WHERE clause from arguments
+            struct whereClauseS *whereClause = convert_conditions(&parsed);
+
+            // Execute select
+            struct resultSetS *result = executeQuerySelectSerial(
+                engine,
+                selectItems,
+                numSelectItems,
+                parsed.table,
+                whereClause
+            );
+
+            // Verify and Print)
+            printTable(NULL, result, max_rows);  // Limit to max_rows for testing
+
+            // Cleanup
+            if (result) freeResultSet(result);  // Free the results object
+            free_where_clause_list(whereClause);  // Free where clause linked list
+            printf("\n");
         }
 
         case CMD_NONE: {
@@ -198,28 +233,8 @@ void run_test_query(struct engineS *engine, const char *query, int max_rows) {
         }
 
         default: {
-            printf("Unsupported command.\n");
+            fprintf(stderr, "Unsupported command.\n");
             return;
         }
     }
-
-    // Retreive the WHERE clause
-    struct whereClauseS *whereClause = convert_conditions(&parsed);
-
-    // Execute
-    struct resultSetS *result = executeQuerySelectSerial(
-        engine,
-        selectItems,
-        numSelectItems,
-        parsed.table,
-        whereClause
-    );
-
-    // Verify and Print
-    printTable(NULL, result, max_rows);
-
-    // Cleanup
-    if (result) freeResultSet(result);  // Free the results object
-    free_where_clause_list(whereClause);  // Free where clause linked list
-    printf("\n");
 }

data-generation/commands_50k.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ec8a5f1c992bd1c55dfdfa40e77473a388ff8bfe2e9e6bd872566293eee9a9d
-size 278
+oid sha256:e4239d07eb776e56fda0d3fa7757e702ee9b5c7f16d952ade9ee6b080c66f8ea
+size 267

engine/serial/executeEngine-serial.c

@@ -357,9 +357,14 @@ struct resultSetS *executeQuerySelectSerial(
     // Get all indexed attributes in the WHERE clause, using the B+ tree indexes where possible
     struct whereClauseS *wc = whereClause;
     while (wc != NULL) {
+        // Skip nested conditions for index lookup (they don't have a direct attribute)
+        if (wc->attribute == NULL) {
+            wc = wc->next;
+            continue;
+        }
+
         for (int i = 0; i < engine->num_indexes; i++) {
             if (strcmp(wc->attribute, engine->indexed_attributes[i]) == 0) {
-                anyIndexExists = true;
                 indexExists[i] = true;
 
                 // Use B+ tree index for this attribute
@@ -427,6 +432,8 @@ struct resultSetS *executeQuerySelectSerial(
                     continue;
                 }
 
+                anyIndexExists = true;
+
                 // Allocating for keys, using num_records as upper bound.
                 KEY_T *returned_keys = malloc(engine->num_records * sizeof(KEY_T));
                 ROW_PTR *returned_pointers = malloc(engine->num_records * sizeof(ROW_PTR));

include/sql.h

@@ -44,14 +44,18 @@ typedef struct {
     char value[256]; // Increased size for long strings
 } Token;
 
+typedef struct ParsedSQL ParsedSQL;
+
 typedef struct {
     char column[64];
     OperatorType op;
     char value[256]; // Value to compare against
     bool is_numeric; // Whether the value is a number or string/bool
+    bool is_nested;
+    ParsedSQL *nested_sql;
 } Condition;
 
-typedef struct {
+typedef struct ParsedSQL {
     CommandType command;
     char table[64];
     char columns[10][64]; // Up to 10 columns selected
@@ -77,6 +81,7 @@ int tokenize(const char *input, Token tokens[], int max_tokens);
 
 // Parser
 ParsedSQL parse_tokens(Token tokens[]);
+void free_parsed_sql(ParsedSQL *sql);
 
 // Dispatcher removed
 

makefile

@@ -107,10 +107,27 @@ test: $(TEST_BINS)
 	@set -e; for t in $(TEST_BINS); do echo "==> $$t"; $$t || exit 1; done
 	@echo "All tests completed."
 
-# Run the main serial query processor
+# Run the serial version
 run: QPESeq
 	./QPESeq
 
+# Default OpenMP thread count unless overridden
+OMP_THREADS ?= 4
+
+# Run OpenMP version correctly — env var applies only to this command
+run-omp: QPEOMP
+	@echo "Running with OMP_NUM_THREADS=$(OMP_THREADS)"
+	@env OMP_NUM_THREADS=$(OMP_THREADS) ./QPEOMP
+
+# Default MPI process count unless overridden
+MPI_PROCS ?= 4
+
+# Run MPI version with proper launcher syntax
+run-mpi: QPEMPI
+	@echo "Running with $(MPI_PROCS) MPI processes..."
+	@mpirun -np $(MPI_PROCS) ./QPEMPI 2>/dev/null \
+	 || mpiexec -np $(MPI_PROCS) ./QPEMPI
+
 # Run QPESeq under Valgrind to check for memory leaks
 valgrind: QPESeq
 	valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --error-exitcode=1 ./QPESeq

sample-queries.txt

@@ -36,4 +36,4 @@ WHERE sudo_used = TRUE OR (risk_level = 5 AND shell_type = "bash");
 # -- Sample 8:
 SELECT user_name, working_directory, base_command
 FROM Commands
-WHERE user_id = 1001 OR (user_name = "student1002" AND shell_type = "zsh");
+WHERE user_id = 1001 OR (user_name = "student1002" AND shell_type = "zsh");