@simplysm/orm-common 13.0.69 → 13.0.70

package/tests/select/group.expected.ts

@@ -0,0 +1,169 @@
+/**
+ * SELECT - GROUP BY / HAVING test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== GROUP BY ==========
+
+export const groupSingle: ExpectedSql = {
+  mysql: mysql`
+    SELECT \`T1\`.\`name\` AS \`name\`, COUNT(\`T1\`.\`id\`) AS \`cnt\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`
+  `,
+  mssql: tsql`
+    SELECT [T1].[name] AS [name], COUNT([T1].[id]) AS [cnt]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name]
+  `,
+  postgresql: pgsql`
+    SELECT "T1"."name" AS "name", COUNT("T1"."id") AS "cnt"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name"
+  `,
+};
+
+export const groupMultiple: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`name\` AS \`name\`,
+      \`T1\`.\`isActive\` AS \`isActive\`,
+      COUNT(\`T1\`.\`id\`) AS \`cnt\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`, \`T1\`.\`isActive\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[name] AS [name],
+      [T1].[isActive] AS [isActive],
+      COUNT([T1].[id]) AS [cnt]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name], [T1].[isActive]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."name" AS "name",
+      "T1"."isActive" AS "isActive",
+      COUNT("T1"."id") AS "cnt"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name", "T1"."isActive"
+  `,
+};
+
+export const groupAggregate: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`name\` AS \`name\`,
+      COUNT(\`T1\`.\`id\`) AS \`cnt\`,
+      SUM(\`T1\`.\`age\`) AS \`sumAge\`,
+      AVG(\`T1\`.\`age\`) AS \`avgAge\`,
+      MIN(\`T1\`.\`age\`) AS \`minAge\`,
+      MAX(\`T1\`.\`age\`) AS \`maxAge\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[name] AS [name],
+      COUNT([T1].[id]) AS [cnt],
+      SUM([T1].[age]) AS [sumAge],
+      AVG([T1].[age]) AS [avgAge],
+      MIN([T1].[age]) AS [minAge],
+      MAX([T1].[age]) AS [maxAge]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."name" AS "name",
+      COUNT("T1"."id") AS "cnt",
+      SUM("T1"."age") AS "sumAge",
+      AVG("T1"."age") AS "avgAge",
+      MIN("T1"."age") AS "minAge",
+      MAX("T1"."age") AS "maxAge"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name"
+  `,
+};
+
+//#endregion
+
+//#region ========== HAVING ==========
+
+export const havingSingle: ExpectedSql = {
+  mysql: mysql`
+    SELECT \`T1\`.\`name\` AS \`name\`, COUNT(\`T1\`.\`id\`) AS \`cnt\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`
+    HAVING COUNT(\`T1\`.\`id\`) > 5
+  `,
+  mssql: tsql`
+    SELECT [T1].[name] AS [name], COUNT([T1].[id]) AS [cnt]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name]
+    HAVING COUNT([T1].[id]) > 5
+  `,
+  postgresql: pgsql`
+    SELECT "T1"."name" AS "name", COUNT("T1"."id") AS "cnt"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name"
+    HAVING COUNT("T1"."id") > 5
+  `,
+};
+
+export const havingMultiple: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`name\` AS \`name\`,
+      COUNT(\`T1\`.\`id\`) AS \`cnt\`,
+      AVG(\`T1\`.\`age\`) AS \`avgAge\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`
+    HAVING COUNT(\`T1\`.\`id\`) > 5 AND AVG(\`T1\`.\`age\`) >= 25
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[name] AS [name],
+      COUNT([T1].[id]) AS [cnt],
+      AVG([T1].[age]) AS [avgAge]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name]
+    HAVING COUNT([T1].[id]) > 5 AND AVG([T1].[age]) >= 25
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."name" AS "name",
+      COUNT("T1"."id") AS "cnt",
+      AVG("T1"."age") AS "avgAge"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name"
+    HAVING COUNT("T1"."id") > 5 AND AVG("T1"."age") >= 25
+  `,
+};
+
+export const havingOrderCombo: ExpectedSql = {
+  mysql: mysql`
+    SELECT \`T1\`.\`name\` AS \`name\`, COUNT(\`T1\`.\`id\`) AS \`cnt\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    GROUP BY \`T1\`.\`name\`
+    HAVING COUNT(\`T1\`.\`id\`) > 1
+    ORDER BY COUNT(\`T1\`.\`id\`) DESC
+  `,
+  mssql: tsql`
+    SELECT [T1].[name] AS [name], COUNT([T1].[id]) AS [cnt]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    GROUP BY [T1].[name]
+    HAVING COUNT([T1].[id]) > 1
+    ORDER BY COUNT([T1].[id]) DESC
+  `,
+  postgresql: pgsql`
+    SELECT "T1"."name" AS "name", COUNT("T1"."id") AS "cnt"
+    FROM "TestSchema"."User" AS "T1"
+    GROUP BY "T1"."name"
+    HAVING COUNT("T1"."id") > 1
+    ORDER BY COUNT("T1"."id") DESC
+  `,
+};
+
+//#endregion

package/tests/select/group.spec.ts

@@ -0,0 +1,244 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { expr } from "../../src/expr/expr";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import * as expected from "./group.expected";
+
+describe("SELECT - GROUP BY", () => {
+  //#region ========== Basic GROUP BY ==========
+
+  describe("single column", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+      }))
+      .groupBy((item) => [item.name])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+        },
+        groupBy: [{ type: "column", path: ["T1", "name"] }],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.groupSingle[dialect]);
+    });
+  });
+
+  describe("multiple columns", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        isActive: item.isActive,
+        cnt: expr.count(item.id),
+      }))
+      .groupBy((item) => [item.name, item.isActive])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          isActive: { type: "column", path: ["T1", "isActive"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+        },
+        groupBy: [
+          { type: "column", path: ["T1", "name"] },
+          { type: "column", path: ["T1", "isActive"] },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.groupMultiple[dialect]);
+    });
+  });
+
+  describe("aggregate functions", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+        sumAge: expr.sum(item.age),
+        avgAge: expr.avg(item.age),
+        minAge: expr.min(item.age),
+        maxAge: expr.max(item.age),
+      }))
+      .groupBy((item) => [item.name])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+          sumAge: { type: "sum", arg: { type: "column", path: ["T1", "age"] } },
+          avgAge: { type: "avg", arg: { type: "column", path: ["T1", "age"] } },
+          minAge: { type: "min", arg: { type: "column", path: ["T1", "age"] } },
+          maxAge: { type: "max", arg: { type: "column", path: ["T1", "age"] } },
+        },
+        groupBy: [{ type: "column", path: ["T1", "name"] }],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.groupAggregate[dialect]);
+    });
+  });
+
+  //#endregion
+});
+
+describe("SELECT - HAVING", () => {
+  //#region ========== HAVING ==========
+
+  describe("single condition", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+      }))
+      .groupBy((item) => [item.name])
+      .having((item) => [expr.gt(item.cnt, 5)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+        },
+        groupBy: [{ type: "column", path: ["T1", "name"] }],
+        having: [
+          {
+            type: "gt",
+            source: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+            target: { type: "value", value: 5 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.havingSingle[dialect]);
+    });
+  });
+
+  describe("multiple conditions", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+        avgAge: expr.avg(item.age),
+      }))
+      .groupBy((item) => [item.name])
+      .having((item) => [expr.gt(item.cnt, 5), expr.gte(item.avgAge, 25)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+          avgAge: { type: "avg", arg: { type: "column", path: ["T1", "age"] } },
+        },
+        groupBy: [{ type: "column", path: ["T1", "name"] }],
+        having: [
+          {
+            type: "gt",
+            source: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+            target: { type: "value", value: 5 },
+          },
+          {
+            type: "gte",
+            source: { type: "avg", arg: { type: "column", path: ["T1", "age"] } },
+            target: { type: "value", value: 25 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.havingMultiple[dialect]);
+    });
+  });
+
+  describe("GROUP BY + HAVING + ORDER BY combination", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+      }))
+      .groupBy((item) => [item.name])
+      .having((item) => [expr.gt(item.cnt, 1)])
+      .orderBy((item) => item.cnt, "DESC")
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          name: { type: "column", path: ["T1", "name"] },
+          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+        },
+        groupBy: [{ type: "column", path: ["T1", "name"] }],
+        having: [
+          {
+            type: "gt",
+            source: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
+            target: { type: "value", value: 1 },
+          },
+        ],
+        orderBy: [[{ type: "count", arg: { type: "column", path: ["T1", "id"] } }, "DESC"]],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.havingOrderCombo[dialect]);
+    });
+  });
+
+  //#endregion
+});