@simplysm/orm-common 13.0.100 → 14.0.4

package/tests/dml/update.spec.ts

@@ -1,222 +0,0 @@
-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 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("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" },
-      false,
-    );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        enabled: false,
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.fkOff[dialect]);
-    });
-  });
-
-});

package/tests/dml/upsert.expected.ts

@@ -1,215 +0,0 @@
-/**
- * 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

package/tests/dml/upsert.spec.ts

@@ -1,190 +0,0 @@
-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 "./upsert.expected";
-
-describe("UPSERT - Basic", () => {
-  describe("simple UPSERT (WHERE condition)", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpsertQueryDef(
-        () => ({ name: expr.val("string", "new name") }),
-        (upd) => ({ name: upd.name, departmentId: expr.val("number", 1) }),
-      );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "upsert",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        existsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "id"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-        },
-        updateRecord: {
-          name: { type: "value", value: "new name" },
-        },
-        insertRecord: {
-          name: { type: "value", value: "new name" },
-          departmentId: { type: "value", value: 1 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.upsertSimple[dialect]);
-    });
-  });
-
-  describe("INSERT reusing UPDATE values", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpsertQueryDef(
-        () => ({
-          name: expr.val("string", "Gildong Hong"),
-          departmentId: expr.val("number", 2),
-        }),
-        (upd) => ({
-          ...upd,
-          managerId: expr.val("number", 100),
-        }),
-      );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "upsert",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        existsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "id"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-        },
-        updateRecord: {
-          name: { type: "value", value: "Gildong Hong" },
-          departmentId: { type: "value", value: 2 },
-        },
-        insertRecord: {
-          name: { type: "value", value: "Gildong Hong" },
-          departmentId: { type: "value", value: 2 },
-          managerId: { type: "value", value: 100 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.upsertReuse[dialect]);
-    });
-  });
-
-  describe("Specify output column", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpsertQueryDef(
-        () => ({ name: expr.val("string", "New Name") }),
-        (upd) => ({ name: upd.name }),
-        ["id", "name"],
-      );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "upsert",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        existsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "id"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-        },
-        updateRecord: {
-          name: { type: "value", value: "New Name" },
-        },
-        insertRecord: {
-          name: { type: "value", value: "New Name" },
-        },
-        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.upsertWithOutput[dialect]);
-    });
-  });
-
-  describe("UPSERT with literal values (without expr.val)", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpsertQueryDef(
-        () => ({ name: "New Name" }),
-        (upd) => ({ name: upd.name, departmentId: 1 }),
-      );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "upsert",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        existsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "id"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-        },
-        updateRecord: {
-          name: { type: "value", value: "New Name" },
-        },
-        insertRecord: {
-          name: { type: "value", value: "New Name" },
-          departmentId: { type: "value", value: 1 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.upsertPlainValues[dialect]);
-    });
-  });
-});