oak-db 3.3.13 → 3.3.14

package/lib/MySQL/connector.js

@@ -20,27 +20,22 @@ class MySqlConnector {
         return this.pool.end();
     }
     async startTransaction(option) {
-        // 防止用户配置connection可复用
-        const startInner = async () => {
-            const connection = await this.pool.getConnection();
-            // 分配出来的connection不能被别的事务占据
-            for (const txn2 in this.txnDict) {
-                if (this.txnDict[txn2] === connection) {
-                    return new Promise((resolve) => {
-                        this.pool.on('release', () => resolve(startInner()));
-                    });
-                }
-            }
+        const connection = await this.pool.getConnection();
+        const id = (0, uuid_1.v4)();
+        try {
             await connection.beginTransaction();
-            const id = (0, uuid_1.v4)();
             // console.log('start_txn', id, connection.threadId);
             this.txnDict[id] = connection;
             if (option?.isolationLevel) {
                 await connection.query(`SET TRANSACTION ISOLATION LEVEL ${option.isolationLevel};`);
             }
             return id;
-        };
-        return startInner();
+        }
+        catch (err) { // 出错时释放连接
+            connection.release();
+            delete this.txnDict[id];
+            throw err;
+        }
     }
     async exec(sql, txn) {
         if (process.env.NODE_ENV === 'development') {

package/lib/MySQL/store.d.ts

@@ -22,9 +22,12 @@ export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt exte
     aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
     protected supportManyToOneJoin(): boolean;
     protected supportMultipleCreate(): boolean;
+    protected supportUpdateReturning(): boolean;
     private formResult;
     protected selectAbjointRowAsync<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: AsyncContext<ED>, option?: MySqlSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected updateAbjointRowReturningSync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, returning: Record<string, any>, option?: MysqlOperateOption): [number, Partial<ED[T]['Schema']>[]];
     protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: MysqlOperateOption): Promise<number>;
+    protected updateAbjointRowReturningAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, returning?: Record<string, any>, option?: MysqlOperateOption): Promise<[number, Partial<ED[T]['Schema']>[]]>;
     operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OperateOption): Promise<OperationResult<ED>>;
     select<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: SelectOption): Promise<Partial<ED[T]['Schema']>[]>;
     protected countAbjointRowAsync<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: AsyncContext<ED>, option: SelectOption): Promise<number>;

package/lib/MySQL/store.js

@@ -61,6 +61,9 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
     supportMultipleCreate() {
         return true;
     }
+    supportUpdateReturning() {
+        return false;
+    }
     formResult(entity, result) {
         const schema = this.getSchema();
         /*  function resolveObject(r: Record<string, any>, path: string, value: any) {
@@ -236,6 +239,9 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
         const result = await this.connector.exec(sql, context.getCurrentTxnId());
         return this.formResult(entity, result[0]);
     }
+    updateAbjointRowReturningSync(entity, operation, context, returning, option) {
+        throw new Error('Mysql store 不支持同步更新数据');
+    }
     async updateAbjointRowAsync(entity, operation, context, option) {
         const { translator, connector } = this;
         const { action } = operation;
@@ -251,7 +257,7 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
                 const sql = translator.translateRemove(entity, operation, option);
                 const result = await connector.exec(sql, txn);
                 // todo 这里对sorter和indexfrom/count的支持不完整
-                return result[0].changedRows;
+                return result[0].affectedRows;
             }
             default: {
                 (0, assert_1.default)(!['select', 'download', 'stat'].includes(action));
@@ -262,6 +268,9 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
             }
         }
     }
+    async updateAbjointRowReturningAsync(entity, operation, context, returning, option) {
+        throw new Error('MySQL store不支持返回更新数据');
+    }
     async operate(entity, operation, context, option) {
         const { action } = operation;
         (0, assert_1.default)(!['select', 'download', 'stat'].includes(action), '现在不支持使用select operation');

package/lib/MySQL/translator.js

@@ -1069,9 +1069,12 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         if (sorterText) {
             sql += ` order by ${sorterText}`;
         }
-        if (typeof indexFrom === 'number') {
-            (0, assert_1.default)(typeof count === 'number');
-            sql += ` limit ${indexFrom}, ${count}`;
+        if (typeof count === 'number') {
+            // MySQL UPDATE 不支持 LIMIT offset, count 语法
+            if (typeof indexFrom === 'number' && indexFrom > 0) {
+                throw new Error('MySQL does not support LIMIT with OFFSET in UPDATE statements. Use indexFrom=0 or omit indexFrom.');
+            }
+            sql += ` limit ${count}`;
         }
         return sql;
     }
@@ -1087,9 +1090,12 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
             if (sorterText) {
                 sql += ` order by ${sorterText}`;
             }
-            if (typeof indexFrom === 'number') {
-                (0, assert_1.default)(typeof count === 'number');
-                sql += ` limit ${indexFrom}, ${count}`;
+            if (typeof count === 'number') {
+                // MySQL DELETE 不支持 LIMIT offset, count 语法
+                if (typeof indexFrom === 'number' && indexFrom > 0) {
+                    throw new Error('MySQL does not support LIMIT with OFFSET in DELETE statements. Use indexFrom=0 or omit indexFrom.');
+                }
+                sql += ` limit ${count}`;
             }
             return sql;
         }
@@ -1105,9 +1111,12 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         if (sorterText) {
             sql += ` order by ${sorterText}`;
         }
-        if (typeof indexFrom === 'number') {
-            (0, assert_1.default)(typeof count === 'number');
-            sql += ` limit ${indexFrom}, ${count}`;
+        if (typeof count === 'number') {
+            // MySQL UPDATE 不支持 LIMIT offset, count 语法（软删除使用UPDATE）
+            if (typeof indexFrom === 'number' && indexFrom > 0) {
+                throw new Error('MySQL does not support LIMIT with OFFSET in UPDATE statements (soft delete). Use indexFrom=0 or omit indexFrom.');
+            }
+            sql += ` limit ${count}`;
         }
         return sql;
     }

package/lib/PostgreSQL/connector.js

@@ -36,37 +36,27 @@ class PostgreSQLConnector {
         await this.pool.end();
     }
     async startTransaction(option) {
-        const startInner = async () => {
-            const connection = await this.pool.connect();
-            // 添加：检测连接是否已被其他事务占用
-            for (const txn2 in this.txnDict) {
-                if (this.txnDict[txn2] === connection) {
-                    return new Promise((resolve) => {
-                        this.pool.on('release', () => resolve(startInner()));
-                    });
-                }
-            }
-            try {
-                let beginStmt = 'BEGIN';
-                if (option?.isolationLevel) {
-                    // PostgreSQL 隔离级别: 
-                    // READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE
-                    // 注意: PostgreSQL 的 READ UNCOMMITTED 行为等同于 READ COMMITTED
-                    const level = this.mapIsolationLevel(option.isolationLevel);
-                    beginStmt = `BEGIN ISOLATION LEVEL ${level}`;
-                }
-                await connection.query(beginStmt);
-                const id = (0, uuid_1.v4)();
-                this.txnDict[id] = connection;
-                return id;
-            }
-            catch (error) {
-                // 如果启动事务失败，释放连接
-                connection.release();
-                throw error;
+        const connection = await this.pool.connect();
+        const id = (0, uuid_1.v4)();
+        try {
+            let beginStmt = 'BEGIN';
+            if (option?.isolationLevel) {
+                // PostgreSQL 隔离级别: 
+                // READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE
+                // 注意: PostgreSQL 的 READ UNCOMMITTED 行为等同于 READ COMMITTED
+                const level = this.mapIsolationLevel(option.isolationLevel);
+                beginStmt = `BEGIN ISOLATION LEVEL ${level}`;
             }
-        };
-        return startInner();
+            await connection.query(beginStmt);
+            this.txnDict[id] = connection;
+            return id;
+        }
+        catch (error) {
+            // 如果启动事务失败，释放连接
+            connection.release();
+            delete this.txnDict[id];
+            throw error;
+        }
     }
     /**
      * 映射隔离级别到 PostgreSQL 语法
@@ -90,26 +80,17 @@ class PostgreSQLConnector {
         if (process.env.NODE_ENV === 'development') {
             // console.log(`SQL: ${sql}; \n`);
         }
-        try {
-            let result;
-            if (txn) {
-                const connection = this.txnDict[txn];
-                (0, assert_1.default)(connection, `Transaction ${txn} not found`);
-                result = await connection.query(sql);
-            }
-            else {
-                result = await this.pool.query(sql);
-            }
-            // 返回格式与 mysql2 兼容: [rows, fields/result]
-            return [result.rows, result];
+        let result;
+        if (txn) {
+            const connection = this.txnDict[txn];
+            (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+            result = await connection.query(sql);
         }
-        catch (error) {
-            // 增强错误信息
-            const enhancedError = new Error(`PostgreSQL query failed: ${error.message}\nSQL: ${sql.slice(0, 500)}${sql.length > 500 ? '...' : ''}`);
-            enhancedError.originalError = error;
-            enhancedError.sql = sql;
-            throw enhancedError;
+        else {
+            result = await this.pool.query(sql);
         }
+        // 返回格式与 mysql2 兼容: [rows, fields/result]
+        return [result.rows, result];
     }
     async commitTransaction(txn) {
         const connection = this.txnDict[txn];

package/lib/PostgreSQL/store.d.ts

@@ -22,9 +22,12 @@ export declare class PostgreSQLStore<ED extends EntityDict & BaseEntityDict, Cxt
     aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
     protected supportManyToOneJoin(): boolean;
     protected supportMultipleCreate(): boolean;
+    protected supportUpdateReturning(): boolean;
     private formResult;
     protected selectAbjointRowAsync<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: AsyncContext<ED>, option?: PostgreSQLSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
     protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: PostgreSQLOperateOption): Promise<number>;
+    protected updateAbjointRowReturningSync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, returning: Record<string, any>, option?: PostgreSQLOperateOption): [number, Partial<ED[T]['Schema']>[]];
+    protected updateAbjointRowReturningAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, returning: Record<string, any>, option?: PostgreSQLOperateOption): Promise<[number, Partial<ED[T]['Schema']>[]]>;
     operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OperateOption): Promise<OperationResult<ED>>;
     select<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: SelectOption): Promise<Partial<ED[T]['Schema']>[]>;
     protected countAbjointRowAsync<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: AsyncContext<ED>, option: SelectOption): Promise<number>;

package/lib/PostgreSQL/store.js

@@ -94,6 +94,9 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
     supportMultipleCreate() {
         return true;
     }
+    supportUpdateReturning() {
+        return true;
+    }
     formResult(entity, result) {
         const schema = this.getSchema();
         function resolveAttribute(entity2, r, attr, value) {
@@ -302,6 +305,33 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
             }
         }
     }
+    updateAbjointRowReturningSync(entity, operation, context, returning, option) {
+        throw new Error('PostgreSQL store 不支持同步更新数据');
+    }
+    async updateAbjointRowReturningAsync(entity, operation, context, returning, option) {
+        const { translator, connector } = this;
+        const { action } = operation;
+        const txn = context.getCurrentTxnId();
+        switch (action) {
+            case 'create': {
+                const { data } = operation;
+                const sql = translator.translateInsert(entity, data instanceof Array ? data : [data]);
+                const result = await connector.exec(sql, txn);
+                return [result[1].rowCount || 0, []];
+            }
+            case 'remove': {
+                const sql = translator.translateRemove(entity, operation, Object.assign({}, option, { returning }));
+                const result = await connector.exec(sql, txn);
+                return [result[1].rowCount || 0, this.formResult(entity, result[0])];
+            }
+            default: {
+                (0, assert_1.default)(!['select', 'download', 'stat'].includes(action));
+                const sql = translator.translateUpdate(entity, operation, Object.assign({}, option, { returning }));
+                const result = await connector.exec(sql, txn);
+                return [result[1].rowCount || 0, this.formResult(entity, result[0])];
+            }
+        }
+    }
     async operate(entity, operation, context, option) {
         const { action } = operation;
         (0, assert_1.default)(!['select', 'download', 'stat'].includes(action), '不支持使用 select operation');
@@ -336,50 +366,62 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
         await this.connector.disconnect();
     }
     async initialize(option) {
-        // PG的DDL支持事务，所以这里直接用一个事务包裹所有的初始化操作
+        const schema = this.getSchema();
+        // ===== 第一阶段：事务外创建扩展 =====
+        let hasGeoType = false;
+        let hasChineseTsConfig = false;
+        let chineseParser = null;
+        // 扫描 schema
+        for (const entity in schema) {
+            const { attributes, indexes } = schema[entity];
+            for (const attr in attributes) {
+                if (attributes[attr].type === 'geometry') {
+                    hasGeoType = true;
+                }
+            }
+            for (const index of indexes || []) {
+                if (index.config?.tsConfig === 'chinese' || index.config?.tsConfig?.includes('chinese')) {
+                    hasChineseTsConfig = true;
+                }
+                if (index.config?.chineseParser) {
+                    (0, assert_1.default)(!chineseParser || chineseParser === index.config.chineseParser, '当前定义了多个中文分词器，请保持一致');
+                    chineseParser = index.config.chineseParser;
+                }
+            }
+        }
+        // 在事务外创建扩展
+        if (hasGeoType) {
+            console.log('Initializing PostGIS extension for geometry support...');
+            await this.connector.exec('CREATE EXTENSION IF NOT EXISTS postgis;');
+        }
+        if (hasChineseTsConfig) {
+            console.log('Initializing Chinese parser extension...');
+            await this.connector.exec(`CREATE EXTENSION IF NOT EXISTS ${chineseParser || 'zhparser'};`);
+        }
+        // ===== 第二阶段：事务内创建配置和表 =====
         const txn = await this.connector.startTransaction({
             isolationLevel: 'serializable',
         });
         try {
-            const schema = this.getSchema();
-            let hasGeoType = false;
-            let hasChineseTsConfig = false;
-            for (const entity in schema) {
-                const { attributes, indexes } = schema[entity];
-                for (const attr in attributes) {
-                    const { type } = attributes[attr];
-                    if (type === 'geometry') {
-                        hasGeoType = true;
-                    }
-                }
-                for (const index of indexes || []) {
-                    if (index.config?.tsConfig === 'chinese' || index.config?.tsConfig?.includes('chinese')) {
-                        hasChineseTsConfig = true;
-                    }
-                }
-            }
-            if (hasGeoType) {
-                console.log('Initializing PostGIS extension for geometry support...');
-                await this.connector.exec('CREATE EXTENSION IF NOT EXISTS postgis;');
-            }
+            // 创建中文文本搜索配置
             if (hasChineseTsConfig) {
                 console.log('Initializing Chinese text search configuration...');
                 const checkChineseConfigSql = `
-            SELECT COUNT(*) as cnt
-            FROM pg_catalog.pg_ts_config
-            WHERE cfgname = 'chinese';
+                SELECT COUNT(*) as cnt
+                FROM pg_catalog.pg_ts_config
+                WHERE cfgname = 'chinese';
             `;
-                const result = await this.connector.exec(checkChineseConfigSql);
+                const result = await this.connector.exec(checkChineseConfigSql, txn);
                 const count = parseInt(result[0][0]?.cnt || '0', 10);
                 if (count === 0) {
                     const createChineseConfigSql = `
-                CREATE EXTENSION IF NOT EXISTS zhparser;
-                CREATE TEXT SEARCH CONFIGURATION chinese (PARSER = zhparser);
-                ALTER TEXT SEARCH CONFIGURATION chinese ADD MAPPING FOR n,v,a,i,e,l WITH simple;
+                    CREATE TEXT SEARCH CONFIGURATION chinese (PARSER = ${chineseParser || 'zhparser'});
+                    ALTER TEXT SEARCH CONFIGURATION chinese ADD MAPPING FOR n,v,a,i,e,l WITH simple;
                 `;
-                    await this.connector.exec(createChineseConfigSql);
+                    await this.connector.exec(createChineseConfigSql, txn);
                 }
             }
+            // 创建实体表
             for (const entity in schema) {
                 const sqls = this.translator.translateCreateEntity(entity, option);
                 for (const sql of sqls) {

package/lib/PostgreSQL/translator.d.ts

@@ -6,6 +6,12 @@ import { CreateEntityOption } from '../types/Translator';
 export interface PostgreSQLSelectOption extends SqlSelectOption {
 }
 export interface PostgreSQLOperateOption extends SqlOperateOption {
+    /**
+     * PostgreSQL RETURNING 子句的投影
+     * 仅在 update/remove 时有效
+     * 返回受影响的行
+     */
+    returning?: Record<string, any>;
 }
 export declare class PostgreSQLTranslator<ED extends EntityDict & BaseEntityDict> extends SqlTranslator<ED> {
     private getEnumTypeName;
@@ -63,16 +69,22 @@ export declare class PostgreSQLTranslator<ED extends EntityDict & BaseEntityDict
     protected translateExpression<T extends keyof ED>(entity: T, alias: string, expression: RefOrExpression<keyof ED[T]["OpSchema"]>, refDict: Record<string, [string, keyof ED]>): string;
     protected populateSelectStmt<T extends keyof ED>(projectionText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, groupByText?: string, indexFrom?: number, count?: number, option?: PostgreSQLSelectOption): string;
     translateUpdate<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Update'], option?: OP): string;
-    translateRemove<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Remove'], option?: OP): string;
     /**
-     * PostgreSQL专用的结构化JOIN分析
-     * 返回结构化的JOIN信息，而不是拼接好的FROM字符串
+     * 将 projection 转换为 RETURNING 子句的列列表
+     * @param entity 实体名
+     * @param alias 表别名
+     * @param projection 投影定义
      */
-    private analyzeJoinStructured;
+    private buildReturningClause;
     /**
-     * 构建JOIN条件（用于UPDATE/DELETE的WHERE子句）
+     * 验证操作参数的合法性
      */
-    private buildJoinConditions;
+    private validateOperationParams;
+    /**
+     * 添加RETURNING子句
+     */
+    private appendReturningClause;
+    translateRemove<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Remove'], option?: OP): string;
     /**
      * 生成 PostgreSQL UPSERT 语句
      * INSERT ... ON CONFLICT (key) DO UPDATE SET ...

package/lib/PostgreSQL/translator.js

@@ -7,7 +7,6 @@ const util_1 = require("util");
 const lodash_1 = require("lodash");
 const types_1 = require("oak-domain/lib/types");
 const sqlTranslator_1 = require("../sqlTranslator");
-const relation_1 = require("oak-domain/lib/store/relation");
 const GeoTypes = [
     {
         type: 'point',
@@ -1483,10 +1482,11 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
     translateUpdate(entity, operation, option) {
         const { attributes } = this.schema[entity];
         const { filter, sorter, indexFrom, count, data } = operation;
-        (0, assert_1.default)(!sorter, '当前update不支持sorter行为');
-        // 使用结构化的JOIN分析
-        const { aliasDict, filterRefAlias, mainTable, mainAlias, joinInfos, currentNumber } = this.analyzeJoinStructured(entity, { filter, sorter });
-        // 构建SET子句 - PostgreSQL中SET子句不能使用表别名前缀
+        // 参数验证
+        this.validateOperationParams(sorter, indexFrom, count);
+        const mainTable = this.getStorageName(entity);
+        const mainAlias = `${entity}_1`;
+        // 构建 SET 子句
         const setClauses = [];
         for (const attr in data) {
             (0, assert_1.default)(attributes.hasOwnProperty(attr));
@@ -1494,73 +1494,93 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
             setClauses.push(`"${attr}" = ${value}`);
         }
         const setClause = setClauses.join(', ');
-        // 构建过滤条件
-        const { stmt: filterText } = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, option);
-        let sql;
-        if (joinInfos.length === 0) {
-            // 单表更新
-            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-            if (filterText) {
-                sql += ` WHERE ${filterText}`;
-            }
+        // 统一使用子查询方案
+        const subqueryOperation = {
+            data: { [types_1.PrimaryKeyAttribute]: 1 },
+            filter: filter,
+            indexFrom: indexFrom,
+            count: count
+        };
+        const subquery = this.translateSelect(entity, subqueryOperation, { includedDeleted: option?.includedDeleted });
+        let sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause} WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
+        // 添加 RETURNING 子句
+        return this.appendReturningClause(sql, entity, mainAlias, option);
+    }
+    /**
+     * 将 projection 转换为 RETURNING 子句的列列表
+     * @param entity 实体名
+     * @param alias 表别名
+     * @param projection 投影定义
+     */
+    buildReturningClause(entity, alias, projection) {
+        const columns = [];
+        const { attributes } = this.schema[entity];
+        for (const attr in projection) {
+            // if (!attributes[attr]) {
+            //     // 如果存在entity这个attr
+            //     const entityDesc = attributes['entity']
+            //     const entityIdDesc = attributes['entityId']
+            //     if (entityDesc && entityIdDesc && ((entityDesc.ref as string[])?.includes(attr))) {
+            //         // 特殊处理 entity 和 entityId 属性
+            //     }
+            //     continue;
+            // }
+            // 只能返回更新列的相关字段，所以直接assert
+            (0, assert_1.default)(attributes.hasOwnProperty(attr), `RETURNING语法只能返回更新列的字段，但在实体 ${String(entity)} 中未找到原生属性「${attr}」的定义`);
+            const dataType = attributes[attr].type;
+            // 处理特殊类型的投影
+            const columnExpr = this.translateAttrProjection(dataType, alias, attr);
+            // RETURNING 需要明确的别名（不带表前缀）
+            columns.push(`${columnExpr} AS "${attr}"`);
+        }
+        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 +1588,10 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                 setClauses.push(`"${attr}" = ${value}`);
             }
             const setClause = setClauses.join(', ');
-            let sql;
-            if (joinInfos.length === 0) {
-                // 单表更新
-                sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-                if (filterText) {
-                    sql += ` WHERE ${filterText}`;
-                }
-            }
-            else {
-                // 多表更新
-                sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause}`;
-                const fromTables = joinInfos.map(j => `"${j.table}" AS "${j.alias}"`).join(', ');
-                sql += ` FROM ${fromTables}`;
-                const joinConditions = this.buildJoinConditions(joinInfos);
-                let whereClause = joinConditions;
-                if (filterText) {
-                    whereClause = whereClause ? `${whereClause} AND ${filterText}` : filterText;
-                }
-                if (whereClause) {
-                    sql += ` WHERE ${whereClause}`;
-                }
-            }
-            return sql;
-        }
-    }
-    /**
-     * PostgreSQL专用的结构化JOIN分析
-     * 返回结构化的JOIN信息，而不是拼接好的FROM字符串
-     */
-    analyzeJoinStructured(entity, { filter, sorter }, initialNumber) {
-        const { schema } = this;
-        let number = initialNumber || 1;
-        const filterRefAlias = {};
-        const mainAlias = `${entity}_${number++}`;
-        const mainTable = this.getStorageName(entity);
-        const aliasDict = {
-            './': mainAlias,
-        };
-        const joinInfos = [];
-        const analyzeFilterNode = ({ node, path, entityName, alias }) => {
-            Object.keys(node).forEach((op) => {
-                if (['$and', '$or'].includes(op)) {
-                    node[op].forEach((subNode) => analyzeFilterNode({
-                        node: subNode,
-                        path,
-                        entityName,
-                        alias,
-                    }));
-                }
-                else if (['$not'].includes(op)) {
-                    analyzeFilterNode({
-                        node: node[op],
-                        path,
-                        entityName,
-                        alias,
-                    });
-                }
-                else if (['$text'].includes(op)) {
-                    // 全文搜索，不需要JOIN
-                }
-                else {
-                    const rel = (0, relation_1.judgeRelation)(this.schema, entityName, op);
-                    if (typeof rel === 'string') {
-                        const pathAttr = `${path}${op}/`;
-                        if (!aliasDict.hasOwnProperty(pathAttr)) {
-                            const alias2 = `${rel}_${number++}`;
-                            aliasDict[pathAttr] = alias2;
-                            joinInfos.push({
-                                table: this.getStorageName(rel),
-                                alias: alias2,
-                                leftAlias: alias,
-                                leftKey: op + 'Id',
-                                rightKey: 'id',
-                            });
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: rel,
-                                alias: alias2,
-                            });
-                        }
-                        else {
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: rel,
-                                alias: aliasDict[pathAttr],
-                            });
-                        }
-                    }
-                    else if (rel === 2) {
-                        const pathAttr = `${path}${op}/`;
-                        if (!aliasDict.hasOwnProperty(pathAttr)) {
-                            const alias2 = `${op}_${number++}`;
-                            aliasDict[pathAttr] = alias2;
-                            joinInfos.push({
-                                table: this.getStorageName(op),
-                                alias: alias2,
-                                leftAlias: alias,
-                                leftKey: 'entityId',
-                                rightKey: 'id',
-                                extraCondition: `"${alias}"."entity" = '${op}'`,
-                            });
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: op,
-                                alias: alias2,
-                            });
-                        }
-                        else {
-                            analyzeFilterNode({
-                                node: node[op],
-                                path: pathAttr,
-                                entityName: op,
-                                alias: aliasDict[pathAttr],
-                            });
-                        }
-                    }
-                }
-            });
-            if (node['#id']) {
-                (0, assert_1.default)(!filterRefAlias[node['#id']]);
-                filterRefAlias[node['#id']] = [alias, entityName];
-            }
-        };
-        if (filter) {
-            analyzeFilterNode({
-                node: filter,
-                path: './',
-                entityName: entity,
-                alias: mainAlias,
-            });
-        }
-        // TODO: sorter的分析类似，这里省略（UPDATE/DELETE通常不需要sorter）
-        (0, assert_1.default)(!sorter, '当前analyzeJoinStructured不支持sorter行为');
-        return {
-            aliasDict,
-            filterRefAlias,
-            mainTable,
-            mainAlias,
-            joinInfos,
-            currentNumber: number,
-        };
-    }
-    /**
-     * 构建JOIN条件（用于UPDATE/DELETE的WHERE子句）
-     */
-    buildJoinConditions(joinInfos) {
-        const conditions = [];
-        for (const join of joinInfos) {
-            let condition = `"${join.leftAlias}"."${join.leftKey}" = "${join.alias}"."${join.rightKey}"`;
-            if (join.extraCondition) {
-                condition = `(${condition} AND ${join.extraCondition})`;
-            }
-            conditions.push(condition);
+            sql = `UPDATE "${mainTable}" AS "${mainAlias}" SET ${setClause} WHERE "${types_1.PrimaryKeyAttribute}" IN (${subquery})`;
         }
-        return conditions.join(' AND ');
+        // 添加 RETURNING 子句
+        return this.appendReturningClause(sql, entity, mainAlias, option);
     }
     /**
      * 生成 PostgreSQL UPSERT 语句

package/lib/sqlTranslator.d.ts

@@ -53,7 +53,11 @@ export declare abstract class SqlTranslator<ED extends EntityDict & BaseEntityDi
     };
     private translateSorter;
     private translateProjection;
-    private translateSelectInner;
+    protected translateSelectInner<T extends keyof ED, OP extends SqlSelectOption>(entity: T, selection: ED[T]['Selection'], initialNumber: number, refAlias: Record<string, [string, keyof ED]>, option?: OP): {
+        filterStmt: string;
+        stmt: string;
+        currentNumber: number;
+    };
     translateSelect<T extends keyof ED, OP extends SqlSelectOption>(entity: T, selection: ED[T]['Selection'], option?: OP): string;
     translateWhere<T extends keyof ED, OP extends SqlSelectOption>(entity: T, selection: ED[T]['Selection'], option?: OP): string;
     translateAggregate<T extends keyof ED, OP extends SqlSelectOption>(entity: T, aggregation: ED[T]['Aggregation'], option?: OP): string;

package/lib/sqlTranslator.js

@@ -564,10 +564,10 @@ class SqlTranslator {
     translateFilter(entity, filter, aliasDict, filterRefAlias, initialNumber, option) {
         const { schema } = this;
         let currentNumber = initialNumber;
-        const translateInner = (entity2, path, filter2, type) => {
+        const translateInner = (entity2, path, filter2, skipDeletePhy) => {
             const alias = aliasDict[path];
             const { attributes } = schema[entity2];
-            let whereText = type ? '' : this.getDefaultSelectFilter(alias, option);
+            let whereText = skipDeletePhy ? '' : this.getDefaultSelectFilter(alias, option);
             if (filter2) {
                 const attrs = Object.keys(filter2).filter(ele => !ele.startsWith('#'));
                 attrs.forEach((attr) => {
@@ -582,7 +582,7 @@ class SqlTranslator {
                             case '$xor': {
                                 const logicQueries = filter2[attr];
                                 logicQueries.forEach((logicQuery, index) => {
-                                    const sql = translateInner(entity2, path, logicQuery, 'ref'); // 只要传个值就行了，应该无所谓
+                                    const sql = translateInner(entity2, path, logicQuery, true); // 只要传个值就行了，应该无所谓
                                     if (sql) {
                                         whereText += ` (${sql})`;
                                         if (index < logicQueries.length - 1) {
@@ -595,7 +595,7 @@ class SqlTranslator {
                             default: {
                                 (0, assert_1.default)(attr === '$not');
                                 const logicQuery = filter2[attr];
-                                const sql = translateInner(entity2, path, logicQuery, 'ref'); // 只要传个值就行了，应该无所谓
+                                const sql = translateInner(entity2, path, logicQuery, true); // 只要传个值就行了，应该无所谓
                                 if (sql) {
                                     whereText += ` not (${sql})`;
                                     break;
@@ -965,6 +965,10 @@ class SqlTranslator {
         const { data, filter, sorter, indexFrom, count } = operation;
         (0, assert_1.default)(!sorter, '当前remove不支持sorter行为');
         const { aliasDict, filterRefAlias, from: fromText, currentNumber } = this.analyzeJoin(entity, { filter, sorter });
+        // 对于limit，如果有indexForm则一定有count
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number' && count > 0);
+        }
         const alias = aliasDict['./'];
         // 这里原来includeDeleted传的是true，不知道原因，但不合理
         const { stmt: filterText } = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, { includedDeleted: option?.includedDeleted });
@@ -992,6 +996,10 @@ class SqlTranslator {
         const { filter, sorter, indexFrom, count, data } = operation;
         (0, assert_1.default)(!sorter, '当前update不支持sorter行为');
         const { aliasDict, filterRefAlias, from: fromText, currentNumber } = this.analyzeJoin(entity, { filter, sorter });
+        // 对于limit，如果有indexForm则一定有count
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number' && count > 0);
+        }
         const alias = aliasDict['./'];
         let updateText = '';
         for (const attr in data) {

package/lib/types/dbStore.d.ts

@@ -16,6 +16,7 @@ export type Plan = {
     updatedIndexes: Record<string, Index<any>[]>;
 };
 export interface DbStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends AsyncRowStore<ED, Cxt> {
+    checkRelationAsync<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, operation: Omit<ED[T]['Operation'] | ED[T]['Selection'], 'id'>, context: Cxt): Promise<void>;
     connect: () => Promise<void>;
     disconnect: () => Promise<void>;
     initialize(options: CreateEntityOption): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oak-db",
-	"version": "3.3.13",
+	"version": "3.3.14",
 	"description": "oak-db",
 	"main": "lib/index",
 	"author": {
@@ -18,7 +18,7 @@
 		"lodash": "^4.17.21",
 		"mysql": "^2.18.1",
 		"mysql2": "^2.3.3",
-		"oak-domain": "^5.1.34",
+		"oak-domain": "^5.1.36",
 		"pg": "^8.16.3",
 		"uuid": "^8.3.2"
 	},