@simplysm/orm-common 13.0.68 → 13.0.70

package/tests/examples/pivot.spec.ts

@@ -0,0 +1,533 @@
+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 "../setup/test-utils";
+import * as expected from "./pivot.expected";
+
+describe("SELECT - PIVOT (groupBy + switch)", () => {
+  describe("Basic (SUM)", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.sum(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.sum(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotSum[dialect]);
+    });
+  });
+
+  describe("COUNT", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.count(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.count(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "count",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "count",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotCount[dialect]);
+    });
+  });
+
+  describe("AVG", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.avg(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.avg(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "avg",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "avg",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotAvg[dialect]);
+    });
+  });
+
+  describe("MAX", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.max(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.max(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "max",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "max",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotMax[dialect]);
+    });
+  });
+
+  describe("MIN", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.min(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.min(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "min",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "min",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotMin[dialect]);
+    });
+  });
+
+  describe("3 or more pivot values", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2019: expr.sum(expr.if(expr.eq(item.year, 2019), item.amount, undefined)),
+        y2020: expr.sum(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.sum(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+        y2022: expr.sum(expr.if(expr.eq(item.year, 2022), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2019: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2019 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2020: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2022: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2022 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotMultipleYears[dialect]);
+    });
+  });
+
+  describe("String pivot column", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .groupBy((item) => [item.id, item.year])
+      .select((item) => ({
+        id: item.id,
+        year: item.year,
+        food: expr.sum(expr.if(expr.eq(item.category, "Food"), item.amount, undefined)),
+        electronics: expr.sum(expr.if(expr.eq(item.category, "Electronics"), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "year"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          year: { type: "column", path: ["T1", "year"] },
+          food: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "category"] },
+                target: { type: "value", value: "Food" },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          electronics: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "category"] },
+                target: { type: "value", value: "Electronics" },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotStringColumn[dialect]);
+    });
+  });
+
+  describe("WHERE -> PIVOT (groupBy)", () => {
+    const db = createTestDb();
+    const def = db
+      .sales()
+      .where((item) => [expr.eq(item.category, "Food")])
+      .groupBy((item) => [item.id, item.category])
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        y2020: expr.sum(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
+        y2021: expr.sum(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "category"] },
+            target: { type: "value", value: "Food" },
+          },
+        ],
+        groupBy: [
+          { type: "column", path: ["T1", "id"] },
+          { type: "column", path: ["T1", "category"] },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          y2020: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2020 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+          y2021: {
+            type: "sum",
+            arg: {
+              type: "if",
+              condition: {
+                type: "eq",
+                source: { type: "column", path: ["T1", "year"] },
+                target: { type: "value", value: 2021 },
+              },
+              then: { type: "column", path: ["T1", "amount"] },
+              else: { type: "value", value: undefined },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.pivotWithWhere[dialect]);
+    });
+  });
+});

package/tests/examples/sampling.expected.ts

@@ -0,0 +1,69 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== 랜덤 샘플링 ==========
+
+export const samplingBasic: ExpectedSql = {
+  mysql: mysql`
+SELECT *
+FROM \`TestDb\`.\`User\` AS \`T1\`
+ORDER BY RAND()
+LIMIT 5
+  `,
+  mssql: tsql`
+SELECT TOP 5 *
+FROM [TestDb].[TestSchema].[User] AS [T1]
+ORDER BY NEWID()
+  `,
+  postgresql: pgsql`
+SELECT *
+FROM "TestSchema"."User" AS "T1"
+ORDER BY RANDOM()
+LIMIT 5
+  `,
+};
+
+export const samplingWithWhere: ExpectedSql = {
+  mysql: mysql`
+SELECT *
+FROM \`TestDb\`.\`User\` AS \`T1\`
+WHERE \`T1\`.\`age\` >= 20
+ORDER BY RAND()
+LIMIT 3
+  `,
+  mssql: tsql`
+SELECT TOP 3 *
+FROM [TestDb].[TestSchema].[User] AS [T1]
+WHERE [T1].[age] >= 20
+ORDER BY NEWID()
+  `,
+  postgresql: pgsql`
+SELECT *
+FROM "TestSchema"."User" AS "T1"
+WHERE "T1"."age" >= 20
+ORDER BY RANDOM()
+LIMIT 3
+  `,
+};
+
+export const samplingWithSelect: ExpectedSql = {
+  mysql: mysql`
+SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`name\` AS \`name\`
+FROM \`TestDb\`.\`User\` AS \`T1\`
+ORDER BY RAND()
+LIMIT 10
+  `,
+  mssql: tsql`
+SELECT TOP 10 [T1].[id] AS [id], [T1].[name] AS [name]
+FROM [TestDb].[TestSchema].[User] AS [T1]
+ORDER BY NEWID()
+  `,
+  postgresql: pgsql`
+SELECT "T1"."id" AS "id", "T1"."name" AS "name"
+FROM "TestSchema"."User" AS "T1"
+ORDER BY RANDOM()
+LIMIT 10
+  `,
+};
+
+//#endregion

package/tests/examples/sampling.spec.ts

@@ -0,0 +1,104 @@
+/**
+ * 랜덤 샘플링 예제
+ *
+ * sample() 메서드 대신 expr.random()과 orderBy/top을 조합하여 랜덤 샘플링 구현
+ *
+ * 사용법: db.user().orderBy(() => expr.random()).top(5)
+ */
+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 "../setup/test-utils";
+import * as expected from "./sampling.expected";
+
+describe("EXAMPLE - Random sampling", () => {
+  describe("Basic sampling (ORDER BY RANDOM + TOP)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .orderBy(() => expr.random())
+      .top(5)
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        orderBy: [[{ type: "random" }]],
+        top: 5,
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.samplingBasic[dialect]);
+    });
+  });
+
+  describe("Conditional sampling (WHERE + ORDER BY RANDOM + TOP)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.gte(item.age, 20)])
+      .orderBy(() => expr.random())
+      .top(3)
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        where: [
+          {
+            type: "gte",
+            source: { type: "column", path: ["T1", "age"] },
+            target: { type: "value", value: 20 },
+          },
+        ],
+        orderBy: [[{ type: "random" }]],
+        top: 3,
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.samplingWithWhere[dialect]);
+    });
+  });
+
+  describe("Column selection with sampling", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        id: item.id,
+        name: item.name,
+      }))
+      .orderBy(() => expr.random())
+      .top(10)
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          name: { type: "column", path: ["T1", "name"] },
+        },
+        orderBy: [[{ type: "random" }]],
+        top: 10,
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.samplingWithSelect[dialect]);
+    });
+  });
+});