@simplysm/orm-common 13.0.68 → 13.0.70

package/tests/dml/update.spec.ts

@@ -0,0 +1,318 @@
+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 "./update.expected";
+
+describe("UPDATE - Basic", () => {
+  describe("simple UPDATE", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef((_e) => ({
+        name: expr.val("string", "new name"),
+      }));
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "new name" },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateSimple[dialect]);
+    });
+  });
+
+  describe("UPDATE multiple columns", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef(() => ({
+        name: expr.val("string", "New Name"),
+        departmentId: expr.val("number", 2),
+      }));
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "New Name" },
+          departmentId: { type: "value", value: 2 },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateMultiCol[dialect]);
+    });
+  });
+
+  describe("UPDATE with literal values (without expr.val)", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef(() => ({
+        name: "New Name",
+        departmentId: 2,
+      }));
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "New Name" },
+          departmentId: { type: "value", value: 2 },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updatePlainValues[dialect]);
+    });
+  });
+
+  describe("UPDATE mixing literal values and expressions", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef((e) => ({
+        name: "New Name",
+        managerId: expr.raw("number")`${e.managerId} + 1`,
+      }));
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "New Name" },
+          managerId: {
+            type: "raw",
+            sql: "$1 + 1",
+            params: [{ type: "column", path: ["T1", "managerId"] }],
+          },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateMixed[dialect]);
+    });
+  });
+
+  describe("UPDATE referencing current values (e.g., count = count + 1)", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef((e) => ({
+        // managerId = managerId + 1 (예시)
+        managerId: expr.raw("number")`${e.managerId} + 1`,
+      }));
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          managerId: {
+            type: "raw",
+            sql: "$1 + 1",
+            params: [{ type: "column", path: ["T1", "managerId"] }],
+          },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateWithRef[dialect]);
+    });
+  });
+
+  describe("Specify output column", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getUpdateQueryDef(
+        () => ({
+          name: expr.val("string", "New Name"),
+        }),
+        ["id", "name"],
+      );
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "New Name" },
+        },
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "id"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+        output: {
+          columns: ["id", "name"],
+          pkColNames: ["id"],
+          aiColName: "id",
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateWithOutput[dialect]);
+    });
+  });
+
+  describe("Limit update count with TOP", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.departmentId, 1)])
+      .top(10)
+      .getUpdateQueryDef(() => ({
+        name: expr.val("string", "New Name"),
+      }));
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "update",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        record: {
+          name: { type: "value", value: "New Name" },
+        },
+        top: 10,
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "departmentId"] },
+            target: { type: "value", value: 1 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.updateWithTop[dialect]);
+    });
+  });
+});
+
+describe("FK switch", () => {
+  describe("FK off", () => {
+    const db = createTestDb();
+
+    const def = db.getSwitchFkQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "Employee" },
+      "off",
+    );
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "switchFk",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        switch: "off",
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.fkOff[dialect]);
+    });
+  });
+
+  describe("FK on", () => {
+    const db = createTestDb();
+
+    const def = db.getSwitchFkQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "Employee" },
+      "on",
+    );
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "switchFk",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        switch: "on",
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.fkOn[dialect]);
+    });
+  });
+});

package/tests/dml/upsert.expected.ts

@@ -0,0 +1,215 @@
+/**
+ * UPSERT test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== UPSERT - Basic ==========
+
+export const upsertSimple: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'new name'
+    WHERE \`T1\`.\`id\` <=> 1;
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`)
+    SELECT 'new name', 1
+    WHERE NOT EXISTS (SELECT * FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1)
+  `,
+  mssql: tsql`
+    MERGE [TestDb].[TestSchema].[Employee] AS [T1]
+    USING (SELECT 1 AS [_]) AS [_src]
+    ON (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+    WHEN MATCHED THEN
+      UPDATE SET [name] = N'new name'
+    WHEN NOT MATCHED THEN
+      INSERT ([name], [departmentId]) VALUES (N'new name', 1);
+  `,
+  postgresql: pgsql`
+    WITH matched AS (
+      SELECT "T1".* FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    ),
+    updated AS (
+      UPDATE "TestSchema"."Employee" AS "T1"
+      SET "name" = 'new name'
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+      RETURNING *
+    ),
+    inserted AS (
+      INSERT INTO "TestSchema"."Employee" ("name", "departmentId")
+      SELECT 'new name', 1
+      WHERE NOT EXISTS (SELECT 1 FROM matched)
+      RETURNING *
+    )
+    SELECT * FROM updated UNION ALL SELECT * FROM inserted
+  `,
+};
+
+export const upsertReuse: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'Gildong Hong', \`T1\`.\`departmentId\` = 2
+    WHERE \`T1\`.\`id\` <=> 1;
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`, \`managerId\`)
+    SELECT 'Gildong Hong', 2, 100
+    WHERE NOT EXISTS (SELECT * FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1)
+  `,
+  mssql: tsql`
+    MERGE [TestDb].[TestSchema].[Employee] AS [T1]
+    USING (SELECT 1 AS [_]) AS [_src]
+    ON (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+    WHEN MATCHED THEN
+      UPDATE SET [name] = N'Gildong Hong', [departmentId] = 2
+    WHEN NOT MATCHED THEN
+      INSERT ([name], [departmentId], [managerId]) VALUES (N'Gildong Hong', 2, 100);
+  `,
+  postgresql: pgsql`
+    WITH matched AS (
+      SELECT "T1".* FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    ),
+    updated AS (
+      UPDATE "TestSchema"."Employee" AS "T1"
+      SET "name" = 'Gildong Hong', "departmentId" = 2
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+      RETURNING *
+    ),
+    inserted AS (
+      INSERT INTO "TestSchema"."Employee" ("name", "departmentId", "managerId")
+      SELECT 'Gildong Hong', 2, 100
+      WHERE NOT EXISTS (SELECT 1 FROM matched)
+      RETURNING *
+    )
+    SELECT * FROM updated UNION ALL SELECT * FROM inserted
+  `,
+};
+
+export const upsertWithOutput: ExpectedSql = {
+  mysql: mysql`
+    CREATE TEMPORARY TABLE \`SD_TEMP\` AS SELECT \`id\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name'
+    WHERE \`T1\`.\`id\` <=> 1;
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`)
+    SELECT 'New Name'
+    WHERE NOT EXISTS (SELECT * FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1);
+    SELECT \`id\`, \`name\` FROM \`TestDb\`.\`Employee\`
+    WHERE \`TestDb\`.\`Employee\`.\`id\` IN (SELECT \`id\` FROM \`SD_TEMP\`)
+    UNION ALL
+    SELECT \`id\`, \`name\` FROM \`TestDb\`.\`Employee\`
+    WHERE \`id\` = LAST_INSERT_ID() AND NOT EXISTS (SELECT 1 FROM \`SD_TEMP\`);
+    DROP TEMPORARY TABLE \`SD_TEMP\`
+  `,
+  mssql: tsql`
+    MERGE [TestDb].[TestSchema].[Employee] AS [T1]
+    USING (SELECT 1 AS [_]) AS [_src]
+    ON (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+    WHEN MATCHED THEN
+      UPDATE SET [name] = N'New Name'
+    WHEN NOT MATCHED THEN
+      INSERT ([name]) VALUES (N'New Name')
+    OUTPUT INSERTED.[id], INSERTED.[name];
+  `,
+  postgresql: pgsql`
+    WITH matched AS (
+      SELECT "T1".* FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    ),
+    updated AS (
+      UPDATE "TestSchema"."Employee" AS "T1"
+      SET "name" = 'New Name'
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+      RETURNING "id", "name"
+    ),
+    inserted AS (
+      INSERT INTO "TestSchema"."Employee" ("name")
+      SELECT 'New Name'
+      WHERE NOT EXISTS (SELECT 1 FROM matched)
+      RETURNING "id", "name"
+    )
+    SELECT * FROM updated UNION ALL SELECT * FROM inserted
+  `,
+};
+
+export const upsertMultiWhere: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`managerId\` = 10
+    WHERE \`T1\`.\`name\` <=> 'Gildong Hong' AND \`T1\`.\`departmentId\` <=> 1;
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`, \`managerId\`)
+    SELECT 'Gildong Hong', 1, 10
+    WHERE NOT EXISTS (SELECT * FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`name\` <=> 'Gildong Hong' AND \`T1\`.\`departmentId\` <=> 1)
+  `,
+  mssql: tsql`
+    MERGE [TestDb].[TestSchema].[Employee] AS [T1]
+    USING (SELECT 1 AS [_]) AS [_src]
+    ON (([T1].[name] IS NULL AND N'Gildong Hong' IS NULL) OR [T1].[name] = N'Gildong Hong')
+      AND (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
+    WHEN MATCHED THEN
+      UPDATE SET [managerId] = 10
+    WHEN NOT MATCHED THEN
+      INSERT ([name], [departmentId], [managerId]) VALUES (N'Gildong Hong', 1, 10);
+  `,
+  postgresql: pgsql`
+    WITH matched AS (
+      SELECT "T1".* FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."name" IS NOT DISTINCT FROM 'Gildong Hong'
+        AND "T1"."departmentId" IS NOT DISTINCT FROM 1
+    ),
+    updated AS (
+      UPDATE "TestSchema"."Employee" AS "T1"
+      SET "managerId" = 10
+      WHERE "T1"."name" IS NOT DISTINCT FROM 'Gildong Hong'
+        AND "T1"."departmentId" IS NOT DISTINCT FROM 1
+      RETURNING *
+    ),
+    inserted AS (
+      INSERT INTO "TestSchema"."Employee" ("name", "departmentId", "managerId")
+      SELECT 'Gildong Hong', 1, 10
+      WHERE NOT EXISTS (SELECT 1 FROM matched)
+      RETURNING *
+    )
+    SELECT * FROM updated UNION ALL SELECT * FROM inserted
+  `,
+};
+
+export const upsertPlainValues: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name'
+    WHERE \`T1\`.\`id\` <=> 1;
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`)
+    SELECT 'New Name', 1
+    WHERE NOT EXISTS (SELECT * FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1)
+  `,
+  mssql: tsql`
+    MERGE [TestDb].[TestSchema].[Employee] AS [T1]
+    USING (SELECT 1 AS [_]) AS [_src]
+    ON (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+    WHEN MATCHED THEN
+      UPDATE SET [name] = N'New Name'
+    WHEN NOT MATCHED THEN
+      INSERT ([name], [departmentId]) VALUES (N'New Name', 1);
+  `,
+  postgresql: pgsql`
+    WITH matched AS (
+      SELECT "T1".* FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    ),
+    updated AS (
+      UPDATE "TestSchema"."Employee" AS "T1"
+      SET "name" = 'New Name'
+      WHERE "T1"."id" IS NOT DISTINCT FROM 1
+      RETURNING *
+    ),
+    inserted AS (
+      INSERT INTO "TestSchema"."Employee" ("name", "departmentId")
+      SELECT 'New Name', 1
+      WHERE NOT EXISTS (SELECT 1 FROM matched)
+      RETURNING *
+    )
+    SELECT * FROM updated UNION ALL SELECT * FROM inserted
+  `,
+};
+
+//#endregion