@simplysm/orm-common 13.0.69 → 13.0.71

package/tests/expr/conditional.expected.ts

@@ -0,0 +1,134 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+export const ifNull: ExpectedSql = {
+  mysql: mysql`
+    SELECT COALESCE(\`T1\`.\`name\`, 'Unknown') AS \`nameOrDefault\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT COALESCE([T1].[name], N'Unknown') AS [nameOrDefault]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT COALESCE("T1"."name", 'Unknown') AS "nameOrDefault"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const nullIf: ExpectedSql = {
+  mysql: mysql`
+    SELECT NULLIF(\`T1\`.\`age\`, 0) AS \`checkedAge\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT NULLIF([T1].[age], 0) AS [checkedAge]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT NULLIF("T1"."age", 0) AS "checkedAge"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const ifCond: ExpectedSql = {
+  mysql: mysql`
+    SELECT IF(\`T1\`.\`isActive\` <=> TRUE, 'Active', 'Inactive') AS \`status\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT CASE WHEN (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1) THEN N'Active' ELSE N'Inactive' END AS [status]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT CASE WHEN "T1"."isActive" IS NOT DISTINCT FROM TRUE THEN 'Active' ELSE 'Inactive' END AS "status"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const switchCase: ExpectedSql = {
+  mysql: mysql`
+    SELECT CASE
+      WHEN \`T1\`.\`age\` < 20 THEN 'Teen'
+      WHEN \`T1\`.\`age\` < 40 THEN 'Adult'
+      ELSE 'Senior'
+    END AS \`ageGroup\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT CASE
+      WHEN [T1].[age] < 20 THEN N'Teen'
+      WHEN [T1].[age] < 40 THEN N'Adult'
+      ELSE N'Senior'
+    END AS [ageGroup]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT CASE
+      WHEN "T1"."age" < 20 THEN 'Teen'
+      WHEN "T1"."age" < 40 THEN 'Adult'
+      ELSE 'Senior'
+    END AS "ageGroup"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const isExpr: ExpectedSql = {
+  mysql: mysql`
+    SELECT (\`T1\`.\`isActive\` <=> TRUE) AS \`isActiveFlag\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT CASE WHEN (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1) THEN 1 ELSE 0 END AS [isActiveFlag]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT ("T1"."isActive" IS NOT DISTINCT FROM TRUE)::INTEGER AS "isActiveFlag"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const greatest: ExpectedSql = {
+  mysql: mysql`
+    SELECT GREATEST(\`T1\`.\`age\`, 18) AS \`maxVal\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT (SELECT MAX(v) FROM (VALUES ([T1].[age]), (18)) AS t(v)) AS [maxVal]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT GREATEST("T1"."age", 18) AS "maxVal"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const least: ExpectedSql = {
+  mysql: mysql`
+    SELECT LEAST(\`T1\`.\`age\`, 100) AS \`minVal\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT (SELECT MIN(v) FROM (VALUES ([T1].[age]), (100)) AS t(v)) AS [minVal]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT LEAST("T1"."age", 100) AS "minVal"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const ifNullMultiple: ExpectedSql = {
+  mysql: mysql`
+    SELECT COALESCE(\`T1\`.\`email\`, \`T1\`.\`name\`, 'Anonymous') AS \`firstValid\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT COALESCE([T1].[email], [T1].[name], N'Anonymous') AS [firstValid]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT COALESCE("T1"."email", "T1"."name", 'Anonymous') AS "firstValid"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};

package/tests/expr/conditional.spec.ts

@@ -0,0 +1,276 @@
+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"; // toMatchSql matcher
+import * as expected from "./conditional.expected";
+
+describe("Expr - Conditional functions", () => {
+  describe("ifNull - null replacement", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        nameOrDefault: expr.ifNull(item.name, "Unknown"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        nameOrDefault: {
+          type: "ifNull",
+          args: [
+            { type: "column", path: ["T1", "name"] },
+            { type: "value", value: "Unknown" },
+          ],
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.ifNull[dialect]);
+    });
+  });
+
+  describe("nullIf - null if value equals", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        checkedAge: expr.nullIf(item.age, 0),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        checkedAge: {
+          type: "nullIf",
+          source: { type: "column", path: ["T1", "age"] },
+          value: { type: "value", value: 0 },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.nullIf[dialect]);
+    });
+  });
+
+  describe("if - conditional branching", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        status: expr.if(expr.eq(item.isActive, true), "Active", "Inactive"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        status: {
+          type: "if",
+          condition: {
+            type: "eq",
+            source: { type: "column", path: ["T1", "isActive"] },
+            target: { type: "value", value: true },
+          },
+          then: { type: "value", value: "Active" },
+          else: { type: "value", value: "Inactive" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.ifCond[dialect]);
+    });
+  });
+
+  describe("switch - CASE WHEN", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        ageGroup: expr
+          .switch()
+          .case(expr.lt(item.age, 20), "Teen")
+          .case(expr.lt(item.age, 40), "Adult")
+          .default("Senior"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        ageGroup: {
+          type: "switch",
+          cases: expect.arrayContaining([
+            {
+              when: {
+                type: "lt",
+                source: { type: "column", path: ["T1", "age"] },
+                target: { type: "value", value: 20 },
+              },
+              then: { type: "value", value: "Teen" },
+            },
+            {
+              when: {
+                type: "lt",
+                source: { type: "column", path: ["T1", "age"] },
+                target: { type: "value", value: 40 },
+              },
+              then: { type: "value", value: "Adult" },
+            },
+          ]),
+          else: { type: "value", value: "Senior" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.switchCase[dialect]);
+    });
+  });
+
+  describe("is - convert condition to boolean", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        isActiveFlag: expr.is(expr.eq(item.isActive, true)),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        isActiveFlag: {
+          type: "is",
+          condition: {
+            type: "eq",
+            source: { type: "column", path: ["T1", "isActive"] },
+            target: { type: "value", value: true },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.isExpr[dialect]);
+    });
+  });
+
+  describe("greatest - maximum value", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        maxVal: expr.greatest(item.age, 18),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        maxVal: {
+          type: "greatest",
+          args: expect.arrayContaining([
+            { type: "column", path: ["T1", "age"] },
+            { type: "value", value: 18 },
+          ]),
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.greatest[dialect]);
+    });
+  });
+
+  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();
+      expect(() => {
+        db.user()
+          .select((item) => ({
+            result: expr
+              .switch<string | undefined>()
+              .case(expr.gt(item.age, 20), undefined)
+              .default(undefined),
+          }))
+          .getSelectQueryDef();
+      }).toThrow("At least one of switch's case/default must be non-null.");
+    });
+  });
+
+  describe("if - both then and else are undefined", () => {
+    it("throws an error", () => {
+      const db = createTestDb();
+      expect(() => {
+        db.user()
+          .select((item) => ({
+            result: expr.if<string | undefined>(expr.gt(item.age, 20), undefined, undefined),
+          }))
+          .getSelectQueryDef();
+      }).toThrow("At least one of if's then/else must be non-null.");
+    });
+  });
+
+  describe("ifNull - create COALESCE with 3+ arguments", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        firstValid: expr.ifNull(item.email, item.name, "Anonymous"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        firstValid: {
+          type: "ifNull",
+          args: [
+            { type: "column", path: ["T1", "email"] },
+            { type: "column", path: ["T1", "name"] },
+            { type: "value", value: "Anonymous" },
+          ],
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.ifNullMultiple[dialect]);
+    });
+  });
+});