@simplysm/orm-common 13.0.75 → 13.0.77

package/tests/examples/sampling.spec.ts

@@ -39,67 +39,4 @@ describe("EXAMPLE - Random sampling", () => {
     });
   });
 
-  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]);
-    });
-  });
 });

package/tests/examples/unpivot.spec.ts

@@ -79,71 +79,6 @@ describe("SELECT - UNPIVOT (join + union)", () => {
     });
   });
 
-  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

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

@@ -56,14 +56,6 @@ describe("parseSearchQuery", () => {
       });
     });
 
-    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: [] });
@@ -148,14 +140,6 @@ describe("parseSearchQuery", () => {
       });
     });
 
-    it("* on both sides → contains search (explicit)", () => {
-      expect(parseSearchQuery("*사과*")).toEqual({
-        or: ["%사과%"],
-        must: [],
-        not: [],
-      });
-    });
-
     it("* in middle → middle wildcard", () => {
       expect(parseSearchQuery("사*과")).toEqual({
         or: ["사%과"],

package/tests/expr/comparison.spec.ts

@@ -69,19 +69,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.gt(item.age, 20)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "gt",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 20 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.gt[dialect]);
@@ -95,19 +82,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.lt(item.age, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "lt",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lt[dialect]);
@@ -121,19 +95,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.gte(item.age, 18)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "gte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 18 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.gte[dialect]);
@@ -147,19 +108,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.lte(item.age, 65)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "lte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 65 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lte[dialect]);
@@ -227,20 +175,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.between(item.age, undefined, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "age"] },
-            from: undefined,
-            to: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.betweenToOnly[dialect]);

package/tests/expr/conditional.expected.ts

@@ -1,7 +1,7 @@
 import { mysql, pgsql, tsql } from "@simplysm/core-common";
 import type { ExpectedSql } from "../setup/test-utils";
 
-export const ifNull: ExpectedSql = {
+export const coalesce: ExpectedSql = {
   mysql: mysql`
     SELECT COALESCE(\`T1\`.\`name\`, 'Unknown') AS \`nameOrDefault\`
     FROM \`TestDb\`.\`User\` AS \`T1\`
@@ -118,7 +118,7 @@ export const least: ExpectedSql = {
   `,
 };
 
-export const ifNullMultiple: ExpectedSql = {
+export const coalesceMultiple: ExpectedSql = {
   mysql: mysql`
     SELECT COALESCE(\`T1\`.\`email\`, \`T1\`.\`name\`, 'Anonymous') AS \`firstValid\`
     FROM \`TestDb\`.\`User\` AS \`T1\`

package/tests/expr/conditional.spec.ts

@@ -7,19 +7,19 @@ import "../setup/test-utils"; // toMatchSql matcher
 import * as expected from "./conditional.expected";
 
 describe("Expr - Conditional functions", () => {
-  describe("ifNull - null replacement", () => {
+  describe("coalesce - null replacement", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        nameOrDefault: expr.ifNull(item.name, "Unknown"),
+        nameOrDefault: expr.coalesce(item.name, "Unknown"),
       }))
       .getSelectQueryDef();
 
     it("Verify QueryDef", () => {
       expect(def.select).toMatchObject({
         nameOrDefault: {
-          type: "ifNull",
+          type: "coalesce",
           args: [
             { type: "column", path: ["T1", "name"] },
             { type: "value", value: "Unknown" },
@@ -30,7 +30,7 @@ describe("Expr - Conditional functions", () => {
 
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ifNull[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.coalesce[dialect]);
     });
   });
 
@@ -190,33 +190,6 @@ describe("Expr - Conditional functions", () => {
     });
   });
 
-  describe("least - minimum value", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        minVal: expr.least(item.age, 100),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        minVal: {
-          type: "least",
-          args: expect.arrayContaining([
-            { type: "column", path: ["T1", "age"] },
-            { type: "value", value: 100 },
-          ]),
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.least[dialect]);
-    });
-  });
-
   describe("switch - all case/default are undefined", () => {
     it("throws an error", () => {
       const db = createTestDb();
@@ -246,19 +219,19 @@ describe("Expr - Conditional functions", () => {
     });
   });
 
-  describe("ifNull - create COALESCE with 3+ arguments", () => {
+  describe("coalesce - create COALESCE with 3+ arguments", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        firstValid: expr.ifNull(item.email, item.name, "Anonymous"),
+        firstValid: expr.coalesce(item.email, item.name, "Anonymous"),
       }))
       .getSelectQueryDef();
 
     it("Verify QueryDef", () => {
       expect(def.select).toMatchObject({
         firstValid: {
-          type: "ifNull",
+          type: "coalesce",
           args: [
             { type: "column", path: ["T1", "email"] },
             { type: "column", path: ["T1", "name"] },
@@ -270,7 +243,7 @@ describe("Expr - Conditional functions", () => {
 
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ifNullMultiple[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.coalesceMultiple[dialect]);
     });
   });
 });

package/tests/expr/date.spec.ts

@@ -41,15 +41,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        monthPart: {
-          type: "month",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.month[dialect]);
@@ -65,15 +56,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        dayPart: {
-          type: "day",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.day[dialect]);
@@ -89,15 +71,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        hourPart: {
-          type: "hour",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.hour[dialect]);
@@ -113,15 +86,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        minutePart: {
-          type: "minute",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.minute[dialect]);
@@ -137,15 +101,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        secondPart: {
-          type: "second",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.second[dialect]);
@@ -166,7 +121,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         daysDiff: {
           type: "dateDiff",
-          separator: "day",
+          unit: "day",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -189,17 +144,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        yearsDiff: {
-          type: "dateDiff",
-          separator: "year",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.dateDiffYear[dialect]);
@@ -216,17 +160,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        monthsDiff: {
-          type: "dateDiff",
-          separator: "month",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.dateDiffMonth[dialect]);
@@ -247,7 +180,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         hoursDiff: {
           type: "dateDiff",
-          separator: "hour",
+          unit: "hour",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -274,7 +207,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         minutesDiff: {
           type: "dateDiff",
-          separator: "minute",
+          unit: "minute",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -301,7 +234,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         secondsDiff: {
           type: "dateDiff",
-          separator: "second",
+          unit: "second",
           from: { type: "column", path: ["T1", "createdAt"] },
           to: { type: "value", value: targetDate },
         },
@@ -327,7 +260,7 @@ describe("Expr - Date/Time functions", () => {
       expect(def.select).toMatchObject({
         nextMonth: {
           type: "dateAdd",
-          separator: "month",
+          unit: "month",
           source: { type: "column", path: ["T1", "createdAt"] },
           value: { type: "value", value: 1 },
         },

package/tests/expr/math.spec.ts

@@ -56,51 +56,4 @@ describe("Expr - Math functions", () => {
     });
   });
 
-  describe("ceil - ceiling", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        ceiled: expr.ceil(item.age),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        ceiled: {
-          type: "ceil",
-          arg: { type: "column", path: ["T1", "age"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ceil[dialect]);
-    });
-  });
-
-  describe("floor - flooring", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        floored: expr.floor(item.age),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        floored: {
-          type: "floor",
-          arg: { type: "column", path: ["T1", "age"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.floor[dialect]);
-    });
-  });
 });

package/tests/expr/string.spec.ts

@@ -68,15 +68,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        byteLen: {
-          type: "byteLength",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.byteLength[dialect]);
@@ -117,16 +108,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        suffix: {
-          type: "right",
-          source: { type: "column", path: ["T1", "name"] },
-          length: { type: "value", value: 3 },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.right[dialect]);
@@ -142,15 +123,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        trimmed: {
-          type: "trim",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.trim[dialect]);
@@ -218,15 +190,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        upper: {
-          type: "upper",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.upper[dialect]);
@@ -242,15 +205,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        lower: {
-          type: "lower",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lower[dialect]);
@@ -338,16 +292,6 @@ describe("Expr - String functions", () => {
       .where((item) => [expr.like(item.name, "%\\%%")])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.where).toEqual([
-        {
-          type: "like",
-          source: { type: "column", path: ["T1", "name"] },
-          pattern: { type: "value", value: "%\\%%" },
-        },
-      ]);
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.likeEscape[dialect]);