@simplysm/orm-common 13.0.69 → 13.0.71

package/tests/db-context/create-db-context.spec.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from "vitest";
+import { defineDbContext } from "../../src/define-db-context";
+import { createDbContext } from "../../src/create-db-context";
+import { User } from "../setup/models/User";
+import { Post } from "../setup/models/Post";
+import { MockExecutor } from "../setup/MockExecutor";
+import "../setup/test-utils";
+
+const TestDb = defineDbContext({
+  tables: { user: User, post: Post },
+});
+
+describe("createDbContext", () => {
+  it("creates instance with queryable accessors", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+
+    expect(db.database).toBe("TestDb");
+    expect(db.schema).toBe("TestSchema");
+    expect(db.status).toBe("ready");
+    expect(typeof db.user).toBe("function");
+    expect(typeof db.post).toBe("function");
+  });
+
+  it("queryable functions create correct QueryDef", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+
+    const def = db.user().getSelectQueryDef();
+    expect(def).toEqual({
+      type: "select",
+      as: "T1",
+      from: { database: "TestDb", schema: "TestSchema", name: "User" },
+    });
+  });
+
+  it("alias counter increments between queryable calls", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+
+    const userDef = db.user().getSelectQueryDef();
+    const postDef = db.post().getSelectQueryDef();
+    expect(userDef.as).toBe("T1");
+    expect(postDef.as).toBe("T2");
+  });
+
+  it("DDL methods exist on instance", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    // QueryDef generators
+    expect(typeof db.getCreateTableQueryDef).toBe("function");
+    expect(typeof db.getAddColumnQueryDef).toBe("function");
+    expect(typeof db.getClearSchemaQueryDef).toBe("function");
+
+    // Execution methods
+    expect(typeof db.createTable).toBe("function");
+    expect(typeof db.addColumn).toBe("function");
+  });
+
+  it("DDL QueryDef generators produce correct output", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+
+    const clearDef = db.getClearSchemaQueryDef({ database: "TestDb", schema: "TestSchema" });
+    expect(clearDef).toEqual({
+      type: "clearSchema",
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+  });
+
+  it("connect/trans methods exist", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    expect(typeof db.connect).toBe("function");
+    expect(typeof db.connectWithoutTransaction).toBe("function");
+    expect(typeof db.trans).toBe("function");
+  });
+
+  it("connect manages status lifecycle", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    expect(db.status).toBe("ready");
+    await db.connect(async () => {
+      await Promise.resolve();
+      expect(db.status).toBe("transact");
+    });
+    expect(db.status).toBe("ready");
+  });
+
+  it("connectWithoutTransaction manages status lifecycle", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    expect(db.status).toBe("ready");
+    await db.connectWithoutTransaction(async () => {
+      await Promise.resolve();
+      expect(db.status).toBe("connect");
+    });
+    expect(db.status).toBe("ready");
+  });
+
+  it("trans manages status lifecycle within connectWithoutTransaction", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    await db.connectWithoutTransaction(async () => {
+      await Promise.resolve();
+      expect(db.status).toBe("connect");
+      await db.trans(async () => {
+        await Promise.resolve();
+        expect(db.status).toBe("transact");
+      });
+      expect(db.status).toBe("connect");
+    });
+    expect(db.status).toBe("ready");
+  });
+
+  it("connect resets alias counter", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    // Use some aliases
+    db.getNextAlias(); // T1
+    db.getNextAlias(); // T2
+
+    await db.connect(async () => {
+      await Promise.resolve();
+      // After connect, alias counter should be reset
+      const userDef = db.user().getSelectQueryDef();
+      expect(userDef.as).toBe("T1");
+    });
+  });
+
+  it("connect rolls back and rethrows on callback error", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    const testError = new Error("test error");
+    await expect(
+      db.connect(async () => {
+        await Promise.resolve();
+        throw testError;
+      }),
+    ).rejects.toThrow("test error");
+
+    expect(db.status).toBe("ready");
+  });
+
+  it("connectWithoutTransaction rethrows on callback error", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    const testError = new Error("test error");
+    await expect(
+      db.connectWithoutTransaction(async () => {
+        await Promise.resolve();
+        throw testError;
+      }),
+    ).rejects.toThrow("test error");
+
+    expect(db.status).toBe("ready");
+  });
+
+  it("trans throws when already in transaction state", async () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    await db.connect(async () => {
+      // Already in transact state via connect
+      await expect(db.trans(async () => {})).rejects.toThrow("Already in TRANSACTION state.");
+    });
+  });
+
+  it("_migration accessor exists", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    expect(typeof db._migration).toBe("function");
+  });
+
+  it("initialize method exists", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+    });
+
+    expect(typeof db.initialize).toBe("function");
+  });
+
+  it("getQueryDefObjectName resolves table with defaults", () => {
+    const db = createDbContext(TestDb, new MockExecutor(), {
+      database: "TestDb",
+      schema: "TestSchema",
+    });
+
+    const objName = db.getQueryDefObjectName(User);
+    expect(objName).toEqual({
+      database: "TestDb",
+      schema: "TestSchema",
+      name: "User",
+    });
+  });
+});

package/tests/db-context/define-db-context.spec.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import type { DbContextBase, DbContextDef } from "../../src/types/db-context-def";
+import { defineDbContext } from "../../src/define-db-context";
+import { User } from "../setup/models/User";
+import { Post } from "../setup/models/Post";
+import { ActiveUsers } from "../setup/views/ActiveUsers";
+
+describe("DbContext Types", () => {
+  it("DbContextBase interface has required members", () => {
+    // Type-level test: verify the interface exists with correct shape
+    const base: DbContextBase = {
+      status: "ready",
+      database: "test",
+      schema: undefined,
+      getNextAlias: () => "T1",
+      resetAliasCounter: () => {},
+      executeDefs: () => Promise.resolve([[]]),
+      getQueryDefObjectName: () => ({ database: "test", name: "test" }),
+      switchFk: () => Promise.resolve(),
+    };
+    expect(base.status).toBe("ready");
+    expect(base.getNextAlias()).toBe("T1");
+  });
+
+  it("DbContextDef has meta property", () => {
+    const def: DbContextDef<{}, {}> = {
+      meta: {
+        tables: {},
+        views: {},
+        procedures: {},
+        migrations: [],
+      },
+    };
+    expect(def.meta.tables).toEqual({});
+    expect(def.meta.migrations).toEqual([]);
+  });
+});
+
+describe("defineDbContext", () => {
+  it("creates a DbContextDef with tables", () => {
+    const MyDb = defineDbContext({
+      tables: { user: User, post: Post },
+    });
+
+    expect(MyDb.meta.tables.user).toBe(User);
+    expect(MyDb.meta.tables.post).toBe(Post);
+    expect(MyDb.meta.migrations).toEqual([]);
+  });
+
+  it("creates a DbContextDef with views", () => {
+    const MyDb = defineDbContext({
+      tables: { user: User },
+      views: { activeUsers: ActiveUsers },
+    });
+
+    expect(MyDb.meta.views.activeUsers).toBe(ActiveUsers);
+  });
+
+  it("creates a DbContextDef with migrations", () => {
+    const migrations = [{ name: "test", up: async () => {} }];
+    const MyDb = defineDbContext({
+      tables: { user: User },
+      migrations,
+    });
+
+    expect(MyDb.meta.migrations).toBe(migrations);
+  });
+});

package/tests/ddl/basic.expected.ts

@@ -0,0 +1,341 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== Database ==========
+
+export const clearSchema: ExpectedSql = {
+  mysql: mysql`
+SET FOREIGN_KEY_CHECKS = 0;
+SET @tables = NULL;
+SELECT GROUP_CONCAT(table_name) INTO @tables FROM information_schema.tables WHERE table_schema = 'TestDb';
+SET @drop_stmt = IF(@tables IS NULL, 'SELECT 1', CONCAT('DROP TABLE IF EXISTS ', @tables));
+PREPARE stmt FROM @drop_stmt;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+SET FOREIGN_KEY_CHECKS = 1
+  `,
+  mssql: tsql`
+DECLARE @sql NVARCHAR(MAX);
+SET @sql = N'';
+
+-- FK constraint Delete
+SELECT @sql = @sql + N'ALTER TABLE ' + QUOTENAME(OBJECT_SCHEMA_NAME(parent_object_id)) + '.' + QUOTENAME(OBJECT_NAME(parent_object_id)) + N' DROP CONSTRAINT ' + QUOTENAME(name) + N';' + CHAR(13)
+FROM [TestDb].sys.foreign_keys
+WHERE OBJECT_SCHEMA_NAME(parent_object_id) = 'TestSchema';
+
+-- Drop table
+SELECT @sql = @sql + N'DROP TABLE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM [TestDb].sys.tables
+WHERE SCHEMA_NAME(schema_id) = 'TestSchema';
+
+-- Drop view
+SELECT @sql = @sql + N'DROP VIEW ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM [TestDb].sys.views
+WHERE schema_id = SCHEMA_ID('TestSchema');
+
+-- Procedure Delete
+SELECT @sql = @sql + N'DROP PROCEDURE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM [TestDb].sys.procedures
+WHERE SCHEMA_NAME(schema_id) = 'TestSchema';
+
+EXEC sp_executesql @sql;
+  `,
+  postgresql: pgsql`
+DO $$
+DECLARE
+  r RECORD;
+BEGIN
+  -- FK constraint Delete
+  FOR r IN (SELECT conname, conrelid::regclass AS tablename
+            FROM pg_constraint
+            WHERE contype = 'f' AND connamespace = 'TestSchema'::regnamespace)
+  LOOP
+    EXECUTE 'ALTER TABLE ' || r.tablename || ' DROP CONSTRAINT ' || quote_ident(r.conname);
+  END LOOP;
+
+  -- Drop table
+  FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'TestSchema')
+  LOOP
+    EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
+  END LOOP;
+
+  -- Drop view
+  FOR r IN (SELECT viewname FROM pg_views WHERE schemaname = 'TestSchema')
+  LOOP
+    EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.viewname) || ' CASCADE';
+  END LOOP;
+
+  -- function Delete
+  FOR r IN (SELECT proname, pg_get_function_identity_arguments(oid) AS args
+            FROM pg_proc WHERE pronamespace = 'TestSchema'::regnamespace)
+  LOOP
+    EXECUTE 'DROP FUNCTION IF EXISTS ' || quote_ident(r.proname) || '(' || r.args || ') CASCADE';
+  END LOOP;
+END $$
+  `,
+};
+
+export const schemaExists: ExpectedSql = {
+  mysql: mysql`SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = 'TestDb'`,
+  mssql: tsql`
+DECLARE @result NVARCHAR(MAX) = NULL;
+IF EXISTS (SELECT 1 FROM sys.databases WHERE name = 'TestDb')
+BEGIN
+  DECLARE @sql NVARCHAR(MAX) = N'SELECT @result = name FROM ' + QUOTENAME('TestDb') + N'.sys.schemas WHERE name = ''TestSchema''';
+  EXEC sp_executesql @sql, N'@result NVARCHAR(MAX) OUTPUT', @result OUTPUT;
+END
+SELECT @result AS name WHERE @result IS NOT NULL
+  `,
+  postgresql: pgsql`SELECT nspname FROM pg_namespace WHERE nspname = 'TestSchema'`,
+};
+
+//#endregion
+
+//#region ========== Table ==========
+
+export const createTable: ExpectedSql = {
+  mysql: mysql`
+CREATE TABLE \`TestDb\`.\`User\` (
+  \`id\` BIGINT NOT NULL AUTO_INCREMENT,
+  \`name\` VARCHAR(100) NOT NULL,
+  \`email\` VARCHAR(200) NULL,
+  \`age\` INT NULL,
+  \`isActive\` BOOLEAN NOT NULL DEFAULT TRUE,
+  \`companyId\` BIGINT NULL,
+  \`createdAt\` DATETIME NOT NULL,
+  CONSTRAINT \`PK_User\` PRIMARY KEY (\`id\`)
+)
+  `,
+  mssql: tsql`
+CREATE TABLE [TestDb].[TestSchema].[User] (
+  [id] BIGINT NOT NULL IDENTITY(1,1),
+  [name] NVARCHAR(100) NOT NULL,
+  [email] NVARCHAR(200) NULL,
+  [age] INT NULL,
+  [isActive] BIT NOT NULL DEFAULT 1,
+  [companyId] BIGINT NULL,
+  [createdAt] DATETIME2 NOT NULL,
+  CONSTRAINT [PK_User] PRIMARY KEY ([id])
+)
+  `,
+  postgresql: pgsql`
+CREATE TABLE "TestSchema"."User" (
+  "id" BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+  "name" VARCHAR(100) NOT NULL,
+  "email" VARCHAR(200) NULL,
+  "age" INTEGER NULL,
+  "isActive" BOOLEAN NOT NULL DEFAULT TRUE,
+  "companyId" BIGINT NULL,
+  "createdAt" TIMESTAMP NOT NULL,
+  CONSTRAINT "PK_User" PRIMARY KEY ("id")
+)
+  `,
+};
+
+export const truncate: ExpectedSql = {
+  mysql: mysql`TRUNCATE TABLE \`TestDb\`.\`User\``,
+  mssql: tsql`TRUNCATE TABLE [TestDb].[TestSchema].[User]`,
+  postgresql: pgsql`TRUNCATE TABLE "TestSchema"."User" RESTART IDENTITY`,
+};
+
+export const switchFkOn: ExpectedSql = {
+  mysql: mysql`SET FOREIGN_KEY_CHECKS = 1`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] WITH CHECK CHECK CONSTRAINT ALL`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ENABLE TRIGGER ALL`,
+};
+
+export const switchFkOff: ExpectedSql = {
+  mysql: mysql`SET FOREIGN_KEY_CHECKS = 0`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] NOCHECK CONSTRAINT ALL`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" DISABLE TRIGGER ALL`,
+};
+
+export const dropTable: ExpectedSql = {
+  mysql: mysql`DROP TABLE \`TestDb\`.\`User\``,
+  mssql: tsql`DROP TABLE [TestDb].[TestSchema].[User]`,
+  postgresql: pgsql`DROP TABLE "TestSchema"."User"`,
+};
+
+export const renameTable: ExpectedSql = {
+  mysql: mysql`RENAME TABLE \`TestDb\`.\`User\` TO \`Member\``,
+  mssql: tsql`EXEC sp_rename '[TestDb].[TestSchema].[User]', 'Member'`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" RENAME TO "Member"`,
+};
+
+//#endregion
+
+//#region ========== Column ==========
+
+export const addColumn: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` ADD COLUMN \`nickname\` VARCHAR(50) NULL`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ADD [nickname] NVARCHAR(50) NULL`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ADD COLUMN "nickname" VARCHAR(50) NULL`,
+};
+
+export const addColumnWithDefault: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` ADD COLUMN \`score\` INT NOT NULL DEFAULT 0`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ADD [score] INT NOT NULL DEFAULT 0`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ADD COLUMN "score" INTEGER NOT NULL DEFAULT 0`,
+};
+
+export const addColumnWithAutoIncrement: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` ADD COLUMN \`seq\` BIGINT NOT NULL AUTO_INCREMENT`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ADD [seq] BIGINT NOT NULL IDENTITY(1,1)`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ADD COLUMN "seq" BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY`,
+};
+
+export const dropColumn: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` DROP COLUMN \`email\``,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] DROP COLUMN [email]`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" DROP COLUMN "email"`,
+};
+
+export const modifyColumn: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` MODIFY COLUMN \`name\` VARCHAR(200) NULL`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ALTER COLUMN [name] NVARCHAR(200) NULL`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ALTER COLUMN "name" TYPE VARCHAR(200), ALTER COLUMN "name" DROP NOT NULL`,
+};
+
+export const modifyColumnTypeAndDefault: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` MODIFY COLUMN \`score\` INT NOT NULL DEFAULT 100`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ALTER COLUMN [score] INT NOT NULL`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ALTER COLUMN "score" TYPE INTEGER, ALTER COLUMN "score" DROP NOT NULL, ALTER COLUMN "score" SET DEFAULT 100`,
+};
+
+export const renameColumn: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` RENAME COLUMN \`name\` TO \`fullName\``,
+  mssql: tsql`EXEC sp_rename '[TestDb].[TestSchema].[User].name', 'fullName', 'COLUMN'`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" RENAME COLUMN "name" TO "fullName"`,
+};
+
+//#endregion
+
+//#region ========== Primary Key ==========
+
+export const dropPk: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` DROP PRIMARY KEY`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] DROP CONSTRAINT [PK_User]`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" DROP CONSTRAINT "PK_User"`,
+};
+
+export const addPk: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` ADD PRIMARY KEY (\`id\`)`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ADD CONSTRAINT [PK_User] PRIMARY KEY ([id])`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."User" ADD CONSTRAINT "PK_User" PRIMARY KEY ("id")`,
+};
+
+export const addPkComposite: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`UserRole\` ADD PRIMARY KEY (\`userId\`, \`roleId\`)`,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[UserRole] ADD CONSTRAINT [PK_UserRole] PRIMARY KEY ([userId], [roleId])`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."UserRole" ADD CONSTRAINT "PK_UserRole" PRIMARY KEY ("userId", "roleId")`,
+};
+
+//#endregion
+
+//#region ========== Foreign Key / Index ==========
+
+export const addFk: ExpectedSql = {
+  mysql: mysql`
+ALTER TABLE \`TestDb\`.\`Post\` ADD CONSTRAINT \`FK_Post_user\`
+FOREIGN KEY (\`userId\`) REFERENCES \`TestDb\`.\`User\` (\`id\`)
+  `,
+  mssql: tsql`
+ALTER TABLE [TestDb].[TestSchema].[Post] ADD CONSTRAINT [FK_Post_user]
+FOREIGN KEY ([userId]) REFERENCES [TestDb].[TestSchema].[User] ([id]);
+CREATE INDEX [IDX_Post_Post_user] ON [TestDb].[TestSchema].[Post] ([userId]);
+  `,
+  postgresql: pgsql`
+ALTER TABLE "TestSchema"."Post" ADD CONSTRAINT "FK_Post_user"
+FOREIGN KEY ("userId") REFERENCES "TestSchema"."User" ("id");
+CREATE INDEX "IDX_Post_Post_user" ON "TestSchema"."Post" ("userId");
+  `,
+};
+
+export const dropFk: ExpectedSql = {
+  mysql: mysql`ALTER TABLE \`TestDb\`.\`Post\` DROP FOREIGN KEY \`FK_Post_user\``,
+  mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[Post] DROP CONSTRAINT [FK_Post_user]`,
+  postgresql: pgsql`ALTER TABLE "TestSchema"."Post" DROP CONSTRAINT "FK_Post_user"`,
+};
+
+export const addIdx: ExpectedSql = {
+  mysql: mysql`CREATE UNIQUE INDEX \`IDX_User_email\` ON \`TestDb\`.\`User\` (\`email\` ASC)`,
+  mssql: tsql`CREATE UNIQUE INDEX [IDX_User_email] ON [TestDb].[TestSchema].[User] ([email] ASC)`,
+  postgresql: pgsql`CREATE UNIQUE INDEX "IDX_User_email" ON "TestSchema"."User" ("email" ASC)`,
+};
+
+export const dropIdx: ExpectedSql = {
+  mysql: mysql`DROP INDEX \`IDX_User_email\` ON \`TestDb\`.\`User\``,
+  mssql: tsql`DROP INDEX [IDX_User_email] ON [TestDb].[TestSchema].[User]`,
+  postgresql: pgsql`DROP INDEX "TestSchema"."IDX_User_email"`,
+};
+
+export const dropIdxComposite: ExpectedSql = {
+  mysql: mysql`DROP INDEX \`IDX_User_name_email\` ON \`TestDb\`.\`User\``,
+  mssql: tsql`DROP INDEX [IDX_User_name_email] ON [TestDb].[TestSchema].[User]`,
+  postgresql: pgsql`DROP INDEX "TestSchema"."IDX_User_name_email"`,
+};
+
+//#endregion
+
+//#region ========== View ==========
+
+export const createView: ExpectedSql = {
+  mysql: mysql`
+CREATE OR REPLACE VIEW \`TestDb\`.\`ActiveUsers\` AS
+SELECT * FROM \`TestDb\`.\`User\` AS \`T1\`
+WHERE \`T1\`.\`isActive\` <=> TRUE
+  `,
+  mssql: tsql`
+CREATE OR ALTER VIEW [TestDb].[TestSchema].[ActiveUsers] AS
+SELECT * FROM [TestDb].[TestSchema].[User] AS [T1]
+WHERE (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1)
+  `,
+  postgresql: pgsql`
+CREATE OR REPLACE VIEW "TestSchema"."ActiveUsers" AS
+SELECT * FROM "TestSchema"."User" AS "T1"
+WHERE "T1"."isActive" IS NOT DISTINCT FROM TRUE
+  `,
+};
+
+export const dropView: ExpectedSql = {
+  mysql: mysql`DROP VIEW IF EXISTS \`TestDb\`.\`ActiveUsers\``,
+  mssql: tsql`DROP VIEW IF EXISTS [TestDb].[TestSchema].[ActiveUsers]`,
+  postgresql: pgsql`DROP VIEW IF EXISTS "TestSchema"."ActiveUsers"`,
+};
+
+//#endregion
+
+//#region ========== Procedure ==========
+
+export const createProc: ExpectedSql = {
+  mysql: mysql`
+CREATE PROCEDURE \`TestDb\`.\`GetUserById\`(IN \`userId\` BIGINT)
+BEGIN
+-- DBMSwrite matching query --;
+END
+  `,
+  mssql: tsql`
+CREATE OR ALTER PROCEDURE [TestDb].[TestSchema].[GetUserById] @userId BIGINT
+AS
+BEGIN
+SET NOCOUNT ON;
+-- DBMSwrite matching query --
+END
+  `,
+  postgresql: pgsql`
+CREATE OR REPLACE FUNCTION "TestSchema"."GetUserById"("userId" BIGINT)
+RETURNS TABLE("id" BIGINT, "name" VARCHAR(100), "email" VARCHAR(200)) AS $$
+BEGIN
+-- DBMSwrite matching query --;
+END;
+$$ LANGUAGE plpgsql
+  `,
+};
+
+export const dropProc: ExpectedSql = {
+  mysql: mysql`DROP PROCEDURE IF EXISTS \`TestDb\`.\`GetUserById\``,
+  mssql: tsql`DROP PROCEDURE IF EXISTS [TestDb].[TestSchema].[GetUserById]`,
+  postgresql: pgsql`DROP FUNCTION IF EXISTS "TestSchema"."GetUserById"()`,
+};
+
+//#endregion