oak-db 3.3.13 → 4.0.0

package/lib/PostgreSQL/translator.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgreSQLTranslator = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+const crypto_1 = require("crypto");
 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 indexName_1 = require("../utils/indexName");
 const GeoTypes = [
     {
         type: 'point',
@@ -97,10 +98,103 @@ function transformGeoData(data) {
     }
 }
 class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
+    maxIndexNameLength = 63;
+    physicalIndexNameCache;
+    makeIndexNameCacheKey(entityName, tableName, logicalName, suffix = '') {
+        return [entityName, tableName, logicalName, suffix].join('\u0000');
+    }
+    getIndexSuffixes(index) {
+        if (index.config?.type !== 'fulltext' || !Array.isArray(index.config.tsConfig)) {
+            return [''];
+        }
+        if (index.config.tsConfig.length <= 1) {
+            return [''];
+        }
+        return index.config.tsConfig.map((lang) => `_${lang}`);
+    }
+    ensurePhysicalIndexNameCache() {
+        if (this.physicalIndexNameCache) {
+            return this.physicalIndexNameCache;
+        }
+        const entries = [];
+        for (const entityName in this.schema) {
+            const tableName = this.schema[entityName].storageName || entityName;
+            const indexes = this.schema[entityName].indexes || [];
+            for (const index of indexes) {
+                for (const suffix of this.getIndexSuffixes(index)) {
+                    const key = this.makeIndexNameCacheKey(entityName, tableName, index.name, suffix);
+                    entries.push({
+                        key,
+                        baseName: (0, indexName_1.buildCompactPhysicalIndexName)({
+                            entityName,
+                            tableName,
+                            logicalName: index.name,
+                            suffix,
+                            maxLength: this.maxIndexNameLength,
+                        }),
+                    });
+                }
+            }
+        }
+        const grouped = new Map();
+        entries.forEach(({ key, baseName }) => {
+            const bucket = grouped.get(baseName);
+            if (bucket) {
+                bucket.push(key);
+            }
+            else {
+                grouped.set(baseName, [key]);
+            }
+        });
+        const cache = new Map();
+        grouped.forEach((keys, baseName) => {
+            if (keys.length === 1) {
+                cache.set(keys[0], baseName);
+                return;
+            }
+            keys.sort();
+            keys.forEach((key) => {
+                const hash = (0, crypto_1.createHash)('sha1')
+                    .update(key)
+                    .digest('hex')
+                    .slice(0, 8);
+                const prefixLength = Math.max(1, this.maxIndexNameLength - hash.length - 1);
+                cache.set(key, `${baseName.slice(0, prefixLength)}_${hash}`);
+            });
+        });
+        this.physicalIndexNameCache = cache;
+        return cache;
+    }
     // 生成 enum 类型名称
     getEnumTypeName(entity, attr) {
         return `${entity}_${attr}_enum`.toLowerCase();
     }
+    getPhysicalIndexName(entityName, tableName, logicalName, suffix = '') {
+        const key = this.makeIndexNameCacheKey(entityName, tableName, logicalName, suffix);
+        return this.ensurePhysicalIndexNameCache().get(key)
+            || (0, indexName_1.buildCompactPhysicalIndexName)({
+                entityName,
+                tableName,
+                logicalName,
+                suffix,
+                maxLength: this.maxIndexNameLength,
+            });
+    }
+    getLegacyPhysicalIndexNames(entityName, tableName, logicalName, suffix = '') {
+        const names = (0, indexName_1.buildLegacyPhysicalIndexNames)({
+            entityName,
+            tableName,
+            logicalName,
+            suffix,
+            maxLength: this.maxIndexNameLength,
+            serverTruncatesWhenOverflow: true,
+        });
+        const currentName = this.getPhysicalIndexName(entityName, tableName, logicalName, suffix);
+        if (!names.includes(currentName)) {
+            names.push(currentName);
+        }
+        return Array.from(new Set(names));
+    }
     /**
      * 将 MySQL 风格的 JSON 路径转换为 PostgreSQL 路径数组格式
      * 例如: ".foo.bar[0].baz" -> '{foo,bar,0,baz}'
@@ -955,7 +1049,7 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                         indexSql += 'IF NOT EXISTS ';
                     }
                     // 索引名称（多语言时添加后缀）
-                    indexSql += `"${String(entity)}_${name}${suffix}" ON "${tableName}" `;
+                    indexSql += `"${this.getPhysicalIndexName(String(entity), tableName, name, suffix)}" ON "${tableName}" `;
                     // 索引方法
                     if (indexType === 'hash') {
                         indexSql += 'USING HASH ';
@@ -1470,23 +1564,16 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
         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子句不能使用表别名前缀
+        // 参数验证
+        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));
@@ -1494,73 +1581,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}"`);
+        }
+        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);
         }
-        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}`;
-            }
+    }
+    /**
+     * 添加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));
@@ -1568,164 +1675,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,
-            });
+            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause} WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
         }
-        // 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 ');
+        // 添加 RETURNING 子句
+        return this.appendReturningClause(sql, entity, mainAlias, option);
     }
     /**
      * 生成 PostgreSQL UPSERT 语句
@@ -2138,6 +2091,35 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
         }
         return sql;
     }
+    translateColumnDefinition(entity, attr, attrDef) {
+        let sql = `"${attr}" `;
+        const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
+        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 += `"${this.getEnumTypeName(entity, attr)}"`;
+        }
+        else {
+            sql += this.populateDataTypeDef(type, params, enumeration);
+        }
+        if (notNull || type === 'geometry') {
+            sql += ' NOT NULL';
+        }
+        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）
      * 忽略空格、大小写等格式差异

package/lib/index.d.ts

@@ -2,3 +2,4 @@ export * from './MySQL/store';
 export { MySqlSelectOption, MysqlOperateOption } from './MySQL/translator';
 export * from './PostgreSQL/store';
 export { PostgreSQLSelectOption, PostgreSQLOperateOption } from './PostgreSQL/translator';
+export type { MigrationPlan, MigrationPlanningOptions, MigrationWarning, RenameCandidate, SchemaInspectionResult, TableStats, Plan, } from './types/migration';

package/lib/migration.d.ts

@@ -0,0 +1,27 @@
+import { Attribute } from 'oak-domain/lib/types';
+import { AttributeChangeClassification, AttributeSnapshot, MigrationEntityDict, MigrationIndexWithOrigin, MigrationSchema, MigrationPlanningOptions, IndexSnapshot, MigrationPlan, SchemaMigrationAdapter } from './types/migration';
+export declare function normalizeAttribute(attr: Attribute, options?: {
+    schema?: MigrationSchema;
+    column?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): AttributeSnapshot;
+export declare function normalizeIndex(index: MigrationIndexWithOrigin): IndexSnapshot;
+export declare function areAttributesEquivalent(oldAttr: Attribute, newAttr: Attribute, options?: {
+    oldSchema?: MigrationSchema;
+    newSchema?: MigrationSchema;
+    column?: string;
+    oldColumn?: string;
+    newColumn?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): boolean;
+export declare function areIndexesEquivalent(oldIndex: MigrationIndexWithOrigin, newIndex: MigrationIndexWithOrigin): boolean;
+export declare function classifyAttributeChange(oldAttr?: Attribute, newAttr?: Attribute, options?: {
+    oldSchema?: MigrationSchema;
+    newSchema?: MigrationSchema;
+    column?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): AttributeChangeClassification;
+export declare function buildMigrationPlan<ED extends MigrationEntityDict>(currentSchema: MigrationSchema<ED>, targetSchema: MigrationSchema<ED>, adapter: SchemaMigrationAdapter<ED>, options?: MigrationPlanningOptions): MigrationPlan<ED>;