@simplysm/orm-common 13.0.69 → 13.0.70

package/tests/expr/comparison.expected.ts

@@ -0,0 +1,282 @@
+import { mysql, pgsql, tsql, DateTime, DateOnly, Time, Uuid } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+// DateTime 값 테스트용
+export const testDateTime = new DateTime(2024, 1, 15, 10, 30, 0);
+export const testDateOnly = new DateOnly(2024, 1, 15);
+export const testTime = new Time(10, 30, 0);
+export const testUuid = new Uuid("12345678-1234-1234-1234-123456789012");
+
+export const eqNull: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`email\` <=> NULL
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE (([T1].[email] IS NULL AND NULL IS NULL) OR [T1].[email] = NULL)
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."email" IS NOT DISTINCT FROM NULL
+  `,
+};
+
+export const eqValue: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const gt: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` > 20
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] > 20
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" > 20
+  `,
+};
+
+export const lt: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` < 30
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] < 30
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" < 30
+  `,
+};
+
+export const gte: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` >= 18
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] >= 18
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" >= 18
+  `,
+};
+
+export const lte: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` <= 65
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] <= 65
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" <= 65
+  `,
+};
+
+export const between: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` BETWEEN 20 AND 30
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] BETWEEN 20 AND 30
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" BETWEEN 20 AND 30
+  `,
+};
+
+export const betweenFromOnly: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` >= 20
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] >= 20
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" >= 20
+  `,
+};
+
+export const betweenToOnly: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`age\` <= 30
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[age] <= 30
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."age" <= 30
+  `,
+};
+
+export const betweenNone: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE 1=1
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE 1=1
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE TRUE
+  `,
+};
+
+export const betweenColumns: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
+    WHERE \`T1\`.\`feb\` BETWEEN \`T1\`.\`jan\` AND \`T1\`.\`mar\`
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
+    WHERE [T1].[feb] BETWEEN [T1].[jan] AND [T1].[mar]
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."MonthlySales" AS "T1"
+    WHERE "T1"."feb" BETWEEN "T1"."jan" AND "T1"."mar"
+  `,
+};
+
+export const regexpMysqlPostgresql: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`name\` REGEXP '^test.*'
+  `,
+  mssql: tsql``,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."name" ~ '^test.*'
+  `,
+};
+
+export const inEmpty: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE 1=0
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE 1=0
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE FALSE
+  `,
+};
+
+//#region ========== DateTime/DateOnly/Time 값 테스트 ==========
+
+export const eqDateTime: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`createdAt\` <=> '2024-01-15 10:30:00'
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE (([T1].[createdAt] IS NULL AND '2024-01-15 10:30:00' IS NULL) OR [T1].[createdAt] = '2024-01-15 10:30:00')
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."createdAt" IS NOT DISTINCT FROM '2024-01-15 10:30:00'::timestamp
+  `,
+};
+
+//#endregion
+
+//#region ========== inQuery 테스트 ==========
+
+export const inQuery: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`id\` IN (SELECT \`T2\`.\`userId\` AS \`userId\` FROM \`TestDb\`.\`Post\` AS \`T2\`)
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[id] IN (SELECT [T2].[userId] AS [userId] FROM [TestDb].[TestSchema].[Post] AS [T2])
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."id" IN (SELECT "T2"."userId" AS "userId" FROM "TestSchema"."Post" AS "T2")
+  `,
+};
+
+//#endregion

package/tests/expr/comparison.spec.ts

@@ -0,0 +1,400 @@
+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 "./comparison.expected";
+import { DateTime } from "@simplysm/core-common";
+
+describe("Expr - Comparison operators (null-safe)", () => {
+  describe("eq - equality comparison (null == null → true)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.eq(item.email, undefined)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "email"] },
+            target: { type: "value", value: undefined },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.eqNull[dialect]);
+    });
+  });
+
+  describe("eq - value comparison (1 == 1 → true)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.eq(item.id, 1)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.eqValue[dialect]);
+    });
+  });
+
+  describe("gt - greater than comparison", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .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]);
+    });
+  });
+
+  describe("lt - less than comparison", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .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]);
+    });
+  });
+
+  describe("gte - greater than or equal comparison", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .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]);
+    });
+  });
+
+  describe("lte - less than or equal comparison", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .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]);
+    });
+  });
+
+  describe("between - range comparison", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.between(item.age, 20, 30)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "between",
+            source: { type: "column", path: ["T1", "age"] },
+            from: { type: "value", value: 20 },
+            to: { type: "value", value: 30 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.between[dialect]);
+    });
+  });
+
+  describe("between - only from present (>= handling)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.between(item.age, 20, undefined)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "between",
+            source: { type: "column", path: ["T1", "age"] },
+            from: { type: "value", value: 20 },
+            to: undefined,
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.betweenFromOnly[dialect]);
+    });
+  });
+
+  describe("between - only to present (<= handling)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .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]);
+    });
+  });
+
+  describe("between - both absent (always true)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.between(item.age, undefined, undefined)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "between",
+            source: { type: "column", path: ["T1", "age"] },
+            from: undefined,
+            to: undefined,
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.betweenNone[dialect]);
+    });
+  });
+
+  describe("between - using column references for from/to", () => {
+    const db = createTestDb();
+    const def = db
+      .monthlySales()
+      .where((item) => [expr.between(item.feb, item.jan, item.mar)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "between",
+            source: { type: "column", path: ["T1", "feb"] },
+            from: { type: "column", path: ["T1", "jan"] },
+            to: { type: "column", path: ["T1", "mar"] },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.betweenColumns[dialect]);
+    });
+  });
+
+  describe("regexp - regex comparison (MySQL/PostgreSQL)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.regexp(item.name, "^test.*")])
+      .getSelectQueryDef();
+
+    it.each(["mysql", "postgresql"] as const)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.regexpMysqlPostgresql[dialect]);
+    });
+  });
+
+  describe("in - empty array (always false)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.in(item.id, [])])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "in",
+            source: { type: "column", path: ["T1", "id"] },
+            values: [],
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.inEmpty[dialect]);
+    });
+  });
+
+  //#region ========== DateTime 값 테스트 ==========
+
+  describe("eq - DateTime value comparison", () => {
+    const db = createTestDb();
+    const testDateTime = new DateTime(2024, 1, 15, 10, 30, 0);
+    const def = db
+      .user()
+      .where((item) => [expr.eq(item.createdAt, testDateTime)])
+      .getSelectQueryDef();
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.eqDateTime[dialect]);
+    });
+  });
+
+  //#endregion
+
+  //#region ========== inQuery 테스트 ==========
+
+  describe("inQuery - subquery IN condition", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((u) => [
+        expr.inQuery(
+          u.id,
+          db.post().select((p) => ({ userId: p.userId })),
+        ),
+      ])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toMatchObject({
+        type: "select",
+        where: [
+          {
+            type: "inQuery",
+            source: { type: "column", path: ["T1", "id"] },
+            query: {
+              type: "select",
+              select: {
+                userId: { type: "column", path: ["T2", "userId"] },
+              },
+            },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.inQuery[dialect]);
+    });
+  });
+
+  //#endregion
+});