@simplysm/orm-common 13.0.69 → 13.0.71

package/tests/dml/delete.expected.ts

@@ -0,0 +1,96 @@
+/**
+ * DELETE test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== TRUNCATE ==========
+
+export const truncate: ExpectedSql = {
+  mysql: mysql`
+    TRUNCATE TABLE \`TestDb\`.\`Employee\`
+  `,
+  mssql: tsql`
+    TRUNCATE TABLE [TestDb].[TestSchema].[Employee]
+  `,
+  postgresql: pgsql`
+    TRUNCATE TABLE "TestSchema"."Employee" RESTART IDENTITY
+  `,
+};
+
+//#endregion
+
+//#region ========== DELETE - Basic ==========
+
+export const deleteSimple: ExpectedSql = {
+  mysql: mysql`
+    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
+    WHERE \`T1\`.\`id\` <=> 1
+  `,
+  mssql: tsql`
+    DELETE [T1]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    DELETE FROM "TestSchema"."Employee" AS "T1"
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+  `,
+};
+
+export const deleteMultiCond: ExpectedSql = {
+  mysql: mysql`
+    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
+    WHERE \`T1\`.\`departmentId\` <=> 1 AND \`T1\`.\`managerId\` IS NULL
+  `,
+  mssql: tsql`
+    DELETE [T1]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
+      AND [T1].[managerId] IS NULL
+  `,
+  postgresql: pgsql`
+    DELETE FROM "TestSchema"."Employee" AS "T1"
+    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
+      AND "T1"."managerId" IS NULL
+  `,
+};
+
+export const deleteWithOutput: ExpectedSql = {
+  mysql: mysql`
+    CREATE TEMPORARY TABLE \`SD_TEMP\` AS SELECT \`T1\`.\`id\`, \`T1\`.\`name\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
+    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
+    SELECT * FROM \`SD_TEMP\`;
+    DROP TEMPORARY TABLE \`SD_TEMP\`
+  `,
+  mssql: tsql`
+    DELETE [T1]
+    OUTPUT DELETED.[id], DELETED.[name]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
+  `,
+  postgresql: pgsql`
+    DELETE FROM "TestSchema"."Employee" AS "T1"
+    WHERE "T1"."id" IS NOT DISTINCT FROM 1
+    RETURNING "id", "name"
+  `,
+};
+
+export const deleteWithTop: ExpectedSql = {
+  mysql: mysql`
+    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
+    WHERE \`T1\`.\`departmentId\` <=> 1
+    LIMIT 100
+  `,
+  mssql: tsql`
+    DELETE TOP 100 [T1]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
+  `,
+  postgresql: pgsql`
+    DELETE FROM "TestSchema"."Employee" AS "T1"
+    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
+  `,
+};
+
+//#endregion

package/tests/dml/delete.spec.ts

@@ -0,0 +1,160 @@
+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 "./delete.expected";
+
+describe("TRUNCATE", () => {
+  describe("delete entire table (TRUNCATE)", () => {
+    const db = createTestDb();
+
+    const def = db.getTruncateQueryDef({
+      database: "TestDb",
+      schema: "TestSchema",
+      name: "Employee",
+    });
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "truncate",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.truncate[dialect]);
+    });
+  });
+});
+
+describe("DELETE - Basic", () => {
+  describe("simple DELETE", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getDeleteQueryDef();
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "delete",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        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.deleteSimple[dialect]);
+    });
+  });
+
+  describe("DELETE with multiple conditions", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.departmentId, 1), expr.null(e.managerId)])
+      .getDeleteQueryDef();
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "delete",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        where: [
+          {
+            type: "eq",
+            source: { type: "column", path: ["T1", "departmentId"] },
+            target: { type: "value", value: 1 },
+          },
+          {
+            type: "null",
+            arg: { type: "column", path: ["T1", "managerId"] },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.deleteMultiCond[dialect]);
+    });
+  });
+
+  describe("output column specified", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.id, 1)])
+      .getDeleteQueryDef(["id", "name"]);
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "delete",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        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.deleteWithOutput[dialect]);
+    });
+  });
+
+  describe("Limit delete count with TOP", () => {
+    const db = createTestDb();
+
+    const def = db
+      .employee()
+      .where((e) => [expr.eq(e.departmentId, 1)])
+      .top(100)
+      .getDeleteQueryDef();
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "delete",
+        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
+        as: "T1",
+        top: 100,
+        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.deleteWithTop[dialect]);
+    });
+  });
+});

package/tests/dml/insert.expected.ts

@@ -0,0 +1,192 @@
+/**
+ * INSERT test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== INSERT - Basic ==========
+
+export const insertSingle: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`managerId\`, \`departmentId\`)
+    VALUES ('Hong Gildong', NULL, 1)
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name], [managerId], [departmentId])
+    VALUES (N'Hong Gildong', NULL, 1)
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name", "managerId", "departmentId")
+    VALUES ('Hong Gildong', NULL, 1)
+  `,
+};
+
+export const insertBulk: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`)
+    VALUES ('Hong Gildong', 1), ('Kim Chulsu', 1), ('Lee Younghee', 2)
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name], [departmentId])
+    VALUES (N'Hong Gildong', 1), (N'Kim Chulsu', 1), (N'Lee Younghee', 2)
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name", "departmentId")
+    VALUES ('Hong Gildong', 1), ('Kim Chulsu', 1), ('Lee Younghee', 2)
+  `,
+};
+
+export const insertWithOutput: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`managerId\`, \`departmentId\`)
+    VALUES ('Hong Gildong', NULL, 1);
+    SELECT \`id\`, \`name\` FROM \`TestDb\`.\`Employee\` WHERE \`id\` = LAST_INSERT_ID()
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name], [managerId], [departmentId])
+    OUTPUT INSERTED.[id], INSERTED.[name]
+    VALUES (N'Hong Gildong', NULL, 1)
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name", "managerId", "departmentId")
+    VALUES ('Hong Gildong', NULL, 1)
+    RETURNING "id", "name"
+  `,
+};
+
+export const insertNullable: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`)
+    VALUES ('Hong Gildong')
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name])
+    VALUES (N'Hong Gildong')
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name")
+    VALUES ('Hong Gildong')
+  `,
+};
+
+export const insertWithAi: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`id\`, \`name\`, \`managerId\`, \`departmentId\`)
+    VALUES (100, 'Gildong Hong', NULL, 1)
+  `,
+  mssql: tsql`
+    SET IDENTITY_INSERT [TestDb].[TestSchema].[Employee] ON;
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([id], [name], [managerId], [departmentId])
+    VALUES (100, N'Gildong Hong', NULL, 1);
+    SET IDENTITY_INSERT [TestDb].[TestSchema].[Employee] OFF;
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("id", "name", "managerId", "departmentId")
+    VALUES (100, 'Gildong Hong', NULL, 1)
+  `,
+};
+
+//#endregion
+
+//#region ========== INSERT IF NOT EXISTS ==========
+
+export const insertIfNotExistsBasic: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`)
+    SELECT 'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS \`_\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
+      WHERE \`T1\`.\`name\` <=> 'Gildong Hong'
+    )
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name], [departmentId])
+    SELECT N'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS [_] FROM [TestDb].[TestSchema].[Employee] AS [T1]
+      WHERE (([T1].[name] IS NULL AND N'Gildong Hong' IS NULL) OR [T1].[name] = N'Gildong Hong')
+    )
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name", "departmentId")
+    SELECT 'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS "_" FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."name" IS NOT DISTINCT FROM 'Gildong Hong'
+    )
+  `,
+};
+
+export const insertIfNotExistsMultiple: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`Employee\` (\`name\`, \`departmentId\`)
+    SELECT 'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS \`_\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
+      WHERE \`T1\`.\`name\` <=> 'Gildong Hong' AND \`T1\`.\`departmentId\` <=> 1
+    )
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[Employee] ([name], [departmentId])
+    SELECT N'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS [_] FROM [TestDb].[TestSchema].[Employee] AS [T1]
+      WHERE (([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)
+    )
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."Employee" ("name", "departmentId")
+    SELECT 'Gildong Hong', 1
+    WHERE NOT EXISTS (
+      SELECT 1 AS "_" FROM "TestSchema"."Employee" AS "T1"
+      WHERE "T1"."name" IS NOT DISTINCT FROM 'Gildong Hong'
+        AND "T1"."departmentId" IS NOT DISTINCT FROM 1
+    )
+  `,
+};
+
+//#endregion
+
+//#region ========== INSERT INTO ... SELECT ==========
+
+export const insertIntoSelect: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`EmployeeBackup\` (\`id\`, \`name\`)
+    SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`name\` AS \`name\`
+    FROM \`TestDb\`.\`Employee\` AS \`T1\`
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[EmployeeBackup] ([id], [name])
+    SELECT [T1].[id] AS [id], [T1].[name] AS [name]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."EmployeeBackup" ("id", "name")
+    SELECT "T1"."id" AS "id", "T1"."name" AS "name"
+    FROM "TestSchema"."Employee" AS "T1"
+  `,
+};
+
+export const insertIntoSelectWhere: ExpectedSql = {
+  mysql: mysql`
+    INSERT INTO \`TestDb\`.\`EmployeeBackup\` (\`id\`, \`name\`)
+    SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`name\` AS \`name\`
+    FROM \`TestDb\`.\`Employee\` AS \`T1\`
+    WHERE \`T1\`.\`departmentId\` <=> 1
+  `,
+  mssql: tsql`
+    INSERT INTO [TestDb].[TestSchema].[EmployeeBackup] ([id], [name])
+    SELECT [T1].[id] AS [id], [T1].[name] AS [name]
+    FROM [TestDb].[TestSchema].[Employee] AS [T1]
+    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
+  `,
+  postgresql: pgsql`
+    INSERT INTO "TestSchema"."EmployeeBackup" ("id", "name")
+    SELECT "T1"."id" AS "id", "T1"."name" AS "name"
+    FROM "TestSchema"."Employee" AS "T1"
+    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
+  `,
+};
+
+//#endregion