sonamu 0.7.11 → 0.7.13

package/src/database/puri.ts

@@ -3,6 +3,7 @@
 
 import assert from "assert";
 import chalk from "chalk";
+import inflection from "inflection";
 import type { Knex } from "knex";
 import { Naite } from "../naite/naite";
 import type {
@@ -12,7 +13,6 @@ import type {
   Expand,
   ExtractColumnType,
   FulltextColumns,
-  HighlightOptions,
   InsertData,
   InsertResult,
   LeftJoinedMarker,
@@ -25,8 +25,11 @@ import type {
   SelectObject,
   SingleTableValue,
   SqlExpression,
+  TsHighlightOptions,
   TsQueryConfig,
   TsQueryOptions,
+  TsRankOptions,
+  VectorColumns,
   WhereCondition,
   WhereOperator,
 } from "./puri.types";
@@ -127,6 +130,9 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
   static rawString(sql: string): SqlExpression<"string"> {
     return { _type: "sql_expression", _return: "string", _sql: sql };
   }
+  static rawStringArray(sql: string): SqlExpression<"string[]"> {
+    return { _type: "sql_expression", _return: "string[]", _sql: sql };
+  }
   static rawNumber(sql: string): SqlExpression<"number"> {
     return { _type: "sql_expression", _return: "number", _sql: sql };
   }
@@ -150,41 +156,93 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
    *   }),
    * })
    */
-  static highlight(
+  static tsHighlight(
     column: string,
     query: string,
-    options?: HighlightOptions,
+    _options?: TsHighlightOptions,
   ): SqlExpression<"string"> {
+    const { parser = "websearch_to_tsquery", config = "simple", ...options } = _options ?? {};
+
+    const hlOptionParts = Object.entries(options).map(([key, value]) => {
+      return `${inflection.camelize(key)}=${value}`;
+    });
+
+    const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(", ")}'` : "";
+
+    // TODO: rawBinding 메서드 만들어서 XSS 방지
+    return Puri.rawString(
+      `ts_headline('${config}', ${column}, ${parser}('${config}', '${query}')${hlOptions})`,
+    );
+  }
+
+  // ts_rank
+  static tsRank(column: string, query: string, options?: TsRankOptions): SqlExpression<"number"> {
+    return Puri._tsRank("ts_rank", column, query, options);
+  }
+
+  // ts_rank_cd
+  static tsRankCd(column: string, query: string, options?: TsRankOptions): SqlExpression<"number"> {
+    return Puri._tsRank("ts_rank_cd", column, query, options);
+  }
+
+  static _tsRank(
+    type: "ts_rank" | "ts_rank_cd",
+    column: string,
+    query: string,
+    options?: TsRankOptions,
+  ): SqlExpression<"number"> {
     const {
       parser = "websearch_to_tsquery",
       config = "simple",
-      maxWords,
-      minWords,
-      shortWord,
-      highlightAll,
-      maxFragments,
-      startSel,
-      stopSel,
-      fragmentDelimiter,
+      normalization,
+      weights,
     } = options ?? {};
 
-    const hlOptionParts: string[] = [];
+    const weightClause = weights ? `ARRAY[${weights.join(", ")}], ` : "";
+    const normalizationClause = normalization ? `, ${normalization}` : "";
 
-    if (maxWords !== undefined) hlOptionParts.push(`MaxWords=${maxWords}`);
-    if (minWords !== undefined) hlOptionParts.push(`MinWords=${minWords}`);
-    if (shortWord !== undefined) hlOptionParts.push(`ShortWord=${shortWord}`);
-    if (highlightAll !== undefined) hlOptionParts.push(`HighlightAll=${highlightAll}`);
-    if (maxFragments !== undefined) hlOptionParts.push(`MaxFragments=${maxFragments}`);
-    if (startSel !== undefined) hlOptionParts.push(`StartSel="${startSel}"`);
-    if (stopSel !== undefined) hlOptionParts.push(`StopSel="${stopSel}"`);
-    if (fragmentDelimiter !== undefined)
-      hlOptionParts.push(`FragmentDelimiter="${fragmentDelimiter}"`);
+    return Puri.rawNumber(
+      `${type}(${weightClause}${column}, ${parser}('${config}', '${query}')${normalizationClause})`,
+    );
+  }
 
-    const hlOptions = hlOptionParts.length > 0 ? `, '${hlOptionParts.join(", ")}'` : "";
+  /**
+   * PGroonga FullText 인덱스 검색 점수
+   *
+   * @example
+   * .select({
+   *   score: Puri.score(),
+   * })
+   */
+  static score(): SqlExpression<"number"> {
+    return Puri.rawNumber("pgroonga_score(tableoid, ctid)");
+  }
 
-    // TODO: rawBinding 메서드 만들어서 XSS 방지
-    return Puri.rawString(
-      `ts_headline('${config}', ${column}, ${parser}('${config}', '${query}')${hlOptions})`,
+  /**
+   * PGroonga FullText 인덱스 검색 하이라이팅
+   *
+   * @example
+   * .select({
+   *   title: Puri.highlight("posts.title", search),
+   * })
+   */
+  static highlight(column: string, query: string | string[]): SqlExpression<"string">;
+  static highlight(columns: string[], query: string | string[]): SqlExpression<"string[]">;
+
+  static highlight(
+    columnOrColumns: string | string[],
+    query: string | string[],
+  ): SqlExpression<"string"> | SqlExpression<"string[]"> {
+    const queryClause = `ARRAY[${(Array.isArray(query) ? query : [query]).map((q) => `'${q}'`).join(",")}]`;
+
+    // 단일 컬럼인 경우
+    if (typeof columnOrColumns === "string") {
+      return Puri.rawString(`pgroonga_highlight_html(${columnOrColumns}, ${queryClause})`);
+    }
+
+    // 컬럼 배열인 경우
+    return Puri.rawStringArray(
+      `pgroonga_highlight_html(ARRAY[${columnOrColumns.join(",")}], ${queryClause})`,
     );
   }
 
@@ -200,7 +258,7 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
     for (const [alias, columnOrFunction] of Object.entries(flatSelect)) {
       if (typeof columnOrFunction === "object" && columnOrFunction._type === "sql_expression") {
         // SQL 함수인 경우
-        selectClauses.push(this.knex.raw(`${columnOrFunction._sql} as ${alias}`));
+        selectClauses.push(this.knex.raw(`${columnOrFunction._sql} as "${alias}"`));
       } else {
         // 일반 컬럼인 경우
         const columnPath = columnOrFunction as string;
@@ -526,8 +584,40 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
     return this;
   }
 
+  /**
+   * PGroonga FullText 인덱스 검색
+   * - 사용할 PGroonga 인덱스와 동일한 컬럼 구성으로 검색해야 인덱스가 사용됩니다.
+   *
+   * 단일 컬럼 검색:
+   * ```sql
+   * WHERE name &@~ 'search'
+   * ```
+   *
+   * 복합 컬럼 검색:
+   * ```sql
+   * WHERE ARRAY[name::text, description::text] &@~ 'search'
+   * ```
+   */
+  whereSearch<TColumn extends AvailableColumns<TTables>>(
+    column: TColumn | TColumn[],
+    value: string,
+    options?: {
+      weights?: number[]; // 정수 배열
+    },
+  ): this {
+    const { weights } = options ?? {};
+    const columnExpr = Array.isArray(column)
+      ? `ARRAY[${column.map((c) => `${c}::text`).join(",")}]`
+      : column;
+    const pgroongaCondition = `pgroonga_condition(?${weights?.length ? `, weights => ARRAY[${weights.join(",")}]` : ""})`;
+
+    this.knexQuery.whereRaw(`${columnExpr} &@~ ${pgroongaCondition}`, [value]);
+
+    return this;
+  }
+
   // WHERE FULLTEXT
-  whereSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<"string">>(
+  whereTsSearch<TColumn extends AvailableColumns<TTables> | SqlExpression<"string">>(
     column: TColumn,
     value: string,
     options?: TsQueryOptions | TsQueryConfig,
@@ -578,6 +668,127 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
     return this;
   }
 
+  /**
+   * 벡터 유사도 검색 설정
+   *
+   * - SELECT에 similarity 컬럼 추가
+   * - WHERE col IS NOT NULL 추가
+   * - threshold가 있으면 WHERE 조건 추가
+   * - 기존 ORDER BY를 clear하고 원시 연산자로 정렬 (HNSW 인덱스 최적화)
+   *
+   * @param column 벡터 컬럼 경로
+   * @param embedding 쿼리 임베딩 벡터
+   * @param options method, threshold, as 등 옵션
+   *
+   * @example
+   * ```typescript
+   * // cosine similarity (기본값)
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "cosine",
+   *   threshold: 0.5
+   * });
+   *
+   * // L2 distance
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "l2",
+   *   threshold: 1.5  // 거리가 1.5 이하인 결과만
+   * });
+   *
+   * // Inner product
+   * qb.vectorSimilarity("columnName", queryVector, {
+   *   method: "inner_product",
+   *   threshold: 0.7
+   * });
+   * ```
+   */
+  vectorSimilarity(
+    column: VectorColumns<TTables>,
+    embedding: number[],
+    options: {
+      method?: "cosine" | "l2" | "inner_product";
+      threshold?: number;
+    } = {},
+  ): Puri<TSchema, TTables, TResult & { similarity: number }> {
+    const { method = "cosine", threshold } = options;
+    if (
+      !Array.isArray(embedding) ||
+      embedding.length === 0 ||
+      embedding.some((v) => !Number.isFinite(v))
+    ) {
+      throw new Error("Invalid embedding vector: expected a non-empty array of finite numbers");
+    }
+    const vectorLiteral = JSON.stringify(embedding.map((v) => Number(v)));
+
+    // method별 연산자 및 similarity 계산식
+    // - cosine: <=> (cosine distance, 0~2), similarity = 1 - distance
+    // - l2: <-> (euclidean distance), similarity = distance (낮을수록 유사)
+    // - inner_product: <#> (negative inner product), similarity = -distance (높을수록 유사)
+    const operatorMap = {
+      cosine: "<=>",
+      l2: "<->",
+      inner_product: "<#>",
+    } as const;
+    const operator = operatorMap[method];
+
+    // SELECT에 similarity 추가
+    if (method === "cosine") {
+      // cosine: similarity = 1 - cosine_distance (0~1, 높을수록 유사)
+      this.knexQuery.select(
+        this.knex.raw(`1 - (?? <=> ?::vector) as similarity`, [column, vectorLiteral]),
+      );
+    } else if (method === "l2") {
+      // l2: distance 그대로 반환 (낮을수록 유사)
+      this.knexQuery.select(
+        this.knex.raw(`?? <-> ?::vector as similarity`, [column, vectorLiteral]),
+      );
+    } else {
+      // inner_product: pgvector는 음수 반환하므로 부호 반전 (높을수록 유사)
+      this.knexQuery.select(
+        this.knex.raw(`-(?? <#> ?::vector) as similarity`, [column, vectorLiteral]),
+      );
+    }
+
+    // WHERE col IS NOT NULL
+    this.knexQuery.whereNotNull(column);
+
+    // threshold가 있으면 WHERE 추가
+    if (typeof threshold === "number") {
+      if (!Number.isFinite(threshold)) {
+        throw new Error(`Invalid vectorSimilarity threshold: ${threshold}`);
+      }
+
+      if (method === "cosine") {
+        // similarity >= threshold  <=>  cosine_distance <= (1 - threshold)
+        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+          column,
+          vectorLiteral,
+          1 - threshold,
+        ]);
+      } else if (method === "l2") {
+        // distance <= threshold (거리가 threshold 이하)
+        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+          column,
+          vectorLiteral,
+          threshold,
+        ]);
+      } else {
+        // inner_product: -distance >= threshold  <=>  distance <= -threshold
+        this.knexQuery.whereRaw(`?? ${operator} ?::vector <= ?`, [
+          column,
+          vectorLiteral,
+          -threshold,
+        ]);
+      }
+    }
+
+    // 기존 ORDER BY clear 후 원시 연산자로 정렬 (HNSW 인덱스 최적화)
+    // 모든 method에서 ASC: 거리/음수값이 작을수록 유사
+    this.knexQuery.clear("order");
+    this.knexQuery.orderByRaw(`?? ${operator} ?::vector`, [column, vectorLiteral]);
+
+    return this as any;
+  }
+
   // 기본 쿼리 메서드들
   limit(count: number): this {
     if (count < 0) {

package/src/database/puri.types.test-d.ts

@@ -108,7 +108,7 @@ describe("ExtractColumnType", () => {
       type Tables = {
         users: MockSchema["users"];
         department: MockSchema["departments"] & LeftJoinedMarker; // nullable FK
-        company: MockSchema["companies"] & LeftJoinedMarker; // non-null FK → 마커 없음
+        company: MockSchema["companies"]; // non-null FK → 마커 없음
       };
       type Result = ExtractColumnType<Tables, "company.id">;
 

package/src/database/puri.types.ts

@@ -13,13 +13,31 @@ type VirtualKey = "__virtual__";
 type LeftJoinedKey = "__leftJoined__";
 type HasDefault = "__hasDefault__";
 type GeneratedKey = "__generated__";
+type VectorKey = "__vector__";
 
-type InternalTypeKeys = FulltextKey | VirtualKey | LeftJoinedKey | HasDefault | GeneratedKey;
+type InternalTypeKeys =
+  | FulltextKey
+  | VirtualKey
+  | LeftJoinedKey
+  | HasDefault
+  | GeneratedKey
+  | VectorKey;
 
 // ============================================
 // 타입 유틸리티
 // ============================================
 
+// __vector__ 메타데이터에서 벡터 컬럼 추출
+type VectorColumnKeys<T> = T extends { [K in VectorKey]: readonly (infer V)[] }
+  ? V & string
+  : never;
+
+export type VectorColumns<TTables extends Record<string, any>> =
+  | {
+      [TAlias in keyof TTables]: `${TAlias & string}.${VectorColumnKeys<TTables[TAlias]>}`;
+    }[keyof TTables]
+  | (IsSingleKey<TTables> extends true ? VectorColumnKeys<TTables[keyof TTables]> : never);
+
 // 테이블명 타입
 export type TableName<TSchema> = keyof TSchema & string;
 
@@ -78,7 +96,7 @@ export type ResultAvailableColumns<TTables extends Record<string, any>, TResult
 // Select 값 타입 확장 (단일 컬럼 또는 SQL 표현식)
 export type SelectValue<TTables extends Record<string, any>> =
   | AvailableColumns<TTables>
-  | SqlExpression<"string" | "number" | "boolean" | "date">;
+  | SqlExpression<"string" | "number" | "boolean" | "date" | "string[]">;
 
 // 중첩 Select 객체 타입 (재귀적)
 // 예: { parent: { id: "parent.id", name: "parent.name" } }
@@ -178,7 +196,9 @@ type ParseSelectObjectWithPath<
           ? boolean
           : R extends "date"
             ? Date
-            : never
+            : R extends "string[]"
+              ? string[]
+              : never
     : IsNestedObject<TSelect[K]> extends true
       ? TSelect[K] extends NestedSelectObject<TTables>
         ? IsNullableJoinedTable<TTables, JoinPath<Prefix, K & string>> extends true // 주어진 테이블이 FK nullable에 leftJoin되었는지 여부에 따라 select 결과 객체의 타입이 달라집니다.
@@ -205,7 +225,9 @@ type ParseSelectObjectInner<
           ? boolean
           : R extends "date"
             ? Date
-            : never
+            : R extends "string[]"
+              ? string[]
+              : never
     : IsNestedObject<TSelect[K]> extends true
       ? TSelect[K] extends NestedSelectObject<TTables>
         ? IsNullableJoinedTable<TTables, JoinPath<Prefix, K & string>> extends true
@@ -274,7 +296,7 @@ export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
 export type WhereOperator = ComparisonOperator | "like" | "not like";
 
 // SQL Expression 타입 정의
-export type SqlExpression<T extends "string" | "number" | "boolean" | "date"> = {
+export type SqlExpression<T extends "string" | "number" | "boolean" | "date" | "string[]"> = {
   _type: "sql_expression"; // 또는 "computed_value"
   _return: T;
   _sql: string;
@@ -377,7 +399,7 @@ export type TsQueryOptions = {
   config?: TsQueryConfig;
 };
 
-export type HighlightOptions = {
+export type TsHighlightOptions = {
   /** 쿼리 변환 함수 (기본값: "websearch_to_tsquery") */
   parser?: TsQueryParser;
   /** 텍스트 검색 설정 (기본값: "simple") */
@@ -399,3 +421,24 @@ export type HighlightOptions = {
   /** 조각 구분자 (기본값: " ... ") */
   fragmentDelimiter?: string;
 };
+
+export type TsRankOptions = {
+  parser?: TsQueryParser;
+  config?: TsQueryConfig;
+  /** 가중치 배열 [D, C, B, A] (기본값: [0.1, 0.2, 0.4, 1.0]) */
+  weights?: [number, number, number, number];
+  /**
+   * 정규화 옵션
+   * 0: 문서 길이 무시 (기본값)
+   * 1: 1 + log(문서 길이)로 나눔
+   * 2: 문서 길이로 나눔
+   * 4: 평균 조화 거리로 나눔 (ts_rank_cd만)
+   * 8: 고유 단어 수로 나눔
+   * 16: 1 + log(고유 단어 수)로 나눔
+   * 32: rank/(rank+1) -> 0~1 사이의 값으로 스케일링
+   *
+   * 비트마스크를 사용하여 옵션을 조합할 수 있음
+   * 예: 8 | 32 -> 고유 단어 수로 나누고 0~1 스케일링
+   */
+  normalization?: number;
+};

package/src/entity/entity-manager.ts

@@ -85,6 +85,15 @@ class EntityManagerClass {
     return entity;
   }
 
+  getByTable(table: string): Entity {
+    const entity = Array.from(this.entities.values()).find((entity) => entity.table === table);
+    if (entity === undefined) {
+      throw new Error(`존재하지 않는 Entity 요청 ${table}`);
+    }
+
+    return entity;
+  }
+
   exists(entityId: string): boolean {
     const entity = this.entities.get(entityId);
     return entity !== undefined;

package/src/index.ts

@@ -22,6 +22,7 @@ export * from "./migration/types";
 export * from "./naite/naite";
 export * from "./naite/naite-reporter";
 export * from "./stream/sse";
+export * from "./tasks/decorator";
 export * from "./template/template";
 export * from "./template/template-manager";
 export * from "./testing/fixture-manager";
@@ -35,7 +36,6 @@ export * from "./vector/chunking";
 export * from "./vector/config";
 export * from "./vector/embedding";
 export * from "./vector/types";
-export * from "./vector/vector-search";
 
 // export * from "./api/code-converters";
 // export * from "./syncer/syncer";

package/src/migration/code-generation.ts

@@ -1,7 +1,8 @@
 import equal from "fast-deep-equal";
 import { alphabetical, diff } from "radashi";
-import { Naite } from "..";
+import { EntityManager, Naite } from "..";
 import type {
+  EntityProp,
   GenMigrationCode,
   MigrationColumn,
   MigrationForeign,
@@ -216,6 +217,10 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
     return genVectorIndexDefinition(index, table);
   }
 
+  if (index.using === "pgroonga") {
+    return genPgroongaIndexDefinition(index, table);
+  }
+
   const methodMap = {
     index: "INDEX",
     unique: "UNIQUE INDEX",
@@ -245,6 +250,40 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
   );`;
 }
 
+function genPgroongaIndexDefinition(index: MigrationIndex, table: string) {
+  const entity = EntityManager.getByTable(table);
+
+  // 복합 인덱스인 경우 ARRAY 사용
+  const columnClause = (() => {
+    if (index.columns.length === 1) {
+      const column = entity.propsDict[index.columns[0].name];
+      const option = getPgroongaColumnOption(column);
+      return `${index.columns[0].name}${option ? ` ${option}` : ""}`;
+    }
+
+    return `(ARRAY[${index.columns.map((col) => `${col.name}::text`).join(",")}])`;
+  })();
+
+  return `await knex.raw(
+  \`CREATE INDEX ${index.name} ON ${table} USING pgroonga (${columnClause}) WITH (tokenizer='TokenMecab');\`
+  )`;
+}
+
+/**
+ * PGroonga 컬럼 옵션 추출
+ *
+ * FullText 오퍼레이터를 지원하는 경우 우선 설정, 나머지는 디폴트 이용
+ * @link https://pgroonga.github.io/reference
+ */
+function getPgroongaColumnOption(column: EntityProp) {
+  if (column.type === "string" && column.length !== undefined) {
+    return "pgroonga_varchar_full_text_search_ops_v2";
+  } else if (column.type === "json") {
+    return "pgroonga_jsonb_full_text_search_ops_v2";
+  }
+  return null;
+}
+
 /**
  * @description
  * - HNSW (Hierarchical Navigable Small World): 느린 빌드, 빠른 검색 속도, 높은 메모리 및 정확도

package/src/migration/postgresql-schema-reader.ts

@@ -148,7 +148,7 @@ class PostgreSQLSchemaReaderClass {
           sortOrder: idx.sort_order,
         })),
         nullsNotDistinct: firstIndex.nulls_not_distinct,
-        using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | undefined,
+        using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | "pgroonga" | undefined,
       };
     });
 
@@ -219,34 +219,65 @@ class PostgreSQLSchemaReaderClass {
       throw new Error(`Table not found: ${tableName}`);
     }
 
-    // Indexes 조회
+    // Indexes 조회 (PGroonga 표현식 인덱스 포함)
     const indexesQuery = `
       SELECT
-        i.relname as index_name,
-        a.attname as column_name,
-        ix.indisunique as is_unique,
-        ix.indisprimary as is_primary,
-        am.amname as index_type,
-        -- NULLS FIRST/LAST 확인 (비트 연산)
-        (opt & 2) = 2 AS nulls_first,
-        -- ASC/DESC 확인
-        CASE 
-            WHEN (opt & 1) = 1 THEN 'DESC'
-            ELSE 'ASC'
-        END AS sort_order,
-        ix.indnullsnotdistinct AS nulls_not_distinct
+          i.relname AS index_name,
+          CASE
+              WHEN am.amname = 'pgroonga' AND u.attnum = 0 THEN
+                  regexp_replace(
+                      regexp_replace(
+                          TRIM(pgroonga_col.column_expr),
+                          '::text',
+                          '',
+                          'g'
+                      ),
+                      '[()]',
+                      '',
+                      'g'
+                  )
+              ELSE a.attname
+          END AS column_name,
+          ix.indisunique AS is_unique,
+          ix.indisprimary AS is_primary,
+          am.amname AS index_type,
+          COALESCE((u.opt & 2) = 2, FALSE) AS nulls_first,
+          CASE 
+              WHEN (u.opt & 1) = 1 THEN 'DESC'
+              ELSE 'ASC'
+          END AS sort_order,
+          ix.indnullsnotdistinct AS nulls_not_distinct
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid
       JOIN pg_am am ON i.relam = am.oid
-        JOIN LATERAL unnest(ix.indkey, ix.indoption)
-            WITH ORDINALITY AS u(attnum, opt, ord) ON true
-        -- unnest에서 나온 attnum으로 직접 조인
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = u.attnum
+      JOIN LATERAL unnest(ix.indkey, ix.indoption)
+          WITH ORDINALITY AS u(attnum, opt, ord) ON true
+      LEFT JOIN pg_attribute a ON a.attrelid = t.oid 
+          AND a.attnum = u.attnum 
+          AND u.attnum > 0
+      LEFT JOIN LATERAL (
+          SELECT 
+              unnest(
+                  CASE 
+                      WHEN pg_get_expr(ix.indexprs, ix.indrelid) ~ '^ARRAY\\[' THEN
+                          string_to_array(
+                              regexp_replace(
+                                  pg_get_expr(ix.indexprs, ix.indrelid),
+                                  '^ARRAY\\[(.*)\\]$',
+                                  '\\1'
+                              ),
+                              ', '
+                          )
+                      ELSE
+                          ARRAY[pg_get_expr(ix.indexprs, ix.indrelid)]
+                  END
+              ) as column_expr
+      ) pgroonga_col ON am.amname = 'pgroonga' AND u.attnum = 0
       WHERE t.relname = ?
-        AND a.attnum = ANY(ix.indkey)
-      ORDER BY i.relname, array_position(ix.indkey, a.attnum)
-    `;
+          AND (u.attnum > 0 OR (am.amname = 'pgroonga' AND u.attnum = 0))
+      ORDER BY i.relname, u.ord;
+`;
     const indexes = (await compareDB.raw(indexesQuery, [tableName])).rows;
 
     // Foreign Keys 조회