oak-db 1.0.0

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+    "extension": ["ts"],
+    "spec": "test/test*.ts",
+    "require": "ts-node/register"
+}

package/README.md

@@ -0,0 +1,37 @@
+### 3 分钟了解如何进入开发
+
+欢迎使用云效 Codeup，通过阅读以下内容，你可以快速熟悉 Codeup ，并立即开始今天的工作。
+
+### 提交**文件**
+
+首先，你需要了解在 Codeup 中如何提交代码文件，跟着文档「[__提交第一行代码__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e7546fd9001aee81fd)」一起操作试试看吧。
+
+### 开启扫描
+
+开发过程中，为了更好的管理你的代码资产，Codeup 内置了「[__代码规约扫描__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e8546fd9001aee821c)」和「[__敏感信息检测__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e8546fd9001aee821b)」服务，你可以在代码库设置-集成与服务中一键开启，开启后提交或合并请求的变更将自动触发扫描，并及时提供结果反馈。
+
+![](https://img.alicdn.com/tfs/TB1nRDatoz1gK0jSZLeXXb9kVXa-1122-380.png "")
+
+![](https://img.alicdn.com/tfs/TB1PrPatXY7gK0jSZKzXXaikpXa-1122-709.png "")
+
+### 代码评审
+
+功能开发完毕后，通常你需要发起「[__代码合并和评审__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e8546fd9001aee8216)」，Codeup 支持多人协作的代码评审服务，你可以通过「[__保护分支__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e9546fd9001aee8221)」策略及「[__合并请求设置__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e9546fd9001aee8224)」对合并过程进行流程化管控，同时提供 WebIDE 在线代码评审及冲突解决能力，让你的评审过程更加流畅。
+
+![](https://img.alicdn.com/tfs/TB1XHrctkP2gK0jSZPxXXacQpXa-1432-887.png "")
+
+![](https://img.alicdn.com/tfs/TB1V3fctoY1gK0jSZFMXXaWcVXa-1432-600.png "")
+
+### 编写文档
+
+项目推进过程中，你的经验和感悟可以直接记录到 Codeup 代码库的「[__文档__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e8546fd9001aee8213)」内，让智慧可视化。
+
+![](https://img.alicdn.com/tfs/TB1BN2ateT2gK0jSZFvXXXnFXXa-1432-700.png "")
+
+### 成员协作
+
+是时候邀请成员一起编写卓越的代码工程了，请点击右上角「成员」邀请你的小伙伴开始协作吧！
+
+### 更多
+
+Git 使用教学、高级功能指引等更多说明，参见[__Codeup帮助文档__](https://thoughts.aliyun.com/sharespace/5e8c37eb546fd9001aee8242/docs/5e8c37e6546fd9001aee81fa)。

package/lib/MySQL/connector.d.ts

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

package/lib/MySQL/connector.js

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnector = void 0;
+var mysql2_1 = __importDefault(require("mysql2"));
+var uuid_1 = require("uuid");
+var assert_1 = __importDefault(require("assert"));
+var MySqlConnector = /** @class */ (function () {
+    function MySqlConnector(configuration) {
+        this.configuration = configuration;
+        this.txnDict = {};
+    }
+    MySqlConnector.prototype.connect = function () {
+        this.pool = mysql2_1.default.createPool(this.configuration);
+    };
+    MySqlConnector.prototype.disconnect = function () {
+        this.pool.end();
+    };
+    MySqlConnector.prototype.startTransaction = function (option) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.pool.getConnection(function (err, connection) {
+                if (err) {
+                    return reject(err);
+                }
+                var isolationLevel = (option || {}).isolationLevel;
+                var startTxn = function () {
+                    var sql = 'START TRANSACTION;';
+                    connection.query(sql, function (err2) {
+                        var _a;
+                        if (err2) {
+                            connection.release();
+                            return reject(err2);
+                        }
+                        var id = (0, uuid_1.v4)();
+                        Object.assign(_this.txnDict, (_a = {},
+                            _a[id] = connection,
+                            _a));
+                        resolve(id);
+                    });
+                };
+                if (isolationLevel) {
+                    connection.query("SET TRANSACTION ISOLATION LEVEL ".concat(isolationLevel, ";"), function (err2) {
+                        if (err2) {
+                            connection.release();
+                            return reject(err2);
+                        }
+                        startTxn();
+                    });
+                }
+                else {
+                    startTxn();
+                }
+            });
+        });
+    };
+    MySqlConnector.prototype.exec = function (sql, txn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connection_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (process.env.NODE_ENV === 'development') {
+                    console.log(sql);
+                }
+                if (txn) {
+                    connection_1 = this.txnDict[txn];
+                    (0, assert_1.default)(connection_1);
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            connection_1.query(sql, function (err, result) {
+                                if (err) {
+                                    console.error("sql exec err: ".concat(sql), err);
+                                    return reject(err);
+                                }
+                                resolve(result);
+                            });
+                        })];
+                }
+                else {
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            // if (process.env.DEBUG) {
+                            //  console.log(sql);
+                            //}
+                            _this.pool.query(sql, function (err, result) {
+                                if (err) {
+                                    console.error("sql exec err: ".concat(sql), err);
+                                    return reject(err);
+                                }
+                                resolve(result);
+                            });
+                        })];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    MySqlConnector.prototype.commitTransaction = function (txn) {
+        var connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        return new Promise(function (resolve, reject) {
+            connection.query('COMMIT;', function (err) {
+                if (err) {
+                    return reject(err);
+                }
+                connection.release();
+                resolve();
+            });
+        });
+    };
+    MySqlConnector.prototype.rollbackTransaction = function (txn) {
+        var connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        return new Promise(function (resolve, reject) {
+            connection.query('ROLLBACK;', function (err) {
+                if (err) {
+                    return reject(err);
+                }
+                connection.release();
+                resolve();
+            });
+        });
+    };
+    return MySqlConnector;
+}());
+exports.MySqlConnector = MySqlConnector;

package/lib/MySQL/store.d.ts

@@ -0,0 +1,24 @@
+import { EntityDict, Context, DeduceCreateSingleOperation, DeduceRemoveOperation, DeduceUpdateOperation, OperateOption, OperationResult, SelectionResult, TxnOption, SelectRowShape, StorageSchema, DeduceCreateMultipleOperation, SelectOption } from 'oak-domain/lib/types';
+import { CascadeStore } from 'oak-domain/lib/store/CascadeStore';
+import { MySQLConfiguration } from './types/Configuration';
+import { MySqlConnector } from './connector';
+import { MySqlTranslator, MySqlSelectOption, MysqlOperateOption } from './translator';
+export declare class MysqlStore<ED extends EntityDict, Cxt extends Context<ED>> extends CascadeStore<ED, Cxt> {
+    connector: MySqlConnector;
+    translator: MySqlTranslator<ED>;
+    constructor(storageSchema: StorageSchema<ED>, configuration: MySQLConfiguration);
+    protected supportManyToOneJoin(): boolean;
+    protected supportMultipleCreate(): boolean;
+    private formResult;
+    protected selectAbjointRow<T extends keyof ED, S extends ED[T]['Selection']>(entity: T, selection: S, context: Cxt, option?: MySqlSelectOption): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]>;
+    protected updateAbjointRow<T extends keyof ED>(entity: T, operation: DeduceCreateMultipleOperation<ED[T]['Schema']> | DeduceCreateSingleOperation<ED[T]['Schema']> | DeduceUpdateOperation<ED[T]['Schema']> | DeduceRemoveOperation<ED[T]['Schema']>, context: Cxt, option?: MysqlOperateOption): Promise<number>;
+    operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, params?: OperateOption): Promise<OperationResult<ED>>;
+    select<T extends keyof ED, S extends ED[T]['Selection']>(entity: T, selection: S, context: Cxt, option?: SelectOption): Promise<SelectionResult<ED[T]['Schema'], S['data']>>;
+    count<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option?: SelectOption): Promise<number>;
+    begin(option?: TxnOption): Promise<string>;
+    commit(txnId: string): Promise<void>;
+    rollback(txnId: string): Promise<void>;
+    connect(): void;
+    disconnect(): void;
+    initialize(dropIfExists?: boolean): Promise<void>;
+}

package/lib/MySQL/store.js

@@ -0,0 +1,412 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlStore = void 0;
+var CascadeStore_1 = require("oak-domain/lib/store/CascadeStore");
+var connector_1 = require("./connector");
+var translator_1 = require("./translator");
+var lodash_1 = require("lodash");
+var assert_1 = __importDefault(require("assert"));
+var relation_1 = require("oak-domain/lib/store/relation");
+function convertGeoTextToObject(geoText) {
+    if (geoText.startsWith('POINT')) {
+        var coord = geoText.match((/(\d|\.)+(?=\)|\s)/g));
+        return {
+            type: 'Point',
+            coordinates: coord.map(function (ele) { return parseFloat(ele); }),
+        };
+    }
+    else {
+        throw new Error('only support Point now');
+    }
+}
+var MysqlStore = /** @class */ (function (_super) {
+    __extends(MysqlStore, _super);
+    function MysqlStore(storageSchema, configuration) {
+        var _this = _super.call(this, storageSchema) || this;
+        _this.connector = new connector_1.MySqlConnector(configuration);
+        _this.translator = new translator_1.MySqlTranslator(storageSchema);
+        return _this;
+    }
+    MysqlStore.prototype.supportManyToOneJoin = function () {
+        return true;
+    };
+    MysqlStore.prototype.supportMultipleCreate = function () {
+        return true;
+    };
+    MysqlStore.prototype.formResult = function (entity, result) {
+        var schema = this.getSchema();
+        function resolveAttribute(entity2, r, attr, value) {
+            var _a;
+            var _b = schema[entity2], attributes = _b.attributes, view = _b.view;
+            if (!view) {
+                var i = attr.indexOf(".");
+                if (i !== -1) {
+                    var attrHead = attr.slice(0, i);
+                    var attrTail = attr.slice(i + 1);
+                    if (!r[attrHead]) {
+                        r[attrHead] = {};
+                    }
+                    var rel = (0, relation_1.judgeRelation)(schema, entity2, attrHead);
+                    (0, assert_1.default)(rel === 2 || typeof rel === 'string');
+                    resolveAttribute(typeof rel === 'string' ? rel : attrHead, r[attrHead], attrTail, value);
+                }
+                else if (attributes[attr]) {
+                    var type = attributes[attr].type;
+                    switch (type) {
+                        case 'date':
+                        case 'time': {
+                            if (value instanceof Date) {
+                                r[attr] = value.valueOf();
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'geometry': {
+                            if (typeof value === 'string') {
+                                r[attr] = convertGeoTextToObject(value);
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'object':
+                        case 'array': {
+                            if (typeof value === 'string') {
+                                r[attr] = JSON.parse(value.replace(/[\r]/g, '\\r').replace(/[\n]/g, '\\n'));
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'function': {
+                            if (typeof value === 'string') {
+                                // 函数的执行环境需要的参数只有创建函数者知悉，只能由上层再创建Function
+                                r[attr] = "return ".concat(Buffer.from(value, 'base64').toString());
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'bool':
+                        case 'boolean': {
+                            if (value === 0) {
+                                r[attr] = false;
+                            }
+                            else if (value === 1) {
+                                r[attr] = true;
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        default: {
+                            r[attr] = value;
+                        }
+                    }
+                }
+                else {
+                    r[attr] = value;
+                }
+            }
+            else {
+                (0, lodash_1.assign)(r, (_a = {},
+                    _a[attr] = value,
+                    _a));
+            }
+        }
+        function formalizeNullObject(r, e) {
+            var a2 = schema[e].attributes;
+            var allowFormalize = true;
+            for (var attr in r) {
+                if (typeof r[attr] === 'object' && a2[attr] && a2[attr].type === 'ref') {
+                    if (formalizeNullObject(r[attr], a2[attr].ref)) {
+                        r[attr] = null;
+                    }
+                    else {
+                        allowFormalize = false;
+                    }
+                }
+                else if (r[attr] !== null) {
+                    allowFormalize = false;
+                }
+            }
+            return allowFormalize;
+        }
+        function formSingleRow(r) {
+            var result2 = {};
+            for (var attr in r) {
+                var value = r[attr];
+                resolveAttribute(entity, result2, attr, value);
+            }
+            formalizeNullObject(result2, entity);
+            return result2;
+        }
+        if (result instanceof Array) {
+            return result.map(function (r) { return formSingleRow(r); });
+        }
+        return formSingleRow(result);
+    };
+    MysqlStore.prototype.selectAbjointRow = function (entity, selection, context, option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sql, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sql = this.translator.translateSelect(entity, selection, option);
+                        return [4 /*yield*/, this.connector.exec(sql, context.getCurrentTxnId())];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, this.formResult(entity, result)];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.updateAbjointRow = function (entity, operation, context, option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, translator, connector, action, txn, _b, data, sql, sql, sql;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this, translator = _a.translator, connector = _a.connector;
+                        action = operation.action;
+                        txn = context.getCurrentTxnId();
+                        _b = action;
+                        switch (_b) {
+                            case 'create': return [3 /*break*/, 1];
+                            case 'remove': return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 5];
+                    case 1:
+                        data = operation.data;
+                        sql = translator.translateInsert(entity, data instanceof Array ? data : [data]);
+                        return [4 /*yield*/, connector.exec(sql, txn)];
+                    case 2:
+                        _c.sent();
+                        if (!(option === null || option === void 0 ? void 0 : option.dontCollect)) {
+                            context.opRecords.push({
+                                a: 'c',
+                                d: data,
+                                e: entity,
+                            });
+                        }
+                        return [2 /*return*/, data instanceof Array ? data.length : 1];
+                    case 3:
+                        sql = translator.translateRemove(entity, operation, option);
+                        return [4 /*yield*/, connector.exec(sql, txn)];
+                    case 4:
+                        _c.sent();
+                        // todo 这里对sorter和indexfrom/count的支持不完整
+                        if (!(option === null || option === void 0 ? void 0 : option.dontCollect)) {
+                            context.opRecords.push({
+                                a: 'r',
+                                e: entity,
+                                f: operation.filter,
+                            });
+                        }
+                        return [2 /*return*/, 1];
+                    case 5:
+                        (0, assert_1.default)(!['select', 'download', 'stat'].includes(action));
+                        sql = translator.translateUpdate(entity, operation, option);
+                        return [4 /*yield*/, connector.exec(sql, txn)];
+                    case 6:
+                        _c.sent();
+                        // todo 这里对sorter和indexfrom/count的支持不完整
+                        if (!(option === null || option === void 0 ? void 0 : option.dontCollect)) {
+                            context.opRecords.push({
+                                a: 'u',
+                                e: entity,
+                                d: operation.data,
+                                f: operation.filter,
+                            });
+                        }
+                        return [2 /*return*/, 1];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.operate = function (entity, operation, context, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var action;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        action = operation.action;
+                        (0, assert_1.default)(!['select', 'download', 'stat'].includes(action), '现在不支持使用select operation');
+                        return [4 /*yield*/, this.cascadeUpdate(entity, operation, context, params)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.select = function (entity, selection, context, option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cascadeSelect(entity, selection, context, option)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                result: result,
+                            }];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.count = function (entity, selection, context, option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sql, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sql = this.translator.translateCount(entity, selection, option);
+                        return [4 /*yield*/, this.connector.exec(sql, context.getCurrentTxnId())];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.count];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.begin = function (option) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txn;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connector.startTransaction(option)];
+                    case 1:
+                        txn = _a.sent();
+                        return [2 /*return*/, txn];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.commit = function (txnId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connector.commitTransaction(txnId)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.rollback = function (txnId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connector.rollbackTransaction(txnId)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MysqlStore.prototype.connect = function () {
+        this.connector.connect();
+    };
+    MysqlStore.prototype.disconnect = function () {
+        this.connector.disconnect();
+    };
+    MysqlStore.prototype.initialize = function (dropIfExists) {
+        return __awaiter(this, void 0, void 0, function () {
+            var schema, _a, _b, _i, entity, sqls, _c, sqls_1, sql;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        schema = this.getSchema();
+                        _a = [];
+                        for (_b in schema)
+                            _a.push(_b);
+                        _i = 0;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                        entity = _a[_i];
+                        sqls = this.translator.translateCreateEntity(entity, { replace: dropIfExists });
+                        _c = 0, sqls_1 = sqls;
+                        _d.label = 2;
+                    case 2:
+                        if (!(_c < sqls_1.length)) return [3 /*break*/, 5];
+                        sql = sqls_1[_c];
+                        return [4 /*yield*/, this.connector.exec(sql)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _c++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return MysqlStore;
+}(CascadeStore_1.CascadeStore));
+exports.MysqlStore = MysqlStore;