@simplysm/orm-common 13.0.69 → 13.0.70

package/tests/dml/insert.spec.ts

@@ -0,0 +1,288 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { expr } from "../../src/expr/expr";
+import { Table } from "../../src/schema/table-builder";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import * as expected from "./insert.expected";
+
+describe("INSERT - Basic", () => {
+  //#region ========== Single/Multiple INSERT ==========
+
+  describe("single record INSERT", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .getInsertQueryDef([{ name: "Hong Gildong", managerId: undefined, departmentId: 1 }]);
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "insert",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        records: [{ name: "Hong Gildong", managerId: undefined, departmentId: 1 }],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertSingle[dialect]);
+    });
+  });
+
+  describe("multiple records INSERT (bulk)", () => {
+    const db = createTestDb();
+    const def = db.employee().getInsertQueryDef([
+      { name: "Hong Gildong", departmentId: 1 },
+      { name: "Kim Chulsu", managerId: 1, departmentId: 1 },
+      { name: "Lee Younghee", managerId: 1, departmentId: 2 },
+    ]);
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "insert",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        records: [
+          { name: "Hong Gildong", departmentId: 1 },
+          { name: "Kim Chulsu", managerId: 1, departmentId: 1 },
+          { name: "Lee Younghee", managerId: 1, departmentId: 2 },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertBulk[dialect]);
+    });
+  });
+
+  describe("output column specified (RETURNING/OUTPUT)", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .getInsertQueryDef(
+        [{ name: "Hong Gildong", managerId: undefined, departmentId: 1 }],
+        ["id", "name"],
+      );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "insert",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        records: [{ name: "Hong Gildong", managerId: undefined, departmentId: 1 }],
+        output: {
+          columns: ["id", "name"],
+          pkColNames: ["id"],
+          aiColName: "id",
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertWithOutput[dialect]);
+    });
+  });
+
+  describe("omit nullable column", () => {
+    const db = createTestDb();
+    const def = db.employee().getInsertQueryDef([{ name: "Hong Gildong" }]);
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insert",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        records: [{ name: "Hong Gildong" }],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertNullable[dialect]);
+    });
+  });
+
+  describe("Explicitly specify AI column", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .getInsertQueryDef([{ id: 100, name: "Gildong Hong", managerId: undefined, departmentId: 1 }]);
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insert",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        records: [{ id: 100, name: "Gildong Hong", managerId: undefined, departmentId: 1 }],
+        overrideIdentity: true,
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertWithAi[dialect]);
+    });
+  });
+
+  //#endregion
+});
+
+describe("INSERT IF NOT EXISTS", () => {
+  //#region ========== INSERT IF NOT EXISTS ==========
+
+  describe("Basic: prevent duplicates with WHERE NOT EXISTS", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.name, "Gildong Hong")])
+      .getInsertIfNotExistsQueryDef({ name: "Gildong Hong", departmentId: 1 });
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insertIfNotExists",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        record: { name: "Gildong Hong", departmentId: 1 },
+        existsSelectQuery: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+          where: [
+            {
+              type: "eq",
+              source: { type: "column", path: ["T1", "name"] },
+              target: { type: "value", value: "Gildong Hong" },
+            },
+          ],
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertIfNotExistsBasic[dialect]);
+    });
+  });
+
+  describe("Check duplicates with complex conditions", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.name, "Gildong Hong"), expr.eq(e.departmentId, 1)])
+      .getInsertIfNotExistsQueryDef({ name: "Gildong Hong", departmentId: 1 });
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insertIfNotExists",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        record: { name: "Gildong Hong", departmentId: 1 },
+        existsSelectQuery: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+          where: [
+            {
+              type: "eq",
+              source: { type: "column", path: ["T1", "name"] },
+              target: { type: "value", value: "Gildong Hong" },
+            },
+            {
+              type: "eq",
+              source: { type: "column", path: ["T1", "departmentId"] },
+              target: { type: "value", value: 1 },
+            },
+          ],
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertIfNotExistsMultiple[dialect]);
+    });
+  });
+
+  //#endregion
+});
+
+describe("INSERT INTO ... SELECT", () => {
+  const EmployeeBackup = Table("EmployeeBackup")
+    .columns((c) => ({
+      id: c.bigint(),
+      name: c.varchar(100),
+    }))
+    .primaryKey("id");
+
+  //#region ========== INSERT INTO SELECT ==========
+
+  describe("Basic: INSERT SELECT results to different table", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .select((e) => ({
+        id: e.id,
+        name: e.name,
+      }))
+      .getInsertIntoQueryDef(EmployeeBackup);
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insertInto",
+        table: { database: "TestDb", schema: "TestSchema", name: "EmployeeBackup" },
+        recordsSelectQuery: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+          select: {
+            id: { type: "column", path: ["T1", "id"] },
+            name: { type: "column", path: ["T1", "name"] },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertIntoSelect[dialect]);
+    });
+  });
+
+  describe("INSERT INTO SELECT with WHERE condition", () => {
+    const db = createTestDb();
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.departmentId, 1)])
+      .select((e) => ({
+        id: e.id,
+        name: e.name,
+      }))
+      .getInsertIntoQueryDef(EmployeeBackup);
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "insertInto",
+        table: { database: "TestDb", schema: "TestSchema", name: "EmployeeBackup" },
+        recordsSelectQuery: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+          where: [
+            {
+              type: "eq",
+              source: { type: "column", path: ["T1", "departmentId"] },
+              target: { type: "value", value: 1 },
+            },
+          ],
+          select: {
+            id: { type: "column", path: ["T1", "id"] },
+            name: { type: "column", path: ["T1", "name"] },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.insertIntoSelectWhere[dialect]);
+    });
+  });
+
+  //#endregion
+});

package/tests/dml/update.expected.ts

@@ -0,0 +1,176 @@
+/**
+ * UPDATE test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== UPDATE - Basic ==========
+
+export const updateSimple: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'new name'
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[name] = N'new name'
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'new name'
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const updateMultiCol: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name', \`T1\`.\`departmentId\` = 2
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[name] = N'New Name', [T1].[departmentId] = 2
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'New Name', "departmentId" = 2
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const updatePlainValues: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name', \`T1\`.\`departmentId\` = 2
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[name] = N'New Name', [T1].[departmentId] = 2
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'New Name', "departmentId" = 2
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const updateMixed: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name', \`T1\`.\`managerId\` = \`T1\`.\`managerId\` + 1
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[name] = N'New Name', [T1].[managerId] = [T1].[managerId] + 1
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'New Name', "managerId" = "T1"."managerId" + 1
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const updateWithRef: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`managerId\` = \`T1\`.\`managerId\` + 1
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[managerId] = [T1].[managerId] + 1
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "managerId" = "T1"."managerId" + 1
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const updateWithOutput: ExpectedSql = {
+  mysql: mysql`
+    CREATE TEMPORARY TABLE \`SD_TEMP\` AS SELECT \`T1\`.\`id\` AS \`id\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name'
+    WHERE \`T1\`.\`id\` <=> 1;
+    SELECT \`T1\`.\`id\`, \`T1\`.\`name\` FROM \`TestDb\`.\`Employee\` AS \`T1\`, \`SD_TEMP\` WHERE \`T1\`.\`id\` = \`SD_TEMP\`.\`id\`;
+    DROP TEMPORARY TABLE \`SD_TEMP\`
+  `,
+  mssql: tsql`
+    UPDATE [T1]
+    SET [T1].[name] = N'New Name'
+    OUTPUT INSERTED.[id], INSERTED.[name]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'New Name'
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    RETURNING "T1"."id", "T1"."name"
+  `,
+};
+
+export const updateWithTop: ExpectedSql = {
+  mysql: mysql`
+    UPDATE \`TestDb\`.\`Employee\` AS \`T1\`
+    SET \`T1\`.\`name\` = 'New Name'
+    WHERE \`T1\`.\`departmentId\` <=> 1
+    LIMIT 10
+  `,
+  mssql: tsql`
+    UPDATE TOP 10 [T1]
+    SET [T1].[name] = N'New Name'
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
+  `,
+  postgresql: pgsql`
+    UPDATE "TestSchema"."Employee" AS "T1"
+    SET "name" = 'New Name'
+    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
+  `,
+};
+
+//#endregion
+
+//#region ========== FK 스위치 ==========
+
+export const fkOff: ExpectedSql = {
+  mysql: mysql`
+    SET FOREIGN_KEY_CHECKS = 0
+  `,
+  mssql: tsql`
+    ALTER TABLE [TestDb].[TestSchema].[Employee] NOCHECK CONSTRAINT ALL
+  `,
+  postgresql: pgsql`
+    ALTER TABLE "TestSchema"."Employee" DISABLE TRIGGER ALL
+  `,
+};
+
+export const fkOn: ExpectedSql = {
+  mysql: mysql`
+    SET FOREIGN_KEY_CHECKS = 1
+  `,
+  mssql: tsql`
+    ALTER TABLE [TestDb].[TestSchema].[Employee] WITH CHECK CHECK CONSTRAINT ALL
+  `,
+  postgresql: pgsql`
+    ALTER TABLE "TestSchema"."Employee" ENABLE TRIGGER ALL
+  `,
+};
+
+//#endregion