oak-db 3.3.11 → 3.3.13

package/lib/PostgreSQL/translator.js

@@ -0,0 +1,2159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLTranslator = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+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',
+        name: "Point"
+    },
+    {
+        type: 'path',
+        name: "LineString",
+        element: 'point',
+    },
+    {
+        name: "MultiLineString",
+        element: "path",
+        multiple: true,
+    },
+    {
+        type: 'polygon',
+        name: "Polygon",
+        element: "path"
+    },
+    {
+        name: "MultiPoint",
+        element: "point",
+        multiple: true,
+    },
+    {
+        name: "MultiPolygon",
+        element: "polygon",
+        multiple: true,
+    }
+];
+/**
+ * 将 Geo 对象转换为 PostGIS 的 WKT 格式
+ */
+function transformGeoData(data) {
+    if (data instanceof Array) {
+        const element = data[0];
+        if (element instanceof Array) {
+            // GeometryCollection
+            return `ST_GeomFromText('GEOMETRYCOLLECTION(${data.map(ele => transformGeoData(ele).replace(/ST_GeomFromText\('|'\)/g, '')).join(',')})')`;
+        }
+        else {
+            // Multi 类型
+            const geoType = GeoTypes.find(ele => ele.type === element.type);
+            if (!geoType) {
+                throw new Error(`${element.type} is not supported in PostgreSQL`);
+            }
+            const multiGeoType = GeoTypes.find(ele => ele.element === geoType.type && ele.multiple);
+            if (!multiGeoType) {
+                throw new Error(`Multi type for ${element.type} not found`);
+            }
+            const innerWkt = data.map(ele => {
+                const wkt = transformGeoData(ele);
+                // 提取括号内的坐标部分
+                const match = wkt.match(/\(([^)]+)\)/);
+                return match ? match[0] : '';
+            }).join(',');
+            return `ST_GeomFromText('${multiGeoType.name.toUpperCase()}(${innerWkt})')`;
+        }
+    }
+    else {
+        const { type, coordinate } = data;
+        const geoType = GeoTypes.find(ele => ele.type === type);
+        if (!geoType) {
+            throw new Error(`${type} is not supported in PostgreSQL`);
+        }
+        const { element, name } = geoType;
+        if (!element) {
+            // Point: coordinate 是 [x, y]
+            return `ST_GeomFromText('POINT(${coordinate.join(' ')})')`;
+        }
+        if (type === 'path') {
+            // LineString: coordinate 是 [[x1,y1], [x2,y2], ...]
+            const points = coordinate
+                .map(p => p.join(' '))
+                .join(',');
+            return `ST_GeomFromText('LINESTRING(${points})')`;
+        }
+        if (type === 'polygon') {
+            // Polygon: coordinate 是 [[[x1,y1], [x2,y2], ...], [...]]（外环和内环）
+            const rings = coordinate
+                .map(ring => `(${ring.map(p => p.join(' ')).join(',')})`)
+                .join(',');
+            return `ST_GeomFromText('POLYGON(${rings})')`;
+        }
+        throw new Error(`Unsupported geometry type: ${type}`);
+    }
+}
+class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
+    // 生成 enum 类型名称
+    getEnumTypeName(entity, attr) {
+        return `${entity}_${attr}_enum`.toLowerCase();
+    }
+    /**
+     * 将 MySQL 风格的 JSON 路径转换为 PostgreSQL 路径数组格式
+     * 例如: ".foo.bar[0].baz" -> '{foo,bar,0,baz}'
+     */
+    convertJsonPath(mysqlPath) {
+        if (!mysqlPath || mysqlPath === '') {
+            return '';
+        }
+        // 移除开头的点
+        let path = mysqlPath.startsWith('.') ? mysqlPath.slice(1) : mysqlPath;
+        // 解析路径组件
+        const components = [];
+        let current = '';
+        let i = 0;
+        while (i < path.length) {
+            const char = path[i];
+            if (char === '.') {
+                if (current) {
+                    components.push(current);
+                    current = '';
+                }
+                i++;
+            }
+            else if (char === '[') {
+                if (current) {
+                    components.push(current);
+                    current = '';
+                }
+                // 找到对应的 ]
+                const endBracket = path.indexOf(']', i);
+                if (endBracket === -1) {
+                    throw new Error(`Invalid JSON path: unmatched [ at position ${i}`);
+                }
+                const index = path.slice(i + 1, endBracket);
+                components.push(index);
+                i = endBracket + 1;
+            }
+            else {
+                current += char;
+                i++;
+            }
+        }
+        if (current) {
+            components.push(current);
+        }
+        return `'{${components.join(',')}}'`;
+    }
+    /**
+     * 生成 PostgreSQL JSON 访问表达式
+     * @param column 列名（包含别名）
+     * @param path JSON 路径
+     * @param asText 是否返回文本（使用 #>> 而不是 #>）
+     */
+    buildJsonAccessor(column, path, asText = true) {
+        if (!path || path === '') {
+            return column;
+        }
+        const pgPath = this.convertJsonPath(path);
+        const operator = asText ? '#>>' : '#>';
+        return `${column}${operator}${pgPath}`;
+    }
+    getDefaultSelectFilter(alias, option) {
+        if (option?.includedDeleted) {
+            return '';
+        }
+        return ` ("${alias}"."$$deleteAt$$" is null)`;
+    }
+    makeUpSchema() {
+        for (const entity in this.schema) {
+            const { attributes, indexes } = this.schema[entity];
+            const geoIndexes = [];
+            for (const attr in attributes) {
+                if (attributes[attr].type === 'geometry') {
+                    const geoIndex = indexes?.find((idx) => idx.config?.type === 'spatial' && idx.attributes.find((attrDef) => attrDef.name === attr));
+                    if (!geoIndex) {
+                        geoIndexes.push({
+                            name: `${entity}_geo_${attr}`,
+                            attributes: [{
+                                    name: attr,
+                                }],
+                            config: {
+                                type: 'spatial',
+                            }
+                        });
+                    }
+                }
+            }
+            if (geoIndexes.length > 0) {
+                if (indexes) {
+                    indexes.push(...geoIndexes);
+                }
+                else {
+                    (0, lodash_1.assign)(this.schema[entity], {
+                        indexes: geoIndexes,
+                    });
+                }
+            }
+        }
+    }
+    constructor(schema) {
+        super(schema);
+        // PostgreSQL为geometry属性默认创建索引
+        this.makeUpSchema();
+    }
+    static supportedDataTypes = [
+        // numeric types
+        "smallint",
+        "integer",
+        "bigint",
+        "decimal",
+        "numeric",
+        "real",
+        "double precision",
+        // TODO: 下面三种类型暂不支持（在oak-domain中未定义）
+        // "serial",
+        // "bigserial",
+        // "smallserial",
+        // boolean
+        "boolean",
+        // date and time types
+        "date",
+        "time",
+        "timestamp",
+        "timestamptz",
+        "interval",
+        // string types
+        "char",
+        "varchar",
+        "text",
+        // binary
+        "bytea",
+        // json data types
+        "json",
+        "jsonb",
+        // uuid
+        "uuid",
+        // spatial data types (PostGIS)
+        "geometry",
+        "geography",
+        "point",
+        "line",
+        "lseg",
+        "box",
+        "path",
+        "polygon",
+        "circle"
+    ];
+    static spatialTypes = [
+        "geometry",
+        "geography",
+        "point",
+        "line",
+        "lseg",
+        "box",
+        "path",
+        "polygon",
+        "circle"
+    ];
+    static withLengthDataTypes = [
+        "char",
+        "varchar",
+        "bit",
+        "varbit"
+    ];
+    static withPrecisionDataTypes = [
+        "decimal",
+        "numeric",
+        "time",
+        "timestamp",
+        "timestamptz"
+    ];
+    static withScaleDataTypes = [
+        "decimal",
+        "numeric"
+    ];
+    // PostgreSQL 不支持 unsigned，移除此列表
+    // static unsignedAndZerofillTypes - 删除
+    // PostgreSQL 不使用 width 概念
+    // static withWidthDataTypes - 删除
+    static dataTypeDefaults = {
+        "varchar": { length: 255 },
+        "char": { length: 1 },
+        "decimal": { precision: 10, scale: 0 },
+        "numeric": { precision: 10, scale: 0 },
+        "time": { precision: 6 },
+        "timestamp": { precision: 6 },
+        "timestamptz": { precision: 6 },
+        "bit": { length: 1 },
+        "varbit": { length: 255 }
+    };
+    maxAliasLength = 63;
+    populateDataTypeDef(type, params, enumeration) {
+        // 时间类型 - 框架内部用 bigint 存储 Unix 时间戳
+        if (['date', 'datetime', 'time', 'sequence'].includes(type)) {
+            return 'bigint';
+        }
+        // JSON 类型 - PostgreSQL 推荐使用 jsonb
+        if (['object', 'array'].includes(type)) {
+            return 'jsonb';
+        }
+        // 文本类型
+        if (['image', 'function'].includes(type)) {
+            return 'text';
+        }
+        // 引用类型 - UUID 字符串
+        if (type === 'ref') {
+            return 'char(36)';
+        }
+        // 金额类型
+        if (type === 'money') {
+            return 'bigint';
+        }
+        // 布尔类型
+        if (type === 'bool' || type === 'boolean') {
+            return 'boolean';
+        }
+        // 枚举类型 - PostgreSQL 需要使用预创建的 TYPE
+        // 这里返回类型名称，实际创建在 translateCreateEntity 中处理
+        if (type === 'enum') {
+            (0, assert_1.default)(enumeration);
+            // 返回一个占位符，实际类型名会在创建表时确定
+            return '__ENUM_PLACEHOLDER__';
+        }
+        // int 类型映射
+        if (type === 'int' || type === 'integer') {
+            if (params?.width) {
+                const { width } = params;
+                if (width <= 2) {
+                    return 'smallint';
+                }
+                else if (width <= 4) {
+                    return 'integer';
+                }
+                else {
+                    return 'bigint';
+                }
+            }
+            return 'integer';
+        }
+        // MySQL 特有类型映射到 PostgreSQL
+        if (type === 'tinyint') {
+            return 'smallint';
+        }
+        if (type === 'mediumint') {
+            return 'integer';
+        }
+        if (type === 'double') {
+            return 'double precision';
+        }
+        if (type === 'float') {
+            return 'real';
+        }
+        if (type === 'datetime') {
+            return 'timestamp';
+        }
+        if (type === 'blob' || type === 'tinyblob' || type === 'mediumblob' || type === 'longblob') {
+            return 'bytea';
+        }
+        if (type === 'tinytext' || type === 'mediumtext' || type === 'longtext') {
+            return 'text';
+        }
+        // 带长度的类型
+        if (PostgreSQLTranslator.withLengthDataTypes.includes(type)) {
+            const defaults = PostgreSQLTranslator.dataTypeDefaults[type];
+            const length = params?.length ?? defaults?.length;
+            if (length) {
+                return `${type}(${length})`;
+            }
+            return type;
+        }
+        // 带精度的类型
+        if (PostgreSQLTranslator.withPrecisionDataTypes.includes(type)) {
+            const defaults = PostgreSQLTranslator.dataTypeDefaults[type];
+            const precision = params?.precision ?? defaults?.precision;
+            const scale = params?.scale ?? defaults?.scale;
+            if (precision !== undefined) {
+                if (scale !== undefined && PostgreSQLTranslator.withScaleDataTypes.includes(type)) {
+                    return `${type}(${precision}, ${scale})`;
+                }
+                return `${type}(${precision})`;
+            }
+            return type;
+        }
+        // geometry 类型 - 需要 PostGIS 扩展
+        if (type === 'geometry') {
+            return 'geometry';
+        }
+        return type;
+    }
+    /**
+     * PostgreSQL 字符串值转义
+     * 防御SQL注入
+     */
+    escapeStringValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        // PostgreSQL 标准 SQL 转义
+        // 1. 单引号转义为两个单引号
+        // 2. 反斜杠在 standard_conforming_strings=on（默认）时不需要特殊处理
+        const escaped = String(value).replace(/'/g, "''");
+        return `'${escaped}'`;
+    }
+    /**
+     * LIKE 模式转义
+     * 转义 LIKE 语句中的特殊字符
+     */
+    escapeLikePattern(value) {
+        // 先转义 LIKE 的特殊字符
+        const escaped = String(value)
+            .replace(/\\/g, '\\\\') // 反斜杠必须先处理
+            .replace(/%/g, '\\%') // 百分号
+            .replace(/_/g, '\\_'); // 下划线
+        // 再进行字符串值转义
+        return escaped.replace(/'/g, "''");
+    }
+    /**
+     * PostgreSQL 标识符转义
+     * 用于表名、列名等
+     */
+    escapeIdentifier(identifier) {
+        // 标识符中的双引号转义为两个双引号
+        const escaped = String(identifier).replace(/"/g, '""');
+        return `"${escaped}"`;
+    }
+    /**
+     * tsquery 搜索词转义
+     */
+    escapeTsQueryValue(value) {
+        // 移除或转义 tsquery 的特殊字符
+        return String(value)
+            .replace(/'/g, "''") // SQL 单引号
+            .replace(/[&|!():<>\\]/g, ' ') // tsquery 特殊字符替换为空格
+            .replace(/\s+/g, ' ') // 合并多个空格
+            .trim();
+    }
+    quoteIdentifier(identifier) {
+        return `"${identifier}"`;
+    }
+    translateAttrProjection(dataType, alias, attr) {
+        switch (dataType) {
+            case 'geometry': {
+                return ` st_astext("${alias}"."${attr}")`;
+            }
+            default: {
+                return ` "${alias}"."${attr}"`;
+            }
+        }
+    }
+    translateObjectPredicate(predicate, alias, attr) {
+        const columnRef = `"${alias}"."${attr}"`;
+        const translateInner = (o, p) => {
+            let stmt2 = '';
+            if (o instanceof Array) {
+                o.forEach((ele, idx) => {
+                    if (ele !== undefined && ele !== null) {
+                        const part = translateInner(ele, `${p}[${idx}]`);
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        stmt2 += part;
+                    }
+                });
+            }
+            else if (typeof o === 'object' && o !== null) {
+                for (const attr2 in o) {
+                    if (attr2 === '$and') {
+                        const andParts = [];
+                        o[attr2].forEach((ele) => {
+                            const part = translateInner(ele, p);
+                            if (part) {
+                                andParts.push(part);
+                            }
+                        });
+                        if (andParts.length > 0) {
+                            if (stmt2) {
+                                stmt2 += ' AND ';
+                            }
+                            stmt2 += `(${andParts.join(' AND ')})`;
+                        }
+                    }
+                    else if (attr2 === '$or') {
+                        const orParts = [];
+                        o[attr2].forEach((ele) => {
+                            const part = translateInner(ele, p);
+                            if (part) {
+                                orParts.push(part);
+                            }
+                        });
+                        if (orParts.length > 0) {
+                            if (stmt2) {
+                                stmt2 += ' AND ';
+                            }
+                            stmt2 += `(${orParts.join(' OR ')})`;
+                        }
+                    }
+                    else if (attr2 === '$contains') {
+                        // PostgreSQL 使用 @> 操作符检查 JSON 包含关系
+                        const targetArr = Array.isArray(o[attr2]) ? o[attr2] : [o[attr2]];
+                        const value = JSON.stringify(targetArr);
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        if (p) {
+                            // 先提取子路径，再检查包含
+                            const accessor = this.buildJsonAccessor(columnRef, p, false);
+                            stmt2 += `(${accessor} @> '${value}'::jsonb)`;
+                        }
+                        else {
+                            stmt2 += `(${columnRef} @> '${value}'::jsonb)`;
+                        }
+                    }
+                    else if (attr2 === '$overlaps') {
+                        // PostgreSQL 使用 ?| 检查数组键重叠，或使用自定义逻辑
+                        const value = o[attr2];
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        if (Array.isArray(value)) {
+                            // 如果是数组，检查是否有任意元素匹配  
+                            const accessor = p ? this.buildJsonAccessor(columnRef, p, false) : columnRef;
+                            // 使用 @> 操作符检查数组是否包含任意一个值（支持数字和字符串）
+                            const conditions = value.map(v => `${accessor} @> '${JSON.stringify(v)}'::jsonb`);
+                            stmt2 += `(${conditions.join(' OR ')})`;
+                        }
+                        else if (typeof value === 'object' && value !== null) {
+                            // 对象重叠检查 - 检查是否有共同的键
+                            const keys = Object.keys(value);
+                            if (p) {
+                                const accessor = this.buildJsonAccessor(columnRef, p, false);
+                                stmt2 += `(${accessor} ?| array[${keys.map(k => `'${k}'`).join(', ')}])`;
+                            }
+                            else {
+                                stmt2 += `(${columnRef} ?| array[${keys.map(k => `'${k}'`).join(', ')}])`;
+                            }
+                        }
+                        else {
+                            (0, assert_1.default)(typeof value === 'string');
+                            // 单个键的重叠检查
+                            if (p) {
+                                const accessor = this.buildJsonAccessor(columnRef, p, false);
+                                stmt2 += `(${accessor} ? '${value}')`;
+                            }
+                            else {
+                                stmt2 += `(${columnRef} ? '${value}')`;
+                            }
+                        }
+                    }
+                    else if (attr2 === '$length') {
+                        // PostgreSQL 使用 jsonb_array_length
+                        const length = o[attr2];
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        let lengthExpr;
+                        if (p) {
+                            const accessor = this.buildJsonAccessor(columnRef, p, false);
+                            lengthExpr = `jsonb_array_length(${accessor})`;
+                        }
+                        else {
+                            lengthExpr = `jsonb_array_length(${columnRef})`;
+                        }
+                        if (typeof length === 'number') {
+                            stmt2 += `(${lengthExpr} = ${length})`;
+                        }
+                        else {
+                            (0, assert_1.default)(typeof length === 'object');
+                            const op = Object.keys(length)[0];
+                            (0, assert_1.default)(op.startsWith('$'));
+                            stmt2 += `(${lengthExpr} ${this.translatePredicate(op, length[op])})`;
+                        }
+                    }
+                    else if (attr2 === '$exists') {
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        const existsValue = o[attr2];
+                        if (typeof existsValue === 'boolean') {
+                            // $exists: true/false - 检查当前路径的值是否存在（不为 null）  
+                            if (p) {
+                                const accessor = this.buildJsonAccessor(columnRef, p, true);
+                                if (existsValue) {
+                                    stmt2 += `(${accessor} IS NOT NULL)`;
+                                }
+                                else {
+                                    stmt2 += `(${accessor} IS NULL)`;
+                                }
+                            }
+                            else {
+                                if (existsValue) {
+                                    stmt2 += `(${columnRef} IS NOT NULL)`;
+                                }
+                                else {
+                                    stmt2 += `(${columnRef} IS NULL)`;
+                                }
+                            }
+                        }
+                        else {
+                            // $exists: 'keyName' - 检查 JSON 对象是否包含指定的键  
+                            const keyToCheck = existsValue;
+                            if (p) {
+                                const accessor = this.buildJsonAccessor(columnRef, p, false);
+                                stmt2 += `(${accessor} ? '${keyToCheck}')`;
+                            }
+                            else {
+                                stmt2 += `(${columnRef} ? '${keyToCheck}')`;
+                            }
+                        }
+                    }
+                    else if (attr2.startsWith('$')) {
+                        // 其他操作符：$gt, $lt, $eq 等
+                        if (stmt2) {
+                            stmt2 += ' AND ';
+                        }
+                        if (p) {
+                            const accessor = this.buildJsonAccessor(columnRef, p, true);
+                            // JSON 提取的文本需要转换类型进行比较
+                            const predicate = this.translatePredicate(attr2, o[attr2]);
+                            if (typeof o[attr2] === 'number') {
+                                stmt2 += `((${accessor})::numeric ${predicate})`;
+                            }
+                            else if (typeof o[attr2] === 'boolean') {
+                                stmt2 += `((${accessor})::boolean ${predicate})`;
+                            }
+                            else {
+                                stmt2 += `(${accessor} ${predicate})`;
+                            }
+                        }
+                        else {
+                            stmt2 += `(${columnRef} ${this.translatePredicate(attr2, o[attr2])})`;
+                        }
+                    }
+                    else {
+                        // 继续子对象解构
+                        const attr3 = attr2.startsWith('.') ? attr2.slice(1) : attr2;
+                        const part = translateInner(o[attr2], p ? `${p}.${attr3}` : `.${attr3}`);
+                        if (part) {
+                            if (stmt2) {
+                                stmt2 += ' AND ';
+                            }
+                            stmt2 += part;
+                        }
+                    }
+                }
+            }
+            else {
+                // 直接的值比较
+                if (stmt2) {
+                    stmt2 += ' AND ';
+                }
+                if (p) {
+                    const accessor = this.buildJsonAccessor(columnRef, p, true);
+                    if (typeof o === 'string') {
+                        stmt2 += `(${accessor} = '${o}')`;
+                    }
+                    else if (typeof o === 'number') {
+                        stmt2 += `((${accessor})::numeric = ${o})`;
+                    }
+                    else if (typeof o === 'boolean') {
+                        stmt2 += `((${accessor})::boolean = ${o})`;
+                    }
+                    else {
+                        stmt2 += `(${accessor} = ${o})`;
+                    }
+                }
+                else {
+                    // 对根对象的比较
+                    if (typeof o === 'string') {
+                        stmt2 += `(${columnRef}::text = '${o}')`;
+                    }
+                    else {
+                        stmt2 += `(${columnRef} = '${JSON.stringify(o)}'::jsonb)`;
+                    }
+                }
+            }
+            return stmt2;
+        };
+        return translateInner(predicate, '');
+    }
+    translateObjectProjection(projection, alias, attr, prefix) {
+        const columnRef = `"${alias}"."${attr}"`;
+        let stmt = '';
+        const translateInner = (o, p) => {
+            if (o instanceof Array) {
+                o.forEach((item, idx) => {
+                    const p2 = `${p}[${idx}]`;
+                    if (typeof item === 'number') {
+                        // 数字表示选择该位置的值
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        const accessor = this.buildJsonAccessor(columnRef, p2, true);
+                        stmt += accessor;
+                        // 生成别名，将路径中的特殊字符替换
+                        stmt += prefix ? ` AS "${prefix}.${attr}${p2}"` : ` AS "${attr}${p2}"`;
+                    }
+                    else if (typeof item === 'object') {
+                        translateInner(item, p2);
+                    }
+                });
+            }
+            else {
+                for (const key in o) {
+                    const p2 = p ? `${p}.${key}` : `.${key}`;
+                    if (typeof o[key] === 'number') {
+                        // 数字表示选择该字段
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        const accessor = this.buildJsonAccessor(columnRef, p2, true);
+                        stmt += accessor;
+                        // 生成别名
+                        stmt += prefix ? ` AS "${prefix}.${attr}${p2}"` : ` AS "${attr}${p2}"`;
+                    }
+                    else {
+                        translateInner(o[key], p2);
+                    }
+                }
+            }
+        };
+        translateInner(projection, '');
+        return stmt;
+    }
+    translateAttrValue(dataType, value) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        switch (dataType) {
+            case 'geometry': {
+                return transformGeoData(value);
+            }
+            case 'datetime':
+            case 'time':
+            case 'date': {
+                if (value instanceof Date) {
+                    return `${value.valueOf()}`;
+                }
+                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':
+            case 'array': {
+                // PostgreSQL JSONB 需要显式类型转换
+                const jsonStr = JSON.stringify(value).replace(/'/g, "''");
+                return `'${jsonStr}'::jsonb`;
+            }
+            /* case 'function': {
+                return `'${Buffer.from(value.toString()).toString('base64')}'`;
+            } */
+            default: {
+                if (typeof value === 'string') {
+                    return this.escapeStringValue(value);
+                }
+                return value;
+            }
+        }
+    }
+    translateFullTextSearch(value, entity, alias) {
+        const { $search, $ts } = value;
+        const { indexes } = this.schema[entity];
+        const ftIndex = indexes && indexes.find((ele) => {
+            const { config } = ele;
+            return config && config.type === 'fulltext';
+        });
+        (0, assert_1.default)(ftIndex, `Entity ${String(entity)} does not have a fulltext index`);
+        const { attributes } = ftIndex;
+        // PostgreSQL 全文搜索使用 to_tsvector 和 to_tsquery
+        // 将多个列合并成一个文档
+        const columns = attributes.map(({ name }) => `COALESCE("${alias}"."${name}", '')`).join(" || ' ' || ");
+        // 处理搜索词：将空格分隔的词转换为 & 连接
+        const searchTerms = $search
+            .trim()
+            .split(/\s+/)
+            .filter(term => term.length > 0)
+            .map(term => this.escapeTsQueryValue(term))
+            .filter(term => term.length > 0) // 过滤掉转义后为空的词
+            .join(' & ');
+        if (!searchTerms) {
+            // 如果没有有效的搜索词，返回一个始终为假的条件，以避免匹配任何记录
+            console.error('Full-text search: no valid search terms after escaping, returning FALSE condition');
+            return 'FALSE';
+        }
+        const indexTsConfig = ftIndex.config?.tsConfig;
+        let searchTsConfig;
+        if (Array.isArray(indexTsConfig)) {
+            // 如果是Array的情况，则需要去判断一下在不在索引定义中，没定义的话要警告
+            if (!$ts) {
+                if (indexTsConfig.length === 0) {
+                    // 没有$ts也没配置索引的情况，和定义的时候一样默认走simple
+                    searchTsConfig = 'simple';
+                }
+                else {
+                    // 如果没提供$ts，则无法确定唯一的索引方法，目前先走索引定义时的第一个
+                    console.warn(`Full-text search: Entity: ${String(entity)} has multi fulltext Index: ${indexTsConfig.join(', ')} please provide a specific "$ts" value! now using: ${indexTsConfig[0]}`);
+                    return `to_tsvector('${indexTsConfig[0]}', ${columns}) @@ to_tsquery('simple', '${searchTerms}')`; // 使用simple去查询，这里就可能不走索引
+                }
+            }
+            else {
+                // 提供了ts，找indexTsConfig中符合$ts的存在
+                const find = indexTsConfig.findIndex(item => item === $ts);
+                if (find === -1) {
+                    // 如果$ts 在indexTsConfig里面没定义，说明大概率查询的时候不会走索引，需要给个警告
+                    console.warn(`Full-text search: provided "$ts" didnt match any tsConfig in the fulltext Index: ${ftIndex.name} on Entity: ${String(entity)}`);
+                }
+                // 提供了就用
+                searchTsConfig = $ts;
+            }
+        }
+        else {
+            searchTsConfig = $ts || indexTsConfig || 'simple'; // 这里的使用顺序是，$ts > indexTsConfig > default('simple')
+        }
+        return `to_tsvector('${searchTsConfig}', ${columns}) @@ to_tsquery('${searchTsConfig}', '${searchTerms}')`;
+    }
+    translateCreateEntity(entity, options) {
+        const ifExists = options?.ifExists || 'drop';
+        const { schema } = this;
+        const entityDef = schema[entity];
+        const { storageName, attributes, indexes, view, static: _static } = entityDef;
+        const tableName = storageName || entity;
+        const sqls = [];
+        // 收集需要创建的 enum 类型
+        const enumTypesToCreate = [];
+        // 处理删除逻辑
+        if (ifExists === 'drop' || (!_static && ifExists === 'dropIfNotStatic')) {
+            // 先删除表
+            sqls.push(`DROP TABLE IF EXISTS "${tableName}" CASCADE;`);
+        }
+        // 预处理：检查所有 enum 类型
+        for (const attr in attributes) {
+            const attrDef = attributes[attr];
+            if (attrDef.type === 'enum' && attrDef.enumeration) {
+                const enumTypeName = this.getEnumTypeName(tableName, attr);
+                enumTypesToCreate.push({
+                    name: enumTypeName,
+                    values: attrDef.enumeration
+                });
+            }
+        }
+        // 删除并重建 enum 类型
+        for (const enumType of enumTypesToCreate) {
+            if (ifExists === 'drop' || (!_static && ifExists === 'dropIfNotStatic')) {
+                sqls.push(`DROP TYPE IF EXISTS "${enumType.name}" CASCADE;`);
+            }
+            const createEnumSql = `CREATE TYPE "${enumType.name}" AS ENUM (${enumType.values.map(v => `'${v}'`).join(', ')});`;
+            if (ifExists === 'omit' || (_static && ifExists === 'dropIfNotStatic')) {
+                sqls.push(`DO $$ BEGIN ${createEnumSql} EXCEPTION WHEN duplicate_object THEN NULL; END $$;`);
+            }
+            else {
+                sqls.push(createEnumSql);
+            }
+        }
+        // todo view 暂还不支持
+        if (view) {
+            throw new Error('view unsupported yet');
+        }
+        // 构建 CREATE TABLE 语句
+        let createTableSql = 'CREATE TABLE ';
+        if (ifExists === 'omit' || (_static && ifExists === 'dropIfNotStatic')) {
+            createTableSql += 'IF NOT EXISTS ';
+        }
+        createTableSql += `"${tableName}" (\n`;
+        // 翻译所有的属性
+        const columnDefs = [];
+        let hasSequence = null;
+        for (const attr in attributes) {
+            const attrDef = attributes[attr];
+            const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
+            let columnDef = `    "${attr}" `;
+            // 处理 enum 类型
+            if (type === 'enum') {
+                const enumTypeName = this.getEnumTypeName(tableName, attr);
+                columnDef += `"${enumTypeName}"`;
+            }
+            else {
+                columnDef += this.populateDataTypeDef(type, params, enumeration);
+            }
+            // NOT NULL 约束
+            if (notNull || type === 'geometry') {
+                columnDef += ' NOT NULL';
+            }
+            // UNIQUE 约束
+            if (unique) {
+                columnDef += ' UNIQUE';
+            }
+            // 序列处理 - PostgreSQL 使用 GENERATED AS IDENTITY
+            if (sequenceStart) {
+                if (hasSequence) {
+                    throw new Error(`「${entity}」只能有一个 sequence 列`);
+                }
+                hasSequence = attr;
+                // 替换类型为支持自增的类型
+                columnDef = `    "${attr}" bigint GENERATED BY DEFAULT AS IDENTITY (START WITH ${sequenceStart}) UNIQUE`;
+            }
+            // 默认值
+            if (defaultValue !== undefined && !sequenceStart) {
+                (0, assert_1.default)(type !== 'ref');
+                columnDef += ` DEFAULT ${this.translateAttrValue(type, defaultValue)}`;
+            }
+            // 主键
+            if (attr === 'id') {
+                columnDef += ' PRIMARY KEY';
+            }
+            columnDefs.push(columnDef);
+        }
+        createTableSql += columnDefs.join(',\n');
+        createTableSql += '\n);';
+        sqls.push(createTableSql);
+        // 单独创建索引 - PostgreSQL 索引必须在表外定义
+        if (indexes) {
+            for (const indexDef of indexes) {
+                const { name, attributes: indexAttrs, config } = indexDef;
+                const { unique, type: indexType, tsConfig } = config || {};
+                // 确定需要创建的索引配置列表
+                const indexConfigs = [];
+                if (indexType === 'fulltext') {
+                    // 全文索引：根据 tsConfig 确定要创建的索引
+                    if (Array.isArray(tsConfig)) {
+                        if (tsConfig.length === 0) {
+                            console.warn(`entity: ${String(entity)} has empty tsConfig array on fulltext index: ${name}, using 'simple' for default.`);
+                            indexConfigs.push({ suffix: '', tsLang: 'simple' });
+                        }
+                        else if (tsConfig.length === 1) {
+                            indexConfigs.push({ suffix: '', tsLang: tsConfig[0] });
+                        }
+                        else {
+                            // 多语言：为每个语言创建独立索引
+                            for (const lang of tsConfig) {
+                                indexConfigs.push({ suffix: `_${lang}`, tsLang: lang });
+                            }
+                        }
+                    }
+                    else {
+                        indexConfigs.push({ suffix: '', tsLang: tsConfig || 'simple' });
+                    }
+                }
+                else {
+                    // 非全文索引：只创建一个索引
+                    indexConfigs.push({ suffix: '' });
+                }
+                // 为每个配置创建索引
+                for (const indexConfig of indexConfigs) {
+                    const { suffix, tsLang } = indexConfig;
+                    let indexSql = 'CREATE ';
+                    if (unique) {
+                        indexSql += 'UNIQUE ';
+                    }
+                    indexSql += 'INDEX ';
+                    if (ifExists === 'omit' || (_static && ifExists === 'dropIfNotStatic')) {
+                        indexSql += 'IF NOT EXISTS ';
+                    }
+                    // 索引名称（多语言时添加后缀）
+                    indexSql += `"${String(entity)}_${name}${suffix}" ON "${tableName}" `;
+                    // 索引方法
+                    if (indexType === 'hash') {
+                        indexSql += 'USING HASH ';
+                    }
+                    else if (indexType === 'spatial') {
+                        indexSql += 'USING GIST ';
+                    }
+                    else if (indexType === 'fulltext') {
+                        indexSql += 'USING GIN ';
+                    }
+                    indexSql += '(';
+                    const indexColumns = [];
+                    for (const indexAttr of indexAttrs) {
+                        const { name: attrName, direction } = indexAttr;
+                        if (indexType === 'fulltext') {
+                            // 全文索引：使用 to_tsvector
+                            indexColumns.push(`to_tsvector('${tsLang}', COALESCE("${attrName}", ''))`);
+                        }
+                        else {
+                            // 普通索引：直接使用列名
+                            let col = `"${attrName}"`;
+                            if (direction) {
+                                col += ` ${direction}`;
+                            }
+                            indexColumns.push(col);
+                        }
+                    }
+                    indexSql += indexColumns.join(', ');
+                    indexSql += ');';
+                    sqls.push(indexSql);
+                }
+            }
+        }
+        return sqls;
+    }
+    translateFnName(fnName, argumentNumber) {
+        switch (fnName) {
+            // ========== 数学运算 ==========
+            case '$add': {
+                let result = '%s';
+                while (--argumentNumber > 0) {
+                    result += ' + %s';
+                }
+                return result;
+            }
+            case '$subtract': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s - %s';
+            }
+            case '$multiply': {
+                let result = '%s';
+                while (--argumentNumber > 0) {
+                    result += ' * %s';
+                }
+                return result;
+            }
+            case '$divide': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s / %s';
+            }
+            case '$abs': {
+                return 'ABS(%s)';
+            }
+            case '$round': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ROUND(%s, %s)';
+            }
+            case '$ceil': {
+                return 'CEIL(%s)';
+            }
+            case '$floor': {
+                return 'FLOOR(%s)';
+            }
+            case '$mod': {
+                // PostgreSQL 使用 MOD 函数或 % 操作符
+                return 'MOD(%s, %s)';
+            }
+            case '$pow': {
+                (0, assert_1.default)(argumentNumber === 2);
+                // PostgreSQL 使用 POWER
+                return 'POWER(%s, %s)';
+            }
+            // ========== 比较运算 ==========
+            case '$gt': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s > %s';
+            }
+            case '$gte': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s >= %s';
+            }
+            case '$lt': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s < %s';
+            }
+            case '$lte': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s <= %s';
+            }
+            case '$eq': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s = %s';
+            }
+            case '$ne': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s <> %s';
+            }
+            // ========== 字符串操作 ==========
+            case '$startsWith': {
+                (0, assert_1.default)(argumentNumber === 2);
+                // PostgreSQL 使用 || 进行字符串连接
+                return '%s LIKE %s || \'%%\'';
+            }
+            case '$endsWith': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s LIKE \'%%\' || %s';
+            }
+            case '$includes': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s LIKE \'%%\' || %s || \'%%\'';
+            }
+            case '$concat': {
+                // PostgreSQL 支持 CONCAT 函数
+                let result = 'CONCAT(%s';
+                while (--argumentNumber > 0) {
+                    result += ', %s';
+                }
+                result += ')';
+                return result;
+            }
+            // ========== 布尔运算 ==========
+            case '$true': {
+                return '( %s ) = TRUE';
+            }
+            case '$false': {
+                return '( %s ) = FALSE';
+            }
+            case '$and': {
+                let result = '';
+                for (let iter = 0; iter < argumentNumber; iter++) {
+                    result += '%s';
+                    if (iter < argumentNumber - 1) {
+                        result += ' AND ';
+                    }
+                }
+                return result;
+            }
+            case '$or': {
+                let result = '';
+                for (let iter = 0; iter < argumentNumber; iter++) {
+                    result += '%s';
+                    if (iter < argumentNumber - 1) {
+                        result += ' OR ';
+                    }
+                }
+                return result;
+            }
+            case '$not': {
+                return 'NOT %s';
+            }
+            // ========== 日期时间函数 ==========
+            case '$year': {
+                return 'EXTRACT(YEAR FROM %s)::integer';
+            }
+            case '$month': {
+                return 'EXTRACT(MONTH FROM %s)::integer';
+            }
+            case '$day': {
+                return 'EXTRACT(DAY FROM %s)::integer';
+            }
+            case '$hour': {
+                return 'EXTRACT(HOUR FROM %s)::integer';
+            }
+            case '$minute': {
+                return 'EXTRACT(MINUTE FROM %s)::integer';
+            }
+            case '$second': {
+                return 'EXTRACT(SECOND FROM %s)::integer';
+            }
+            case '$weekday': {
+                // PostgreSQL ISODOW: 1(周一) - 7(周日)
+                // 转换为 0(周一) - 6(周日) 以兼容 MySQL
+                return '(EXTRACT(ISODOW FROM %s)::integer - 1)';
+            }
+            case '$weekOfYear': {
+                return 'EXTRACT(WEEK FROM %s)::integer';
+            }
+            case '$dayOfMonth': {
+                return 'EXTRACT(DAY FROM %s)::integer';
+            }
+            case '$dayOfWeek': {
+                // PostgreSQL DOW: 0(周日) - 6(周六)
+                // MySQL DAYOFWEEK: 1(周日) - 7(周六)
+                // 转换以兼容 MySQL
+                return '(EXTRACT(DOW FROM %s)::integer + 1)';
+            }
+            case '$dayOfYear': {
+                return 'EXTRACT(DOY FROM %s)::integer';
+            }
+            // 下面两个函数需要特殊处理，放在 translateExpression 里实现
+            // case '$dateDiff': {
+            //     // PostgreSQL 日期差值计算
+            //     // 参数: unit, date1, date2
+            //     // 返回 date1 - date2 的差值
+            //     assert(argumentNumber === 3);
+            //     // 注意：这里需要特殊处理，因为 PostgreSQL 的日期差异计算方式不同
+            //     return 'EXTRACT(EPOCH FROM (%s - %s))::integer / 86400';
+            // }
+            // case '$dateAdd': {
+            //     // 日期加法
+            //     assert(argumentNumber === 3);
+            //     // 参数: date, amount, unit
+            //     return '(%s + INTERVAL \'1 %s\' * %s)';
+            // }
+            case '$dateCeil': {
+                // 日期向上取整 - 参数: [date, unit]
+                // 在 translateExpression 中特殊处理
+                (0, assert_1.default)(argumentNumber === 2);
+                return '__DATE_CEIL__(%s, %s)';
+            }
+            case '$dateFloor': {
+                // 日期向下取整 - 参数: [date, unit]
+                // 在 translateExpression 中特殊处理
+                (0, assert_1.default)(argumentNumber === 2);
+                return '__DATE_FLOOR__(%s, %s)';
+            }
+            // ========== 地理空间函数 (PostGIS) ==========
+            case '$contains': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ST_Contains(%s, %s)';
+            }
+            case '$distance': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ST_Distance(%s, %s)';
+            }
+            case '$within': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ST_Within(%s, %s)';
+            }
+            case '$intersects': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ST_Intersects(%s, %s)';
+            }
+            // ========== 聚合函数 ==========
+            case '$$count': {
+                return 'COUNT(%s)';
+            }
+            case '$$sum': {
+                return 'SUM(%s)';
+            }
+            case '$$max': {
+                return 'MAX(%s)';
+            }
+            case '$$min': {
+                return 'MIN(%s)';
+            }
+            case '$$avg': {
+                return 'AVG(%s)';
+            }
+            default: {
+                throw new Error(`unrecognized function ${fnName}`);
+            }
+        }
+    }
+    translateAttrInExpression(entity, attr, exprText) {
+        const { attributes } = this.schema[entity];
+        const attrDef = attributes[attr];
+        if (!attrDef) {
+            return exprText;
+        }
+        const { type } = attrDef;
+        if (['date', 'time', 'datetime'].includes(type)) {
+            // 从 Unix 时间戳（毫秒）转成 timestamp 类型参加 expr 的运算
+            // PostgreSQL 使用 TO_TIMESTAMP，参数为秒
+            return `TO_TIMESTAMP(${exprText}::double precision / 1000)`;
+        }
+        return exprText;
+    }
+    translateExpression(entity, alias, expression, refDict) {
+        const translateConstant = (constant) => {
+            if (constant instanceof Date) {
+                // PostgreSQL 使用 TO_TIMESTAMP，参数为秒
+                return `TO_TIMESTAMP(${constant.valueOf()}::double precision / 1000)`;
+            }
+            else if (typeof constant === 'string') {
+                // 转义单引号
+                return `'${constant.replace(/'/g, "''")}'`;
+            }
+            else {
+                (0, assert_1.default)(typeof constant === 'number');
+                return `${constant}`;
+            }
+        };
+        const translateInner = (expr) => {
+            const k = Object.keys(expr);
+            let result;
+            if (k.includes('#attr')) {
+                const attrName = (expr)['#attr'];
+                const attrText = `"${alias}"."${attrName}"`;
+                result = this.translateAttrInExpression(entity, attrName, attrText);
+            }
+            else if (k.includes('#refId')) {
+                const refId = (expr)['#refId'];
+                const refAttr = (expr)['#refAttr'];
+                (0, assert_1.default)(refDict[refId]);
+                const [refAlias, refEntity] = refDict[refId];
+                const attrText = `"${refAlias}"."${refAttr}"`;
+                result = this.translateAttrInExpression(refEntity, refAttr, attrText);
+            }
+            else {
+                (0, assert_1.default)(k.length === 1);
+                const fnKey = k[0];
+                const fnArgs = (expr)[fnKey];
+                // 特殊处理日期相关函数
+                if (fnKey === '$dateDiff') {
+                    // $dateDiff: [date1, date2, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 3);
+                    const [date1Expr, date2Expr, unit] = fnArgs;
+                    // 转换日期表达式
+                    const translateDateArg = (arg) => {
+                        if (arg instanceof Date) {
+                            return `TO_TIMESTAMP(${arg.valueOf()}::double precision / 1000)`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `TO_TIMESTAMP(${arg}::double precision / 1000)`;
+                        }
+                        else {
+                            return translateInner(arg);
+                        }
+                    };
+                    const date1Str = translateDateArg(date1Expr);
+                    const date2Str = translateDateArg(date2Expr);
+                    // 根据单位生成不同的 SQL
+                    switch (unit) {
+                        case 's':
+                            result = `EXTRACT(EPOCH FROM (${date1Str} - ${date2Str}))::bigint`;
+                            break;
+                        case 'm':
+                            result = `(EXTRACT(EPOCH FROM (${date1Str} - ${date2Str})) / 60)::bigint`;
+                            break;
+                        case 'h':
+                            result = `(EXTRACT(EPOCH FROM (${date1Str} - ${date2Str})) / 3600)::bigint`;
+                            break;
+                        case 'd':
+                            result = `(EXTRACT(EPOCH FROM (${date1Str} - ${date2Str})) / 86400)::bigint`;
+                            break;
+                        case 'M':
+                            // 月份差异使用 AGE 函数
+                            result = `(EXTRACT(YEAR FROM AGE(${date1Str}, ${date2Str})) * 12 + EXTRACT(MONTH FROM AGE(${date1Str}, ${date2Str})))::bigint`;
+                            break;
+                        case 'y':
+                            result = `EXTRACT(YEAR FROM AGE(${date1Str}, ${date2Str}))::bigint`;
+                            break;
+                        default:
+                            throw new Error(`Unsupported date diff unit: ${unit}`);
+                    }
+                }
+                else if (fnKey === '$dateCeil') {
+                    // $dateCeil: [date, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 2);
+                    const [dateExpr, unit] = fnArgs;
+                    // 获取毫秒时间戳表达式
+                    const getTimestampExpr = (arg) => {
+                        if (arg instanceof Date) {
+                            return `${arg.valueOf()}`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `${arg}`;
+                        }
+                        else {
+                            // 属性引用，直接返回属性（存储本身就是毫秒时间戳）
+                            const k = Object.keys(arg);
+                            if (k.includes('#attr')) {
+                                return `"${alias}"."${arg['#attr']}"`;
+                            }
+                            else if (k.includes('#refId')) {
+                                const refId = arg['#refId'];
+                                const refAttr = arg['#refAttr'];
+                                return `"${refDict[refId][0]}"."${refAttr}"`;
+                            }
+                            // 其他表达式递归处理
+                            return translateInner(arg);
+                        }
+                    };
+                    const tsExpr = getTimestampExpr(dateExpr);
+                    // 固定间隔单位：直接用时间戳数学运算
+                    const msPerUnit = {
+                        's': 1000,
+                        'm': 60000,
+                        'h': 3600000,
+                        'd': 86400000,
+                    };
+                    if (msPerUnit[unit]) {
+                        // CEIL 向上取整：CEIL(timestamp / interval) * interval
+                        result = `CEIL(${tsExpr}::numeric / ${msPerUnit[unit]}) * ${msPerUnit[unit]}`;
+                    }
+                    else {
+                        // 月和年需要用日期函数，但最终转回时间戳
+                        const dateStr = `TO_TIMESTAMP(${tsExpr}::double precision / 1000)`;
+                        const unitMap = {
+                            'M': 'month',
+                            'y': 'year'
+                        };
+                        const pgUnit = unitMap[unit];
+                        if (!pgUnit) {
+                            throw new Error(`Unsupported date ceil unit: ${unit}`);
+                        }
+                        // 向上取整：如果截断后不等于原值，则加一个单位，最后转回毫秒时间戳
+                        result = `(EXTRACT(EPOCH FROM (CASE WHEN DATE_TRUNC('${pgUnit}', ${dateStr}) = ${dateStr} THEN ${dateStr} ELSE DATE_TRUNC('${pgUnit}', ${dateStr}) + INTERVAL '1 ${pgUnit}' END)) * 1000)::bigint`;
+                    }
+                }
+                else if (fnKey === '$dateFloor') {
+                    // $dateFloor: [date, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 2);
+                    const [dateExpr, unit] = fnArgs;
+                    // 获取毫秒时间戳表达式
+                    const getTimestampExpr = (arg) => {
+                        if (arg instanceof Date) {
+                            return `${arg.valueOf()}`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `${arg}`;
+                        }
+                        else {
+                            // 属性引用，直接返回属性（存储本身就是毫秒时间戳）
+                            const k = Object.keys(arg);
+                            if (k.includes('#attr')) {
+                                return `"${alias}"."${arg['#attr']}"`;
+                            }
+                            else if (k.includes('#refId')) {
+                                const refId = arg['#refId'];
+                                const refAttr = arg['#refAttr'];
+                                return `"${refDict[refId][0]}"."${refAttr}"`;
+                            }
+                            // 其他表达式递归处理
+                            return translateInner(arg);
+                        }
+                    };
+                    const tsExpr = getTimestampExpr(dateExpr);
+                    // 固定间隔单位：直接用时间戳数学运算
+                    const msPerUnit = {
+                        's': 1000,
+                        'm': 60000,
+                        'h': 3600000,
+                        'd': 86400000,
+                    };
+                    if (msPerUnit[unit]) {
+                        // FLOOR 向下取整：FLOOR(timestamp / interval) * interval
+                        result = `FLOOR(${tsExpr}::numeric / ${msPerUnit[unit]}) * ${msPerUnit[unit]}`;
+                    }
+                    else {
+                        // 月和年需要用日期函数，但最终转回时间戳
+                        const dateStr = `TO_TIMESTAMP(${tsExpr}::double precision / 1000)`;
+                        const unitMap = {
+                            'M': 'month',
+                            'y': 'year'
+                        };
+                        const pgUnit = unitMap[unit];
+                        if (!pgUnit) {
+                            throw new Error(`Unsupported date floor unit: ${unit}`);
+                        }
+                        // DATE_TRUNC 向下取整，转回毫秒时间戳
+                        result = `(EXTRACT(EPOCH FROM DATE_TRUNC('${pgUnit}', ${dateStr})) * 1000)::bigint`;
+                    }
+                }
+                else if (fnArgs instanceof Array) {
+                    // 原有的数组参数处理逻辑
+                    const fnName = this.translateFnName(fnKey, fnArgs.length);
+                    const args = [fnName];
+                    args.push(...fnArgs.map((ele) => {
+                        if (['string', 'number'].includes(typeof ele) || ele instanceof Date) {
+                            return translateConstant(ele);
+                        }
+                        else {
+                            return translateInner(ele);
+                        }
+                    }));
+                    result = util_1.format.apply(null, args);
+                }
+                else {
+                    // 原有的单参数处理逻辑
+                    const fnName = this.translateFnName(fnKey, 1);
+                    const args = [fnName];
+                    if (['string', 'number'].includes(typeof fnArgs) || fnArgs instanceof Date) {
+                        args.push(translateConstant(fnArgs));
+                    }
+                    else {
+                        args.push(translateInner(fnArgs));
+                    }
+                    result = util_1.format.apply(null, args);
+                }
+            }
+            return result;
+        };
+        return translateInner(expression);
+    }
+    populateSelectStmt(projectionText, fromText, aliasDict, filterText, sorterText, groupByText, indexFrom, count, option) {
+        let sql = `SELECT ${projectionText} FROM ${fromText}`;
+        if (filterText) {
+            sql += ` WHERE ${filterText}`;
+        }
+        if (groupByText) {
+            sql += ` GROUP BY ${groupByText}`;
+        }
+        if (sorterText) {
+            sql += ` ORDER BY ${sorterText}`;
+        }
+        // PostgreSQL 语法: LIMIT count OFFSET offset
+        if (typeof count === 'number') {
+            sql += ` LIMIT ${count}`;
+        }
+        if (typeof indexFrom === 'number' && indexFrom > 0) {
+            sql += ` OFFSET ${indexFrom}`;
+        }
+        // FOR UPDATE 锁定
+        if (option?.forUpdate) {
+            sql += ' FOR UPDATE';
+            if (typeof option.forUpdate === 'string') {
+                // PostgreSQL 支持: NOWAIT, SKIP LOCKED, OF table_name
+                sql += ` ${option.forUpdate}`;
+            }
+        }
+        return sql;
+    }
+    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子句不能使用表别名前缀
+        const setClauses = [];
+        for (const attr in data) {
+            (0, assert_1.default)(attributes.hasOwnProperty(attr));
+            const value = this.translateAttrValue(attributes[attr].type, data[attr]);
+            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}`;
+            }
+        }
+        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}`;
+            }
+        }
+        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];
+        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;
+        }
+        else {
+            // 软删除 - 实际是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));
+                const value = this.translateAttrValue(attributes[attr].type, data[attr]);
+                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);
+        }
+        return conditions.join(' AND ');
+    }
+    /**
+     * 生成 PostgreSQL UPSERT 语句
+     * INSERT ... ON CONFLICT (key) DO UPDATE SET ...
+     */
+    translateUpsert(entity, data, conflictKeys, updateAttrs) {
+        const { schema } = this;
+        const { attributes, storageName = entity } = schema[entity];
+        // 基础 INSERT 语句
+        let sql = this.translateInsert(entity, data);
+        // ON CONFLICT 子句
+        const conflictColumns = conflictKeys.map(k => this.quoteIdentifier(k)).join(', ');
+        sql += ` ON CONFLICT (${conflictColumns})`;
+        // DO UPDATE SET 子句
+        const dataFull = data.reduce((prev, cur) => Object.assign({}, cur, prev), {});
+        const attrsToUpdate = updateAttrs || Object.keys(dataFull).filter(attr => attributes.hasOwnProperty(attr) && !conflictKeys.includes(attr) && attr !== 'id');
+        if (attrsToUpdate.length > 0) {
+            const updateParts = attrsToUpdate.map(attr => `${this.quoteIdentifier(attr)} = EXCLUDED.${this.quoteIdentifier(attr)}`);
+            sql += ` DO UPDATE SET ${updateParts.join(', ')}`;
+        }
+        else {
+            sql += ' DO NOTHING';
+        }
+        return sql;
+    }
+    populateUpdateStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
+        // 这个方法不应该被直接调用了，因为translateUpdate已经重写
+        throw new Error('populateUpdateStmt should not be called directly in PostgreSQL. Use translateUpdate instead.');
+    }
+    populateRemoveStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
+        // 这个方法不应该被直接调用了，因为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;