@simplysm/orm-common 13.0.100 → 14.0.4

package/src/query-builder/mysql/mysql-query-builder.ts

@@ -39,20 +39,20 @@ import { MysqlExprRenderer } from "./mysql-expr-renderer";
 /**
  * MySQL QueryBuilder
  *
- * MySQL specifics:
- * - No OUTPUT support: workaround via multi-statement pattern (INSERT + SET @var + SELECT)
- * - INSERT OUTPUT: uses LAST_INSERT_ID() for AI column, extracts PK from record for non-AI
- * - UPDATE/UPSERT OUTPUT: saves PK to temp table first since WHERE condition may change after UPDATE, then SELECT
- * - DELETE OUTPUT: saves output columns to temp table before delete
- * - switchFk: global setting (SET FOREIGN_KEY_CHECKS), table parameter is ignored
- * - Index is automatically created when adding FK
+ * MySQL 고유 사항:
+ * - OUTPUT 미지원: multi-statement 패턴으로 우회 (INSERT + SET @var + SELECT)
+ * - INSERT OUTPUT: AI column은 LAST_INSERT_ID() 사용, 비 AI는 레코드에서 PK 추출
+ * - UPDATE/UPSERT OUTPUT: UPDATE 후 WHERE 조건이 변경될 수 있으므로 먼저 PK를 임시 테이블에 저장 후 SELECT
+ * - DELETE OUTPUT: 삭제 전 output column을 임시 테이블에 저장
+ * - switchFk: 전역 설정 (SET FOREIGN_KEY_CHECKS), table 파라미터 무시
+ * - FK 추가 시 인덱스 자동 생성
  */
 export class MysqlQueryBuilder extends QueryBuilderBase {
   protected expr = new MysqlExprRenderer((def) => this.select(def).sql);
 
   //#region ========== Utilities ==========
 
-  /** Render table name (MySQL: ignores schema, uses database.table only) */
+  /** 테이블명 렌더링 (MySQL: schema 무시, database.table만 사용) */
   protected tableName(obj: QueryDefObjectName): string {
     if (obj.database != null) {
       return `${this.expr.wrap(obj.database)}.${this.expr.wrap(obj.name)}`;
@@ -60,7 +60,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     return this.expr.wrap(obj.name);
   }
 
-  /** Render LIMIT clause */
+  /** LIMIT 절 렌더링 */
   protected renderLimit(limit: [number, number] | undefined, top: number | undefined): string {
     if (limit != null) {
       const [offset, count] = limit;
@@ -75,15 +75,15 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
   protected renderJoin(join: SelectQueryDefJoin): string {
     const alias = this.expr.wrap(join.as);
 
-    // Detect if LATERAL JOIN is needed
+    // LATERAL JOIN이 필요한지 감지
     if (this.needsLateral(join)) {
-      // If from is an array (UNION ALL), use renderFrom(join.from),
-      // otherwise (orderBy, top, select, etc.) use renderFrom(join) to generate subquery
+      // from이 배열(UNION ALL)이면 renderFrom(join.from) 사용,
+      // 그 외(orderBy, top, select 등)이면 renderFrom(join)으로 서브쿼리 생성
       const from = Array.isArray(join.from) ? this.renderFrom(join.from) : this.renderFrom(join);
       return ` LEFT OUTER JOIN LATERAL ${from} AS ${alias} ON TRUE`;
     }
 
-    // Normal JOIN
+    // 일반 JOIN
     const from = this.renderFrom(join.from);
     const where =
       join.where != null && join.where.length > 0
@@ -128,7 +128,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
 
     // LOCK
     if (def.lock) {
-      // MySQL: SELECT ... FOR UPDATE (appended at the end)
+      // MySQL: SELECT ... FOR UPDATE (끝에 추가)
     }
 
     // JOINs
@@ -149,7 +149,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     // LIMIT
     sql += this.renderLimit(def.limit, def.top);
 
-    // LOCK (FOR UPDATE at end)
+    // LOCK (끝에 FOR UPDATE 추가)
     if (def.lock) {
       sql += " FOR UPDATE";
     }
@@ -165,13 +165,13 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const table = this.tableName(def.table);
 
     if (def.records.length === 0) {
-      throw new Error("INSERT requires at least one record.");
+      throw new Error("INSERT에는 최소 1개의 레코드가 필요합니다.");
     }
 
     const columns = Object.keys(def.records[0]);
     const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
 
-    // No OUTPUT needed: simple batch INSERT
+    // OUTPUT 불필요: 단순 배치 INSERT
     if (def.output == null) {
       const valuesList = def.records.map((record) => {
         const values = columns.map((c) => this.expr.escapeValue(record[c]));
@@ -180,9 +180,9 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return { sql: `INSERT INTO ${table} (${colList}) VALUES ${valuesList.join(", ")}` };
     }
 
-    // OUTPUT needed: execute INSERT + SELECT via multi-statement
-    // Result sets: [INSERT result, SELECT result, INSERT result, SELECT result, ...]
-    // → Extract only SELECT results with resultSetIndex=1, resultSetStride=2
+    // OUTPUT 필요: multi-statement로 INSERT + SELECT 실행
+    // 결과 셋: [INSERT 결과, SELECT 결과, INSERT 결과, SELECT 결과, ...]
+    // → resultSetIndex=1, resultSetStride=2로 SELECT 결과만 추출
     const output = def.output;
     const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
     const statements: string[] = [];
@@ -191,7 +191,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       const values = columns.map((c) => this.expr.escapeValue(record[c])).join(", ");
       statements.push(`INSERT INTO ${table} (${colList}) VALUES (${values})`);
 
-      // SELECT by PK (uses LAST_INSERT_ID() for aiColName)
+      // PK로 SELECT (aiColName에는 LAST_INSERT_ID() 사용)
       const whereForSelect = output.pkColNames.map((pk) => {
         const wrappedPk = this.expr.wrap(pk);
         if (pk === output.aiColName) {
@@ -216,23 +216,23 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
     const values = columns.map((c) => this.expr.escapeValue(def.record[c])).join(", ");
 
-    // Render existsSelectQuery as SELECT 1 AS _
+    // existsSelectQuery를 SELECT 1 AS _로 렌더링
     const existsQuerySql = this.select({
       ...def.existsSelectQuery,
       select: { _: { type: "value", value: 1 } },
     }).sql;
 
-    // No OUTPUT needed: simple INSERT IF NOT EXISTS
+    // OUTPUT 불필요: 단순 INSERT IF NOT EXISTS
     if (def.output == null) {
       const sql = `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
       return { sql };
     }
 
-    // OUTPUT needed: multi-statement (INSERT + SET @affected + SELECT)
+    // OUTPUT 필요: multi-statement (INSERT + SET @affected + SELECT)
     const output = def.output;
     const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
 
-    // SELECT WHERE condition for OUTPUT
+    // OUTPUT용 SELECT WHERE 조건
     const whereForSelect = output.pkColNames.map((pk) => {
       const wrappedPk = this.expr.wrap(pk);
       if (pk === output.aiColName) {
@@ -241,14 +241,14 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return `${wrappedPk} = ${this.expr.escapeValue(def.record[pk])}`;
     });
 
-    // multi-statement: INSERT → SET @affected → SELECT (result only if inserted)
+    // multi-statement: INSERT → SET @affected → SELECT (삽입된 경우에만 결과 반환)
     const statements = [
       `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`,
       `SET @sd_affected = ROW_COUNT()`,
       `SELECT ${outputCols} FROM ${table} WHERE ${whereForSelect.join(" AND ")} AND @sd_affected > 0`,
     ];
 
-    // results[0]=INSERT, results[1]=SET(empty result), results[2]=SELECT
+    // results[0]=INSERT, results[1]=SET(빈 결과), results[2]=SELECT
     return { sql: statements.join(";\n"), resultSetIndex: 2 };
   }
 
@@ -256,7 +256,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const table = this.tableName(def.table);
     const selectSql = this.select(def.recordsSelectQuery).sql;
 
-    // Extract columns from INSERT INTO SELECT
+    // INSERT INTO SELECT에서 column 추출
     const selectDef = def.recordsSelectQuery;
     const colList =
       selectDef.select != null
@@ -265,15 +265,15 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
             .join(", ")
         : "*";
 
-    // No OUTPUT needed: simple INSERT INTO SELECT
+    // OUTPUT 불필요: 단순 INSERT INTO SELECT
     if (def.output == null) {
       return { sql: `INSERT INTO ${table} (${colList}) ${selectSql}` };
     }
 
-    // OUTPUT needed: multi-statement
+    // OUTPUT 필요: multi-statement
     const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
 
-    // When PK is AI: query range via LAST_INSERT_ID() + ROW_COUNT()
+    // PK가 AI인 경우: LAST_INSERT_ID() + ROW_COUNT()로 범위 조회
     if (def.output.aiColName != null) {
       const aiCol = this.expr.wrap(def.output.aiColName);
 
@@ -283,14 +283,14 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
         `SELECT ${outputCols} FROM ${table} WHERE ${aiCol} >= @sd_first_id AND ${aiCol} < @sd_first_id + @sd_count`,
       ];
 
-      // results[0]=INSERT, results[1]=SET(empty result), results[2]=SELECT
+      // results[0]=INSERT, results[1]=SET(빈 결과), results[2]=SELECT
       return { sql: statements.join(";\n"), resultSetIndex: 2 };
     }
 
-    // PK is not AI: save PKs to temp table then query
+    // PK가 AI가 아닌 경우: PK를 임시 테이블에 저장 후 조회
     const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
 
-    // Generate SELECT extracting only PK columns from recordsSelectQuery
+    // recordsSelectQuery에서 PK column만 추출하는 SELECT 생성
     const pkSelectDef: SelectQueryDef = {
       ...def.recordsSelectQuery,
       select: Object.fromEntries(
@@ -299,7 +299,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     };
     const pkSelectSql = this.select(pkSelectDef).sql;
 
-    // SELECT from target using PK from temp table
+    // 임시 테이블의 PK를 사용하여 대상에서 SELECT
     const pkConditions = def.output.pkColNames.map((pk) => {
       const wrappedPk = this.expr.wrap(pk);
       return `${table}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
@@ -312,7 +312,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       `DROP TEMPORARY TABLE ${tempTableName}`,
     ];
 
-    // results[0]=CREATE, results[1]=INSERT, results[2]=SELECT, results[3]=DROP
+    // results[0]=CREATE, results[1]=INSERT, results[2]=SELECT, results[3]=DROP 결과
     return { sql: statements.join(";\n"), resultSetIndex: 2 };
   }
 
@@ -329,7 +329,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       ([col, expr]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(expr)}`,
     );
 
-    // No OUTPUT needed: simple UPDATE
+    // OUTPUT 불필요: 단순 UPDATE
     if (def.output == null) {
       let sql = `UPDATE ${table} AS ${alias}`;
       sql += this.renderJoins(def.joins);
@@ -341,11 +341,11 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return { sql };
     }
 
-    // OUTPUT needed: multi-statement (save PK to temp table + UPDATE + SELECT + DROP)
+    // OUTPUT 필요: multi-statement (PK를 임시 테이블에 저장 + UPDATE + SELECT + DROP)
     const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
     const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
 
-    // Save target PKs to temp table (since WHERE condition may change after UPDATE)
+    // 대상 PK를 임시 테이블에 저장 (UPDATE 후 WHERE 조건이 변경될 수 있으므로)
     const pkSelectCols = def.output.pkColNames
       .map((pk) => `${alias}.${this.expr.wrap(pk)} AS ${this.expr.wrap(pk)}`)
       .join(", ");
@@ -360,14 +360,14 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     updateSql += this.renderWhere(def.where);
     if (def.top != null) updateSql += ` LIMIT ${def.top}`;
 
-    // SELECT using PK from temp table (query updated values)
+    // 임시 테이블의 PK로 SELECT (업데이트된 값 조회)
     const pkConditions = def.output.pkColNames.map((pk) => {
       const wrappedPk = this.expr.wrap(pk);
       return `${alias}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
     });
     const selectSql = `SELECT ${outputCols} FROM ${table} AS ${alias}, ${tempTableName} WHERE ${pkConditions.join(" AND ")}`;
 
-    // Drop temp table
+    // 임시 테이블 삭제
     const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
 
     const statements = [createTempSql, updateSql, selectSql, dropSql];
@@ -382,7 +382,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const table = this.tableName(def.table);
     const alias = this.expr.wrap(def.as);
 
-    // No OUTPUT needed: simple DELETE
+    // OUTPUT 불필요: 단순 DELETE
     if (def.output == null) {
       let sql = `DELETE ${alias} FROM ${table} AS ${alias}`;
       sql += this.renderJoins(def.joins);
@@ -393,25 +393,25 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return { sql };
     }
 
-    // OUTPUT needed: multi-statement (save to temp table before delete + DELETE + SELECT + DROP)
+    // OUTPUT 필요: multi-statement (삭제 전 임시 테이블에 저장 + DELETE + SELECT + DROP)
     const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
     const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
 
-    // Save to temp table before delete
+    // 삭제 전 임시 테이블에 저장
     let createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${outputCols} FROM ${table} AS ${alias}`;
     createTempSql += this.renderJoins(def.joins);
     createTempSql += this.renderWhere(def.where);
 
-    // Execute DELETE
+    // DELETE 실행
     let deleteSql = `DELETE ${alias} FROM ${table} AS ${alias}`;
     deleteSql += this.renderJoins(def.joins);
     deleteSql += this.renderWhere(def.where);
     if (def.top != null) deleteSql += ` LIMIT ${def.top}`;
 
-    // Return results from temp table
+    // 임시 테이블에서 결과 반환
     const selectSql = `SELECT * FROM ${tempTableName}`;
 
-    // Drop temp table
+    // 임시 테이블 삭제
     const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
 
     const statements = [createTempSql, deleteSql, selectSql, dropSql];
@@ -427,17 +427,17 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const alias = this.expr.wrap(def.existsSelectQuery.as);
     const existsQuerySql = this.select(def.existsSelectQuery).sql;
 
-    // UPDATE SET part (alias.column format)
+    // UPDATE SET 부분 (alias.column 형식)
     const updateSetParts = Object.entries(def.updateRecord).map(
       ([col, e]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(e)}`,
     );
 
-    // INSERT part
+    // INSERT 부분
     const insertColumns = Object.keys(def.insertRecord);
     const insertColList = insertColumns.map((c) => this.expr.wrap(c)).join(", ");
     const insertValues = insertColumns.map((c) => this.expr.render(def.insertRecord[c])).join(", ");
 
-    // Extract WHERE condition (from existsSelectQuery's where)
+    // WHERE 조건 추출 (existsSelectQuery의 where에서)
     const whereCondition =
       def.existsSelectQuery.where != null && def.existsSelectQuery.where.length > 0
         ? this.expr.renderWhere(def.existsSelectQuery.where)
@@ -454,22 +454,22 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return { sql: statements.join(";\n") };
     }
 
-    // OUTPUT needed: multi-statement (CREATE TEMP + UPDATE + INSERT + SELECT + DROP)
+    // OUTPUT 필요: multi-statement (CREATE TEMP + UPDATE + INSERT + SELECT + DROP)
     const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
     const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
 
-    // Save target PKs to temp table (since WHERE condition may change after UPDATE)
+    // 대상 PK를 임시 테이블에 저장 (UPDATE 후 WHERE 조건이 변경될 수 있으므로)
     const pkSelectCols = def.output.pkColNames.map((pk) => this.expr.wrap(pk)).join(", ");
     const createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${pkSelectCols} FROM ${table} AS ${alias} WHERE ${whereCondition}`;
 
-    // UPDATE (update if exists)
+    // UPDATE (존재하면 업데이트)
     const updateSql = `UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")} WHERE ${whereCondition}`;
 
-    // INSERT (NOT EXISTS Pattern)
+    // INSERT (NOT EXISTS 패턴)
     const insertSql = `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`;
 
-    // SELECT: query UPDATE result or INSERT result (merged with UNION ALL)
-    // UPDATE case: query by PK from temp table
+    // SELECT: UPDATE 결과 또는 INSERT 결과 조회 (UNION ALL로 병합)
+    // UPDATE 경우: 임시 테이블의 PK로 조회
     const output = def.output;
     const updatePkConditions = output.pkColNames.map((pk) => {
       const wrappedPk = this.expr.wrap(pk);
@@ -477,7 +477,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     });
     const selectUpdateSql = `SELECT ${outputCols} FROM ${table} WHERE ${updatePkConditions.join(" AND ")}`;
 
-    // INSERT case: query by PK from insertRecord (LAST_INSERT_ID() for AI, only when temp table is empty)
+    // INSERT 경우: insertRecord의 PK로 조회 (AI에는 LAST_INSERT_ID() 사용, 임시 테이블이 비어있을 때만)
     const insertPkConditions = output.pkColNames.map((pk) => {
       const wrappedPk = this.expr.wrap(pk);
       if (pk === output.aiColName) {
@@ -490,7 +490,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
 
     const selectSql = `${selectUpdateSql} UNION ALL ${selectInsertSql}`;
 
-    // DROP
+    // 임시 테이블 삭제
     const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
 
     const statements = [createTempSql, updateSql, insertSql, selectSql, dropSql];
@@ -507,7 +507,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const colDefs = def.columns.map((col) => {
       let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
 
-      // nullable: true → NULL, else → NOT NULL
+      // nullable: true → NULL, 아니면 → NOT NULL
       if (col.nullable === true) {
         colSql += " NULL";
       } else {
@@ -525,7 +525,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       return colSql;
     });
 
-    // Primary Key with CONSTRAINT name
+    // CONSTRAINT 이름이 포함된 Primary Key
     if (def.primaryKey != null && def.primaryKey.length > 0) {
       const pkCols = def.primaryKey.map((c) => this.expr.wrap(c)).join(", ");
       const pkName = this.expr.wrap(`PK_${def.table.name}`);
@@ -544,7 +544,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
   }
 
   protected truncate(def: TruncateQueryDef): QueryBuildResult {
-    // MySQL: TRUNCATE automatically resets AUTO_INCREMENT
+    // MySQL: TRUNCATE는 AUTO_INCREMENT를 자동으로 초기화
     return { sql: `TRUNCATE TABLE ${this.tableName(def.table)}` };
   }
 
@@ -608,7 +608,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
 
   protected renameColumn(def: RenameColumnQueryDef): QueryBuildResult {
     const table = this.tableName(def.table);
-    // MySQL 8.0+: RENAME COLUMN supported
+    // MySQL 8.0+: RENAME COLUMN 지원
     return {
       sql: `ALTER TABLE ${table} RENAME COLUMN ${this.expr.wrap(def.column)} TO ${this.expr.wrap(def.newName)}`,
     };
@@ -635,7 +635,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     const targetTable = this.tableName(fk.targetTable);
     const targetCols = fk.targetPkColumns.map((c) => this.expr.wrap(c)).join(", ");
 
-    // MySQL automatically creates index when adding FK, so no separate index needed
+    // MySQL은 FK 추가 시 인덱스를 자동 생성하므로 별도 인덱스 불필요
     return {
       sql: `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(fk.name)} FOREIGN KEY (${fkCols}) REFERENCES ${targetTable} (${targetCols})`,
     };
@@ -676,7 +676,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
   protected createProc(def: CreateProcQueryDef): QueryBuildResult {
     const proc = this.tableName(def.procedure);
 
-    // Process params
+    // 파라미터 처리
     const paramList =
       def.params
         ?.map((p) => {
@@ -719,11 +719,11 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
   //#region ========== Utils ==========
 
   protected clearSchema(def: ClearSchemaQueryDef): QueryBuildResult {
-    // MySQL: DROP all tables (in MySQL, database and schema are synonymous)
-    // Query table list from information_schema then DROP
-    // SQL injection prevention: identifier validation
+    // MySQL: 모든 테이블 삭제 (MySQL에서 database와 schema는 동의어)
+    // information_schema에서 테이블 목록 조회 후 DROP
+    // SQL 인젝션 방지: 식별자 유효성 검사
     if (!/^[a-zA-Z0-9_]+$/.test(def.database)) {
-      throw new Error(`Invalid database name: ${def.database}`);
+      throw new Error(`잘못된 데이터베이스 이름: ${def.database}`);
     }
 
     const dbName = this.expr.escapeString(def.database);
@@ -741,14 +741,14 @@ SET FOREIGN_KEY_CHECKS = 1`,
   }
 
   protected schemaExists(def: SchemaExistsQueryDef): QueryBuildResult {
-    // MySQL: database and schema are synonymous
+    // MySQL: database와 schema는 동의어
     const dbName = this.expr.escapeString(def.database);
     return {
       sql: `SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = '${dbName}'`,
     };
   }
 
-  /** MySQL only supports global setting (table parameter is ignored) */
+  /** MySQL은 전역 설정만 지원 (table 파라미터 무시) */
   protected switchFk(def: SwitchFkQueryDef): QueryBuildResult {
     return def.enabled
       ? { sql: "SET FOREIGN_KEY_CHECKS = 1" }

package/src/query-builder/postgresql/postgresql-expr-renderer.ts

@@ -69,22 +69,22 @@ import type { DataType } from "../../types/column";
 import { ExprRendererBase } from "../base/expr-renderer-base";
 
 /**
- * PostgreSQL expression renderer
+ * PostgreSQL 표현식 렌더러
  */
 export class PostgresqlExprRenderer extends ExprRendererBase {
-  //#region ========== Utilities (public - also used by QueryBuilder) ==========
+  //#region ========== 유틸리티 (public - QueryBuilder에서도 사용) ==========
 
-  /** Wrap identifier */
+  /** 식별자 감싸기 */
   wrap(name: string): string {
     return `"${name.replace(/"/g, '""')}"`;
   }
 
-  /** Escape for SQL string literals (returns without quotes) */
+  /** SQL 문자열 리터럴용 이스케이프 (따옴표 제외) */
   escapeString(value: string): string {
     return value.replace(/'/g, "''");
   }
 
-  /** value escape */
+  /** 값 이스케이프 */
   escapeValue(value: unknown): string {
     if (value == null) {
       return "NULL";
@@ -113,10 +113,10 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
     if (value instanceof Uint8Array) {
       return `'\\x${bytes.toHex(value)}'::bytea`;
     }
-    throw new Error(`Unknown value type: ${typeof value}`);
+    throw new Error(`알 수 없는 값 타입: ${typeof value}`);
   }
 
-  /** DataType → SQL type */
+  /** DataType → SQL 타입 변환 */
   renderDataType(dataType: DataType): string {
     switch (dataType.type) {
       case "int":
@@ -176,7 +176,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   //#region ========== comparison (null-safe) ==========
 
   protected eq(expr: ExprEq): string {
-    // PostgreSQL: null-safe equal (uses IS NOT DISTINCT FROM operator)
+    // PostgreSQL: NULL 안전 동등 비교 (IS NOT DISTINCT FROM 연산자 사용)
     const left = this.render(expr.source);
     const right = this.render(expr.target);
     return `${left} IS NOT DISTINCT FROM ${right}`;
@@ -217,7 +217,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   }
 
   protected like(expr: ExprLike): string {
-    // Always add ESCAPE '\'
+    // 항상 ESCAPE '\' 추가
     return `${this.render(expr.source)} LIKE ${this.render(expr.pattern)} ESCAPE '\\'`;
   }
 
@@ -228,7 +228,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
 
   protected in(expr: ExprIn): string {
     if (expr.values.length === 0) {
-      return "FALSE"; // empty IN is always false
+      return "FALSE"; // 빈 IN은 항상 false
     }
     const values = expr.values.map((v) => this.render(v)).join(", ");
     return `${this.render(expr.source)} IN (${values})`;
@@ -239,7 +239,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   }
 
   protected exists(expr: ExprExists): string {
-    // Render as SELECT 1
+    // SELECT 1로 렌더링
     const subquery = this.buildSelect({
       ...expr.query,
       select: { _: { type: "value", value: 1 } },
@@ -270,7 +270,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   //#region ========== String (null handling) ==========
 
   protected concat(expr: ExprConcat): string {
-    // PostgreSQL: uses || operator with COALESCE
+    // PostgreSQL: COALESCE와 || 연산자 사용
     const args = expr.args.map((a) => `COALESCE(${this.render(a)}, '')`);
     return args.join(" || ");
   }
@@ -304,12 +304,12 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   }
 
   protected length(expr: ExprLength): string {
-    // PostgreSQL: LENGTH() (null handling)
+    // PostgreSQL: LENGTH() (null 처리)
     return `LENGTH(COALESCE(${this.render(expr.arg)}, ''))`;
   }
 
   protected byteLength(expr: ExprByteLength): string {
-    // PostgreSQL: OCTET_LENGTH() (null handling)
+    // PostgreSQL: OCTET_LENGTH() (null 처리)
     return `OCTET_LENGTH(COALESCE(${this.render(expr.arg)}, ''))`;
   }
 
@@ -378,7 +378,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
 
   protected isoWeekStartDate(expr: ExprIsoWeekStartDate): string {
     const src = this.render(expr.arg);
-    // ISO week start date (Monday)
+    // ISO 주 시작일 (월요일)
     return `DATE_TRUNC('week', ${src})::DATE`;
   }
 
@@ -413,7 +413,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   }
 
   protected formatDate(expr: ExprFormatDate): string {
-    // JS format → PostgreSQL TO_CHAR format
+    // JS 포맷 → PostgreSQL TO_CHAR 포맷
     const pgFormat = this.convertDateFormat(expr.format);
     return `TO_CHAR(${this.render(expr.source)}, '${pgFormat}')`;
   }
@@ -436,7 +436,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   }
 
   private convertDateFormat(format: string): string {
-    // JS format → PostgreSQL TO_CHAR format
+    // JS 포맷 → PostgreSQL TO_CHAR 포맷
     return format
       .replace(/yyyy/g, "YYYY")
       .replace(/MM/g, "MM")
@@ -510,14 +510,14 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
   //#region ========== Other ==========
 
   protected greatest(expr: ExprGreatest): string {
-    if (expr.args.length === 0) throw new Error("greatest requires at least one argument.");
-    // PostgreSQL: native GREATEST support
+    if (expr.args.length === 0) throw new Error("greatest에는 최소 1개의 인수가 필요합니다.");
+    // PostgreSQL: GREATEST 네이티브 지원
     return `GREATEST(${expr.args.map((a) => this.render(a)).join(", ")})`;
   }
 
   protected least(expr: ExprLeast): string {
-    if (expr.args.length === 0) throw new Error("least requires at least one argument.");
-    // PostgreSQL: native LEAST support
+    if (expr.args.length === 0) throw new Error("least에는 최소 1개의 인수가 필요합니다.");
+    // PostgreSQL: LEAST 네이티브 지원
     return `LEAST(${expr.args.map((a) => this.render(a)).join(", ")})`;
   }
 
@@ -541,7 +541,7 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
     const fn = this.renderWindowFn(expr.fn);
     let over = this.renderWindowSpec(expr.spec);
 
-    // LAST_VALUE default frame only sees up to CURRENT ROW, so full frame must be specified
+    // LAST_VALUE 기본 프레임은 CURRENT ROW까지만 보므로 전체 프레임을 지정해야 함
     if (expr.fn.type === "lastValue" && over.length > 0) {
       over += " ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING";
     }