@simplysm/orm-common 13.0.69 → 13.0.71

package/dist/expr/expr.js

@@ -5,28 +5,28 @@ import {
 } from "../types/column.js";
 import { ExprUnit, WhereExprUnit } from "./expr-unit.js";
 const expr = {
-  //#region ========== 값 생성 ==========
+  //#region ========== Value creation ==========
   /**
-   * 리터럴 값을 ExprUnit으로 래핑
+   * Wrap literal value as ExprUnit
    *
-   * dataType에 맞는 base 타입으로 widening하여 리터럴 타입 제거
+   * Widen to base type matching dataType, remove literal type
    *
-   * @param dataType - 값의 데이터 타입 ("string", "number", "boolean", "DateTime", "DateOnly", "Time", "Uuid", "Buffer")
-   * @param value - 래핑할 값 (undefined 허용)
-   * @returns 래핑된 ExprUnit 인스턴스
+   * @param dataType - Value의 data type ("string", "number", "boolean", "DateTime", "DateOnly", "Time", "Uuid", "Buffer")
+   * @param value - 래핑할 value (undefined allow)
+   * @returns 래핑된 ExprUnit instance
    *
    * @example
    * ```typescript
-   * // 문자열 값
+   * // String value
    * expr.val("string", "active")
    *
-   * // 숫자 값
+   * // Number value
    * expr.val("number", 100)
    *
-   * // 날짜 값
+   * // Date value
    * expr.val("DateOnly", DateOnly.today())
    *
-   * // undefined 값
+   * // undefined value
    * expr.val("string", undefined)
    * ```
    */
@@ -34,17 +34,17 @@ const expr = {
     return new ExprUnit(dataType, { type: "value", value });
   },
   /**
-   * 컬럼 참조를 생성
+   * Generate column reference
    *
-   * 일반적으로 Queryable 콜백 내 프록시 객체를 사용하므로 직접 호출할 일이 적음
+   * Typically proxy objects are used inside Queryable callbacks
    *
-   * @param dataType - 컬럼의 데이터 타입
-   * @param path - 컬럼 경로 (테이블 alias, 컬럼명 등)
-   * @returns 컬럼 참조 ExprUnit 인스턴스
+   * @param dataType - Column data type
+   * @param path - Column path (table alias, column name, etc.)
+   * @returns Column reference ExprUnit instance
    *
    * @example
    * ```typescript
-   * // 직접 컬럼 참조 (내부용)
+   * // Direct column reference (internal use)
    * expr.col("string", "T1", "name")
    * ```
    */
@@ -52,23 +52,23 @@ const expr = {
     return new ExprUnit(dataType, { type: "column", path });
   },
   /**
-   * Raw SQL 표현식 생성 (escape hatch)
+   * Raw SQL expression Generate (escape hatch)
    *
-   * ORM에서 지원하지 않는 DB별 함수나 문법을 직접 사용할 때 사용.
-   * 태그 템플릿 리터럴 형식으로 사용하며, 보간된 값은 자동으로 파라미터화됨
+   * Use when you need to directly use DB-specific functions or syntax not supported by the ORM.
+   * Used as tagged template literal, interpolated values are automatically parameterized
    *
-   * @param dataType - 반환될 값의 데이터 타입
-   * @returns 태그 템플릿 함수
+   * @param dataType - Data type of the returned value
+   * @returns Tagged template function
    *
    * @example
    * ```typescript
-   * // MySQL JSON 함수 사용
+   * // Using MySQL JSON function
    * db.user().select((u) => ({
    *   name: u.name,
    *   data: expr.raw("string")`JSON_EXTRACT(${u.metadata}, '$.email')`,
    * }))
    *
-   * // PostgreSQL 배열 함수
+   * // PostgreSQL array function
    * expr.raw("number")`ARRAY_LENGTH(${u.tags}, 1)`
    * ```
    */
@@ -85,15 +85,15 @@ const expr = {
     };
   },
   //#endregion
-  //#region ========== WHERE - 비교 연산 ==========
+  //#region ========== WHERE - Comparison operators ==========
   /**
-   * 동등 비교 (NULL-safe)
+   * Equality comparison (NULL-safe)
    *
-   * NULL 값도 안전하게 비교 (MySQL: `<=>`, MSSQL/PostgreSQL: `IS NULL OR =`)
+   * Safely compare even NULL values (MySQL: `<=>`, MSSQL/PostgreSQL: `IS NULL OR =`)
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param target - 비교 대상 값 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param target - Target value or expression for comparison
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -109,11 +109,11 @@ const expr = {
     });
   },
   /**
-   * 초과 비교 (>)
+   * Greater than comparison (>)
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param target - 비교 대상 값 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param target - Target value or expression for comparison
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -129,11 +129,11 @@ const expr = {
     });
   },
   /**
-   * 미만 비교 (<)
+   * Less than comparison (<)
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param target - 비교 대상 값 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param target - Target value or expression for comparison
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -149,11 +149,11 @@ const expr = {
     });
   },
   /**
-   * 이상 비교 (>=)
+   * Greater than or equal comparison (>=)
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param target - 비교 대상 값 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param target - Target value or expression for comparison
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -169,11 +169,11 @@ const expr = {
     });
   },
   /**
-   * 이하 비교 (<=)
+   * Less than or equal comparison (<=)
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param target - 비교 대상 값 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param target - Target value or expression for comparison
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -189,22 +189,22 @@ const expr = {
     });
   },
   /**
-   * 범위 비교 (BETWEEN)
+   * range comparison (BETWEEN)
    *
    * from/to가 undefined이면 해당 방향은 무제한
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param from - 시작 값 (undefined이면 하한 없음)
-   * @param to - 끝 값 (undefined이면 상한 없음)
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param from - start value (undefined이면 하한 N/A)
+   * @param to - 끝 value (undefined이면 상한 N/A)
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
-   * // 범위 지정
+   * // range 지정
    * db.user().where((u) => [expr.between(u.age, 18, 65)])
    * // WHERE age BETWEEN 18 AND 65
    *
-   * // 하한만 지정
+   * // Specify only lower bound
    * db.user().where((u) => [expr.between(u.age, 18, undefined)])
    * // WHERE age >= 18
    * ```
@@ -218,12 +218,12 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== WHERE - NULL 체크 ==========
+  //#region ========== WHERE - NULL check ==========
   /**
    * NULL 체크 (IS NULL)
    *
-   * @param source - 체크할 컬럼 또는 표현식
-   * @returns WHERE 조건 표현식
+   * @param source - 체크할 column 또는 expression
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -238,16 +238,16 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== WHERE - 문자열 검색 ==========
+  //#region ========== WHERE - String search ==========
   /**
-   * LIKE 패턴 매칭
+   * LIKE pattern 매칭
    *
    * `%`는 0개 이상의 문자, `_`는 단일 문자와 매칭.
-   * 특수문자는 `\`로 이스케이프됨
+   * 특수문자는 `\`로 escape됨
    *
-   * @param source - 검색할 컬럼 또는 표현식
-   * @param pattern - 검색 패턴 (%, _ 와일드카드 사용 가능)
-   * @returns WHERE 조건 표현식
+   * @param source - 검색할 column 또는 expression
+   * @param pattern - 검색 pattern (%, _ wildcard 사용 가능)
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -255,7 +255,7 @@ const expr = {
    * db.user().where((u) => [expr.like(u.name, "John%")])
    * // WHERE name LIKE 'John%' ESCAPE '\'
    *
-   * // 포함 검색
+   * // include 검색
    * db.user().where((u) => [expr.like(u.email, "%@gmail.com")])
    * ```
    */
@@ -267,13 +267,13 @@ const expr = {
     });
   },
   /**
-   * 정규식 패턴 매칭
+   * regular expression pattern 매칭
    *
-   * DBMS별 정규식 문법 차이 주의 필요
+   * DBMS별 regular expression 문법 차이 주의 필요
    *
-   * @param source - 검색할 컬럼 또는 표현식
-   * @param pattern - 정규식 패턴
-   * @returns WHERE 조건 표현식
+   * @param source - 검색할 column 또는 expression
+   * @param pattern - regular expression pattern
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -291,11 +291,11 @@ const expr = {
   //#endregion
   //#region ========== WHERE - IN ==========
   /**
-   * IN 연산자 - 값 목록과 비교
+   * IN operator - Value 목록과 comparison
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param values - 비교할 값 목록
-   * @returns WHERE 조건 표현식
+   * @param source - Column or expression to compare
+   * @param values - 비교할 value 목록
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -311,14 +311,14 @@ const expr = {
     });
   },
   /**
-   * IN (SELECT ...) - 서브쿼리 결과와 비교
+   * IN (SELECT ...) - Subquery 결과와 comparison
    *
-   * 서브쿼리는 반드시 단일 컬럼만 SELECT해야 함
+   * Subquery는 반드시 단일 column만 SELECT해야 함
    *
-   * @param source - 비교할 컬럼 또는 표현식
-   * @param query - 단일 컬럼을 반환하는 Queryable
-   * @returns WHERE 조건 표현식
-   * @throws {Error} 서브쿼리가 단일 컬럼이 아닌 경우
+   * @param source - Column or expression to compare
+   * @param query - 단일 column을 반환하는 Queryable
+   * @returns WHERE condition expression
+   * @throws {Error} Subquery가 단일 column이 아닌 경우
    *
    * @example
    * ```typescript
@@ -336,7 +336,7 @@ const expr = {
   inQuery(source, query) {
     const queryDef = query.getSelectQueryDef();
     if (queryDef.select == null || Object.keys(queryDef.select).length !== 1) {
-      throw new Error("inQuery\uC758 \uC11C\uBE0C\uCFFC\uB9AC\uB294 \uB2E8\uC77C \uCEEC\uB7FC\uB9CC SELECT\uD574\uC57C \uD569\uB2C8\uB2E4.");
+      throw new Error("inQuery subquery must SELECT only a single column.");
     }
     return new WhereExprUnit({
       type: "inQuery",
@@ -345,12 +345,12 @@ const expr = {
     });
   },
   /**
-   * EXISTS (SELECT ...) - 서브쿼리 결과 존재 여부 확인
+   * EXISTS (SELECT ...) - Subquery result 존재 여부 확인
    *
-   * 서브쿼리가 하나 이상의 행을 반환하면 true
+   * Subquery가 하나 이상의 행을 반환하면 true
    *
    * @param query - 존재 여부를 확인할 Queryable
-   * @returns WHERE 조건 표현식
+   * @returns WHERE condition expression
    *
    * @example
    * ```typescript
@@ -371,12 +371,12 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== WHERE - 논리 연산 ==========
+  //#region ========== WHERE - Logical operators ==========
   /**
-   * NOT 연산자 - 조건 부정
+   * NOT operator - Condition 부정
    *
-   * @param arg - 부정할 조건
-   * @returns 부정된 WHERE 조건 표현식
+   * @param arg - 부정할 condition
+   * @returns 부정된 WHERE condition expression
    *
    * @example
    * ```typescript
@@ -391,12 +391,12 @@ const expr = {
     });
   },
   /**
-   * AND 연산자 - 모든 조건 충족
+   * AND operator - 모든 condition 충족
    *
-   * 여러 조건을 AND로 결합. where() 메서드에 배열로 전달하면 자동으로 AND 적용됨
+   * 여러 조건을 AND로 결합. where() 메서드에 배열로 전달하면 automatic으로 AND applied
    *
-   * @param conditions - AND로 결합할 조건 목록
-   * @returns 결합된 WHERE 조건 표현식
+   * @param conditions - AND로 결합할 condition 목록
+   * @returns 결합된 WHERE condition expression
    *
    * @example
    * ```typescript
@@ -411,7 +411,7 @@ const expr = {
    */
   and(conditions) {
     if (conditions.length === 0) {
-      throw new ArgumentError({ conditions: "\uBE48 \uBC30\uC5F4\uC740 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4" });
+      throw new ArgumentError({ conditions: "empty arrays are not allowed" });
     }
     return new WhereExprUnit({
       type: "and",
@@ -419,10 +419,10 @@ const expr = {
     });
   },
   /**
-   * OR 연산자 - 하나 이상의 조건 충족
+   * OR operator - 하나 이상의 condition 충족
    *
-   * @param conditions - OR로 결합할 조건 목록
-   * @returns 결합된 WHERE 조건 표현식
+   * @param conditions - OR로 결합할 condition 목록
+   * @returns 결합된 WHERE condition expression
    *
    * @example
    * ```typescript
@@ -437,7 +437,7 @@ const expr = {
    */
   or(conditions) {
     if (conditions.length === 0) {
-      throw new ArgumentError({ conditions: "\uBE48 \uBC30\uC5F4\uC740 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4" });
+      throw new ArgumentError({ conditions: "empty arrays are not allowed" });
     }
     return new WhereExprUnit({
       type: "or",
@@ -449,10 +449,10 @@ const expr = {
   /**
    * 문자열 연결 (CONCAT)
    *
-   * NULL 값은 빈 문자열로 처리됨 (DBMS별 자동 변환)
+   * NULL 값은 빈 문자열로 processing됨 (DBMS별 automatic Transform)
    *
    * @param args - 연결할 문자열들
-   * @returns 연결된 문자열 표현식
+   * @returns 연결된 문자열 expression
    *
    * @example
    * ```typescript
@@ -471,9 +471,9 @@ const expr = {
   /**
    * 문자열 왼쪽에서 지정 길이만큼 추출 (LEFT)
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @param length - 추출할 문자 수
-   * @returns 추출된 문자열 표현식
+   * @returns 추출된 문자열 expression
    *
    * @example
    * ```typescript
@@ -493,9 +493,9 @@ const expr = {
   /**
    * 문자열 오른쪽에서 지정 길이만큼 추출 (RIGHT)
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @param length - 추출할 문자 수
-   * @returns 추출된 문자열 표현식
+   * @returns 추출된 문자열 expression
    *
    * @example
    * ```typescript
@@ -513,10 +513,10 @@ const expr = {
     });
   },
   /**
-   * 문자열 양쪽 공백 제거 (TRIM)
+   * 문자열 양쪽 공백 Remove (TRIM)
    *
-   * @param source - 원본 문자열
-   * @returns 공백이 제거된 문자열 표현식
+   * @param source - original string
+   * @returns 공백이 제거된 문자열 expression
    *
    * @example
    * ```typescript
@@ -535,12 +535,12 @@ const expr = {
   /**
    * 문자열 왼쪽 패딩 (LPAD)
    *
-   * 지정 길이가 될 때까지 왼쪽에 fillString 반복 추가
+   * 지정 길이가 될 때까지 왼쪽에 fillString loop Add
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @param length - 목표 길이
    * @param fillString - 패딩에 사용할 문자열
-   * @returns 패딩된 문자열 표현식
+   * @returns 패딩된 문자열 expression
    *
    * @example
    * ```typescript
@@ -548,7 +548,7 @@ const expr = {
    *   orderNo: expr.padStart(expr.cast(o.id, { type: "varchar", length: 10 }), 8, "0"),
    * }))
    * // SELECT LPAD(CAST(id AS VARCHAR(10)), 8, '0') AS orderNo
-   * // 결과: "00000123"
+   * // Result: "00000123"
    * ```
    */
   padStart(source, length, fillString) {
@@ -562,10 +562,10 @@ const expr = {
   /**
    * 문자열 치환 (REPLACE)
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @param from - 찾을 문자열
    * @param to - 대체할 문자열
-   * @returns 치환된 문자열 표현식
+   * @returns 치환된 문자열 expression
    *
    * @example
    * ```typescript
@@ -584,10 +584,10 @@ const expr = {
     });
   },
   /**
-   * 문자열 대문자 변환 (UPPER)
+   * 문자열 대문자 Transform (UPPER)
    *
-   * @param source - 원본 문자열
-   * @returns 대문자로 변환된 문자열 표현식
+   * @param source - original string
+   * @returns 대문자로 Transform된 문자열 expression
    *
    * @example
    * ```typescript
@@ -604,10 +604,10 @@ const expr = {
     });
   },
   /**
-   * 문자열 소문자 변환 (LOWER)
+   * 문자열 소문자 Transform (LOWER)
    *
-   * @param source - 원본 문자열
-   * @returns 소문자로 변환된 문자열 표현식
+   * @param source - original string
+   * @returns 소문자로 Transform된 문자열 expression
    *
    * @example
    * ```typescript
@@ -626,7 +626,7 @@ const expr = {
   /**
    * 문자열 길이 (문자 수)
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @returns 문자 수
    *
    * @example
@@ -648,7 +648,7 @@ const expr = {
    *
    * UTF-8 환경에서 한글은 3바이트
    *
-   * @param source - 원본 문자열
+   * @param source - original string
    * @returns 바이트 수
    *
    * @example
@@ -670,15 +670,15 @@ const expr = {
    *
    * SQL 표준에 따라 1-based index 사용
    *
-   * @param source - 원본 문자열
-   * @param start - 시작 위치 (1부터 시작)
+   * @param source - original string
+   * @param start - start 위치 (1부터 start)
    * @param length - 추출할 길이 (생략 시 끝까지)
-   * @returns 추출된 문자열 표현식
+   * @returns 추출된 문자열 expression
    *
    * @example
    * ```typescript
    * db.user().select((u) => ({
-   *   // "Hello World"에서 인덱스 1부터 5글자: "Hello"
+   *   // "Hello World"에서 Index 1부터 5글자: "Hello"
    *   prefix: expr.substring(u.name, 1, 5),
    * }))
    * // SELECT SUBSTRING(name, 1, 5) AS prefix
@@ -695,11 +695,11 @@ const expr = {
   /**
    * 문자열 내 위치 찾기 (LOCATE/CHARINDEX)
    *
-   * 1-based index 반환, 없으면 0 반환
+   * 1-based index return, 없으면 0 return
    *
    * @param source - 검색할 문자열
    * @param search - 찾을 문자열
-   * @returns 위치 (1부터 시작, 없으면 0)
+   * @returns 위치 (1부터 start, 없으면 0)
    *
    * @example
    * ```typescript
@@ -718,12 +718,12 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== SELECT - 숫자 ==========
+  //#region ========== SELECT - Number ==========
   /**
    * 절대값 (ABS)
    *
-   * @param source - 원본 숫자
-   * @returns 절대값 표현식
+   * @param source - 원본 Number
+   * @returns 절대값 expression
    *
    * @example
    * ```typescript
@@ -742,9 +742,9 @@ const expr = {
   /**
    * 반올림 (ROUND)
    *
-   * @param source - 원본 숫자
+   * @param source - 원본 Number
    * @param digits - 소수점 이하 자릿수
-   * @returns 반올림된 숫자 표현식
+   * @returns 반올림된 Number expression
    *
    * @example
    * ```typescript
@@ -765,8 +765,8 @@ const expr = {
   /**
    * 올림 (CEILING)
    *
-   * @param source - 원본 숫자
-   * @returns 올림된 숫자 표현식
+   * @param source - 원본 Number
+   * @returns 올림된 Number expression
    *
    * @example
    * ```typescript
@@ -786,8 +786,8 @@ const expr = {
   /**
    * 버림 (FLOOR)
    *
-   * @param source - 원본 숫자
-   * @returns 버림된 숫자 표현식
+   * @param source - 원본 Number
+   * @returns 버림된 Number expression
    *
    * @example
    * ```typescript
@@ -805,12 +805,12 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== SELECT - 날짜 ==========
+  //#region ========== SELECT - Date ==========
   /**
    * 연도 추출 (YEAR)
    *
-   * @param source - DateTime 또는 DateOnly 표현식
-   * @returns 연도 (4자리 숫자)
+   * @param source - DateTime 또는 DateOnly expression
+   * @returns 연도 (4자리 Number)
    *
    * @example
    * ```typescript
@@ -829,7 +829,7 @@ const expr = {
   /**
    * 월 추출 (MONTH)
    *
-   * @param source - DateTime 또는 DateOnly 표현식
+   * @param source - DateTime 또는 DateOnly expression
    * @returns 월 (1~12)
    *
    * @example
@@ -849,7 +849,7 @@ const expr = {
   /**
    * 일 추출 (DAY)
    *
-   * @param source - DateTime 또는 DateOnly 표현식
+   * @param source - DateTime 또는 DateOnly expression
    * @returns 일 (1~31)
    *
    * @example
@@ -869,7 +869,7 @@ const expr = {
   /**
    * 시 추출 (HOUR)
    *
-   * @param source - DateTime 또는 Time 표현식
+   * @param source - DateTime 또는 Time expression
    * @returns 시 (0~23)
    *
    * @example
@@ -889,7 +889,7 @@ const expr = {
   /**
    * 분 추출 (MINUTE)
    *
-   * @param source - DateTime 또는 Time 표현식
+   * @param source - DateTime 또는 Time expression
    * @returns 분 (0~59)
    *
    * @example
@@ -909,7 +909,7 @@ const expr = {
   /**
    * 초 추출 (SECOND)
    *
-   * @param source - DateTime 또는 Time 표현식
+   * @param source - DateTime 또는 Time expression
    * @returns 초 (0~59)
    *
    * @example
@@ -929,9 +929,9 @@ const expr = {
   /**
    * ISO 주차 추출
    *
-   * ISO 8601 기준 주차 (월요일 시작, 1~53)
+   * ISO 8601 기준 주차 (월요일 start, 1~53)
    *
-   * @param source - DateOnly 표현식
+   * @param source - DateOnly expression
    * @returns ISO 주차 번호
    *
    * @example
@@ -951,10 +951,10 @@ const expr = {
   /**
    * ISO 주 시작일 (월요일)
    *
-   * 해당 날짜가 속한 주의 월요일 반환
+   * 해당 Date가 속한 주의 월요일 return
    *
-   * @param source - DateOnly 표현식
-   * @returns 주의 시작 날짜 (월요일)
+   * @param source - DateOnly expression
+   * @returns 주의 start Date (월요일)
    *
    * @example
    * ```typescript
@@ -973,9 +973,9 @@ const expr = {
   /**
    * ISO 연월 (해당 월의 1일)
    *
-   * 해당 날짜의 월 첫째 날 반환
+   * 해당 Date의 월 첫째 날 return
    *
-   * @param source - DateOnly 표현식
+   * @param source - DateOnly expression
    * @returns 월의 첫째 날
    *
    * @example
@@ -993,12 +993,12 @@ const expr = {
     });
   },
   /**
-   * 날짜 차이 계산 (DATEDIFF)
+   * Date 차이 계산 (DATEDIFF)
    *
    * @param separator - 단위 ("year", "month", "day", "hour", "minute", "second")
-   * @param from - 시작 날짜
-   * @param to - 끝 날짜
-   * @returns 차이 값 (to - from)
+   * @param from - start Date
+   * @param to - 끝 Date
+   * @returns 차이 value (to - from)
    *
    * @example
    * ```typescript
@@ -1017,12 +1017,12 @@ const expr = {
     });
   },
   /**
-   * 날짜 더하기 (DATEADD)
+   * Date 더하기 (DATEADD)
    *
    * @param separator - 단위 ("year", "month", "day", "hour", "minute", "second")
-   * @param source - 원본 날짜
-   * @param value - 더할 값 (음수 가능)
-   * @returns 계산된 날짜
+   * @param source - 원본 Date
+   * @param value - 더할 value (음수 가능)
+   * @returns 계산된 Date
    *
    * @example
    * ```typescript
@@ -1041,13 +1041,13 @@ const expr = {
     });
   },
   /**
-   * 날짜 포맷 (DATE_FORMAT)
+   * Date 포맷 (DATE_FORMAT)
    *
    * DBMS별로 포맷 문자열 규칙이 다를 수 있음
    *
-   * @param source - 날짜 표현식
+   * @param source - Date expression
    * @param format - 포맷 문자열 (예: "%Y-%m-%d")
-   * @returns 포맷된 문자열 표현식
+   * @returns 포맷된 문자열 expression
    *
    * @example
    * ```typescript
@@ -1066,14 +1066,14 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== SELECT - 조건 ==========
+  //#region ========== SELECT - Condition ==========
   /**
    * NULL 대체 (COALESCE/IFNULL)
    *
-   * 첫 번째 non-null 값을 반환. 마지막 인자가 non-nullable이면 결과도 non-nullable
+   * 첫 번째 non-null 값을 return. 마지막 인자가 non-nullable이면 결과도 non-nullable
    *
-   * @param args - 검사할 값들 (마지막은 기본값)
-   * @returns 첫 번째 non-null 값
+   * @param args - Inspect할 값들 (마지막은 Default value)
+   * @returns 첫 번째 non-null value
    *
    * @example
    * ```typescript
@@ -1085,18 +1085,18 @@ const expr = {
    */
   ifNull,
   /**
-   * 특정 값이면 NULL 반환 (NULLIF)
+   * 특정 값이면 NULL return (NULLIF)
    *
-   * source === value 이면 NULL 반환, 아니면 source 반환
+   * source === value 이면 NULL return, 아니면 source return
    *
-   * @param source - 원본 값
-   * @param value - 비교할 값
-   * @returns NULL 또는 원본 값
+   * @param source - 원본 value
+   * @param value - 비교할 value
+   * @returns NULL 또는 원본 value
    *
    * @example
    * ```typescript
    * db.user().select((u) => ({
-   *   // 빈 문자열을 NULL로 변환
+   *   // 빈 문자열을 NULL로 Transform
    *   bio: expr.nullIf(u.bio, ""),
    * }))
    * // SELECT NULLIF(bio, '') AS bio
@@ -1110,12 +1110,12 @@ const expr = {
     });
   },
   /**
-   * WHERE 표현식을 boolean으로 변환
+   * WHERE 표현식을 boolean으로 Transform
    *
-   * SELECT 절에서 조건 결과를 boolean 컬럼으로 사용할 때 사용
+   * SELECT 절에서 condition 결과를 boolean column으로 사용할 때 사용
    *
-   * @param condition - 변환할 조건
-   * @returns boolean 표현식
+   * @param condition - Transform할 condition
+   * @returns boolean expression
    *
    * @example
    * ```typescript
@@ -1132,11 +1132,11 @@ const expr = {
     });
   },
   /**
-   * CASE WHEN 표현식 빌더
+   * CASE WHEN expression builder
    *
-   * 체이닝 방식으로 조건 분기를 구성
+   * 체이닝 방식으로 condition 분기를 구성
    *
-   * @returns SwitchExprBuilder 인스턴스
+   * @returns SwitchExprBuilder instance
    *
    * @example
    * ```typescript
@@ -1154,12 +1154,12 @@ const expr = {
     return createSwitchBuilder();
   },
   /**
-   * 단순 IF 조건 (삼항 연산자)
+   * 단순 IF condition (삼항 operator)
    *
-   * @param condition - 조건
-   * @param then - 조건이 참일 때 값
-   * @param else_ - 조건이 거짓일 때 값
-   * @returns 조건부 값 표현식
+   * @param condition - Condition
+   * @param then - Condition이 참일 때 value
+   * @param else_ - Condition이 거짓일 때 value
+   * @returns 조건부 value expression
    *
    * @example
    * ```typescript
@@ -1182,7 +1182,7 @@ const expr = {
     }
     const nonNullLiteral = allValues.find((v) => v != null);
     if (nonNullLiteral == null) {
-      throw new Error("if\uC758 then/else \uC911 \uC801\uC5B4\uB3C4 \uD558\uB098\uB294 non-null\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+      throw new Error("At least one of if's then/else must be non-null.");
     }
     return new ExprUnit(inferColumnPrimitiveStr(nonNullLiteral), {
       type: "if",
@@ -1192,21 +1192,21 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== SELECT - 집계 ==========
-  // SUM, AVG, MAX등의 집계는 모든 값이 NULL이거나 행이 없을 때만 NULL 반환 (값이 NULL인 행은 무시함)
+  //#region ========== SELECT - Aggregate ==========
+  // SUM, AVG, MAX등의 집계는 모든 값이 NULL이거나 행이 없을 때만 NULL return (값이 NULL인 행은 무시함)
   /**
-   * 행 수 카운트 (COUNT)
+   * row 수 카운트 (COUNT)
    *
-   * @param arg - 카운트할 컬럼 (생략 시 전체 행 수)
-   * @param distinct - true면 중복 제거
-   * @returns 행 수
+   * @param arg - 카운트할 column (생략 시 전체 row 수)
+   * @param distinct - true면 중복 Remove
+   * @returns row 수
    *
    * @example
    * ```typescript
-   * // 전체 행 수
+   * // 전체 row 수
    * db.user().select(() => ({ total: expr.count() }))
    *
-   * // 중복 제거 카운트
+   * // 중복 Remove 카운트
    * db.order().select((o) => ({
    *   uniqueCustomers: expr.count(o.customerId, true),
    * }))
@@ -1222,9 +1222,9 @@ const expr = {
   /**
    * 합계 (SUM)
    *
-   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
    *
-   * @param arg - 합계를 구할 숫자 컬럼
+   * @param arg - 합계를 구할 Number column
    * @returns 합계 (또는 NULL)
    *
    * @example
@@ -1244,9 +1244,9 @@ const expr = {
   /**
    * 평균 (AVG)
    *
-   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
    *
-   * @param arg - 평균을 구할 숫자 컬럼
+   * @param arg - 평균을 구할 Number column
    * @returns 평균 (또는 NULL)
    *
    * @example
@@ -1266,9 +1266,9 @@ const expr = {
   /**
    * 최대값 (MAX)
    *
-   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
    *
-   * @param arg - 최대값을 구할 컬럼
+   * @param arg - 최대값을 구할 column
    * @returns 최대값 (또는 NULL)
    *
    * @example
@@ -1288,9 +1288,9 @@ const expr = {
   /**
    * 최소값 (MIN)
    *
-   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL 반환
+   * NULL 값은 무시됨. 모든 값이 NULL이면 NULL return
    *
-   * @param arg - 최소값을 구할 컬럼
+   * @param arg - 최소값을 구할 column
    * @returns 최소값 (또는 NULL)
    *
    * @example
@@ -1308,9 +1308,9 @@ const expr = {
     });
   },
   //#endregion
-  //#region ========== SELECT - 기타 ==========
+  //#region ========== SELECT - Other ==========
   /**
-   * 여러 값 중 최대값 (GREATEST)
+   * 여러 value 중 최대값 (GREATEST)
    *
    * @param args - 비교할 값들
    * @returns 최대값
@@ -1330,7 +1330,7 @@ const expr = {
     });
   },
   /**
-   * 여러 값 중 최소값 (LEAST)
+   * 여러 value 중 최소값 (LEAST)
    *
    * @param args - 비교할 값들
    * @returns 최소값
@@ -1350,9 +1350,9 @@ const expr = {
     });
   },
   /**
-   * 행 번호 (ROW_NUMBER 없이 전체 행에 대한 순번)
+   * row 번호 (ROW_NUMBER 없이 전체 행에 대한 순번)
    *
-   * @returns 행 번호 (1부터 시작)
+   * @returns row 번호 (1부터 start)
    *
    * @example
    * ```typescript
@@ -1368,15 +1368,15 @@ const expr = {
     });
   },
   /**
-   * 난수 생성 (RAND/RANDOM)
+   * 난수 Generate (RAND/RANDOM)
    *
-   * 0~1 사이의 난수 반환. ORDER BY에서 랜덤 정렬용으로 주로 사용
+   * 0~1 사이의 난수 return. ORDER BY에서 랜덤 정렬용으로 주로 사용
    *
    * @returns 0~1 사이의 난수
    *
    * @example
    * ```typescript
-   * // 랜덤 정렬
+   * // 랜덤 sorting
    * db.user().orderBy(() => expr.random()).limit(10)
    * ```
    */
@@ -1386,11 +1386,11 @@ const expr = {
     });
   },
   /**
-   * 타입 변환 (CAST)
+   * type transformation (CAST)
    *
-   * @param source - 변환할 표현식
-   * @param targetType - 대상 데이터 타입
-   * @returns 변환된 표현식
+   * @param source - Transform할 expression
+   * @param targetType - 대상 data type
+   * @returns Transform된 expression
    *
    * @example
    * ```typescript
@@ -1408,13 +1408,13 @@ const expr = {
     });
   },
   /**
-   * 스칼라 서브쿼리 - SELECT 절에서 단일 값 반환 서브쿼리
+   * 스칼라 Subquery - SELECT 절에서 단일 value return Subquery
    *
-   * 서브쿼리는 반드시 단일 행, 단일 컬럼을 반환해야 함
+   * Subquery는 반드시 단일 row, 단일 column을 반환해야 함
    *
-   * @param dataType - 반환될 값의 데이터 타입
+   * @param dataType - Data type of the returned value
    * @param queryable - 스칼라 값을 반환하는 Queryable
-   * @returns 서브쿼리 결과 표현식
+   * @returns Subquery result expression
    *
    * @example
    * ```typescript
@@ -1439,12 +1439,12 @@ const expr = {
   //#endregion
   //#region ========== SELECT - Window Functions ==========
   /**
-   * ROW_NUMBER() - 파티션 내 행 번호
+   * ROW_NUMBER() - 파티션 내 row 번호
    *
-   * 각 파티션 내에서 1부터 시작하는 순차 번호 부여
+   * 각 파티션 내에서 1부터 시작하는 sequential 번호 부여
    *
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 행 번호 (1부터 시작)
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns row 번호 (1부터 start)
    *
    * @example
    * ```typescript
@@ -1468,7 +1468,7 @@ const expr = {
   /**
    * RANK() - 파티션 내 순위 (동점 시 같은 순위, 다음 순위 건너뜀)
    *
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+   * @param spec - Window spec (partitionBy, orderBy)
    * @returns 순위 (동점 후 건너뜀: 1, 1, 3)
    *
    * @example
@@ -1491,7 +1491,7 @@ const expr = {
   /**
    * DENSE_RANK() - 파티션 내 밀집 순위 (동점 시 같은 순위, 다음 순위 유지)
    *
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+   * @param spec - Window spec (partitionBy, orderBy)
    * @returns 밀집 순위 (동점 후 연속: 1, 1, 2)
    *
    * @example
@@ -1512,15 +1512,15 @@ const expr = {
     });
   },
   /**
-   * NTILE(n) - 파티션을 n개 그룹으로 분할
+   * NTILE(n) - 파티션을 n개 그룹으로 split
    *
    * @param n - 분할할 그룹 수
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
+   * @param spec - Window spec (partitionBy, orderBy)
    * @returns 그룹 번호 (1 ~ n)
    *
    * @example
    * ```typescript
-   * // 상위 25%를 찾기 위한 사분위 분할
+   * // 상위 25%를 찾기 위한 사분위 split
    * db.user().select((u) => ({
    *   name: u.name,
    *   quartile: expr.ntile(4, {
@@ -1537,12 +1537,12 @@ const expr = {
     });
   },
   /**
-   * LAG() - 이전 행의 값 참조
+   * LAG() - 이전 행의 value 참조
    *
-   * @param column - 참조할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @param options - offset (기본 1), default (이전 행이 없을 때 기본값)
-   * @returns 이전 행의 값 (또는 기본값/NULL)
+   * @param column - column to reference
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @param options - offset (Basic 1), default (이전 행이 없을 때 Default value)
+   * @returns 이전 행의 value (또는 Default value/NULL)
    *
    * @example
    * ```typescript
@@ -1569,12 +1569,12 @@ const expr = {
     });
   },
   /**
-   * LEAD() - 다음 행의 값 참조
+   * LEAD() - 다음 행의 value 참조
    *
-   * @param column - 참조할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @param options - offset (기본 1), default (다음 행이 없을 때 기본값)
-   * @returns 다음 행의 값 (또는 기본값/NULL)
+   * @param column - column to reference
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @param options - offset (Basic 1), default (다음 행이 없을 때 Default value)
+   * @returns 다음 행의 value (또는 Default value/NULL)
    *
    * @example
    * ```typescript
@@ -1601,11 +1601,11 @@ const expr = {
     });
   },
   /**
-   * FIRST_VALUE() - 파티션/프레임의 첫 번째 값
+   * FIRST_VALUE() - 파티션/프레임의 첫 번째 value
    *
-   * @param column - 참조할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 첫 번째 값
+   * @param column - column to reference
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns 첫 번째 value
    *
    * @example
    * ```typescript
@@ -1626,11 +1626,11 @@ const expr = {
     });
   },
   /**
-   * LAST_VALUE() - 파티션/프레임의 마지막 값
+   * LAST_VALUE() - 파티션/프레임의 마지막 value
    *
-   * @param column - 참조할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 마지막 값
+   * @param column - column to reference
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns 마지막 value
    *
    * @example
    * ```typescript
@@ -1651,11 +1651,11 @@ const expr = {
     });
   },
   /**
-   * SUM() OVER - 윈도우 합계
+   * SUM() OVER - Window 합계
    *
-   * @param column - 합계를 구할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 윈도우 내 합계
+   * @param column - 합계를 구할 column
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns Window 내 합계
    *
    * @example
    * ```typescript
@@ -1677,15 +1677,15 @@ const expr = {
     });
   },
   /**
-   * AVG() OVER - 윈도우 평균
+   * AVG() OVER - Window 평균
    *
-   * @param column - 평균을 구할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 윈도우 내 평균
+   * @param column - 평균을 구할 column
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns Window 내 평균
    *
    * @example
    * ```typescript
-   * // 이동 평균
+   * // move 평균
    * db.stock().select((s) => ({
    *   ...s,
    *   movingAvg: expr.avgOver(s.price, {
@@ -1703,11 +1703,11 @@ const expr = {
     });
   },
   /**
-   * COUNT() OVER - 윈도우 카운트
+   * COUNT() OVER - Window 카운트
    *
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @param column - 카운트할 컬럼 (생략 시 전체 행 수)
-   * @returns 윈도우 내 행 수
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @param column - 카운트할 column (생략 시 전체 row 수)
+   * @returns Window 내 row 수
    *
    * @example
    * ```typescript
@@ -1727,11 +1727,11 @@ const expr = {
     });
   },
   /**
-   * MIN() OVER - 윈도우 최소값
+   * MIN() OVER - Window 최소값
    *
-   * @param column - 최소값을 구할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 윈도우 내 최소값
+   * @param column - 최소값을 구할 column
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns Window 내 최소값
    *
    * @example
    * ```typescript
@@ -1751,11 +1751,11 @@ const expr = {
     });
   },
   /**
-   * MAX() OVER - 윈도우 최대값
+   * MAX() OVER - Window 최대값
    *
-   * @param column - 최대값을 구할 컬럼
-   * @param spec - 윈도우 스펙 (partitionBy, orderBy)
-   * @returns 윈도우 내 최대값
+   * @param column - 최대값을 구할 column
+   * @param spec - Window spec (partitionBy, orderBy)
+   * @returns Window 내 최대값
    *
    * @example
    * ```typescript
@@ -1777,9 +1777,9 @@ const expr = {
   //#endregion
   //#region ========== Helper ==========
   /**
-   * ExprInput을 Expr로 변환 (내부용)
+   * ExprInput을 Expr로 Transform (내부용)
    *
-   * @param value - 변환할 값
+   * @param value - Transform할 value
    * @returns Expr JSON AST
    */
   toExpr(value) {
@@ -1817,7 +1817,7 @@ function createSwitchBuilder() {
       }
       const nonNullLiteral = allValues.find((v) => v != null);
       if (nonNullLiteral == null) {
-        throw new Error("switch\uC758 case/default \uC911 \uC801\uC5B4\uB3C4 \uD558\uB098\uB294 non-null\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+        throw new Error("At least one of switch's case/default must be non-null.");
       }
       return new ExprUnit(inferColumnPrimitiveStr(nonNullLiteral), {
         type: "switch",
@@ -1836,7 +1836,7 @@ function toExpr(value) {
 function findDataType(args) {
   const exprUnit = args.find((a) => a instanceof ExprUnit);
   if (!exprUnit) {
-    throw new Error("args\uC911 \uC801\uC5B4\uB3C4 \uD558\uB098\uB294 ExprUnit\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+    throw new Error("At least one of the arguments must be an ExprUnit.");
   }
   return exprUnit.dataType;
 }