diff --git a/tests/step-03/index.test.js b/tests/step-03/index.test.js index 946727ebf..d3896e9fc 100644 --- a/tests/step-03/index.test.js +++ b/tests/step-03/index.test.js @@ -1,5 +1,5 @@ -const readCSV = require("../../src/csvReader"); -const { parseQuery } = require("../../src/queryParser"); +const { readCSV } = require("../../src/csvReader"); +const { parseSelectQuery } = require("../../src/queryParser"); test("Read CSV File", async () => { const data = await readCSV("./student.csv"); @@ -11,18 +11,18 @@ 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: [], - joinType: null, + isDistinct: false, joinCondition: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinTable: null, + joinType: null, + limit: null, + whereClauses: [], }); }); - -test("Invalid Query Format", () => { - const query = "SELECT id, name"; - expect(() => parseQuery(query)).toThrow(); -}); diff --git a/tests/step-04/index.test.js b/tests/step-04/index.test.js index 7e02e405c..9ee7dde9d 100644 --- a/tests/step-04/index.test.js +++ b/tests/step-04/index.test.js @@ -1,6 +1,6 @@ -const readCSV = require("../../src/csvReader"); -const { 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,14 +12,19 @@ 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: [], - joinType: null, joinCondition: null, + groupByFields: null, + limit: null, + isDistinct: false, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinTable: null, + joinType: null, + whereClauses: [], }); }); diff --git a/tests/step-05/index.test.js b/tests/step-05/index.test.js index 1ea8cd00e..a4596a3c1 100644 --- a/tests/step-05/index.test.js +++ b/tests/step-05/index.test.js @@ -1,6 +1,6 @@ -const readCSV = require("../../src/csvReader"); -const { 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,14 +12,19 @@ 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: [], - joinType: null, joinCondition: null, joinTable: null, + isDistinct: false, + limit: null, + joinType: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + whereClauses: [], }); }); @@ -34,29 +39,37 @@ 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 query = "SELECT id, name FROM student WHERE age = 30 AND name = John"; + const parsed = parseSelectQuery(query); expect(parsed).toEqual({ fields: ["id", "name"], table: "student", + joinCondition: null, + joinTable: null, + limit: null, + isDistinct: false, + joinType: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, whereClauses: [ { field: "age", operator: "=", - value: "25", + value: "30", + }, + { + field: "name", + operator: "=", + value: "John", }, ], - joinType: null, - joinCondition: null, - joinTable: null, }); }); test("Execute SQL Query with WHERE Clause", async () => { - const query = "SELECT id, name FROM student WHERE age = 25"; + const query = "SELECT id, name FROM student WHERE age = 30 AND name = John"; 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"); + expect(result[0]).toEqual({ id: "1", name: "John" }); }); diff --git a/tests/step-06/index.test.js b/tests/step-06/index.test.js index 8933fce58..50ca76587 100644 --- a/tests/step-06/index.test.js +++ b/tests/step-06/index.test.js @@ -1,6 +1,6 @@ -const readCSV = require("../../src/csvReader"); -const { 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,14 +12,19 @@ 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: [], - joinType: null, joinCondition: null, + isDistinct: false, joinTable: null, + limit: null, + joinType: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + whereClauses: [], }); }); @@ -35,10 +40,18 @@ 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", + isDistinct: false, + joinCondition: null, + joinTable: null, + joinType: null, + limit: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, whereClauses: [ { field: "age", @@ -46,9 +59,6 @@ test("Parse SQL Query with WHERE Clause", () => { value: "25", }, ], - joinType: null, - joinCondition: null, - joinTable: null, }); }); @@ -63,10 +73,18 @@ 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", + isDistinct: false, + joinCondition: null, + joinTable: null, + joinType: null, + limit: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, whereClauses: [ { field: "age", @@ -79,9 +97,6 @@ test("Parse SQL Query with Multiple WHERE Clauses", () => { value: "John", }, ], - joinType: null, - joinCondition: null, - joinTable: null, }); }); diff --git a/tests/step-07/index.test.js b/tests/step-07/index.test.js index 5a22db3de..496c43a5b 100644 --- a/tests/step-07/index.test.js +++ b/tests/step-07/index.test.js @@ -1,6 +1,6 @@ -const readCSV = require("../../src/csvReader"); -const { 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"); @@ -10,19 +10,6 @@ test("Read CSV File", async () => { 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); - expect(parsed).toEqual({ - fields: ["id", "name"], - table: "student", - whereClauses: [], - joinType: null, - joinCondition: null, - joinTable: null, - }); -}); - test("Execute SQL Query", async () => { const query = "SELECT id, name FROM student"; const result = await executeSELECTQuery(query); @@ -33,25 +20,6 @@ test("Execute SQL Query", async () => { expect(result[0]).toEqual({ id: "1", name: "John" }); }); -test("Parse SQL Query with WHERE Clause", () => { - const query = "SELECT id, name FROM student WHERE age = 25"; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ["id", "name"], - table: "student", - whereClauses: [ - { - field: "age", - operator: "=", - value: "25", - }, - ], - joinType: null, - joinCondition: null, - joinTable: null, - }); -}); - test("Execute SQL Query with WHERE Clause", async () => { const query = "SELECT id, name FROM student WHERE age = 25"; const result = await executeSELECTQuery(query); @@ -61,30 +29,6 @@ test("Execute SQL Query with WHERE Clause", async () => { expect(result[0].id).toBe("2"); }); -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); - expect(parsed).toEqual({ - fields: ["id", "name"], - table: "student", - whereClauses: [ - { - field: "age", - operator: "=", - value: "30", - }, - { - field: "name", - operator: "=", - value: "John", - }, - ], - joinType: null, - joinCondition: null, - joinTable: null, - }); -}); - test("Execute SQL Query with Multiple WHERE Clause", async () => { const query = "SELECT id, name FROM student WHERE age = 30 AND name = John"; const result = await executeSELECTQuery(query); @@ -105,3 +49,44 @@ test("Execute SQL Query with Not Equal to", async () => { expect(result.length).toEqual(3); expect(result[0]).toHaveProperty("name"); }); +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", + isDistinct: false, + whereClauses: [ + { + field: "age", + operator: "=", + value: "25", + }, + ], + joinCondition: null, + groupByFields: null, + limit: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + joinTable: null, + joinType: null, + }); +}); diff --git a/tests/step-08/index.test.js b/tests/step-08/index.test.js index a359d7e26..df470b1dd 100644 --- a/tests/step-08/index.test.js +++ b/tests/step-08/index.test.js @@ -1,6 +1,6 @@ -const readCSV = require("../../src/csvReader"); -const { 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,14 +12,19 @@ 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", + isDistinct: false, whereClauses: [], - joinType: null, joinCondition: null, + limit: null, joinTable: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + joinType: null, }); }); @@ -35,7 +40,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,9 +51,14 @@ test("Parse SQL Query with WHERE Clause", () => { value: "25", }, ], - joinType: null, + isDistinct: false, joinCondition: null, joinTable: null, + limit: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + joinType: null, }); }); @@ -63,10 +73,12 @@ 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", + limit: null, + isDistinct: false, whereClauses: [ { field: "age", @@ -79,9 +91,12 @@ test("Parse SQL Query with Multiple WHERE Clauses", () => { value: "John", }, ], - joinType: null, joinCondition: null, joinTable: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, + joinType: null, }); }); @@ -109,13 +124,18 @@ 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: [], - joinType: null, joinTable: "enrollment", + joinType: "INNER", + limit: null, + isDistinct: false, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinCondition: { left: "student.id", right: "enrollment.student_id" }, }); }); @@ -123,13 +143,18 @@ 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", whereClauses: [{ field: "student.age", operator: ">", value: "20" }], - joinType: null, joinTable: "enrollment", + joinType: "INNER", + groupByFields: null, + limit: null, + orderByFields: null, + isDistinct: false, + hasAggregateWithoutGroupBy: false, joinCondition: { left: "student.id", right: "enrollment.student_id" }, }); }); @@ -138,14 +163,6 @@ 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( @@ -160,20 +177,6 @@ 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( diff --git a/tests/step-09/index.test.js b/tests/step-09/index.test.js index fbd3802ee..348fbbc79 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,13 +12,18 @@ 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, + limit: null, + groupByFields: null, + orderByFields: null, + isDistinct: false, + hasAggregateWithoutGroupBy: false, joinType: null, }); }); @@ -35,10 +40,11 @@ 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", + isDistinct: false, whereClauses: [ { field: "age", @@ -48,6 +54,10 @@ test("Parse SQL Query with WHERE Clause", () => { ], joinCondition: null, joinTable: null, + groupByFields: null, + limit: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinType: null, }); }); @@ -63,10 +73,11 @@ 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", + isDistinct: false, whereClauses: [ { field: "age", @@ -80,7 +91,11 @@ test("Parse SQL Query with Multiple WHERE Clauses", () => { }, ], joinCondition: null, + limit: null, joinTable: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinType: null, }); }); @@ -109,12 +124,17 @@ 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: [], + isDistinct: false, joinTable: "enrollment", + groupByFields: null, + orderByFields: null, + limit: null, + hasAggregateWithoutGroupBy: false, joinCondition: { left: "student.id", right: "enrollment.student_id" }, joinType: "INNER", }); @@ -123,12 +143,17 @@ 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", whereClauses: [{ field: "student.age", operator: ">", value: "20" }], joinTable: "enrollment", + groupByFields: null, + isDistinct: false, + limit: null, + orderByFields: null, + hasAggregateWithoutGroupBy: false, joinCondition: { left: "student.id", right: "enrollment.student_id" }, joinType: "INNER", }); diff --git a/tests/step-10/index.test.js b/tests/step-10/index.test.js index 5e118eda5..c7af02a24 100644 --- a/tests/step-10/index.test.js +++ b/tests/step-10/index.test.js @@ -1,59 +1,60 @@ -const readCSV = require('../../src/csvReader'); -const {parseQuery, parseJoinClause} = 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('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); - /* +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"); + 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("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' }, @@ -61,18 +62,21 @@ test('Execute SQL Query with INNER JOIN', async () => { { '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" - })); + 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); - /* +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', @@ -86,531 +90,658 @@ test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => { } ] */ - 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('Parse SQL Query', () => { - const query = 'SELECT id, name FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['id', 'name'], - table: 'student', - whereClauses: [], - joinCondition: null, - joinTable: null, - joinType: null, - groupByFields: null, - hasAggregateWithoutGroupBy: false, - }); -}); - -test('Parse SQL Query with WHERE Clause', () => { - const query = 'SELECT id, name FROM student WHERE age = 25'; - const parsed = parseQuery(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, - }); -}); - -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); - 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, - }); -}); - -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); - 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, - }) -}); - -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); - 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, + 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("Parse SQL Query", () => { + const query = "SELECT id, name FROM student"; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ["id", "name"], + table: "student", + isDistinct: false, + whereClauses: [], + joinCondition: null, + joinTable: null, + joinType: null, + limit: null, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: 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", + isDistinct: false, + whereClauses: [ + { + field: "age", + operator: "=", + value: "25", + }, + ], + joinCondition: null, + joinTable: null, + joinType: null, + limit: null, + orderByFields: null, + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + isDistinct: false, + whereClauses: [ + { + field: "age", + operator: "=", + value: "30", + }, + { + field: "name", + operator: "=", + value: "John", + }, + ], + joinCondition: null, + joinTable: null, + limit: null, + orderByFields: null, + joinType: null, + groupByFields: null, + hasAggregateWithoutGroupBy: 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: [], + isDistinct: false, + limit: null, + joinTable: "enrollment", + joinType: "INNER", + joinCondition: { left: "student.id", right: "enrollment.student_id" }, + groupByFields: null, + orderByFields: null, + hasAggregateWithoutGroupBy: 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", + isDistinct: false, + joinCondition: { left: "student.id", right: "enrollment.student_id" }, + groupByFields: null, + orderByFields: null, + limit: null, + hasAggregateWithoutGroupBy: 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", + orderByFields: null, + limit: null, + isDistinct: false, + joinTable: "enrollment", + joinCondition: { left: "student.id", right: "enrollment.student_id" }, + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + isDistinct: false, + orderByFields: null, + limit: null, + joinTable: "enrollment", + joinCondition: { left: "student.id", right: "enrollment.student_id" }, + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + limit: null, + joinType: "LEFT", + isDistinct: false, + orderByFields: null, + table: "student", + whereClauses: [{ field: "student.age", operator: ">", value: "22" }], + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + limit: null, + joinType: "LEFT", + orderByFields: null, + isDistinct: false, + table: "student", + limit: null, + whereClauses: [ + { field: "enrollment.course", operator: "=", value: "'Physics'" }, + ], + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + limit: null, + isDistinct: false, + joinType: "RIGHT", + orderByFields: null, + table: "student", + limit: null, + whereClauses: [{ field: "student.age", operator: "<", value: "25" }], + groupByFields: null, + hasAggregateWithoutGroupBy: 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", + limit: null, + joinType: "RIGHT", + isDistinct: false, + table: "student", + limit: null, + orderByFields: null, + whereClauses: [ + { field: "enrollment.course", operator: "=", value: "'Chemistry'" }, + ], + groupByFields: null, + hasAggregateWithoutGroupBy: false, + }); +}); + +test("Parse COUNT Aggregate Query", () => { + const query = "SELECT COUNT(*) FROM student"; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ["COUNT(*)"], + table: "student", + isDistinct: false, + whereClauses: [], + groupByFields: null, + orderByFields: null, + limit: null, + hasAggregateWithoutGroupBy: true, + joinCondition: null, + joinTable: null, + joinType: null, + }); +}); + +test("Parse SUM Aggregate Query", () => { + const query = "SELECT SUM(age) FROM student"; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ["SUM(age)"], + table: "student", + isDistinct: false, + whereClauses: [], + groupByFields: null, + limit: null, + orderByFields: null, + hasAggregateWithoutGroupBy: true, + joinCondition: null, + joinTable: null, + joinType: null, + }); +}); + +test("Parse AVG Aggregate Query", () => { + const query = "SELECT AVG(age) FROM student"; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ["AVG(age)"], + table: "student", + orderByFields: null, + isDistinct: false, + whereClauses: [], + groupByFields: null, + hasAggregateWithoutGroupBy: true, + limit: null, + joinCondition: null, + joinTable: null, + joinType: null, + }); +}); + +test("Parse MIN Aggregate Query", () => { + const query = "SELECT MIN(age) FROM student"; + const parsed = parseSelectQuery(query); + expect(parsed).toEqual({ + fields: ["MIN(age)"], + table: "student", + orderByFields: null, + whereClauses: [], + isDistinct: false, + limit: null, + groupByFields: null, + hasAggregateWithoutGroupBy: true, + joinCondition: null, + joinTable: null, + joinType: null, + }); +}); + +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: [], + orderByFields: null, + isDistinct: false, + limit: null, + groupByFields: null, + hasAggregateWithoutGroupBy: true, + joinCondition: null, + joinTable: null, + joinType: null, + }); +}); + +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, + isDistinct: false, + limit: null, + orderByFields: null, + joinTable: null, + joinCondition: null, + hasAggregateWithoutGroupBy: 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, + isDistinct: false, + limit: null, + orderByFields: null, + joinCondition: null, + hasAggregateWithoutGroupBy: 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, + orderByFields: null, + isDistinct: false, + limit: null, + joinCondition: null, + hasAggregateWithoutGroupBy: 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", + limit: null, + whereClauses: [ + { field: "enrollment.course", operator: "=", value: '"Mathematics"' }, + ], + groupByFields: ["student.name"], + joinType: "INNER", + joinTable: "enrollment", + orderByFields: null, + isDistinct: false, + joinCondition: { + left: "student.id", + right: "enrollment.student_id", + }, + hasAggregateWithoutGroupBy: 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 = parseQuery(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, - }) -}) - -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); - 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, - }) -}) - -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); - 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, - }); -}); - -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); - 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, - }); -}); - -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); - 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, - }); -}); - -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); - 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, - }); -}); - - -test('Parse COUNT Aggregate Query', () => { - const query = 'SELECT COUNT(*) FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['COUNT(*)'], - table: 'student', - whereClauses: [], - groupByFields: null, - hasAggregateWithoutGroupBy: true, - "joinCondition": null, - "joinTable": null, - "joinType": null, - }); -}); - - -test('Parse SUM Aggregate Query', () => { - const query = 'SELECT SUM(age) FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['SUM(age)'], - table: 'student', - whereClauses: [], - groupByFields: null, - hasAggregateWithoutGroupBy: true, - "joinCondition": null, - "joinTable": null, - "joinType": null, - }); -}); - -test('Parse AVG Aggregate Query', () => { - const query = 'SELECT AVG(age) FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['AVG(age)'], - table: 'student', - whereClauses: [], - groupByFields: null, - hasAggregateWithoutGroupBy: true, - "joinCondition": null, - "joinTable": null, - "joinType": null, - }); -}); - -test('Parse MIN Aggregate Query', () => { - const query = 'SELECT MIN(age) FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['MIN(age)'], - table: 'student', - whereClauses: [], - groupByFields: null, - hasAggregateWithoutGroupBy: true, - "joinCondition": null, - "joinTable": null, - "joinType": null, - }); -}); - -test('Parse MAX Aggregate Query', () => { - const query = 'SELECT MAX(age) FROM student'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['MAX(age)'], - table: 'student', - whereClauses: [], - groupByFields: null, - hasAggregateWithoutGroupBy: true, - "joinCondition": null, - "joinTable": null, - "joinType": null, - }); -}); - -test('Parse basic GROUP BY query', () => { - const query = 'SELECT age, COUNT(*) FROM student GROUP BY age'; - const parsed = parseQuery(query); - expect(parsed).toEqual({ - fields: ['age', 'COUNT(*)'], - table: 'student', - whereClauses: [], - groupByFields: ['age'], - joinType: null, - joinTable: null, - joinCondition: null, - hasAggregateWithoutGroupBy: 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); - expect(parsed).toEqual({ - fields: ['age', 'COUNT(*)'], - table: 'student', - whereClauses: [{ field: 'age', operator: '>', value: '22' }], - groupByFields: ['age'], - joinType: null, - joinTable: null, - joinCondition: null, - hasAggregateWithoutGroupBy: 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); - expect(parsed).toEqual({ - fields: ['student_id', 'course', 'COUNT(*)'], - table: 'enrollment', - whereClauses: [], - groupByFields: ['student_id', 'course'], - joinType: null, - joinTable: null, - joinCondition: null, - hasAggregateWithoutGroupBy: 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); - 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 - }); -}); \ No newline at end of file