A SQL database engine written in JavaScript diff --git a/enrollment.csv b/enrollment.csv new file mode 100644 index 000000000..3f7f04422 --- /dev/null +++ b/enrollment.csv @@ -0,0 +1,6 @@ +student_id,course +1,Mathematics +1,Physics +2,Chemistry +3,Mathematics +5,Biology diff --git a/package-lock.json b/package-lock.json index 3afaec37f..a6ba782df 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,7 +9,6 @@ "version": "0.1.6", "license": "ISC", "dependencies": { - "csv-parser": "^3.0.0", "json2csv": "^6.0.0-alpha.2", "xterm": "^5.3.0" }, @@ -17,6 +16,7 @@ "stylusdb-cli": "node ./src/cli.js" }, "devDependencies": { + "csv-parser": "^3.0.0", "jest": "^29.7.0" } }, @@ -1573,6 +1573,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/csv-parser/-/csv-parser-3.0.0.tgz", "integrity": "sha512-s6OYSXAK3IdKqYO33y09jhypG/bSDHPuyCme/IdEHfWpLf/jKcpitVFyOC6UemgGk8v7Q5u2XE0vvwmanxhGlQ==", + "dev": true, "dependencies": { "minimist": "^1.2.0" }, @@ -2943,6 +2944,7 @@ "version": "1.2.8", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" } diff --git a/package.json b/package.json index f52103d5c..df75296ba 100644 --- a/package.json +++ b/package.json @@ -4,11 +4,15 @@ "description": "A minimal SQL based DB based on CSV files. For educational purposes only.", "main": "./src/index.js", "directories": { - "doc": "docs" + "doc": "docs", + "test": "tests" }, "scripts": { "test": "jest", - "test:1": "jest --testPathPattern=./tests/step-01", + "test:82": "jest --testPathPattern=./tests/csvReader.test.js", + "test:83": "jest --testPathPattern=./tests/queryExecutor.test.js", + "test:84": "jest --testPathPattern=./tests/queryParser.test.js", + "test:1": "jest --testPathPattern=./tests/step-01", "test:2": "jest --testPathPattern=./tests/step-02", "test:3": "jest --testPathPattern=./tests/step-03", "test:4": "jest --testPathPattern=./tests/step-04", @@ -38,11 +42,11 @@ "author": "Chakshu Gautam", "license": "ISC", "devDependencies": { + "csv-parser": "^3.0.0", "jest": "^29.7.0" }, "dependencies": { - "csv-parser": "^3.0.0", "json2csv": "^6.0.0-alpha.2", "xterm": "^5.3.0" } -} \ No newline at end of file +} diff --git a/src/cli.js b/src/cli.js new file mode 100644 index 000000000..20ebf5175 --- /dev/null +++ b/src/cli.js @@ -0,0 +1,41 @@ +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 { + 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 e69de29bb..526e1d935 100644 --- a/src/csvReader.js +++ b/src/csvReader.js @@ -0,0 +1,26 @@ +const fs = require('fs'); +const csv = require('csv-parser'); +const { parse } = require('json2csv'); + +function readCSV(filePath) { + const results = []; + + return new Promise((resolve, reject) => { + fs.createReadStream(filePath) + .pipe(csv()) + .on('data', (data) => results.push(data)) + .on('end', () => { + resolve(results); + }) + .on('error', (error) => { + reject(error); + }); + }); +} + +async function writeCSV(filename, data) { + const csv = parse(data); + fs.writeFileSync(filename, csv); +} + +module.exports = {readCSV,writeCSV}; \ No newline at end of file diff --git a/src/index.js b/src/index.js new file mode 100644 index 000000000..17abb4bd8 --- /dev/null +++ b/src/index.js @@ -0,0 +1,356 @@ +const { parseSelectQuery,parseInsertQuery,parseDeleteQuery} = require('./queryParser'); +const {readCSV, writeCSV} = require('./csvReader'); + + +function evaluateCondition(row, clause) { + let { field, operator, value } = clause; + + value = value.replace(/["']/g, ''); + if(row[field]) + row[field] = row[field].replace(/["']/g, ''); + + if (operator === 'LIKE') { + // Transform SQL LIKE pattern to JavaScript RegExp pattern + const regexPattern = '^' + value.replace(/%/g, '.*').replace(/_/g, '.') + '$'; + const regex = new RegExp(regexPattern, 'i'); // 'i' for case-insensitive matching + + + return regex.test(row[field]); + } + + switch (operator) { + case '=': return row[field] == value; + case '!=': return row[field] !== value; + case '>': return row[field] > value; + case '<': return row[field] < value; + case '>=': return row[field] >= value; + case '<=': return row[field] <= value; + default: throw new Error(`Unsupported operator: ${operator}`); + } +} + +function performInnerJoin(data, joinData, joinCondition, fields, table) { + // Logic for INNER JOIN + data = data.flatMap(mainRow => { + + return joinData + .filter(joinRow => { + const mainValue = mainRow[joinCondition.left.split('.')[1]]; + const joinValue = joinRow[joinCondition.right.split('.')[1]]; + return mainValue === joinValue; + }) + .map(joinRow => { + return fields.reduce((acc, field) => { + const [tableName, fieldName] = field.split('.'); + acc[field] = tableName === table ? mainRow[fieldName] : joinRow[fieldName]; + return acc; + }, {}); + }); + }); + return data +} + +function performLeftJoin(data, joinData, joinCondition, fields, table) { + + return data.flatMap(mainRow => { + const matchingJoinRows = joinData.filter(joinRow => { + const mainValue = getValueFromRow(mainRow, joinCondition.left); + const joinValue = getValueFromRow(joinRow, joinCondition.right); + return mainValue === joinValue; + }); + + if (matchingJoinRows.length === 0) { + return [createResultRow(mainRow, null, fields, table, true)]; + } + + return matchingJoinRows.map(joinRow => createResultRow(mainRow, joinRow, fields, table, true)); + }); +} + +function getValueFromRow(row, compoundFieldName) { + const [tableName, fieldName] = compoundFieldName.split('.'); + return row[`${tableName}.${fieldName}`] || row[fieldName]; +} + +function performRightJoin(data, joinData, joinCondition, fields, table) { + // Cache the structure of a main table row (keys only) + const mainTableRowStructure = data.length > 0 ? Object.keys(data[0]).reduce((acc, key) => { + acc[key] = null; // Set all values to null initially + return acc; + }, {}) : {}; + + return joinData.map(joinRow => { + const mainRowMatch = data.find(mainRow => { + const mainValue = getValueFromRow(mainRow, joinCondition.left); + const joinValue = getValueFromRow(joinRow, joinCondition.right); + return mainValue === joinValue; + }); + + // Use the cached structure if no match is found + const mainRowToUse = mainRowMatch || mainTableRowStructure; + + // Include all necessary fields from the 'student' table + return createResultRow(mainRowToUse, joinRow, fields, table, true); + }); +} + +function createResultRow(mainRow, joinRow, fields, table, includeAllMainFields) { + const resultRow = {}; + + if (includeAllMainFields) { + // Include all fields from the main table + Object.keys(mainRow || {}).forEach(key => { + const prefixedKey = `${table}.${key}`; + resultRow[prefixedKey] = mainRow ? mainRow[key] : null; + }); + } + + // Now, add or overwrite with the fields specified in the query + fields.forEach(field => { + const [tableName, fieldName] = field.includes('.') ? field.split('.') : [table, field]; + resultRow[field] = tableName === table && mainRow ? mainRow[fieldName] : joinRow ? joinRow[fieldName] : null; + }); + + return resultRow; +} +// Helper function to apply GROUP BY and aggregate functions + +function applyGroupBy(data, groupByFields, aggregateFunctions) { + // Implement logic to group data and calculate aggregates + const groupResults = {}; + + data.forEach((row) => { + const groupKey = groupByFields.map(field => row[field]).join('-'); + + if (!groupResults[groupKey]) { + groupResults[groupKey] = { count: 0, sums: {}, mins: {}, maxes: {} }; + groupByFields.forEach(field => groupResults[groupKey][field] = row[field]); + } + + // Aggregate calculations + groupResults[groupKey].count += 1; + aggregateFunctions.forEach(func => { + const match = /(\w+)\((\w+)\)/.exec(func); + if (match) { + const [, aggFunc, aggField] = match; + const value = parseFloat(row[aggField]); + + switch (aggFunc.toUpperCase()) { + case 'SUM': + groupResults[groupKey].sums[aggField] = (groupResults[groupKey].sums[aggField] || 0) + value; + break; + case 'MIN': + groupResults[groupKey].mins[aggField] = Math.min(groupResults[groupKey].mins[aggField] || value, value); + break; + case 'MAX': + groupResults[groupKey].maxes[aggField] = Math.max(groupResults[groupKey].maxes[aggField] || value, value); + break; + // Additional aggregate functions can be added here + } + } + }); + }); + + // Convert grouped results into an array format + return Object.values(groupResults).map(group => { + // Construct the final grouped object based on required fields + const finalGroup = {}; + groupByFields.forEach(field => finalGroup[field] = group[field]); + aggregateFunctions.forEach(func => { + const match = /(\w+)\((\*|\w+)\)/.exec(func); + if (match) { + const [, aggFunc, aggField] = match; + switch (aggFunc.toUpperCase()) { + case 'SUM': + finalGroup[func] = group.sums[aggField]; + break; + case 'MIN': + finalGroup[func] = group.mins[aggField]; + break; + case 'MAX': + finalGroup[func] = group.maxes[aggField]; + break; + case 'COUNT': + finalGroup[func] = group.count; + break; + // Additional aggregate functions can be handled here + } + } + }); + return finalGroup; + }); +} + + +function aggregatedOperations(aggregateFunction, rows) { + const [op, fieldName] = aggregateFunction + .split("(") + .map((part) => part.trim().replace(")", "")); + if (fieldName === "*") { + return rows.length; + } + + const values = rows.map((row) => row[fieldName]); + + let result; + switch (op.toUpperCase()) { + case "COUNT": + result = values.length; + break; + case "AVG": + result = + values.reduce((acc, val) => acc + Number(val), 0) / values.length; + break; + case "MAX": + result = Math.max(...values); + break; + case "MIN": + result = Math.min(...values); + break; + case "SUM": + result = values.reduce((acc, val) => acc + Number(val), 0); + break; + // Handle other aggregate functions if needed + default: + throw new Error(`Unsupported aggregate function: ${op}`); + } + + return result; +} + +async function executeSELECTQuery(query) { + try { + const { fields, table, whereClauses, joinType, joinTable, joinCondition, groupByFields, orderByFields, limit,isDistinct, hasAggregateWithoutGroupBy } = parseSelectQuery(query) + + let data = await readCSV(`${table}.csv`); + + // Perform INNER JOIN if specified + if (joinTable && joinCondition) { + const joinData = await readCSV(`${joinTable}.csv`); + switch (joinType.toUpperCase()) { + case 'INNER': + data = performInnerJoin(data, joinData, joinCondition, fields, table); + break; + case 'LEFT': + data = performLeftJoin(data, joinData, joinCondition, fields, table); + break; + case 'RIGHT': + data = performRightJoin(data, joinData, joinCondition, fields, table); + break; + // Handle default case or unsupported JOIN types + } + } + + + let filteredData = whereClauses.length > 0 + ? data.filter(row => whereClauses.every(clause => evaluateCondition(row, clause))) + : data; + + // logic for group by + if (groupByFields) { + filteredData = applyGroupBy(filteredData, groupByFields, fields); + } + + if (hasAggregateWithoutGroupBy && fields.length == 1) { + const selectedRow = {}; + selectedRow[fields[0]] = aggregatedOperations(fields[0], filteredData); + return [selectedRow]; + } + + // console.log("AFTER GROUP: ", filteredData); + + if (orderByFields) { + filteredData.sort((a, b) => { + for (let { fieldName, order } of orderByFields) { + if (a[fieldName] < b[fieldName]) return order === "ASC" ? -1 : 1; + if (a[fieldName] > b[fieldName]) return order === "ASC" ? 1 : -1; + } + return 0; + }); + } + + // console.log("AFTER ORDER: ", filteredData); + + if (limit !== null) { + filteredData = filteredData.slice(0, limit); + } + + if (isDistinct) { + filteredData = [ + ...new Map( + filteredData.map((item) => [ + fields.map((field) => item[field]).join("|"), + item, + ]) + ).values(), + ]; + } + + // Filter the fields based on the query fields + return filteredData.map((row) => { + const selectedRow = {}; + fields.forEach((field) => { + if (hasAggregateWithoutGroupBy) { + selectedRow[field] = aggregatedOperations(field, filteredData); + } else { + selectedRow[field] = row[field]; + } + }); + return selectedRow; + }); + } catch (error) { + throw new Error(`Error executing query: ${error.message}`); + } + } + async function executeINSERTQuery(query) { + const { table, columns, values, returningColumns } = parseInsertQuery(query); + const data = await readCSV(`${table}.csv`); + + + const headers = data.length > 0 ? Object.keys(data[0]) : columns; + const newRow = {}; + headers.forEach(header => { + const columnIndex = columns.indexOf(header); + if (columnIndex !== -1) { + let value = values[columnIndex]; + if (value.startsWith("'") && value.endsWith("'")) { + value = value.substring(1, value.length - 1); + } + newRow[header] = value; + } else { + newRow[header] = header === 'id' ? newId.toString() : ''; + } + }); + + data.push(newRow); + + await writeCSV(`${table}.csv`, data); + + let returningResult = {}; + if (returningColumns.length > 0) { + returningColumns.forEach(column => { + returningResult[column] = newRow[column]; + }); + } + + return { + returning: returningResult + }; +} + +async function executeDELETEQuery(query) { + const { table, whereClause } = parseDeleteQuery(query); + let data = await readCSV(`${table}.csv`); + + if (whereClause.length > 0) { + data = data.filter(row => !whereClause.every(clause => evaluateCondition(row, clause))); + } else { + data = []; + } + + await writeCSV(`${table}.csv`, data); + + return { message: "Rows deleted successfully." }; +} + +module.exports = {executeSELECTQuery, executeINSERTQuery, executeDELETEQuery}; \ No newline at end of file diff --git a/src/queryParser.js b/src/queryParser.js new file mode 100644 index 000000000..063ff0ee9 --- /dev/null +++ b/src/queryParser.js @@ -0,0 +1,214 @@ +function parseSelectQuery(query) { + try { + // Trim the query to remove any leading/trailing whitespaces + query = query.trim(); + let isDistinct = false; + if (query.toUpperCase().includes('SELECT DISTINCT')) { + isDistinct = true; + query = query.replace('SELECT DISTINCT', 'SELECT'); + } + + const limitRegex = /\sLIMIT\s(\d+)/i; + + + const limitMatch = query.match(limitRegex); + let limit = null; + if (limitMatch) { + limit = parseInt(limitMatch[1]); + } + query = query.replace(limitRegex, ''); + + // Updated regex to capture ORDER BY clause + + const orderByRegex = /\sORDER BY\s(.+)/i; + const orderByMatch = query.match(orderByRegex); + + let orderByFields = null; + if (orderByMatch) { + orderByFields = orderByMatch[1].split(',').map(field => { + const [fieldName, order] = field.trim().split(/\s+/); + return { fieldName, order: order ? order.toUpperCase() : 'ASC' }; + }); + } + // + // Remove ORDER BY clause from the query for further processing + query = query.replace(orderByRegex, ''); + + // Split the query at the GROUP BY clause if it exists + const groupByRegex = /\sGROUP BY\s(.+)/i; + const groupByMatch = query.match(groupByRegex); + + let groupByFields = null; + if (groupByMatch) { + groupByFields = groupByMatch[1].split(',').map(field => field.trim()); + } + + // Remove GROUP BY clause from the query for further processing + query = query.replace(groupByRegex, ''); + + + + // Split the query at the WHERE clause if it exists + const whereSplit = query.split(/\sWHERE\s/i); + const queryWithoutWhere = whereSplit[0]; // Everything before WHERE clause + + // WHERE clause is the second part after splitting, if it exists + const whereClause = whereSplit.length > 1 ? whereSplit[1].trim() : null; + + // identifying like statement + + + + // Split the remaining query at the JOIN clause if it exists + const joinSplit = queryWithoutWhere.split(/\s(INNER|LEFT|RIGHT) JOIN\s/i); + const selectPart = joinSplit[0].trim(); // Everything before JOIN clause + + // Parse the SELECT part + const selectRegex = /^SELECT\s(.+?)\sFROM\s(.+)/i; + const selectMatch = selectPart.match(selectRegex); + + if (!selectMatch) { + throw new Error("Invalid SELECT format"); + } + + + + const [, fields, table] = selectMatch; + + + + // Extract JOIN information + const { joinType, joinTable, joinCondition } = parseJoinClause(queryWithoutWhere); + + // Parse the WHERE part if it exists + let whereClauses = []; + if (whereClause) { + whereClauses = parseWhereClause(whereClause); + } + + // Check for the presence of aggregate functions without GROUP BY + const aggregateFunctionRegex = /(\bCOUNT\b|\bAVG\b|\bSUM\b|\bMIN\b|\bMAX\b)\s*\(\s*(\*|\w+)\s*\)/i; + const hasAggregateWithoutGroupBy = aggregateFunctionRegex.test(query) && !groupByFields; + + + + return { + fields: fields.split(',').map(field => field.trim()), + table: table.trim(), + whereClauses, + joinType, + joinTable, + joinCondition, + groupByFields, + orderByFields, + limit, + isDistinct, + hasAggregateWithoutGroupBy + }; + }catch (error) { + throw new Error(`Query parsing error: ${error.message}`); + } +} + +function parseWhereClause(whereString) { + const conditionRegex = /(.*?)(=|!=|>=|<=|>|<)(.*)/; + return whereString.split(/ AND | OR /i).map(conditionString => { + if (conditionString.includes(' LIKE ')) { + const [field, pattern] = conditionString.split(/\sLIKE\s/i); + return { field: field.trim(), operator: 'LIKE', value: pattern.trim().replace(/^'(.*)'$/, '$1') }; + } else { + const match = conditionString.match(conditionRegex); + if (match) { + const [, field, operator, value] = match; + return { field: field.trim(), operator, value: value.trim() }; + } + throw new Error('Invalid WHERE clause format'); + } + }); +} + + + +function parseJoinClause(query) { + const joinRegex = /\s(INNER|LEFT|RIGHT) JOIN\s(.+?)\sON\s([\w.]+)\s*=\s*([\w.]+)/i; + const joinMatch = query.match(joinRegex); + + if (joinMatch) { + return { + joinType: joinMatch[1].trim(), + joinTable: joinMatch[2].trim(), + joinCondition: { + left: joinMatch[3].trim(), + right: joinMatch[4].trim() + } + }; + } + + + + return { + joinType: null, + joinTable: null, + joinCondition: null + }; +} + + +function parseInsertQuery(query) { + query = query.replace(/"?\w+"?\."(\w+)"?/g, '$1'); + + const insertRegex = /INSERT INTO "?(\w+)"?\s\(([^)]+)\)\sVALUES\s\(([^)]+)\)/i; + const insertMatch = query.match(insertRegex); + + if (!insertMatch) { + throw new Error("Invalid INSERT INTO syntax."); + } + + const [, table, columns, values] = insertMatch; + + const parsedColumns = columns.split(',').map((name) => { + return name.trim().replace(/^"?(.+?)"?$/g, '$1'); + }); + + const parsedValues = values.split(',').map((value) => { + return value.trim().replace(/^'(.*)'$/g, '$1').replace(/^"(.*)"$/g, '$1'); + }); + + const returningMatch = query.match(/RETURNING\s(.+)$/i); + const returningColumns = returningMatch + ? returningMatch[1].split(',').map((name) => { + return name.trim().replace(/\w+\./g, '').replace(/^"?(.+?)"?$/g, '$1'); + }) + : []; + return { + type: 'INSERT', + table: table.trim().replace(/^"?(.+?)"?$/g, '$1'), + columns: parsedColumns, + values: parsedValues, + returningColumns + }; +} + +function parseDeleteQuery(query) { + const deleteRegex = /DELETE FROM (\w+)( WHERE (.*))?/i; + const deleteMatch = query.match(deleteRegex); + + if (!deleteMatch) { + throw new Error("Invalid DELETE syntax."); + } + + const [, table, ,whereString] = deleteMatch; + let whereClause = []; + if (whereString) { + whereClause = parseWhereClause(whereString); + } + + return { + type: 'DELETE', + table: table.trim(), + whereClause + }; +} + + +module.exports = { parseSelectQuery, parseJoinClause, parseInsertQuery, parseDeleteQuery }; \ No newline at end of file diff --git a/student.csv b/student.csv new file mode 100644 index 000000000..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/csvReader.test.js b/tests/csvReader.test.js new file mode 100644 index 000000000..42c8eb9e6 --- /dev/null +++ b/tests/csvReader.test.js @@ -0,0 +1,9 @@ +const {readCSV} = require('../src/csvReader'); + +test('Read CSV File', async () => { + 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/queryExecutor.test.js b/tests/queryExecutor.test.js new file mode 100644 index 000000000..de3586702 --- /dev/null +++ b/tests/queryExecutor.test.js @@ -0,0 +1,393 @@ +const {executeSELECTQuery} = require('../src/index'); + +test('Execute SQL Query', async () => { + const query = 'SELECT id, name FROM student'; + 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' }); +}); + +test('Execute SQL Query with WHERE Clause', async () => { + 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'); +}); + +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); + 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(3); + expect(result[0]).toHaveProperty('name'); +}); + +test('Execute 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 executeSELECTQuery(query); + /* + result = [ + { 'student.name': 'John', 'enrollment.course': 'Mathematics' }, + { 'student.name': 'John', 'enrollment.course': 'Physics' }, + { 'student.name': 'Jane', 'enrollment.course': 'Chemistry' }, + { 'student.name': 'Bob', 'enrollment.course': 'Mathematics' } + ] + */ + expect(result.length).toEqual(4); + // toHaveProperty is not working here due to dot in the property name + expect(result[0]).toEqual(expect.objectContaining({ + "enrollment.course": "Mathematics", + "student.name": "John" + })); +}); + +test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { + const query = 'SELECT student.name, enrollment.course, student.age FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 25'; + const result = await executeSELECTQuery(query); + /* + result = [ + { + 'student.name': 'John', + 'enrollment.course': 'Mathematics', + 'student.age': '30' + }, + { + 'student.name': 'John', + 'enrollment.course': 'Physics', + 'student.age': '30' + } + ] + */ + expect(result.length).toEqual(2); + // toHaveProperty is not working here due to dot in the property name + expect(result[0]).toEqual(expect.objectContaining({ + "enrollment.course": "Mathematics", + "student.name": "John" + })); +}); + +test('Execute SQL Query with LEFT JOIN', async () => { + const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id'; + const result = await executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "student.name": "Alice", "enrollment.course": null }), + expect.objectContaining({ "student.name": "John", "enrollment.course": "Mathematics" }) + ])); + expect(result.length).toEqual(5); // 4 students, but John appears twice +}); + +test('Execute SQL Query with RIGHT JOIN', async () => { + const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id'; + const result = await executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "student.name": null, "enrollment.course": "Biology" }), + expect.objectContaining({ "student.name": "John", "enrollment.course": "Mathematics" }) + ])); + expect(result.length).toEqual(5); // 4 courses, but Mathematics appears twice +}); + +test('Execute 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 executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "enrollment.course": "Mathematics", "student.name": "John" }), + expect.objectContaining({ "enrollment.course": "Physics", "student.name": "John" }) + ])); + expect(result.length).toEqual(4); +}); + +test('Execute 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 executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "student.name": "John", "enrollment.course": "Physics" }) + ])); + expect(result.length).toEqual(1); +}); + +test('Execute 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 executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "enrollment.course": "Mathematics", "student.name": "Bob" }), + expect.objectContaining({ "enrollment.course": "Biology", "student.name": null }) + ])); + expect(result.length).toEqual(2); +}); + +test('Execute 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 executeSELECTQuery(query); + expect(result).toEqual(expect.arrayContaining([ + expect.objectContaining({ "enrollment.course": "Chemistry", "student.name": "Jane" }), + ])); + expect(result.length).toEqual(1); +}); + +test('Execute SQL Query with RIGHT JOIN with a multiple WHERE clauses filtering the join table and main table', async () => { + const query = `SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id WHERE enrollment.course = 'Chemistry' AND student.age = 26`; + const result = await executeSELECTQuery(query); + expect(result).toEqual([]); +}); + +test('Execute COUNT Aggregate Query', async () => { + const query = 'SELECT COUNT(*) FROM student'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([{ 'COUNT(*)': 4 }]); +}); + +test('Execute SUM Aggregate Query', async () => { + const query = 'SELECT SUM(age) FROM student'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([{ 'SUM(age)': 101 }]); +}); + +test('Execute AVG Aggregate Query', async () => { + const query = 'SELECT AVG(age) FROM student'; + const result = await executeSELECTQuery(query); + // Assuming AVG returns a single decimal point value + expect(result).toEqual([{ 'AVG(age)': 25.25 }]); +}); + +test('Execute MIN Aggregate Query', async () => { + const query = 'SELECT MIN(age) FROM student'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([{ 'MIN(age)': 22 }]); +}); + +test('Execute MAX Aggregate Query', async () => { + const query = 'SELECT MAX(age) FROM student'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([{ 'MAX(age)': 30 }]); +}); + +test('Count students per age', async () => { + const query = 'SELECT age, COUNT(*) FROM student GROUP BY age'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([ + { age: '22', 'COUNT(*)': 1 }, + { age: '24', 'COUNT(*)': 1 }, + { age: '25', 'COUNT(*)': 1 }, + { age: '30', 'COUNT(*)': 1 } + ]); +}); + +test('Count enrollments per course', async () => { + const query = 'SELECT course, COUNT(*) FROM enrollment GROUP BY course'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([ + { course: 'Mathematics', 'COUNT(*)': 2 }, + { course: 'Physics', 'COUNT(*)': 1 }, + { course: 'Chemistry', 'COUNT(*)': 1 }, + { course: 'Biology', 'COUNT(*)': 1 } + ]); +}); + + +test('Count courses per student', async () => { + const query = 'SELECT student_id, COUNT(*) FROM enrollment GROUP BY student_id'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([ + { student_id: '1', 'COUNT(*)': 2 }, + { student_id: '2', 'COUNT(*)': 1 }, + { student_id: '3', 'COUNT(*)': 1 }, + { student_id: '5', 'COUNT(*)': 1 } + ]); +}); + +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); + expect(result).toEqual([ + { age: '24', 'COUNT(*)': 1 }, + { age: '25', 'COUNT(*)': 1 }, + { age: '30', 'COUNT(*)': 1 } + ]); +}); + +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); + expect(result).toEqual([ + { course: 'Mathematics', 'COUNT(*)': 2 } + ]); +}); + +test('Count courses for a specific student', async () => { + const query = 'SELECT student_id, COUNT(*) FROM enrollment WHERE student_id = 1 GROUP BY student_id'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([ + { student_id: '1', 'COUNT(*)': 2 } + ]); +}); + +test('Average age of students above a certain age', async () => { + const query = 'SELECT AVG(age) FROM student WHERE age > 22'; + const result = await executeSELECTQuery(query); + const expectedAverage = (25 + 30 + 24) / 3; // Average age of students older than 22 + expect(result).toEqual([{ 'AVG(age)': expectedAverage }]); +}); + +test('Execute SQL Query with ORDER BY', async () => { + const query = 'SELECT name FROM student ORDER BY name ASC'; + const result = await executeSELECTQuery(query); + + expect(result).toStrictEqual([ + { name: 'Alice' }, + { name: 'Bob' }, + { name: 'Jane' }, + { name: 'John' } + ]); +}); + +test('Execute SQL Query with ORDER BY and WHERE', async () => { + const query = 'SELECT name FROM student WHERE age > 24 ORDER BY name DESC'; + const result = await executeSELECTQuery(query); + + expect(result).toStrictEqual([ + { name: 'John' }, + { name: 'Jane' }, + ]); +}); +test('Execute SQL Query with ORDER BY and GROUP BY', async () => { + const query = 'SELECT COUNT(id) as count, age FROM student GROUP BY age ORDER BY age DESC'; + const result = await executeSELECTQuery(query); + + expect(result).toStrictEqual([ + { age: '30', 'COUNT(id) as count': 1 }, + { age: '25', 'COUNT(id) as count': 1 }, + { age: '24', 'COUNT(id) as count': 1 }, + { age: '22', 'COUNT(id) as count': 1 } + ]); +}); + +test('Execute SQL Query with standard LIMIT clause', async () => { + const query = 'SELECT id, name FROM student LIMIT 2'; + const result = await executeSELECTQuery(query); + expect(result.length).toEqual(2); +}); + +test('Execute SQL Query with LIMIT clause equal to total rows', async () => { + const query = 'SELECT id, name FROM student LIMIT 4'; + const result = await executeSELECTQuery(query); + expect(result.length).toEqual(4); +}); + +test('Execute SQL Query with LIMIT clause exceeding total rows', async () => { + const query = 'SELECT id, name FROM student LIMIT 10'; + const result = await executeSELECTQuery(query); + expect(result.length).toEqual(4); // Total rows in student.csv +}); + +test('Execute SQL Query with LIMIT 0', async () => { + const query = 'SELECT id, name FROM student LIMIT 0'; + const result = await executeSELECTQuery(query); + expect(result.length).toEqual(0); +}); + +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'); +}); + +test('Error Handling with Malformed Query', async () => { + const query = 'SELECT FROM table'; // intentionally malformed + await expect(executeSELECTQuery(query)).rejects.toThrow("Error executing query: Query parsing error: Invalid SELECT format"); +}); + +test('Basic DISTINCT Usage', async () => { + const query = 'SELECT DISTINCT age FROM student'; + const result = await executeSELECTQuery(query); + expect(result).toEqual([{ age: '30' }, { age: '25' }, { age: '22' }, { age: '24' }]); +}); + +test('DISTINCT with Multiple Columns', async () => { + const query = 'SELECT DISTINCT student_id, course FROM enrollment'; + const result = await executeSELECTQuery(query); + // Expecting unique combinations of student_id and course + expect(result).toEqual([ + { student_id: '1', course: 'Mathematics' }, + { student_id: '1', course: 'Physics' }, + { student_id: '2', course: 'Chemistry' }, + { student_id: '3', course: 'Mathematics' }, + { student_id: '5', course: 'Biology' }, + ]); +}); + +// Not a good test right now +test('DISTINCT with WHERE Clause', async () => { + const query = 'SELECT DISTINCT course FROM enrollment WHERE student_id = "1"'; + const result = await executeSELECTQuery(query); + // Expecting courses taken by student with ID 1 + expect(result).toEqual([{ course: 'Mathematics' }, { course: 'Physics' }]); +}); + +test('DISTINCT with JOIN Operations', async () => { + const query = 'SELECT DISTINCT student.name FROM student INNER JOIN enrollment ON student.id = enrollment.student_id'; + const result = await executeSELECTQuery(query); + // Expecting names of students who are enrolled in any course + expect(result).toEqual([{ "student.name": 'John' }, { "student.name": 'Jane' }, { "student.name": 'Bob' }]); +}); + +test('DISTINCT with ORDER BY and LIMIT', async () => { + const query = 'SELECT DISTINCT age FROM student ORDER BY age DESC LIMIT 2'; + const result = await executeSELECTQuery(query); + // Expecting the two highest unique ages + expect(result).toEqual([{ age: '30' }, { age: '25' }]); +}); + +test('Execute SQL Query with LIKE Operator for Name', async () => { + const query = "SELECT name FROM student WHERE name LIKE '%Jane%'"; + const result = await executeSELECTQuery(query); + // Expecting names containing 'Jane' + expect(result).toEqual([{ name: 'Jane' }]); +}); + +test('Execute SQL Query with LIKE Operator and Wildcards', async () => { + const query = "SELECT name FROM student WHERE name LIKE 'J%'"; + const result = await executeSELECTQuery(query); + // Expecting names starting with 'J' + expect(result).toEqual([{ name: 'John' }, { name: 'Jane' }]); +}); + +test('Execute SQL Query with LIKE Operator Case Insensitive', async () => { + const query = "SELECT name FROM student WHERE name LIKE '%bob%'"; + const result = await executeSELECTQuery(query); + // Expecting names 'Bob' (case insensitive) + expect(result).toEqual([{ name: 'Bob' }]); +}); + +test('Execute SQL Query with LIKE Operator and DISTINCT', async () => { + const query = "SELECT DISTINCT name FROM student WHERE name LIKE '%e%'"; + const result = await executeSELECTQuery(query); + // Expecting unique names containing 'e' + expect(result).toEqual([{ name: 'Jane' }, { name: 'Alice' }]); +}); + +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' }]); +}); diff --git a/tests/queryParser.test.js b/tests/queryParser.test.js new file mode 100644 index 000000000..4c6a45e5c --- /dev/null +++ b/tests/queryParser.test.js @@ -0,0 +1,423 @@ +const { parseJoinClause, parseSelectQuery } = require('../src/queryParser'); + +describe('parseJoinClause', () => { + + test('Parse SQL Query', () => { + const query = 'SELECT id, name FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['id', 'name'], + table: 'student', + whereClauses: [], + joinCondition: null, + joinTable: null, + joinType: null, + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['id', 'name'], + 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('Parse SQL Query with Multiple WHERE Clauses', () => { + const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['id', 'name'], + table: 'student', + whereClauses: [{ + "field": "age", + "operator": "=", + "value": "30", + }, { + "field": "name", + "operator": "=", + "value": "John", + }], + joinCondition: null, + joinTable: null, + joinType: null, + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 parseSelectQuery(query); + expect(result).toEqual({ + fields: ['student.name', 'enrollment.course'], + table: 'student', + whereClauses: [], + joinTable: 'enrollment', + 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 parseSelectQuery(query); + expect(result).toEqual({ + fields: ['student.name', 'enrollment.course'], + table: 'student', + whereClauses: [{ field: 'student.age', operator: '>', value: '20' }], + joinTable: 'enrollment', + joinType: "INNER", + joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "orderByFields": null, + "limit": null, + isDistinct: false + }) + }); + + test('Parse INNER JOIN clause', () => { + const query = 'SELECT * FROM table1 INNER JOIN table2 ON table1.id = table2.ref_id'; + const result = parseJoinClause(query); + expect(result).toEqual({ + joinType: 'INNER', + joinTable: 'table2', + joinCondition: { left: 'table1.id', right: 'table2.ref_id' }, + }); + }); + + test('Parse LEFT JOIN clause', () => { + const query = 'SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.ref_id'; + const result = parseJoinClause(query); + expect(result).toEqual({ + joinType: 'LEFT', + joinTable: 'table2', + joinCondition: { left: 'table1.id', right: 'table2.ref_id' } + }); + }); + + test('Parse RIGHT JOIN clause', () => { + const query = 'SELECT * FROM table1 RIGHT JOIN table2 ON table1.id = table2.ref_id'; + const result = parseJoinClause(query); + expect(result).toEqual({ + joinType: 'RIGHT', + joinTable: 'table2', + joinCondition: { left: 'table1.id', right: 'table2.ref_id' } + }); + }); + + test('Returns null for queries without JOIN', () => { + const query = 'SELECT * FROM table1'; + const result = parseJoinClause(query); + expect(result).toEqual( + { + joinType: null, + joinTable: null, + joinCondition: null + } + ); + }); + + 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 = parseSelectQuery(query); + expect(result).toEqual({ + fields: ['student.name', 'enrollment.course'], + table: 'student', + whereClauses: [], + joinType: 'LEFT', + joinTable: 'enrollment', + joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 = parseSelectQuery(query); + expect(result).toEqual({ + fields: ['student.name', 'enrollment.course'], + table: 'student', + whereClauses: [], + joinType: 'RIGHT', + joinTable: 'enrollment', + joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 parseSelectQuery(query); + expect(result).toEqual({ + "fields": ["student.name", "enrollment.course"], + "joinCondition": { "left": "student.id", "right": "enrollment.student_id" }, + "joinTable": "enrollment", + "joinType": "LEFT", + "table": "student", + "whereClauses": [{ "field": "student.age", "operator": ">", "value": "22" }], + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 parseSelectQuery(query); + expect(result).toEqual({ + "fields": ["student.name", "enrollment.course"], + "joinCondition": { "left": "student.id", "right": "enrollment.student_id" }, + "joinTable": "enrollment", + "joinType": "LEFT", + "table": "student", + "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Physics'" }], + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 parseSelectQuery(query); + expect(result).toEqual({ + "fields": ["student.name", "enrollment.course"], + "joinCondition": { "left": "student.id", "right": "enrollment.student_id" }, + "joinTable": "enrollment", + "joinType": "RIGHT", + "table": "student", + "whereClauses": [{ "field": "student.age", "operator": "<", "value": "25" }], + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "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 parseSelectQuery(query); + expect(result).toEqual({ + "fields": ["student.name", "enrollment.course"], + "joinCondition": { "left": "student.id", "right": "enrollment.student_id" }, + "joinTable": "enrollment", + "joinType": "RIGHT", + "table": "student", + "whereClauses": [{ "field": "enrollment.course", "operator": "=", "value": "'Chemistry'" }], + groupByFields: null, + hasAggregateWithoutGroupBy: false, + "orderByFields": null, + "limit": null, + isDistinct: false + }); + }); + + + test('Parse COUNT Aggregate Query', () => { + const query = 'SELECT COUNT(*) FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['COUNT(*)'], + table: 'student', + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + "joinCondition": null, + "joinTable": null, + "joinType": null, + "orderByFields": null, + "limit": null, + isDistinct: false + }); + }); + + + test('Parse SUM Aggregate Query', () => { + const query = 'SELECT SUM(age) FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['SUM(age)'], + table: 'student', + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + "joinCondition": null, + "joinTable": null, + "joinType": null, + "orderByFields": null, + "limit": null, + isDistinct: false + }); + }); + + test('Parse AVG Aggregate Query', () => { + const query = 'SELECT AVG(age) FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['AVG(age)'], + table: 'student', + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + "joinCondition": null, + "joinTable": null, + "joinType": null, + "orderByFields": null, + "limit": null, + isDistinct: false + }); + }); + + test('Parse MIN Aggregate Query', () => { + const query = 'SELECT MIN(age) FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['MIN(age)'], + table: 'student', + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + "joinCondition": null, + "joinTable": null, + "joinType": null, + "orderByFields": null, + "limit": null, + isDistinct: false + }); + }); + + test('Parse MAX Aggregate Query', () => { + const query = 'SELECT MAX(age) FROM student'; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['MAX(age)'], + table: 'student', + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + "joinCondition": null, + "joinTable": null, + "joinType": 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 = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['age', 'COUNT(*)'], + table: 'student', + whereClauses: [], + groupByFields: ['age'], + joinType: null, + joinTable: null, + joinCondition: null, + hasAggregateWithoutGroupBy: false, + 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 = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['age', 'COUNT(*)'], + table: 'student', + whereClauses: [{ field: 'age', operator: '>', value: '22' }], + groupByFields: ['age'], + joinType: null, + joinTable: null, + joinCondition: null, + hasAggregateWithoutGroupBy: false, + 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 = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['student_id', 'course', 'COUNT(*)'], + table: 'enrollment', + whereClauses: [], + groupByFields: ['student_id', 'course'], + joinType: null, + joinTable: null, + joinCondition: null, + hasAggregateWithoutGroupBy: false, + 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 = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ['student.name', 'COUNT(*)'], + table: 'student', + whereClauses: [{ field: 'enrollment.course', operator: '=', value: '"Mathematics"' }], + groupByFields: ['student.name'], + joinType: 'INNER', + joinTable: 'enrollment', + joinCondition: { + left: 'student.id', + right: 'enrollment.student_id' + }, + hasAggregateWithoutGroupBy: false, + orderByFields: null, + "limit": null, + isDistinct: false, + }); + }); +}); \ No newline at end of file diff --git a/tests/step-02/index.test.js b/tests/step-02/index.test.js index a5467ee48..59a3322e8 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'); + 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 }); \ No newline at end of file diff --git a/tests/step-03/index.test.js b/tests/step-03/index.test.js index 9145ad3e4..f7e1640a7 100644 --- a/tests/step-03/index.test.js +++ b/tests/step-03/index.test.js @@ -1,19 +1,19 @@ -const readCSV = require('../../src/csvReader'); -const parseQuery = require('../../src/queryParser'); - -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 { parseSelectQuery } = require('../../src/queryParser'); 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..64ac7463b 100644 --- a/tests/step-04/index.test.js +++ b/tests/step-04/index.test.js @@ -1,26 +1,44 @@ -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(4); +// expect(data[0].name).toBe('John'); +// expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later +// }); + 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..221f7da0f 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,32 @@ 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.length).toBe(1); // Update to reflect the correct number of expected results expect(result[0]).toHaveProperty('id'); expect(result[0]).toHaveProperty('name'); - expect(result[0].id).toBe('2'); -}); \ No newline at end of file + expect(result[0].id).toBe('2'); // Update to reflect the correct expected result +}); diff --git a/tests/step-06/index.test.js b/tests/step-06/index.test.js index 2e2ef6416..59490324d 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,34 +39,42 @@ 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.length).toBe(1); // Update to reflect the correct number of expected results expect(result[0]).toHaveProperty('id'); expect(result[0]).toHaveProperty('name'); - expect(result[0].id).toBe('2'); + expect(result[0].id).toBe('2'); // Update to reflect the correct expected result }); 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..4b7abb7ed 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'; +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 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..3586974e5 100644 --- a/tests/step-08/index.test.js +++ b/tests/step-08/index.test.js @@ -1,27 +1,34 @@ -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, }); }); + test('Execute SQL Query', async () => { const query = 'SELECT id, name FROM student'; const result = await executeSELECTQuery(query); @@ -34,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', @@ -44,7 +51,13 @@ test('Parse SQL Query with WHERE Clause', () => { "value": "25", }], joinCondition: null, - joinTable: null + joinTable: null, + joinType: null, + groupByFields : null, + hasAggregateWithoutGroupBy: false, + orderByFields: null, + "limit": null, + isDistinct:false, }); }); @@ -59,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', @@ -73,7 +86,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,52 +106,64 @@ 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' } + joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, + groupByFields : null, + joinType: 'INNER', + 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' } + joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, + joinType: 'INNER', + groupByFields : null, + hasAggregateWithoutGroupBy: false, + orderByFields: null, + "limit": null, + isDistinct:false, }) }); test('Execute 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 executeSELECTQuery(query); - /* + let result = await executeSELECTQuery(query); + result = [ { 'student.name': 'John', 'enrollment.course': 'Mathematics' }, { 'student.name': 'John', 'enrollment.course': 'Physics' }, { 'student.name': 'Jane', 'enrollment.course': 'Chemistry' }, { 'student.name': 'Bob', 'enrollment.course': 'Mathematics' } ] - */ + expect(result.length).toEqual(4); // toHaveProperty is not working here due to dot in the property name expect(result[0]).toEqual(expect.objectContaining({ @@ -143,8 +174,8 @@ test('Execute SQL Query with INNER JOIN', async () => { test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { const query = 'SELECT student.name, enrollment.course, student.age FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 25'; - const result = await executeSELECTQuery(query); - /* + let result = await executeSELECTQuery(query); + result = [ { 'student.name': 'John', @@ -157,11 +188,11 @@ test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { 'student.age': '30' } ] - */ + expect(result.length).toEqual(2); // toHaveProperty is not working here due to dot in the property name expect(result[0]).toEqual(expect.objectContaining({ "enrollment.course": "Mathematics", "student.name": "John" })); -}); \ No newline at end of file +}); diff --git a/tests/step-09/index.test.js b/tests/step-09/index.test.js index aaf711f5a..f669fb192 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} = require('../../src/queryParser'); +const {executeSELECTQuery} = require('../../src/index'); test('Read CSV File', async () => { const data = await readCSV('./student.csv'); @@ -12,17 +12,23 @@ test('Read CSV File', 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', whereClauses: [], joinCondition: null, joinTable: null, - joinType: null + joinType: null, + groupByFields : null, + hasAggregateWithoutGroupBy: false, + orderByFields: null, + "limit": null, + isDistinct:false, }); }); + test('Execute SQL Query', async () => { const query = 'SELECT id, name FROM student'; const result = await executeSELECTQuery(query); @@ -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,10 +52,16 @@ 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, }); }); + test('Execute SQL Query with WHERE Clause', async () => { const query = 'SELECT id, name FROM student WHERE age = 25'; const result = await executeSELECTQuery(query); @@ -61,7 +73,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 +88,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,41 +120,51 @@ 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, }) }); test('Execute 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 executeSELECTQuery(query); - /* + let result = await executeSELECTQuery(query); + result = [ { 'student.name': 'John', 'enrollment.course': 'Mathematics' }, { 'student.name': 'John', 'enrollment.course': 'Physics' }, { 'student.name': 'Jane', 'enrollment.course': 'Chemistry' }, { 'student.name': 'Bob', 'enrollment.course': 'Mathematics' } ] - */ + expect(result.length).toEqual(4); // toHaveProperty is not working here due to dot in the property name expect(result[0]).toEqual(expect.objectContaining({ @@ -148,8 +175,8 @@ test('Execute SQL Query with INNER JOIN', async () => { test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { const query = 'SELECT student.name, enrollment.course, student.age FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 25'; - const result = await executeSELECTQuery(query); - /* + let result = await executeSELECTQuery(query); + result = [ { 'student.name': 'John', @@ -162,7 +189,7 @@ test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { 'student.age': '30' } ] - */ + expect(result.length).toEqual(2); // toHaveProperty is not working here due to dot in the property name expect(result[0]).toEqual(expect.objectContaining({ @@ -176,17 +203,17 @@ test('Execute SQL Query with LEFT JOIN', async () => { const result = await executeSELECTQuery(query); expect(result).toEqual(expect.arrayContaining([ expect.objectContaining({ "student.name": "Alice", "enrollment.course": null }), - expect.objectContaining({ "student.name": "John", "enrollment.course": "Mathematics" }) + expect.objectContaining({ "student.name": "John", "enrollment.course": "Mathematics" }), ])); expect(result.length).toEqual(5); // 4 students, but John appears twice }); -test('Execute SQL Query with LEFT JOIN', async () => { - const query = 'SELECT student.name, enrollment.course FROM student LEFT JOIN enrollment ON student.id=enrollment.student_id'; +test('Execute SQL Query with RIGHT JOIN', async () => { + const query = 'SELECT student.name, enrollment.course FROM student RIGHT JOIN enrollment ON student.id=enrollment.student_id'; const result = await executeSELECTQuery(query); expect(result).toEqual(expect.arrayContaining([ - expect.objectContaining({ "student.name": "Alice", "enrollment.course": null }), + expect.objectContaining({ "enrollment.course": "Mathematics", "student.name": "John" }), expect.objectContaining({ "student.name": "John", "enrollment.course": "Mathematics" }) ])); - expect(result.length).toEqual(5); // 4 students, but John appears twice -}); \ No newline at end of file + expect(result.length).toEqual(5); // 4 courses, but Mathematics appears twice +}); diff --git a/tests/step-10/index.test.js b/tests/step-10/index.test.js index 5e118eda5..9270417d6 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'); @@ -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,12 +268,15 @@ test('Parse SQL Query', () => { joinType: null, groupByFields: null, hasAggregateWithoutGroupBy: false, + "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', @@ -287,12 +290,15 @@ test('Parse SQL Query with WHERE Clause', () => { joinType: null, groupByFields: null, hasAggregateWithoutGroupBy: false, + "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', @@ -310,12 +316,15 @@ test('Parse SQL Query with Multiple WHERE Clauses', () => { joinType: null, groupByFields: null, hasAggregateWithoutGroupBy: false, + "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', @@ -325,12 +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, + 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', @@ -340,6 +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, + isDistinct: false }) }); @@ -387,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', @@ -397,12 +412,15 @@ test('Parse LEFT Join Query Completely', () => { joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, groupByFields: null, hasAggregateWithoutGroupBy: false, + "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', @@ -412,12 +430,15 @@ test('Parse LEFT Join Query Completely', () => { joinCondition: { left: 'student.id', right: 'enrollment.student_id' }, groupByFields: null, hasAggregateWithoutGroupBy: false, + "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" }, @@ -427,12 +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, + 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" }, @@ -442,12 +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, + 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" }, @@ -457,12 +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, + 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" }, @@ -472,13 +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, + 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', @@ -488,13 +521,16 @@ test('Parse COUNT Aggregate Query', () => { "joinCondition": null, "joinTable": null, "joinType": 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', @@ -504,12 +540,15 @@ test('Parse SUM Aggregate Query', () => { "joinCondition": null, "joinTable": null, "joinType": 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', @@ -519,12 +558,15 @@ test('Parse AVG Aggregate Query', () => { "joinCondition": null, "joinTable": null, "joinType": 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', @@ -534,12 +576,15 @@ test('Parse MIN Aggregate Query', () => { "joinCondition": null, "joinTable": null, "joinType": 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', @@ -549,12 +594,15 @@ test('Parse MAX Aggregate Query', () => { "joinCondition": null, "joinTable": null, "joinType": 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', @@ -563,13 +611,16 @@ test('Parse basic GROUP BY query', () => { joinType: null, joinTable: null, joinCondition: null, - hasAggregateWithoutGroupBy: false + hasAggregateWithoutGroupBy: false, + 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', @@ -578,13 +629,16 @@ test('Parse GROUP BY query with WHERE clause', () => { joinType: null, joinTable: null, joinCondition: null, - hasAggregateWithoutGroupBy: false + hasAggregateWithoutGroupBy: false, + 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', @@ -593,13 +647,16 @@ test('Parse GROUP BY query with multiple fields', () => { joinType: null, joinTable: null, joinCondition: null, - hasAggregateWithoutGroupBy: false + hasAggregateWithoutGroupBy: false, + 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', @@ -611,6 +668,9 @@ test('Parse GROUP BY query with JOIN and WHERE clauses', () => { left: 'student.id', right: 'enrollment.student_id' }, - hasAggregateWithoutGroupBy: false + hasAggregateWithoutGroupBy: 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 1cf5f2def..fba535495 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..11e21ad77 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', @@ -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-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..64881ea65 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', @@ -784,4 +784,5 @@ test('DISTINCT with ORDER BY and LIMIT', async () => { const result = await executeSELECTQuery(query); // Expecting the two highest unique ages expect(result).toEqual([{ age: '30' }, { age: '25' }]); -}); \ No newline at end of file +}); + diff --git a/tests/step-15/index.test.js b/tests/step-15/index.test.js index a2aa4daee..677646807 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', 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');