diff --git a/.github/.keep b/.github/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/.github/workflows/classroom.yml b/.github/workflows/classroom.yml
index dca83b024..17a8b338d 100644
--- a/.github/workflows/classroom.yml
+++ b/.github/workflows/classroom.yml
@@ -1,19 +1,221 @@
-name: GitHub Classroom Workflow
-
-on:
-  - push
-  - workflow_dispatch
-
+name: Autograding Tests
+'on':
+- push
+- workflow_dispatch
+- repository_dispatch
 permissions:
   checks: write
   actions: read
   contents: read
-
 jobs:
-  build:
-    name: Autograding
+  run-autograding-tests:
     runs-on: ubuntu-latest
     if: github.actor != 'github-classroom[bot]'
     steps:
-      - uses: actions/checkout@v4
-      - uses: education/autograding@v1
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Step-1 Test
+      id: step-1-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-1 Test
+        setup-command: npm install
+        command: npm run test:1
+        timeout: 10
+        max-score: 10
+    - name: Step-2 Test
+      id: step-2-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-2 Test
+        setup-command: npm install
+        command: npm run test:2
+        timeout: 10
+        max-score: 10
+    - name: Step-3 Test
+      id: step-3-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-3 Test
+        setup-command: npm install
+        command: npm run test:3
+        timeout: 10
+        max-score: 10
+    - name: Step-4 Test
+      id: step-4-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-4 Test
+        setup-command: npm install
+        command: npm run test:4
+        timeout: 10
+        max-score: 10
+    - name: Step-5 Test
+      id: step-5-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-5 Test
+        setup-command: npm install
+        command: npm run test:5
+        timeout: 10
+        max-score: 10
+    - name: Step-6 Test
+      id: step-6-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-6 Test
+        setup-command: npm install
+        command: npm run test:6
+        timeout: 10
+        max-score: 10
+    - name: Step-7 Test
+      id: step-7-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-7 Test
+        setup-command: npm install
+        command: npm run test:7
+        timeout: 10
+        max-score: 10
+    - name: Step-8 Test
+      id: step-8-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-8 Test
+        setup-command: npm install
+        command: npm run test:8
+        timeout: 10
+        max-score: 10
+    - name: Step-9 Test
+      id: step-9-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-9 Test
+        setup-command: npm install
+        command: npm run test:9
+        timeout: 10
+        max-score: 10
+    - name: Step-10 Test
+      id: step-10-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-10 Test
+        setup-command: npm install
+        command: npm run test:10
+        timeout: 10
+        max-score: 10
+    - name: Step-11 Test
+      id: step-11-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-11 Test
+        setup-command: npm install
+        command: npm run test:11
+        timeout: 10
+        max-score: 10
+    - name: Step-12 Test
+      id: step-12-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-12 Test
+        setup-command: npm install
+        command: npm run test:12
+        timeout: 10
+        max-score: 10
+    - name: Step-13 Test
+      id: step-13-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-13 Test
+        setup-command: npm install
+        command: npm run test:13
+        timeout: 10
+        max-score: 10
+    - name: Step-14 Test
+      id: step-14-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-14 Test
+        setup-command: npm install
+        command: npm run test:14
+        timeout: 10
+        max-score: 10
+    - name: Step-15 Test
+      id: step-15-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-15 Test
+        setup-command: npm install
+        command: npm run test:15
+        timeout: 10
+        max-score: 10
+    - name: Step-16 Test
+      id: step-16-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-16 Test
+        setup-command: npm install
+        command: npm run test:16
+        timeout: 10
+        max-score: 10
+    - name: Step-17 Test
+      id: step-17-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-17 Test
+        setup-command: npm install
+        command: npm run test:17
+        timeout: 10
+        max-score: 10
+    - name: Step-18 Test
+      id: step-18-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-18 Test
+        setup-command: npm install
+        command: npm run test:18
+        timeout: 10
+        max-score: 10
+    - name: Step-19 Test
+      id: step-19-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-19 Test
+        setup-command: npm install
+        command: npm run test:19
+        timeout: 10
+        max-score: 10
+    - name: Step-20 Test
+      id: step-20-test
+      uses: education/autograding-command-grader@v1
+      with:
+        test-name: Step-20 Test
+        setup-command: npm install
+        command: npm run test:20
+        timeout: 10
+        max-score: 10
+    - name: Autograding Reporter
+      uses: education/autograding-grading-reporter@v1
+      env:
+        STEP-1-TEST_RESULTS: "${{steps.step-1-test.outputs.result}}"
+        STEP-2-TEST_RESULTS: "${{steps.step-2-test.outputs.result}}"
+        STEP-3-TEST_RESULTS: "${{steps.step-3-test.outputs.result}}"
+        STEP-4-TEST_RESULTS: "${{steps.step-4-test.outputs.result}}"
+        STEP-5-TEST_RESULTS: "${{steps.step-5-test.outputs.result}}"
+        STEP-6-TEST_RESULTS: "${{steps.step-6-test.outputs.result}}"
+        STEP-7-TEST_RESULTS: "${{steps.step-7-test.outputs.result}}"
+        STEP-8-TEST_RESULTS: "${{steps.step-8-test.outputs.result}}"
+        STEP-9-TEST_RESULTS: "${{steps.step-9-test.outputs.result}}"
+        STEP-10-TEST_RESULTS: "${{steps.step-10-test.outputs.result}}"
+        STEP-11-TEST_RESULTS: "${{steps.step-11-test.outputs.result}}"
+        STEP-12-TEST_RESULTS: "${{steps.step-12-test.outputs.result}}"
+        STEP-13-TEST_RESULTS: "${{steps.step-13-test.outputs.result}}"
+        STEP-14-TEST_RESULTS: "${{steps.step-14-test.outputs.result}}"
+        STEP-15-TEST_RESULTS: "${{steps.step-15-test.outputs.result}}"
+        STEP-16-TEST_RESULTS: "${{steps.step-16-test.outputs.result}}"
+        STEP-17-TEST_RESULTS: "${{steps.step-17-test.outputs.result}}"
+        STEP-18-TEST_RESULTS: "${{steps.step-18-test.outputs.result}}"
+        STEP-19-TEST_RESULTS: "${{steps.step-19-test.outputs.result}}"
+        STEP-20-TEST_RESULTS: "${{steps.step-20-test.outputs.result}}"
+      with:
+        runners: step-1-test,step-2-test,step-3-test,step-4-test,step-5-test,step-6-test,step-7-test,step-8-test,step-9-test,step-10-test,step-11-test,step-12-test,step-13-test,step-14-test,step-15-test,step-16-test,step-17-test,step-18-test,step-19-test,step-20-test
diff --git a/docs/tutorials/02.md b/docs/tutorials/02.md
index c4bc3c742..c190cca59 100644
--- a/docs/tutorials/02.md
+++ b/docs/tutorials/02.md
@@ -3,7 +3,7 @@
 In this step we add the functionality to read from CSV files, since our DB would read from and write to CSV files, considering them as tables.
 
 ### 2.1 Create a Sample CSV File
-Create a new CSV file in your project directory. Let's call it `sample.csv` and add some sample data to it:
+Create a new CSV file in your project directory. Let's call it `student.csv` and add some sample data to it:
 
 ```csv
 id,name,age
@@ -52,7 +52,7 @@ Example test:
 const readCSV = require('../src/csvReader');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
     expect(data.length).toBe(3);
     expect(data[0].name).toBe('John');
diff --git a/docs/tutorials/03.md b/docs/tutorials/03.md
index c6e1dc18b..e34e91acd 100644
--- a/docs/tutorials/03.md
+++ b/docs/tutorials/03.md
@@ -11,7 +11,7 @@ Example implementation:
 ```javascript
 // src/queryParser.js
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     const selectRegex = /SELECT (.+) FROM (.+)/i;
     const match = query.match(selectRegex);
 
@@ -26,7 +26,7 @@ function parseQuery(query) {
     }
 }
 
-module.exports = parseQuery;
+module.exports = parseSelectQuery;
 ```
 
 ### 3.2 Update Test to Check Query Parsing
@@ -36,11 +36,11 @@ Example test:
 ```javascript
 // tests/index.test.js
 
-const parseQuery = require('../src/queryParser');
+const {parseSelectQuery} = require('../src/queryParser');
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'sample'
diff --git a/docs/tutorials/04.md b/docs/tutorials/04.md
index 0339f1812..4cf9cb1f2 100644
--- a/docs/tutorials/04.md
+++ b/docs/tutorials/04.md
@@ -10,11 +10,11 @@ Here's a basic implementation:
 ```javascript
 // src/index.js
 
-const parseQuery = require('./queryParser');
+const {parseSelectQuery} = require('./queryParser');
 const readCSV = require('./csvReader');
 
 async function executeSELECTQuery(query) {
-    const { fields, table } = parseQuery(query);
+    const { fields, table } = parseSelectQuery(query);
     const data = await readCSV(`${table}.csv`);
     
     // Filter the fields based on the query
diff --git a/docs/tutorials/05.md b/docs/tutorials/05.md
index 291552cba..2c219211a 100644
--- a/docs/tutorials/05.md
+++ b/docs/tutorials/05.md
@@ -11,7 +11,7 @@ Here's an updated implementation:
 ```javascript
 // src/queryParser.js
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     const selectRegex = /SELECT (.+?) FROM (.+?)(?: WHERE (.*))?$/i;
     const match = query.match(selectRegex);
 
@@ -27,7 +27,7 @@ function parseQuery(query) {
     }
 }
 
-module.exports = parseQuery;
+module.exports = parseSelectQuery;
 ```
 
 ### 5.2 Run the Updated Tests
@@ -42,11 +42,11 @@ Example implementation:
 ```javascript
 // src/index.js
 
-const parseQuery = require('./queryParser');
+const {parseSelectQuery} = require('./queryParser');
 const readCSV = require('./csvReader');
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClause } = parseQuery(query);
+    const { fields, table, whereClause } = parseSelectQuery(query);
     const data = await readCSV(`${table}.csv`);
     
     // Filtering based on WHERE clause
diff --git a/docs/tutorials/06.md b/docs/tutorials/06.md
index 69405e509..7c408b523 100644
--- a/docs/tutorials/06.md
+++ b/docs/tutorials/06.md
@@ -11,7 +11,7 @@ Here's an example implementation:
 ```javascript
 // src/queryParser.js
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     const selectRegex = /SELECT (.+?) FROM (.+?)(?: WHERE (.*))?$/i;
     const match = query.match(selectRegex);
 
@@ -36,7 +36,7 @@ function parseWhereClause(whereString) {
     });
 }
 
-module.exports = parseQuery;
+module.exports = parseSelectQuery;
 ```
 
 > **💡Do it yourself:** Add error handling to the newly added function.
@@ -49,11 +49,11 @@ Here's an example implementation:
 ```javascript
 // src/index.js
 
-const parseQuery = require('./queryParser');
+const {parseSelectQuery} = require('./queryParser');
 const readCSV = require('./csvReader');
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClauses } = parseQuery(query);
+    const { fields, table, whereClauses } = parseSelectQuery(query);
     const data = await readCSV(`${table}.csv`);
 
     // Apply WHERE clause filtering
@@ -85,7 +85,7 @@ Example test:
 ```javascript
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM sample WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'sample',
diff --git a/docs/tutorials/08.md b/docs/tutorials/08.md
index 123aac444..290f0bb34 100644
--- a/docs/tutorials/08.md
+++ b/docs/tutorials/08.md
@@ -3,8 +3,8 @@
 In this step we implement the `JOIN` functionality from SQL.
 
 ### 8.1 Preparing CSV Files for INNER JOIN
-- Rename `sample.csv` to `student.csv`
-- Update the tests in `tests/index.test.js` to use `student.csv` instead of `sample.csv` and update the expected results accordingly.
+- Rename `student.csv` to `student.csv`
+- Update the tests in `tests/index.test.js` to use `student.csv` instead of `student.csv` and update the expected results accordingly.
 
 ### 8.2 Create a new Enrollment CSV File
 This setup gives us two CSV files: one for student information and another for their course enrollments. We can now use these files to demonstrate the INNER JOIN functionality in the next step.
@@ -67,7 +67,7 @@ Example implementation:
 ```javascript
 // src/queryParser.js
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     // First, let's trim the query to remove any leading/trailing whitespaces
     query = query.trim();
 
@@ -137,7 +137,7 @@ Example implementation:
 // src/index.js at executeSELECTQuery
 
 // Now we will have joinTable, joinCondition in the parsed query
-const { fields, table, whereClauses, joinTable, joinCondition } = parseQuery(query);
+const { fields, table, whereClauses, joinTable, joinCondition } = parseSelectQuery(query);
 let data = await readCSV(`${table}.csv`);
 
 // Perform INNER JOIN if specified
diff --git a/docs/tutorials/09.md b/docs/tutorials/09.md
index 86ca209ed..0782d1f6b 100644
--- a/docs/tutorials/09.md
+++ b/docs/tutorials/09.md
@@ -62,13 +62,13 @@ function parseJoinClause(query) {
     };
 }
 
-// Update the parseQuery function to use parseJoinClause
+// Update the parseSelectQuery function to use parseJoinClause
 // ...existing code...
 
-module.exports = { parseQuery, parseJoinClause };
+module.exports = { parseSelectQuery, parseJoinClause };
 ```
 
-> 💡**Do it yourself**: Remember to update the `parseQuery` function to use the `parseJoinClause` function implemented above
+> 💡**Do it yourself**: Remember to update the `parseSelectQuery` function to use the `parseJoinClause` function implemented above
 
 ### 9.2 Updating the Execute Function for Different JOIN Types
 - Modify `executeSELECTQuery` in `src/index.js` to handle `LEFT JOIN` and `RIGHT JOIN` alongside `INNER JOIN`. Implement `performLeftJoin` and `performRightJoin` functions to encapsulate the specific logic for these JOIN types.
@@ -95,7 +95,7 @@ function performRightJoin(/* parameters */) {
 }
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClauses, joinType, joinTable, joinCondition } = parseQuery(query);
+    const { fields, table, whereClauses, joinType, joinTable, joinCondition } = parseSelectQuery(query);
     let data = await readCSV(`${table}.csv`);
 
     // Logic for applying JOINs
diff --git a/docs/tutorials/10.md b/docs/tutorials/10.md
index 75f093b0a..779f5bcdf 100644
--- a/docs/tutorials/10.md
+++ b/docs/tutorials/10.md
@@ -12,7 +12,7 @@ Example snippet for updating `queryParser.js`:
 
 // ...existing code...
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     // ...existing parsing logic...
 
     // Updated regex to capture GROUP BY clause
@@ -32,10 +32,10 @@ function parseQuery(query) {
 
 // ...remaining code...
 
-module.exports = { parseQuery, parseJoinClause };
+module.exports = { parseSelectQuery, parseJoinClause };
 ```
 
-> 💡**Do it yourself**: Update the `parseQuery` function based on the hints in the above code snippet.
+> 💡**Do it yourself**: Update the `parseSelectQuery` function based on the hints in the above code snippet.
 
 ### 10.2 Update the Execute Function to Apply GROUP BY and Aggregate Functions
 - Modify `executeSELECTQuery` in `src/index.js` to perform grouping based on the `GROUP BY` clause and apply aggregate functions like `COUNT`, `SUM`, `AVG`, `MIN`, and `MAX`.
@@ -53,7 +53,7 @@ function applyGroupBy(data, groupByFields, aggregateFunctions) {
 }
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields } = parseQuery(query);
+    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields } = parseSelectQuery(query);
     let data = await readCSV(`${table}.csv`);
 
     // ...existing logic for JOINs and WHERE clause...
diff --git a/docs/tutorials/11.md b/docs/tutorials/11.md
index 02938ab60..0ba572333 100644
--- a/docs/tutorials/11.md
+++ b/docs/tutorials/11.md
@@ -1,81 +1,299 @@
-## Step 11: Implementing ORDER BY Clause
+const { parseSelectQuery } = require('./queryParser');
+const readCSV = require('./csvReader');
 
-In this step we implement the functionality of ordering our records in a particular sequence by adding support for the `ORDER BY` SQL clause.
+function performInnerJoin(data, joinData, joinCondition, fields, table) {
+    return data.flatMap(mainRow => {
+        return joinData
+            .filter(joinRow => {
+                const mainValue = mainRow[joinCondition.left.split('.')[1]];
+                const joinValue = joinRow[joinCondition.right.split('.')[1]];
+                return mainValue === joinValue;
+            })
+            .map(joinRow => {
+                return fields.reduce((acc, field) => {
+                    const [tableName, fieldName] = field.split('.');
+                    acc[field] = tableName === table ? mainRow[fieldName] : joinRow[fieldName];
+                    return acc;
+                }, {});
+            });
+    });
+}
+
+function performLeftJoin(data, joinData, joinCondition, fields, table) {
+    return data.flatMap(mainRow => {
+        const matchingJoinRows = joinData.filter(joinRow => {
+            const mainValue = getValueFromRow(mainRow, joinCondition.left);
+            const joinValue = getValueFromRow(joinRow, joinCondition.right);
+            return mainValue === joinValue;
+        });
+
+        if (matchingJoinRows.length === 0) {
+            return [createResultRow(mainRow, null, fields, table, true)];
+        }
+
+        return matchingJoinRows.map(joinRow => createResultRow(mainRow, joinRow, fields, table, true));
+    });
+}
 
-### 11.1 Update the Parser to Handle ORDER BY Clauses
-- Modify `queryParser.js` to parse `ORDER BY` clauses in the SQL query. The parser should identify the columns to order by and the sort direction (`ASC` or `DESC`).
+function getValueFromRow(row, compoundFieldName) {
+    const [tableName, fieldName] = compoundFieldName.split('.');
+    return row[`${tableName}.${fieldName}`] || row[fieldName];
+}
 
-Example snippet for updating `queryParser.js`:
-```javascript
-// src/queryParser.js
+function performRightJoin(data, joinData, joinCondition, fields, table) {
+    // Cache the structure of a main table row (keys only)
+    const mainTableRowStructure = data.length > 0 ? Object.keys(data[0]).reduce((acc, key) => {
+        acc[key] = null; // Set all values to null initially
+        return acc;
+    }, {}) : {};
 
-// ...existing code...
+    return joinData.map(joinRow => {
+        const mainRowMatch = data.find(mainRow => {
+            const mainValue = getValueFromRow(mainRow, joinCondition.left);
+            const joinValue = getValueFromRow(joinRow, joinCondition.right);
+            return mainValue === joinValue;
+        });
 
-function parseQuery(query) {
-    // ...existing parsing logic...
+        // Use the cached structure if no match is found
+        const mainRowToUse = mainRowMatch || mainTableRowStructure;
+
+        // Include all necessary fields from the 'student' table
+        return createResultRow(mainRowToUse, joinRow, fields, table, true);
+    });
+}
 
-    // Updated regex to capture ORDER BY clause
-    const orderByRegex = /\sORDER BY\s(.+)/i;
-    const orderByMatch = query.match(orderByRegex);
+function createResultRow(mainRow, joinRow, fields, table, includeAllMainFields) {
+    const resultRow = {};
 
-    let orderByFields = null;
-    if (orderByMatch) {
-        orderByFields = orderByMatch[1].split(',').map(field => {
-            const [fieldName, order] = field.trim().split(/\s+/);
-            return { fieldName, order: order ? order.toUpperCase() : 'ASC' };
+    if (includeAllMainFields) {
+        // Include all fields from the main table
+        Object.keys(mainRow || {}).forEach(key => {
+            const prefixedKey = `${table}.${key}`;
+            resultRow[prefixedKey] = mainRow ? mainRow[key] : null;
         });
     }
 
-    return {
-        // ...existing parsed parts,
-        orderByFields
-    };
+    // Now, add or overwrite with the fields specified in the query
+    fields.forEach(field => {
+        const [tableName, fieldName] = field.includes('.') ? field.split('.') : [table, field];
+        resultRow[field] = tableName === table && mainRow ? mainRow[fieldName] : joinRow ? joinRow[fieldName] : null;
+    });
+
+    return resultRow;
 }
 
-// ...remaining code...
+function evaluateCondition(row, clause) {
+    let { field, operator, value } = clause;
+
+    // Check if the field exists in the row
+    if (row[field] === undefined) {
+        throw new Error(`Invalid field: ${field}`);
+    }
+
+    // Parse row value and condition value based on their actual types
+    const rowValue = parseValue(row[field]);
+    let conditionValue = parseValue(value);
+
+    switch (operator) {
+        case '=': return rowValue === conditionValue;
+        case '!=': return rowValue !== conditionValue;
+        case '>': return rowValue > conditionValue;
+        case '<': return rowValue < conditionValue;
+        case '>=': return rowValue >= conditionValue;
+        case '<=': return rowValue <= conditionValue;
+        default: throw new Error(`Unsupported operator: ${operator}`);
+    }
+}
+
+// Helper function to parse value based on its apparent type
+function parseValue(value) {
+
+    // Return null or undefined as is
+    if (value === null || value === undefined) {
+        return value;
+    }
+
+    // If the value is a string enclosed in single or double quotes, remove them
+    if (typeof value === 'string' && ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"')))) {
+        value = value.substring(1, value.length - 1);
+    }
 
-module.exports = { parseQuery, parseJoinClause };
-```
+    // Check if value is a number
+    if (!isNaN(value) && value.trim() !== '') {
+        return Number(value);
+    }
+    // Assume value is a string if not a number
+    return value;
+}
 
-> 💡 **Do it yourself**: Update the `parseQuery` function to add support for `ORDER BY` clause with the help of hints in the above code snippet.
+function applyGroupBy(data, groupByFields, aggregateFunctions) {
+    const groupResults = {};
 
-> 💡 **Ask yourself**: Is there some scope of refactoring in the above code snippet?
+    data.forEach(row => {
+        // Generate a key for the group
+        const groupKey = groupByFields.map(field => row[field]).join('-');
 
+        // Initialize group in results if it doesn't exist
+        if (!groupResults[groupKey]) {
+            groupResults[groupKey] = { count: 0, sums: {}, mins: {}, maxes: {} };
+            groupByFields.forEach(field => groupResults[groupKey][field] = row[field]);
+        }
 
-### 11.2 Update the Execute Function to Apply ORDER BY Clause
-- Modify `executeSELECTQuery` in `src/index.js` to sort the results based on the `ORDER BY` clause.
+        // Aggregate calculations
+        groupResults[groupKey].count += 1;
+        aggregateFunctions.forEach(func => {
+            const match = /(\w+)\((\w+)\)/.exec(func);
+            if (match) {
+                const [, aggFunc, aggField] = match;
+                const value = parseFloat(row[aggField]);
 
-```javascript
-// src/index.js
+                switch (aggFunc.toUpperCase()) {
+                    case 'SUM':
+                        groupResults[groupKey].sums[aggField] = (groupResults[groupKey].sums[aggField] || 0) + value;
+                        break;
+                    case 'MIN':
+                        groupResults[groupKey].mins[aggField] = Math.min(groupResults[groupKey].mins[aggField] || value, value);
+                        break;
+                    case 'MAX':
+                        groupResults[groupKey].maxes[aggField] = Math.max(groupResults[groupKey].maxes[aggField] || value, value);
+                        break;
+                    // Additional aggregate functions can be added here
+                }
+            }
+        });
+    });
 
-// ...existing imports and functions...
+    // Convert grouped results into an array format
+    return Object.values(groupResults).map(group => {
+        // Construct the final grouped object based on required fields
+        const finalGroup = {};
+        groupByFields.forEach(field => finalGroup[field] = group[field]);
+        aggregateFunctions.forEach(func => {
+            const match = /(\w+)\((\*|\w+)\)/.exec(func);
+            if (match) {
+                const [, aggFunc, aggField] = match;
+                switch (aggFunc.toUpperCase()) {
+                    case 'SUM':
+                        finalGroup[func] = group.sums[aggField];
+                        break;
+                    case 'MIN':
+                        finalGroup[func] = group.mins[aggField];
+                        break;
+                    case 'MAX':
+                        finalGroup[func] = group.maxes[aggField];
+                        break;
+                    case 'COUNT':
+                        finalGroup[func] = group.count;
+                        break;
+                    // Additional aggregate functions can be handled here
+                }
+            }
+        });
+
+        return finalGroup;
+    });
+}
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields } = parseQuery(query);
+    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, hasAggregateWithoutGroupBy, orderByFields } = parseSelectQuery(query);
     let data = await readCSV(`${table}.csv`);
 
-    // ...existing logic for JOINs, WHERE clause, and GROUP BY...
+    // Perform INNER JOIN if specified
+    if (joinTable && joinCondition) {
+        const joinData = await readCSV(`${joinTable}.csv`);
+        switch (joinType.toUpperCase()) {
+            case 'INNER':
+                data = performInnerJoin(data, joinData, joinCondition, fields, table);
+                break;
+            case 'LEFT':
+                data = performLeftJoin(data, joinData, joinCondition, fields, table);
+                break;
+            case 'RIGHT':
+                data = performRightJoin(data, joinData, joinCondition, fields, table);
+                break;
+            default:
+                throw new Error(`Unsupported JOIN type: ${joinType}`);
+        }
+    }
+    // Apply WHERE clause filtering after JOIN (or on the original data if no join)
+    let filteredData = whereClauses.length > 0
+        ? data.filter(row => whereClauses.every(clause => evaluateCondition(row, clause)))
+        : data;
+
+    let groupResults = filteredData;
+    if (hasAggregateWithoutGroupBy) {
+        // Special handling for queries like 'SELECT COUNT(*) FROM table'
+        const result = {};
 
-    if (orderByFields) {
-        data.sort((a, b) => {
-            for (let { fieldName, order } of orderByFields) {
-                if (a[fieldName] < b[fieldName]) return order === 'ASC' ? -1 : 1;
-                if (a[fieldName] > b[fieldName]) return order === 'ASC' ? 1 : -1;
+        // console.log({ filteredData })
+
+        fields.forEach(field => {
+            const match = /(\w+)\((\*|\w+)\)/.exec(field);
+            if (match) {
+                const [, aggFunc, aggField] = match;
+                switch (aggFunc.toUpperCase()) {
+                    case 'COUNT':
+                        result[field] = filteredData.length;
+                        break;
+                    case 'SUM':
+                        result[field] = filteredData.reduce((acc, row) => acc + parseFloat(row[aggField]), 0);
+                        break;
+                    case 'AVG':
+                        result[field] = filteredData.reduce((acc, row) => acc + parseFloat(row[aggField]), 0) / filteredData.length;
+                        break;
+                    case 'MIN':
+                        result[field] = Math.min(...filteredData.map(row => parseFloat(row[aggField])));
+                        break;
+                    case 'MAX':
+                        result[field] = Math.max(...filteredData.map(row => parseFloat(row[aggField])));
+                        break;
+                    // Additional aggregate functions can be handled here
+                }
             }
-            return 0;
         });
-    }
 
-    // ...existing logic for field selection...
-}
+        return [result];
+        // Add more cases here if needed for other aggregates
+    } else if (groupByFields) {
+        groupResults = applyGroupBy(filteredData, groupByFields, fields);
 
-module.exports = executeSELECTQuery;
-```
+        // Order them by the specified fields
+        let orderedResults = groupResults;
+        if (orderByFields) {
+            orderedResults = groupResults.sort((a, b) => {
+                for (let { fieldName, order } of orderByFields) {
+                    if (a[fieldName] < b[fieldName]) return order === 'ASC' ? -1 : 1;
+                    if (a[fieldName] > b[fieldName]) return order === 'ASC' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+        return groupResults;
+    } else {
 
-> 💡 **Do it yourself**: Update the `executeSELECTQuery` function to add support for `ORDER BY` clause with the help of hints in the above code snippet.
+        // Order them by the specified fields
+        let orderedResults = groupResults;
+        if (orderByFields) {
+            orderedResults = groupResults.sort((a, b) => {
+                for (let { fieldName, order } of orderByFields) {
+                    if (a[fieldName] < b[fieldName]) return order === 'ASC' ? -1 : 1;
+                    if (a[fieldName] > b[fieldName]) return order === 'ASC' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
 
-### 11.3 Add Tests for ORDER BY Clause
+        // Select the specified fields
+        return orderedResults.map(row => {
+            const selectedRow = {};
+            fields.forEach(field => {
+                // Assuming 'field' is just the column name without table prefix
+                selectedRow[field] = row[field];
+            });
+            return selectedRow;
+        });
+    }
+}
 
-- Add tests for the `ORDER BY` clause. You can see the existing tests [here](https://github.com/ChakshuGautam/stylusdb-sql/commit/39efbc7d7a81296c58a31e5fe84224938f64bcf7) to do TDD.
 
-> 💡 **Ask yourself**: What is Test Drive Development? 
\ No newline at end of file
+module.exports = executeSELECTQuery;
\ No newline at end of file
diff --git a/docs/tutorials/12.md b/docs/tutorials/12.md
index a3263ee6c..dcde988ee 100644
--- a/docs/tutorials/12.md
+++ b/docs/tutorials/12.md
@@ -13,7 +13,7 @@ Example snippet for updating `queryParser.js`:
 
 // ...existing code...
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     // ...existing parsing logic...
 
     // Updated regex to capture LIMIT clause
@@ -33,10 +33,10 @@ function parseQuery(query) {
 
 // ...remaining code...
 
-module.exports = { parseQuery, parseJoinClause };
+module.exports = { parseSelectQuery, parseJoinClause };
 ```
 
-> 💡 **Do it yourself**: Update the `parseQuery` function to add support for `LIMIT` clause with the help of hints in the above code snippet.
+> 💡 **Do it yourself**: Update the `parseSelectQuery` function to add support for `LIMIT` clause with the help of hints in the above code snippet.
 
 > 💡 **Ask yourself**: Is there some scope of refactoring in the above code snippet?
 
@@ -50,7 +50,7 @@ Example snippet for updating `executeSELECTQuery`:
 // ...existing imports and functions...
 
 async function executeSELECTQuery(query) {
-    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit } = parseQuery(query);
+    const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit } = parseSelectQuery(query);
     let data = await readCSV(`${table}.csv`);
 
     // ...existing logic for JOINs, WHERE clause, GROUP BY, and ORDER BY...
diff --git a/docs/tutorials/13.md b/docs/tutorials/13.md
index 39ec2c803..acac62473 100644
--- a/docs/tutorials/13.md
+++ b/docs/tutorials/13.md
@@ -3,7 +3,7 @@
 Every piece of software can error out and hence making it extremely crucial to handle errors and validate the data. We'll add support or error handling and validation in this step.
 
 ### 3.1 Enhance Error Handling in Parser
-- Update `parseQuery` function in `queryParser.js` to include more comprehensive error messages and checks. Ensure that it validates the structure of the SQL query and catches common syntax errors.
+- Update `parseSelectQuery` function in `queryParser.js` to include more comprehensive error messages and checks. Ensure that it validates the structure of the SQL query and catches common syntax errors.
 
 Example updates for `queryParser.js`:
 
@@ -12,7 +12,7 @@ Example updates for `queryParser.js`:
 
 // ...existing code...
 
-function parseQuery(query) {
+function parseSelectQuery(query) {
     try {
         // ...existing parsing logic...
 
@@ -33,10 +33,10 @@ function parseQuery(query) {
 
 // ...remaining code...
 
-module.exports = { parseQuery, parseJoinClause };
+module.exports = { parseSelectQuery, parseJoinClause };
 ```
 
-> 💡 **Do it yourself**: Update the `parseQuery` function to add some level of error handling. 
+> 💡 **Do it yourself**: Update the `parseSelectQuery` function to add some level of error handling. 
 
 ### 13.2 Enhance Error Handling in Execute Function
 - Update `executeSELECTQuery` function in `src/index.js` to handle errors gracefully. Catch errors during the execution process and provide informative messages.
@@ -50,7 +50,7 @@ Example updates for `executeSELECTQuery`:
 
 async function executeSELECTQuery(query) {
     try {
-        const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit } = parseQuery(query);
+        const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit } = parseSelectQuery(query);
 
         // ...existing logic for reading data and applying JOINs, WHERE, GROUP BY, ORDER BY, and LIMIT...
 
diff --git a/docs/tutorials/14.md b/docs/tutorials/14.md
index d1422661e..07dbb6657 100644
--- a/docs/tutorials/14.md
+++ b/docs/tutorials/14.md
@@ -1,6 +1,6 @@
 ## Step 14: Implementing DISTINCT Keyword
 ### 14.1 Update the Parser to Handle DISTINCT
-- Modify parseQuery in `queryParser.js` to recognize the `DISTINCT` keyword in the SQL query. The parser should identify when `DISTINCT` is used and modify the parsed query accordingly.
+- Modify parseSelectQuery in `queryParser.js` to recognize the `DISTINCT` keyword in the SQL query. The parser should identify when `DISTINCT` is used and modify the parsed query accordingly.
 
 Example updates for queryParser.js:
 ```javascript
@@ -34,7 +34,7 @@ Update the `enrollment.csv` to include `5,Physics,` and `student.csv` to include
 ```javascript
 test('Parse SQL Query with Basic DISTINCT', () => {
     const query = 'SELECT DISTINCT age FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age'],
         table: 'student',
@@ -52,7 +52,7 @@ test('Parse SQL Query with Basic DISTINCT', () => {
 
 test('Parse SQL Query with DISTINCT and Multiple Columns', () => {
     const query = 'SELECT DISTINCT student_id, course FROM enrollment';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course'],
         table: 'enrollment',
@@ -70,7 +70,7 @@ test('Parse SQL Query with DISTINCT and Multiple Columns', () => {
 
 test('Parse SQL Query with DISTINCT and WHERE Clause', () => {
     const query = 'SELECT DISTINCT course FROM enrollment WHERE student_id = "1"';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['course'],
         table: 'enrollment',
@@ -88,7 +88,7 @@ test('Parse SQL Query with DISTINCT and WHERE Clause', () => {
 
 test('Parse SQL Query with DISTINCT and JOIN Operations', () => {
     const query = 'SELECT DISTINCT student.name FROM student INNER JOIN enrollment ON student.id = enrollment.student_id';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name'],
         table: 'student',
@@ -109,7 +109,7 @@ test('Parse SQL Query with DISTINCT and JOIN Operations', () => {
 
 test('Parse SQL Query with DISTINCT, ORDER BY, and LIMIT', () => {
     const query = 'SELECT DISTINCT age FROM student ORDER BY age DESC LIMIT 2';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age'],
         table: 'student',
@@ -127,7 +127,7 @@ test('Parse SQL Query with DISTINCT, ORDER BY, and LIMIT', () => {
 
 test('Parse SQL Query with DISTINCT on All Columns', () => {
     const query = 'SELECT DISTINCT * FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['*'],
         table: 'student',
diff --git a/docs/tutorials/15.md b/docs/tutorials/15.md
index 8a5831cc1..64880d05d 100644
--- a/docs/tutorials/15.md
+++ b/docs/tutorials/15.md
@@ -1,6 +1,6 @@
 ## Step 15: Adding Support for LIKE Operator
 ### 15.1 Update the Parser to Handle LIKE Clauses
-Modify `parseQuery` in `queryParser.js` to recognize `LIKE`` conditions in the `WHERE`` clause.
+Modify `parseSelectQuery` in `queryParser.js` to recognize `LIKE`` conditions in the `WHERE`` clause.
 
 The parser should be capable of identifying LIKE patterns within the query.
 Example updates for queryParser.js:
@@ -31,7 +31,7 @@ Make sure the following test passes now.
 ```javascript
 test('Parse SQL Query with LIKE Clause', () => {
     const query = "SELECT name FROM student WHERE name LIKE '%Jane%'";
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['name'],
         table: 'student',
@@ -49,7 +49,7 @@ test('Parse SQL Query with LIKE Clause', () => {
 
 test('Parse SQL Query with LIKE Clause and Wildcards', () => {
     const query = "SELECT name FROM student WHERE name LIKE 'J%'";
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['name'],
         table: 'student',
@@ -67,7 +67,7 @@ test('Parse SQL Query with LIKE Clause and Wildcards', () => {
 
 test('Parse SQL Query with Multiple LIKE Clauses', () => {
     const query = "SELECT name FROM student WHERE name LIKE 'J%' AND age LIKE '2%'";
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['name'],
         table: 'student',
@@ -88,7 +88,7 @@ test('Parse SQL Query with Multiple LIKE Clauses', () => {
 
 test('Parse SQL Query with LIKE and ORDER BY Clauses', () => {
     const query = "SELECT name FROM student WHERE name LIKE '%e%' ORDER BY age DESC";
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['name'],
         table: 'student',
diff --git a/enrollment.csv b/enrollment.csv
new file mode 100644
index 000000000..3f7f04422
--- /dev/null
+++ b/enrollment.csv
@@ -0,0 +1,6 @@
+student_id,course
+1,Mathematics
+1,Physics
+2,Chemistry
+3,Mathematics
+5,Biology
diff --git a/package-lock.json b/package-lock.json
index 3afaec37f..a6ba782df 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,6 @@
       "version": "0.1.6",
       "license": "ISC",
       "dependencies": {
-        "csv-parser": "^3.0.0",
         "json2csv": "^6.0.0-alpha.2",
         "xterm": "^5.3.0"
       },
@@ -17,6 +16,7 @@
         "stylusdb-cli": "node ./src/cli.js"
       },
       "devDependencies": {
+        "csv-parser": "^3.0.0",
         "jest": "^29.7.0"
       }
     },
@@ -1573,6 +1573,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/csv-parser/-/csv-parser-3.0.0.tgz",
       "integrity": "sha512-s6OYSXAK3IdKqYO33y09jhypG/bSDHPuyCme/IdEHfWpLf/jKcpitVFyOC6UemgGk8v7Q5u2XE0vvwmanxhGlQ==",
+      "dev": true,
       "dependencies": {
         "minimist": "^1.2.0"
       },
@@ -2943,6 +2944,7 @@
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
       "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
       }
diff --git a/package.json b/package.json
index f52103d5c..988a7f575 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
     "test:18": "jest --testPathPattern=./tests/step-18",
     "test:19": "jest --testPathPattern=./tests/step-19",
     "test:20": "jest --testPathPattern=./tests/step-20",
+   
     "test-verbose": "jest --verbose",
     "server": "node ./src/server.js"
   },
@@ -38,11 +39,11 @@
   "author": "Chakshu Gautam",
   "license": "ISC",
   "devDependencies": {
+    "csv-parser": "^3.0.0",
     "jest": "^29.7.0"
   },
   "dependencies": {
-    "csv-parser": "^3.0.0",
     "json2csv": "^6.0.0-alpha.2",
     "xterm": "^5.3.0"
   }
-}
\ No newline at end of file
+}
diff --git a/src/cli.js b/src/cli.js
new file mode 100644
index 000000000..f19119849
--- /dev/null
+++ b/src/cli.js
@@ -0,0 +1,30 @@
+const readline = require('readline');
+const {executeSELECTQuery,executeDELETEQuery,executeINSERTQuery} = require('./index');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+rl.setPrompt('SQL> ');
+console.log('SQL Query Engine CLI. Enter your SQL commands, or type "exit" to quit.');
+
+rl.prompt();
+
+rl.on('line', async (line) => {
+    if (line.toLowerCase() === 'exit') {
+        rl.close();
+        return;
+    }
+
+    try {
+        // Execute the query - do your own implementation
+    }catch (error) {
+        console.error('Error:', error.message);
+    }
+
+    rl.prompt();
+}).on('close', () => {
+    console.log('Exiting SQL CLI');
+    process.exit(0);
+});
\ No newline at end of file
diff --git a/src/csvReader.js b/src/csvReader.js
index e69de29bb..526e1d935 100644
--- a/src/csvReader.js
+++ b/src/csvReader.js
@@ -0,0 +1,26 @@
+const fs = require('fs');
+const csv = require('csv-parser');
+const { parse } = require('json2csv');
+
+function readCSV(filePath) {
+    const results = [];
+
+    return new Promise((resolve, reject) => {
+        fs.createReadStream(filePath)
+            .pipe(csv())
+            .on('data', (data) => results.push(data))
+            .on('end', () => {
+                resolve(results);
+            })
+            .on('error', (error) => {
+                reject(error);
+            });
+    });
+}
+
+async function writeCSV(filename, data) {
+    const csv = parse(data);
+    fs.writeFileSync(filename, csv);
+}
+
+module.exports = {readCSV,writeCSV};
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 000000000..50e9f5758
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,359 @@
+// src/index.js
+
+const  { parseSelectQuery,parseInsertQuery,parseDeleteQuery} = require('./queryParser');
+const {readCSV, writeCSV} = require('./csvReader');
+
+
+function evaluateCondition(row, clause) {
+    let { field, operator, value } = clause;
+   
+    value = value.replace(/["']/g, '');
+    if(row[field])
+    row[field] = row[field].replace(/["']/g, '');
+
+    if (operator === 'LIKE') {
+        // Transform SQL LIKE pattern to JavaScript RegExp pattern
+        const regexPattern = '^' + value.replace(/%/g, '.*').replace(/_/g, '.') + '$';
+        const regex = new RegExp(regexPattern, 'i'); // 'i' for case-insensitive matching
+    
+
+        return regex.test(row[field]);
+    }
+
+    switch (operator) {
+        case '=':  return row[field] == value;
+        case '!=': return row[field] !== value;
+        case '>': return row[field] > value;
+        case '<': return row[field] < value;
+        case '>=': return row[field] >= value;
+        case '<=': return row[field] <= value;
+        default: throw new Error(`Unsupported operator: ${operator}`);
+    }
+}
+
+function performInnerJoin(data, joinData, joinCondition, fields, table) {
+    // Logic for INNER JOIN
+    data = data.flatMap(mainRow => {
+        
+        return joinData
+            .filter(joinRow => {
+                const mainValue = mainRow[joinCondition.left.split('.')[1]];
+                const joinValue = joinRow[joinCondition.right.split('.')[1]];
+                return mainValue === joinValue;
+            })
+            .map(joinRow => {
+                return fields.reduce((acc, field) => {
+                    const [tableName, fieldName] = field.split('.');
+                    acc[field] = tableName === table ? mainRow[fieldName] : joinRow[fieldName];
+                    return acc;
+                }, {});
+            });
+    });
+    return data
+    // ...
+}
+
+function performLeftJoin(data, joinData, joinCondition, fields, table) {
+    
+    return data.flatMap(mainRow => {
+        const matchingJoinRows = joinData.filter(joinRow => {
+            const mainValue = getValueFromRow(mainRow, joinCondition.left);
+            const joinValue = getValueFromRow(joinRow, joinCondition.right);
+            return mainValue === joinValue;
+        });
+
+        if (matchingJoinRows.length === 0) {
+            return [createResultRow(mainRow, null, fields, table, true)];
+        }
+
+        return matchingJoinRows.map(joinRow => createResultRow(mainRow, joinRow, fields, table, true));
+    });
+}
+
+function getValueFromRow(row, compoundFieldName) {
+    const [tableName, fieldName] = compoundFieldName.split('.');
+    return row[`${tableName}.${fieldName}`] || row[fieldName];
+}
+
+function performRightJoin(data, joinData, joinCondition, fields, table) {
+    // Cache the structure of a main table row (keys only)
+    const mainTableRowStructure = data.length > 0 ? Object.keys(data[0]).reduce((acc, key) => {
+        acc[key] = null; // Set all values to null initially
+        return acc;
+    }, {}) : {};
+
+    return joinData.map(joinRow => {
+        const mainRowMatch = data.find(mainRow => {
+            const mainValue = getValueFromRow(mainRow, joinCondition.left);
+            const joinValue = getValueFromRow(joinRow, joinCondition.right);
+            return mainValue === joinValue;
+        });
+
+        // Use the cached structure if no match is found
+        const mainRowToUse = mainRowMatch || mainTableRowStructure;
+
+        // Include all necessary fields from the 'student' table
+        return createResultRow(mainRowToUse, joinRow, fields, table, true);
+    });
+}
+
+function createResultRow(mainRow, joinRow, fields, table, includeAllMainFields) {
+    const resultRow = {};
+
+    if (includeAllMainFields) {
+        // Include all fields from the main table
+        Object.keys(mainRow || {}).forEach(key => {
+            const prefixedKey = `${table}.${key}`;
+            resultRow[prefixedKey] = mainRow ? mainRow[key] : null;
+        });
+    }
+
+    // Now, add or overwrite with the fields specified in the query
+    fields.forEach(field => {
+        const [tableName, fieldName] = field.includes('.') ? field.split('.') : [table, field];
+        resultRow[field] = tableName === table && mainRow ? mainRow[fieldName] : joinRow ? joinRow[fieldName] : null;
+    });
+
+    return resultRow;
+}
+// Helper function to apply GROUP BY and aggregate functions
+
+function applyGroupBy(data, groupByFields, aggregateFunctions) {
+    // Implement logic to group data and calculate aggregates
+    const groupResults = {};
+    
+    data.forEach((row) => {
+        const groupKey = groupByFields.map(field => row[field]).join('-');
+        
+        if (!groupResults[groupKey]) {
+            groupResults[groupKey] = { count: 0, sums: {}, mins: {}, maxes: {} };
+            groupByFields.forEach(field => groupResults[groupKey][field] = row[field]);
+        }
+
+        // Aggregate calculations
+        groupResults[groupKey].count += 1;
+        aggregateFunctions.forEach(func => {
+            const match = /(\w+)\((\w+)\)/.exec(func);
+            if (match) {
+                const [, aggFunc, aggField] = match;
+                const value = parseFloat(row[aggField]);
+
+                switch (aggFunc.toUpperCase()) {
+                    case 'SUM':
+                        groupResults[groupKey].sums[aggField] = (groupResults[groupKey].sums[aggField] || 0) + value;
+                        break;
+                    case 'MIN':
+                        groupResults[groupKey].mins[aggField] = Math.min(groupResults[groupKey].mins[aggField] || value, value);
+                        break;
+                    case 'MAX':
+                        groupResults[groupKey].maxes[aggField] = Math.max(groupResults[groupKey].maxes[aggField] || value, value);
+                        break;
+                    // Additional aggregate functions can be added here
+                }
+            }
+        });
+    });
+
+    // Convert grouped results into an array format
+    return Object.values(groupResults).map(group => {
+        // Construct the final grouped object based on required fields
+        const finalGroup = {};
+        groupByFields.forEach(field => finalGroup[field] = group[field]);
+        aggregateFunctions.forEach(func => {
+            const match = /(\w+)\((\*|\w+)\)/.exec(func);
+            if (match) {
+                const [, aggFunc, aggField] = match;
+                switch (aggFunc.toUpperCase()) {
+                    case 'SUM':
+                        finalGroup[func] = group.sums[aggField];
+                        break;
+                    case 'MIN':
+                        finalGroup[func] = group.mins[aggField];
+                        break;
+                    case 'MAX':
+                        finalGroup[func] = group.maxes[aggField];
+                        break;
+                    case 'COUNT':
+                        finalGroup[func] = group.count;
+                        break;
+                    // Additional aggregate functions can be handled here
+                }
+            }
+        });
+        return finalGroup;
+    });
+}
+
+
+function aggregatedOperations(aggregateFunction, rows) {
+    const [op, fieldName] = aggregateFunction
+      .split("(")
+      .map((part) => part.trim().replace(")", ""));
+    if (fieldName === "*") {
+      return rows.length;
+    }
+  
+    const values = rows.map((row) => row[fieldName]);
+  
+    let result;
+    switch (op.toUpperCase()) {
+      case "COUNT":
+        result = values.length;
+        break;
+      case "AVG":
+        result =
+          values.reduce((acc, val) => acc + Number(val), 0) / values.length;
+        break;
+      case "MAX":
+        result = Math.max(...values);
+        break;
+      case "MIN":
+        result = Math.min(...values);
+        break;
+      case "SUM":
+        result = values.reduce((acc, val) => acc + Number(val), 0);
+        break;
+      // Handle other aggregate functions if needed
+      default:
+        throw new Error(`Unsupported aggregate function: ${op}`);
+    }
+  
+    return result;
+}
+  
+async function executeSELECTQuery(query) {
+    try {
+        const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit,isDistinct, hasAggregateWithoutGroupBy } = parseSelectQuery(query)
+   
+        let data = await readCSV(`${table}.csv`);
+        
+        // Perform INNER JOIN if specified
+        if (joinTable && joinCondition) {
+            const joinData = await readCSV(`${joinTable}.csv`);
+            switch (joinType.toUpperCase()) {
+                case 'INNER':
+                    data = performInnerJoin(data, joinData, joinCondition, fields, table);
+                    break;
+                case 'LEFT':
+                    data = performLeftJoin(data, joinData, joinCondition, fields, table);
+                    break;
+                case 'RIGHT':
+                    data = performRightJoin(data, joinData, joinCondition, fields, table);
+                    break;
+                // Handle default case or unsupported JOIN types
+            }
+        }
+    
+    
+        let filteredData = whereClauses.length > 0
+        ? data.filter(row => whereClauses.every(clause => evaluateCondition(row, clause)))
+            : data;
+        
+    // logic for group by
+    if (groupByFields) {
+        filteredData = applyGroupBy(filteredData, groupByFields, fields);
+      }
+  
+      if (hasAggregateWithoutGroupBy && fields.length == 1) {
+        const selectedRow = {};
+        selectedRow[fields[0]] = aggregatedOperations(fields[0], filteredData);
+        return [selectedRow];
+      }
+  
+      // console.log("AFTER GROUP: ", filteredData);
+  
+      if (orderByFields) {
+        filteredData.sort((a, b) => {
+          for (let { fieldName, order } of orderByFields) {
+            if (a[fieldName] < b[fieldName]) return order === "ASC" ? -1 : 1;
+            if (a[fieldName] > b[fieldName]) return order === "ASC" ? 1 : -1;
+          }
+          return 0;
+        });
+      }
+  
+      // console.log("AFTER ORDER: ", filteredData);
+  
+      if (limit !== null) {
+        filteredData = filteredData.slice(0, limit);
+      }
+  
+      if (isDistinct) {
+        filteredData = [
+          ...new Map(
+            filteredData.map((item) => [
+              fields.map((field) => item[field]).join("|"),
+              item,
+            ])
+          ).values(),
+        ];
+      }
+  
+      // Filter the fields based on the query fields
+      return filteredData.map((row) => {
+        const selectedRow = {};
+        fields.forEach((field) => {
+          if (hasAggregateWithoutGroupBy) {
+            selectedRow[field] = aggregatedOperations(field, filteredData);
+          } else {
+            selectedRow[field] = row[field];
+          }
+        });
+        return selectedRow;
+      });
+    } catch (error) {
+      throw new Error(`Error executing query: ${error.message}`);
+    }
+  }
+  async function executeINSERTQuery(query) {
+    const { table, columns, values, returningColumns } = parseInsertQuery(query);
+    const data = await readCSV(`${table}.csv`);
+
+    
+    const headers = data.length > 0 ? Object.keys(data[0]) : columns;
+    const newRow = {};
+    headers.forEach(header => {
+        const columnIndex = columns.indexOf(header);
+        if (columnIndex !== -1) {
+            let value = values[columnIndex];
+            if (value.startsWith("'") && value.endsWith("'")) {
+                value = value.substring(1, value.length - 1);
+            }
+            newRow[header] = value;
+        } else {
+            newRow[header] = header === 'id' ? newId.toString() : '';
+        }
+    });
+
+    data.push(newRow);
+
+    await writeCSV(`${table}.csv`, data);
+
+    let returningResult = {};
+    if (returningColumns.length > 0) {
+        returningColumns.forEach(column => {
+            returningResult[column] = newRow[column];
+        });
+    }
+
+    return {
+        returning: returningResult
+    };
+}
+
+async function executeDELETEQuery(query) {
+    const { table, whereClause } = parseDeleteQuery(query);
+    let data = await readCSV(`${table}.csv`);
+
+    if (whereClause.length > 0) {
+        data = data.filter(row => !whereClause.every(clause => evaluateCondition(row, clause)));
+    } else {
+        data = [];
+    }
+
+    await writeCSV(`${table}.csv`, data);
+
+    return { message: "Rows deleted successfully." };
+}
+
+module.exports = {executeSELECTQuery, executeINSERTQuery, executeDELETEQuery};
\ No newline at end of file
diff --git a/src/queryParser.js b/src/queryParser.js
new file mode 100644
index 000000000..f0470679c
--- /dev/null
+++ b/src/queryParser.js
@@ -0,0 +1,215 @@
+
+function parseSelectQuery(query) {
+    try {
+        // Trim the query to remove any leading/trailing whitespaces
+        query = query.trim();
+        let isDistinct = false;
+        if (query.toUpperCase().includes('SELECT DISTINCT')) {
+            isDistinct = true;
+            query = query.replace('SELECT DISTINCT', 'SELECT');
+        }
+
+        const limitRegex = /\sLIMIT\s(\d+)/i;
+    
+    
+        const limitMatch = query.match(limitRegex);
+        let limit = null;
+        if (limitMatch) {
+            limit = parseInt(limitMatch[1]);
+        }
+        query = query.replace(limitRegex, '');
+
+        // Updated regex to capture ORDER BY clause
+
+        const orderByRegex = /\sORDER BY\s(.+)/i;
+        const orderByMatch = query.match(orderByRegex);
+
+        let orderByFields = null;
+        if (orderByMatch) {
+            orderByFields = orderByMatch[1].split(',').map(field => {
+                const [fieldName, order] = field.trim().split(/\s+/);
+                return { fieldName, order: order ? order.toUpperCase() : 'ASC' };
+            });
+        }
+        // 
+        // Remove ORDER BY clause from the query for further processing
+        query = query.replace(orderByRegex, '');
+
+        // Split the query at the GROUP BY clause if it exists
+        const groupByRegex = /\sGROUP BY\s(.+)/i;
+        const groupByMatch = query.match(groupByRegex);
+
+        let groupByFields = null;
+        if (groupByMatch) {
+            groupByFields = groupByMatch[1].split(',').map(field => field.trim());
+        }
+
+        // Remove GROUP BY clause from the query for further processing
+        query = query.replace(groupByRegex, '');
+    
+   
+
+        // Split the query at the WHERE clause if it exists
+        const whereSplit = query.split(/\sWHERE\s/i);
+        const queryWithoutWhere = whereSplit[0]; // Everything before WHERE clause
+
+        // WHERE clause is the second part after splitting, if it exists
+        const whereClause = whereSplit.length > 1 ? whereSplit[1].trim() : null;
+
+        // identifying like statement
+
+       
+
+        // Split the remaining query at the JOIN clause if it exists
+        const joinSplit = queryWithoutWhere.split(/\s(INNER|LEFT|RIGHT) JOIN\s/i);
+        const selectPart = joinSplit[0].trim(); // Everything before JOIN clause
+
+        // Parse the SELECT part
+        const selectRegex = /^SELECT\s(.+?)\sFROM\s(.+)/i;
+        const selectMatch = selectPart.match(selectRegex);
+        
+            if (!selectMatch) {
+                throw new Error("Invalid SELECT format");
+              }
+          
+        
+
+        const [, fields, table] = selectMatch;
+
+  
+
+        // Extract JOIN information
+        const { joinType, joinTable, joinCondition } = parseJoinClause(queryWithoutWhere);
+
+        // Parse the WHERE part if it exists
+        let whereClauses = [];
+        if (whereClause) {
+            whereClauses = parseWhereClause(whereClause);
+        }
+
+        // Check for the presence of aggregate functions without GROUP BY
+        const aggregateFunctionRegex = /(\bCOUNT\b|\bAVG\b|\bSUM\b|\bMIN\b|\bMAX\b)\s*\(\s*(\*|\w+)\s*\)/i;
+        const hasAggregateWithoutGroupBy = aggregateFunctionRegex.test(query) && !groupByFields;
+
+    
+ 
+        return {
+            fields: fields.split(',').map(field => field.trim()),
+            table: table.trim(),
+            whereClauses,
+            joinType,
+            joinTable,
+            joinCondition,
+            groupByFields,
+            orderByFields,
+            limit,
+            isDistinct,
+            hasAggregateWithoutGroupBy
+        };
+    }catch (error) {
+        throw new Error(`Query parsing error: ${error.message}`);
+    }
+}
+
+function parseWhereClause(whereString) {
+    const conditionRegex = /(.*?)(=|!=|>=|<=|>|<)(.*)/;
+    return whereString.split(/ AND | OR /i).map(conditionString => {
+        if (conditionString.includes(' LIKE ')) {
+            const [field, pattern] = conditionString.split(/\sLIKE\s/i);
+            return { field: field.trim(), operator: 'LIKE', value: pattern.trim().replace(/^'(.*)'$/, '$1') };
+        } else {
+            const match = conditionString.match(conditionRegex);
+            if (match) {
+                const [, field, operator, value] = match;
+                return { field: field.trim(), operator, value: value.trim() };
+            }
+            throw new Error('Invalid WHERE clause format');
+        }
+    });
+}
+
+
+
+function parseJoinClause(query) {
+    const joinRegex = /\s(INNER|LEFT|RIGHT) JOIN\s(.+?)\sON\s([\w.]+)\s*=\s*([\w.]+)/i;
+    const joinMatch = query.match(joinRegex);
+
+    if (joinMatch) {
+        return {
+            joinType: joinMatch[1].trim(),
+            joinTable: joinMatch[2].trim(),
+            joinCondition: {
+                left: joinMatch[3].trim(),
+                right: joinMatch[4].trim()
+            }
+        };
+    }
+
+    
+
+    return {
+        joinType: null,
+        joinTable: null,
+        joinCondition: null
+    };
+}
+
+
+function parseInsertQuery(query) {
+    query = query.replace(/"?\w+"?\."(\w+)"?/g, '$1');
+
+    const insertRegex = /INSERT INTO "?(\w+)"?\s\(([^)]+)\)\sVALUES\s\(([^)]+)\)/i;
+    const insertMatch = query.match(insertRegex);
+
+    if (!insertMatch) {
+        throw new Error("Invalid INSERT INTO syntax.");
+    }
+
+    const [, table, columns, values] = insertMatch;
+
+    const parsedColumns = columns.split(',').map((name) => {
+        return name.trim().replace(/^"?(.+?)"?$/g, '$1');
+    });
+
+    const parsedValues = values.split(',').map((value) => {
+        return value.trim().replace(/^'(.*)'$/g, '$1').replace(/^"(.*)"$/g, '$1');
+    });
+
+    const returningMatch = query.match(/RETURNING\s(.+)$/i);
+    const returningColumns = returningMatch
+        ? returningMatch[1].split(',').map((name) => {
+            return name.trim().replace(/\w+\./g, '').replace(/^"?(.+?)"?$/g, '$1');
+        })
+        : [];
+    return {
+        type: 'INSERT',
+        table: table.trim().replace(/^"?(.+?)"?$/g, '$1'),
+        columns: parsedColumns,
+        values: parsedValues,
+        returningColumns
+    };
+}
+
+function parseDeleteQuery(query) {
+    const deleteRegex = /DELETE FROM (\w+)( WHERE (.*))?/i;
+    const deleteMatch = query.match(deleteRegex);
+
+    if (!deleteMatch) {
+        throw new Error("Invalid DELETE syntax.");
+    }
+
+    const [, table, ,whereString] = deleteMatch;
+    let whereClause = [];
+    if (whereString) {
+        whereClause = parseWhereClause(whereString);
+    }
+
+    return {
+        type: 'DELETE',
+        table: table.trim(),
+        whereClause
+    };
+}
+
+
+module.exports = { parseSelectQuery, parseJoinClause, parseInsertQuery, parseDeleteQuery };
\ No newline at end of file
diff --git a/student.csv b/student.csv
new file mode 100644
index 000000000..62af2b027
--- /dev/null
+++ b/student.csv
@@ -0,0 +1,5 @@
+id,name,age
+1,John,30
+2,Jane,25
+3,Bob,22
+4,Alice,24
diff --git a/tests/step-02/index.test.js b/tests/step-02/index.test.js
index a5467ee48..5eedb3f26 100644
--- a/tests/step-02/index.test.js
+++ b/tests/step-02/index.test.js
@@ -1,9 +1,9 @@
-const readCSV = require('../../src/csvReader');
+const {readCSV} = require('../../src/csvReader');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
-    expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+        const data = await readCSV('./student.csv');
+        expect(data.length).toBeGreaterThan(0);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
\ No newline at end of file
diff --git a/tests/step-03/index.test.js b/tests/step-03/index.test.js
index 9145ad3e4..a46ab14a6 100644
--- a/tests/step-03/index.test.js
+++ b/tests/step-03/index.test.js
@@ -1,19 +1,28 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample'
+        table: 'student',
+        whereClauses: [],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
\ No newline at end of file
diff --git a/tests/step-04/index.test.js b/tests/step-04/index.test.js
index bc353dd3d..0e606bfd5 100644
--- a/tests/step-04/index.test.js
+++ b/tests/step-04/index.test.js
@@ -1,26 +1,35 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample'
+        table: 'student',
+        whereClauses: [],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query', async () => {
-    const query = 'SELECT id, name FROM sample';
+    const query = 'SELECT id, name FROM student';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBeGreaterThan(0);
     expect(result[0]).toHaveProperty('id');
diff --git a/tests/step-05/index.test.js b/tests/step-05/index.test.js
index 66a77c061..91efe3130 100644
--- a/tests/step-05/index.test.js
+++ b/tests/step-05/index.test.js
@@ -1,27 +1,35 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
-        whereClause: null
+        table: 'student',
+        whereClauses: [],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct:false
     });
 });
 
 test('Execute SQL Query', async () => {
-    const query = 'SELECT id, name FROM sample';
+    const query = 'SELECT id, name FROM student';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBeGreaterThan(0);
     expect(result[0]).toHaveProperty('id');
@@ -31,20 +39,41 @@ test('Execute SQL Query', async () => {
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student WHERE age = 25';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
-        whereClause: 'age = 25'
+        table: 'student',
+        whereClauses: [{
+            "field": "age",
+            "operator": "=",
+            "value": "25",
+        }],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct:false
     });
 });
 
+
 test('Execute SQL Query with WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
+    const query = 'SELECT id, name FROM student where age = 25';
     const result = await executeSELECTQuery(query);
-    expect(result.length).toBe(1);
-    expect(result[0]).toHaveProperty('id');
-    expect(result[0]).toHaveProperty('name');
-    expect(result[0].id).toBe('2');
+    let newresult = result.map((obj) => {
+        const newobj = {}
+        for (const key in obj) {
+            newobj[key.toLowerCase()]=obj[key]
+        }
+        return newobj
+    })
+    console.log("redsult",newresult)
+    expect(newresult.length).toBe(1);
+    expect(newresult[0]).toHaveProperty('id');
+    expect(newresult[0]).toHaveProperty('name');
+    expect(newresult[0].id).toBe('2');
 });
\ No newline at end of file
diff --git a/tests/step-06/index.test.js b/tests/step-06/index.test.js
index 2e2ef6416..75cd701e1 100644
--- a/tests/step-06/index.test.js
+++ b/tests/step-06/index.test.js
@@ -1,27 +1,35 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
-        whereClauses: []
+       table: 'student',
+        whereClauses: [],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query', async () => {
-    const query = 'SELECT id, name FROM sample';
+    const query = 'SELECT id, name FROM student';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBeGreaterThan(0);
     expect(result[0]).toHaveProperty('id');
@@ -31,21 +39,29 @@ test('Execute SQL Query', async () => {
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student WHERE age = 25';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
+        table: 'student',
         whereClauses: [{
-          field: "age",
-          operator: "=",
-          value: "25",
+            "field": "age",
+            "operator": "=",
+            "value": "25",
         }],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query with WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
+    const query = 'SELECT id, name FROM student WHERE age = 25';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBe(1);
     expect(result[0]).toHaveProperty('id');
@@ -54,11 +70,11 @@ test('Execute SQL Query with WHERE Clause', async () => {
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
+        table: 'student',
         whereClauses: [{
             "field": "age",
             "operator": "=",
@@ -67,12 +83,20 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
             "field": "name",
             "operator": "=",
             "value": "John",
-        }]
+        }],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query with Multiple WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 30 AND name = John';
+    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBe(1);
     expect(result[0]).toEqual({ id: '1', name: 'John' });
diff --git a/tests/step-07/index.test.js b/tests/step-07/index.test.js
index ee0ebed5e..3b7b52c34 100644
--- a/tests/step-07/index.test.js
+++ b/tests/step-07/index.test.js
@@ -1,27 +1,35 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
-    const data = await readCSV('./sample.csv');
+    const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM sample';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
-        whereClauses: []
+        table: 'student',
+        whereClauses: [],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query', async () => {
-    const query = 'SELECT id, name FROM sample';
+    const query = 'SELECT id, name FROM student';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBeGreaterThan(0);
     expect(result[0]).toHaveProperty('id');
@@ -31,21 +39,29 @@ test('Execute SQL Query', async () => {
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student WHERE age = 25';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
+        table: 'student',
         whereClauses: [{
-          field: "age",
-          operator: "=",
-          value: "25",
+            "field": "age",
+            "operator": "=",
+            "value": "25",
         }],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query with WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 25';
+    const query = 'SELECT id, name FROM student WHERE age = 25';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBe(1);
     expect(result[0]).toHaveProperty('id');
@@ -54,11 +70,11 @@ test('Execute SQL Query with WHERE Clause', async () => {
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'sample',
+        table: 'student',
         whereClauses: [{
             "field": "age",
             "operator": "=",
@@ -67,27 +83,35 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
             "field": "name",
             "operator": "=",
             "value": "John",
-        }]
+        }],
+        joinCondition: null,
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Execute SQL Query with Multiple WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM sample WHERE age = 30 AND name = John';
+    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
     const result = await executeSELECTQuery(query);
     expect(result.length).toBe(1);
     expect(result[0]).toEqual({ id: '1', name: 'John' });
 });
 
 test('Execute SQL Query with Greater Than', async () => {
-    const queryWithGT = 'SELECT id FROM sample WHERE age > 22';
+    const queryWithGT = 'SELECT id FROM student WHERE age > 22';
     const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
+    expect(result.length).toEqual(3);
     expect(result[0]).toHaveProperty('id');
 });
 
 test('Execute SQL Query with Not Equal to', async () => {
-    const queryWithGT = 'SELECT name FROM sample WHERE age != 25';
+    const queryWithGT = 'SELECT name FROM student WHERE age != 25';
     const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
+    expect(result.length).toEqual(3);
     expect(result[0]).toHaveProperty('name');
 });
\ No newline at end of file
diff --git a/tests/step-08/index.test.js b/tests/step-08/index.test.js
index aab1467e6..b239ef966 100644
--- a/tests/step-08/index.test.js
+++ b/tests/step-08/index.test.js
@@ -1,24 +1,30 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
     expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
+    expect(data.length).toBe(4);
     expect(data[0].name).toBe('John');
     expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
 });
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
         whereClauses: [],
         joinCondition: null,
-        joinTable: null
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -34,17 +40,23 @@ test('Execute SQL Query', async () => {
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
-        table: 'student',
+       table: 'student',
         whereClauses: [{
             "field": "age",
             "operator": "=",
             "value": "25",
         }],
         joinCondition: null,
-        joinTable: null
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -59,7 +71,7 @@ test('Execute SQL Query with WHERE Clause', async () => {
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -73,7 +85,13 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
             "value": "John",
         }],
         joinCondition: null,
-        joinTable: null
+        joinTable: null,
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -87,38 +105,50 @@ test('Execute SQL Query with Complex WHERE Clause', async () => {
 test('Execute SQL Query with Greater Than', async () => {
     const queryWithGT = 'SELECT id FROM student WHERE age > 22';
     const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
+    expect(result.length).toEqual(3);
     expect(result[0]).toHaveProperty('id');
 });
 
 test('Execute SQL Query with Not Equal to', async () => {
     const queryWithGT = 'SELECT name FROM student WHERE age != 25';
     const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
+    expect(result.length).toEqual(3);
     expect(result[0]).toHaveProperty('name');
 });
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
         whereClauses: [],
         joinTable: 'enrollment',
-        joinCondition: { left: 'student.id', right: 'enrollment.student_id' }
+        joinType: "INNER",
+        joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
         whereClauses: [{ field: 'student.age', operator: '>', value: '20' }],
         joinTable: 'enrollment',
-        joinCondition: { left: 'student.id', right: 'enrollment.student_id' }
+        joinType:"INNER",
+        joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
diff --git a/tests/step-09/index.test.js b/tests/step-09/index.test.js
index aaf711f5a..bf06b61df 100644
--- a/tests/step-09/index.test.js
+++ b/tests/step-09/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery,parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -12,14 +12,20 @@ test('Read CSV File', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
+    console.log(parsed)
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
         whereClauses: [],
         joinCondition: null,
         joinTable: null,
-        joinType: null
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -35,7 +41,7 @@ test('Execute SQL Query', async () => {
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -46,7 +52,12 @@ test('Parse SQL Query with WHERE Clause', () => {
         }],
         joinCondition: null,
         joinTable: null,
-        joinType: null
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -61,7 +72,7 @@ test('Execute SQL Query with WHERE Clause', async () => {
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -76,7 +87,12 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
         }],
         joinCondition: null,
         joinTable: null,
-        joinType: null
+        joinType: null,
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
@@ -103,27 +119,37 @@ test('Execute SQL Query with Not Equal to', async () => {
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
         whereClauses: [],
         joinTable: 'enrollment',
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
-        joinType: 'INNER'
+        joinType: 'INNER',
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
         whereClauses: [{ field: 'student.age', operator: '>', value: '20' }],
         joinTable: 'enrollment',
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
-        joinType: 'INNER'
+        joinType: 'INNER',
+        groupByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
diff --git a/tests/step-10/index.test.js b/tests/step-10/index.test.js
index 5e118eda5..33de1ba8f 100644
--- a/tests/step-10/index.test.js
+++ b/tests/step-10/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -226,6 +226,7 @@ test('Count courses per student', async () => {
 test('Count students within a specific age range', async () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
     const result = await executeSELECTQuery(query);
+    console.log("result",result)
     expect(result).toEqual([
         { age: '24', 'COUNT(*)': 1 },
         { age: '25', 'COUNT(*)': 1 },
@@ -236,6 +237,7 @@ test('Count students within a specific age range', async () => {
 test('Count enrollments for a specific course', async () => {
     const query = 'SELECT course, COUNT(*) FROM enrollment WHERE course = "Mathematics" GROUP BY course';
     const result = await executeSELECTQuery(query);
+    console.log(result)
     expect(result).toEqual([
         { course: 'Mathematics', 'COUNT(*)': 2 }
     ]);
@@ -258,7 +260,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -267,13 +269,16 @@ test('Parse SQL Query', () => {
         joinTable: null,
         joinType: null,
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -286,13 +291,16 @@ test('Parse SQL Query with WHERE Clause', () => {
         joinTable: null,
         joinType: null,
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -309,13 +317,16 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
         joinTable: null,
         joinType: null,
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -324,13 +335,16 @@ test('Parse SQL Query with INNER JOIN', async () => {
         joinType: "INNER",
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -339,7 +353,10 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
         joinType: "INNER",
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     })
 });
 
@@ -387,7 +404,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -396,13 +413,16 @@ test('Parse LEFT Join Query Completely', () => {
         joinTable: 'enrollment',
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     })
 })
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -411,13 +431,16 @@ test('Parse LEFT Join Query Completely', () => {
         joinTable: 'enrollment',
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     })
 })
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -426,13 +449,16 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
         "table": "student",
         "whereClauses": [{ "field": "student.age", "operator": ">", "value": "22" }],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -441,13 +467,16 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
         "table": "student",
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Physics'" }],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -456,13 +485,16 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
         "table": "student",
         "whereClauses": [{ "field": "student.age", "operator": "<", "value": "25" }],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -471,20 +503,26 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
         "table": "student",
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Chemistry'" }],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false,
     });
 });
 
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
         whereClauses: [],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: true,
+        limit:null,
+        isDistinct: false,
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
@@ -494,13 +532,16 @@ test('Parse COUNT Aggregate Query', () => {
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
         whereClauses: [],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: true,
+        limit:null,
+        isDistinct: false,
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
@@ -509,13 +550,16 @@ test('Parse SUM Aggregate Query', () => {
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
         whereClauses: [],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: true,
+        limit:null,
+        isDistinct: false,
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
@@ -524,13 +568,16 @@ test('Parse AVG Aggregate Query', () => {
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
         whereClauses: [],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: true,
+        limit:null,
+        isDistinct: false,
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
@@ -539,13 +586,16 @@ test('Parse MIN Aggregate Query', () => {
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
         whereClauses: [],
         groupByFields: null,
+        orderByFields: null,
         hasAggregateWithoutGroupBy: true,
+        limit:null,
+        isDistinct: false,
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
@@ -554,7 +604,7 @@ test('Parse MAX Aggregate Query', () => {
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -563,13 +613,16 @@ test('Parse basic GROUP BY query', () => {
         joinType: null,
         joinTable: null,
         joinCondition: null,
-        hasAggregateWithoutGroupBy: false
+        orderByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -578,13 +631,16 @@ test('Parse GROUP BY query with WHERE clause', () => {
         joinType: null,
         joinTable: null,
         joinCondition: null,
-        hasAggregateWithoutGroupBy: false
+        orderByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -593,13 +649,16 @@ test('Parse GROUP BY query with multiple fields', () => {
         joinType: null,
         joinTable: null,
         joinCondition: null,
-        hasAggregateWithoutGroupBy: false
+        orderByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
@@ -611,6 +670,9 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
             left: 'student.id',
             right: 'enrollment.student_id'
         },
-        hasAggregateWithoutGroupBy: false
+        orderByFields: null,
+        hasAggregateWithoutGroupBy: false,
+        limit:null,
+        isDistinct: false
     });
 });
\ No newline at end of file
diff --git a/tests/step-11/index.test.js b/tests/step-11/index.test.js
index 1cf5f2def..f7c91f3f5 100644
--- a/tests/step-11/index.test.js
+++ b/tests/step-11/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -268,13 +268,15 @@ test('Parse SQL Query', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -288,13 +290,15 @@ test('Parse SQL Query with WHERE Clause', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -312,13 +316,15 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -328,13 +334,15 @@ test('Parse SQL Query with INNER JOIN', async () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -344,7 +352,9 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     })
 });
 
@@ -392,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -402,13 +412,15 @@ test('Parse LEFT Join Query Completely', () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     })
 })
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -418,13 +430,15 @@ test('Parse LEFT Join Query Completely', () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     })
 })
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -434,13 +448,15 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
         "whereClauses": [{ "field": "student.age", "operator": ">", "value": "22" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -450,13 +466,15 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Physics'" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -466,13 +484,15 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
         "whereClauses": [{ "field": "student.age", "operator": "<", "value": "25" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -482,14 +502,16 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Chemistry'" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -499,14 +521,16 @@ test('Parse COUNT Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -516,13 +540,15 @@ test('Parse SUM Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -532,13 +558,15 @@ test('Parse AVG Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -548,13 +576,15 @@ test('Parse MIN Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -564,13 +594,15 @@ test('Parse MAX Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null
+        "orderByFields": null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -580,13 +612,15 @@ test('Parse basic GROUP BY query', () => {
         joinTable: null,
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
-        orderByFields: null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -596,13 +630,15 @@ test('Parse GROUP BY query with WHERE clause', () => {
         joinTable: null,
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
-        orderByFields: null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -612,13 +648,15 @@ test('Parse GROUP BY query with multiple fields', () => {
         joinTable: null,
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
-        orderByFields: null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
@@ -631,7 +669,9 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
             right: 'enrollment.student_id'
         },
         hasAggregateWithoutGroupBy: false,
-        orderByFields: null
+        orderByFields: null,
+        limit:null,
+        isDistinct: false
     });
 });
 
diff --git a/tests/step-12/index.test.js b/tests/step-12/index.test.js
index d15c77ef5..477c55eed 100644
--- a/tests/step-12/index.test.js
+++ b/tests/step-12/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -268,14 +268,15 @@ test('Parse SQL Query', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -289,14 +290,15 @@ test('Parse SQL Query with WHERE Clause', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -314,14 +316,15 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
         joinType: null,
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -331,14 +334,15 @@ test('Parse SQL Query with INNER JOIN', async () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -348,8 +352,9 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     })
 });
 
@@ -397,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -407,14 +412,15 @@ test('Parse LEFT Join Query Completely', () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     })
 })
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -424,14 +430,15 @@ test('Parse LEFT Join Query Completely', () => {
         joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     })
 })
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -441,14 +448,15 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
         "whereClauses": [{ "field": "student.age", "operator": ">", "value": "22" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -458,14 +466,15 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Physics'" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -475,14 +484,15 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
         "whereClauses": [{ "field": "student.age", "operator": "<", "value": "25" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -492,15 +502,16 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
         "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Chemistry'" }],
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -510,15 +521,16 @@ test('Parse COUNT Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -528,14 +540,15 @@ test('Parse SUM Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -545,14 +558,15 @@ test('Parse AVG Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -562,14 +576,15 @@ test('Parse MIN Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -579,14 +594,15 @@ test('Parse MAX Aggregate Query', () => {
         "joinCondition": null,
         "joinTable": null,
         "joinType": null,
-        "orderByFields": null,
-        "limit": null
+        orderByFields: null,
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -597,13 +613,14 @@ test('Parse basic GROUP BY query', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -614,13 +631,14 @@ test('Parse GROUP BY query with WHERE clause', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -631,13 +649,14 @@ test('Parse GROUP BY query with multiple fields', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        limit: null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
@@ -651,7 +670,9 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
         },
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null,
+        limit: null,
+        isDistinct: false,
+        isDistinct: false
     });
 });
 
@@ -715,6 +736,7 @@ test('Execute SQL Query with LIMIT 0', async () => {
 test('Execute SQL Query with LIMIT and ORDER BY clause', async () => {
     const query = 'SELECT id, name FROM student ORDER BY age DESC LIMIT 2';
     const result = await executeSELECTQuery(query);
+    
     expect(result.length).toEqual(2);
     expect(result[0].name).toEqual('John');
     expect(result[1].name).toEqual('Jane');
diff --git a/tests/step-13/index.test.js b/tests/step-13/index.test.js
index 0797faaba..3cba3555a 100644
--- a/tests/step-13/index.test.js
+++ b/tests/step-13/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -269,13 +269,14 @@ test('Parse SQL Query', () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -290,13 +291,14 @@ test('Parse SQL Query with WHERE Clause', () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -315,13 +317,14 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -332,13 +335,14 @@ test('Parse SQL Query with INNER JOIN', async () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     })
 });
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -349,7 +353,8 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     })
 });
 
@@ -397,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -408,13 +413,14 @@ test('Parse LEFT Join Query Completely', () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     })
 })
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -425,13 +431,14 @@ test('Parse LEFT Join Query Completely', () => {
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     })
 })
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -442,13 +449,14 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -459,13 +467,14 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -476,13 +485,14 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -493,14 +503,15 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
         groupByFields: null,
         hasAggregateWithoutGroupBy: false,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -511,14 +522,15 @@ test('Parse COUNT Aggregate Query', () => {
         "joinTable": null,
         "joinType": null,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -529,13 +541,14 @@ test('Parse SUM Aggregate Query', () => {
         "joinTable": null,
         "joinType": null,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -546,13 +559,14 @@ test('Parse AVG Aggregate Query', () => {
         "joinTable": null,
         "joinType": null,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -563,13 +577,14 @@ test('Parse MIN Aggregate Query', () => {
         "joinTable": null,
         "joinType": null,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -580,13 +595,14 @@ test('Parse MAX Aggregate Query', () => {
         "joinTable": null,
         "joinType": null,
         "orderByFields": null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -597,13 +613,14 @@ test('Parse basic GROUP BY query', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -614,13 +631,14 @@ test('Parse GROUP BY query with WHERE clause', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -631,13 +649,14 @@ test('Parse GROUP BY query with multiple fields', () => {
         joinCondition: null,
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
-        "limit": null
+        "limit": null,
+        isDistinct: false
     });
 });
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
@@ -652,6 +671,7 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
         hasAggregateWithoutGroupBy: false,
         orderByFields: null,
         "limit": null,
+        isDistinct: false,
     });
 });
 
diff --git a/tests/step-14/index.test.js b/tests/step-14/index.test.js
index 502411fa7..ad0c833b6 100644
--- a/tests/step-14/index.test.js
+++ b/tests/step-14/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -276,7 +276,7 @@ test('Parse SQL Query', () => {
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -298,7 +298,7 @@ test('Parse SQL Query with WHERE Clause', () => {
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -324,7 +324,7 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -342,7 +342,7 @@ test('Parse SQL Query with INNER JOIN', async () => {
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -402,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -420,7 +420,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -438,7 +438,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -456,7 +456,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -474,7 +474,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -492,7 +492,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -511,7 +511,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -530,7 +530,7 @@ test('Parse COUNT Aggregate Query', () => {
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -548,7 +548,7 @@ test('Parse SUM Aggregate Query', () => {
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -566,7 +566,7 @@ test('Parse AVG Aggregate Query', () => {
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -584,7 +584,7 @@ test('Parse MIN Aggregate Query', () => {
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -602,7 +602,7 @@ test('Parse MAX Aggregate Query', () => {
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -620,7 +620,7 @@ test('Parse basic GROUP BY query', () => {
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -638,7 +638,7 @@ test('Parse GROUP BY query with WHERE clause', () => {
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -656,7 +656,7 @@ test('Parse GROUP BY query with multiple fields', () => {
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
diff --git a/tests/step-15/index.test.js b/tests/step-15/index.test.js
index a2aa4daee..b4b081c66 100644
--- a/tests/step-15/index.test.js
+++ b/tests/step-15/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -276,7 +276,7 @@ test('Parse SQL Query', () => {
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -298,7 +298,7 @@ test('Parse SQL Query with WHERE Clause', () => {
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -324,7 +324,7 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -342,7 +342,7 @@ test('Parse SQL Query with INNER JOIN', async () => {
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -402,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -420,7 +420,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -438,7 +438,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -456,7 +456,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -474,7 +474,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -492,7 +492,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -511,7 +511,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -530,7 +530,7 @@ test('Parse COUNT Aggregate Query', () => {
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -548,7 +548,7 @@ test('Parse SUM Aggregate Query', () => {
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -566,7 +566,7 @@ test('Parse AVG Aggregate Query', () => {
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -584,7 +584,7 @@ test('Parse MIN Aggregate Query', () => {
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -602,7 +602,7 @@ test('Parse MAX Aggregate Query', () => {
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -620,7 +620,7 @@ test('Parse basic GROUP BY query', () => {
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -638,7 +638,7 @@ test('Parse GROUP BY query with WHERE clause', () => {
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -656,7 +656,7 @@ test('Parse GROUP BY query with multiple fields', () => {
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
@@ -817,6 +817,7 @@ test('Execute SQL Query with LIKE Operator and DISTINCT', async () => {
 test('LIKE with ORDER BY and LIMIT', async () => {
     const query = "SELECT name FROM student WHERE name LIKE '%a%' ORDER BY name ASC LIMIT 2";
     const result = await executeSELECTQuery(query);
+    
     // Expecting the first two names alphabetically that contain 'a'
     expect(result).toEqual([{ name: 'Alice' }, { name: 'Jane' }]);
 });
\ No newline at end of file
diff --git a/tests/step-16/index.test.js b/tests/step-16/index.test.js
index a2aa4daee..677646807 100644
--- a/tests/step-16/index.test.js
+++ b/tests/step-16/index.test.js
@@ -1,6 +1,6 @@
-const readCSV = require('../../src/csvReader');
-const {parseQuery, parseJoinClause} = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const {readCSV} = require('../../src/csvReader');
+const {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
+const {executeSELECTQuery} = require('../../src/index');
 
 test('Read CSV File', async () => {
     const data = await readCSV('./student.csv');
@@ -258,7 +258,7 @@ test('Average age of students above a certain age', async () => {
 
 test('Parse SQL Query', () => {
     const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -276,7 +276,7 @@ test('Parse SQL Query', () => {
 
 test('Parse SQL Query with WHERE Clause', () => {
     const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -298,7 +298,7 @@ test('Parse SQL Query with WHERE Clause', () => {
 
 test('Parse SQL Query with Multiple WHERE Clauses', () => {
     const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['id', 'name'],
         table: 'student',
@@ -324,7 +324,7 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
 
 test('Parse SQL Query with INNER JOIN', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -342,7 +342,7 @@ test('Parse SQL Query with INNER JOIN', async () => {
 
 test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -402,7 +402,7 @@ test('Returns null for queries without JOIN', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -420,7 +420,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse LEFT Join Query Completely', () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id';
-    const result = parseQuery(query);
+    const result = parseSelectQuery(query);
     expect(result).toEqual({
         fields: ['student.name', 'enrollment.course'],
         table: 'student',
@@ -438,7 +438,7 @@ test('Parse LEFT Join Query Completely', () => {
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age > 22';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -456,7 +456,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the main tabl
 
 test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Physics'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -474,7 +474,7 @@ test('Parse SQL Query with LEFT JOIN with a WHERE clause filtering the join tabl
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main table', async () => {
     const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE student.age < 25';
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -492,7 +492,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the main tab
 
 test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join table', async () => {
     const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry'`;
-    const result = await parseQuery(query);
+    const result = await parseSelectQuery(query);
     expect(result).toEqual({
         "fields": ["student.name", "enrollment.course"],
         "joinCondition": { "left": "student.id", "right": "enrollment.student_id" },
@@ -511,7 +511,7 @@ test('Parse SQL Query with RIGHT JOIN with a WHERE clause filtering the join tab
 
 test('Parse COUNT Aggregate Query', () => {
     const query = 'SELECT COUNT(*) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['COUNT(*)'],
         table: 'student',
@@ -530,7 +530,7 @@ test('Parse COUNT Aggregate Query', () => {
 
 test('Parse SUM Aggregate Query', () => {
     const query = 'SELECT SUM(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['SUM(age)'],
         table: 'student',
@@ -548,7 +548,7 @@ test('Parse SUM Aggregate Query', () => {
 
 test('Parse AVG Aggregate Query', () => {
     const query = 'SELECT AVG(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['AVG(age)'],
         table: 'student',
@@ -566,7 +566,7 @@ test('Parse AVG Aggregate Query', () => {
 
 test('Parse MIN Aggregate Query', () => {
     const query = 'SELECT MIN(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MIN(age)'],
         table: 'student',
@@ -584,7 +584,7 @@ test('Parse MIN Aggregate Query', () => {
 
 test('Parse MAX Aggregate Query', () => {
     const query = 'SELECT MAX(age) FROM student';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['MAX(age)'],
         table: 'student',
@@ -602,7 +602,7 @@ test('Parse MAX Aggregate Query', () => {
 
 test('Parse basic GROUP BY query', () => {
     const query = 'SELECT age, COUNT(*) FROM student GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -620,7 +620,7 @@ test('Parse basic GROUP BY query', () => {
 
 test('Parse GROUP BY query with WHERE clause', () => {
     const query = 'SELECT age, COUNT(*) FROM student WHERE age > 22 GROUP BY age';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['age', 'COUNT(*)'],
         table: 'student',
@@ -638,7 +638,7 @@ test('Parse GROUP BY query with WHERE clause', () => {
 
 test('Parse GROUP BY query with multiple fields', () => {
     const query = 'SELECT student_id, course, COUNT(*) FROM enrollment GROUP BY student_id, course';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student_id', 'course', 'COUNT(*)'],
         table: 'enrollment',
@@ -656,7 +656,7 @@ test('Parse GROUP BY query with multiple fields', () => {
 
 test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
     const query = 'SELECT student.name, COUNT(*) FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE enrollment.course = "Mathematics" GROUP BY student.name';
-    const parsed = parseQuery(query);
+    const parsed = parseSelectQuery(query);
     expect(parsed).toEqual({
         fields: ['student.name', 'COUNT(*)'],
         table: 'student',
diff --git a/tests/step-20/deleteExecutor.test.js b/tests/step-20/deleteExecutor.test.js
index 636403858..11ae617b7 100644
--- a/tests/step-20/deleteExecutor.test.js
+++ b/tests/step-20/deleteExecutor.test.js
@@ -1,4 +1,4 @@
-const { executeDELETEQuery } = require('../../src/queryExecutor');
+const { executeDELETEQuery } = require('../../src/index');
 const { readCSV, writeCSV } = require('../../src/csvReader');
 const fs = require('fs');
 
diff --git a/tests/step-20/index.test.js b/tests/step-20/index.test.js
index dc1fa19ae..c99d01fbb 100644
--- a/tests/step-20/index.test.js
+++ b/tests/step-20/index.test.js
@@ -1,5 +1,5 @@
 const {readCSV} = require('../../src/csvReader');
-const {executeSELECTQuery } = require('../../src/queryExecutor');
+const {executeSELECTQuery } = require('../../src/index');
 const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
 
 test('Read CSV File', async () => {
diff --git a/tests/step-20/insertExecuter.test.js b/tests/step-20/insertExecuter.test.js
index 581d17f73..8c405f727 100644
--- a/tests/step-20/insertExecuter.test.js
+++ b/tests/step-20/insertExecuter.test.js
@@ -1,4 +1,4 @@
-const { executeINSERTQuery } = require('../../src/queryExecutor');
+const { executeINSERTQuery } = require('../../src/index');
 const { readCSV, writeCSV } = require('../../src/csvReader');
 const fs = require('fs');