@simplysm/orm-common 14.0.46 → 14.0.48

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

@@ -82,13 +82,16 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       // 그 외(orderBy, top, select 등)이면 renderFrom(join)으로 서브쿼리 생성
       const from = Array.isArray(join.from) ? this.renderFrom(join.from) : this.renderFrom(join);
       return ` LEFT OUTER JOIN LATERAL ${from} AS ${alias} ON TRUE`;
-    }
-
-    // 일반 JOIN
-    const from = this.renderFrom(join.from);
-    const where =
-      join.where != null && join.where.length > 0
-        ? ` ON ${this.expr.renderWhere(join.where)}`
+    }
+
+    // 일반 JOIN
+    const from = this.renderFrom(join.from);
+    if (this.isRecursiveSelfJoin(join)) {
+      return ` CROSS JOIN ${from} AS ${alias}`;
+    }
+    const where =
+      join.where != null && join.where.length > 0
+        ? ` ON ${this.expr.renderWhere(join.where)}`
         : " ON TRUE";
     return ` LEFT OUTER JOIN ${from} AS ${alias}${where}`;
   }
@@ -97,13 +100,13 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
 
   //#region ========== DML - SELECT ==========
 
-  protected select(def: SelectQueryDef): QueryBuildResult {
+  protected select(def: SelectQueryDef): QueryBuildResult {
     // WITH (CTE)
-    let sql = "";
-    if (def.with != null) {
-      const { name, base, recursive } = def.with;
-      sql += `WITH ${this.expr.wrap(name)} AS (${this.select(base).sql} UNION ALL ${this.select(recursive).sql}) `;
-    }
+    let sql = "";
+    if (def.with != null) {
+      const { name, base, recursive } = def.with;
+      sql += `WITH RECURSIVE ${this.expr.wrap(name)} AS (${this.select(base).sql} UNION ALL ${this.select(recursive).sql}) `;
+    }
 
     // SELECT
     sql += "SELECT";
@@ -121,11 +124,22 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       sql += " *";
     }
 
-    // FROM
-    if (def.from != null) {
-      const from = this.renderFrom(def.from);
-      sql += ` FROM ${from} AS ${this.expr.wrap(def.as)}`;
-    }
+    const recursiveSelfJoin = def.joins?.find((join) => this.isRecursiveSelfJoin(join));
+    const remainingJoins =
+      recursiveSelfJoin != null ? def.joins?.filter((join) => join !== recursiveSelfJoin) : def.joins;
+
+    // FROM
+    if (def.from != null) {
+      if (recursiveSelfJoin != null) {
+        const selfFrom = this.renderFrom(recursiveSelfJoin.from);
+        const baseFrom = this.renderFrom(def.from);
+        sql += ` FROM ${selfFrom} AS ${this.expr.wrap(recursiveSelfJoin.as)}`;
+        sql += ` CROSS JOIN ${baseFrom} AS ${this.expr.wrap(def.as)}`;
+      } else {
+        const from = this.renderFrom(def.from);
+        sql += ` FROM ${from} AS ${this.expr.wrap(def.as)}`;
+      }
+    }
 
     // LOCK
     if (def.lock) {
@@ -133,7 +147,7 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     }
 
     // JOINs
-    sql += this.renderJoins(def.joins);
+    sql += this.renderJoins(remainingJoins);
 
     // WHERE
     sql += this.renderWhere(def.where);
@@ -469,6 +483,10 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
     // INSERT (NOT EXISTS 패턴)
     const insertSql = `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`;
 
+    // MySQL은 같은 문장에서 TEMPORARY TABLE을 두 번 참조할 수 없으므로
+    // row count를 변수에 저장하여 두 번째 참조를 대체
+    const setCntSql = `SET @sd_tmp_cnt = (SELECT COUNT(*) FROM ${tempTableName})`;
+
     // SELECT: UPDATE 결과 또는 INSERT 결과 조회 (UNION ALL로 병합)
     // UPDATE 경우: 임시 테이블의 PK로 조회
     const output = def.output;
@@ -487,15 +505,15 @@ export class MysqlQueryBuilder extends QueryBuilderBase {
       const pkExpr = def.insertRecord[pk];
       return `${wrappedPk} = ${this.expr.render(pkExpr)}`;
     });
-    const selectInsertSql = `SELECT ${outputCols} FROM ${table} WHERE ${insertPkConditions.join(" AND ")} AND NOT EXISTS (SELECT 1 FROM ${tempTableName})`;
+    const selectInsertSql = `SELECT ${outputCols} FROM ${table} WHERE ${insertPkConditions.join(" AND ")} AND @sd_tmp_cnt = 0`;
 
     const selectSql = `${selectUpdateSql} UNION ALL ${selectInsertSql}`;
 
     // 임시 테이블 삭제
     const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
 
-    const statements = [createTempSql, updateSql, insertSql, selectSql, dropSql];
-    return { sql: statements.join(";\n"), resultSetIndex: 3 };
+    const statements = [createTempSql, updateSql, insertSql, setCntSql, selectSql, dropSql];
+    return { sql: statements.join(";\n"), resultSetIndex: 4 };
   }
 
   //#endregion

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

@@ -320,9 +320,9 @@ export class PostgresqlExprRenderer extends ExprRendererBase {
     return `SUBSTRING(${this.render(expr.source)} FROM ${this.render(expr.start)})`;
   }
 
-  protected indexOf(expr: ExprIndexOf): string {
-    return `POSITION(${this.render(expr.search)} IN ${this.render(expr.source)})`;
-  }
+  protected indexOf(expr: ExprIndexOf): string {
+    return `(POSITION(${this.render(expr.search)} IN ${this.render(expr.source)}) - 1)`;
+  }
 
   //#endregion
 

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

@@ -77,13 +77,16 @@ export class PostgresqlQueryBuilder extends QueryBuilderBase {
       // 그 외(orderBy, top, select 등)이면 renderFrom(join)으로 서브쿼리 생성
       const from = Array.isArray(join.from) ? this.renderFrom(join.from) : this.renderFrom(join);
       return ` LEFT OUTER JOIN LATERAL ${from} AS ${alias} ON TRUE`;
-    }
-
-    // 일반 JOIN
-    const from = this.renderFrom(join.from);
-    const where =
-      join.where != null && join.where.length > 0
-        ? ` ON ${this.expr.renderWhere(join.where)}`
+    }
+
+    // 일반 JOIN
+    const from = this.renderFrom(join.from);
+    if (this.isRecursiveSelfJoin(join)) {
+      return ` CROSS JOIN ${from} AS ${alias}`;
+    }
+    const where =
+      join.where != null && join.where.length > 0
+        ? ` ON ${this.expr.renderWhere(join.where)}`
         : " ON TRUE";
     return ` LEFT OUTER JOIN ${from} AS ${alias}${where}`;
   }

package/src/utils/pick-result-sets.ts

@@ -0,0 +1,30 @@
+import type { QueryBuildResult } from "../types/db";
+
+/**
+ * 다중 결과 셋에서 QueryBuildResult 메타데이터에 따라 필요한 결과만 추출한다.
+ *
+ * - `resultSetIndex`가 없으면 첫 번째 셋 반환
+ * - `resultSetStride`가 없으면 `resultSetIndex`번째 셋 단일 반환
+ * - `resultSetStride`가 있으면 `resultSetIndex`부터 stride 간격으로 모든 셋을 concat하여 반환
+ *   (MySQL 배치 INSERT: `INSERT;SELECT;INSERT;SELECT;...` 형태에서 SELECT 결과만 모을 때 사용)
+ */
+export function pickResultSets<T>(
+  rawResults: T[][],
+  buildResult: Pick<QueryBuildResult, "resultSetIndex" | "resultSetStride">,
+): T[] {
+  const { resultSetIndex, resultSetStride } = buildResult;
+
+  if (resultSetIndex == null) {
+    return rawResults[0] ?? [];
+  }
+
+  if (resultSetStride == null) {
+    return rawResults[resultSetIndex] ?? [];
+  }
+
+  const merged: T[] = [];
+  for (let j = resultSetIndex; j < rawResults.length; j += resultSetStride) {
+    merged.push(...rawResults[j]);
+  }
+  return merged;
+}

package/src/utils/result-parser.ts

@@ -16,11 +16,11 @@ declare function setImmediate(callback: () => void): void;
  * @returns 파싱된 값
  * @throws 파싱 실패 시 Error
  */
-function parseValue(value: unknown, type: ColumnPrimitiveStr): unknown {
-  // null/undefined는 그대로 반환 (key 제거는 호출자가 처리)
-  if (value == null) {
-    return undefined;
-  }
+function parseValue(value: unknown, type: ColumnPrimitiveStr): unknown {
+  // undefined는 key 제거 대상으로 남기고, null은 SQL 결과값으로 보존한다.
+  if (value == null) {
+    return value;
+  }
 
   switch (type) {
     case "number": {
@@ -93,13 +93,11 @@ function flatToNested(
   const result: Record<string, unknown> = {};
 
   for (const { key, type, parts } of columnInfos) {
-    const rawValue = record[key];
-    const parsedValue = parseValue(rawValue, type);
-
-    // undefined 값은 key로 추가하지 않음
-    if (parsedValue == null) continue;
-
-    if (parts != null) {
+    const rawValue = record[key];
+    if (typeof rawValue === "undefined") continue;
+    const parsedValue = parseValue(rawValue, type);
+
+    if (parts != null) {
       // 중첩 key: "posts.id" → { posts: { id: ... } }
       let current = result;
       for (let i = 0; i < parts.length - 1; i++) {
@@ -122,9 +120,45 @@ function flatToNested(
 /**
  * 객체가 비어있는지 확인 (모든 값이 undefined)
  */
-function isEmptyObject(record: Record<string, unknown>): boolean {
-  return Object.keys(record).length === 0;
-}
+function isEmptyObject(record: Record<string, unknown>): boolean {
+  return Object.keys(record).length === 0;
+}
+
+/**
+ * JOIN 결과 객체가 실질적으로 비어있는지 확인
+ *
+ * 모든 값이 null/undefined 이거나, 중첩 객체도 재귀적으로 비어있으면 비어있는 JOIN으로 간주한다.
+ */
+function isEmptyJoinObject(record: Record<string, unknown>): boolean {
+  const entries = Object.entries(record);
+  if (entries.length === 0) {
+    return true;
+  }
+
+  for (const [, value] of entries) {
+    if (value == null) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        return false;
+      }
+      continue;
+    }
+
+    if (typeof value === "object") {
+      if (!isEmptyJoinObject(value as Record<string, unknown>)) {
+        return false;
+      }
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}
 
 // ============================================
 // 메인 함수
@@ -367,10 +401,10 @@ function groupRecordsRecursively(
         const localKey = currentPath === "" ? joinKey : joinKey.slice(currentPath.length + 1);
         const joinData = newGroup[localKey] as Record<string, unknown> | undefined;
 
-        if (joinData != null && !isEmptyObject(joinData)) {
-          if (!joinsConfig[joinKey].isSingle) {
-            // 배열로 변환 (hashSet은 첫 merge 시 초기화)
-            newGroup[localKey] = [joinData];
+        if (joinData != null && !isEmptyJoinObject(joinData)) {
+          if (!joinsConfig[joinKey].isSingle) {
+            // 배열로 변환 (hashSet은 첫 merge 시 초기화)
+            newGroup[localKey] = [joinData];
           }
         } else {
           // 데이터가 비어있으면 key 삭제
@@ -466,9 +500,9 @@ function mergeJoinData(
 ): void {
   const newJoinData = newRecord[localKey] as Record<string, unknown> | undefined;
 
-  if (newJoinData == null || isEmptyObject(newJoinData)) {
-    return; // 병합할 데이터 없음
-  }
+  if (newJoinData == null || isEmptyJoinObject(newJoinData)) {
+    return; // 병합할 데이터 없음
+  }
 
   const existingJoinData = existingGroup[localKey];