@simplysm/orm-common 14.0.99 → 14.0.101

package/dist/expr/expr.js

@@ -7,27 +7,6 @@ import { ExprUnit, WhereExprUnit } from "./expr-unit.js";
  * 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 래퍼 클래스
  */
@@ -41,21 +20,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(dataType, value) {
         return new ExprUnit(dataType, { type: "value", value });
@@ -68,12 +32,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(dataType, ...path) {
         return new ExprUnit(dataType, { type: "column", path });
@@ -86,18 +44,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(dataType) {
         return (strings, ...values) => {
@@ -121,12 +67,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(source, target) {
         return new WhereExprUnit({
@@ -141,12 +81,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(source, target) {
         return new WhereExprUnit({
@@ -161,12 +95,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(source, target) {
         return new WhereExprUnit({
@@ -181,12 +109,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(source, target) {
         return new WhereExprUnit({
@@ -201,12 +123,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(source, target) {
         return new WhereExprUnit({
@@ -224,17 +140,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(source, from, to) {
         return new WhereExprUnit({
@@ -251,12 +156,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(source) {
         return new WhereExprUnit({
@@ -275,16 +174,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, pattern) {
         return new WhereExprUnit({
@@ -301,12 +190,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, pattern) {
         return new WhereExprUnit({
@@ -323,12 +206,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(source, values) {
         return new WhereExprUnit({
@@ -346,19 +223,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(source, query) {
         const queryDef = query.getSelectQueryDef();
@@ -378,17 +242,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) {
         const { select: _, ...queryDefWithoutSelect } = query.getSelectQueryDef(); // EXISTS는 SELECT 절이 불필요, 패킷 크기 절약
@@ -404,12 +257,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) {
         return new WhereExprUnit({
@@ -424,17 +271,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) {
         if (conditions.length === 0) {
@@ -450,17 +286,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) {
         if (conditions.length === 0) {
@@ -480,14 +305,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) {
         return new ExprUnit("string", {
@@ -501,14 +318,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(source, length) {
         return new ExprUnit("string", {
@@ -523,14 +332,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(source, length) {
         return new ExprUnit("string", {
@@ -544,14 +345,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(source) {
         return new ExprUnit("string", {
@@ -568,15 +361,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(source, length, fillString) {
         return new ExprUnit("string", {
@@ -593,14 +377,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(source, from, to) {
         return new ExprUnit("string", {
@@ -615,14 +391,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(source) {
         return new ExprUnit("string", {
@@ -635,14 +403,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(source) {
         return new ExprUnit("string", {
@@ -655,14 +415,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) {
         return new ExprUnit("number", {
@@ -677,14 +429,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) {
         return new ExprUnit("number", {
@@ -701,15 +445,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(source, start, length) {
         return new ExprUnit("string", {
@@ -727,15 +462,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, search) {
         return new ExprUnit("number", {
@@ -751,14 +477,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(source) {
         return new ExprUnit("number", {
@@ -772,15 +490,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(source, digits) {
         return new ExprUnit("number", {
@@ -794,15 +503,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(source) {
         return new ExprUnit("number", {
@@ -815,15 +515,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(source) {
         return new ExprUnit("number", {
@@ -838,14 +529,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(source) {
         return new ExprUnit("number", {
@@ -858,14 +541,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(source) {
         return new ExprUnit("number", {
@@ -878,14 +553,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(source) {
         return new ExprUnit("number", {
@@ -898,14 +565,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(source) {
         return new ExprUnit("number", {
@@ -918,14 +577,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(source) {
         return new ExprUnit("number", {
@@ -938,14 +589,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(source) {
         return new ExprUnit("number", {
@@ -960,14 +603,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(source) {
         return new ExprUnit("number", {
@@ -982,14 +617,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(source) {
         return new ExprUnit("DateOnly", {
@@ -1004,14 +631,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(source) {
         return new ExprUnit("string", {
@@ -1026,14 +645,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(unit, from, to) {
         return new ExprUnit("number", {
@@ -1050,14 +661,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(unit, source, value) {
         return new ExprUnit(source.dataType, {
@@ -1075,15 +678,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(source, format) {
         return new ExprUnit("string", {
@@ -1101,14 +695,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,
     /**
@@ -1119,15 +705,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(source, value) {
         return new ExprUnit(source.dataType, {
@@ -1143,14 +720,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) {
         return new ExprUnit("boolean", {
@@ -1164,18 +733,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() {
         return createSwitchBuilder();
@@ -1187,14 +744,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(condition, then, else_) {
         const allValues = [then, else_];
@@ -1229,17 +778,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, distinct) {
         return new ExprUnit("number", {
@@ -1255,14 +793,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) {
         return new ExprUnit("number", {
@@ -1277,14 +807,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) {
         return new ExprUnit("number", {
@@ -1299,14 +821,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(arg) {
         return new ExprUnit(arg.dataType, {
@@ -1321,14 +835,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(arg) {
         return new ExprUnit(arg.dataType, {
@@ -1343,14 +849,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(...args) {
         return new ExprUnit(findDataType(args), {
@@ -1363,14 +861,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(...args) {
         return new ExprUnit(findDataType(args), {
@@ -1382,14 +872,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() {
         return new ExprUnit("number", {
@@ -1402,12 +884,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() {
         return new ExprUnit("number", {
@@ -1420,14 +896,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(source, targetType) {
         return new ExprUnit(dataTypeStrToColumnPrimitiveStr[targetType.type], {
@@ -1444,20 +912,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(dataType, queryable) {
         return new ExprUnit(dataType, {
@@ -1474,18 +928,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) {
         return new ExprUnit("number", {
@@ -1499,16 +941,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) {
         return new ExprUnit("number", {
@@ -1522,16 +954,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) {
         return new ExprUnit("number", {
@@ -1546,17 +968,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, spec) {
         return new ExprUnit("number", {
@@ -1572,18 +983,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(column, spec, options) {
         return new ExprUnit(column.dataType, {
@@ -1604,18 +1003,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(column, spec, options) {
         return new ExprUnit(column.dataType, {
@@ -1635,17 +1022,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(column, spec) {
         return new ExprUnit(column.dataType, {
@@ -1660,17 +1036,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(column, spec) {
         return new ExprUnit(column.dataType, {
@@ -1685,18 +1050,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, spec) {
         return new ExprUnit("number", {
@@ -1711,18 +1064,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, spec) {
         return new ExprUnit("number", {
@@ -1737,16 +1078,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, column) {
         return new ExprUnit("number", {
@@ -1761,16 +1092,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(column, spec) {
         return new ExprUnit(column.dataType, {
@@ -1785,16 +1106,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(column, spec) {
         return new ExprUnit(column.dataType, {