oak-db 3.3.11 → 3.3.13

package/lib/MySQL/translator.js

@@ -119,21 +119,21 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         // numeric types
         "bit",
         "int",
-        "integer",
+        "integer", // synonym for int
         "tinyint",
         "smallint",
         "mediumint",
         "bigint",
         "float",
         "double",
-        "double precision",
-        "real",
+        "double precision", // synonym for double
+        "real", // synonym for double
         "decimal",
-        "dec",
-        "numeric",
-        "fixed",
-        "bool",
-        "boolean",
+        "dec", // synonym for decimal
+        "numeric", // synonym for decimal
+        "fixed", // synonym for decimal
+        "bool", // synonym for tinyint
+        "boolean", // synonym for tinyint
         // date and time types
         "date",
         "datetime",
@@ -142,10 +142,10 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         "year",
         // string types
         "char",
-        "nchar",
+        "nchar", // synonym for national char
         "national char",
         "varchar",
-        "nvarchar",
+        "nvarchar", // synonym for national varchar
         "national varchar",
         "blob",
         "text",
@@ -266,14 +266,18 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
             return 'text ';
         }
         if (type === 'ref') {
-            return 'char(36)';
+            return 'char(36) ';
+        }
+        if (['bool', 'boolean'].includes(type)) {
+            // MySQL读出来就是tinyint(1)
+            return 'tinyint(1) ';
         }
         if (type === 'money') {
-            return 'bigint';
+            return 'bigint ';
         }
         if (type === 'enum') {
             (0, assert_1.default)(enumeration);
-            return `enum(${enumeration.map(ele => `'${ele}'`).join(',')})`;
+            return `enum(${enumeration.map(ele => `'${ele}'`).join(',')}) `;
         }
         if (MySqlTranslator.withLengthDataTypes.includes(type)) {
             if (params) {
@@ -291,34 +295,34 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                 if (typeof scale === 'number') {
                     return `${type}(${precision}, ${scale}) `;
                 }
-                return `${type}(${precision})`;
+                return `${type}(${precision}) `;
             }
             else {
                 const { precision, scale } = MySqlTranslator.dataTypeDefaults[type];
                 if (typeof scale === 'number') {
                     return `${type}(${precision}, ${scale}) `;
                 }
-                return `${type}(${precision})`;
+                return `${type}(${precision}) `;
             }
         }
         if (MySqlTranslator.withWidthDataTypes.includes(type)) {
             (0, assert_1.default)(type === 'int');
-            const { width } = params;
+            const { width } = params || { width: 4 };
             switch (width) {
                 case 1: {
-                    return 'tinyint';
+                    return 'tinyint ';
                 }
                 case 2: {
-                    return 'smallint';
+                    return 'smallint ';
                 }
                 case 3: {
-                    return 'mediumint';
+                    return 'mediumint ';
                 }
                 case 4: {
-                    return 'int';
+                    return 'int ';
                 }
                 default: {
-                    return 'bigint';
+                    return 'bigint ';
                 }
             }
         }
@@ -553,6 +557,28 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         const columns2 = attributes.map(({ name }) => `${alias}.${name}`);
         return ` match(${columns2.join(',')}) against ('${$search}' in natural language mode)`;
     }
+    translateAttributeDef(attr, attrDef) {
+        let sql = `\`${attr}\` `;
+        const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
+        sql += this.populateDataTypeDef(type, params, enumeration);
+        if (notNull || type === 'geometry') {
+            sql += ' not null ';
+        }
+        if (unique) {
+            sql += ' unique ';
+        }
+        if (typeof sequenceStart === 'number') {
+            sql += ' auto_increment unique ';
+        }
+        if (defaultValue !== undefined) {
+            (0, assert_1.default)(type !== 'ref');
+            sql += ` default ${this.translateAttrValue(type, defaultValue)}`;
+        }
+        if (attr === types_1.PrimaryKeyAttribute) {
+            sql += ' primary key';
+        }
+        return sql;
+    }
     translateCreateEntity(entity, options) {
         const ifExists = options?.ifExists || 'drop';
         const { schema } = this;
@@ -578,32 +604,14 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
             sql += '(';
             // 翻译所有的属性
             Object.keys(attributes).forEach((attr, idx) => {
-                const attrDef = attributes[attr];
-                const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
-                sql += `\`${attr}\` `;
-                sql += this.populateDataTypeDef(type, params, enumeration);
-                if (notNull || type === 'geometry') {
-                    sql += ' not null ';
-                }
-                if (unique) {
-                    sql += ' unique ';
-                }
-                if (sequenceStart) {
-                    if (hasSequence) {
-                        throw new Error(`「${entity}」只能有一个sequence列`);
-                    }
-                    hasSequence = sequenceStart;
-                    sql += ' auto_increment unique ';
-                }
-                if (defaultValue !== undefined) {
-                    (0, assert_1.default)(type !== 'ref');
-                    sql += ` default ${this.translateAttrValue(type, defaultValue)}`;
+                const attrSql = this.translateAttributeDef(attr, attributes[attr]);
+                if (idx !== 0) {
+                    sql += ', ';
                 }
-                if (attr === 'id') {
-                    sql += ' primary key';
-                }
-                if (idx < Object.keys(attributes).length - 1) {
-                    sql += ',\n';
+                sql += attrSql;
+                if (typeof attributes[attr].sequenceStart === 'number') {
+                    (0, assert_1.default)(hasSequence === false, 'Entity can only have one auto increment attribute.');
+                    hasSequence = attributes[attr].sequenceStart;
                 }
             });
             // 翻译索引信息
@@ -621,12 +629,11 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                     else if (type === 'spatial') {
                         sql += ' spatial ';
                     }
-                    sql += `index ${name} `;
+                    sql += `index \`${name}\` `;
                     if (type === 'hash') {
                         sql += ` using hash `;
                     }
                     sql += '(';
-                    let includeDeleteAt = false;
                     attributes.forEach(({ name, size, direction }, idx2) => {
                         sql += `\`${name}\``;
                         if (size) {
@@ -636,15 +643,9 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                             sql += ` ${direction}`;
                         }
                         if (idx2 < attributes.length - 1) {
-                            sql += ',';
-                        }
-                        if (name === '$$deleteAt$$') {
-                            includeDeleteAt = true;
+                            sql += ', ';
                         }
                     });
-                    if (!includeDeleteAt && !type) {
-                        sql += ', `$$deleteAt$$`'; // 在mysql80+之后，需要给属性加上``包裹，否则会报错
-                    }
                     sql += ')';
                     if (parser) {
                         sql += ` with parser ${parser}`;
@@ -796,10 +797,11 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
             case '$dayOfYear': {
                 return 'DAYOFYEAR(%s)';
             }
-            case '$dateDiff': {
-                (0, assert_1.default)(argumentNumber === 3);
-                return 'DATEDIFF(%s, %s, %s)';
-            }
+            // 这个实现有问题，DATEDIFF只是计算两个日期之间的天数差，只接受两个参数，放在translateExperession里实现
+            // case '$dateDiff': {
+            //     assert(argumentNumber === 3);
+            //     return 'DATEDIFF(%s, %s, %s)';
+            // }
             case '$contains': {
                 (0, assert_1.default)(argumentNumber === 2);
                 return 'ST_CONTAINS(%s, %s)';
@@ -816,6 +818,22 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                 result += ')';
                 return result;
             }
+            // ========== 聚合函数 ==========
+            case '$$count': {
+                return 'COUNT(%s)';
+            }
+            case '$$sum': {
+                return 'SUM(%s)';
+            }
+            case '$$max': {
+                return 'MAX(%s)';
+            }
+            case '$$min': {
+                return 'MIN(%s)';
+            }
+            case '$$avg': {
+                return 'AVG(%s)';
+            }
             default: {
                 throw new Error(`unrecoganized function ${fnName}`);
             }
@@ -854,15 +872,142 @@ 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);
-                if ((expr)[k[0]] instanceof Array) {
-                    const fnName = this.translateFnName(k[0], (expr)[k[0]].length);
+                const fnKey = k[0];
+                const fnArgs = (expr)[fnKey];
+                // 特殊处理日期相关函数
+                if (fnKey === '$dateDiff') {
+                    // $dateDiff: [date1, date2, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 3);
+                    const [date1Expr, date2Expr, unit] = fnArgs;
+                    // 转换日期表达式
+                    const translateDateArg = (arg) => {
+                        if (arg instanceof Date) {
+                            return `FROM_UNIXTIME(${arg.valueOf()} / 1000)`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `FROM_UNIXTIME(${arg} / 1000)`;
+                        }
+                        else {
+                            return translateInner(arg);
+                        }
+                    };
+                    const date1Str = translateDateArg(date1Expr);
+                    const date2Str = translateDateArg(date2Expr);
+                    // MySQL TIMESTAMPDIFF 单位映射
+                    const unitMap = {
+                        's': 'SECOND',
+                        'm': 'MINUTE',
+                        'h': 'HOUR',
+                        'd': 'DAY',
+                        'M': 'MONTH',
+                        'y': 'YEAR'
+                    };
+                    const mysqlUnit = unitMap[unit];
+                    if (!mysqlUnit) {
+                        throw new Error(`Unsupported date diff unit: ${unit}`);
+                    }
+                    // TIMESTAMPDIFF(unit, date1, date2) 返回 date2 - date1
+                    // 但类型定义是 date1 - date2，所以参数顺序要反过来
+                    result = `TIMESTAMPDIFF(${mysqlUnit}, ${date2Str}, ${date1Str})`;
+                }
+                else if (fnKey === '$dateCeil') {
+                    // $dateCeil: [date, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 2);
+                    const [dateExpr, unit] = fnArgs;
+                    const getTimestampExpr = (arg) => {
+                        if (arg instanceof Date) {
+                            return `${arg.valueOf()}`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `${arg}`;
+                        }
+                        else {
+                            const k = Object.keys(arg);
+                            if (k.includes('#attr')) {
+                                return `\`${alias}\`.\`${arg['#attr']}\``;
+                            }
+                            else if (k.includes('#refId')) {
+                                const refId = arg['#refId'];
+                                const refAttr = arg['#refAttr'];
+                                return `\`${refDict[refId][0]}\`.\`${refAttr}\``;
+                            }
+                            return translateInner(arg);
+                        }
+                    };
+                    const tsExpr = getTimestampExpr(dateExpr);
+                    const msPerUnit = {
+                        's': 1000,
+                        'm': 60000,
+                        'h': 3600000,
+                        'd': 86400000,
+                    };
+                    if (msPerUnit[unit]) {
+                        // CEIL 向上取整
+                        result = `CEIL(${tsExpr} / ${msPerUnit[unit]}) * ${msPerUnit[unit]}`;
+                    }
+                    else {
+                        (0, assert_1.default)(typeof unit === 'string', 'unit should be string');
+                        console.warn('暂不支持 $dateCeil 对月年单位的处理');
+                        throw new Error(`Unsupported date ceil unit: ${unit}`);
+                    }
+                }
+                else if (fnKey === '$dateFloor') {
+                    // $dateFloor: [date, unit]
+                    (0, assert_1.default)(fnArgs instanceof Array && fnArgs.length === 2);
+                    const [dateExpr, unit] = fnArgs;
+                    // 获取毫秒时间戳表达式
+                    const getTimestampExpr = (arg) => {
+                        if (arg instanceof Date) {
+                            return `${arg.valueOf()}`;
+                        }
+                        else if (typeof arg === 'number') {
+                            return `${arg}`;
+                        }
+                        else {
+                            // 属性引用，直接返回属性（存储本身就是毫秒时间戳）
+                            const k = Object.keys(arg);
+                            if (k.includes('#attr')) {
+                                return `\`${alias}\`.\`${arg['#attr']}\``;
+                            }
+                            else if (k.includes('#refId')) {
+                                const refId = arg['#refId'];
+                                const refAttr = arg['#refAttr'];
+                                return `\`${refDict[refId][0]}\`.\`${refAttr}\``;
+                            }
+                            // 其他表达式递归处理
+                            return translateInner(arg);
+                        }
+                    };
+                    const tsExpr = getTimestampExpr(dateExpr);
+                    // 固定间隔单位：直接用时间戳数学运算
+                    const msPerUnit = {
+                        's': 1000,
+                        'm': 60000,
+                        'h': 3600000,
+                        'd': 86400000,
+                    };
+                    if (msPerUnit[unit]) {
+                        // FLOOR(timestamp / interval) * interval
+                        result = `FLOOR(${tsExpr} / ${msPerUnit[unit]}) * ${msPerUnit[unit]}`;
+                    }
+                    else {
+                        (0, assert_1.default)(typeof unit === 'string', 'unit should be string');
+                        console.warn('暂不支持 $dateFloor 对月年单位的处理');
+                        throw new Error(`Unsupported date floor unit: ${unit}`);
+                    }
+                }
+                else if (fnArgs instanceof Array) {
+                    // 原有的数组参数处理逻辑
+                    const fnName = this.translateFnName(fnKey, fnArgs.length);
                     const args = [fnName];
-                    args.push(...(expr)[k[0]].map((ele) => {
+                    args.push(...fnArgs.map((ele) => {
                         if (['string', 'number'].includes(typeof ele) || ele instanceof Date) {
                             return translateConstant(ele);
                         }
@@ -873,9 +1018,10 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
                     result = util_1.format.apply(null, args);
                 }
                 else {
-                    const fnName = this.translateFnName(k[0], 1);
+                    // 原有的单参数处理逻辑
+                    const fnName = this.translateFnName(fnKey, 1);
                     const args = [fnName];
-                    const arg = (expr)[k[0]];
+                    const arg = fnArgs;
                     if (['string', 'number'].includes(typeof arg) || arg instanceof Date) {
                         args.push(translateConstant(arg));
                     }
@@ -949,7 +1095,7 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         }
         // 新的remove应该包含$$deleteAt$$的值了
         /* const now = Date.now();
-
+    
         const updateText2 = updateText ? `${updateText}, \`${alias}\`.\`$$deleteAt$$\` = '${now}'` : `\`${alias}\`.\`$$deleteAt$$\` = '${now}'`; */
         (0, assert_1.default)(updateText.includes(types_1.DeleteAtAttribute));
         let sql = `update ${fromText} set ${updateText}`;
@@ -965,5 +1111,99 @@ class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
         }
         return sql;
     }
+    /**
+     * 将MySQL返回的Type回译成oak的类型，是 populateDataTypeDef 的反函数
+     * @param type
+     */
+    reTranslateToAttribute(type) {
+        const withLengthDataTypes = MySqlTranslator.withLengthDataTypes.join('|');
+        let result = (new RegExp(`^(${withLengthDataTypes})\\((\\d+)\\)$`)).exec(type);
+        if (result) {
+            return {
+                type: result[1],
+                params: {
+                    length: parseInt(result[2]),
+                }
+            };
+        }
+        const withPrecisionDataTypes = MySqlTranslator.withPrecisionDataTypes.join('|');
+        result = (new RegExp(`^(${withPrecisionDataTypes})\\((\\d+),(d+)\\)$`)).exec(type);
+        if (result) {
+            return {
+                type: result[1],
+                params: {
+                    precision: parseInt(result[2]),
+                    scale: parseInt(result[3]),
+                },
+            };
+        }
+        result = (/^enum\((\S+)\)$/).exec(type);
+        if (result) {
+            const enumeration = result[1].split(',').map(ele => ele.slice(1, -1));
+            return {
+                type: 'enum',
+                enumeration
+            };
+        }
+        return {
+            type: type,
+        };
+    }
+    // 分析当前数据库结构图
+    async readSchema(execFn) {
+        const result = {};
+        const sql = 'show tables;';
+        const [tables] = await execFn(sql);
+        for (const tableItem of tables) {
+            const table = Object.values(tableItem)[0];
+            const [tableResult] = await execFn(`desc \`${table}\``);
+            const attributes = {};
+            for (const attrItem of tableResult) {
+                const { Field: attrName, Null: isNull, Type: type, Key: key } = attrItem;
+                attributes[attrName] = {
+                    ...this.reTranslateToAttribute(type),
+                    notNull: isNull.toUpperCase() === 'NO',
+                    unique: key.toUpperCase() === 'UNI',
+                };
+                // 自增列只可能是seq
+                if (attrName === '$$seq$$') {
+                    attributes[attrName].sequenceStart = 10000;
+                }
+            }
+            Object.assign(result, {
+                [table]: {
+                    attributes,
+                }
+            });
+            const [indexedColumns] = (await execFn(`show index from \`${table}\``));
+            if (indexedColumns.length) {
+                const groupedColumns = (0, lodash_1.groupBy)(indexedColumns.sort((ele1, ele2) => ele1.Key_name.localeCompare(ele2.Key_name) || ele1.Seq_in_index - ele2.Seq_in_index), 'Key_name');
+                const indexes = Object.values(groupedColumns).map((ele) => {
+                    const index = {
+                        name: ele[0].Key_name,
+                        attributes: ele.map(ele2 => ({
+                            name: ele2.Column_name,
+                            direction: ele2.Collation === 'D' ? 'DESC' : (ele2.Collation === 'A' ? 'ASC' : undefined),
+                            size: ele2.Sub_part || undefined,
+                        })),
+                    };
+                    if (ele[0].Non_unique === 0 || ele[0].Index_type.toUpperCase() !== 'BTREE') {
+                        index.config = {};
+                        if (ele[0].Non_unique === 0) {
+                            index.config.unique = true;
+                        }
+                        if (ele[0].Index_type.toUpperCase() !== 'BTREE') {
+                            index.config.type = ele[0].Index_type.toLowerCase();
+                        }
+                    }
+                    return index;
+                });
+                Object.assign(result[table], {
+                    indexes,
+                });
+            }
+        }
+        return result;
+    }
 }
 exports.MySqlTranslator = MySqlTranslator;

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

@@ -1,12 +1,12 @@
-export type MySQLConfiguration = {
-    host: string;
-    user: string;
-    password: string;
-    database: string;
-    charset: 'utf8mb4_general_ci';
-    connectionLimit: number;
-    port?: number;
-};
-export type Configuration = {
-    mysql: MySQLConfiguration;
-};
+export type MySQLConfiguration = {
+    host: string;
+    user: string;
+    password: string;
+    database: string;
+    charset: 'utf8mb4_general_ci';
+    connectionLimit: number;
+    port?: number;
+};
+export type Configuration = {
+    mysql: MySQLConfiguration;
+};

package/lib/MySQL/types/Configuration.js

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

package/lib/PostgreSQL/connector.d.ts

@@ -0,0 +1,27 @@
+import { Pool, PoolClient, QueryResult, QueryResultRow } from 'pg';
+import { TxnOption } from 'oak-domain/lib/types';
+import { PostgreSQLConfiguration } from './types/Configuration';
+export declare class PostgreSQLConnector {
+    pool: Pool;
+    configuration: PostgreSQLConfiguration;
+    txnDict: Record<string, PoolClient>;
+    constructor(configuration: PostgreSQLConfiguration);
+    connect(): void;
+    disconnect(): Promise<void>;
+    startTransaction(option?: TxnOption): Promise<string>;
+    /**
+     * 映射隔离级别到 PostgreSQL 语法
+     */
+    private mapIsolationLevel;
+    exec(sql: string, txn?: string): Promise<[QueryResultRow[], QueryResult]>;
+    commitTransaction(txn: string): Promise<void>;
+    rollbackTransaction(txn: string): Promise<void>;
+    /**
+     * 获取连接池状态
+     */
+    getPoolStatus(): {
+        total: number;
+        idle: number;
+        waiting: number;
+    };
+}