@simplysm/orm-common 13.0.68 → 13.0.70

package/tests/examples/unpivot.expected.ts

@@ -0,0 +1,120 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== UNPIVOT - Basic ==========
+
+export const unpivotBasic: ExpectedSql = {
+  mysql: mysql`
+SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
+  \`T1.unpvt\`.\`month\` AS \`month\`, \`T1.unpvt\`.\`amount\` AS \`amount\`
+FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS \`month\`, \`T1\`.\`jan\` AS \`amount\`
+  UNION ALL
+  SELECT 'feb' AS \`month\`, \`T1\`.\`feb\` AS \`amount\`
+  UNION ALL
+  SELECT 'mar' AS \`month\`, \`T1\`.\`mar\` AS \`amount\`
+) AS \`T1.unpvt\` ON TRUE
+  `,
+  mssql: tsql`
+SELECT [T1].[id] AS [id], [T1].[category] AS [category],
+  [T1.unpvt].[month] AS [month], [T1.unpvt].[amount] AS [amount]
+FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
+OUTER APPLY (
+  SELECT N'jan' AS [month], [T1].[jan] AS [amount]
+  UNION ALL
+  SELECT N'feb' AS [month], [T1].[feb] AS [amount]
+  UNION ALL
+  SELECT N'mar' AS [month], [T1].[mar] AS [amount]
+) AS [T1.unpvt]
+  `,
+  postgresql: pgsql`
+SELECT "T1"."id" AS "id", "T1"."category" AS "category",
+  "T1.unpvt"."month" AS "month", "T1.unpvt"."amount" AS "amount"
+FROM "TestSchema"."MonthlySales" AS "T1"
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS "month", "T1"."jan" AS "amount"
+  UNION ALL
+  SELECT 'feb' AS "month", "T1"."feb" AS "amount"
+  UNION ALL
+  SELECT 'mar' AS "month", "T1"."mar" AS "amount"
+) AS "T1.unpvt" ON TRUE
+  `,
+};
+
+export const unpivotTwoColumns: ExpectedSql = {
+  mysql: mysql`
+SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`, \`T1\`.\`mar\` AS \`mar\`,
+  \`T1.unpvt\`.\`period\` AS \`period\`, \`T1.unpvt\`.\`value\` AS \`value\`
+FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS \`period\`, \`T1\`.\`jan\` AS \`value\`
+  UNION ALL
+  SELECT 'feb' AS \`period\`, \`T1\`.\`feb\` AS \`value\`
+) AS \`T1.unpvt\` ON TRUE
+  `,
+  mssql: tsql`
+SELECT [T1].[id] AS [id], [T1].[category] AS [category], [T1].[mar] AS [mar],
+  [T1.unpvt].[period] AS [period], [T1.unpvt].[value] AS [value]
+FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
+OUTER APPLY (
+  SELECT N'jan' AS [period], [T1].[jan] AS [value]
+  UNION ALL
+  SELECT N'feb' AS [period], [T1].[feb] AS [value]
+) AS [T1.unpvt]
+  `,
+  postgresql: pgsql`
+SELECT "T1"."id" AS "id", "T1"."category" AS "category", "T1"."mar" AS "mar",
+  "T1.unpvt"."period" AS "period", "T1.unpvt"."value" AS "value"
+FROM "TestSchema"."MonthlySales" AS "T1"
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS "period", "T1"."jan" AS "value"
+  UNION ALL
+  SELECT 'feb' AS "period", "T1"."feb" AS "value"
+) AS "T1.unpvt" ON TRUE
+  `,
+};
+
+export const unpivotWithWhere: ExpectedSql = {
+  mysql: mysql`
+SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
+  \`T1.unpvt\`.\`month\` AS \`month\`, \`T1.unpvt\`.\`amount\` AS \`amount\`
+FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS \`month\`, \`T1\`.\`jan\` AS \`amount\`
+  UNION ALL
+  SELECT 'feb' AS \`month\`, \`T1\`.\`feb\` AS \`amount\`
+  UNION ALL
+  SELECT 'mar' AS \`month\`, \`T1\`.\`mar\` AS \`amount\`
+) AS \`T1.unpvt\` ON TRUE
+WHERE \`T1\`.\`category\`<=>'A'
+  `,
+  mssql: tsql`
+SELECT [T1].[id] AS [id], [T1].[category] AS [category],
+  [T1.unpvt].[month] AS [month], [T1.unpvt].[amount] AS [amount]
+FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
+OUTER APPLY (
+  SELECT N'jan' AS [month], [T1].[jan] AS [amount]
+  UNION ALL
+  SELECT N'feb' AS [month], [T1].[feb] AS [amount]
+  UNION ALL
+  SELECT N'mar' AS [month], [T1].[mar] AS [amount]
+) AS [T1.unpvt]
+WHERE (([T1].[category] IS NULL AND N'A' IS NULL) OR [T1].[category] = N'A')
+  `,
+  postgresql: pgsql`
+SELECT "T1"."id" AS "id", "T1"."category" AS "category",
+  "T1.unpvt"."month" AS "month", "T1.unpvt"."amount" AS "amount"
+FROM "TestSchema"."MonthlySales" AS "T1"
+LEFT OUTER JOIN LATERAL (
+  SELECT 'jan' AS "month", "T1"."jan" AS "amount"
+  UNION ALL
+  SELECT 'feb' AS "month", "T1"."feb" AS "amount"
+  UNION ALL
+  SELECT 'mar' AS "month", "T1"."mar" AS "amount"
+) AS "T1.unpvt" ON TRUE
+WHERE "T1"."category" IS NOT DISTINCT FROM 'A'
+  `,
+};
+
+//#endregion

package/tests/examples/unpivot.spec.ts

@@ -0,0 +1,226 @@
+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 "./unpivot.expected";
+
+describe("SELECT - UNPIVOT (join + union)", () => {
+  describe("Basic", () => {
+    const db = createTestDb();
+    const def = db
+      .monthlySales()
+      .join("unpvt", (qr, c) =>
+        qr.union(
+          qr.select({ month: expr.val("string", "jan"), amount: c.jan }),
+          qr.select({ month: expr.val("string", "feb"), amount: c.feb }),
+          qr.select({ month: expr.val("string", "mar"), amount: c.mar }),
+        ),
+      )
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        month: item.unpvt![0].month,
+        amount: item.unpvt![0].amount,
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          month: { type: "column", path: ["T1.unpvt", "month"] },
+          amount: { type: "column", path: ["T1.unpvt", "amount"] },
+        },
+        joins: [
+          {
+            type: "select",
+            as: "T1.unpvt",
+            from: [
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "jan" },
+                  amount: { type: "column", path: ["T1", "jan"] },
+                },
+              },
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "feb" },
+                  amount: { type: "column", path: ["T1", "feb"] },
+                },
+              },
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "mar" },
+                  amount: { type: "column", path: ["T1", "mar"] },
+                },
+              },
+            ],
+            isSingle: false,
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unpivotBasic[dialect]);
+    });
+  });
+
+  describe("2-column unpivot", () => {
+    const db = createTestDb();
+    const def = db
+      .monthlySales()
+      .join("unpvt", (qr, c) =>
+        qr.union(
+          qr.select({ period: expr.val("string", "jan"), value: c.jan }),
+          qr.select({ period: expr.val("string", "feb"), value: c.feb }),
+        ),
+      )
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        mar: item.mar,
+        period: item.unpvt![0].period,
+        value: item.unpvt![0].value,
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          mar: { type: "column", path: ["T1", "mar"] },
+          period: { type: "column", path: ["T1.unpvt", "period"] },
+          value: { type: "column", path: ["T1.unpvt", "value"] },
+        },
+        joins: [
+          {
+            type: "select",
+            as: "T1.unpvt",
+            from: [
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  period: { type: "value", value: "jan" },
+                  value: { type: "column", path: ["T1", "jan"] },
+                },
+              },
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  period: { type: "value", value: "feb" },
+                  value: { type: "column", path: ["T1", "feb"] },
+                },
+              },
+            ],
+            isSingle: false,
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unpivotTwoColumns[dialect]);
+    });
+  });
+
+  describe("WHERE -> UNPIVOT", () => {
+    const db = createTestDb();
+    const def = db
+      .monthlySales()
+      .where((r) => [expr.eq(r.category, "A")])
+      .join("unpvt", (qr, c) =>
+        qr.union(
+          qr.select({ month: expr.val("string", "jan"), amount: c.jan }),
+          qr.select({ month: expr.val("string", "feb"), amount: c.feb }),
+          qr.select({ month: expr.val("string", "mar"), amount: c.mar }),
+        ),
+      )
+      .select((item) => ({
+        id: item.id,
+        category: item.category,
+        month: item.unpvt![0].month,
+        amount: item.unpvt![0].amount,
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "category"] },
+            target: { type: "value", value: "A" },
+          },
+        ],
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          category: { type: "column", path: ["T1", "category"] },
+          month: { type: "column", path: ["T1.unpvt", "month"] },
+          amount: { type: "column", path: ["T1.unpvt", "amount"] },
+        },
+        joins: [
+          {
+            type: "select",
+            as: "T1.unpvt",
+            from: [
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "jan" },
+                  amount: { type: "column", path: ["T1", "jan"] },
+                },
+              },
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "feb" },
+                  amount: { type: "column", path: ["T1", "feb"] },
+                },
+              },
+              {
+                type: "select",
+                as: "T1.unpvt",
+                select: {
+                  month: { type: "value", value: "mar" },
+                  amount: { type: "column", path: ["T1", "mar"] },
+                },
+              },
+            ],
+            isSingle: false,
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unpivotWithWhere[dialect]);
+    });
+  });
+});

package/tests/exec/search-parser.spec.ts

@@ -0,0 +1,283 @@
+import { describe, expect, it } from "vitest";
+import { parseSearchQuery } from "../../src/exec/search-parser";
+
+describe("parseSearchQuery", () => {
+  //#region ========== Basic behavior ==========
+
+  describe("Basic behavior", () => {
+    it("Empty string → empty result", () => {
+      expect(parseSearchQuery("")).toEqual({ or: [], must: [], not: [] });
+      expect(parseSearchQuery("   ")).toEqual({ or: [], must: [], not: [] });
+    });
+
+    it("Single word → add LIKE pattern to or array", () => {
+      expect(parseSearchQuery("Apple")).toEqual({
+        or: ["%Apple%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("Multiple words (space separated) → OR condition", () => {
+      expect(parseSearchQuery("사과 바나나")).toEqual({
+        or: ["%사과%", "%바나나%"],
+        must: [],
+        not: [],
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== Prefixes ==========
+
+  describe("Prefixes", () => {
+    it("+ prefix → must (AND condition)", () => {
+      expect(parseSearchQuery("+사과")).toEqual({
+        or: [],
+        must: ["%사과%"],
+        not: [],
+      });
+    });
+
+    it("- prefix → not (NOT condition)", () => {
+      expect(parseSearchQuery("-바나나")).toEqual({
+        or: [],
+        must: [],
+        not: ["%바나나%"],
+      });
+    });
+
+    it("Mixed prefixes", () => {
+      expect(parseSearchQuery("사과 +딸기 -바나나")).toEqual({
+        or: ["%사과%"],
+        must: ["%딸기%"],
+        not: ["%바나나%"],
+      });
+    });
+
+    it("Multiple identical prefixes", () => {
+      expect(parseSearchQuery("+사과 +바나나")).toEqual({
+        or: [],
+        must: ["%사과%", "%바나나%"],
+        not: [],
+      });
+    });
+
+    it("Ignore when only prefixes present", () => {
+      expect(parseSearchQuery("+ - ")).toEqual({ or: [], must: [], not: [] });
+      expect(parseSearchQuery("+ 사과")).toEqual({ or: ["%사과%"], must: [], not: [] });
+    });
+
+    it("Consecutive prefixes", () => {
+      // First prefix is processed, remaining are included as literal
+      expect(parseSearchQuery("++term")).toEqual({
+        or: [],
+        must: ["%+term%"], // + prefix processed, "+term" remains as literal including +
+        not: [],
+      });
+      expect(parseSearchQuery("--word")).toEqual({
+        or: [],
+        must: [],
+        not: ["%-word%"], // - prefix processed, "-word" remains as literal including -
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== Quotes ==========
+
+  describe("Quotes", () => {
+    it("Quoted phrase → must (exact match)", () => {
+      expect(parseSearchQuery('"Delicious Fruit"')).toEqual({
+        or: [],
+        must: ["%Delicious Fruit%"],
+        not: [],
+      });
+    });
+
+    it("+quote → must", () => {
+      expect(parseSearchQuery('+"Delicious Fruit"')).toEqual({
+        or: [],
+        must: ["%Delicious Fruit%"],
+        not: [],
+      });
+    });
+
+    it("-quote → not", () => {
+      expect(parseSearchQuery('-"Delicious Fruit"')).toEqual({
+        or: [],
+        must: [],
+        not: ["%Delicious Fruit%"],
+      });
+    });
+
+    it("Ignore empty quotes", () => {
+      expect(parseSearchQuery('""')).toEqual({ or: [], must: [], not: [] });
+      expect(parseSearchQuery('"  "')).toEqual({ or: [], must: [], not: [] });
+    });
+
+    it("Mix quotes and regular words", () => {
+      expect(parseSearchQuery('사과 "Delicious Fruit" 바나나')).toEqual({
+        or: ["%사과%", "%바나나%"],
+        must: ["%Delicious Fruit%"],
+        not: [],
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== Wildcards ==========
+
+  describe("Wildcards", () => {
+    it("* at start → search by suffix", () => {
+      expect(parseSearchQuery("*사과")).toEqual({
+        or: ["%사과"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("* at end → search by prefix", () => {
+      expect(parseSearchQuery("사과*")).toEqual({
+        or: ["사과%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("* on both sides → contains search (explicit)", () => {
+      expect(parseSearchQuery("*사과*")).toEqual({
+        or: ["%사과%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("* in middle → middle wildcard", () => {
+      expect(parseSearchQuery("사*과")).toEqual({
+        or: ["사%과"],
+        must: [],
+        not: [],
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== Escaping ==========
+
+  describe("Escaping", () => {
+    it("\\* → literal *", () => {
+      expect(parseSearchQuery("app\\*test")).toEqual({
+        or: ["%app*test%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("\\% → SQL LIKE \\%", () => {
+      expect(parseSearchQuery("100\\%")).toEqual({
+        or: ["%100\\%%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it('\\" → literal "', () => {
+      expect(parseSearchQuery('\\"test\\"')).toEqual({
+        or: ['%"test"%'],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("\\+ → literal + (not prefix)", () => {
+      expect(parseSearchQuery("\\+positive")).toEqual({
+        or: ["%+positive%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("\\- → literal - (not prefix)", () => {
+      expect(parseSearchQuery("\\-negative")).toEqual({
+        or: ["%-negative%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("\\\\ → literal \\", () => {
+      expect(parseSearchQuery("path\\\\to\\\\file")).toEqual({
+        or: ["%path\\\\to\\\\file%"],
+        must: [],
+        not: [],
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== SQL special characters ==========
+
+  describe("SQL special character escaping", () => {
+    it("_ → \\_ (SQL LIKE escape)", () => {
+      expect(parseSearchQuery("file_name")).toEqual({
+        or: ["%file\\_name%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("% → \\% (SQL LIKE escape)", () => {
+      expect(parseSearchQuery("100%")).toEqual({
+        or: ["%100\\%%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("[ → \\[ (SQL LIKE escape)", () => {
+      expect(parseSearchQuery("array[0]")).toEqual({
+        or: ["%array\\[0]%"],
+        must: [],
+        not: [],
+      });
+    });
+  });
+
+  //#endregion
+
+  //#region ========== Complex search ==========
+
+  describe("Complex search", () => {
+    it("TSDoc example: normal + quote + exclude + required", () => {
+      expect(parseSearchQuery('사과 "Delicious Fruit" -바나나 +딸기')).toEqual({
+        or: ["%사과%"],
+        must: ["%Delicious Fruit%", "%딸기%"],
+        not: ["%바나나%"],
+      });
+    });
+
+    it("Mix wildcards and regular words", () => {
+      expect(parseSearchQuery("app* test")).toEqual({
+        or: ["app%", "%test%"],
+        must: [],
+        not: [],
+      });
+    });
+
+    it("Mix all elements", () => {
+      expect(parseSearchQuery('*start end* +must -not "exact phrase"')).toEqual({
+        or: ["%start", "end%"],
+        must: ["%exact phrase%", "%must%"],
+        not: ["%not%"],
+      });
+    });
+  });
+
+  //#endregion
+});

package/tests/executable/basic.expected.ts

@@ -0,0 +1,18 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== Procedure Execution ==========
+
+export const execProcNoParams: ExpectedSql = {
+  mysql: mysql`CALL \`TestDb\`.\`GetUserById\`()`,
+  mssql: tsql`EXEC [TestDb].[TestSchema].[GetUserById]`,
+  postgresql: pgsql`SELECT "TestSchema"."GetUserById"()`,
+};
+
+export const execProcWithParams: ExpectedSql = {
+  mysql: mysql`CALL \`TestDb\`.\`GetUserById\`(123)`,
+  mssql: tsql`EXEC [TestDb].[TestSchema].[GetUserById] 123`,
+  postgresql: pgsql`SELECT "TestSchema"."GetUserById"(123)`,
+};
+
+//#endregion

package/tests/executable/basic.spec.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import "../setup/test-utils";
+import * as expected from "./basic.expected";
+
+describe("Executable - Basic", () => {
+  describe("getExecProcQueryDef - without parameters", () => {
+    const db = createTestDb();
+    const def = db.getUserById().getExecProcQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "execProc",
+        procedure: {
+          database: "TestDb",
+          schema: "TestSchema",
+          name: "GetUserById",
+        },
+        params: undefined,
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.execProcNoParams[dialect]);
+    });
+  });
+
+  describe("getExecProcQueryDef - with parameters", () => {
+    const db = createTestDb();
+    const def = db.getUserById().getExecProcQueryDef({ userId: 123 });
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "execProc",
+        procedure: {
+          database: "TestDb",
+          schema: "TestSchema",
+          name: "GetUserById",
+        },
+        params: {
+          userId: { type: "value", value: 123 },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.execProcWithParams[dialect]);
+    });
+  });
+});