oak-db 3.3.12 → 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

@@ -1,4 +1,4 @@
-import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult, Attribute, Index } from 'oak-domain/lib/types';
+import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { CascadeStore } from 'oak-domain/lib/store/CascadeStore';
 import { MySQLConfiguration } from './types/Configuration';
@@ -7,7 +7,7 @@ import { MySqlTranslator, MySqlSelectOption, MysqlOperateOption } from './transl
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
 import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
 import { CreateEntityOption } from '../types/Translator';
-import { DbStore } from '../types/dbStore';
+import { DbStore, Plan } from '../types/dbStore';
 export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements DbStore<ED, Cxt> {
     protected countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
     protected aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
@@ -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>;
@@ -48,16 +51,3 @@ export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt exte
      */
     diffSchema(schemaOld: StorageSchema<any>, schemaNew: StorageSchema<any>): Plan;
 }
-type Plan = {
-    newTables: Record<string, {
-        attributes: Record<string, Attribute>;
-    }>;
-    newIndexes: Record<string, Index<any>[]>;
-    updatedTables: Record<string, {
-        attributes: Record<string, Attribute & {
-            isNew: boolean;
-        }>;
-    }>;
-    updatedIndexes: Record<string, Index<any>[]>;
-};
-export {};

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');
@@ -354,7 +363,7 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
                 };
                 for (const attr in attributesNew) {
                     if (attributes[attr]) {
-                        // 因为反向无法复原原来定义的attribute类型，这里就比较两次创建的sql是不是一致。
+                        // 因为反向无法复原原来定义的attribute类型，这里就比较两次创建的sql是不是一致，不是太好的设计。
                         const sql1 = this.translator.translateAttributeDef(attr, attributesNew[attr]);
                         const sql2 = this.translator.translateAttributeDef(attr, attributes[attr]);
                         if (!this.translator.compareSql(sql1, sql2)) {

package/lib/MySQL/translator.js

@@ -872,8 +872,10 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                 const refId = (expr)['#refId'];
                 const refAttr = (expr)['#refAttr'];
                 (0, assert_1.default)(refDict[refId]);
-                const attrText = `\`${refDict[refId][0]}\`.\`${refAttr}\``;
-                result = this.translateAttrInExpression(entity, (expr)['#refAttr'], attrText);
+                const [refAlias, refEntity] = refDict[refId];
+                const attrText = `\`${refAlias}\`.\`${refAttr}\``;
+                // 这里必须使用refEntity，否则在filter深层嵌套节点表达式时会出现entity不对应
+                result = this.translateAttrInExpression(refEntity, (expr)['#refAttr'], attrText);
             }
             else {
                 (0, assert_1.default)(k.length === 1);
@@ -1067,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;
     }
@@ -1085,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;
         }
@@ -1103,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.d.ts

@@ -16,10 +16,6 @@ export declare class PostgreSQLConnector {
     exec(sql: string, txn?: string): Promise<[QueryResultRow[], QueryResult]>;
     commitTransaction(txn: string): Promise<void>;
     rollbackTransaction(txn: string): Promise<void>;
-    /**
-     * 执行多条 SQL 语句（用于初始化等场景）
-     */
-    execBatch(sqls: string[], txn?: string): Promise<void>;
     /**
      * 获取连接池状态
      */

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];
@@ -133,16 +114,6 @@ class PostgreSQLConnector {
             connection.release();
         }
     }
-    /**
-     * 执行多条 SQL 语句（用于初始化等场景）
-     */
-    async execBatch(sqls, txn) {
-        for (const sql of sqls) {
-            if (sql.trim()) {
-                await this.exec(sql, txn);
-            }
-        }
-    }
     /**
      * 获取连接池状态
      */

package/lib/PostgreSQL/store.d.ts

@@ -7,7 +7,7 @@ import { PostgreSQLTranslator, PostgreSQLSelectOption, PostgreSQLOperateOption }
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
 import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
 import { CreateEntityOption } from '../types/Translator';
-import { DbStore } from '../types/dbStore';
+import { DbStore, Plan } from '../types/dbStore';
 export declare class PostgreSQLStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements DbStore<ED, Cxt> {
     protected countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
     protected aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
@@ -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>;
@@ -35,4 +38,16 @@ export declare class PostgreSQLStore<ED extends EntityDict & BaseEntityDict, Cxt
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     initialize(option: CreateEntityOption): Promise<void>;
+    readSchema(): Promise<StorageSchema<ED>>;
+    /**
+     * 根据载入的dataSchema，和数据库中原来的schema，决定如何来upgrade
+     * 制订出来的plan分为两阶段：增加阶段和削减阶段，在两个阶段之间，由用户来修正数据
+     */
+    makeUpgradePlan(): Promise<Plan>;
+    /**
+     * 比较两个schema的不同，这里计算的是new对old的增量
+     * @param schemaOld
+     * @param schemaNew
+     */
+    diffSchema(schemaOld: StorageSchema<any>, schemaNew: StorageSchema<any>): Plan;
 }

package/lib/PostgreSQL/store.js

@@ -8,6 +8,12 @@ const translator_1 = require("./translator");
 const lodash_1 = require("lodash");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const relation_1 = require("oak-domain/lib/store/relation");
+const ToNumberAttrs = new Set([
+    '$$seq$$',
+    '$$createAt$$',
+    '$$updateAt$$',
+    '$$deleteAt$$',
+]);
 function convertGeoTextToObject(geoText) {
     if (geoText.startsWith('POINT')) {
         const coord = geoText.match(/(-?\d+\.?\d*)/g);
@@ -88,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) {
@@ -121,12 +130,19 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
                     const { type } = attributes[attr];
                     switch (type) {
                         case 'date':
-                        case 'time': {
+                        case 'time':
+                        case 'datetime': {
                             if (value instanceof Date) {
                                 r[attr] = value.valueOf();
                             }
                             else {
-                                r[attr] = value;
+                                if (typeof value === 'string') {
+                                    r[attr] = parseInt(value, 10);
+                                }
+                                else {
+                                    (0, assert_1.default)(typeof value === 'number' || value === null);
+                                    r[attr] = value;
+                                }
                             }
                             break;
                         }
@@ -203,6 +219,14 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
                             // PostgreSQL count 返回字符串
                             r[attr] = parseInt(value, 10);
                         }
+                        else if (attr.startsWith("#sum") || attr.startsWith("#avg") || attr.startsWith("#min") || attr.startsWith("#max")) {
+                            // PostgreSQL sum/avg/min/max 返回字符串
+                            r[attr] = parseFloat(value);
+                        }
+                        else if (ToNumberAttrs.has(attr)) {
+                            // PostgreSQL sum/avg/min/max 返回字符串
+                            r[attr] = parseInt(value, 10);
+                        }
                         else {
                             r[attr] = value;
                         }
@@ -281,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');
@@ -316,14 +367,203 @@ class PostgreSQLStore extends CascadeStore_1.CascadeStore {
     }
     async initialize(option) {
         const schema = this.getSchema();
-        // 可选：先创建 PostGIS 扩展
-        // await this.connector.exec('CREATE EXTENSION IF NOT EXISTS postgis;');
+        // ===== 第一阶段：事务外创建扩展 =====
+        let hasGeoType = false;
+        let hasChineseTsConfig = false;
+        let chineseParser = null;
+        // 扫描 schema
         for (const entity in schema) {
-            const sqls = this.translator.translateCreateEntity(entity, option);
-            for (const sql of sqls) {
-                await this.connector.exec(sql);
+            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 {
+            // 创建中文文本搜索配置
+            if (hasChineseTsConfig) {
+                console.log('Initializing Chinese text search configuration...');
+                const checkChineseConfigSql = `
+                SELECT COUNT(*) as cnt
+                FROM pg_catalog.pg_ts_config
+                WHERE cfgname = 'chinese';
+            `;
+                const result = await this.connector.exec(checkChineseConfigSql, txn);
+                const count = parseInt(result[0][0]?.cnt || '0', 10);
+                if (count === 0) {
+                    const createChineseConfigSql = `
+                    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, txn);
+                }
+            }
+            // 创建实体表
+            for (const entity in schema) {
+                const sqls = this.translator.translateCreateEntity(entity, option);
+                for (const sql of sqls) {
+                    await this.connector.exec(sql, txn);
+                }
+            }
+            await this.connector.commitTransaction(txn);
+        }
+        catch (error) {
+            await this.connector.rollbackTransaction(txn);
+            throw error;
+        }
+    }
+    // 从数据库中读取当前schema
+    readSchema() {
+        return this.translator.readSchema((sql) => this.connector.exec(sql));
+    }
+    /**
+     * 根据载入的dataSchema，和数据库中原来的schema，决定如何来upgrade
+     * 制订出来的plan分为两阶段：增加阶段和削减阶段，在两个阶段之间，由用户来修正数据
+     */
+    async makeUpgradePlan() {
+        const originSchema = await this.readSchema();
+        const plan = this.diffSchema(originSchema, this.translator.schema);
+        return plan;
+    }
+    /**
+     * 比较两个schema的不同，这里计算的是new对old的增量
+     * @param schemaOld
+     * @param schemaNew
+     */
+    diffSchema(schemaOld, schemaNew) {
+        const plan = {
+            newTables: {},
+            newIndexes: {},
+            updatedIndexes: {},
+            updatedTables: {},
+        };
+        for (const table in schemaNew) {
+            // PostgreSQL 表名区分大小写（使用双引号时）
+            if (schemaOld[table]) {
+                const { attributes, indexes } = schemaOld[table];
+                const { attributes: attributesNew, indexes: indexesNew } = schemaNew[table];
+                const assignToUpdateTables = (attr, isNew) => {
+                    const skipAttrs = ['$$seq$$', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$', 'id'];
+                    if (skipAttrs.includes(attr)) {
+                        return;
+                    }
+                    if (!plan.updatedTables[table]) {
+                        plan.updatedTables[table] = {
+                            attributes: {
+                                [attr]: {
+                                    ...attributesNew[attr],
+                                    isNew,
+                                }
+                            }
+                        };
+                    }
+                    else {
+                        plan.updatedTables[table].attributes[attr] = {
+                            ...attributesNew[attr],
+                            isNew,
+                        };
+                    }
+                };
+                for (const attr in attributesNew) {
+                    if (attributes[attr]) {
+                        // 比较两次创建的属性定义是否一致
+                        const sql1 = this.translator.translateAttributeDef(attr, attributesNew[attr]);
+                        const sql2 = this.translator.translateAttributeDef(attr, attributes[attr]);
+                        if (!this.translator.compareSql(sql1, sql2)) {
+                            assignToUpdateTables(attr, false);
+                        }
+                    }
+                    else {
+                        assignToUpdateTables(attr, true);
+                    }
+                }
+                if (indexesNew) {
+                    const assignToIndexes = (index, isNew) => {
+                        if (isNew) {
+                            if (plan.newIndexes[table]) {
+                                plan.newIndexes[table].push(index);
+                            }
+                            else {
+                                plan.newIndexes[table] = [index];
+                            }
+                        }
+                        else {
+                            if (plan.updatedIndexes[table]) {
+                                plan.updatedIndexes[table].push(index);
+                            }
+                            else {
+                                plan.updatedIndexes[table] = [index];
+                            }
+                        }
+                    };
+                    const compareConfig = (config1, config2) => {
+                        const unique1 = config1?.unique || false;
+                        const unique2 = config2?.unique || false;
+                        if (unique1 !== unique2) {
+                            return false;
+                        }
+                        const type1 = config1?.type || 'btree';
+                        const type2 = config2?.type || 'btree';
+                        // tsConfig 比较
+                        const tsConfig1 = config1?.tsConfig;
+                        const tsConfig2 = config2?.tsConfig;
+                        if (JSON.stringify(tsConfig1) !== JSON.stringify(tsConfig2)) {
+                            return false;
+                        }
+                        return type1 === type2;
+                    };
+                    for (const index of indexesNew) {
+                        const { name, config, attributes: indexAttrs } = index;
+                        const origin = indexes?.find(ele => ele.name === name);
+                        if (origin) {
+                            if (JSON.stringify(indexAttrs) !== JSON.stringify(origin.attributes)) {
+                                assignToIndexes(index, false);
+                            }
+                            else {
+                                if (!compareConfig(config, origin.config)) {
+                                    assignToIndexes(index, false);
+                                }
+                            }
+                        }
+                        else {
+                            assignToIndexes(index, true);
+                        }
+                    }
+                }
+            }
+            else {
+                plan.newTables[table] = {
+                    attributes: schemaNew[table].attributes,
+                };
+                if (schemaNew[table].indexes) {
+                    plan.newIndexes[table] = schemaNew[table].indexes;
+                }
             }
         }
+        return plan;
     }
 }
 exports.PostgreSQLStore = PostgreSQLStore;