oak-db 3.3.10 → 3.3.12

package/lib/MySQL/connector.d.ts

@@ -1,15 +1,15 @@
-import mysql, { Pool } from 'mysql2/promise';
-import { TxnOption } from 'oak-domain/lib/types';
-import { MySQLConfiguration } from './types/Configuration';
-export declare class MySqlConnector {
-    pool: Pool;
-    configuration: MySQLConfiguration;
-    txnDict: Record<string, mysql.PoolConnection>;
-    constructor(configuration: MySQLConfiguration);
-    connect(): void;
-    disconnect(): Promise<void>;
-    startTransaction(option?: TxnOption): Promise<string>;
-    exec(sql: string, txn?: string): Promise<[mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket | mysql.OkPacket[] | mysql.ResultSetHeader, mysql.FieldPacket[]]>;
-    commitTransaction(txn: string): Promise<void>;
-    rollbackTransaction(txn: string): Promise<void>;
-}
+import mysql, { Pool } from 'mysql2/promise';
+import { TxnOption } from 'oak-domain/lib/types';
+import { MySQLConfiguration } from './types/Configuration';
+export declare class MySqlConnector {
+    pool: Pool;
+    configuration: MySQLConfiguration;
+    txnDict: Record<string, mysql.PoolConnection>;
+    constructor(configuration: MySQLConfiguration);
+    connect(): void;
+    disconnect(): Promise<void>;
+    startTransaction(option?: TxnOption): Promise<string>;
+    exec(sql: string, txn?: string): Promise<[mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket | mysql.OkPacket[] | mysql.ResultSetHeader, mysql.FieldPacket[]]>;
+    commitTransaction(txn: string): Promise<void>;
+    rollbackTransaction(txn: string): Promise<void>;
+}

package/lib/MySQL/connector.js

@@ -1,77 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlConnector = void 0;
-const tslib_1 = require("tslib");
-const promise_1 = tslib_1.__importDefault(require("mysql2/promise"));
-const uuid_1 = require("uuid");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-class MySqlConnector {
-    pool;
-    configuration;
-    txnDict;
-    constructor(configuration) {
-        this.configuration = configuration;
-        this.txnDict = {};
-        this.pool = promise_1.default.createPool(this.configuration);
-    }
-    connect() {
-    }
-    disconnect() {
-        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()));
-                    });
-                }
-            }
-            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();
-    }
-    async exec(sql, txn) {
-        if (process.env.NODE_ENV === 'development') {
-            // console.log(sql);
-        }
-        if (txn) {
-            const connection = this.txnDict[txn];
-            (0, assert_1.default)(connection);
-            const result = await connection.query(sql);
-            return result;
-        }
-        else {
-            const result = await this.pool.query(sql);
-            return result;
-        }
-    }
-    async commitTransaction(txn) {
-        const connection = this.txnDict[txn];
-        (0, assert_1.default)(connection);
-        delete this.txnDict[txn];
-        // console.log('commit_txn', txn, connection.threadId);
-        await connection.commit();
-        connection.release();
-    }
-    async rollbackTransaction(txn) {
-        const connection = this.txnDict[txn];
-        (0, assert_1.default)(connection);
-        // console.log('rollback_txn', txn, connection.threadId);
-        await connection.rollback();
-        delete this.txnDict[txn];
-        connection.release();
-    }
-}
-exports.MySqlConnector = MySqlConnector;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnector = void 0;
+const tslib_1 = require("tslib");
+const promise_1 = tslib_1.__importDefault(require("mysql2/promise"));
+const uuid_1 = require("uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+class MySqlConnector {
+    pool;
+    configuration;
+    txnDict;
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.txnDict = {};
+        this.pool = promise_1.default.createPool(this.configuration);
+    }
+    connect() {
+    }
+    disconnect() {
+        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()));
+                    });
+                }
+            }
+            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();
+    }
+    async exec(sql, txn) {
+        if (process.env.NODE_ENV === 'development') {
+            // console.log(`${sql}; \n`);
+        }
+        if (txn) {
+            const connection = this.txnDict[txn];
+            (0, assert_1.default)(connection);
+            const result = await connection.query(sql);
+            return result;
+        }
+        else {
+            const result = await this.pool.query(sql);
+            return result;
+        }
+    }
+    async commitTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        delete this.txnDict[txn];
+        // console.log('commit_txn', txn, connection.threadId);
+        await connection.commit();
+        connection.release();
+    }
+    async rollbackTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        // console.log('rollback_txn', txn, connection.threadId);
+        await connection.rollback();
+        delete this.txnDict[txn];
+        connection.release();
+    }
+}
+exports.MySqlConnector = MySqlConnector;

package/lib/MySQL/store.d.ts

@@ -1,13 +1,14 @@
-import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult } from 'oak-domain/lib/types';
+import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult, Attribute, Index } 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';
 import { MySqlConnector } from './connector';
 import { MySqlTranslator, MySqlSelectOption, MysqlOperateOption } from './translator';
-import { AsyncContext, AsyncRowStore } from 'oak-domain/lib/store/AsyncRowStore';
+import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
 import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
 import { CreateEntityOption } from '../types/Translator';
-export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements AsyncRowStore<ED, Cxt> {
+import { DbStore } 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']>;
     protected selectAbjointRow<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: SyncContext<ED>, option: OP): Partial<ED[T]['Schema']>[];
@@ -31,7 +32,32 @@ export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt exte
     begin(option?: TxnOption): Promise<string>;
     commit(txnId: string): Promise<void>;
     rollback(txnId: string): Promise<void>;
-    connect(): void;
+    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;
 }
+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

@@ -209,7 +209,7 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
                     // 边界，如果是toModi的对象，这里的外键确实有可能为空
                     // assert(schema[e].toModi || r[`${attr}Id`] === r[attr].id, `对象${<string>e}取数据时，发现其外键与连接的对象的主键不一致，rowId是${r.id}，其${attr}Id值为${r[`${attr}Id`]}，连接的对象的主键为${r[attr].id}`);
                     if (r[attr].id === null) {
-                        (0, assert_1.default)(schema[e].toModi || r[`${attr}Id`] === null);
+                        (0, assert_1.default)(schema[e].toModi || r[`${attr}Id`] === null, `对象${String(e)}取数据时，发现其外键找不到目标对象，rowId是${r.id}，其外键${attr}Id值为${r[`${attr}Id`]}`);
                         delete r[attr];
                         continue;
                     }
@@ -289,8 +289,8 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
     async rollback(txnId) {
         await this.connector.rollbackTransaction(txnId);
     }
-    connect() {
-        this.connector.connect();
+    async connect() {
+        await this.connector.connect();
     }
     async disconnect() {
         await this.connector.disconnect();
@@ -304,5 +304,127 @@ class MysqlStore extends CascadeStore_1.CascadeStore {
             }
         }
     }
+    // 从数据库中读取当前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) {
+            // mysql数据字典不分大小写的
+            if (schemaOld[table] || schemaOld[table.toLowerCase()]) {
+                const { attributes, indexes } = schemaOld[table] || schemaOld[table.toLowerCase()];
+                const { attributes: attributesNew, indexes: indexesNew } = schemaNew[table];
+                const assignToUpdateTables = (attr, isNew) => {
+                    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]) {
+                        // 因为反向无法复原原来定义的attribute类型，这里就比较两次创建的sql是不是一致。
+                        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';
+                        // parser目前无法从mysql中读出来，所以不比了
+                        return type1 === type2;
+                    };
+                    for (const index of indexesNew) {
+                        const { name, config, attributes } = index;
+                        const origin = indexes?.find(ele => ele.name === name);
+                        if (origin) {
+                            if (JSON.stringify(attributes) !== JSON.stringify(origin.attributes)) {
+                                // todo，这里要细致比较，不能用json.stringify
+                                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.MysqlStore = MysqlStore;

package/lib/MySQL/translator.d.ts

@@ -1,107 +1,114 @@
-import { EntityDict, Q_FullTextValue, RefOrExpression, Ref, 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 { SqlOperateOption, SqlSelectOption, SqlTranslator } from "../sqlTranslator";
-import { CreateEntityOption } from '../types/Translator';
-export interface MySqlSelectOption extends SqlSelectOption {
-}
-export interface MysqlOperateOption extends SqlOperateOption {
-}
-export declare class MySqlTranslator<ED extends EntityDict & BaseEntityDict> extends SqlTranslator<ED> {
-    protected getDefaultSelectFilter(alias: string, option?: MySqlSelectOption): string;
-    private makeUpSchema;
-    constructor(schema: StorageSchema<ED>);
-    static supportedDataTypes: DataType[];
-    static spatialTypes: DataType[];
-    static withLengthDataTypes: DataType[];
-    static withPrecisionDataTypes: DataType[];
-    static withScaleDataTypes: DataType[];
-    static unsignedAndZerofillTypes: DataType[];
-    static withWidthDataTypes: DataType[];
-    static dataTypeDefaults: {
-        varchar: {
-            length: number;
-        };
-        nvarchar: {
-            length: number;
-        };
-        "national varchar": {
-            length: number;
-        };
-        char: {
-            length: number;
-        };
-        binary: {
-            length: number;
-        };
-        varbinary: {
-            length: number;
-        };
-        decimal: {
-            precision: number;
-            scale: number;
-        };
-        dec: {
-            precision: number;
-            scale: number;
-        };
-        numeric: {
-            precision: number;
-            scale: number;
-        };
-        fixed: {
-            precision: number;
-            scale: number;
-        };
-        float: {
-            precision: number;
-        };
-        double: {
-            precision: number;
-        };
-        time: {
-            precision: number;
-        };
-        datetime: {
-            precision: number;
-        };
-        timestamp: {
-            precision: number;
-        };
-        bit: {
-            width: number;
-        };
-        int: {
-            width: number;
-        };
-        integer: {
-            width: number;
-        };
-        tinyint: {
-            width: number;
-        };
-        smallint: {
-            width: number;
-        };
-        mediumint: {
-            width: number;
-        };
-        bigint: {
-            width: number;
-        };
-    };
-    maxAliasLength: number;
-    private populateDataTypeDef;
-    protected translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
-    protected translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
-    protected translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
-    protected translateAttrValue(dataType: DataType | Ref, value: any): string;
-    protected translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
-    translateCreateEntity<T extends keyof ED>(entity: T, options?: CreateEntityOption): string[];
-    private translateFnName;
-    private translateAttrInExpression;
-    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?: MySqlSelectOption): string;
-    protected populateUpdateStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: MysqlOperateOption): string;
-    protected populateRemoveStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: MysqlOperateOption): string;
-}
+import { EntityDict, Q_FullTextValue, RefOrExpression, Ref, StorageSchema, Attribute } 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 { SqlOperateOption, SqlSelectOption, SqlTranslator } from "../sqlTranslator";
+import { CreateEntityOption } from '../types/Translator';
+export interface MySqlSelectOption extends SqlSelectOption {
+}
+export interface MysqlOperateOption extends SqlOperateOption {
+}
+export declare class MySqlTranslator<ED extends EntityDict & BaseEntityDict> extends SqlTranslator<ED> {
+    protected getDefaultSelectFilter(alias: string, option?: MySqlSelectOption): string;
+    private makeUpSchema;
+    constructor(schema: StorageSchema<ED>);
+    static supportedDataTypes: DataType[];
+    static spatialTypes: DataType[];
+    static withLengthDataTypes: DataType[];
+    static withPrecisionDataTypes: DataType[];
+    static withScaleDataTypes: DataType[];
+    static unsignedAndZerofillTypes: DataType[];
+    static withWidthDataTypes: DataType[];
+    static dataTypeDefaults: {
+        varchar: {
+            length: number;
+        };
+        nvarchar: {
+            length: number;
+        };
+        "national varchar": {
+            length: number;
+        };
+        char: {
+            length: number;
+        };
+        binary: {
+            length: number;
+        };
+        varbinary: {
+            length: number;
+        };
+        decimal: {
+            precision: number;
+            scale: number;
+        };
+        dec: {
+            precision: number;
+            scale: number;
+        };
+        numeric: {
+            precision: number;
+            scale: number;
+        };
+        fixed: {
+            precision: number;
+            scale: number;
+        };
+        float: {
+            precision: number;
+        };
+        double: {
+            precision: number;
+        };
+        time: {
+            precision: number;
+        };
+        datetime: {
+            precision: number;
+        };
+        timestamp: {
+            precision: number;
+        };
+        bit: {
+            width: number;
+        };
+        int: {
+            width: number;
+        };
+        integer: {
+            width: number;
+        };
+        tinyint: {
+            width: number;
+        };
+        smallint: {
+            width: number;
+        };
+        mediumint: {
+            width: number;
+        };
+        bigint: {
+            width: number;
+        };
+    };
+    maxAliasLength: number;
+    private populateDataTypeDef;
+    protected translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
+    protected translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
+    protected translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
+    protected translateAttrValue(dataType: DataType | Ref, value: any): string;
+    protected translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
+    translateAttributeDef(attr: string, attrDef: Attribute): string;
+    translateCreateEntity<T extends keyof ED>(entity: T, options?: CreateEntityOption): string[];
+    private translateFnName;
+    private translateAttrInExpression;
+    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?: MySqlSelectOption): string;
+    protected populateUpdateStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: MysqlOperateOption): string;
+    protected populateRemoveStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: MysqlOperateOption): string;
+    /**
+     * 将MySQL返回的Type回译成oak的类型，是 populateDataTypeDef 的反函数
+     * @param type
+     */
+    private reTranslateToAttribute;
+    readSchema(execFn: (sql: string) => Promise<any>): Promise<StorageSchema<ED>>;
+}