@simplysm/orm-common 14.0.100 → 14.0.102

package/src/expr/expr.ts

@@ -34,27 +34,6 @@ export interface SwitchExprBuilder<TPrimitive extends ColumnPrimitive> {
  * SQL 문자열 대신 JSON AST(Expr)를 생성하며, QueryBuilder가
  * 각 DBMS(MySQL, MSSQL, PostgreSQL)로 변환
  *
- * @example
- * ```typescript
- * // WHERE condition
- * db.user().where((u) => [
- *   expr.eq(u.status, "active"),
- *   expr.gt(u.age, 18),
- * ])
- *
- * // SELECT expression
- * db.user().select((u) => ({
- *   name: expr.concat(u.firstName, " ", u.lastName),
- *   age: expr.dateDiff("year", u.birthDate, expr.val("DateOnly", DateOnly.today())),
- * }))
- *
- * // Aggregate function
- * db.order().groupBy((o) => o.userId).select((o) => ({
- *   userId: o.userId,
- *   total: expr.sum(o.amount),
- * }))
- * ```
- *
  * @see {@link Queryable} Query builder 클래스
  * @see {@link ExprUnit} Expression 래퍼 클래스
  */
@@ -69,21 +48,6 @@ export const expr = {
    * @param dataType - 값의 데이터 타입 ("string", "number", "boolean", "DateTime", "DateOnly", "Time", "Uuid", "Buffer")
    * @param value - 래핑할 값 (undefined 허용)
    * @returns 래핑된 ExprUnit 인스턴스
-   *
-   * @example
-   * ```typescript
-   * // String value
-   * expr.val("string", "active")
-   *
-   * // Number value
-   * expr.val("number", 100)
-   *
-   * // Date value
-   * expr.val("DateOnly", DateOnly.today())
-   *
-   * // undefined value
-   * expr.val("string", undefined)
-   * ```
    */
   val<TStr extends ColumnPrimitiveStr, T extends ColumnPrimitiveMap[TStr] | undefined>(
     dataType: TStr,
@@ -102,12 +66,6 @@ export const expr = {
    * @param dataType - Column 데이터 타입
    * @param path - Column 경로 (테이블 별칭, column 이름 등)
    * @returns Column 참조 ExprUnit 인스턴스
-   *
-   * @example
-   * ```typescript
-   * // Direct column reference (internal use)
-   * expr.col("string", "T1", "name")
-   * ```
    */
   col<TStr extends ColumnPrimitiveStr>(
     dataType: ColumnPrimitiveStr,
@@ -124,18 +82,6 @@ export const expr = {
    *
    * @param dataType - 반환 값의 데이터 타입
    * @returns 태그드 템플릿 함수
-   *
-   * @example
-   * ```typescript
-   * // Using MySQL JSON function
-   * db.user().select((u) => ({
-   *   name: u.name,
-   *   data: expr.raw("string")`JSON_EXTRACT(${u.metadata}, '$.email')`,
-   * }))
-   *
-   * // PostgreSQL array function
-   * expr.raw("number")`ARRAY_LENGTH(${u.tags}, 1)`
-   * ```
    */
   raw<T extends ColumnPrimitiveStr>(
     dataType: T,
@@ -169,12 +115,6 @@ export const expr = {
    * @param source - 비교할 column 또는 expression
    * @param target - 비교 대상 값 또는 expression
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.eq(u.status, "active")])
-   * // WHERE status <=> 'active' (MySQL)
-   * ```
    */
   eq<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -190,12 +130,6 @@ export const expr = {
    * @param source - 비교할 column 또는 expression
    * @param target - 비교 대상 값 또는 expression
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.gt(u.age, 18)])
-   * // WHERE age > 18
-   * ```
    */
   gt<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -211,12 +145,6 @@ export const expr = {
    * @param source - 비교할 column 또는 expression
    * @param target - 비교 대상 값 또는 expression
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.lt(u.score, 60)])
-   * // WHERE score < 60
-   * ```
    */
   lt<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -232,12 +160,6 @@ export const expr = {
    * @param source - 비교할 column 또는 expression
    * @param target - 비교 대상 값 또는 expression
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.gte(u.age, 18)])
-   * // WHERE age >= 18
-   * ```
    */
   gte<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -253,12 +175,6 @@ export const expr = {
    * @param source - 비교할 column 또는 expression
    * @param target - 비교 대상 값 또는 expression
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.lte(u.score, 100)])
-   * // WHERE score <= 100
-   * ```
    */
   lte<T extends ColumnPrimitive>(source: ExprUnit<T>, target: ExprInput<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -277,17 +193,6 @@ export const expr = {
    * @param from - 시작 값 (undefined이면 하한 없음)
    * @param to - 끝 값 (undefined이면 상한 없음)
    * @returns WHERE 조건 expression
-   *
-   * @example
-   * ```typescript
-   * // Specify 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
-   * ```
    */
   between<T extends ColumnPrimitive>(
     source: ExprUnit<T>,
@@ -311,12 +216,6 @@ export const expr = {
    *
    * @param source - Column or expression to check
    * @returns WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.null(u.deletedAt)])
-   * // WHERE deletedAt IS NULL
-   * ```
    */
   null<T extends ColumnPrimitive>(source: ExprUnit<T>): WhereExprUnit {
     return new WhereExprUnit({
@@ -338,16 +237,6 @@ export const expr = {
    * @param source - Column or expression to search
    * @param pattern - Search pattern (%, _ wildcards available)
    * @returns WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * // Prefix search
-   * db.user().where((u) => [expr.like(u.name, "John%")])
-   * // WHERE name LIKE 'John%' ESCAPE '\'
-   *
-   * // Contains search
-   * db.user().where((u) => [expr.like(u.email, "%@gmail.com")])
-   * ```
    */
   like(
     source: ExprUnit<string | undefined>,
@@ -368,12 +257,6 @@ export const expr = {
    * @param source - Column or expression to search
    * @param pattern - Regular expression pattern
    * @returns WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.regexp(u.email, "^[a-z]+@")])
-   * // MySQL: WHERE email REGEXP '^[a-z]+@'
-   * ```
    */
   regexp(
     source: ExprUnit<string | undefined>,
@@ -396,12 +279,6 @@ export const expr = {
    * @param source - Column or expression to compare
    * @param values - List of values to compare against
    * @returns WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.in(u.status, ["active", "pending"])])
-   * // WHERE status IN ('active', 'pending')
-   * ```
    */
   in<T extends ColumnPrimitive>(source: ExprUnit<T>, values: ExprInput<T>[]): WhereExprUnit {
     return new WhereExprUnit({
@@ -420,19 +297,6 @@ export const expr = {
    * @param query - Queryable that returns a single column
    * @returns WHERE condition expression
    * @throws {Error} When the subquery does not return a single column
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [
-   *   expr.inQuery(
-   *     u.id,
-   *     db.order()
-   *       .where((o) => [expr.gt(o.amount, 1000)])
-   *       .select((o) => ({ userId: o.userId }))
-   *   ),
-   * ])
-   * // WHERE id IN (SELECT userId FROM Order WHERE amount > 1000)
-   * ```
    */
   inQuery<T extends ColumnPrimitive, TData extends Record<string, T>>(
     source: ExprUnit<T>,
@@ -456,17 +320,6 @@ export const expr = {
    *
    * @param query - Queryable to check for existence
    * @returns WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * // Query users who have orders
-   * db.user().where((u) => [
-   *   expr.exists(
-   *     db.order().where((o) => [expr.eq(o.userId, u.id)])
-   *   ),
-   * ])
-   * // WHERE EXISTS (SELECT 1 FROM Order WHERE userId = User.id)
-   * ```
    */
   exists(query: Queryable<any, any>): WhereExprUnit {
     const { select: _, ...queryDefWithoutSelect } = query.getSelectQueryDef(); // EXISTS는 SELECT 절이 불필요, 패킷 크기 절약
@@ -485,12 +338,6 @@ export const expr = {
    *
    * @param arg - Condition to negate
    * @returns Negated WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [expr.not(expr.eq(u.status, "deleted"))])
-   * // WHERE NOT (status <=> 'deleted')
-   * ```
    */
   not(arg: WhereExprUnit): WhereExprUnit {
     return new WhereExprUnit({
@@ -506,17 +353,6 @@ export const expr = {
    *
    * @param conditions - List of conditions to combine with AND
    * @returns Combined WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [
-   *   expr.and([
-   *     expr.eq(u.status, "active"),
-   *     expr.gte(u.age, 18),
-   *   ]),
-   * ])
-   * // WHERE (status <=> 'active' AND age >= 18)
-   * ```
    */
   and(conditions: WhereExprUnit[]): WhereExprUnit {
     if (conditions.length === 0) {
@@ -533,17 +369,6 @@ export const expr = {
    *
    * @param conditions - List of conditions to combine with OR
    * @returns Combined WHERE condition expression
-   *
-   * @example
-   * ```typescript
-   * db.user().where((u) => [
-   *   expr.or([
-   *     expr.eq(u.status, "active"),
-   *     expr.eq(u.status, "pending"),
-   *   ]),
-   * ])
-   * // WHERE (status <=> 'active' OR status <=> 'pending')
-   * ```
    */
   or(conditions: WhereExprUnit[]): WhereExprUnit {
     if (conditions.length === 0) {
@@ -566,14 +391,6 @@ export const expr = {
    *
    * @param args - Strings to concatenate
    * @returns Concatenated string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   fullName: expr.concat(u.firstName, " ", u.lastName),
-   * }))
-   * // SELECT CONCAT(firstName, ' ', lastName) AS fullName
-   * ```
    */
   concat(...args: ExprInput<string | undefined>[]): ExprUnit<string> {
     return new ExprUnit("string", {
@@ -588,14 +405,6 @@ export const expr = {
    * @param source - Original string
    * @param length - Number of characters to extract
    * @returns Extracted string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   initial: expr.left(u.name, 1),
-   * }))
-   * // SELECT LEFT(name, 1) AS initial
-   * ```
    */
   left<T extends string | undefined>(source: ExprUnit<T>, length: ExprInput<number>): ExprUnit<T> {
     return new ExprUnit("string", {
@@ -611,14 +420,6 @@ export const expr = {
    * @param source - Original string
    * @param length - Number of characters to extract
    * @returns Extracted string expression
-   *
-   * @example
-   * ```typescript
-   * db.phone().select((p) => ({
-   *   lastFour: expr.right(p.number, 4),
-   * }))
-   * // SELECT RIGHT(number, 4) AS lastFour
-   * ```
    */
   right<T extends string | undefined>(source: ExprUnit<T>, length: ExprInput<number>): ExprUnit<T> {
     return new ExprUnit("string", {
@@ -633,14 +434,6 @@ export const expr = {
    *
    * @param source - Original string
    * @returns String expression with whitespace removed
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   name: expr.trim(u.name),
-   * }))
-   * // SELECT TRIM(name) AS name
-   * ```
    */
   trim<T extends string | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("string", {
@@ -658,15 +451,6 @@ export const expr = {
    * @param length - Target length
    * @param fillString - String to use for padding
    * @returns Padded string expression
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   orderNo: expr.padStart(expr.cast(o.id, { type: "varchar", length: 10 }), 8, "0"),
-   * }))
-   * // SELECT LPAD(CAST(id AS VARCHAR(10)), 8, '0') AS orderNo
-   * // Result: "00000123"
-   * ```
    */
   padStart<T extends string | undefined>(
     source: ExprUnit<T>,
@@ -688,14 +472,6 @@ export const expr = {
    * @param from - String to find
    * @param to - Replacement string
    * @returns Replaced string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   phone: expr.replace(u.phone, "-", ""),
-   * }))
-   * // SELECT REPLACE(phone, '-', '') AS phone
-   * ```
    */
   replace<T extends string | undefined>(
     source: ExprUnit<T>,
@@ -715,14 +491,6 @@ export const expr = {
    *
    * @param source - Original string
    * @returns Uppercase string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   code: expr.upper(u.code),
-   * }))
-   * // SELECT UPPER(code) AS code
-   * ```
    */
   upper<T extends string | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("string", {
@@ -736,14 +504,6 @@ export const expr = {
    *
    * @param source - Original string
    * @returns Lowercase string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   email: expr.lower(u.email),
-   * }))
-   * // SELECT LOWER(email) AS email
-   * ```
    */
   lower<T extends string | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("string", {
@@ -757,14 +517,6 @@ export const expr = {
    *
    * @param source - Original string
    * @returns Character count
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   nameLength: expr.length(u.name),
-   * }))
-   * // SELECT CHAR_LENGTH(name) AS nameLength
-   * ```
    */
   length(source: ExprUnit<string | undefined>): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -780,14 +532,6 @@ export const expr = {
    *
    * @param source - Original string
    * @returns Byte count
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   byteLen: expr.byteLength(u.name),
-   * }))
-   * // SELECT OCTET_LENGTH(name) AS byteLen
-   * ```
    */
   byteLength(source: ExprUnit<string | undefined>): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -805,15 +549,6 @@ export const expr = {
    * @param start - Start position (starting from 1)
    * @param length - Length to extract (to the end if omitted)
    * @returns Extracted string expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   // From "Hello World", 5 characters starting at index 1: "Hello"
-   *   prefix: expr.substring(u.name, 1, 5),
-   * }))
-   * // SELECT SUBSTRING(name, 1, 5) AS prefix
-   * ```
    */
   substring<T extends string | undefined>(
     source: ExprUnit<T>,
@@ -836,15 +571,6 @@ export const expr = {
    * @param source - String to search in
    * @param search - String to find
    * @returns Position (starting from 1, 0 if not found)
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   atPos: expr.indexOf(u.email, "@"),
-   * }))
-   * // SELECT LOCATE('@', email) AS atPos (MySQL)
-   * // "john@example.com" → 5
-   * ```
    */
   indexOf(source: ExprUnit<string | undefined>, search: ExprInput<string>): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -863,14 +589,6 @@ export const expr = {
    *
    * @param source - Original number
    * @returns Absolute value expression
-   *
-   * @example
-   * ```typescript
-   * db.account().select((a) => ({
-   *   balance: expr.abs(a.balance),
-   * }))
-   * // SELECT ABS(balance) AS balance
-   * ```
    */
   abs<T extends number | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("number", {
@@ -885,15 +603,6 @@ export const expr = {
    * @param source - Original number
    * @param digits - Number of decimal places
    * @returns Rounded number expression
-   *
-   * @example
-   * ```typescript
-   * db.product().select((p) => ({
-   *   price: expr.round(p.price, 2),
-   * }))
-   * // SELECT ROUND(price, 2) AS price
-   * // 123.456 → 123.46
-   * ```
    */
   round<T extends number | undefined>(source: ExprUnit<T>, digits: number): ExprUnit<T> {
     return new ExprUnit("number", {
@@ -908,15 +617,6 @@ export const expr = {
    *
    * @param source - Original number
    * @returns Ceiling number expression
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   pages: expr.ceil(expr.multiply(o.itemCount, 0.1)),
-   * }))
-   * // SELECT CEILING(itemCount / 10) AS pages
-   * // 25 / 10 = 2.5 → 3
-   * ```
    */
   ceil<T extends number | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("number", {
@@ -930,15 +630,6 @@ export const expr = {
    *
    * @param source - Original number
    * @returns Floor number expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   ageGroup: expr.floor(expr.multiply(u.age, 0.1)),
-   * }))
-   * // SELECT FLOOR(age / 10) AS ageGroup
-   * // 25 / 10 = 2.5 → 2
-   * ```
    */
   floor<T extends number | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("number", {
@@ -956,14 +647,6 @@ export const expr = {
    *
    * @param source - DateTime or DateOnly expression
    * @returns Year (4-digit number)
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   birthYear: expr.year(u.birthDate),
-   * }))
-   * // SELECT YEAR(birthDate) AS birthYear
-   * ```
    */
   year<T extends DateTime | DateOnly | undefined>(
     source: ExprUnit<T>,
@@ -979,14 +662,6 @@ export const expr = {
    *
    * @param source - DateTime or DateOnly expression
    * @returns Month (1~12)
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   orderMonth: expr.month(o.createdAt),
-   * }))
-   * // SELECT MONTH(createdAt) AS orderMonth
-   * ```
    */
   month<T extends DateTime | DateOnly | undefined>(
     source: ExprUnit<T>,
@@ -1002,14 +677,6 @@ export const expr = {
    *
    * @param source - DateTime or DateOnly expression
    * @returns Day (1~31)
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   birthDay: expr.day(u.birthDate),
-   * }))
-   * // SELECT DAY(birthDate) AS birthDay
-   * ```
    */
   day<T extends DateTime | DateOnly | undefined>(
     source: ExprUnit<T>,
@@ -1025,14 +692,6 @@ export const expr = {
    *
    * @param source - DateTime or Time expression
    * @returns Hour (0~23)
-   *
-   * @example
-   * ```typescript
-   * db.log().select((l) => ({
-   *   logHour: expr.hour(l.createdAt),
-   * }))
-   * // SELECT HOUR(createdAt) AS logHour
-   * ```
    */
   hour<T extends DateTime | Time | undefined>(
     source: ExprUnit<T>,
@@ -1048,14 +707,6 @@ export const expr = {
    *
    * @param source - DateTime or Time expression
    * @returns Minute (0~59)
-   *
-   * @example
-   * ```typescript
-   * db.log().select((l) => ({
-   *   logMinute: expr.minute(l.createdAt),
-   * }))
-   * // SELECT MINUTE(createdAt) AS logMinute
-   * ```
    */
   minute<T extends DateTime | Time | undefined>(
     source: ExprUnit<T>,
@@ -1071,14 +722,6 @@ export const expr = {
    *
    * @param source - DateTime or Time expression
    * @returns Second (0~59)
-   *
-   * @example
-   * ```typescript
-   * db.log().select((l) => ({
-   *   logSecond: expr.second(l.createdAt),
-   * }))
-   * // SELECT SECOND(createdAt) AS logSecond
-   * ```
    */
   second<T extends DateTime | Time | undefined>(
     source: ExprUnit<T>,
@@ -1096,14 +739,6 @@ export const expr = {
    *
    * @param source - DateOnly expression
    * @returns ISO week number
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   weekNum: expr.isoWeek(o.orderDate),
-   * }))
-   * // SELECT WEEK(orderDate, 3) AS weekNum (MySQL)
-   * ```
    */
   isoWeek<T extends DateOnly | undefined>(
     source: ExprUnit<T>,
@@ -1121,14 +756,6 @@ export const expr = {
    *
    * @param source - DateOnly expression
    * @returns Week start date (Monday)
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   weekStart: expr.isoWeekStartDate(o.orderDate),
-   * }))
-   * // 2024-01-10 (Wed) → 2024-01-08 (Mon)
-   * ```
    */
   isoWeekStartDate<T extends DateOnly | undefined>(source: ExprUnit<T>): ExprUnit<T> {
     return new ExprUnit("DateOnly", {
@@ -1144,14 +771,6 @@ export const expr = {
    *
    * @param source - DateOnly expression
    * @returns Year-month string (YYYYMM)
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   yearMonth: expr.isoYearMonth(o.orderDate),
-   * }))
-   * // 2024-01-15 → "202401"
-   * ```
    */
   isoYearMonth<T extends DateOnly | undefined>(
     source: ExprUnit<T>,
@@ -1169,14 +788,6 @@ export const expr = {
    * @param from - Start date
    * @param to - End date
    * @returns Difference value (to - from)
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   age: expr.dateDiff("year", u.birthDate, expr.val("DateOnly", DateOnly.today())),
-   * }))
-   * // SELECT DATEDIFF(year, birthDate, '2024-01-15') AS age
-   * ```
    */
   dateDiff<T extends DateTime | DateOnly | Time | undefined>(
     unit: DateUnit,
@@ -1198,14 +809,6 @@ export const expr = {
    * @param source - Original date
    * @param value - Value to add (negative allowed)
    * @returns Calculated date
-   *
-   * @example
-   * ```typescript
-   * db.subscription().select((s) => ({
-   *   expiresAt: expr.dateAdd("month", s.startDate, 12),
-   * }))
-   * // SELECT DATEADD(month, 12, startDate) AS expiresAt
-   * ```
    */
   dateAdd<T extends DateTime | DateOnly | Time | undefined>(
     unit: DateUnit,
@@ -1228,15 +831,6 @@ export const expr = {
    * @param source - Date expression
    * @param format - Format string (e.g., "%Y-%m-%d")
    * @returns Formatted string expression
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   orderDate: expr.formatDate(o.createdAt, "%Y-%m-%d"),
-   * }))
-   * // SELECT DATE_FORMAT(createdAt, '%Y-%m-%d') AS orderDate (MySQL)
-   * // 2024-01-15 10:30:00 → "2024-01-15"
-   * ```
    */
   formatDate<T extends DateTime | DateOnly | Time | undefined>(
     source: ExprUnit<T>,
@@ -1260,14 +854,6 @@ export const expr = {
    *
    * @param args - Values to inspect (last is default value)
    * @returns First non-null value
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   displayName: expr.coalesce(u.nickname, u.name, "Guest"),
-   * }))
-   * // SELECT COALESCE(nickname, name, 'Guest') AS displayName
-   * ```
    */
   coalesce,
 
@@ -1279,15 +865,6 @@ export const expr = {
    * @param source - Original value
    * @param value - Value to compare
    * @returns NULL or original value
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   // Convert empty string to NULL
-   *   bio: expr.nullIf(u.bio, ""),
-   * }))
-   * // SELECT NULLIF(bio, '') AS bio
-   * ```
    */
   nullIf<T extends ColumnPrimitive>(
     source: ExprUnit<T>,
@@ -1307,14 +884,6 @@ export const expr = {
    *
    * @param condition - Condition to transform
    * @returns boolean expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   isActive: expr.is(expr.eq(u.status, "active")),
-   * }))
-   * // SELECT (status <=> 'active') AS isActive
-   * ```
    */
   is(condition: WhereExprUnit): ExprUnit<boolean> {
     return new ExprUnit("boolean", {
@@ -1329,18 +898,6 @@ export const expr = {
    * 메서드 체이닝으로 조건 분기 구성
    *
    * @returns SwitchExprBuilder instance
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   grade: expr.switch<string>()
-   *     .case(expr.gte(u.score, 90), "A")
-   *     .case(expr.gte(u.score, 80), "B")
-   *     .case(expr.gte(u.score, 70), "C")
-   *     .default("F"),
-   * }))
-   * // SELECT CASE WHEN score >= 90 THEN 'A' ... ELSE 'F' END AS grade
-   * ```
    */
   switch<T extends ColumnPrimitive>(): SwitchExprBuilder<T> {
     return createSwitchBuilder<T>();
@@ -1353,14 +910,6 @@ export const expr = {
    * @param then - Value when condition is true
    * @param else_ - Value when condition is false
    * @returns Conditional value expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   type: expr.if(expr.gte(u.age, 18), "adult", "minor"),
-   * }))
-   * // SELECT IF(age >= 18, 'adult', 'minor') AS type
-   * ```
    */
   if<T extends ColumnPrimitive>(
     condition: WhereExprUnit,
@@ -1404,17 +953,6 @@ export const expr = {
    * @param arg - Column to count (all rows if omitted)
    * @param distinct - If true, remove duplicates
    * @returns Row count
-   *
-   * @example
-   * ```typescript
-   * // Total row count
-   * db.user().select(() => ({ total: expr.count() }))
-   *
-   * // Distinct count
-   * db.order().select((o) => ({
-   *   uniqueCustomers: expr.count(o.customerId, true),
-   * }))
-   * ```
    */
   count(arg?: ExprUnit<ColumnPrimitive>, distinct?: boolean): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1431,14 +969,6 @@ export const expr = {
    *
    * @param arg - Number column to sum
    * @returns Sum (or NULL)
-   *
-   * @example
-   * ```typescript
-   * db.order().groupBy((o) => o.userId).select((o) => ({
-   *   userId: o.userId,
-   *   totalAmount: expr.sum(o.amount),
-   * }))
-   * ```
    */
   sum(arg: ExprUnit<number | undefined>): ExprUnit<number | undefined> {
     return new ExprUnit("number", {
@@ -1454,14 +984,6 @@ export const expr = {
    *
    * @param arg - Number column to average
    * @returns Average (or NULL)
-   *
-   * @example
-   * ```typescript
-   * db.product().groupBy((p) => p.categoryId).select((p) => ({
-   *   categoryId: p.categoryId,
-   *   avgPrice: expr.avg(p.price),
-   * }))
-   * ```
    */
   avg(arg: ExprUnit<number | undefined>): ExprUnit<number | undefined> {
     return new ExprUnit("number", {
@@ -1477,14 +999,6 @@ export const expr = {
    *
    * @param arg - Column to find maximum of
    * @returns Maximum value (or NULL)
-   *
-   * @example
-   * ```typescript
-   * db.order().groupBy((o) => o.userId).select((o) => ({
-   *   userId: o.userId,
-   *   lastOrderDate: expr.max(o.createdAt),
-   * }))
-   * ```
    */
   max<T extends ColumnPrimitive>(arg: ExprUnit<T>): ExprUnit<T | undefined> {
     return new ExprUnit(arg.dataType, {
@@ -1500,14 +1014,6 @@ export const expr = {
    *
    * @param arg - Column to find minimum of
    * @returns Minimum value (or NULL)
-   *
-   * @example
-   * ```typescript
-   * db.product().groupBy((p) => p.categoryId).select((p) => ({
-   *   categoryId: p.categoryId,
-   *   minPrice: expr.min(p.price),
-   * }))
-   * ```
    */
   min<T extends ColumnPrimitive>(arg: ExprUnit<T>): ExprUnit<T | undefined> {
     return new ExprUnit(arg.dataType, {
@@ -1525,14 +1031,6 @@ export const expr = {
    *
    * @param args - Values to compare
    * @returns Greatest value
-   *
-   * @example
-   * ```typescript
-   * db.product().select((p) => ({
-   *   effectivePrice: expr.greatest(p.price, p.minPrice),
-   * }))
-   * // SELECT GREATEST(price, minPrice) AS effectivePrice
-   * ```
    */
   greatest<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T> {
     return new ExprUnit(findDataType(args), {
@@ -1546,14 +1044,6 @@ export const expr = {
    *
    * @param args - Values to compare
    * @returns Least value
-   *
-   * @example
-   * ```typescript
-   * db.product().select((p) => ({
-   *   effectivePrice: expr.least(p.price, p.maxDiscount),
-   * }))
-   * // SELECT LEAST(price, maxDiscount) AS effectivePrice
-   * ```
    */
   least<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T> {
     return new ExprUnit(findDataType(args), {
@@ -1566,14 +1056,6 @@ export const expr = {
    * 행 번호 (ROW_NUMBER 없이 모든 행에 순번 부여)
    *
    * @returns Row number (starting from 1)
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   rowNum: expr.rowNum(),
-   *   name: u.name,
-   * }))
-   * ```
    */
   rowNum(): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1587,12 +1069,6 @@ export const expr = {
    * 0과 1 사이의 난수 반환. 주로 ORDER BY에서 무작위 정렬에 사용
    *
    * @returns Random number between 0 and 1
-   *
-   * @example
-   * ```typescript
-   * // Random sorting
-   * db.user().orderBy(() => expr.random()).limit(10)
-   * ```
    */
   random(): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1606,14 +1082,6 @@ export const expr = {
    * @param source - Expression to transform
    * @param targetType - Target data type
    * @returns Transformed expression
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   idStr: expr.cast(o.id, { type: "varchar", length: 20 }),
-   * }))
-   * // SELECT CAST(id AS VARCHAR(20)) AS idStr
-   * ```
    */
   cast<T extends ColumnPrimitive, TDataType extends DataType>(
     source: ExprUnit<T>,
@@ -1634,20 +1102,6 @@ export const expr = {
    * @param dataType - Data type of the returned value
    * @param queryable - Queryable that returns a scalar value
    * @returns Subquery result expression
-   *
-   * @example
-   * ```typescript
-   * db.user().select((u) => ({
-   *   id: u.id,
-   *   postCount: expr.subquery(
-   *     "number",
-   *     db.post()
-   *       .where((p) => [expr.eq(p.userId, u.id)])
-   *       .select(() => ({ cnt: expr.count() }))
-   *   ),
-   * }))
-   * // SELECT id, (SELECT COUNT(*) FROM Post WHERE userId = User.id) AS postCount
-   * ```
    */
   subquery<TStr extends ColumnPrimitiveStr>(
     dataType: TStr,
@@ -1670,18 +1124,6 @@ export const expr = {
    *
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Row number (starting from 1)
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   ...o,
-   *   rowNum: expr.rowNumber({
-   *     partitionBy: [o.userId],
-   *     orderBy: [[o.createdAt, "DESC"]],
-   *   }),
-   * }))
-   * // SELECT *, ROW_NUMBER() OVER (PARTITION BY userId ORDER BY createdAt DESC)
-   * ```
    */
   rowNumber(spec: WinSpecInput): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1696,16 +1138,6 @@ export const expr = {
    *
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Rank (skips after ties: 1, 1, 3)
-   *
-   * @example
-   * ```typescript
-   * db.student().select((s) => ({
-   *   name: s.name,
-   *   rank: expr.rank({
-   *     orderBy: [[s.score, "DESC"]],
-   *   }),
-   * }))
-   * ```
    */
   rank(spec: WinSpecInput): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1720,16 +1152,6 @@ export const expr = {
    *
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Dense rank (consecutive after ties: 1, 1, 2)
-   *
-   * @example
-   * ```typescript
-   * db.student().select((s) => ({
-   *   name: s.name,
-   *   denseRank: expr.denseRank({
-   *     orderBy: [[s.score, "DESC"]],
-   *   }),
-   * }))
-   * ```
    */
   denseRank(spec: WinSpecInput): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1745,17 +1167,6 @@ export const expr = {
    * @param n - Number of groups to split into
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Group number (1 ~ n)
-   *
-   * @example
-   * ```typescript
-   * // Quartile split to find top 25%
-   * db.user().select((u) => ({
-   *   name: u.name,
-   *   quartile: expr.ntile(4, {
-   *     orderBy: [[u.score, "DESC"]],
-   *   }),
-   * }))
-   * ```
    */
   ntile(n: number, spec: WinSpecInput): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1772,18 +1183,6 @@ export const expr = {
    * @param spec - Window spec (partitionBy, orderBy)
    * @param options - offset (default 1), default (default value when no previous row)
    * @returns Previous row's value (or default value/NULL)
-   *
-   * @example
-   * ```typescript
-   * db.stock().select((s) => ({
-   *   date: s.date,
-   *   price: s.price,
-   *   prevPrice: expr.lag(s.price, {
-   *     partitionBy: [s.symbol],
-   *     orderBy: [[s.date, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   lag<T extends ColumnPrimitive>(
     column: ExprUnit<T>,
@@ -1809,18 +1208,6 @@ export const expr = {
    * @param spec - Window spec (partitionBy, orderBy)
    * @param options - offset (default 1), default (default value when no following row)
    * @returns Following row's value (or default value/NULL)
-   *
-   * @example
-   * ```typescript
-   * db.stock().select((s) => ({
-   *   date: s.date,
-   *   price: s.price,
-   *   nextPrice: expr.lead(s.price, {
-   *     partitionBy: [s.symbol],
-   *     orderBy: [[s.date, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   lead<T extends ColumnPrimitive>(
     column: ExprUnit<T>,
@@ -1845,17 +1232,6 @@ export const expr = {
    * @param column - Column to reference
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns First value
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   ...o,
-   *   firstOrderAmount: expr.firstValue(o.amount, {
-   *     partitionBy: [o.userId],
-   *     orderBy: [[o.createdAt, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   firstValue<T extends ColumnPrimitive>(
     column: ExprUnit<T>,
@@ -1874,17 +1250,6 @@ export const expr = {
    * @param column - Column to reference
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Last value
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   ...o,
-   *   lastOrderAmount: expr.lastValue(o.amount, {
-   *     partitionBy: [o.userId],
-   *     orderBy: [[o.createdAt, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   lastValue<T extends ColumnPrimitive>(
     column: ExprUnit<T>,
@@ -1903,18 +1268,6 @@ export const expr = {
    * @param column - Column to sum
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Sum within window
-   *
-   * @example
-   * ```typescript
-   * // Running total
-   * db.order().select((o) => ({
-   *   ...o,
-   *   runningTotal: expr.sumOver(o.amount, {
-   *     partitionBy: [o.userId],
-   *     orderBy: [[o.createdAt, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   sumOver(column: ExprUnit<number | undefined>, spec: WinSpecInput): ExprUnit<number | undefined> {
     return new ExprUnit("number", {
@@ -1930,18 +1283,6 @@ export const expr = {
    * @param column - Column to average
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Average within window
-   *
-   * @example
-   * ```typescript
-   * // Moving average
-   * db.stock().select((s) => ({
-   *   ...s,
-   *   movingAvg: expr.avgOver(s.price, {
-   *     partitionBy: [s.symbol],
-   *     orderBy: [[s.date, "ASC"]],
-   *   }),
-   * }))
-   * ```
    */
   avgOver(column: ExprUnit<number | undefined>, spec: WinSpecInput): ExprUnit<number | undefined> {
     return new ExprUnit("number", {
@@ -1957,16 +1298,6 @@ export const expr = {
    * @param spec - Window spec (partitionBy, orderBy)
    * @param column - Column to count (all rows if omitted)
    * @returns Row count within window
-   *
-   * @example
-   * ```typescript
-   * db.order().select((o) => ({
-   *   ...o,
-   *   totalOrdersPerUser: expr.countOver({
-   *     partitionBy: [o.userId],
-   *   }),
-   * }))
-   * ```
    */
   countOver(spec: WinSpecInput, column?: ExprUnit<ColumnPrimitive>): ExprUnit<number> {
     return new ExprUnit("number", {
@@ -1982,16 +1313,6 @@ export const expr = {
    * @param column - Column to find minimum of
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Minimum value within window
-   *
-   * @example
-   * ```typescript
-   * db.stock().select((s) => ({
-   *   ...s,
-   *   minPriceInPeriod: expr.minOver(s.price, {
-   *     partitionBy: [s.symbol],
-   *   }),
-   * }))
-   * ```
    */
   minOver<T extends ColumnPrimitive>(
     column: ExprUnit<T>,
@@ -2010,16 +1331,6 @@ export const expr = {
    * @param column - Column to find maximum of
    * @param spec - Window spec (partitionBy, orderBy)
    * @returns Maximum value within window
-   *
-   * @example
-   * ```typescript
-   * db.stock().select((s) => ({
-   *   ...s,
-   *   maxPriceInPeriod: expr.maxOver(s.price, {
-   *     partitionBy: [s.symbol],
-   *   }),
-   * }))
-   * ```
    */
   maxOver<T extends ColumnPrimitive>(
     column: ExprUnit<T>,