oak-db 3.3.10 → 3.3.12

package/lib/MySQL/translator.js

@@ -1,969 +1,1207 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlTranslator = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const util_1 = require("util");
-const lodash_1 = require("lodash");
-const types_1 = require("oak-domain/lib/types");
-const sqlTranslator_1 = require("../sqlTranslator");
-const GeoTypes = [
-    {
-        type: 'point',
-        name: "Point"
-    },
-    {
-        type: 'path',
-        name: "LineString",
-        element: 'point',
-    },
-    {
-        name: "MultiLineString",
-        element: "path",
-        multiple: true,
-    },
-    {
-        type: 'polygon',
-        name: "Polygon",
-        element: "path"
-    },
-    {
-        name: "MultiPoint",
-        element: "point",
-        multiple: true,
-    },
-    {
-        name: "MultiPolygon",
-        element: "polygon",
-        multiple: true,
-    }
-];
-function transformGeoData(data) {
-    if (data instanceof Array) {
-        const element = data[0];
-        if (element instanceof Array) {
-            return ` GeometryCollection(${data.map(ele => transformGeoData(ele)).join(',')})`;
-        }
-        else {
-            const geoType = GeoTypes.find(ele => ele.type === element.type);
-            if (!geoType) {
-                throw new Error(`${element.type} is not supported in MySQL`);
-            }
-            const multiGeoType = GeoTypes.find(ele => ele.element === geoType.type && ele.multiple);
-            return ` ${multiGeoType.name}(${data.map(ele => transformGeoData(ele)).join(',')})`;
-        }
-    }
-    else {
-        const { type, coordinate } = data;
-        const geoType = GeoTypes.find(ele => ele.type === type);
-        if (!geoType) {
-            throw new Error(`${data.type} is not supported in MySQL`);
-        }
-        const { element, name } = geoType;
-        if (!element) {
-            // Point
-            return ` ${name}(${coordinate.join(',')})`;
-        }
-        // Polygon or Linestring
-        return ` ${name}(${coordinate.map((ele) => transformGeoData({
-            type: element,
-            coordinate: ele,
-        }))})`;
-    }
-}
-class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
-    getDefaultSelectFilter(alias, option) {
-        if (option?.includedDeleted) {
-            return '';
-        }
-        return ` (\`${alias}\`.\`$$deleteAt$$\` is null)`;
-    }
-    makeUpSchema() {
-        for (const entity in this.schema) {
-            const { attributes, indexes } = this.schema[entity];
-            const geoIndexes = [];
-            for (const attr in attributes) {
-                if (attributes[attr].type === 'geometry') {
-                    const geoIndex = indexes?.find((idx) => idx.config?.type === 'spatial' && idx.attributes.find((attrDef) => attrDef.name === attr));
-                    if (!geoIndex) {
-                        geoIndexes.push({
-                            name: `${entity}_geo_${attr}`,
-                            attributes: [{
-                                    name: attr,
-                                }],
-                            config: {
-                                type: 'spatial',
-                            }
-                        });
-                    }
-                }
-            }
-            if (geoIndexes.length > 0) {
-                if (indexes) {
-                    indexes.push(...geoIndexes);
-                }
-                else {
-                    (0, lodash_1.assign)(this.schema[entity], {
-                        indexes: geoIndexes,
-                    });
-                }
-            }
-        }
-    }
-    constructor(schema) {
-        super(schema);
-        // MySQL为geometry属性默认创建索引
-        this.makeUpSchema();
-    }
-    static supportedDataTypes = [
-        // numeric types
-        "bit",
-        "int",
-        "integer",
-        "tinyint",
-        "smallint",
-        "mediumint",
-        "bigint",
-        "float",
-        "double",
-        "double precision",
-        "real",
-        "decimal",
-        "dec",
-        "numeric",
-        "fixed",
-        "bool",
-        "boolean",
-        // date and time types
-        "date",
-        "datetime",
-        "timestamp",
-        "time",
-        "year",
-        // string types
-        "char",
-        "nchar",
-        "national char",
-        "varchar",
-        "nvarchar",
-        "national varchar",
-        "blob",
-        "text",
-        "tinyblob",
-        "tinytext",
-        "mediumblob",
-        "mediumtext",
-        "longblob",
-        "longtext",
-        "enum",
-        "set",
-        "binary",
-        "varbinary",
-        // json data type
-        "json",
-        // spatial data types
-        "geometry",
-        "point",
-        "linestring",
-        "polygon",
-        "multipoint",
-        "multilinestring",
-        "multipolygon",
-        "geometrycollection"
-    ];
-    static spatialTypes = [
-        "geometry",
-        "point",
-        "linestring",
-        "polygon",
-        "multipoint",
-        "multilinestring",
-        "multipolygon",
-        "geometrycollection"
-    ];
-    static withLengthDataTypes = [
-        "char",
-        "varchar",
-        "nvarchar",
-        "binary",
-        "varbinary"
-    ];
-    static withPrecisionDataTypes = [
-        "decimal",
-        "dec",
-        "numeric",
-        "fixed",
-        "float",
-        "double",
-        "double precision",
-        "real",
-        "time",
-        "datetime",
-        "timestamp"
-    ];
-    static withScaleDataTypes = [
-        "decimal",
-        "dec",
-        "numeric",
-        "fixed",
-        "float",
-        "double",
-        "double precision",
-        "real"
-    ];
-    static unsignedAndZerofillTypes = [
-        "int",
-        "integer",
-        "smallint",
-        "tinyint",
-        "mediumint",
-        "bigint",
-        "decimal",
-        "dec",
-        "numeric",
-        "fixed",
-        "float",
-        "double",
-        "double precision",
-        "real"
-    ];
-    static withWidthDataTypes = [
-        'int',
-    ];
-    static dataTypeDefaults = {
-        "varchar": { length: 255 },
-        "nvarchar": { length: 255 },
-        "national varchar": { length: 255 },
-        "char": { length: 1 },
-        "binary": { length: 1 },
-        "varbinary": { length: 255 },
-        "decimal": { precision: 10, scale: 0 },
-        "dec": { precision: 10, scale: 0 },
-        "numeric": { precision: 10, scale: 0 },
-        "fixed": { precision: 10, scale: 0 },
-        "float": { precision: 12 },
-        "double": { precision: 22 },
-        "time": { precision: 0 },
-        "datetime": { precision: 0 },
-        "timestamp": { precision: 0 },
-        "bit": { width: 1 },
-        "int": { width: 11 },
-        "integer": { width: 11 },
-        "tinyint": { width: 4 },
-        "smallint": { width: 6 },
-        "mediumint": { width: 9 },
-        "bigint": { width: 20 }
-    };
-    maxAliasLength = 63;
-    populateDataTypeDef(type, params, enumeration) {
-        if (['date', 'datetime', 'time', 'sequence'].includes(type)) {
-            return 'bigint ';
-        }
-        if (['object', 'array'].includes(type)) {
-            return 'json ';
-        }
-        if (['image', 'function'].includes(type)) {
-            return 'text ';
-        }
-        if (type === 'ref') {
-            return 'char(36)';
-        }
-        if (type === 'money') {
-            return 'bigint';
-        }
-        if (type === 'enum') {
-            (0, assert_1.default)(enumeration);
-            return `enum(${enumeration.map(ele => `'${ele}'`).join(',')})`;
-        }
-        if (MySqlTranslator.withLengthDataTypes.includes(type)) {
-            if (params) {
-                const { length } = params;
-                return `${type}(${length}) `;
-            }
-            else {
-                const { length } = MySqlTranslator.dataTypeDefaults[type];
-                return `${type}(${length}) `;
-            }
-        }
-        if (MySqlTranslator.withPrecisionDataTypes.includes(type)) {
-            if (params) {
-                const { precision, scale } = params;
-                if (typeof scale === 'number') {
-                    return `${type}(${precision}, ${scale}) `;
-                }
-                return `${type}(${precision})`;
-            }
-            else {
-                const { precision, scale } = MySqlTranslator.dataTypeDefaults[type];
-                if (typeof scale === 'number') {
-                    return `${type}(${precision}, ${scale}) `;
-                }
-                return `${type}(${precision})`;
-            }
-        }
-        if (MySqlTranslator.withWidthDataTypes.includes(type)) {
-            (0, assert_1.default)(type === 'int');
-            const { width } = params;
-            switch (width) {
-                case 1: {
-                    return 'tinyint';
-                }
-                case 2: {
-                    return 'smallint';
-                }
-                case 3: {
-                    return 'mediumint';
-                }
-                case 4: {
-                    return 'int';
-                }
-                default: {
-                    return 'bigint';
-                }
-            }
-        }
-        return `${type} `;
-    }
-    translateAttrProjection(dataType, alias, attr) {
-        switch (dataType) {
-            case 'geometry': {
-                return ` st_astext(\`${alias}\`.\`${attr}\`)`;
-            }
-            default: {
-                return ` \`${alias}\`.\`${attr}\``;
-            }
-        }
-    }
-    translateObjectPredicate(predicate, alias, attr) {
-        const translateInner = (o, p) => {
-            let stmt2 = '';
-            if (o instanceof Array) {
-                o.forEach((ele, idx) => {
-                    if (ele !== undefined && ele !== null) {
-                        const part = translateInner(ele, `${p}[${idx}]`);
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        stmt2 += `${part}`;
-                    }
-                });
-            }
-            else if (typeof o === 'object') {
-                for (const attr2 in o) {
-                    if (attr2 === '$and') {
-                        o[attr2].forEach((ele) => {
-                            const part = translateInner(ele, p);
-                            if (stmt2) {
-                                stmt2 += ' and ';
-                            }
-                            stmt2 += `${part}`;
-                        });
-                    }
-                    else if (attr2 === '$or') {
-                        let stmtOr = '';
-                        o[attr2].forEach((ele) => {
-                            const part = translateInner(ele, p);
-                            if (stmtOr) {
-                                stmtOr += ' or ';
-                            }
-                            stmtOr += `${part}`;
-                        });
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        stmt2 += `(${stmtOr})`;
-                    }
-                    else if (attr2 === '$contains') {
-                        // json_contains，多值的包含关系
-                        const value = JSON.stringify(o[attr2]);
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        if (p) {
-                            stmt2 += `(JSON_CONTAINS(${alias}.${attr}->>"$${p}", CAST('${value}' AS JSON)))`;
-                        }
-                        else {
-                            stmt2 += `(JSON_CONTAINS(${alias}.${attr}, CAST('${value}' AS JSON)))`;
-                        }
-                    }
-                    else if (attr2 === '$overlaps') {
-                        // json_overlaps，多值的交叉关系
-                        const value = JSON.stringify(o[attr2]);
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        if (p) {
-                            stmt2 += `(JSON_OVERLAPS(${alias}.${attr}->>"$${p}", CAST('${value}' AS JSON)))`;
-                        }
-                        else {
-                            stmt2 += `(JSON_OVERLAPS(${alias}.${attr}, CAST('${value}' AS JSON)))`;
-                        }
-                    }
-                    else if (attr2 === '$length') {
-                        // json length
-                        const length = o[attr2];
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        if (typeof length === 'number') {
-                            if (p) {
-                                stmt2 += `(JSON_LENGTH(${alias}.${attr}->>"$${p}") = ${length})`;
-                            }
-                            else {
-                                stmt2 += `(JSON_LENGTH(${alias}.${attr}) = ${length})`;
-                            }
-                        }
-                        else {
-                            (0, assert_1.default)(typeof length === 'object');
-                            const op = Object.keys(length)[0];
-                            (0, assert_1.default)(op.startsWith('$'));
-                            if (p) {
-                                stmt2 += `(JSON_LENGTH(${alias}.${attr}->>"$${p}") ${this.translatePredicate(op, length[op])})`;
-                            }
-                            else {
-                                stmt2 += `(JSON_LENGTH(${alias}.${attr}) ${this.translatePredicate(op, length[op])})`;
-                            }
-                        }
-                    }
-                    else if (attr2.startsWith('$')) {
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        if (p) {
-                            stmt2 += `(${alias}.${attr}->>"$${p}" ${this.translatePredicate(attr2, o[attr2])})`;
-                        }
-                        else {
-                            stmt2 += `(${alias}.${attr} ${this.translatePredicate(attr2, o[attr2])})`;
-                        }
-                    }
-                    else {
-                        // 继续子对象解构
-                        const attr3 = attr2.startsWith('.') ? attr2.slice(1) : attr2;
-                        const part = translateInner(o[attr2], `${p}.${attr3}`);
-                        if (stmt2) {
-                            stmt2 += ' and ';
-                        }
-                        stmt2 += `${part}`;
-                    }
-                }
-            }
-            else {
-                // 直接的属性处理
-                if (stmt2) {
-                    stmt2 += ' and ';
-                }
-                if (typeof o === 'string') {
-                    if (p) {
-                        stmt2 += `(${alias}.${attr}->>"$${p}" = '${o}')`;
-                    }
-                    else {
-                        //  对根对象的字符串比较
-                        stmt2 += `(${alias}.${attr} = '${o}')`;
-                    }
-                }
-                else {
-                    (0, assert_1.default)(p);
-                    stmt2 += `(${alias}.${attr}->>"$${p}" = ${o})`;
-                }
-            }
-            return stmt2;
-        };
-        return translateInner(predicate, '');
-    }
-    translateObjectProjection(projection, alias, attr, prefix) {
-        let stmt = '';
-        const translateInner = (o, p) => {
-            if (o instanceof Array) {
-                o.forEach((item, idx) => {
-                    const p2 = `${p}[${idx}]`;
-                    if (typeof item === 'number') {
-                        if (stmt) {
-                            stmt += ', ';
-                        }
-                        stmt += `${alias}.${attr}->>"$${p2}"`;
-                        stmt += prefix ? ` as \`${prefix}.${attr}${p2}\`` : ` as \`${attr}${p2}\``;
-                    }
-                    else if (typeof item === 'object') {
-                        translateInner(item, p2);
-                    }
-                });
-            }
-            else {
-                for (const key in o) {
-                    const p2 = `${p}.${key}`;
-                    if (typeof o[key] === 'number') {
-                        if (stmt) {
-                            stmt += ', ';
-                        }
-                        stmt += `${alias}.${attr}->>"$${p2}"`;
-                        stmt += prefix ? ` as \`${prefix}.${attr}${p2}\`` : ` as \`${attr}${p2}\``;
-                    }
-                    else {
-                        translateInner(o[key], p2);
-                    }
-                }
-            }
-        };
-        translateInner(projection, '');
-        return stmt;
-    }
-    translateAttrValue(dataType, value) {
-        if (value === null || value === undefined) {
-            return 'null';
-        }
-        switch (dataType) {
-            case 'geometry': {
-                return transformGeoData(value);
-            }
-            case 'datetime':
-            case 'time':
-            case 'date': {
-                if (value instanceof Date) {
-                    return `${value.valueOf()}`;
-                }
-                else if (typeof value === 'number') {
-                    return `${value}`;
-                }
-                return `'${(new Date(value)).valueOf()}'`;
-            }
-            case 'object':
-            case 'array': {
-                return this.escapeStringValue(JSON.stringify(value));
-            }
-            /* case 'function': {
-                return `'${Buffer.from(value.toString()).toString('base64')}'`;
-            } */
-            default: {
-                if (typeof value === 'string') {
-                    return this.escapeStringValue(value);
-                }
-                return value;
-            }
-        }
-    }
-    translateFullTextSearch(value, entity, alias) {
-        const { $search } = value;
-        const { indexes } = this.schema[entity];
-        const ftIndex = indexes && indexes.find((ele) => {
-            const { config } = ele;
-            return config && config.type === 'fulltext';
-        });
-        (0, assert_1.default)(ftIndex);
-        const { attributes } = ftIndex;
-        const columns2 = attributes.map(({ name }) => `${alias}.${name}`);
-        return ` match(${columns2.join(',')}) against ('${$search}' in natural language mode)`;
-    }
-    translateCreateEntity(entity, options) {
-        const ifExists = options?.ifExists;
-        const { schema } = this;
-        const entityDef = schema[entity];
-        const { storageName, attributes, indexes, view, static: _static } = entityDef;
-        let hasSequence = false;
-        // todo view暂还不支持
-        const entityType = view ? 'view' : 'table';
-        let sql = `create ${entityType} `;
-        if (ifExists === 'omit' || (_static && ifExists === 'dropIfNotStatic')) {
-            sql += ' if not exists';
-        }
-        if (storageName) {
-            sql += `\`${storageName}\` `;
-        }
-        else {
-            sql += `\`${entity}\` `;
-        }
-        if (view) {
-            throw new Error(' view unsupported yet');
-        }
-        else {
-            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)}`;
-                }
-                if (attr === 'id') {
-                    sql += ' primary key';
-                }
-                if (idx < Object.keys(attributes).length - 1) {
-                    sql += ',\n';
-                }
-            });
-            // 翻译索引信息
-            if (indexes) {
-                sql += ',\n';
-                indexes.forEach(({ name, attributes, config }, idx) => {
-                    const { unique, type, parser } = config || {};
-                    // 因为有deleteAt的存在，这里的unique没意义，只能框架自己去建立checker来处理
-                    /* if (unique) {
-                        sql += ' unique ';
-                    }
-                    else */ if (type === 'fulltext') {
-                        sql += ' fulltext ';
-                    }
-                    else if (type === 'spatial') {
-                        sql += ' spatial ';
-                    }
-                    sql += `index ${name} `;
-                    if (type === 'hash') {
-                        sql += ` using hash `;
-                    }
-                    sql += '(';
-                    let includeDeleteAt = false;
-                    attributes.forEach(({ name, size, direction }, idx2) => {
-                        sql += `\`${name}\``;
-                        if (size) {
-                            sql += ` (${size})`;
-                        }
-                        if (direction) {
-                            sql += ` ${direction}`;
-                        }
-                        if (idx2 < attributes.length - 1) {
-                            sql += ',';
-                        }
-                        if (name === '$$deleteAt$$') {
-                            includeDeleteAt = true;
-                        }
-                    });
-                    if (!includeDeleteAt && !type) {
-                        sql += ', `$$deleteAt$$`'; // 在mysql80+之后，需要给属性加上``包裹，否则会报错
-                    }
-                    sql += ')';
-                    if (parser) {
-                        sql += ` with parser ${parser}`;
-                    }
-                    if (idx < indexes.length - 1) {
-                        sql += ',\n';
-                    }
-                });
-            }
-        }
-        sql += ')';
-        if (typeof hasSequence === 'number') {
-            sql += `auto_increment = ${hasSequence}`;
-        }
-        if (ifExists === 'drop' || (!_static && ifExists === 'dropIfNotStatic')) {
-            return [`drop ${entityType}  if exists \`${storageName || entity}\`;`, sql];
-        }
-        return [sql];
-    }
-    translateFnName(fnName, argumentNumber) {
-        switch (fnName) {
-            case '$add': {
-                let result = '%s';
-                while (--argumentNumber > 0) {
-                    result += ' + %s';
-                }
-                return result;
-            }
-            case '$subtract': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s - %s';
-            }
-            case '$multiply': {
-                let result = '%s';
-                while (--argumentNumber > 0) {
-                    result += ' * %s';
-                }
-                return result;
-            }
-            case '$divide': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s / %s';
-            }
-            case '$abs': {
-                return 'ABS(%s)';
-            }
-            case '$round': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return 'ROUND(%s, %s)';
-            }
-            case '$ceil': {
-                return 'CEIL(%s)';
-            }
-            case '$floor': {
-                return 'FLOOR(%s)';
-            }
-            case '$mod': {
-                return 'MOD(%s, %s)';
-            }
-            case '$pow': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return 'POW(%s, %s)';
-            }
-            case '$gt': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s > %s';
-            }
-            case '$gte': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s >= %s';
-            }
-            case '$lt': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s < %s';
-            }
-            case '$lte': {
-                return '%s <= %s';
-            }
-            case '$eq': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s = %s';
-            }
-            case '$ne': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s <> %s';
-            }
-            case '$startsWith': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s like CONCAT(%s, \'%\')';
-            }
-            case '$endsWith': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s like CONCAT(\'%\', %s)';
-            }
-            case '$includes': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return '%s like CONCAT(\'%\', %s, \'%\')';
-            }
-            case '$true': {
-                return '%s = true';
-            }
-            case '$false': {
-                return '%s = false';
-            }
-            case '$and': {
-                let result = '';
-                for (let iter = 0; iter < argumentNumber; iter++) {
-                    result += '%s';
-                    if (iter < argumentNumber - 1) {
-                        result += ' and ';
-                    }
-                }
-                return result;
-            }
-            case '$or': {
-                let result = '';
-                for (let iter = 0; iter < argumentNumber; iter++) {
-                    result += '%s';
-                    if (iter < argumentNumber - 1) {
-                        result += ' or ';
-                    }
-                }
-                return result;
-            }
-            case '$not': {
-                return 'not %s';
-            }
-            case '$year': {
-                return 'YEAR(%s)';
-            }
-            case '$month': {
-                return 'MONTH(%s)';
-            }
-            case '$weekday': {
-                return 'WEEKDAY(%s)';
-            }
-            case '$weekOfYear': {
-                return 'WEEKOFYEAR(%s)';
-            }
-            case '$day': {
-                return 'DAY(%s)';
-            }
-            case '$dayOfMonth': {
-                return 'DAYOFMONTH(%s)';
-            }
-            case '$dayOfWeek': {
-                return 'DAYOFWEEK(%s)';
-            }
-            case '$dayOfYear': {
-                return 'DAYOFYEAR(%s)';
-            }
-            case '$dateDiff': {
-                (0, assert_1.default)(argumentNumber === 3);
-                return 'DATEDIFF(%s, %s, %s)';
-            }
-            case '$contains': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return 'ST_CONTAINS(%s, %s)';
-            }
-            case '$distance': {
-                (0, assert_1.default)(argumentNumber === 2);
-                return 'ST_DISTANCE(%s, %s)';
-            }
-            case '$concat': {
-                let result = ' concat(%s';
-                while (--argumentNumber > 0) {
-                    result += ', %s';
-                }
-                result += ')';
-                return result;
-            }
-            default: {
-                throw new Error(`unrecoganized function ${fnName}`);
-            }
-        }
-    }
-    translateAttrInExpression(entity, attr, exprText) {
-        const { attributes } = this.schema[entity];
-        const { type } = attributes[attr];
-        if (['date', 'time', 'datetime'].includes(type)) {
-            // 从unix时间戵转成date类型参加expr的运算
-            return `from_unixtime(${exprText} / 1000)`;
-        }
-        return exprText;
-    }
-    translateExpression(entity, alias, expression, refDict) {
-        const translateConstant = (constant) => {
-            if (constant instanceof Date) {
-                return ` from_unixtime(${constant.valueOf()}/1000)`;
-            }
-            else if (typeof constant === 'string') {
-                return ` '${constant}'`;
-            }
-            else {
-                (0, assert_1.default)(typeof constant === 'number');
-                return ` ${constant}`;
-            }
-        };
-        const translateInner = (expr) => {
-            const k = Object.keys(expr);
-            let result;
-            if (k.includes('#attr')) {
-                const attrText = `\`${alias}\`.\`${(expr)['#attr']}\``;
-                result = this.translateAttrInExpression(entity, (expr)['#attr'], attrText);
-            }
-            else if (k.includes('#refId')) {
-                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);
-            }
-            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 args = [fnName];
-                    args.push(...(expr)[k[0]].map((ele) => {
-                        if (['string', 'number'].includes(typeof ele) || ele instanceof Date) {
-                            return translateConstant(ele);
-                        }
-                        else {
-                            return translateInner(ele);
-                        }
-                    }));
-                    result = util_1.format.apply(null, args);
-                }
-                else {
-                    const fnName = this.translateFnName(k[0], 1);
-                    const args = [fnName];
-                    const arg = (expr)[k[0]];
-                    if (['string', 'number'].includes(typeof arg) || arg instanceof Date) {
-                        args.push(translateConstant(arg));
-                    }
-                    else {
-                        args.push(translateInner(arg));
-                    }
-                    result = util_1.format.apply(null, args);
-                }
-            }
-            return result;
-        };
-        return translateInner(expression);
-    }
-    populateSelectStmt(projectionText, fromText, aliasDict, filterText, sorterText, groupByText, indexFrom, count, option) {
-        // todo hint of use index
-        let sql = `select ${projectionText} from ${fromText}`;
-        if (filterText) {
-            sql += ` where ${filterText}`;
-        }
-        if (sorterText) {
-            sql += ` order by ${sorterText}`;
-        }
-        if (groupByText) {
-            sql += ` group by ${groupByText}`;
-        }
-        if (typeof indexFrom === 'number') {
-            (0, assert_1.default)(typeof count === 'number');
-            sql += ` limit ${indexFrom}, ${count}`;
-        }
-        if (option?.forUpdate) {
-            sql += ' for update';
-            if (typeof option?.forUpdate === 'string') {
-                sql += ` ${option.forUpdate}`;
-            }
-        }
-        return sql;
-    }
-    populateUpdateStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
-        // todo using index
-        (0, assert_1.default)(updateText);
-        let sql = `update ${fromText} set ${updateText}`;
-        if (filterText) {
-            sql += ` where ${filterText}`;
-        }
-        if (sorterText) {
-            sql += ` order by ${sorterText}`;
-        }
-        if (typeof indexFrom === 'number') {
-            (0, assert_1.default)(typeof count === 'number');
-            sql += ` limit ${indexFrom}, ${count}`;
-        }
-        return sql;
-    }
-    populateRemoveStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
-        // todo using index
-        const alias = aliasDict['./'];
-        if (option?.deletePhysically) {
-            // assert(!updateText, 'physically delete does not support setting trigger data');
-            let sql = `delete ${alias} from ${fromText} `;
-            if (filterText) {
-                sql += ` where ${filterText}`;
-            }
-            if (sorterText) {
-                sql += ` order by ${sorterText}`;
-            }
-            if (typeof indexFrom === 'number') {
-                (0, assert_1.default)(typeof count === 'number');
-                sql += ` limit ${indexFrom}, ${count}`;
-            }
-            return sql;
-        }
-        // 新的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}`;
-        if (filterText) {
-            sql += ` where ${filterText}`;
-        }
-        if (sorterText) {
-            sql += ` order by ${sorterText}`;
-        }
-        if (typeof indexFrom === 'number') {
-            (0, assert_1.default)(typeof count === 'number');
-            sql += ` limit ${indexFrom}, ${count}`;
-        }
-        return sql;
-    }
-}
-exports.MySqlTranslator = MySqlTranslator;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlTranslator = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const util_1 = require("util");
+const lodash_1 = require("lodash");
+const types_1 = require("oak-domain/lib/types");
+const sqlTranslator_1 = require("../sqlTranslator");
+const GeoTypes = [
+    {
+        type: 'point',
+        name: "Point"
+    },
+    {
+        type: 'path',
+        name: "LineString",
+        element: 'point',
+    },
+    {
+        name: "MultiLineString",
+        element: "path",
+        multiple: true,
+    },
+    {
+        type: 'polygon',
+        name: "Polygon",
+        element: "path"
+    },
+    {
+        name: "MultiPoint",
+        element: "point",
+        multiple: true,
+    },
+    {
+        name: "MultiPolygon",
+        element: "polygon",
+        multiple: true,
+    }
+];
+function transformGeoData(data) {
+    if (data instanceof Array) {
+        const element = data[0];
+        if (element instanceof Array) {
+            return ` GeometryCollection(${data.map(ele => transformGeoData(ele)).join(',')})`;
+        }
+        else {
+            const geoType = GeoTypes.find(ele => ele.type === element.type);
+            if (!geoType) {
+                throw new Error(`${element.type} is not supported in MySQL`);
+            }
+            const multiGeoType = GeoTypes.find(ele => ele.element === geoType.type && ele.multiple);
+            return ` ${multiGeoType.name}(${data.map(ele => transformGeoData(ele)).join(',')})`;
+        }
+    }
+    else {
+        const { type, coordinate } = data;
+        const geoType = GeoTypes.find(ele => ele.type === type);
+        if (!geoType) {
+            throw new Error(`${data.type} is not supported in MySQL`);
+        }
+        const { element, name } = geoType;
+        if (!element) {
+            // Point
+            return ` ${name}(${coordinate.join(',')})`;
+        }
+        // Polygon or Linestring
+        return ` ${name}(${coordinate.map((ele) => transformGeoData({
+            type: element,
+            coordinate: ele,
+        }))})`;
+    }
+}
+class MySqlTranslator extends sqlTranslator_1.SqlTranslator {
+    getDefaultSelectFilter(alias, option) {
+        if (option?.includedDeleted) {
+            return '';
+        }
+        return ` (\`${alias}\`.\`$$deleteAt$$\` is null)`;
+    }
+    makeUpSchema() {
+        for (const entity in this.schema) {
+            const { attributes, indexes } = this.schema[entity];
+            const geoIndexes = [];
+            for (const attr in attributes) {
+                if (attributes[attr].type === 'geometry') {
+                    const geoIndex = indexes?.find((idx) => idx.config?.type === 'spatial' && idx.attributes.find((attrDef) => attrDef.name === attr));
+                    if (!geoIndex) {
+                        geoIndexes.push({
+                            name: `${entity}_geo_${attr}`,
+                            attributes: [{
+                                    name: attr,
+                                }],
+                            config: {
+                                type: 'spatial',
+                            }
+                        });
+                    }
+                }
+            }
+            if (geoIndexes.length > 0) {
+                if (indexes) {
+                    indexes.push(...geoIndexes);
+                }
+                else {
+                    (0, lodash_1.assign)(this.schema[entity], {
+                        indexes: geoIndexes,
+                    });
+                }
+            }
+        }
+    }
+    constructor(schema) {
+        super(schema);
+        // MySQL为geometry属性默认创建索引
+        this.makeUpSchema();
+    }
+    static supportedDataTypes = [
+        // numeric types
+        "bit",
+        "int",
+        "integer", // synonym for int
+        "tinyint",
+        "smallint",
+        "mediumint",
+        "bigint",
+        "float",
+        "double",
+        "double precision", // synonym for double
+        "real", // synonym for double
+        "decimal",
+        "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",
+        "timestamp",
+        "time",
+        "year",
+        // string types
+        "char",
+        "nchar", // synonym for national char
+        "national char",
+        "varchar",
+        "nvarchar", // synonym for national varchar
+        "national varchar",
+        "blob",
+        "text",
+        "tinyblob",
+        "tinytext",
+        "mediumblob",
+        "mediumtext",
+        "longblob",
+        "longtext",
+        "enum",
+        "set",
+        "binary",
+        "varbinary",
+        // json data type
+        "json",
+        // spatial data types
+        "geometry",
+        "point",
+        "linestring",
+        "polygon",
+        "multipoint",
+        "multilinestring",
+        "multipolygon",
+        "geometrycollection"
+    ];
+    static spatialTypes = [
+        "geometry",
+        "point",
+        "linestring",
+        "polygon",
+        "multipoint",
+        "multilinestring",
+        "multipolygon",
+        "geometrycollection"
+    ];
+    static withLengthDataTypes = [
+        "char",
+        "varchar",
+        "nvarchar",
+        "binary",
+        "varbinary"
+    ];
+    static withPrecisionDataTypes = [
+        "decimal",
+        "dec",
+        "numeric",
+        "fixed",
+        "float",
+        "double",
+        "double precision",
+        "real",
+        "time",
+        "datetime",
+        "timestamp"
+    ];
+    static withScaleDataTypes = [
+        "decimal",
+        "dec",
+        "numeric",
+        "fixed",
+        "float",
+        "double",
+        "double precision",
+        "real"
+    ];
+    static unsignedAndZerofillTypes = [
+        "int",
+        "integer",
+        "smallint",
+        "tinyint",
+        "mediumint",
+        "bigint",
+        "decimal",
+        "dec",
+        "numeric",
+        "fixed",
+        "float",
+        "double",
+        "double precision",
+        "real"
+    ];
+    static withWidthDataTypes = [
+        'int',
+    ];
+    static dataTypeDefaults = {
+        "varchar": { length: 255 },
+        "nvarchar": { length: 255 },
+        "national varchar": { length: 255 },
+        "char": { length: 1 },
+        "binary": { length: 1 },
+        "varbinary": { length: 255 },
+        "decimal": { precision: 10, scale: 0 },
+        "dec": { precision: 10, scale: 0 },
+        "numeric": { precision: 10, scale: 0 },
+        "fixed": { precision: 10, scale: 0 },
+        "float": { precision: 12 },
+        "double": { precision: 22 },
+        "time": { precision: 0 },
+        "datetime": { precision: 0 },
+        "timestamp": { precision: 0 },
+        "bit": { width: 1 },
+        "int": { width: 11 },
+        "integer": { width: 11 },
+        "tinyint": { width: 4 },
+        "smallint": { width: 6 },
+        "mediumint": { width: 9 },
+        "bigint": { width: 20 }
+    };
+    maxAliasLength = 63;
+    populateDataTypeDef(type, params, enumeration) {
+        if (['date', 'datetime', 'time', 'sequence'].includes(type)) {
+            return 'bigint ';
+        }
+        if (['object', 'array'].includes(type)) {
+            return 'json ';
+        }
+        if (['image', 'function'].includes(type)) {
+            return 'text ';
+        }
+        if (type === 'ref') {
+            return 'char(36) ';
+        }
+        if (['bool', 'boolean'].includes(type)) {
+            // MySQL读出来就是tinyint(1)
+            return 'tinyint(1) ';
+        }
+        if (type === 'money') {
+            return 'bigint ';
+        }
+        if (type === 'enum') {
+            (0, assert_1.default)(enumeration);
+            return `enum(${enumeration.map(ele => `'${ele}'`).join(',')}) `;
+        }
+        if (MySqlTranslator.withLengthDataTypes.includes(type)) {
+            if (params) {
+                const { length } = params;
+                return `${type}(${length}) `;
+            }
+            else {
+                const { length } = MySqlTranslator.dataTypeDefaults[type];
+                return `${type}(${length}) `;
+            }
+        }
+        if (MySqlTranslator.withPrecisionDataTypes.includes(type)) {
+            if (params) {
+                const { precision, scale } = params;
+                if (typeof scale === 'number') {
+                    return `${type}(${precision}, ${scale}) `;
+                }
+                return `${type}(${precision}) `;
+            }
+            else {
+                const { precision, scale } = MySqlTranslator.dataTypeDefaults[type];
+                if (typeof scale === 'number') {
+                    return `${type}(${precision}, ${scale}) `;
+                }
+                return `${type}(${precision}) `;
+            }
+        }
+        if (MySqlTranslator.withWidthDataTypes.includes(type)) {
+            (0, assert_1.default)(type === 'int');
+            const { width } = params || { width: 4 };
+            switch (width) {
+                case 1: {
+                    return 'tinyint ';
+                }
+                case 2: {
+                    return 'smallint ';
+                }
+                case 3: {
+                    return 'mediumint ';
+                }
+                case 4: {
+                    return 'int ';
+                }
+                default: {
+                    return 'bigint ';
+                }
+            }
+        }
+        return `${type} `;
+    }
+    translateAttrProjection(dataType, alias, attr) {
+        switch (dataType) {
+            case 'geometry': {
+                return ` st_astext(\`${alias}\`.\`${attr}\`)`;
+            }
+            default: {
+                return ` \`${alias}\`.\`${attr}\``;
+            }
+        }
+    }
+    translateObjectPredicate(predicate, alias, attr) {
+        const translateInner = (o, p) => {
+            let stmt2 = '';
+            if (o instanceof Array) {
+                o.forEach((ele, idx) => {
+                    if (ele !== undefined && ele !== null) {
+                        const part = translateInner(ele, `${p}[${idx}]`);
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        stmt2 += `${part}`;
+                    }
+                });
+            }
+            else if (typeof o === 'object') {
+                for (const attr2 in o) {
+                    if (attr2 === '$and') {
+                        o[attr2].forEach((ele) => {
+                            const part = translateInner(ele, p);
+                            if (stmt2) {
+                                stmt2 += ' and ';
+                            }
+                            stmt2 += `${part}`;
+                        });
+                    }
+                    else if (attr2 === '$or') {
+                        let stmtOr = '';
+                        o[attr2].forEach((ele) => {
+                            const part = translateInner(ele, p);
+                            if (stmtOr) {
+                                stmtOr += ' or ';
+                            }
+                            stmtOr += `${part}`;
+                        });
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        stmt2 += `(${stmtOr})`;
+                    }
+                    else if (attr2 === '$contains') {
+                        // json_contains，多值的包含关系
+                        const value = JSON.stringify(o[attr2]);
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        if (p) {
+                            stmt2 += `(JSON_CONTAINS(${alias}.${attr}->>"$${p}", CAST('${value}' AS JSON)))`;
+                        }
+                        else {
+                            stmt2 += `(JSON_CONTAINS(${alias}.${attr}, CAST('${value}' AS JSON)))`;
+                        }
+                    }
+                    else if (attr2 === '$overlaps') {
+                        // json_overlaps，多值的交叉关系
+                        const value = JSON.stringify(o[attr2]);
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        if (p) {
+                            stmt2 += `(JSON_OVERLAPS(${alias}.${attr}->>"$${p}", CAST('${value}' AS JSON)))`;
+                        }
+                        else {
+                            stmt2 += `(JSON_OVERLAPS(${alias}.${attr}, CAST('${value}' AS JSON)))`;
+                        }
+                    }
+                    else if (attr2 === '$length') {
+                        // json length
+                        const length = o[attr2];
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        if (typeof length === 'number') {
+                            if (p) {
+                                stmt2 += `(JSON_LENGTH(${alias}.${attr}->>"$${p}") = ${length})`;
+                            }
+                            else {
+                                stmt2 += `(JSON_LENGTH(${alias}.${attr}) = ${length})`;
+                            }
+                        }
+                        else {
+                            (0, assert_1.default)(typeof length === 'object');
+                            const op = Object.keys(length)[0];
+                            (0, assert_1.default)(op.startsWith('$'));
+                            if (p) {
+                                stmt2 += `(JSON_LENGTH(${alias}.${attr}->>"$${p}") ${this.translatePredicate(op, length[op])})`;
+                            }
+                            else {
+                                stmt2 += `(JSON_LENGTH(${alias}.${attr}) ${this.translatePredicate(op, length[op])})`;
+                            }
+                        }
+                    }
+                    else if (attr2.startsWith('$')) {
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        if (p) {
+                            stmt2 += `(${alias}.${attr}->>"$${p}" ${this.translatePredicate(attr2, o[attr2])})`;
+                        }
+                        else {
+                            stmt2 += `(${alias}.${attr} ${this.translatePredicate(attr2, o[attr2])})`;
+                        }
+                    }
+                    else {
+                        // 继续子对象解构
+                        const attr3 = attr2.startsWith('.') ? attr2.slice(1) : attr2;
+                        const part = translateInner(o[attr2], `${p}.${attr3}`);
+                        if (stmt2) {
+                            stmt2 += ' and ';
+                        }
+                        stmt2 += `${part}`;
+                    }
+                }
+            }
+            else {
+                // 直接的属性处理
+                if (stmt2) {
+                    stmt2 += ' and ';
+                }
+                if (typeof o === 'string') {
+                    if (p) {
+                        stmt2 += `(${alias}.${attr}->>"$${p}" = '${o}')`;
+                    }
+                    else {
+                        //  对根对象的字符串比较
+                        stmt2 += `(${alias}.${attr} = '${o}')`;
+                    }
+                }
+                else {
+                    (0, assert_1.default)(p);
+                    stmt2 += `(${alias}.${attr}->>"$${p}" = ${o})`;
+                }
+            }
+            return stmt2;
+        };
+        return translateInner(predicate, '');
+    }
+    translateObjectProjection(projection, alias, attr, prefix) {
+        let stmt = '';
+        const translateInner = (o, p) => {
+            if (o instanceof Array) {
+                o.forEach((item, idx) => {
+                    const p2 = `${p}[${idx}]`;
+                    if (typeof item === 'number') {
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        stmt += `${alias}.${attr}->>"$${p2}"`;
+                        stmt += prefix ? ` as \`${prefix}.${attr}${p2}\`` : ` as \`${attr}${p2}\``;
+                    }
+                    else if (typeof item === 'object') {
+                        translateInner(item, p2);
+                    }
+                });
+            }
+            else {
+                for (const key in o) {
+                    const p2 = `${p}.${key}`;
+                    if (typeof o[key] === 'number') {
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        stmt += `${alias}.${attr}->>"$${p2}"`;
+                        stmt += prefix ? ` as \`${prefix}.${attr}${p2}\`` : ` as \`${attr}${p2}\``;
+                    }
+                    else {
+                        translateInner(o[key], p2);
+                    }
+                }
+            }
+        };
+        translateInner(projection, '');
+        return stmt;
+    }
+    translateAttrValue(dataType, value) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        switch (dataType) {
+            case 'geometry': {
+                return transformGeoData(value);
+            }
+            case 'datetime':
+            case 'time':
+            case 'date': {
+                if (value instanceof Date) {
+                    return `${value.valueOf()}`;
+                }
+                else if (typeof value === 'number') {
+                    return `${value}`;
+                }
+                return `'${(new Date(value)).valueOf()}'`;
+            }
+            case 'object':
+            case 'array': {
+                return this.escapeStringValue(JSON.stringify(value));
+            }
+            /* case 'function': {
+                return `'${Buffer.from(value.toString()).toString('base64')}'`;
+            } */
+            default: {
+                if (typeof value === 'string') {
+                    return this.escapeStringValue(value);
+                }
+                return value;
+            }
+        }
+    }
+    translateFullTextSearch(value, entity, alias) {
+        const { $search } = value;
+        const { indexes } = this.schema[entity];
+        const ftIndex = indexes && indexes.find((ele) => {
+            const { config } = ele;
+            return config && config.type === 'fulltext';
+        });
+        (0, assert_1.default)(ftIndex);
+        const { attributes } = ftIndex;
+        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;
+        const entityDef = schema[entity];
+        const { storageName, attributes, indexes, view, static: _static } = entityDef;
+        let hasSequence = false;
+        // todo view暂还不支持
+        const entityType = view ? 'view' : 'table';
+        let sql = `create ${entityType} `;
+        if (ifExists === 'omit' || (_static && ifExists === 'dropIfNotStatic')) {
+            sql += ' if not exists';
+        }
+        if (storageName) {
+            sql += `\`${storageName}\` `;
+        }
+        else {
+            sql += `\`${entity}\` `;
+        }
+        if (view) {
+            throw new Error(' view unsupported yet');
+        }
+        else {
+            sql += '(';
+            // 翻译所有的属性
+            Object.keys(attributes).forEach((attr, idx) => {
+                const attrSql = this.translateAttributeDef(attr, attributes[attr]);
+                if (idx !== 0) {
+                    sql += ', ';
+                }
+                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;
+                }
+            });
+            // 翻译索引信息
+            if (indexes) {
+                sql += ',\n';
+                indexes.forEach(({ name, attributes, config }, idx) => {
+                    const { unique, type, parser } = config || {};
+                    // 因为有deleteAt的存在，这里的unique没意义，只能框架自己去建立checker来处理
+                    /* if (unique) {
+                        sql += ' unique ';
+                    }
+                    else */ if (type === 'fulltext') {
+                        sql += ' fulltext ';
+                    }
+                    else if (type === 'spatial') {
+                        sql += ' spatial ';
+                    }
+                    sql += `index \`${name}\` `;
+                    if (type === 'hash') {
+                        sql += ` using hash `;
+                    }
+                    sql += '(';
+                    attributes.forEach(({ name, size, direction }, idx2) => {
+                        sql += `\`${name}\``;
+                        if (size) {
+                            sql += ` (${size})`;
+                        }
+                        if (direction) {
+                            sql += ` ${direction}`;
+                        }
+                        if (idx2 < attributes.length - 1) {
+                            sql += ', ';
+                        }
+                    });
+                    sql += ')';
+                    if (parser) {
+                        sql += ` with parser ${parser}`;
+                    }
+                    if (idx < indexes.length - 1) {
+                        sql += ',\n';
+                    }
+                });
+            }
+        }
+        sql += ')';
+        if (typeof hasSequence === 'number') {
+            sql += `auto_increment = ${hasSequence}`;
+        }
+        if (ifExists === 'drop' || (!_static && ifExists === 'dropIfNotStatic')) {
+            return [`drop ${entityType}  if exists \`${storageName || entity}\`;`, sql];
+        }
+        return [sql];
+    }
+    translateFnName(fnName, argumentNumber) {
+        switch (fnName) {
+            case '$add': {
+                let result = '%s';
+                while (--argumentNumber > 0) {
+                    result += ' + %s';
+                }
+                return result;
+            }
+            case '$subtract': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s - %s';
+            }
+            case '$multiply': {
+                let result = '%s';
+                while (--argumentNumber > 0) {
+                    result += ' * %s';
+                }
+                return result;
+            }
+            case '$divide': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s / %s';
+            }
+            case '$abs': {
+                return 'ABS(%s)';
+            }
+            case '$round': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ROUND(%s, %s)';
+            }
+            case '$ceil': {
+                return 'CEIL(%s)';
+            }
+            case '$floor': {
+                return 'FLOOR(%s)';
+            }
+            case '$mod': {
+                return 'MOD(%s, %s)';
+            }
+            case '$pow': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'POW(%s, %s)';
+            }
+            case '$gt': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s > %s';
+            }
+            case '$gte': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s >= %s';
+            }
+            case '$lt': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s < %s';
+            }
+            case '$lte': {
+                return '%s <= %s';
+            }
+            case '$eq': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s = %s';
+            }
+            case '$ne': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s <> %s';
+            }
+            case '$startsWith': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s like CONCAT(%s, \'%\')';
+            }
+            case '$endsWith': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s like CONCAT(\'%\', %s)';
+            }
+            case '$includes': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return '%s like CONCAT(\'%\', %s, \'%\')';
+            }
+            case '$true': {
+                return '%s = true';
+            }
+            case '$false': {
+                return '%s = false';
+            }
+            case '$and': {
+                let result = '';
+                for (let iter = 0; iter < argumentNumber; iter++) {
+                    result += '%s';
+                    if (iter < argumentNumber - 1) {
+                        result += ' and ';
+                    }
+                }
+                return result;
+            }
+            case '$or': {
+                let result = '';
+                for (let iter = 0; iter < argumentNumber; iter++) {
+                    result += '%s';
+                    if (iter < argumentNumber - 1) {
+                        result += ' or ';
+                    }
+                }
+                return result;
+            }
+            case '$not': {
+                return 'not %s';
+            }
+            case '$year': {
+                return 'YEAR(%s)';
+            }
+            case '$month': {
+                return 'MONTH(%s)';
+            }
+            case '$weekday': {
+                return 'WEEKDAY(%s)';
+            }
+            case '$weekOfYear': {
+                return 'WEEKOFYEAR(%s)';
+            }
+            case '$day': {
+                return 'DAY(%s)';
+            }
+            case '$dayOfMonth': {
+                return 'DAYOFMONTH(%s)';
+            }
+            case '$dayOfWeek': {
+                return 'DAYOFWEEK(%s)';
+            }
+            case '$dayOfYear': {
+                return 'DAYOFYEAR(%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)';
+            }
+            case '$distance': {
+                (0, assert_1.default)(argumentNumber === 2);
+                return 'ST_DISTANCE(%s, %s)';
+            }
+            case '$concat': {
+                let result = ' concat(%s';
+                while (--argumentNumber > 0) {
+                    result += ', %s';
+                }
+                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}`);
+            }
+        }
+    }
+    translateAttrInExpression(entity, attr, exprText) {
+        const { attributes } = this.schema[entity];
+        const { type } = attributes[attr];
+        if (['date', 'time', 'datetime'].includes(type)) {
+            // 从unix时间戵转成date类型参加expr的运算
+            return `from_unixtime(${exprText} / 1000)`;
+        }
+        return exprText;
+    }
+    translateExpression(entity, alias, expression, refDict) {
+        const translateConstant = (constant) => {
+            if (constant instanceof Date) {
+                return ` from_unixtime(${constant.valueOf()}/1000)`;
+            }
+            else if (typeof constant === 'string') {
+                return ` '${constant}'`;
+            }
+            else {
+                (0, assert_1.default)(typeof constant === 'number');
+                return ` ${constant}`;
+            }
+        };
+        const translateInner = (expr) => {
+            const k = Object.keys(expr);
+            let result;
+            if (k.includes('#attr')) {
+                const attrText = `\`${alias}\`.\`${(expr)['#attr']}\``;
+                result = this.translateAttrInExpression(entity, (expr)['#attr'], attrText);
+            }
+            else if (k.includes('#refId')) {
+                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);
+            }
+            else {
+                (0, assert_1.default)(k.length === 1);
+                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(...fnArgs.map((ele) => {
+                        if (['string', 'number'].includes(typeof ele) || ele instanceof Date) {
+                            return translateConstant(ele);
+                        }
+                        else {
+                            return translateInner(ele);
+                        }
+                    }));
+                    result = util_1.format.apply(null, args);
+                }
+                else {
+                    // 原有的单参数处理逻辑
+                    const fnName = this.translateFnName(fnKey, 1);
+                    const args = [fnName];
+                    const arg = fnArgs;
+                    if (['string', 'number'].includes(typeof arg) || arg instanceof Date) {
+                        args.push(translateConstant(arg));
+                    }
+                    else {
+                        args.push(translateInner(arg));
+                    }
+                    result = util_1.format.apply(null, args);
+                }
+            }
+            return result;
+        };
+        return translateInner(expression);
+    }
+    populateSelectStmt(projectionText, fromText, aliasDict, filterText, sorterText, groupByText, indexFrom, count, option) {
+        // todo hint of use index
+        let sql = `select ${projectionText} from ${fromText}`;
+        if (filterText) {
+            sql += ` where ${filterText}`;
+        }
+        if (sorterText) {
+            sql += ` order by ${sorterText}`;
+        }
+        if (groupByText) {
+            sql += ` group by ${groupByText}`;
+        }
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number');
+            sql += ` limit ${indexFrom}, ${count}`;
+        }
+        if (option?.forUpdate) {
+            sql += ' for update';
+            if (typeof option?.forUpdate === 'string') {
+                sql += ` ${option.forUpdate}`;
+            }
+        }
+        return sql;
+    }
+    populateUpdateStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
+        // todo using index
+        (0, assert_1.default)(updateText);
+        let sql = `update ${fromText} set ${updateText}`;
+        if (filterText) {
+            sql += ` where ${filterText}`;
+        }
+        if (sorterText) {
+            sql += ` order by ${sorterText}`;
+        }
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number');
+            sql += ` limit ${indexFrom}, ${count}`;
+        }
+        return sql;
+    }
+    populateRemoveStmt(updateText, fromText, aliasDict, filterText, sorterText, indexFrom, count, option) {
+        // todo using index
+        const alias = aliasDict['./'];
+        if (option?.deletePhysically) {
+            // assert(!updateText, 'physically delete does not support setting trigger data');
+            let sql = `delete ${alias} from ${fromText} `;
+            if (filterText) {
+                sql += ` where ${filterText}`;
+            }
+            if (sorterText) {
+                sql += ` order by ${sorterText}`;
+            }
+            if (typeof indexFrom === 'number') {
+                (0, assert_1.default)(typeof count === 'number');
+                sql += ` limit ${indexFrom}, ${count}`;
+            }
+            return sql;
+        }
+        // 新的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}`;
+        if (filterText) {
+            sql += ` where ${filterText}`;
+        }
+        if (sorterText) {
+            sql += ` order by ${sorterText}`;
+        }
+        if (typeof indexFrom === 'number') {
+            (0, assert_1.default)(typeof count === 'number');
+            sql += ` limit ${indexFrom}, ${count}`;
+        }
+        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;