@simplysm/orm-common 13.0.100 → 14.0.1

package/tests/errors/queryable-errors.spec.ts

@@ -1,126 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { Queryable } from "../../src/exec/queryable";
-import { createQueryBuilder } from "../../src/query-builder/query-builder";
-import { expr } from "../../src/expr/expr";
-
-describe("Queryable error cases", () => {
-  describe("expr.and()/expr.or() errors", () => {
-    it("ArgumentError when calling and() with empty array", () => {
-      expect(() => expr.and([])).toThrow("empty arrays are not allowed");
-    });
-
-  });
-
-  describe("executable errors", () => {
-    it("Error when passing parameters to procedure without parameters", () => {
-      const db = createTestDb();
-      expect(() => {
-        // @ts-expect-error - test passing parameters to a procedure that expects none
-        db.getAllUsers().getExecProcQueryDef({ unexpectedParam: 1 });
-      }).toThrow("has no parameters.");
-    });
-  });
-
-  describe("include() errors", () => {
-    it("Error when including non-existent relation", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        // @ts-expect-error - non-existent relation test
-        db.user().include((item) => item.nonExistentRelation);
-      }).toThrow("Relation 'nonExistentRelation' not found.");
-    });
-
-    it("Error when calling include on ViewBuilder-based queryable", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        // @ts-expect-error - ViewBuilder has no relations, include not supported
-        db.activeUsers().include((item) => item.someRelation);
-      }).toThrow("include() can only be used on TableBuilder-based queryables.");
-    });
-  });
-
-  describe("union() errors", () => {
-    it("Error when calling union with a single queryable", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        Queryable.union(db.user());
-      }).toThrow("union requires at least 2 queryables.");
-    });
-  });
-
-  describe("limit() errors", () => {
-    it("Error when calling limit without ORDER BY", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.user().limit(0, 10);
-      }).toThrow("limit() requires ORDER BY clause.");
-    });
-  });
-
-  describe("regexp() errors", () => {
-    it("Error when using regexp in MSSQL", () => {
-      const db = createTestDb();
-      const def = db
-        .user()
-        .where((item) => [expr.regexp(item.name, "^test.*")])
-        .getSelectQueryDef();
-
-      const builder = createQueryBuilder("mssql");
-      expect(() => {
-        builder.build(def);
-      }).toThrow("MSSQL does not natively support REGEXP.");
-    });
-  });
-
-  describe("inQuery() errors", () => {
-    it("Error when using multi-column subquery", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.user()
-          .where((u) => [
-            expr.inQuery(
-              u.id,
-              // @ts-expect-error - multi-column subquery
-              db.post().select((p) => ({ userId: p.userId, title: p.title })),
-            ),
-          ])
-          .getSelectQueryDef();
-      }).toThrow("inQuery subquery must SELECT only a single column.");
-    });
-
-  });
-
-  describe("countAsync() errors", () => {
-    it("Error when calling directly after distinct()", async () => {
-      const db = createTestDb();
-
-      await expect(
-        db
-          .user()
-          .select((u) => ({ name: u.name }))
-          .distinct()
-          .count(),
-      ).rejects.toThrow(
-        "Cannot use count() after distinct(). Use wrap() first.",
-      );
-    });
-
-    it("Error when calling directly after groupBy()", async () => {
-      const db = createTestDb();
-
-      await expect(
-        db
-          .user()
-          .groupBy((u) => [u.name])
-          .count(),
-      ).rejects.toThrow("Cannot use count() after groupBy(). Use wrap() first.");
-    });
-  });
-
-});

package/tests/escape.spec.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { MysqlExprRenderer } from "../src/query-builder/mysql/mysql-expr-renderer";
-
-describe("MysqlExprRenderer.escapeString", () => {
-  const renderer = new MysqlExprRenderer(() => "");
-
-  //#region ========== Basic Escaping ==========
-
-  it("should escape quotes", () => {
-    const result = renderer.escapeString("O'Reilly");
-    expect(result).toBe("O''Reilly");
-  });
-
-  it("should escape backslashes", () => {
-    const result = renderer.escapeString("C:\\path");
-    expect(result).toBe("C:\\\\path");
-  });
-
-  it("should escape NULL bytes", () => {
-    const result = renderer.escapeString("admin\0--");
-    expect(result).toBe("admin\\0--");
-  });
-
-  //#endregion
-
-  //#region ========== Combined Attack Test ==========
-
-  it("should defend against backslash + quote combination", () => {
-    const malicious = "\\'";
-    const result = renderer.escapeString(malicious);
-    expect(result).toBe("\\\\''");
-  });
-
-  //#endregion
-});
-
-describe("MysqlExprRenderer.escapeValue", () => {
-  const renderer = new MysqlExprRenderer(() => "");
-
-  it("escapes string with escapeString() and wraps in quotes", () => {
-    const result = renderer.escapeValue("O'Reilly");
-    expect(result).toBe("'O''Reilly'");
-  });
-
-  it("returns 'NULL' string for null", () => {
-    const result = renderer.escapeValue(null);
-    expect(result).toBe("NULL");
-  });
-
-  it("converts number to string", () => {
-    const result = renderer.escapeValue(123);
-    expect(result).toBe("123");
-  });
-
-  it("converts boolean to TRUE/FALSE", () => {
-    expect(renderer.escapeValue(true)).toBe("TRUE");
-    expect(renderer.escapeValue(false)).toBe("FALSE");
-  });
-});

package/tests/examples/pivot.expected.ts

@@ -1,211 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-//#region ========== PIVOT - Basic Aggregate Functions ==========
-
-export const pivotSum: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  SUM(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  SUM(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-export const pivotCount: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  COUNT(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  COUNT(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  COUNT(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  COUNT(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  COUNT(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  COUNT(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-export const pivotAvg: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  AVG(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  AVG(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  AVG(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  AVG(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  AVG(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  AVG(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-export const pivotMax: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  MAX(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  MAX(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  MAX(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  MAX(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  MAX(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  MAX(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-export const pivotMin: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  MIN(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  MIN(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  MIN(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  MIN(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  MIN(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  MIN(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-//#endregion
-
-//#region ========== PIVOT - Multiple Pivot Values ==========
-
-export const pivotMultipleYears: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  SUM(IF(\`T1\`.\`year\`<=>2019,\`T1\`.\`amount\`,NULL)) AS \`y2019\`,
-  SUM(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  SUM(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`,
-  SUM(IF(\`T1\`.\`year\`<=>2022,\`T1\`.\`amount\`,NULL)) AS \`y2022\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2019 IS NULL) OR [T1].[year] = 2019) THEN [T1].[amount] ELSE NULL END) AS [y2019],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2022 IS NULL) OR [T1].[year] = 2022) THEN [T1].[amount] ELSE NULL END) AS [y2022]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2019 THEN "T1"."amount" ELSE NULL END) AS "y2019",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2022 THEN "T1"."amount" ELSE NULL END) AS "y2022"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-export const pivotStringColumn: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`year\` AS \`year\`,
-  SUM(IF(\`T1\`.\`category\`<=>'Food',\`T1\`.\`amount\`,NULL)) AS \`food\`,
-  SUM(IF(\`T1\`.\`category\`<=>'Electronics',\`T1\`.\`amount\`,NULL)) AS \`electronics\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`year\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[year] AS [year],
-  SUM(CASE WHEN (([T1].[category] IS NULL AND N'Food' IS NULL) OR [T1].[category] = N'Food') THEN [T1].[amount] ELSE NULL END) AS [food],
-  SUM(CASE WHEN (([T1].[category] IS NULL AND N'Electronics' IS NULL) OR [T1].[category] = N'Electronics') THEN [T1].[amount] ELSE NULL END) AS [electronics]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-GROUP BY [T1].[id], [T1].[year]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."year" AS "year",
-  SUM(CASE WHEN "T1"."category" IS NOT DISTINCT FROM 'Food' THEN "T1"."amount" ELSE NULL END) AS "food",
-  SUM(CASE WHEN "T1"."category" IS NOT DISTINCT FROM 'Electronics' THEN "T1"."amount" ELSE NULL END) AS "electronics"
-FROM "TestSchema"."Sales" AS "T1"
-GROUP BY "T1"."id", "T1"."year"
-  `,
-};
-
-export const pivotWithWhere: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  SUM(IF(\`T1\`.\`year\`<=>2020,\`T1\`.\`amount\`,NULL)) AS \`y2020\`,
-  SUM(IF(\`T1\`.\`year\`<=>2021,\`T1\`.\`amount\`,NULL)) AS \`y2021\`
-FROM \`TestDb\`.\`Sales\` AS \`T1\`
-WHERE \`T1\`.\`category\`<=>'Food'
-GROUP BY \`T1\`.\`id\`, \`T1\`.\`category\`
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2020 IS NULL) OR [T1].[year] = 2020) THEN [T1].[amount] ELSE NULL END) AS [y2020],
-  SUM(CASE WHEN (([T1].[year] IS NULL AND 2021 IS NULL) OR [T1].[year] = 2021) THEN [T1].[amount] ELSE NULL END) AS [y2021]
-FROM [TestDb].[TestSchema].[Sales] AS [T1]
-WHERE (([T1].[category] IS NULL AND N'Food' IS NULL) OR [T1].[category] = N'Food')
-GROUP BY [T1].[id], [T1].[category]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2020 THEN "T1"."amount" ELSE NULL END) AS "y2020",
-  SUM(CASE WHEN "T1"."year" IS NOT DISTINCT FROM 2021 THEN "T1"."amount" ELSE NULL END) AS "y2021"
-FROM "TestSchema"."Sales" AS "T1"
-WHERE "T1"."category" IS NOT DISTINCT FROM 'Food'
-GROUP BY "T1"."id", "T1"."category"
-  `,
-};
-
-//#endregion

package/tests/examples/pivot.spec.ts

@@ -1,200 +0,0 @@
-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("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

@@ -1,69 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-//#region ========== Random Sampling ==========
-
-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