@simplysm/orm-common 13.0.100 → 14.0.4

package/src/create-db-context.ts

@@ -15,7 +15,7 @@ import { queryable } from "./exec/queryable";
 import { executable } from "./exec/executable";
 import { obj } from "@simplysm/core-common";
 
-// DDL imports
+// DDL import
 import * as tableDdl from "./ddl/table-ddl";
 import * as columnDdl from "./ddl/column-ddl";
 import * as relationDdl from "./ddl/relation-ddl";
@@ -30,18 +30,18 @@ import type { ForeignKeyBuilder } from "./schema/factory/relation-builder";
 import type { IndexBuilder } from "./schema/factory/index-builder";
 
 /**
- * DbContext instance factory
+ * DbContext 인스턴스 팩토리
  *
- * Takes DbContextDef (definition) and DbContextExecutor (executor) and creates
- * a complete DbContext instance including queryable accessors, DDL methods,
- * and connection/transaction management
+ * DbContextDef (정의)와 DbContextExecutor (실행기)를 받아
+ * queryable 접근자, DDL 메서드, 연결/트랜잭션 관리를 포함한
+ * 완전한 DbContext 인스턴스를 생성한다
  *
- * @param def - Definition object created by defineDbContext()
- * @param executor - Query executor (NodeDbContextExecutor, ServiceDbContextExecutor, etc.)
- * @param opt - Database options
- * @param opt.database - Database name
- * @param opt.schema - Schema name (MSSQL: dbo, PostgreSQL: public)
- * @returns A complete DbContext instance
+ * @param def - defineDbContext()로 생성된 정의 객체
+ * @param executor - 쿼리 실행기 (NodeDbContextExecutor, ServiceDbContextExecutor 등)
+ * @param opt - 데이터베이스 옵션
+ * @param opt.database - 데이터베이스 이름
+ * @param opt.schema - schema 이름 (MSSQL: dbo, PostgreSQL: public)
+ * @returns 완전한 DbContext 인스턴스
  *
  * @example
  * ```typescript
@@ -61,12 +61,12 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
   executor: DbContextExecutor,
   opt: { database: string; schema?: string },
 ): DbContextInstance<TDef> {
-  // ── Internal state (closure) ──
+  // ── 내부 상태 (클로저) ──
   let aliasCounter = 0;
   let status: DbContextStatus = "ready";
   let relationsValidated = false;
 
-  // ── DbContextBase implementation ──
+  // ── DbContextBase 구현 ──
   const base: DbContextBase = {
     get status() {
       return status;
@@ -94,7 +94,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
         status === "transact" &&
         defs.some((d) => (DDL_TYPES as readonly string[]).includes(d.type))
       ) {
-        throw new Error("Cannot execute DDL while in TRANSACTION state.");
+        throw new Error("TRANSACTION 상태에서는 DDL을 실행할 수 없습니다.");
       }
       return executor.executeDefs(defs, resultMetas);
     },
@@ -112,9 +112,9 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     },
   };
 
-  // ── Compose all into single object ──
+  // ── 모든 요소를 하나의 객체로 합성 ──
   const db = {
-    // Spread base properties (getters/setters need special handling)
+    // base 속성 전개 (getter/setter는 별도 처리 필요)
     get status() {
       return base.status;
     },
@@ -132,13 +132,13 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     executeDefs: base.executeDefs,
     getQueryDefObjectName: base.getQueryDefObjectName,
 
-    //#region ========== Connection management ==========
+    //#region ========== 연결 관리 ==========
 
     /**
-     * Execute callback within a transaction (automatic commit/rollback)
+     * 트랜잭션 내에서 콜백 실행 (자동 커밋/롤백)
      *
-     * Connect -> Start transaction -> Execute callback -> Commit -> Close connection
-     * If error occurs, automatically rollback and close connection
+     * 연결 -> 트랜잭션 시작 -> 콜백 실행 -> 커밋 -> 연결 종료
+     * 오류 발생 시 자동으로 롤백 후 연결 종료
      */
     async connect<TResult>(
       fn: () => Promise<TResult>,
@@ -191,9 +191,9 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     },
 
     /**
-     * Connect without transaction, execute callback, and auto-close
+     * 트랜잭션 없이 연결 후 콜백 실행, 자동 종료
      *
-     * Used for DDL operations or read operations that don't require transactions
+     * 트랜잭션이 필요 없는 DDL 작업이나 읽기 작업에 사용
      */
     async connectWithoutTransaction<TResult>(callback: () => Promise<TResult>): Promise<TResult> {
       if (!relationsValidated) {
@@ -220,16 +220,16 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     },
 
     /**
-     * Start transaction in already connected state (automatic commit/rollback)
+     * 이미 연결된 상태에서 트랜잭션 시작 (자동 커밋/롤백)
      *
-     * Used when transaction is needed partially within connectWithoutTransaction
+     * connectWithoutTransaction 내에서 부분적으로 트랜잭션이 필요할 때 사용
      */
     async transaction<TResult>(
       fn: () => Promise<TResult>,
       isolationLevel?: IsolationLevel,
     ): Promise<TResult> {
       if (status === "transact") {
-        throw new Error("Already in TRANSACTION state.");
+        throw new Error("이미 TRANSACTION 상태입니다.");
       }
 
       await executor.beginTransaction(isolationLevel);
@@ -253,7 +253,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
           } else {
             throw err1;
           }
-          // If NO_ACTIVE_TRANSACTION error, ignore and throw original error
+          // NO_ACTIVE_TRANSACTION 오류이면 무시하고 원래 오류를 던짐
           status = "connect";
         }
         throw err;
@@ -264,7 +264,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
 
     //#endregion
 
-    //#region ========== DDL execution methods ==========
+    //#region ========== DDL 실행 메서드 ==========
 
     async createTable(table: TableBuilder<any, any>): Promise<void> {
       await base.executeDefs([tableDdl.getCreateTableQueryDef(base, table)]);
@@ -347,7 +347,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
 
     //#endregion
 
-    //#region ========== DDL QueryDef generators ==========
+    //#region ========== DDL QueryDef 생성기 ==========
 
     getCreateTableQueryDef: (table: TableBuilder<any, any>) =>
       tableDdl.getCreateTableQueryDef(base, table),
@@ -383,7 +383,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
 
     //#endregion
 
-    //#region ========== Initialize ==========
+    //#region ========== 초기화 ==========
 
     async initialize(options?: { dbs?: string[]; force?: boolean }): Promise<void> {
       await initializeImpl(db as any, def, options);
@@ -392,7 +392,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     //#endregion
   };
 
-  // ── Add Queryable accessors ──
+  // ── Queryable 접근자 추가 ──
   for (const [key, tableOrView] of Object.entries(def.meta.tables)) {
     (db as any)[key] = queryable(db as any, tableOrView as TableBuilder<any, any>);
   }
@@ -400,7 +400,7 @@ export function createDbContext<TDef extends DbContextDef<any, any, any>>(
     (db as any)[key] = queryable(db as any, view as ViewBuilder<any, any, any>);
   }
 
-  // ── Add Executable accessors ──
+  // ── Executable 접근자 추가 ──
   for (const [key, proc] of Object.entries(def.meta.procedures)) {
     (db as any)[key] = executable(base, proc as ProcedureBuilder<any, any>);
   }

package/src/ddl/column-ddl.ts

@@ -8,7 +8,7 @@ import type {
 } from "../types/query-def";
 
 /**
- * Generate ADD COLUMN QueryDef
+ * ADD COLUMN QueryDef 생성
  */
 export function getAddColumnQueryDef(
   table: QueryDefObjectName,
@@ -29,7 +29,7 @@ export function getAddColumnQueryDef(
 }
 
 /**
- * Generate DROP COLUMN QueryDef
+ * DROP COLUMN QueryDef 생성
  */
 export function getDropColumnQueryDef(
   table: QueryDefObjectName,
@@ -39,7 +39,7 @@ export function getDropColumnQueryDef(
 }
 
 /**
- * Generate MODIFY COLUMN QueryDef
+ * MODIFY COLUMN QueryDef 생성
  */
 export function getModifyColumnQueryDef(
   table: QueryDefObjectName,
@@ -60,7 +60,7 @@ export function getModifyColumnQueryDef(
 }
 
 /**
- * Generate RENAME COLUMN QueryDef
+ * RENAME COLUMN QueryDef 생성
  */
 export function getRenameColumnQueryDef(
   table: QueryDefObjectName,

package/src/ddl/initialize.ts

@@ -15,24 +15,24 @@ import { getAddForeignKeyQueryDef, getAddIndexQueryDef } from "./relation-ddl";
 import { getClearSchemaQueryDef, getSchemaExistsQueryDef } from "./schema-ddl";
 
 /**
- * Code First Database Initialize
+ * Code First 데이터베이스 초기화
  *
- * Creates Tables/Views/Procedures defined in DbContext to Database and
- * applies migrations
+ * DbContext에 정의된 Table/View/Procedure를 데이터베이스에 생성하고
+ * migration을 적용한다
  *
- * @param db - DbContext instance
- * @param def - DbContext definition
- * @param options - Initialize options
- * @param options.dbs - List of target Databases for initialize (current database if not specified)
- * @param options.force - If true, delete existing schema and recreate all
- * @throws {Error} When there is no Database to initialize
- * @throws {Error} When the specified Database does not exist
+ * @param db - DbContext 인스턴스
+ * @param def - DbContext 정의
+ * @param options - 초기화 옵션
+ * @param options.dbs - 초기화 대상 데이터베이스 목록 (미지정 시 현재 데이터베이스)
+ * @param options.force - true이면 기존 schema를 삭제하고 모두 재생성
+ * @throws {Error} 초기화할 데이터베이스가 없을 때
+ * @throws {Error} 지정된 데이터베이스가 존재하지 않을 때
  *
- * Behavior:
- * - **force=true**: clearSchema → create all → register all migrations as "applied"
- * - **force=false** (default):
- *   - No _Migration Table: create all + register all migrations
- *   - _Migration Table exists: execute only unapplied migrations
+ * 동작:
+ * - **force=true**: clearSchema → 전체 생성 → 모든 migration을 "적용됨"으로 등록
+ * - **force=false** (기본값):
+ *   - _Migration 테이블 없음: 전체 생성 + 모든 migration 등록
+ *   - _Migration 테이블 있음: 미적용 migration만 실행
  */
 export async function initialize(
   db: DbContextBase & DbContextDdlMethods & { _migration: () => Queryable<{ code: string }, any> },
@@ -41,55 +41,55 @@ export async function initialize(
 ): Promise<void> {
   const dbNames = options?.dbs ?? (db.database !== undefined ? [db.database] : []);
   if (dbNames.length < 1) {
-    throw new Error("No Database to initialize.");
+    throw new Error("초기화할 데이터베이스가 없습니다.");
   }
 
   const force = options?.force ?? false;
 
-  // 1. Check DB existence
+  // 1. DB 존재 여부 확인
   for (const dbName of dbNames) {
     const schemaExistsDef = getSchemaExistsQueryDef(dbName, db.schema);
     const result = await db.executeDefs([schemaExistsDef]);
     const schemaExists = result[0].length > 0;
     if (!schemaExists) {
-      throw new Error(`Database '${dbName}' does not exist.`);
+      throw new Error(`데이터베이스 '${dbName}'이(가) 존재하지 않습니다.`);
     }
   }
 
   if (force) {
-    // 2. force: initialize all dbs
+    // 2. force: 모든 DB 초기화
     for (const dbName of dbNames) {
       const clearDef = getClearSchemaQueryDef({ database: dbName, schema: db.schema });
       await db.executeDefs([clearDef]);
     }
     await createAllObjects(db, def);
 
-    // Register all migrations as "applied"
+    // 모든 migration을 "적용됨"으로 등록
     if (def.meta.migrations.length > 0) {
       await db._migration().insert(def.meta.migrations.map((m) => ({ code: m.name })));
     }
   } else {
-    // 3. Migration-based initialize
+    // 3. Migration 기반 초기화
     let appliedMigrations: { code: string }[] | undefined;
     try {
       appliedMigrations = await db._migration().execute();
     } catch (err) {
-      // No Table = new environment
+      // 테이블 없음 = 새 환경
       if (!isTableNotExistsError(err)) {
         throw err;
       }
     }
 
     if (appliedMigrations == null) {
-      // New environment: create all
+      // 새 환경: 전체 생성
       await createAllObjects(db, def);
 
-      // Register all migrations as "applied"
+      // 모든 migration을 "적용됨"으로 등록
       if (def.meta.migrations.length > 0) {
         await db._migration().insert(def.meta.migrations.map((m) => ({ code: m.name })));
       }
     } else {
-      // Existing environment: execute only unapplied migrations
+      // 기존 환경: 미적용 migration만 실행
       const appliedCodes = new Set(appliedMigrations.map((m) => m.code));
       const pendingMigrations = def.meta.migrations.filter((m) => !appliedCodes.has(m.name));
 
@@ -102,13 +102,13 @@ export async function initialize(
 }
 
 /**
- * Generate all objects (table/view/procedure/FK/index)
+ * 모든 객체 생성 (table/view/procedure/FK/index)
  */
 async function createAllObjects(
   db: DbContextBase,
   def: DbContextDef<any, any, any>,
 ): Promise<void> {
-  // 1. Generate Table/View/Procedure
+  // 1. Table/View/Procedure 생성
   const builders = getBuilders(def);
   const createDefs: QueryDef[] = [];
   for (const builder of builders) {
@@ -118,7 +118,7 @@ async function createAllObjects(
     await db.executeDefs(createDefs);
   }
 
-  // 2. Generate FK (TableBuilder only)
+  // 2. FK 생성 (TableBuilder만)
   const tables = builders.filter((b) => b instanceof TableBuilder);
   const addFkDefs: QueryDef[] = [];
   for (const table of tables) {
@@ -136,7 +136,7 @@ async function createAllObjects(
     await db.executeDefs(addFkDefs);
   }
 
-  // 3. Generate Index (TableBuilder only)
+  // 3. Index 생성 (TableBuilder만)
   const createIndexDefs: QueryDef[] = [];
   for (const table of tables) {
     const indexes = table.meta.indexes;
@@ -153,7 +153,7 @@ async function createAllObjects(
 }
 
 /**
- * Collect all builders from DbContext (Table/View/Procedure)
+ * DbContext에서 모든 builder 수집 (Table/View/Procedure)
  */
 function getBuilders(
   def: DbContextDef<any, any, any>,
@@ -186,8 +186,8 @@ function getBuilders(
 }
 
 /**
- * Validate ForeignKeyTarget/RelationKeyTarget relations
- * - Checks if the table returned by targetTableFn() has a FK/RelationKey matching the relationName
+ * ForeignKeyTarget/RelationKeyTarget 관계 검증
+ * - targetTableFn()이 반환하는 테이블에 relationName과 일치하는 FK/RelationKey가 있는지 확인
  */
 export function validateRelations(def: DbContextDef<any, any, any>): void {
   const builders = getBuilders(def);
@@ -211,8 +211,8 @@ export function validateRelations(def: DbContextDef<any, any, any>): void {
 
       if (!(fkRel instanceof ForeignKeyBuilder) && !(fkRel instanceof RelationKeyBuilder)) {
         throw new Error(
-          `Invalid relation target: '${fkRelName}' referenced by ${table.meta.name}.${relName} ` +
-            `is not a valid ForeignKey/RelationKey in ${targetTable.meta.name}.`,
+          `유효하지 않은 관계 대상: ${table.meta.name}.${relName}이(가) 참조하는 '${fkRelName}'은(는) ` +
+            `${targetTable.meta.name}에서 유효한 ForeignKey/RelationKey가 아닙니다.`,
         );
       }
     }
@@ -220,9 +220,9 @@ export function validateRelations(def: DbContextDef<any, any, any>): void {
 }
 
 /**
- * Check if the error indicates a table does not exist
+ * 오류가 테이블 미존재를 나타내는지 확인
  *
- * DBMS-specific error code/message patterns:
+ * DBMS별 오류 코드/메시지 패턴:
  * - MySQL: errno 1146 (ER_NO_SUCH_TABLE), "Table 'xxx' doesn't exist"
  * - MSSQL: number 208, "Invalid object name 'xxx'"
  * - PostgreSQL: code "42P01", "relation \"xxx\" does not exist"
@@ -230,13 +230,13 @@ export function validateRelations(def: DbContextDef<any, any, any>): void {
 function isTableNotExistsError(err: unknown): boolean {
   if (err == null) return false;
 
-  // Check error code first (reliable even in multilingual environments)
+  // 오류 코드를 먼저 확인 (다국어 환경에서도 안정적)
   const errObj = err as Record<string, unknown>;
   if (errObj["errno"] === 1146) return true; // MySQL ER_NO_SUCH_TABLE
   if (errObj["number"] === 208) return true; // MSSQL
   if (errObj["code"] === "42P01") return true; // PostgreSQL
 
-  // Fallback: message matching (may be unreliable in multilingual environments)
+  // 폴백: 메시지 매칭 (다국어 환경에서는 신뢰할 수 없을 수 있음)
   const message = err instanceof Error ? err.message : String(err);
   const lowerMessage = message.toLowerCase();
 

package/src/ddl/relation-ddl.ts

@@ -13,21 +13,21 @@ import { getMatchedPrimaryKeys } from "../exec/queryable";
 import { getQueryDefObjectName } from "./table-ddl";
 
 /**
- * Generate DROP PRIMARY KEY QueryDef
+ * DROP PRIMARY KEY QueryDef 생성
  */
 export function getDropPrimaryKeyQueryDef(table: QueryDefObjectName): DropPrimaryKeyQueryDef {
   return { type: "dropPrimaryKey", table };
 }
 
 /**
- * Generate ADD PRIMARY KEY QueryDef
+ * ADD PRIMARY KEY QueryDef 생성
  */
 export function getAddPrimaryKeyQueryDef(table: QueryDefObjectName, columns: string[]): AddPrimaryKeyQueryDef {
   return { type: "addPrimaryKey", table, columns };
 }
 
 /**
- * Generate ADD FOREIGN KEY QueryDef
+ * ADD FOREIGN KEY QueryDef 생성
  */
 export function getAddForeignKeyQueryDef(
   db: DbContextBase,
@@ -52,7 +52,7 @@ export function getAddForeignKeyQueryDef(
 }
 
 /**
- * ADD INDEX QueryDef Generate
+ * ADD INDEX QueryDef 생성
  */
 export function getAddIndexQueryDef(
   table: QueryDefObjectName,
@@ -75,14 +75,14 @@ export function getAddIndexQueryDef(
 }
 
 /**
- * DROP FOREIGN KEY QueryDef Generate
+ * DROP FOREIGN KEY QueryDef 생성
  */
 export function getDropForeignKeyQueryDef(table: QueryDefObjectName, relationName: string): DropForeignKeyQueryDef {
   return { type: "dropForeignKey", table, foreignKey: `FK_${table.name}_${relationName}` };
 }
 
 /**
- * DROP INDEX QueryDef Generate
+ * DROP INDEX QueryDef 생성
  */
 export function getDropIndexQueryDef(table: QueryDefObjectName, columns: string[]): DropIndexQueryDef {
   return { type: "dropIndex", table, index: `IDX_${table.name}_${columns.join("_")}` };

package/src/ddl/schema-ddl.ts

@@ -7,7 +7,7 @@ import type {
 } from "../types/query-def";
 
 /**
- * Generate CLEAR SCHEMA QueryDef
+ * CLEAR SCHEMA QueryDef 생성
  */
 export function getClearSchemaQueryDef(params: {
   database: string;
@@ -17,21 +17,21 @@ export function getClearSchemaQueryDef(params: {
 }
 
 /**
- * Generate SCHEMA EXISTS QueryDef
+ * SCHEMA EXISTS QueryDef 생성
  */
 export function getSchemaExistsQueryDef(database: string, schema?: string): SchemaExistsQueryDef {
   return { type: "schemaExists", database, schema };
 }
 
 /**
- * Generate TRUNCATE TABLE QueryDef
+ * TRUNCATE TABLE QueryDef 생성
  */
 export function getTruncateQueryDef(table: QueryDefObjectName): TruncateQueryDef {
   return { type: "truncate", table };
 }
 
 /**
- * Generate SWITCH FK QueryDef
+ * SWITCH FK QueryDef 생성
  */
 export function getSwitchFkQueryDef(
   table: QueryDefObjectName,

package/src/ddl/table-ddl.ts

@@ -14,12 +14,12 @@ import type { DbContextBase } from "../types/db-context-def";
 import { obj } from "@simplysm/core-common";
 
 /**
- * Transform Builder to CREATE QueryDef
+ * Builder를 CREATE QueryDef로 변환
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param builder - Table/View/Procedure builder
  * @returns CREATE TABLE/VIEW/PROCEDURE QueryDef
- * @throws {Error} When unknown builder type
+ * @throws {Error} 알 수 없는 builder 타입일 때
  */
 export function getCreateObjectQueryDef(
   db: DbContextBase,
@@ -33,21 +33,21 @@ export function getCreateObjectQueryDef(
     return getCreateProcQueryDef(db, builder);
   }
 
-  throw new Error(`Unknown builder type: ${typeof builder}`);
+  throw new Error(`알 수 없는 builder 타입: ${typeof builder}`);
 }
 
 /**
- * CREATE TABLE QueryDef Generate
+ * CREATE TABLE QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param table - Table builder
  * @returns CREATE TABLE QueryDef
- * @throws {Error} When table has no columns
+ * @throws {Error} 테이블에 column이 없을 때
  */
 export function getCreateTableQueryDef(db: DbContextBase, table: TableBuilder<any, any>): QueryDef {
   const columns = table.meta.columns as ColumnBuilderRecord | undefined;
   if (columns == null) {
-    throw new Error(`Table '${table.meta.name}' has no columns.`);
+    throw new Error(`테이블 '${table.meta.name}'에 column이 없습니다.`);
   }
 
   return {
@@ -65,19 +65,19 @@ export function getCreateTableQueryDef(db: DbContextBase, table: TableBuilder<an
 }
 
 /**
- * CREATE VIEW QueryDef Generate
+ * CREATE VIEW QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param view - View builder
  * @returns CREATE VIEW QueryDef
- * @throws {Error} When view has no viewFn
+ * @throws {Error} View에 viewFn이 없을 때
  */
 export function getCreateViewQueryDef(
   db: DbContextBase,
   view: ViewBuilder<any, any, any>,
 ): QueryDef {
   if (view.meta.viewFn == null) {
-    throw new Error(`View '${view.meta.name}' has no viewFn.`);
+    throw new Error(`View '${view.meta.name}'에 viewFn이 없습니다.`);
   }
 
   const qr = view.meta.viewFn(db);
@@ -95,19 +95,19 @@ export function getCreateViewQueryDef(
 }
 
 /**
- * CREATE PROCEDURE QueryDef Generate
+ * CREATE PROCEDURE QueryDef 생성
  *
- * @param db - DbContext instance
+ * @param db - DbContext 인스턴스
  * @param procedure - Procedure builder
  * @returns CREATE PROCEDURE QueryDef
- * @throws {Error} When procedure has no body
+ * @throws {Error} Procedure에 body가 없을 때
  */
 export function getCreateProcQueryDef(
   db: DbContextBase,
   procedure: ProcedureBuilder<any, any>,
 ): QueryDef {
   if (procedure.meta.query == null) {
-    throw new Error(`Procedure '${procedure.meta.name}' has no body.`);
+    throw new Error(`Procedure '${procedure.meta.name}'에 body가 없습니다.`);
   }
 
   const params = procedure.meta.params as ColumnBuilderRecord | undefined;
@@ -140,14 +140,14 @@ export function getCreateProcQueryDef(
 }
 
 /**
- * DROP TABLE QueryDef Generate
+ * DROP TABLE QueryDef 생성
  */
 export function getDropTableQueryDef(table: QueryDefObjectName): DropTableQueryDef {
   return { type: "dropTable", table };
 }
 
 /**
- * RENAME TABLE QueryDef Generate
+ * RENAME TABLE QueryDef 생성
  */
 export function getRenameTableQueryDef(
   table: QueryDefObjectName,
@@ -157,25 +157,25 @@ export function getRenameTableQueryDef(
 }
 
 /**
- * DROP VIEW QueryDef Generate
+ * DROP VIEW QueryDef 생성
  */
 export function getDropViewQueryDef(view: QueryDefObjectName): DropViewQueryDef {
   return { type: "dropView", view };
 }
 
 /**
- * DROP PROCEDURE QueryDef Generate
+ * DROP PROCEDURE QueryDef 생성
  */
 export function getDropProcQueryDef(procedure: QueryDefObjectName): DropProcQueryDef {
   return { type: "dropProc", procedure };
 }
 
 /**
- * Transform TableBuilder/ViewBuilder to QueryDefObjectName
+ * TableBuilder/ViewBuilder를 QueryDefObjectName으로 변환
  *
- * @param db - DbContext instance
- * @param tableOrView - Table or View builder
- * @returns Object name information for use in QueryDef
+ * @param db - DbContext 인스턴스
+ * @param tableOrView - Table 또는 View builder
+ * @returns QueryDef에서 사용할 객체 이름 정보
  */
 export function getQueryDefObjectName(
   db: DbContextBase,