@simplysm/orm-common 13.0.100 → 14.0.4

package/src/index.ts

@@ -1,6 +1,6 @@
 //#region ========== Core ==========
 
-// Functional API (recommended)
+// 함수형 API (권장)
 export * from "./define-db-context";
 export * from "./create-db-context";
 export * from "./types/db-context-def";
@@ -25,12 +25,12 @@ export * from "./expr/expr-unit";
 
 //#region ========== Schema Builders ==========
 
-// Table / View / Procedure
+// 테이블 / 뷰 / 프로시저
 export * from "./schema/table-builder";
 export * from "./schema/view-builder";
 export * from "./schema/procedure-builder";
 
-// Factory
+// 팩토리
 export * from "./schema/factory/column-builder";
 export * from "./schema/factory/index-builder";
 export * from "./schema/factory/relation-builder";
@@ -59,19 +59,19 @@ export * from "./query-builder/postgresql/postgresql-expr-renderer";
 
 //#region ========== Types ==========
 
-// Database types
+// 데이터베이스 타입
 export * from "./types/db";
 
-// Result parsing
+// 결과 파싱
 export * from "./utils/result-parser";
 
-// Column types
+// column 타입
 export * from "./types/column";
 
-// Expression types
+// 표현식 타입
 export * from "./types/expr";
 
-// QueryDef types
+// QueryDef 타입
 export * from "./types/query-def";
 
 //#endregion

package/src/models/system-migration.ts

@@ -4,5 +4,5 @@ export const _Migration = Table("_migration")
   .columns((c) => ({
     code: c.varchar(255),
   }))
-  .description("System Migration Table")
+  .description("시스템 마이그레이션 테이블")
   .primaryKey("code");

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

@@ -68,12 +68,12 @@ import type {
 import type { SelectQueryDef } from "../../types/query-def";
 
 /**
- * Expr → SQL Render abstract base class
+ * Expr → SQL 렌더링 추상 기본 클래스
  *
- * Base principles:
- * - Implement only 100% identical logic across all dialects (dispatch)
- * - If different at all, make it abstract
- * - Method names match expr.type (enables dynamic dispatch)
+ * 기본 원칙:
+ * - 모든 dialect에서 100% 동일한 로직만 구현 (dispatch)
+ * - 조금이라도 다르면 abstract로 처리
+ * - 메서드 이름이 expr.type과 동일 (동적 dispatch 가능)
  */
 export abstract class ExprRendererBase {
   constructor(protected buildSelect: (def: SelectQueryDef) => string) {}
@@ -81,31 +81,31 @@ export abstract class ExprRendererBase {
   //#region ========== Public Utilities ==========
 
   /**
-   * Wrap identifier (table name, column name, etc.)
+   * 식별자 감싸기 (테이블명, column명 등)
    * MySQL: `name`, MSSQL: [name], PostgreSQL: "name"
    */
   abstract wrap(name: string): string;
 
   /**
-   * Escape for SQL string literals
-   * Called when used as a string value in dynamic SQL or system queries
-   * e.g.: WHERE schema_name = 'escaped_value'
+   * SQL 문자열 리터럴용 이스케이프
+   * 동적 SQL이나 시스템 쿼리에서 문자열 값으로 사용할 때 호출
+   * 예: WHERE schema_name = 'escaped_value'
    */
   abstract escapeString(value: string): string;
 
   /**
-   * Value escape (transform to appropriate SQL literal based on type)
+   * 값 이스케이프 (타입에 맞는 SQL 리터럴로 변환)
    */
   abstract escapeValue(value: unknown): string;
 
   //#endregion
 
-  //#region ========== Dispatch (100% identical) ==========
+  //#region ========== Dispatch (100% 동일) ==========
 
   render(expr: Expr | WhereExpr): string {
     const method = this[expr.type as keyof this];
     if (typeof method !== "function") {
-      throw new Error(`Unknown Expr type: ${expr.type}`);
+      throw new Error(`알 수 없는 Expr 타입: ${expr.type}`);
     }
     return (method as (e: Expr | WhereExpr) => string).call(this, expr);
   }
@@ -125,7 +125,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - comparison (null-safe required) ==========
+  //#region ========== Abstract - 비교 (null-safe 필수) ==========
 
   protected abstract eq(expr: ExprEq): string;
   protected abstract gt(expr: ExprGt): string;
@@ -142,7 +142,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - logic ==========
+  //#region ========== Abstract - 논리 ==========
 
   protected abstract not(expr: ExprNot): string;
   protected abstract and(expr: ExprAnd): string;
@@ -150,7 +150,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - String (null processing required) ==========
+  //#region ========== Abstract - 문자열 (null 처리 필수) ==========
 
   protected abstract concat(expr: ExprConcat): string;
   protected abstract left(expr: ExprLeft): string;
@@ -167,7 +167,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - Number ==========
+  //#region ========== Abstract - 숫자 ==========
 
   protected abstract abs(expr: ExprAbs): string;
   protected abstract round(expr: ExprRound): string;
@@ -176,7 +176,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - Date ==========
+  //#region ========== Abstract - 날짜 ==========
 
   protected abstract year(expr: ExprYear): string;
   protected abstract month(expr: ExprMonth): string;
@@ -193,7 +193,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - Condition ==========
+  //#region ========== Abstract - 조건 ==========
 
   protected abstract coalesce(expr: ExprCoalesce): string;
   protected abstract nullIf(expr: ExprNullIf): string;
@@ -203,7 +203,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - Aggregate ==========
+  //#region ========== Abstract - 집계 ==========
 
   protected abstract count(expr: ExprCount): string;
   protected abstract sum(expr: ExprSum): string;
@@ -213,7 +213,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - Other ==========
+  //#region ========== Abstract - 기타 ==========
 
   protected abstract greatest(expr: ExprGreatest): string;
   protected abstract least(expr: ExprLeast): string;
@@ -229,7 +229,7 @@ export abstract class ExprRendererBase {
 
   //#endregion
 
-  //#region ========== Abstract - System ==========
+  //#region ========== Abstract - 시스템 ==========
 
   protected abstract subquery(expr: ExprSubquery): string;
 

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

@@ -37,14 +37,14 @@ import type { QueryBuildResult } from "../../types/db";
 import type { ExprRendererBase } from "./expr-renderer-base";
 
 /**
- * QueryDef → SQL render abstract base class
+ * QueryDef → SQL 렌더링 추상 기본 클래스
  *
- * Base principles:
- * - Implement only 100% identical logic across all dialects (dispatch)
- * - If different at all, make it abstract
- * - Method name identical to def.type (enables dynamic dispatch)
+ * 기본 원칙:
+ * - 모든 dialect에서 100% 동일한 로직만 구현 (dispatch)
+ * - 조금이라도 다르면 abstract로 처리
+ * - 메서드 이름이 def.type과 동일 (동적 dispatch 가능)
  */
-/** Properties that are part of a basic (non-LATERAL) JOIN */
+/** 기본(비 LATERAL) JOIN의 속성 목록 */
 const BASIC_JOIN_PROPS: ReadonlySet<string> = new Set<
   keyof Pick<SelectQueryDefJoin, "type" | "from" | "as" | "where" | "isSingle">
 >(["type", "from", "as", "where", "isSingle"]);
@@ -52,35 +52,35 @@ const BASIC_JOIN_PROPS: ReadonlySet<string> = new Set<
 export abstract class QueryBuilderBase {
   protected abstract expr: ExprRendererBase;
 
-  //#region ========== Dispatch (100% identical) ==========
+  //#region ========== Dispatch (100% 동일) ==========
 
   build(def: QueryDef): QueryBuildResult {
     const method = this[def.type as keyof this];
     if (typeof method !== "function") {
-      throw new Error(`Unknown QueryDef type: ${def.type}`);
+      throw new Error(`알 수 없는 QueryDef 타입: ${def.type}`);
     }
     return (method as (d: QueryDef) => QueryBuildResult).call(this, def);
   }
 
-  /** Helper to wrap SQL in QueryBuildResult */
+  /** SQL을 QueryBuildResult로 래핑하는 헬퍼 */
   protected result(sql: string, resultSetIndex?: number): QueryBuildResult {
     return resultSetIndex != null ? { sql, resultSetIndex } : { sql };
   }
 
   //#endregion
 
-  //#region ========== Common render method (100% identical) ==========
+  //#region ========== 공통 렌더링 메서드 (100% 동일) ==========
 
-  /** Table name render (different per dialect, so abstract) */
+  /** 테이블명 렌더링 (dialect마다 다르므로 abstract) */
   protected abstract tableName(obj: QueryDefObjectName): string;
 
-  /** WHERE clause render */
+  /** WHERE 절 렌더링 */
   protected renderWhere(wheres: WhereExpr[] | undefined): string {
     if (wheres == null || wheres.length === 0) return "";
     return ` WHERE ${this.expr.renderWhere(wheres)}`;
   }
 
-  /** ORDER BY clause render */
+  /** ORDER BY 절 렌더링 */
   protected renderOrderBy(orderBy: [Expr, ("ASC" | "DESC")?][] | undefined): string {
     if (orderBy == null || orderBy.length === 0) return "";
     const parts = orderBy.map(
@@ -89,58 +89,58 @@ export abstract class QueryBuilderBase {
     return ` ORDER BY ${parts.join(", ")}`;
   }
 
-  /** GROUP BY clause render */
+  /** GROUP BY 절 렌더링 */
   protected renderGroupBy(groupBy: Expr[] | undefined): string {
     if (groupBy == null || groupBy.length === 0) return "";
     return ` GROUP BY ${groupBy.map((g) => this.expr.render(g)).join(", ")}`;
   }
 
-  /** HAVING clause render */
+  /** HAVING 절 렌더링 */
   protected renderHaving(having: WhereExpr[] | undefined): string {
     if (having == null || having.length === 0) return "";
     return ` HAVING ${this.expr.renderWhere(having)}`;
   }
 
-  /** JOIN clause render */
+  /** JOIN 절 렌더링 */
   protected renderJoins(joins: SelectQueryDefJoin[] | undefined): string {
     if (joins == null || joins.length === 0) return "";
     return joins.map((j) => this.renderJoin(j)).join("");
   }
 
-  /** Single JOIN render (different per dialect, so abstract) */
+  /** 단일 JOIN 렌더링 (dialect마다 다르므로 abstract) */
   protected abstract renderJoin(join: SelectQueryDefJoin): string;
 
   /**
-   * Detect if JOIN needs LATERAL/CROSS APPLY
+   * JOIN에 LATERAL/CROSS APPLY가 필요한지 감지
    *
-   * If JOIN has only basic properties (type, from, as, where, isSingle), treat as normal JOIN.
-   * Otherwise, subquery is needed, so use LATERAL JOIN:
+   * JOIN이 기본 속성(type, from, as, where, isSingle)만 가지면 일반 JOIN으로 처리.
+   * 그 외의 경우 서브쿼리가 필요하므로 LATERAL JOIN 사용:
    *
-   * - select: column transformation/aggregation needed (normal JOIN references entire table)
-   * - joins: nested JOIN handled inside subquery
-   * - orderBy, top, limit: sorting/limit applied inside subquery
-   * - groupBy, having: aggregation performed inside subquery
-   * - distinct: deduplication applied inside subquery
-   * - from (array): UNION ALL pattern
+   * - select: column 변환/집계가 필요 (일반 JOIN은 전체 테이블 참조)
+   * - joins: 중첩 JOIN은 서브쿼리 내부에서 처리
+   * - orderBy, top, limit: 정렬/제한은 서브쿼리 내부에서 적용
+   * - groupBy, having: 집계는 서브쿼리 내부에서 수행
+   * - distinct: 중복 제거는 서브쿼리 내부에서 적용
+   * - from (array): UNION ALL 패턴
    *
-   * Note: select and joins are auto-generated during nested joins, so not in basicJoinProps.
-   * Even if user doesn't call .select() directly, internal .joinSingle() may add
-   * select/joins, which also requires subquery.
+   * 참고: select와 joins는 중첩 join 시 자동 생성되므로 basicJoinProps에 없음.
+   * 사용자가 직접 .select()를 호출하지 않더라도 내부 .joinSingle()이
+   * select/joins를 추가할 수 있으며, 이 경우에도 서브쿼리가 필요함.
    */
   protected needsLateral(join: SelectQueryDefJoin): boolean {
-    // If from is array, always LATERAL (UNION ALL pattern)
+    // from이 배열이면 항상 LATERAL (UNION ALL 패턴)
     if (Array.isArray(join.from)) {
       return true;
     }
 
-    // LATERAL needed if join has additional properties beyond basic JOIN properties
+    // 기본 JOIN 속성 외 추가 속성이 있으면 LATERAL 필요
     return Object.keys(join).some((key) => !BASIC_JOIN_PROPS.has(key));
   }
 
-  /** FROM clause source render */
+  /** FROM 절 소스 렌더링 */
   protected renderFrom(from: SelectQueryDef["from"]): string {
     if (from == null) {
-      throw new Error("FROM clause is required.");
+      throw new Error("FROM 절이 필요합니다.");
     }
     if (typeof from === "string") {
       return this.expr.wrap(from);

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

@@ -69,22 +69,22 @@ import type { DataType } from "../../types/column";
 import { ExprRendererBase } from "../base/expr-renderer-base";
 
 /**
- * MSSQL expression renderer
+ * MSSQL 표현식 렌더러
  */
 export class MssqlExprRenderer 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 MssqlExprRenderer extends ExprRendererBase {
     if (value instanceof Uint8Array) {
       return `0x${bytes.toHex(value)}`;
     }
-    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 MssqlExprRenderer extends ExprRendererBase {
   //#region ========== comparison (null-safe) ==========
 
   protected eq(expr: ExprEq): string {
-    // MSSQL: null-safe equal (OR Pattern)
+    // MSSQL: NULL 안전 동등 비교 (OR 패턴)
     const left = this.render(expr.source);
     const right = this.render(expr.target);
     return `((${left} IS NULL AND ${right} IS NULL) OR ${left} = ${right})`;
@@ -217,18 +217,18 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   protected like(expr: ExprLike): string {
-    // Always add ESCAPE '\'
+    // 항상 ESCAPE '\' 추가
     return `${this.render(expr.source)} LIKE ${this.render(expr.pattern)} ESCAPE '\\'`;
   }
 
   protected regexp(_expr: ExprRegexp): string {
-    // MSSQL does not support REGEXP - needs LIKE pattern or CLR
-    throw new Error("MSSQL does not natively support REGEXP.");
+    // MSSQL은 REGEXP을 지원하지 않음 - LIKE 패턴 또는 CLR 필요
+    throw new Error("MSSQL은 기본적으로 REGEXP을 지원하지 않습니다.");
   }
 
   protected in(expr: ExprIn): string {
     if (expr.values.length === 0) {
-      return "1=0"; // empty IN is always false
+      return "1=0"; // 빈 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 MssqlExprRenderer 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 MssqlExprRenderer extends ExprRendererBase {
   //#region ========== String (null handling) ==========
 
   protected concat(expr: ExprConcat): string {
-    // MSSQL 2012+: CONCAT function automatically treats NULL as empty string
+    // MSSQL 2012+: CONCAT 함수는 NULL을 자동으로 빈 문자열로 처리
     const args = expr.args.map((a) => this.render(a)).join(", ");
     return `CONCAT(${args})`;
   }
@@ -288,7 +288,7 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   protected padStart(expr: ExprPadStart): string {
-    // MSSQL: RIGHT(REPLICATE(fill, len) + source, len)
+    // MSSQL: RIGHT(REPLICATE(채움문자, 길이) + 원본, 길이)
     const source = this.render(expr.source);
     const len = this.render(expr.length);
     const fill = this.render(expr.fillString);
@@ -308,12 +308,12 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   protected length(expr: ExprLength): string {
-    // MSSQL: LEN() (null handling)
+    // MSSQL: LEN() (null 처리)
     return `LEN(ISNULL(${this.render(expr.arg)}, N''))`;
   }
 
   protected byteLength(expr: ExprByteLength): string {
-    // MSSQL: DATALENGTH() (null handling)
+    // MSSQL: DATALENGTH() (null 처리)
     return `DATALENGTH(ISNULL(${this.render(expr.arg)}, N''))`;
   }
 
@@ -321,7 +321,7 @@ export class MssqlExprRenderer extends ExprRendererBase {
     if (expr.length != null) {
       return `SUBSTRING(${this.render(expr.source)}, ${this.render(expr.start)}, ${this.render(expr.length)})`;
     }
-    // MSSQL: if no length, go to end
+    // MSSQL: 길이 미지정 시 끝까지
     return `SUBSTRING(${this.render(expr.source)}, ${this.render(expr.start)}, LEN(${this.render(expr.source)}))`;
   }
 
@@ -384,9 +384,9 @@ export class MssqlExprRenderer extends ExprRendererBase {
 
   protected isoWeekStartDate(expr: ExprIsoWeekStartDate): string {
     const src = this.render(expr.arg);
-    // ISO week start date (Monday) - always returns Monday regardless of @@DATEFIRST
-    // Principle: DATEDIFF(DAY, 0, date) is the number of days from 1900-01-01 (Monday)
-    // (days + 6) % 7 + 1 = 1(Mon), 2(Tue), ..., 7(Sun)
+    // ISO 주 시작일 (월요일) - @@DATEFIRST와 무관하게 항상 월요일 반환
+    // 원리: DATEDIFF(DAY, 0, date)는 1900-01-01(월요일)부터의 일수
+    // (days + 6) % 7 + 1 = 1(월), 2(화), ..., 7(일)
     const weekDay = `((DATEDIFF(DAY, 0, ${src}) + 6) % 7 + 1)`;
     return `DATEADD(DAY, 1 - ${weekDay}, CAST(${src} AS DATE))`;
   }
@@ -411,7 +411,7 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   protected formatDate(expr: ExprFormatDate): string {
-    // JS format → MSSQL FORMAT style
+    // JS 포맷 → MSSQL FORMAT 스타일
     const mssqlFormat = this.convertDateFormat(expr.format);
     return `FORMAT(${this.render(expr.source)}, '${mssqlFormat}')`;
   }
@@ -434,7 +434,7 @@ export class MssqlExprRenderer extends ExprRendererBase {
   }
 
   private convertDateFormat(format: string): string {
-    // For MSSQL FORMAT function (uses the same format)
+    // MSSQL FORMAT 함수용 (동일 포맷 사용)
     return format;
   }
 
@@ -502,17 +502,17 @@ export class MssqlExprRenderer extends ExprRendererBase {
   //#region ========== Other ==========
 
   protected greatest(expr: ExprGreatest): string {
-    if (expr.args.length === 0) throw new Error("greatest requires at least one argument.");
+    if (expr.args.length === 0) throw new Error("greatest에는 최소 1개의 인수가 필요합니다.");
     if (expr.args.length === 1) return this.render(expr.args[0]);
-    // MSSQL 2012+: VALUES + MAX approach
+    // MSSQL 2012+: VALUES + MAX 방식
     const values = expr.args.map((a) => `(${this.render(a)})`).join(", ");
     return `(SELECT MAX(v) FROM (VALUES ${values}) AS t(v))`;
   }
 
   protected least(expr: ExprLeast): string {
-    if (expr.args.length === 0) throw new Error("least requires at least one argument.");
+    if (expr.args.length === 0) throw new Error("least에는 최소 1개의 인수가 필요합니다.");
     if (expr.args.length === 1) return this.render(expr.args[0]);
-    // MSSQL 2012+: VALUES + MIN approach
+    // MSSQL 2012+: VALUES + MIN 방식
     const values = expr.args.map((a) => `(${this.render(a)})`).join(", ");
     return `(SELECT MIN(v) FROM (VALUES ${values}) AS t(v))`;
   }
@@ -537,7 +537,7 @@ export class MssqlExprRenderer 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";
     }