oak-db 3.3.12 → 3.3.14

package/lib/PostgreSQL/translator.js

@@ -7,7 +7,6 @@ const util_1 = require("util");
 const lodash_1 = require("lodash");
 const types_1 = require("oak-domain/lib/types");
 const sqlTranslator_1 = require("../sqlTranslator");
-const relation_1 = require("oak-domain/lib/store/relation");
 const GeoTypes = [
     {
         type: 'point',
@@ -741,6 +740,7 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                 else if (typeof value === 'number') {
                     return `${value}`;
                 }
+                (0, assert_1.default)(typeof value === 'string', 'Invalid date/time value');
                 return `'${(new Date(value)).valueOf()}'`;
             }
             case 'object':
@@ -967,12 +967,8 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                     }
                     indexSql += '(';
                     const indexColumns = [];
-                    let includeDeleteAt = false;
                     for (const indexAttr of indexAttrs) {
                         const { name: attrName, direction } = indexAttr;
-                        if (attrName === '$$deleteAt$$') {
-                            includeDeleteAt = true;
-                        }
                         if (indexType === 'fulltext') {
                             // 全文索引：使用 to_tsvector
                             indexColumns.push(`to_tsvector('${tsLang}', COALESCE("${attrName}", ''))`);
@@ -986,10 +982,6 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                             indexColumns.push(col);
                         }
                     }
-                    // 非特殊索引自动包含 deleteAt
-                    if (!includeDeleteAt && !indexType) {
-                        indexColumns.push('"$$deleteAt$$"');
-                    }
                     indexSql += indexColumns.join(', ');
                     indexSql += ');';
                     sqls.push(indexSql);
@@ -1490,10 +1482,11 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
     translateUpdate(entity, operation, option) {
         const { attributes } = this.schema[entity];
         const { filter, sorter, indexFrom, count, data } = operation;
-        (0, assert_1.default)(!sorter, '当前update不支持sorter行为');
-        // 使用结构化的JOIN分析
-        const { aliasDict, filterRefAlias, mainTable, mainAlias, joinInfos, currentNumber } = this.analyzeJoinStructured(entity, { filter, sorter });
-        // 构建SET子句 - PostgreSQL中SET子句不能使用表别名前缀
+        // 参数验证
+        this.validateOperationParams(sorter, indexFrom, count);
+        const mainTable = this.getStorageName(entity);
+        const mainAlias = `${entity}_1`;
+        // 构建 SET 子句
         const setClauses = [];
         for (const attr in data) {
             (0, assert_1.default)(attributes.hasOwnProperty(attr));
@@ -1501,73 +1494,93 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
             setClauses.push(`"${attr}" = ${value}`);
         }
         const setClause = setClauses.join(', ');
-        // 构建过滤条件
-        const { stmt: filterText } = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, option);
-        let sql;
-        if (joinInfos.length === 0) {
-            // 单表更新
-            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-            if (filterText) {
-                sql += ` WHERE ${filterText}`;
-            }
+        // 统一使用子查询方案
+        const subqueryOperation = {
+            data: { [types_1.PrimaryKeyAttribute]: 1 },
+            filter: filter,
+            indexFrom: indexFrom,
+            count: count
+        };
+        const subquery = this.translateSelect(entity, subqueryOperation, { includedDeleted: option?.includedDeleted });
+        let sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause} WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
+        // 添加 RETURNING 子句
+        return this.appendReturningClause(sql, entity, mainAlias, option);
+    }
+    /**
+     * 将 projection 转换为 RETURNING 子句的列列表
+     * @param entity 实体名
+     * @param alias 表别名
+     * @param projection 投影定义
+     */
+    buildReturningClause(entity, alias, projection) {
+        const columns = [];
+        const { attributes } = this.schema[entity];
+        for (const attr in projection) {
+            // if (!attributes[attr]) {
+            //     // 如果存在entity这个attr
+            //     const entityDesc = attributes['entity']
+            //     const entityIdDesc = attributes['entityId']
+            //     if (entityDesc && entityIdDesc && ((entityDesc.ref as string[])?.includes(attr))) {
+            //         // 特殊处理 entity 和 entityId 属性
+            //     }
+            //     continue;
+            // }
+            // 只能返回更新列的相关字段，所以直接assert
+            (0, assert_1.default)(attributes.hasOwnProperty(attr), `RETURNING语法只能返回更新列的字段，但在实体 ${String(entity)} 中未找到原生属性「${attr}」的定义`);
+            const dataType = attributes[attr].type;
+            // 处理特殊类型的投影
+            const columnExpr = this.translateAttrProjection(dataType, alias, attr);
+            // RETURNING 需要明确的别名（不带表前缀）
+            columns.push(`${columnExpr} AS "${attr}"`);
         }
-        else {
-            // 多表更新 - PostgreSQL语法: UPDATE main SET ... FROM other_tables WHERE join_conditions AND filter
-            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-            // FROM子句包含所有JOIN的表
-            const fromTables = joinInfos.map(j => `"${j.table}" AS "${j.alias}"`).join(', ');
-            sql += ` FROM ${fromTables}`;
-            // WHERE子句包含JOIN条件和过滤条件
-            const joinConditions = this.buildJoinConditions(joinInfos);
-            let whereClause = joinConditions;
-            if (filterText) {
-                whereClause = whereClause ? `${whereClause} AND ${filterText}` : filterText;
-            }
-            if (whereClause) {
-                sql += ` WHERE ${whereClause}`;
-            }
+        if (columns.length === 0) {
+            throw new Error(`No valid columns in RETURNING clause for entity ${String(entity)}`);
+        }
+        return columns.join(', ');
+    }
+    /**
+     * 验证操作参数的合法性
+     */
+    validateOperationParams(sorter, indexFrom, count) {
+        (0, assert_1.default)(!sorter, '当前update/remove不支持sorter行为');
+        // 对于limit，如果有indexFrom则一定有count
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number' && count > 0);
+        }
+    }
+    /**
+     * 添加RETURNING子句
+     */
+    appendReturningClause(sql, entity, mainAlias, option) {
+        if (option?.returning) {
+            const returningClause = this.buildReturningClause(entity, mainAlias, option.returning);
+            return `${sql} RETURNING ${returningClause}`;
         }
         return sql;
     }
     translateRemove(entity, operation, option) {
         const { data, filter, sorter, indexFrom, count } = operation;
-        (0, assert_1.default)(!sorter, '当前remove不支持sorter行为');
-        // 使用结构化的JOIN分析
-        const { aliasDict, filterRefAlias, mainTable, mainAlias, joinInfos, currentNumber } = this.analyzeJoinStructured(entity, { filter, sorter });
-        // 构建过滤条件
-        const { stmt: filterText } = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, { includedDeleted: option?.includedDeleted });
         const { attributes } = this.schema[entity];
+        // 参数验证
+        this.validateOperationParams(sorter, indexFrom, count);
+        const mainTable = this.getStorageName(entity);
+        const mainAlias = `${entity}_1`;
+        // 构建子查询
+        const subqueryOperation = {
+            data: { [types_1.PrimaryKeyAttribute]: 1 },
+            filter: filter,
+            indexFrom: indexFrom,
+            count: count
+        };
+        const subquery = this.translateSelect(entity, subqueryOperation, { includedDeleted: option?.includedDeleted });
+        let sql;
         if (option?.deletePhysically) {
             // 物理删除
             (0, assert_1.default)((0, lodash_1.difference)(Object.keys(data), [types_1.UpdateAtAttribute, types_1.DeleteAtAttribute]).length === 0);
-            let sql;
-            if (joinInfos.length === 0) {
-                // 单表删除
-                sql = `DELETE FROM "${mainTable}" AS "${mainAlias}"`;
-                if (filterText) {
-                    sql += ` WHERE ${filterText}`;
-                }
-            }
-            else {
-                // 多表删除 - PostgreSQL语法: DELETE FROM main USING other_tables WHERE join_conditions AND filter
-                sql = `DELETE FROM "${mainTable}" AS "${mainAlias}"`;
-                // USING子句包含所有JOIN的表
-                const usingTables = joinInfos.map(j => `"${j.table}" AS "${j.alias}"`).join(', ');
-                sql += ` USING ${usingTables}`;
-                // WHERE子句包含JOIN条件和过滤条件
-                const joinConditions = this.buildJoinConditions(joinInfos);
-                let whereClause = joinConditions;
-                if (filterText) {
-                    whereClause = whereClause ? `${whereClause} AND ${filterText}` : filterText;
-                }
-                if (whereClause) {
-                    sql += ` WHERE ${whereClause}`;
-                }
-            }
-            return sql;
+            sql = `DELETE FROM "${mainTable}" AS "${mainAlias}" WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
         }
         else {
-            // 软删除 - 实际是UPDATE操作
+            // 软删除- 实际是 UPDATE
             const setClauses = [];
             for (const attr in data) {
                 (0, assert_1.default)([types_1.TriggerDataAttribute, types_1.TriggerUuidAttribute, types_1.DeleteAtAttribute, types_1.UpdateAtAttribute].includes(attr));
@@ -1575,164 +1588,10 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                 setClauses.push(`"${attr}" = ${value}`);
             }
             const setClause = setClauses.join(', ');
-            let sql;
-            if (joinInfos.length === 0) {
-                // 单表更新
-                sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-                if (filterText) {
-                    sql += ` WHERE ${filterText}`;
-                }
-            }
-            else {
-                // 多表更新
-                sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-                const fromTables = joinInfos.map(j => `"${j.table}" AS "${j.alias}"`).join(', ');
-                sql += ` FROM ${fromTables}`;
-                const joinConditions = this.buildJoinConditions(joinInfos);
-                let whereClause = joinConditions;
-                if (filterText) {
-                    whereClause = whereClause ? `${whereClause} AND ${filterText}` : filterText;
-                }
-                if (whereClause) {
-                    sql += ` WHERE ${whereClause}`;
-                }
-            }
-            return sql;
-        }
-    }
-    /**
-     * PostgreSQL专用的结构化JOIN分析
-     * 返回结构化的JOIN信息，而不是拼接好的FROM字符串
-     */
-    analyzeJoinStructured(entity, { filter, sorter }, initialNumber) {
-        const { schema } = this;
-        let number = initialNumber || 1;
-        const filterRefAlias = {};
-        const mainAlias = `${entity}_${number++}`;
-        const mainTable = this.getStorageName(entity);
-        const aliasDict = {
-            './': mainAlias,
-        };
-        const joinInfos = [];
-        const analyzeFilterNode = ({ node, path, entityName, alias }) => {
-            Object.keys(node).forEach((op) => {
-                if (['$and', '$or'].includes(op)) {
-                    node[op].forEach((subNode) => analyzeFilterNode({
-                        node: subNode,
-                        path,
-                        entityName,
-                        alias,
-                    }));
-                }
-                else if (['$not'].includes(op)) {
-                    analyzeFilterNode({
-                        node: node[op],
-                        path,
-                        entityName,
-                        alias,
-                    });
-                }
-                else if (['$text'].includes(op)) {
-                    // 全文搜索，不需要JOIN
-                }
-                else {
-                    const rel = (0, relation_1.judgeRelation)(this.schema, entityName, op);
-                    if (typeof rel === 'string') {
-                        const pathAttr = `${path}${op}/`;
-                        if (!aliasDict.hasOwnProperty(pathAttr)) {
-                            const alias2 = `${rel}_${number++}`;
-                            aliasDict[pathAttr] = alias2;
-                            joinInfos.push({
-                                table: this.getStorageName(rel),
-                                alias: alias2,
-                                leftAlias: alias,
-                                leftKey: op + 'Id',
-                                rightKey: 'id',
-                            });
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: rel,
-                                alias: alias2,
-                            });
-                        }
-                        else {
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: rel,
-                                alias: aliasDict[pathAttr],
-                            });
-                        }
-                    }
-                    else if (rel === 2) {
-                        const pathAttr = `${path}${op}/`;
-                        if (!aliasDict.hasOwnProperty(pathAttr)) {
-                            const alias2 = `${op}_${number++}`;
-                            aliasDict[pathAttr] = alias2;
-                            joinInfos.push({
-                                table: this.getStorageName(op),
-                                alias: alias2,
-                                leftAlias: alias,
-                                leftKey: 'entityId',
-                                rightKey: 'id',
-                                extraCondition: `"${alias}"."entity" = '${op}'`,
-                            });
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: op,
-                                alias: alias2,
-                            });
-                        }
-                        else {
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: op,
-                                alias: aliasDict[pathAttr],
-                            });
-                        }
-                    }
-                }
-            });
-            if (node['#id']) {
-                (0, assert_1.default)(!filterRefAlias[node['#id']]);
-                filterRefAlias[node['#id']] = [alias, entityName];
-            }
-        };
-        if (filter) {
-            analyzeFilterNode({
-                node: filter,
-                path: './',
-                entityName: entity,
-                alias: mainAlias,
-            });
-        }
-        // TODO: sorter的分析类似，这里省略（UPDATE/DELETE通常不需要sorter）
-        (0, assert_1.default)(!sorter, '当前analyzeJoinStructured不支持sorter行为');
-        return {
-            aliasDict,
-            filterRefAlias,
-            mainTable,
-            mainAlias,
-            joinInfos,
-            currentNumber: number,
-        };
-    }
-    /**
-     * 构建JOIN条件（用于UPDATE/DELETE的WHERE子句）
-     */
-    buildJoinConditions(joinInfos) {
-        const conditions = [];
-        for (const join of joinInfos) {
-            let condition = `"${join.leftAlias}"."${join.leftKey}" = "${join.alias}"."${join.rightKey}"`;
-            if (join.extraCondition) {
-                condition = `(${condition} AND ${join.extraCondition})`;
-            }
-            conditions.push(condition);
+            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause} WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
         }
-        return conditions.join(' AND ');
+        // 添加 RETURNING 子句
+        return this.appendReturningClause(sql, entity, mainAlias, option);
     }
     /**
      * 生成 PostgreSQL UPSERT 语句
@@ -1766,5 +1625,401 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
         // 这个方法不应该被直接调用了，因为translateRemove已经重写
         throw new Error('populateRemoveStmt should not be called directly in PostgreSQL. Use translateRemove instead.');
     }
+    /**
+     * 将 PostgreSQL 返回的 Type 回译成 oak 的类型，是 populateDataTypeDef 的反函数
+     * @param type PostgreSQL 类型字符串
+     */
+    reTranslateToAttribute(type) {
+        // 处理带长度的类型：character varying(255), character(10)
+        const varcharMatch = /^character varying\((\d+)\)$/.exec(type);
+        if (varcharMatch) {
+            return {
+                type: 'varchar',
+                params: {
+                    length: parseInt(varcharMatch[1], 10),
+                }
+            };
+        }
+        const charMatch = /^character\((\d+)\)$/.exec(type);
+        if (charMatch) {
+            return {
+                type: 'char',
+                params: {
+                    length: parseInt(charMatch[1], 10),
+                }
+            };
+        }
+        // 处理带精度和小数位的类型：numeric(10,2)
+        const numericWithScaleMatch = /^numeric\((\d+),(\d+)\)$/.exec(type);
+        if (numericWithScaleMatch) {
+            return {
+                type: 'decimal',
+                params: {
+                    precision: parseInt(numericWithScaleMatch[1], 10),
+                    scale: parseInt(numericWithScaleMatch[2], 10),
+                },
+            };
+        }
+        // 处理只带精度的类型：numeric(10), timestamp(6)
+        const numericMatch = /^numeric\((\d+)\)$/.exec(type);
+        if (numericMatch) {
+            return {
+                type: 'decimal',
+                params: {
+                    precision: parseInt(numericMatch[1], 10),
+                    scale: 0,
+                },
+            };
+        }
+        const timestampMatch = /^timestamp\((\d+)\) without time zone$/.exec(type);
+        if (timestampMatch) {
+            return {
+                type: 'timestamp',
+                params: {
+                    precision: parseInt(timestampMatch[1], 10),
+                },
+            };
+        }
+        const timeMatch = /^time\((\d+)\) without time zone$/.exec(type);
+        if (timeMatch) {
+            return {
+                type: 'time',
+                params: {
+                    precision: parseInt(timeMatch[1], 10),
+                },
+            };
+        }
+        // PostgreSQL 类型映射到 oak 类型
+        const typeMap = {
+            'bigint': 'bigint',
+            'integer': 'integer',
+            'smallint': 'smallint',
+            'real': 'real',
+            'double precision': 'double precision',
+            'boolean': 'boolean',
+            'text': 'text',
+            'jsonb': 'object',
+            'json': 'object',
+            'bytea': 'bytea',
+            'character varying': 'varchar',
+            'character': 'char',
+            'timestamp without time zone': 'timestamp',
+            'time without time zone': 'time',
+            'date': 'date',
+            'uuid': 'uuid',
+            'geometry': 'geometry',
+            'numeric': 'decimal',
+        };
+        const mappedType = typeMap[type];
+        if (mappedType) {
+            return { type: mappedType };
+        }
+        // 如果是用户定义的枚举类型，返回 enum（具体值需要额外查询）
+        // 这里先返回基础类型，枚举值在 readSchema 中单独处理
+        return { type: type };
+    }
+    /**
+     * 从 PostgreSQL 数据库读取当前的 schema 结构
+     */
+    async readSchema(execFn) {
+        const result = {};
+        // 1. 获取所有表
+        const tablesSql = `
+        SELECT tablename 
+        FROM pg_tables 
+        WHERE schemaname = 'public'
+        ORDER BY tablename;
+    `;
+        const [tablesResult] = await execFn(tablesSql);
+        for (const tableRow of tablesResult) {
+            const tableName = tableRow.tablename;
+            // 2. 获取表的列信息
+            const columnsSql = `
+            SELECT 
+                column_name,
+                data_type,
+                character_maximum_length,
+                numeric_precision,
+                numeric_scale,
+                is_nullable,
+                column_default,
+                udt_name
+            FROM information_schema.columns
+            WHERE table_schema = 'public' 
+                AND table_name = '${tableName}'
+            ORDER BY ordinal_position;
+        `;
+            const [columnsResult] = await execFn(columnsSql);
+            const attributes = {};
+            for (const col of columnsResult) {
+                const { column_name: colName, data_type: dataType, character_maximum_length: maxLength, numeric_precision: precision, numeric_scale: scale, is_nullable: isNullable, column_default: defaultValue, udt_name: udtName, } = col;
+                let attr;
+                // 处理用户定义类型（枚举）
+                if (dataType === 'USER-DEFINED') {
+                    const enumSql = `
+            SELECT e.enumlabel
+            FROM pg_type t
+            JOIN pg_enum e ON t.oid = e.enumtypid
+            WHERE t.typname = '${udtName}'
+            ORDER BY e.enumsortorder;
+        `;
+                    const [enumResult] = await execFn(enumSql);
+                    const enumeration = enumResult.map((r) => r.enumlabel);
+                    attr = {
+                        type: 'enum',
+                        enumeration,
+                    };
+                }
+                else {
+                    // 构建完整的类型字符串
+                    let fullType = dataType;
+                    const integerTypes = ['bigint', 'integer', 'smallint', 'serial', 'bigserial', 'smallserial'];
+                    if (maxLength && !integerTypes.includes(dataType)) {
+                        fullType = `${dataType}(${maxLength})`;
+                    }
+                    else if (precision !== null && scale !== null && !integerTypes.includes(dataType)) {
+                        fullType = `${dataType}(${precision},${scale})`;
+                    }
+                    else if (precision !== null && !integerTypes.includes(dataType)) {
+                        fullType = `${dataType}(${precision})`;
+                    }
+                    attr = this.reTranslateToAttribute(fullType);
+                }
+                // ========== 类型还原逻辑 ==========
+                // 框架将某些语义类型存储为 bigint，需要根据列名还原
+                if (attr.type === 'bigint') {
+                    // 1. 检查是否是序列列
+                    if (colName === '$$seq$$' || (defaultValue && defaultValue.includes('nextval'))) {
+                        attr.type = 'sequence';
+                        attr.sequenceStart = 10000; // 默认起始值
+                    }
+                    // 2. 检查是否是时间戳列
+                    else if (['$$createAt$$', '$$updateAt$$', '$$deleteAt$$'].includes(colName)) {
+                        attr.type = 'datetime';
+                    }
+                    // 3. 检查其他可能的时间类型列（根据命名约定）
+                    else if (colName.endsWith('At') || colName.endsWith('Time')) {
+                        // 可选：根据业务约定判断是否应该是 datetime
+                        // 这里保守处理，只转换框架标准字段
+                    }
+                }
+                // 处理约束 - 只在为 true 时添加
+                if (isNullable === 'NO') {
+                    attr.notNull = true;
+                }
+                // 处理默认值
+                if (defaultValue && !defaultValue.includes('nextval')) {
+                    let cleanDefault = defaultValue.replace(/::[a-z]+/gi, '').replace(/'/g, '');
+                    if (cleanDefault === 'true') {
+                        attr.default = true;
+                    }
+                    else if (cleanDefault === 'false') {
+                        attr.default = false;
+                    }
+                    else if (!isNaN(Number(cleanDefault))) {
+                        attr.default = Number(cleanDefault);
+                    }
+                    else if (cleanDefault !== '') {
+                        attr.default = cleanDefault;
+                    }
+                }
+                // 检查唯一约束
+                const uniqueSql = `
+        SELECT COUNT(*) as cnt
+        FROM pg_index ix
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+        WHERE t.relname = '${tableName}'
+            AND a.attname = '${colName}'
+            AND ix.indisunique = true
+            AND NOT ix.indisprimary
+            AND array_length(ix.indkey, 1) = 1;
+    `;
+                const [uniqueResult] = await execFn(uniqueSql);
+                const uniqueCount = parseInt(uniqueResult[0]?.cnt || '0', 10);
+                if (uniqueCount > 0) {
+                    attr.unique = true;
+                }
+                attributes[colName] = attr;
+            }
+            // 3. 获取索引信息
+            const indexesSql = `
+    SELECT 
+        i.relname as index_name,
+        ix.indisunique as is_unique,
+        am.amname as index_type,
+        pg_get_indexdef(ix.indexrelid) as index_def
+    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
+    WHERE t.relname = '${tableName}'
+        AND t.relkind = 'r'
+        AND i.relname NOT LIKE '%_pkey'
+        AND NOT ix.indisprimary
+    ORDER BY i.relname;
+`;
+            const [indexesResult] = await execFn(indexesSql);
+            if (indexesResult.length > 0) {
+                const indexes = [];
+                for (const row of indexesResult) {
+                    const { index_name: indexName, is_unique: isUnique, index_type: indexType, index_def: indexDef } = row;
+                    // 解析索引定义以获取列名和配置
+                    const index = {
+                        name: indexName,
+                        attributes: [],
+                    };
+                    // 解析索引定义字符串
+                    // 示例: CREATE INDEX "user_index_fulltext_chinese" ON public."user" USING gin (to_tsvector('chinese'::regconfig, (COALESCE(name, ''::text) || ' '::text) || COALESCE(nickname, ''::text)))
+                    if (indexType === 'gin' && indexDef.includes('to_tsvector')) {
+                        // 全文索引
+                        index.config = { type: 'fulltext' };
+                        // 提取 tsConfig
+                        const tsConfigMatch = indexDef.match(/to_tsvector\('([^']+)'/);
+                        if (tsConfigMatch) {
+                            const tsConfig = tsConfigMatch[1];
+                            index.config.tsConfig = tsConfig;
+                        }
+                        // 提取列名（从 COALESCE 中）
+                        const columnMatches = indexDef.matchAll(/COALESCE\("?([^",\s]+)"?/g);
+                        const columns = Array.from(columnMatches, m => m[1]);
+                        index.attributes = columns.map(col => ({ name: col }));
+                        // 处理多语言索引的情况：移除语言后缀
+                        // 例如: user_index_fulltext_chinese -> index_fulltext
+                        const nameParts = indexName.split('_');
+                        if (nameParts.length > 2) {
+                            const possibleLang = nameParts[nameParts.length - 1];
+                            // 如果最后一部分是语言代码，移除它
+                            if (['chinese', 'english', 'simple', 'german', 'french', 'spanish', 'russian', 'japanese'].includes(possibleLang)) {
+                                index.name = nameParts.slice(0, -1).join('_');
+                            }
+                        }
+                    }
+                    else if (indexType === 'gist') {
+                        // 空间索引
+                        index.config = { type: 'spatial' };
+                        // 提取列名
+                        const columnMatch = indexDef.match(/\(([^)]+)\)/);
+                        if (columnMatch) {
+                            const columns = columnMatch[1].split(',').map(c => c.trim().replace(/"/g, ''));
+                            index.attributes = columns.map(col => ({ name: col }));
+                        }
+                    }
+                    else if (indexType === 'hash') {
+                        // 哈希索引
+                        index.config = { type: 'hash' };
+                        // 提取列名
+                        const columnMatch = indexDef.match(/\(([^)]+)\)/);
+                        if (columnMatch) {
+                            const columns = columnMatch[1].split(',').map(c => c.trim().replace(/"/g, ''));
+                            index.attributes = columns.map(col => ({ name: col }));
+                        }
+                    }
+                    else {
+                        // B-tree 索引（默认）
+                        // 提取列名和排序方向
+                        const columnMatch = indexDef.match(/\(([^)]+)\)/);
+                        if (columnMatch) {
+                            const columnDefs = columnMatch[1].split(',');
+                            index.attributes = columnDefs.map(colDef => {
+                                const trimmed = colDef.trim().replace(/"/g, '');
+                                const parts = trimmed.split(/\s+/);
+                                const attr = { name: parts[0] };
+                                // 检查排序方向
+                                if (parts.includes('DESC')) {
+                                    attr.direction = 'DESC';
+                                }
+                                else if (parts.includes('ASC')) {
+                                    attr.direction = 'ASC';
+                                }
+                                return attr;
+                            });
+                        }
+                        // 如果是唯一索引
+                        if (isUnique) {
+                            index.config = { unique: true };
+                        }
+                    }
+                    // 移除表名前缀（如果存在）
+                    // 例如: user_index_fulltext -> index_fulltext
+                    if (index.name.startsWith(`${tableName}_`)) {
+                        index.name = index.name.substring(tableName.length + 1);
+                    }
+                    indexes.push(index);
+                }
+                Object.assign(result, {
+                    [tableName]: {
+                        attributes,
+                        indexes,
+                    }
+                });
+            }
+            else {
+                Object.assign(result, {
+                    [tableName]: {
+                        attributes,
+                    }
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * 将属性定义转换为 PostgreSQL DDL 语句
+     * @param attr 属性名
+     * @param attrDef 属性定义
+     */
+    translateAttributeDef(attr, attrDef) {
+        let sql = `"${attr}" `;
+        const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
+        // 处理序列类型（IDENTITY）
+        if (type === 'sequence' || (typeof sequenceStart === 'number')) {
+            sql += `bigint GENERATED BY DEFAULT AS IDENTITY (START WITH ${sequenceStart || 10000}) UNIQUE`;
+            return sql;
+        }
+        // 处理枚举类型
+        if (type === 'enum') {
+            (0, assert_1.default)(enumeration, 'Enum type requires enumeration values');
+            sql += `enum(${enumeration.map(v => `'${v}'`).join(',')})`;
+        }
+        else {
+            sql += this.populateDataTypeDef(type, params, enumeration);
+        }
+        // NOT NULL 约束
+        if (notNull || type === 'geometry') {
+            sql += ' NOT NULL';
+        }
+        // UNIQUE 约束
+        if (unique) {
+            sql += ' UNIQUE';
+        }
+        // 默认值
+        if (defaultValue !== undefined && !sequenceStart) {
+            (0, assert_1.default)(type !== 'ref', 'ref type should not have default value');
+            sql += ` DEFAULT ${this.translateAttrValue(type, defaultValue)}`;
+        }
+        // 主键
+        if (attr === 'id') {
+            sql += ' PRIMARY KEY';
+        }
+        return sql;
+    }
+    /**
+     * 比较两个 SQL 语句是否等价（用于 schema diff）
+     * 忽略空格、大小写等格式差异
+     */
+    compareSql(sql1, sql2) {
+        // 标准化 SQL：移除多余空格，统一大小写
+        const normalize = (sql) => {
+            return sql
+                .replace(/\s+/g, ' ') // 多个空格合并为一个
+                .replace(/\(\s+/g, '(') // 移除括号后的空格
+                .replace(/\s+\)/g, ')') // 移除括号前的空格
+                .replace(/,\s+/g, ',') // 移除逗号后的空格
+                .trim()
+                .toLowerCase();
+        };
+        return normalize(sql1) === normalize(sql2);
+    }
 }
 exports.PostgreSQLTranslator = PostgreSQLTranslator;