A SQL database engine written in JavaScript
From afa31d4641386da3712934ba38543fcaa966bd8f Mon Sep 17 00:00:00 2001
From: Rishabh Dewangan
A SQL database engine written in JavaScript
diff --git a/enrollment.csv b/enrollment.csv
new file mode 100644
index 000000000..e80af8d93
--- /dev/null
+++ b/enrollment.csv
@@ -0,0 +1,6 @@
+student_id,course
+1,Mathematics
+1,Physics
+2,Chemistry
+3,Mathematics
+5,Biology
\ 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 0b7b54548..526e1d935 100644
--- a/src/csvReader.js
+++ b/src/csvReader.js
@@ -1,7 +1,6 @@
-// src/csvReader.js
-
const fs = require('fs');
const csv = require('csv-parser');
+const { parse } = require('json2csv');
function readCSV(filePath) {
const results = [];
@@ -19,4 +18,9 @@ function readCSV(filePath) {
});
}
-module.exports = readCSV;
\ No newline at end of file
+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
index e69de29bb..50e9f5758 100644
--- a/src/index.js
+++ 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
index 8cba13b8a..f0470679c 100644
--- a/src/queryParser.js
+++ b/src/queryParser.js
@@ -1,16 +1,215 @@
-function parseQuery(query) {
- const selectRegex = /SELECT (.+) FROM (.+)/i;
- const match = query.match(selectRegex);
- if (match) {
- const [, fields, table] = match;
+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()
+ table: table.trim(),
+ whereClauses,
+ joinType,
+ joinTable,
+ joinCondition,
+ groupByFields,
+ orderByFields,
+ limit,
+ isDistinct,
+ hasAggregateWithoutGroupBy
};
- } else {
- throw new Error('Invalid query format');
+ }catch (error) {
+ throw new Error(`Query parsing error: ${error.message}`);
}
}
-module.exports = parseQuery;
\ No newline at end of file
+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..e9c960121
--- /dev/null
+++ b/student.csv
@@ -0,0 +1,5 @@
+id,name,age
+1,John,30
+2,Jane,25
+3,Bob,22
+4,Alice,24
\ No newline at end of file
diff --git a/tests/index.test.js b/tests/index.test.js
index d42c7f23e..a9c2bf2f2 100644
--- a/tests/index.test.js
+++ b/tests/index.test.js
@@ -28,4 +28,16 @@ test('Parse SQL Query', () => {
test('Invalid SQL Query', () => {
const query = 'Invalid SQL Query';
expect(() => parseQuery(query)).toThrow('Invalid query format');
+});
+
+const executeSELECTQuery = require('../src/index');
+
+test('Execute SQL Query', async () => {
+ const query = 'SELECT id, name FROM sample';
+ const result = await executeSELECTQuery(query);
+ expect(result.length).toBeGreaterThan(0);
+ expect(result[0]).toHaveProperty('id');
+ expect(result[0]).toHaveProperty('name');
+ expect(result[0]).not.toHaveProperty('age');
+ expect(result[0]).toEqual({ id: '1', name: 'John' });
});
\ No newline at end of file
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');
From 973facdb3bdaeb0b2dc66b7b3830830188989fc6 Mon Sep 17 00:00:00 2001
From: Rishabh Dewangan
A SQL database engine written in JavaScript
diff --git a/package-lock.json b/package-lock.json
index a6ba782df..3afaec37f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,6 +9,7 @@
"version": "0.1.6",
"license": "ISC",
"dependencies": {
+ "csv-parser": "^3.0.0",
"json2csv": "^6.0.0-alpha.2",
"xterm": "^5.3.0"
},
@@ -16,7 +17,6 @@
"stylusdb-cli": "node ./src/cli.js"
},
"devDependencies": {
- "csv-parser": "^3.0.0",
"jest": "^29.7.0"
}
},
@@ -1573,7 +1573,6 @@
"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"
},
@@ -2944,7 +2943,6 @@
"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 d2b9c2349..f52103d5c 100644
--- a/package.json
+++ b/package.json
@@ -4,8 +4,7 @@
"description": "A minimal SQL based DB based on CSV files. For educational purposes only.",
"main": "./src/index.js",
"directories": {
- "doc": "docs",
- "test": "tests"
+ "doc": "docs"
},
"scripts": {
"test": "jest",
@@ -39,11 +38,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/sample.csv b/sample.csv
deleted file mode 100644
index 9e7a9fa25..000000000
--- a/sample.csv
+++ /dev/null
@@ -1,4 +0,0 @@
-id,name,age
-1,John,30
-2,Jane,25
-3,Bob,22
\ No newline at end of file
diff --git a/src/cli.js b/src/cli.js
index f19119849..6d281e6ea 100644
--- a/src/cli.js
+++ b/src/cli.js
@@ -1,30 +1,89 @@
+#!/usr/bin/env node
+
const readline = require('readline');
-const {executeSELECTQuery,executeDELETEQuery,executeINSERTQuery} = require('./index');
+
+const { executeSELECTQuery, executeINSERTQuery, executeDELETEQuery } = 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) {
+
+ if (line.toLowerCase().startsWith('select')) {
+
+ const result = await executeSELECTQuery(line);
+
+ console.log('Result:', result);
+
+ } else if (line.toLowerCase().startsWith('insert into')) {
+
+ const result = await executeINSERTQuery(line);
+
+ console.log(result.message);
+
+ } else if (line.toLowerCase().startsWith('delete from')) {
+
+ const result = await executeDELETEQuery(line);
+
+ console.log(result.message);
+
+ } else {
+
+ console.log('Unsupported command');
+
+ }
+
+ } 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 526e1d935..f07cf3db4 100644
--- a/src/csvReader.js
+++ b/src/csvReader.js
@@ -4,11 +4,12 @@ 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('data', (data) => {
+ results.push(data)
+ })
.on('end', () => {
resolve(results);
})
@@ -23,4 +24,4 @@ async function writeCSV(filename, data) {
fs.writeFileSync(filename, csv);
}
-module.exports = {readCSV,writeCSV};
\ No newline at end of file
+module.exports = { readCSV, writeCSV };
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
index 50e9f5758..37946433b 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,359 +1,14 @@
-// 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
+const { readCSV, writeCSV } = require('./csvReader');
+const { parseSelectQuery, parseInsertQuery, parseDeleteQuery } = require('./queryParser');
+const { executeSELECTQuery, executeINSERTQuery, executeDELETEQuery } = require('./queryExecuter');
+
+module.exports = {
+ readCSV,
+ writeCSV,
+ executeSELECTQuery,
+ executeINSERTQuery,
+ executeDELETEQuery,
+ parseSelectQuery,
+ parseInsertQuery,
+ parseDeleteQuery
+}
\ No newline at end of file
diff --git a/src/queryExecutor.js b/src/queryExecutor.js
new file mode 100644
index 000000000..85681f54b
--- /dev/null
+++ b/src/queryExecutor.js
@@ -0,0 +1,370 @@
+const { parseSelectQuery, parseInsertQuery, parseDeleteQuery } = require('./queryParser');
+const { readCSV, writeCSV } = require('./csvReader');
+
+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));
+ });
+}
+
+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;
+}
+
+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);
+
+ 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 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);
+ }
+
+ // 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;
+}
+
+function applyGroupBy(data, groupByFields, aggregateFunctions) {
+ const groupResults = {};
+
+ 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]);
+ }
+
+ // 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;
+ });
+}
+
+async function executeSELECTQuery(query) {
+ try {
+
+ const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, hasAggregateWithoutGroupBy, orderByFields, limit, isDistinct } = 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;
+ 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 = {};
+
+ 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 [result];
+ // Add more cases here if needed for other aggregates
+ } else if (groupByFields) {
+ groupResults = applyGroupBy(filteredData, groupByFields, fields);
+
+ // 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;
+ });
+ }
+ if (limit !== null) {
+ groupResults = groupResults.slice(0, limit);
+ }
+ return groupResults;
+ } else {
+
+ // 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;
+ });
+ }
+
+ // Select the specified fields
+ let finalResults = orderedResults.map(row => {
+ const selectedRow = {};
+ fields.forEach(field => {
+ // Assuming 'field' is just the column name without table prefix
+ selectedRow[field] = row[field];
+ });
+ return selectedRow;
+ });
+
+ // Remove duplicates if specified
+ let distinctResults = finalResults;
+ if (isDistinct) {
+ distinctResults = [...new Map(finalResults.map(item => [fields.map(field => item[field]).join('|'), item])).values()];
+ }
+
+ let limitResults = distinctResults;
+ if (limit !== null) {
+ limitResults = distinctResults.slice(0, limit);
+ }
+
+ return limitResults;
+
+
+ }
+ } catch (error) {
+ throw new Error(`Error executing query: ${error.message}`);
+ }
+}
+
+async function executeINSERTQuery(query) {
+ console.log(parseInsertQuery(query));
+ const { table, columns, values } = parseInsertQuery(query);
+ const data = await readCSV(`${table}.csv`);
+
+ // Create a new row object
+ const newRow = {};
+ columns.forEach((column, index) => {
+ // Remove single quotes from the values
+ let value = values[index];
+ if (value.startsWith("'") && value.endsWith("'")) {
+ value = value.substring(1, value.length - 1);
+ }
+ newRow[column] = value;
+ });
+
+ // Add the new row to the data
+ data.push(newRow);
+
+ // Save the updated data back to the CSV file
+ await writeCSV(`${table}.csv`, data); // Implement writeCSV function
+
+ return { message: "Row inserted successfully." };
+}
+
+async function executeDELETEQuery(query) {
+ const { table, whereClauses } = parseDeleteQuery(query);
+ let data = await readCSV(`${table}.csv`);
+
+ if (whereClauses.length > 0) {
+ // Filter out the rows that meet the where clause conditions
+ data = data.filter(row => !whereClauses.every(clause => evaluateCondition(row, clause)));
+ } else {
+ // If no where clause, clear the entire table
+ data = [];
+ }
+
+ // Save the updated data back to the CSV file
+ 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
index f0470679c..67b94f5d0 100644
--- a/src/queryParser.js
+++ b/src/queryParser.js
@@ -1,98 +1,78 @@
-
function parseSelectQuery(query) {
try {
+
// Trim the query to remove any leading/trailing whitespaces
query = query.trim();
+
+ // Initialize distinct flag
let isDistinct = false;
+
+ // Check for DISTINCT keyword and update the query
if (query.toUpperCase().includes('SELECT DISTINCT')) {
isDistinct = true;
query = query.replace('SELECT DISTINCT', 'SELECT');
}
+ // Updated regex to capture LIMIT clause and remove it for further processing
const limitRegex = /\sLIMIT\s(\d+)/i;
-
-
const limitMatch = query.match(limitRegex);
+
let limit = null;
if (limitMatch) {
- limit = parseInt(limitMatch[1]);
+ limit = parseInt(limitMatch[1], 10);
+ query = query.replace(limitRegex, ''); // Remove LIMIT clause
}
- query = query.replace(limitRegex, '');
-
- // Updated regex to capture ORDER BY clause
+ // Process ORDER BY clause and remove it for further processing
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' };
});
+ query = query.replace(orderByRegex, '');
}
- //
- // 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
+ // Process GROUP BY clause and remove it for further processing
const groupByRegex = /\sGROUP BY\s(.+)/i;
const groupByMatch = query.match(groupByRegex);
-
let groupByFields = null;
if (groupByMatch) {
groupByFields = groupByMatch[1].split(',').map(field => field.trim());
+ query = query.replace(groupByRegex, '');
}
- // Remove GROUP BY clause from the query for further processing
- query = query.replace(groupByRegex, '');
-
-
-
- // Split the query at the WHERE clause if it exists
+ // Process WHERE clause
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
+ // Process JOIN clause
const joinSplit = queryWithoutWhere.split(/\s(INNER|LEFT|RIGHT) JOIN\s/i);
const selectPart = joinSplit[0].trim(); // Everything before JOIN clause
- // Parse the SELECT part
+ // Extract JOIN information
+ const { joinType, joinTable, joinCondition } = parseJoinClause(queryWithoutWhere);
+
+ // Parse SELECT part
const selectRegex = /^SELECT\s(.+?)\sFROM\s(.+)/i;
const selectMatch = selectPart.match(selectRegex);
-
- if (!selectMatch) {
- throw new Error("Invalid SELECT format");
- }
-
-
-
+ 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
+ // Parse 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;
+ // Check for aggregate functions without GROUP BY
+ const hasAggregateWithoutGroupBy = checkAggregateWithoutGroupBy(query, groupByFields);
-
-
return {
fields: fields.split(',').map(field => field.trim()),
table: table.trim(),
@@ -102,15 +82,20 @@ function parseSelectQuery(query) {
joinCondition,
groupByFields,
orderByFields,
+ hasAggregateWithoutGroupBy,
limit,
- isDistinct,
- hasAggregateWithoutGroupBy
+ isDistinct
};
- }catch (error) {
+ } catch (error) {
throw new Error(`Query parsing error: ${error.message}`);
}
}
+function checkAggregateWithoutGroupBy(query, groupByFields) {
+ const aggregateFunctionRegex = /(\bCOUNT\b|\bAVG\b|\bSUM\b|\bMIN\b|\bMAX\b)\s*\(\s*(\*|\w+)\s*\)/i;
+ return aggregateFunctionRegex.test(query) && !groupByFields;
+}
+
function parseWhereClause(whereString) {
const conditionRegex = /(.*?)(=|!=|>=|<=|>|<)(.*)/;
return whereString.split(/ AND | OR /i).map(conditionString => {
@@ -128,8 +113,6 @@ function parseWhereClause(whereString) {
});
}
-
-
function parseJoinClause(query) {
const joinRegex = /\s(INNER|LEFT|RIGHT) JOIN\s(.+?)\sON\s([\w.]+)\s*=\s*([\w.]+)/i;
const joinMatch = query.match(joinRegex);
@@ -145,8 +128,6 @@ function parseJoinClause(query) {
};
}
-
-
return {
joinType: null,
joinTable: null,
@@ -154,60 +135,41 @@ function parseJoinClause(query) {
};
}
-
function parseInsertQuery(query) {
- query = query.replace(/"?\w+"?\."(\w+)"?/g, '$1');
-
- const insertRegex = /INSERT INTO "?(\w+)"?\s\(([^)]+)\)\sVALUES\s\(([^)]+)\)/i;
- const insertMatch = query.match(insertRegex);
+ const insertRegex = /INSERT INTO (\w+)\s\((.+)\)\sVALUES\s\((.+)\)/i;
+ const match = query.match(insertRegex);
- if (!insertMatch) {
+ if (!match) {
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');
- })
- : [];
+ const [, table, columns, values] = match;
return {
type: 'INSERT',
- table: table.trim().replace(/^"?(.+?)"?$/g, '$1'),
- columns: parsedColumns,
- values: parsedValues,
- returningColumns
+ table: table.trim(),
+ columns: columns.split(',').map(column => column.trim()),
+ values: values.split(',').map(value => value.trim())
};
}
function parseDeleteQuery(query) {
const deleteRegex = /DELETE FROM (\w+)( WHERE (.*))?/i;
- const deleteMatch = query.match(deleteRegex);
+ const match = query.match(deleteRegex);
- if (!deleteMatch) {
+ if (!match) {
throw new Error("Invalid DELETE syntax.");
}
- const [, table, ,whereString] = deleteMatch;
- let whereClause = [];
+ const [, table, , whereString] = match;
+ let whereClauses = [];
if (whereString) {
- whereClause = parseWhereClause(whereString);
+ whereClauses = parseWhereClause(whereString);
}
return {
type: 'DELETE',
table: table.trim(),
- whereClause
+ whereClauses
};
}
diff --git a/tests/index.test.js b/tests/index.test.js
deleted file mode 100644
index a9c2bf2f2..000000000
--- a/tests/index.test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-// tests/index.test.js
-
-test('Basic Jest Test', () => {
- expect(1).toBe(1);
- });
-
- 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);
- expect(data[0].name).toBe('John');
- expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
- });
-
-const parseQuery = require('../src/queryParser');
-
-test('Parse SQL Query', () => {
- const query = 'SELECT id, name FROM sample';
- const parsed = parseQuery(query);
- expect(parsed).toEqual({
- fields: ['id', 'name'],
- table: 'sample'
- });
-});
-
-test('Invalid SQL Query', () => {
- const query = 'Invalid SQL Query';
- expect(() => parseQuery(query)).toThrow('Invalid query format');
-});
-
-const executeSELECTQuery = require('../src/index');
-
-test('Execute SQL Query', async () => {
- const query = 'SELECT id, name FROM sample';
- const result = await executeSELECTQuery(query);
- expect(result.length).toBeGreaterThan(0);
- expect(result[0]).toHaveProperty('id');
- expect(result[0]).toHaveProperty('name');
- expect(result[0]).not.toHaveProperty('age');
- expect(result[0]).toEqual({ id: '1', name: 'John' });
-});
\ No newline at end of file
diff --git a/tests/step-02/index.test.js b/tests/step-02/index.test.js
index 5eedb3f26..59a3322e8 100644
--- a/tests/step-02/index.test.js
+++ b/tests/step-02/index.test.js
@@ -1,8 +1,8 @@
const {readCSV} = require('../../src/csvReader');
test('Read CSV File', async () => {
- const data = await readCSV('./student.csv');
- expect(data.length).toBeGreaterThan(0);
+ 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
diff --git a/tests/step-03/index.test.js b/tests/step-03/index.test.js
index a46ab14a6..fcb733a0b 100644
--- a/tests/step-03/index.test.js
+++ b/tests/step-03/index.test.js
@@ -1,5 +1,6 @@
+
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -21,8 +22,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "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 0e606bfd5..51e8cfd7d 100644
--- a/tests/step-04/index.test.js
+++ b/tests/step-04/index.test.js
@@ -1,6 +1,6 @@
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -22,8 +22,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
diff --git a/tests/step-05/index.test.js b/tests/step-05/index.test.js
index 91efe3130..8522a0db7 100644
--- a/tests/step-05/index.test.js
+++ b/tests/step-05/index.test.js
@@ -1,6 +1,6 @@
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -22,9 +22,9 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
- isDistinct:false
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -37,7 +37,6 @@ test('Execute SQL Query', async () => {
expect(result[0]).not.toHaveProperty('age');
expect(result[0]).toEqual({ id: '1', name: 'John' });
});
-
test('Parse SQL Query with WHERE Clause', () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const parsed = parseSelectQuery(query);
@@ -54,26 +53,16 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
- isDistinct:false
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
-
-
test('Execute SQL Query with WHERE Clause', async () => {
- const query = 'SELECT id, name FROM student where age = 25';
+ const query = 'SELECT id, name FROM student WHERE age = 25';
const result = await executeSELECTQuery(query);
- 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');
+ expect(result.length).toBe(1);
+ expect(result[0]).toHaveProperty('id');
+ expect(result[0]).toHaveProperty('name');
+ expect(result[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 75cd701e1..fe79fabba 100644
--- a/tests/step-06/index.test.js
+++ b/tests/step-06/index.test.js
@@ -1,6 +1,6 @@
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -15,15 +15,15 @@ test('Parse SQL Query', () => {
const parsed = parseSelectQuery(query);
expect(parsed).toEqual({
fields: ['id', 'name'],
- table: 'student',
+ table: 'student',
whereClauses: [],
joinCondition: null,
joinTable: null,
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -37,7 +37,6 @@ test('Execute SQL Query', async () => {
expect(result[0]).not.toHaveProperty('age');
expect(result[0]).toEqual({ id: '1', name: 'John' });
});
-
test('Parse SQL Query with WHERE Clause', () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const parsed = parseSelectQuery(query);
@@ -54,12 +53,11 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
-
test('Execute SQL Query with WHERE Clause', async () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const result = await executeSELECTQuery(query);
@@ -89,13 +87,13 @@ 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('Execute SQL Query with Multiple WHERE Clause', async () => {
+test('Execute SQL Query with Complex WHERE Clause', async () => {
const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
const result = await executeSELECTQuery(query);
expect(result.length).toBe(1);
diff --git a/tests/step-07/index.test.js b/tests/step-07/index.test.js
index 3b7b52c34..5faa49133 100644
--- a/tests/step-07/index.test.js
+++ b/tests/step-07/index.test.js
@@ -1,6 +1,6 @@
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -22,8 +22,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -37,7 +37,6 @@ test('Execute SQL Query', async () => {
expect(result[0]).not.toHaveProperty('age');
expect(result[0]).toEqual({ id: '1', name: 'John' });
});
-
test('Parse SQL Query with WHERE Clause', () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const parsed = parseSelectQuery(query);
@@ -54,12 +53,11 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
-
test('Execute SQL Query with WHERE Clause', async () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const result = await executeSELECTQuery(query);
@@ -89,19 +87,18 @@ 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('Execute SQL Query with Multiple WHERE Clause', async () => {
+test('Execute SQL Query with Complex WHERE Clause', async () => {
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 student WHERE age > 22';
const result = await executeSELECTQuery(queryWithGT);
diff --git a/tests/step-08/index.test.js b/tests/step-08/index.test.js
index b239ef966..93e1799b0 100644
--- a/tests/step-08/index.test.js
+++ b/tests/step-08/index.test.js
@@ -1,6 +1,6 @@
const {readCSV} = require('../../src/csvReader');
-const {parseSelectQuery} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -22,8 +22,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -37,13 +37,12 @@ test('Execute SQL Query', async () => {
expect(result[0]).not.toHaveProperty('age');
expect(result[0]).toEqual({ id: '1', name: 'John' });
});
-
test('Parse SQL Query with WHERE Clause', () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const parsed = parseSelectQuery(query);
expect(parsed).toEqual({
fields: ['id', 'name'],
- table: 'student',
+ table: 'student',
whereClauses: [{
"field": "age",
"operator": "=",
@@ -54,12 +53,11 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
-
test('Execute SQL Query with WHERE Clause', async () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const result = await executeSELECTQuery(query);
@@ -89,8 +87,8 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -101,7 +99,6 @@ test('Execute SQL Query with Complex WHERE Clause', async () => {
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 student WHERE age > 22';
const result = await executeSELECTQuery(queryWithGT);
@@ -128,8 +125,8 @@ 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
})
});
@@ -142,12 +139,12 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
table: 'student',
whereClauses: [{ field: 'student.age', operator: '>', value: '20' }],
joinTable: 'enrollment',
- joinType:"INNER",
+ joinType: "INNER",
joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
})
});
diff --git a/tests/step-09/index.test.js b/tests/step-09/index.test.js
index bf06b61df..02e6cdb86 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 {parseSelectQuery,parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -13,7 +13,6 @@ test('Read CSV File', async () => {
test('Parse SQL Query', () => {
const query = 'SELECT id, name FROM student';
const parsed = parseSelectQuery(query);
- console.log(parsed)
expect(parsed).toEqual({
fields: ['id', 'name'],
table: 'student',
@@ -23,8 +22,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -38,7 +37,6 @@ test('Execute SQL Query', async () => {
expect(result[0]).not.toHaveProperty('age');
expect(result[0]).toEqual({ id: '1', name: 'John' });
});
-
test('Parse SQL Query with WHERE Clause', () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const parsed = parseSelectQuery(query);
@@ -55,12 +53,11 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
-
test('Execute SQL Query with WHERE Clause', async () => {
const query = 'SELECT id, name FROM student WHERE age = 25';
const result = await executeSELECTQuery(query);
@@ -90,8 +87,8 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -102,7 +99,6 @@ test('Execute SQL Query with Complex WHERE Clause', async () => {
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 student WHERE age > 22';
const result = await executeSELECTQuery(queryWithGT);
@@ -125,12 +121,12 @@ test('Parse SQL Query with INNER JOIN', async () => {
table: 'student',
whereClauses: [],
joinTable: 'enrollment',
+ joinType: "INNER",
joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
- joinType: 'INNER',
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
})
});
@@ -143,12 +139,12 @@ test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
table: 'student',
whereClauses: [{ field: 'student.age', operator: '>', value: '20' }],
joinTable: 'enrollment',
+ joinType: "INNER",
joinCondition: { left: 'student.id', right: 'enrollment.student_id' },
- joinType: 'INNER',
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
})
});
diff --git a/tests/step-10/index.test.js b/tests/step-10/index.test.js
index 33de1ba8f..2b9ef2e73 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -226,7 +226,6 @@ 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 },
@@ -237,7 +236,6 @@ 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 }
]);
@@ -269,10 +267,10 @@ test('Parse SQL Query', () => {
joinTable: null,
joinType: null,
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
- isDistinct: false,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -291,10 +289,10 @@ test('Parse SQL Query with WHERE Clause', () => {
joinTable: null,
joinType: null,
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
- isDistinct: false,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -317,10 +315,10 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
joinTable: null,
joinType: null,
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
- isDistinct: false,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -335,10 +333,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
})
});
@@ -353,10 +351,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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
})
});
@@ -413,10 +411,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
})
})
@@ -431,10 +429,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
})
})
@@ -449,10 +447,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -467,10 +465,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -485,10 +483,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -503,10 +501,10 @@ 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,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -519,13 +517,13 @@ test('Parse COUNT Aggregate Query', () => {
table: 'student',
whereClauses: [],
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: true,
- limit:null,
- isDistinct: false,
"joinCondition": null,
"joinTable": null,
"joinType": null,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -538,13 +536,13 @@ test('Parse SUM Aggregate Query', () => {
table: 'student',
whereClauses: [],
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: true,
- limit:null,
- isDistinct: false,
"joinCondition": null,
"joinTable": null,
"joinType": null,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -556,13 +554,13 @@ test('Parse AVG Aggregate Query', () => {
table: 'student',
whereClauses: [],
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: true,
- limit:null,
- isDistinct: false,
"joinCondition": null,
"joinTable": null,
"joinType": null,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -574,13 +572,13 @@ test('Parse MIN Aggregate Query', () => {
table: 'student',
whereClauses: [],
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: true,
- limit:null,
- isDistinct: false,
"joinCondition": null,
"joinTable": null,
"joinType": null,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -592,13 +590,13 @@ test('Parse MAX Aggregate Query', () => {
table: 'student',
whereClauses: [],
groupByFields: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: true,
- limit:null,
- isDistinct: false,
"joinCondition": null,
"joinTable": null,
"joinType": null,
+ "orderByFields": null,
+ "limit": null,
+ isDistinct: false
});
});
@@ -613,9 +611,9 @@ test('Parse basic GROUP BY query', () => {
joinType: null,
joinTable: null,
joinCondition: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
+ orderByFields: null,
+ "limit": null,
isDistinct: false
});
});
@@ -631,9 +629,9 @@ test('Parse GROUP BY query with WHERE clause', () => {
joinType: null,
joinTable: null,
joinCondition: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
+ orderByFields: null,
+ "limit": null,
isDistinct: false
});
});
@@ -649,9 +647,9 @@ test('Parse GROUP BY query with multiple fields', () => {
joinType: null,
joinTable: null,
joinCondition: null,
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
+ orderByFields: null,
+ "limit": null,
isDistinct: false
});
});
@@ -670,9 +668,9 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
left: 'student.id',
right: 'enrollment.student_id'
},
- orderByFields: null,
hasAggregateWithoutGroupBy: false,
- limit:null,
- isDistinct: false
+ orderByFields: null,
+ "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 f7c91f3f5..68f672e72 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -268,8 +268,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -290,8 +290,8 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -316,8 +316,8 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit:null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -334,8 +334,8 @@ 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
})
});
@@ -352,8 +352,8 @@ 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
})
});
@@ -413,7 +413,7 @@ test('Parse LEFT Join Query Completely', () => {
groupByFields: null,
hasAggregateWithoutGroupBy: false,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
})
})
@@ -431,7 +431,7 @@ test('Parse LEFT Join Query Completely', () => {
groupByFields: null,
hasAggregateWithoutGroupBy: false,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
})
})
@@ -449,7 +449,7 @@ 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
});
});
@@ -467,7 +467,7 @@ 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
});
});
@@ -485,7 +485,7 @@ 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
});
});
@@ -503,7 +503,7 @@ 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
});
});
@@ -522,7 +522,7 @@ test('Parse COUNT Aggregate Query', () => {
"joinTable": null,
"joinType": null,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -541,7 +541,7 @@ test('Parse SUM Aggregate Query', () => {
"joinTable": null,
"joinType": null,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -559,7 +559,7 @@ test('Parse AVG Aggregate Query', () => {
"joinTable": null,
"joinType": null,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -577,7 +577,7 @@ test('Parse MIN Aggregate Query', () => {
"joinTable": null,
"joinType": null,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -595,7 +595,7 @@ test('Parse MAX Aggregate Query', () => {
"joinTable": null,
"joinType": null,
"orderByFields": null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -613,7 +613,7 @@ test('Parse basic GROUP BY query', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -631,7 +631,7 @@ test('Parse GROUP BY query with WHERE clause', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -649,7 +649,7 @@ test('Parse GROUP BY query with multiple fields', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit:null,
+ "limit": null,
isDistinct: false
});
});
@@ -670,8 +670,8 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
},
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit:null,
- isDistinct: false
+ "limit": null,
+ isDistinct: false,
});
});
diff --git a/tests/step-12/index.test.js b/tests/step-12/index.test.js
index 477c55eed..d6a7a6913 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -268,8 +268,8 @@ test('Parse SQL Query', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -290,8 +290,8 @@ test('Parse SQL Query with WHERE Clause', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -316,8 +316,8 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => {
joinType: null,
groupByFields: null,
hasAggregateWithoutGroupBy: false,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -334,8 +334,8 @@ 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
})
});
@@ -352,8 +352,8 @@ 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
})
});
@@ -412,8 +412,8 @@ 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
})
})
@@ -430,8 +430,8 @@ 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
})
})
@@ -448,8 +448,8 @@ 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
});
});
@@ -466,8 +466,8 @@ 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
});
});
@@ -484,8 +484,8 @@ 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
});
});
@@ -502,8 +502,8 @@ 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
});
});
@@ -521,8 +521,8 @@ test('Parse COUNT Aggregate Query', () => {
"joinCondition": null,
"joinTable": null,
"joinType": null,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -540,8 +540,8 @@ test('Parse SUM Aggregate Query', () => {
"joinCondition": null,
"joinTable": null,
"joinType": null,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -558,8 +558,8 @@ test('Parse AVG Aggregate Query', () => {
"joinCondition": null,
"joinTable": null,
"joinType": null,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -576,8 +576,8 @@ test('Parse MIN Aggregate Query', () => {
"joinCondition": null,
"joinTable": null,
"joinType": null,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -594,8 +594,8 @@ test('Parse MAX Aggregate Query', () => {
"joinCondition": null,
"joinTable": null,
"joinType": null,
- orderByFields: null,
- limit: null,
+ "orderByFields": null,
+ "limit": null,
isDistinct: false
});
});
@@ -613,7 +613,7 @@ test('Parse basic GROUP BY query', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit: null,
+ "limit": null,
isDistinct: false
});
});
@@ -631,7 +631,7 @@ test('Parse GROUP BY query with WHERE clause', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit: null,
+ "limit": null,
isDistinct: false
});
});
@@ -649,7 +649,7 @@ test('Parse GROUP BY query with multiple fields', () => {
joinCondition: null,
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit: null,
+ "limit": null,
isDistinct: false
});
});
@@ -670,9 +670,8 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => {
},
hasAggregateWithoutGroupBy: false,
orderByFields: null,
- limit: null,
+ "limit": null,
isDistinct: false,
- isDistinct: false
});
});
@@ -736,7 +735,6 @@ 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 3cba3555a..5fe667f4c 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
diff --git a/tests/step-14/index.test.js b/tests/step-14/index.test.js
index ad0c833b6..0bc0e0607 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
diff --git a/tests/step-15/index.test.js b/tests/step-15/index.test.js
index b4b081c66..dc1fa19ae 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
@@ -817,7 +817,6 @@ 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 677646807..dc1fa19ae 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 {parseSelectQuery, parseJoinClause} = require('../../src/queryParser');
-const {executeSELECTQuery} = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
+const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
const data = await readCSV('./student.csv');
diff --git a/tests/step-17/index.test.js b/tests/step-17/index.test.js
index c99d01fbb..dc1fa19ae 100644
--- a/tests/step-17/index.test.js
+++ b/tests/step-17/index.test.js
@@ -1,5 +1,5 @@
const {readCSV} = require('../../src/csvReader');
-const {executeSELECTQuery } = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
diff --git a/tests/step-17/insertExecuter.test.js b/tests/step-17/insertExecuter.test.js
index 8c405f727..581d17f73 100644
--- a/tests/step-17/insertExecuter.test.js
+++ b/tests/step-17/insertExecuter.test.js
@@ -1,4 +1,4 @@
-const { executeINSERTQuery } = require('../../src/index');
+const { executeINSERTQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
diff --git a/tests/step-18/deleteExecutor.test.js b/tests/step-18/deleteExecutor.test.js
index 11ae617b7..636403858 100644
--- a/tests/step-18/deleteExecutor.test.js
+++ b/tests/step-18/deleteExecutor.test.js
@@ -1,4 +1,4 @@
-const { executeDELETEQuery } = require('../../src/index');
+const { executeDELETEQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
diff --git a/tests/step-18/index.test.js b/tests/step-18/index.test.js
index c99d01fbb..dc1fa19ae 100644
--- a/tests/step-18/index.test.js
+++ b/tests/step-18/index.test.js
@@ -1,5 +1,5 @@
const {readCSV} = require('../../src/csvReader');
-const {executeSELECTQuery } = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
diff --git a/tests/step-18/insertExecuter.test.js b/tests/step-18/insertExecuter.test.js
index 8c405f727..581d17f73 100644
--- a/tests/step-18/insertExecuter.test.js
+++ b/tests/step-18/insertExecuter.test.js
@@ -1,4 +1,4 @@
-const { executeINSERTQuery } = require('../../src/index');
+const { executeINSERTQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
diff --git a/tests/step-19/.cph/.insertExecuter.test.js_344b632c9c4863f3843be516d9be4761.prob b/tests/step-19/.cph/.insertExecuter.test.js_344b632c9c4863f3843be516d9be4761.prob
new file mode 100644
index 000000000..a677ab136
--- /dev/null
+++ b/tests/step-19/.cph/.insertExecuter.test.js_344b632c9c4863f3843be516d9be4761.prob
@@ -0,0 +1 @@
+{"name":"Local: insertExecuter","url":"/home/pratyush/github-classroom/status-20X/stylusdb-sql-assignment-bruno-noir/tests/step-19/insertExecuter.test.js","tests":[{"id":1714807548051,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"/home/pratyush/github-classroom/status-20X/stylusdb-sql-assignment-bruno-noir/tests/step-19/insertExecuter.test.js","group":"local","local":true}
\ No newline at end of file
diff --git a/tests/step-19/deleteExecutor.test.js b/tests/step-19/deleteExecutor.test.js
index 11ae617b7..636403858 100644
--- a/tests/step-19/deleteExecutor.test.js
+++ b/tests/step-19/deleteExecutor.test.js
@@ -1,4 +1,4 @@
-const { executeDELETEQuery } = require('../../src/index');
+const { executeDELETEQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
diff --git a/tests/step-19/index.test.js b/tests/step-19/index.test.js
index c99d01fbb..dc1fa19ae 100644
--- a/tests/step-19/index.test.js
+++ b/tests/step-19/index.test.js
@@ -1,5 +1,5 @@
const {readCSV} = require('../../src/csvReader');
-const {executeSELECTQuery } = require('../../src/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
const { parseJoinClause, parseSelectQuery } = require('../../src/queryParser');
test('Read CSV File', async () => {
diff --git a/tests/step-19/insertExecuter.test.js b/tests/step-19/insertExecuter.test.js
index 8c405f727..95453731b 100644
--- a/tests/step-19/insertExecuter.test.js
+++ b/tests/step-19/insertExecuter.test.js
@@ -1,33 +1,72 @@
-const { executeINSERTQuery } = require('../../src/index');
+const { executeINSERTQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
-// Helper function to create grades.csv with initial data
+
async function createGradesCSV() {
- const initialData = [
- { student_id: '1', course: 'Mathematics', grade: 'A' },
- { student_id: '2', course: 'Chemistry', grade: 'B' },
- { student_id: '3', course: 'Mathematics', grade: 'C' }
- ];
- await writeCSV('grades.csv', initialData);
+
+ const initialData = [
+
+ { student_id: "1", course: "Mathematics", grade: "A" },
+
+ { student_id: "2", course: "Chemistry", grade: "B" },
+
+ { student_id: "3", course: "Mathematics", grade: "C" },
+
+ ];
+
+ await writeCSV("grades.csv", initialData);
+
}
+
+
+
// Test to INSERT a new grade and verify
-test('Execute INSERT INTO Query for grades.csv', async () => {
- // Create grades.csv with initial data
- await createGradesCSV();
-
- // Execute INSERT statement
- const insertQuery = "INSERT INTO grades (student_id, course, grade) VALUES ('4', 'Physics', 'A')";
- await executeINSERTQuery(insertQuery);
-
- // Verify the new entry
- const updatedData = await readCSV('grades.csv');
- const newEntry = updatedData.find(row => row.student_id === '4' && row.course === 'Physics');
- console.log(updatedData)
- expect(newEntry).toBeDefined();
- expect(newEntry.grade).toEqual('A');
-
- // Cleanup: Delete grades.csv
- fs.unlinkSync('grades.csv');
+
+test("Execute INSERT INTO Query for grades.csv", async () => {
+
+ // Create grades.csv with initial data
+
+ await createGradesCSV();
+
+
+
+
+ // Execute INSERT statement
+
+ const insertQuery =
+
+ "INSERT INTO grades (student_id, course, grade) VALUES ('4', 'Physics', 'A')";
+
+ await executeINSERTQuery(insertQuery);
+
+
+
+
+ // Verify the new entry
+
+ const updatedData = await readCSV("grades.csv");
+
+ const newEntry = updatedData.find(
+
+ (row) => row.student_id === "4" && row.course === "Physics"
+
+ );
+
+
+
+
+
+ expect(newEntry).toBeDefined();
+
+ expect(newEntry.grade).toEqual("A");
+
+
+
+
+ // Cleanup: Delete grades.csv
+
+ fs.unlinkSync("grades.csv");
+
});
\ No newline at end of file
diff --git a/tests/step-20/deleteExecutor.test.js b/tests/step-20/deleteExecutor.test.js
index 11ae617b7..636403858 100644
--- a/tests/step-20/deleteExecutor.test.js
+++ b/tests/step-20/deleteExecutor.test.js
@@ -1,4 +1,4 @@
-const { executeDELETEQuery } = require('../../src/index');
+const { executeDELETEQuery } = require('../../src/queryExecutor');
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 c99d01fbb..dc1fa19ae 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/index');
+const {executeSELECTQuery } = require('../../src/queryExecutor');
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 8c405f727..581d17f73 100644
--- a/tests/step-20/insertExecuter.test.js
+++ b/tests/step-20/insertExecuter.test.js
@@ -1,4 +1,4 @@
-const { executeINSERTQuery } = require('../../src/index');
+const { executeINSERTQuery } = require('../../src/queryExecutor');
const { readCSV, writeCSV } = require('../../src/csvReader');
const fs = require('fs');
From 8e587f323e94d3ad415a2ed0b7b809f40a3e8ced Mon Sep 17 00:00:00 2001
From: Rishabh Dewangan StylusDB SQL
StylusDB SQL