oak-db 3.3.10 → 3.3.12

package/lib/PostgreSQL/types/Configuration.d.ts

@@ -0,0 +1,13 @@
+export type PostgreSQLConfiguration = {
+    host: string;
+    user: string;
+    password: string;
+    database: string;
+    port?: number;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+};
+export type Configuration = {
+    postgresql: PostgreSQLConfiguration;
+};

package/lib/PostgreSQL/types/Configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -1,2 +1,4 @@
-export * from './MySQL/store';
-export { MySqlSelectOption, MysqlOperateOption } from './MySQL/translator';
+export * from './MySQL/store';
+export { MySqlSelectOption, MysqlOperateOption } from './MySQL/translator';
+export * from './PostgreSQL/store';
+export { PostgreSQLSelectOption, PostgreSQLOperateOption } from './PostgreSQL/translator';

package/lib/index.js

@@ -1,4 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./MySQL/store"), exports);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./MySQL/store"), exports);
+tslib_1.__exportStar(require("./PostgreSQL/store"), exports);

package/lib/sqlTranslator.d.ts

@@ -1,55 +1,68 @@
-import { EntityDict, OperateOption, Q_FullTextValue, Ref, RefOrExpression, SelectOption, StorageSchema } from "oak-domain/lib/types";
-import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { DataType } from "oak-domain/lib/types/schema/DataTypes";
-import { CreateEntityOption } from './types/Translator';
-export interface SqlSelectOption extends SelectOption {
-}
-export interface SqlOperateOption extends OperateOption {
-}
-export declare abstract class SqlTranslator<ED extends EntityDict & BaseEntityDict> {
-    readonly schema: StorageSchema<ED>;
-    constructor(schema: StorageSchema<ED>);
-    private makeFullSchema;
-    protected abstract getDefaultSelectFilter<OP extends SqlSelectOption>(alias: string, option?: OP): string;
-    protected abstract translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
-    protected abstract translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
-    protected abstract translateAttrValue(dataType: DataType | Ref, value: any): string;
-    protected abstract translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
-    abstract translateCreateEntity<T extends keyof ED>(entity: T, option: CreateEntityOption): string[];
-    protected abstract translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
-    protected abstract populateSelectStmt<T extends keyof ED, OP extends SqlSelectOption>(projectionText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, groupByText?: string, indexFrom?: number, count?: number, option?: OP, selection?: ED[T]['Selection'], aggregation?: ED[T]['Aggregation']): string;
-    protected abstract populateUpdateStmt<OP extends SqlOperateOption>(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
-    protected abstract populateRemoveStmt<OP extends SqlOperateOption>(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
-    protected abstract translateExpression<T extends keyof ED>(entity: T, alias: string, expression: RefOrExpression<keyof ED[T]['OpSchema']>, refDict: Record<string, [string, keyof ED]>): string;
-    private getStorageName;
-    translateInsert<T extends keyof ED>(entity: T, data: ED[T]['CreateMulti']['data']): string;
-    /**
-     * analyze the join relations in projection/query/sort
-     * 所有的层次关系都当成left join处理，如果有内表为空的情况，请手动处理
-     * {
-     *      b: {
-     *          name: {
-     *              $exists: false,
-     *          }
-*           }
-     * }
-     * 这样的query会把内表为空的行也返回
-     * @param param0
-     */
-    private analyzeJoin;
-    private translateComparison;
-    private translateEvaluation;
-    protected translatePredicate(predicate: string, value: any, type?: DataType | Ref): string;
-    private translateFilter;
-    private translateSorter;
-    private translateProjection;
-    private translateSelectInner;
-    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;
-    translateCount<T extends keyof ED, OP extends SqlSelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option?: OP): string;
-    translateRemove<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Remove'], option?: OP): string;
-    translateUpdate<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Update'], option?: OP): string;
-    translateDestroyEntity(entity: string, truncate?: boolean): string;
-    escapeStringValue(value: string): string;
-}
+import { EntityDict, OperateOption, Q_FullTextValue, Ref, RefOrExpression, SelectOption, StorageSchema } from "oak-domain/lib/types";
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { DataType } from "oak-domain/lib/types/schema/DataTypes";
+import { CreateEntityOption } from './types/Translator';
+export interface SqlSelectOption extends SelectOption {
+}
+export interface SqlOperateOption extends OperateOption {
+}
+export declare abstract class SqlTranslator<ED extends EntityDict & BaseEntityDict> {
+    readonly schema: StorageSchema<ED>;
+    constructor(schema: StorageSchema<ED>);
+    private makeFullSchema;
+    protected abstract getDefaultSelectFilter<OP extends SqlSelectOption>(alias: string, option?: OP): string;
+    protected abstract translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
+    protected abstract translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
+    protected abstract translateAttrValue(dataType: DataType | Ref, value: any): string;
+    protected abstract translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
+    abstract translateCreateEntity<T extends keyof ED>(entity: T, option: CreateEntityOption): string[];
+    protected abstract translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
+    protected abstract populateSelectStmt<T extends keyof ED, OP extends SqlSelectOption>(projectionText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, groupByText?: string, indexFrom?: number, count?: number, option?: OP, selection?: ED[T]['Selection'], aggregation?: ED[T]['Aggregation']): string;
+    protected abstract populateUpdateStmt<OP extends SqlOperateOption>(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
+    protected abstract populateRemoveStmt<OP extends SqlOperateOption>(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
+    protected abstract translateExpression<T extends keyof ED>(entity: T, alias: string, expression: RefOrExpression<keyof ED[T]['OpSchema']>, refDict: Record<string, [string, keyof ED]>): string;
+    protected getStorageName<T extends keyof ED>(entity: T): string;
+    translateInsert<T extends keyof ED>(entity: T, data: ED[T]['CreateMulti']['data']): string;
+    /**
+     * analyze the join relations in projection/query/sort
+     * 所有的层次关系都当成left join处理，如果有内表为空的情况，请手动处理
+     * {
+     *      b: {
+     *          name: {
+     *              $exists: false,
+     *          }
+*           }
+     * }
+     * 这样的query会把内表为空的行也返回
+     * @param param0
+     */
+    private analyzeJoin;
+    /**
+     * 对like模式中的特殊字符进行转义
+     * 例如 % 和 _，以防止被当成通配符处理
+     * @param pattern     like模式字符串
+     * @returns 转义后的字符串
+     */
+    escapeLikePattern(pattern: string): string;
+    private translateComparison;
+    private translateEvaluation;
+    protected translatePredicate(predicate: string, value: any, type?: DataType | Ref): string;
+    protected translateFilter<T extends keyof ED, OP extends SqlSelectOption>(entity: T, filter: ED[T]['Selection']['filter'], aliasDict: Record<string, string>, filterRefAlias: Record<string, [string, keyof ED]>, initialNumber: number, option?: OP): {
+        stmt: string;
+        currentNumber: number;
+    };
+    private translateSorter;
+    private translateProjection;
+    private translateSelectInner;
+    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;
+    translateCount<T extends keyof ED, OP extends SqlSelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option?: OP): string;
+    translateRemove<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Remove'], option?: OP): string;
+    translateUpdate<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Update'], option?: OP): string;
+    translateDestroyEntity(entity: string, truncate?: boolean): string;
+    escapeStringValue(value: string): string;
+    /**比较两段sql是否完全一致，这里是把所有的空格去掉了 */
+    compareSql(sql1: string, sql2: string): boolean;
+    quoteIdentifier(name: string): string;
+}

package/lib/sqlTranslator.js

@@ -21,7 +21,7 @@ class SqlTranslator {
             const { attributes, indexes } = schema[entity];
             // 增加默认的属性
             (0, lodash_1.assign)(attributes, {
-                id: {
+                [types_1.PrimaryKeyAttribute]: {
                     type: 'char',
                     params: {
                         length: 36,
@@ -69,7 +69,7 @@ class SqlTranslator {
                             name: types_1.DeleteAtAttribute,
                         }],
                 }, {
-                    name: `${entity}_trigger_uuid`,
+                    name: `${entity}_trigger_uuid_auto_create`,
                     attributes: [{
                             name: types_1.TriggerUuidAttribute,
                         }]
@@ -137,6 +137,16 @@ class SqlTranslator {
                 }
             }
             if (indexes) {
+                for (const index of indexes) {
+                    const { attributes, config } = index;
+                    if (!config?.type || config.type === 'btree') {
+                        if (!attributes.find((ele) => ele.name === types_1.DeleteAtAttribute)) {
+                            attributes.push({
+                                name: types_1.DeleteAtAttribute,
+                            });
+                        }
+                    }
+                }
                 indexes.push(...intrinsticIndexes);
             }
             else {
@@ -154,14 +164,14 @@ class SqlTranslator {
     translateInsert(entity, data) {
         const { schema } = this;
         const { attributes, storageName = entity } = schema[entity];
-        let sql = `insert into \`${storageName}\`(`;
+        let sql = `insert into ${this.quoteIdentifier(storageName)}(`;
         /**
          * 这里的attrs要用所有行的union集合
          */
         const dataFull = data.reduce((prev, cur) => Object.assign({}, cur, prev), {});
         const attrs = Object.keys(dataFull).filter(ele => attributes.hasOwnProperty(ele));
         attrs.forEach((attr, idx) => {
-            sql += ` \`${attr}\``;
+            sql += ` ${this.quoteIdentifier(attr)}`;
             if (idx < attrs.length - 1) {
                 sql += ',';
             }
@@ -209,7 +219,7 @@ class SqlTranslator {
         const projectionRefAlias = {};
         const filterRefAlias = {};
         const alias = `${entity}_${number++}`;
-        let from = ` \`${this.getStorageName(entity)}\` \`${alias}\` `;
+        let from = ` ${this.quoteIdentifier(this.getStorageName(entity))} ${this.quoteIdentifier(alias)} `;
         const aliasDict = {
             './': alias,
         };
@@ -243,7 +253,7 @@ class SqlTranslator {
                             (0, lodash_1.assign)(aliasDict, {
                                 [pathAttr]: alias2,
                             });
-                            from += ` left join \`${this.getStorageName(rel)}\` \`${alias2}\` on \`${alias}\`.\`${op}Id\` = \`${alias2}\`.\`id\``;
+                            from += ` left join ${this.quoteIdentifier(this.getStorageName(rel))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier(op + 'Id')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')}`;
                         }
                         else {
                             alias2 = aliasDict[pathAttr];
@@ -263,7 +273,7 @@ class SqlTranslator {
                             (0, lodash_1.assign)(aliasDict, {
                                 [pathAttr]: alias2,
                             });
-                            from += ` left join \`${this.getStorageName(op)}\` \`${alias2}\` on \`${alias}\`.\`entityId\` = \`${alias2}\`.\`id\` and \`${alias}\`.\`entity\` = '${op}'`;
+                            from += ` left join ${this.quoteIdentifier(this.getStorageName(op))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entityId')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')} and ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entity')} = '${op}'`;
                         }
                         else {
                             alias2 = aliasDict[pathAttr];
@@ -307,7 +317,7 @@ class SqlTranslator {
                     (0, lodash_1.assign)(aliasDict, {
                         [pathAttr]: alias2,
                     });
-                    from += ` left join \`${this.getStorageName(rel)}\` \`${alias2}\` on \`${alias}\`.\`${attr}Id\` = \`${alias2}\`.\`id\``;
+                    from += ` left join ${this.quoteIdentifier(this.getStorageName(rel))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr + 'Id')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')}`;
                 }
                 else {
                     alias2 = aliasDict[pathAttr];
@@ -327,7 +337,7 @@ class SqlTranslator {
                     (0, lodash_1.assign)(aliasDict, {
                         [pathAttr]: alias2,
                     });
-                    from += ` left join \`${this.getStorageName(attr)}\` \`${alias2}\` on \`${alias}\`.\`entityId\` = \`${alias2}\`.\`id\` and \`${alias}\`.\`entity\` = '${attr}'`;
+                    from += ` left join ${this.quoteIdentifier(this.getStorageName(attr))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entityId')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')} and ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entity')} = '${attr}'`;
                 }
                 else {
                     alias2 = aliasDict[pathAttr];
@@ -365,7 +375,7 @@ class SqlTranslator {
                         (0, lodash_1.assign)(aliasDict, {
                             [pathAttr]: alias2,
                         });
-                        from += ` left join \`${this.getStorageName(rel)}\` \`${alias2}\` on \`${alias}\`.\`${attr}Id\` = \`${alias2}\`.\`id\``;
+                        from += ` left join ${this.quoteIdentifier(this.getStorageName(rel))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr + 'Id')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')}`;
                     }
                     else {
                         alias2 = aliasDict[pathAttr];
@@ -385,7 +395,7 @@ class SqlTranslator {
                         (0, lodash_1.assign)(aliasDict, {
                             [pathAttr]: alias2,
                         });
-                        from += ` left join \`${this.getStorageName(attr)}\` \`${alias2}\` on \`${alias}\`.\`entityId\` = \`${alias2}\`.\`id\` and \`${alias}\`.\`entity\` = '${attr}'`;
+                        from += ` left join ${this.quoteIdentifier(this.getStorageName(attr))} ${this.quoteIdentifier(alias2)} on ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entityId')} = ${this.quoteIdentifier(alias2)}.${this.quoteIdentifier('id')} and ${this.quoteIdentifier(alias)}.${this.quoteIdentifier('entity')} = '${attr}'`;
                     }
                     else {
                         alias2 = aliasDict[pathAttr];
@@ -426,6 +436,15 @@ class SqlTranslator {
             currentNumber: number,
         };
     }
+    /**
+     * 对like模式中的特殊字符进行转义
+     * 例如 % 和 _，以防止被当成通配符处理
+     * @param pattern     like模式字符串
+     * @returns 转义后的字符串
+     */
+    escapeLikePattern(pattern) {
+        return pattern.replace(/[%_]/g, (match) => `\\${match}`);
+    }
     translateComparison(attr, value, type) {
         const SQL_OP = {
             $gt: '>',
@@ -445,16 +464,19 @@ class SqlTranslator {
         }
         switch (attr) {
             case '$startsWith': {
-                return ` like '${value}%'`;
+                const escaped = this.escapeLikePattern(value);
+                return ` LIKE '${escaped}%'`;
             }
             case '$endsWith': {
-                return ` like '%${value}'`;
+                const escaped = this.escapeLikePattern(value);
+                return ` LIKE '%${escaped}'`;
             }
             case '$includes': {
-                return ` like '%${value}%'`;
+                const escaped = this.escapeLikePattern(value);
+                return ` LIKE '%${escaped}%'`;
             }
             default: {
-                throw new Error(`unrecoganized comparison operator ${attr}`);
+                throw new Error(`unrecognized comparison operator ${attr}`);
             }
         }
     }
@@ -499,7 +521,7 @@ class SqlTranslator {
             };
             const values = value.map((v) => {
                 if (type && ['varchar', 'char', 'text', 'nvarchar', 'ref', 'enum'].includes(type) || typeof v === 'string') {
-                    return `'${v}'`;
+                    return this.escapeStringValue(String(v));
                 }
                 else {
                     return `${v}`;
@@ -516,7 +538,7 @@ class SqlTranslator {
         else if (predicate === '$between') {
             const values = value.map((v) => {
                 if (type && ['varchar', 'char', 'text', 'nvarchar', 'ref', 'enum'].includes(type) || typeof v === 'string') {
-                    return `'${v}'`;
+                    return this.escapeStringValue(String(v));
                 }
                 else {
                     return `${v}`;
@@ -626,7 +648,7 @@ class SqlTranslator {
                                     filter: filter2[attr]
                                 }, currentNumber, filterRefAlias, option);
                                 currentNumber = ct2;
-                                whereText += `(${refAlia2}.id ${predicate} (${stmt}))`;
+                                whereText += `(${this.quoteIdentifier(alias)}.${this.quoteIdentifier('id')} ${predicate} (${stmt}))`;
                             }
                             else {
                                 /**
@@ -682,15 +704,18 @@ class SqlTranslator {
                                     whereText += `(${this.translateObjectPredicate(filter2[attr], alias, attr)})`;
                                 }
                                 else {
+                                    if (!filter2[attr]) {
+                                        throw new Error(`属性${attr}的查询条件不能为null或undefined`);
+                                    }
                                     (0, assert_1.default)(Object.keys(filter2[attr]).length === 1);
                                     const predicate = Object.keys(filter2[attr])[0];
                                     (0, assert_1.default)(predicate.startsWith('$'));
                                     // 对属性上的谓词处理
-                                    whereText += ` (\`${alias}\`.\`${attr}\` ${this.translatePredicate(predicate, filter2[attr][predicate], type2)})`;
+                                    whereText += ` (${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr)} ${this.translatePredicate(predicate, filter2[attr][predicate], type2)})`;
                                 }
                             }
                             else {
-                                whereText += ` (\`${alias}\`.\`${attr}\` = ${this.translateAttrValue(type2, filter2[attr])})`;
+                                whereText += ` (${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr)} = ${this.translateAttrValue(type2, filter2[attr])})`;
                             }
                         }
                     }
@@ -716,7 +741,7 @@ class SqlTranslator {
                 return this.translateExpression(entity2, alias, sortAttr[attr], {});
             }
             else if (sortAttr[attr] === 1) {
-                return `\`${alias}\`.\`${attr}\``;
+                return `${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr)}`;
             }
             else {
                 const rel = (0, relation_1.judgeRelation)(this.schema, entity2, attr);
@@ -765,12 +790,12 @@ class SqlTranslator {
                         projText += ` ${exprText}`;
                     }
                     else {
-                        projText += ` ${exprText} as \`${prefix2}${attr}\``;
+                        projText += ` ${exprText} as ${this.quoteIdentifier(prefix2 + attr)}`;
                         if (!as) {
-                            as = `\`${prefix2}${attr}\``;
+                            as = this.quoteIdentifier(prefix2 + attr);
                         }
                         else {
-                            as += `, \`${prefix2}${attr}\``;
+                            as += `, ${this.quoteIdentifier(prefix2 + attr)}`;
                         }
                     }
                 }
@@ -789,12 +814,12 @@ class SqlTranslator {
                                 projText += ` ${this.translateAttrProjection(type, alias, attr)}`;
                             }
                             else {
-                                projText += ` ${this.translateAttrProjection(type, alias, attr)} as \`${prefix2}${attr}\``;
+                                projText += ` ${this.translateAttrProjection(type, alias, attr)} as ${this.quoteIdentifier(prefix2 + attr)}`;
                                 if (!as) {
-                                    as = `\`${prefix2}${attr}\``;
+                                    as = this.quoteIdentifier(prefix2 + attr);
                                 }
                                 else {
-                                    as += `, \`${prefix2}${attr}\``;
+                                    as += `, ${this.quoteIdentifier(prefix2 + attr)}`;
                                 }
                             }
                         }
@@ -810,12 +835,12 @@ class SqlTranslator {
                                 projText += ` ${this.translateAttrProjection(type, alias, attr)}`;
                             }
                             else {
-                                projText += ` ${this.translateAttrProjection(type, alias, attr)} as \`${prefix2}${projection2[attr]}\``;
+                                projText += ` ${this.translateAttrProjection(type, alias, attr)} as ${this.quoteIdentifier(`${prefix2}${projection2[attr]}`)}`;
                                 if (!as) {
-                                    as = `\`${prefix2}${projection2[attr]}\``;
+                                    as = this.quoteIdentifier(`${prefix2}${projection2[attr]}`);
                                 }
                                 else {
-                                    as += `\`${prefix2}${projection2[attr]}\``;
+                                    as += `, ${this.quoteIdentifier(`${prefix2}${projection2[attr]}`)}`;
                                 }
                             }
                         }
@@ -885,29 +910,29 @@ class SqlTranslator {
                 let { projText: projSubText } = this.translateProjection(entity, data[k], aliasDict, projectionRefAlias, undefined, true);
                 let projSubText2 = '';
                 if (k.startsWith('#max')) {
-                    projSubText2 = `max(${projSubText}) as \`${k}\``;
+                    projSubText2 = `max(${projSubText}) as ${this.quoteIdentifier(k)}`;
                 }
                 else if (k.startsWith('#min')) {
-                    projSubText2 = `min(${projSubText}) as \`${k}\``;
+                    projSubText2 = `min(${projSubText}) as ${this.quoteIdentifier(k)}`;
                 }
                 else if (k.startsWith('#count')) {
                     if (data.distinct) {
                         projSubText = `distinct ${projSubText}`;
                     }
-                    projSubText2 = `count(${projSubText}) as \`${k}\``;
+                    projSubText2 = `count(${projSubText}) as ${this.quoteIdentifier(k)}`;
                 }
                 else if (k.startsWith('#sum')) {
                     if (data.distinct) {
                         projSubText = `distinct ${projSubText}`;
                     }
-                    projSubText2 = `sum(${projSubText}) as \`${k}\``;
+                    projSubText2 = `sum(${projSubText}) as ${this.quoteIdentifier(k)}`;
                 }
                 else {
                     if (data.distinct) {
                         projSubText = `distinct ${projSubText}`;
                     }
                     (0, assert_1.default)(k.startsWith('#avg'));
-                    projSubText2 = `avg(${projSubText}) as \`${k}\``;
+                    projSubText2 = `avg(${projSubText}) as ${this.quoteIdentifier(k)}`;
                 }
                 if (!projText) {
                     projText = projSubText2;
@@ -955,7 +980,7 @@ class SqlTranslator {
                 // delete只支持对volatile trigger的metadata域赋值
                 (0, assert_1.default)([types_1.TriggerDataAttribute, types_1.TriggerUuidAttribute, types_1.DeleteAtAttribute, types_1.UpdateAtAttribute].includes(attr));
                 const value = this.translateAttrValue(attributes[attr].type, data[attr]);
-                updateText += `\`${alias}\`.\`${attr}\` = ${value}`;
+                updateText += `${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr)} = ${value}`;
             }
         }
         return this.populateRemoveStmt(updateText, fromText, aliasDict, filterText, /* sorterText */ undefined, indexFrom, count, option);
@@ -973,7 +998,7 @@ class SqlTranslator {
             }
             (0, assert_1.default)(attributes.hasOwnProperty(attr));
             const value = this.translateAttrValue(attributes[attr].type, data[attr]);
-            updateText += `\`${alias}\`.\`${attr}\` = ${value}`;
+            updateText += `${this.quoteIdentifier(alias)}.${this.quoteIdentifier(attr)} = ${value}`;
         }
         const { stmt: filterText } = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, option);
         // const sorterText = sorter && this.translateSorter(entity, sorter, aliasDict);
@@ -984,10 +1009,10 @@ class SqlTranslator {
         const { storageName = entity, view } = schema[entity];
         let sql;
         if (view) {
-            sql = `drop view if exists \`${storageName}\``;
+            sql = `drop view if exists ${this.quoteIdentifier(storageName)}`;
         }
         else {
-            sql = truncate ? `truncate table \`${storageName}\`` : `drop table if exists \`${storageName}\``;
+            sql = truncate ? `truncate table ${this.quoteIdentifier(storageName)}` : `drop table if exists ${this.quoteIdentifier(storageName)}`;
         }
         return sql;
     }
@@ -995,5 +1020,13 @@ class SqlTranslator {
         const result = sqlstring_1.default.escape(value);
         return result;
     }
+    /**比较两段sql是否完全一致，这里是把所有的空格去掉了 */
+    compareSql(sql1, sql2) {
+        const reg = /[\t\r\f\n\s]/g;
+        return sql1.replaceAll(reg, '') === sql2.replaceAll(reg, '');
+    }
+    quoteIdentifier(name) {
+        return `\`${name}\``; // MySQL 默认
+    }
 }
 exports.SqlTranslator = SqlTranslator;

package/lib/types/Translator.d.ts

@@ -1,3 +1,3 @@
-export type CreateEntityOption = {
-    ifExists?: 'drop' | 'omit' | 'dropIfNotStatic';
-};
+export type CreateEntityOption = {
+    ifExists?: 'drop' | 'omit' | 'dropIfNotStatic';
+};

package/lib/types/Translator.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/configuration.d.ts

@@ -0,0 +1,7 @@
+import { PostgreSQLConfiguration } from './../PostgreSQL/types/Configuration';
+import { MySQLConfiguration } from './../MySQL/types/Configuration';
+export type DbConfiguration = PostgreSQLConfiguration & {
+    type: 'postgresql';
+} | MySQLConfiguration & {
+    type: 'mysql';
+};

package/lib/types/configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/dbStore.d.ts

@@ -0,0 +1,8 @@
+import { EntityDict } from "oak-domain/lib/base-app-domain";
+import { AsyncContext, AsyncRowStore } from "oak-domain/lib/store/AsyncRowStore";
+import { CreateEntityOption } from "./Translator";
+export interface DbStore<ED extends EntityDict, Cxt extends AsyncContext<ED>> extends AsyncRowStore<ED, Cxt> {
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    initialize(options: CreateEntityOption): Promise<void>;
+}

package/lib/types/dbStore.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oak-db",
-	"version": "3.3.10",
+	"version": "3.3.12",
 	"description": "oak-db",
 	"main": "lib/index",
 	"author": {
@@ -10,15 +10,16 @@
 		"lib/**/*"
 	],
 	"scripts": {
-		"test": "mocha",
+		"test": "node --stack-size=65500 ./node_modules/mocha/bin/mocha",
 		"make:test:domain": "ts-node script/makeTestDomain.ts",
-		"build": "tsc"
+		"build": "node --stack-size=4096 ./script/build.js"
 	},
 	"dependencies": {
 		"lodash": "^4.17.21",
 		"mysql": "^2.18.1",
 		"mysql2": "^2.3.3",
-		"oak-domain": "^5.1.27",
+		"oak-domain": "^5.1.33",
+		"pg": "^8.16.3",
 		"uuid": "^8.3.2"
 	},
 	"license": "ISC",
@@ -27,11 +28,11 @@
 		"@types/luxon": "^2.3.2",
 		"@types/mocha": "^9.1.1",
 		"@types/node": "^20.6.0",
+		"@types/pg": "^8.16.0",
 		"@types/sqlstring": "^2.3.0",
 		"@types/uuid": "^8.3.4",
 		"cross-env": "^7.0.3",
 		"mocha": "^10.2.0",
-		"oak-general-business": "~5.5.0",
 		"ts-node": "^10.9.1",
 		"tslib": "^2.4.0",
 		"typescript": "^5.2.2"