oak-db 2.2.10 → 3.0.0

package/lib/MySQL/store.d.ts

@@ -10,6 +10,7 @@ export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt exte
     protected aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
     protected selectAbjointRow<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: SyncContext<ED>, option: OP): Partial<ED[T]['Schema']>[];
     protected updateAbjointRow<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: SyncContext<ED>, option: OP): number;
+    exec(script: string, txnId?: string): Promise<any>;
     connector: MySqlConnector;
     translator: MySqlTranslator<ED>;
     constructor(storageSchema: StorageSchema<ED>, configuration: MySQLConfiguration);

package/lib/MySQL/store.js

@@ -37,6 +37,9 @@ var MysqlStore = /** @class */ (function (_super) {
     MysqlStore.prototype.updateAbjointRow = function (entity, operation, context, option) {
         throw new Error('MySQL store不支持同步更新数据，不应该跑到这儿');
     };
+    MysqlStore.prototype.exec = function (script, txnId) {
+        return this.connector.exec(script, txnId);
+    };
     MysqlStore.prototype.aggregateAsync = function (entity, aggregation, context, option) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var sql, result;
@@ -63,6 +66,25 @@ var MysqlStore = /** @class */ (function (_super) {
     };
     MysqlStore.prototype.formResult = function (entity, result) {
         var schema = this.getSchema();
+        /*  function resolveObject(r: Record<string, any>, path: string, value: any) {
+             const i = path.indexOf(".");
+             const bs = path.indexOf('[');
+             const be = path.indexOf(']');
+             if (i === -1 && bs === -1) {
+                 r[i] = value;
+             }
+             else if (i === -1) {
+ 
+             }
+             else if (bs === -1) {
+                 const attrHead = path.slice(0, i);
+                 const attrTail = path.slice(i + 1);
+                 if (!r[attrHead]) {
+                     r[attrHead] = {};
+                 }
+                 resolveObject(r[attrHead], attrTail, value);
+             }
+         } */
         function resolveAttribute(entity2, r, attr, value) {
             var _a;
             var _b = schema[entity2], attributes = _b.attributes, view = _b.view;
@@ -71,19 +93,24 @@ var MysqlStore = /** @class */ (function (_super) {
                 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);
-                    if (rel === 0) {
-                        resolveAttribute(entity2, r[attrHead], attrTail, value);
-                    }
-                    else if (rel === 2) {
-                        resolveAttribute(attrHead, r[attrHead], attrTail, value);
+                    if (rel === 1) {
+                        (0, lodash_1.set)(r, attr, value);
                     }
                     else {
-                        (0, assert_1.default)(typeof rel === 'string');
-                        resolveAttribute(rel, r[attrHead], attrTail, value);
+                        if (!r[attrHead]) {
+                            r[attrHead] = {};
+                        }
+                        if (rel === 0) {
+                            resolveAttribute(entity2, r[attrHead], attrTail, value);
+                        }
+                        else if (rel === 2) {
+                            resolveAttribute(attrHead, r[attrHead], attrTail, value);
+                        }
+                        else {
+                            (0, assert_1.default)(typeof rel === 'string');
+                            resolveAttribute(rel, r[attrHead], attrTail, value);
+                        }
                     }
                 }
                 else if (attributes[attr]) {
@@ -141,6 +168,17 @@ var MysqlStore = /** @class */ (function (_super) {
                             }
                             break;
                         }
+                        case 'decimal': {
+                            // mysql内部取回decimal是字符串
+                            if (typeof value === 'string') {
+                                r[attr] = parseFloat(value);
+                            }
+                            else {
+                                (0, assert_1.default)(value === null || typeof value === 'number');
+                                r[attr] = value;
+                            }
+                            break;
+                        }
                         default: {
                             r[attr] = value;
                         }
@@ -283,7 +321,7 @@ var MysqlStore = /** @class */ (function (_super) {
                     case 0:
                         action = operation.action;
                         (0, assert_1.default)(!['select', 'download', 'stat'].includes(action), '现在不支持使用select operation');
-                        return [4 /*yield*/, this.cascadeUpdateAsync(entity, operation, context, option)];
+                        return [4 /*yield*/, _super.prototype.operateAsync.call(this, entity, operation, context, option)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -294,7 +332,7 @@ var MysqlStore = /** @class */ (function (_super) {
             var result;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.cascadeSelectAsync(entity, selection, context, option)];
+                    case 0: return [4 /*yield*/, _super.prototype.selectAsync.call(this, entity, selection, context, option)];
                     case 1:
                         result = _a.sent();
                         return [2 /*return*/, result];

package/lib/MySQL/translator.d.ts

@@ -1,11 +1,12 @@
 import { EntityDict, Q_FullTextValue, RefOrExpression, Ref, StorageSchema } from "oak-domain/lib/types";
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { DataType } from "oak-domain/lib/types/schema/DataTypes";
 import { SqlOperateOption, SqlSelectOption, SqlTranslator } from "../sqlTranslator";
 export interface MySqlSelectOption extends SqlSelectOption {
 }
 export interface MysqlOperateOption extends SqlOperateOption {
 }
-export declare class MySqlTranslator<ED extends EntityDict> extends SqlTranslator<ED> {
+export declare class MySqlTranslator<ED extends EntityDict & BaseEntityDict> extends SqlTranslator<ED> {
     protected getDefaultSelectFilter(alias: string, option?: MySqlSelectOption): string;
     private makeUpSchema;
     constructor(schema: StorageSchema<ED>);
@@ -91,6 +92,8 @@ export declare class MySqlTranslator<ED extends EntityDict> extends SqlTranslato
     maxAliasLength: number;
     private populateDataTypeDef;
     protected translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
+    protected translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
+    protected translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
     protected translateAttrValue(dataType: DataType | Ref, value: any): string;
     protected translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
     translateCreateEntity<T extends keyof ED>(entity: T, options?: {

package/lib/MySQL/translator.js

@@ -128,7 +128,7 @@ var MySqlTranslator = /** @class */ (function (_super) {
             return 'bigint ';
         }
         if (['object', 'array'].includes(type)) {
-            return 'text ';
+            return 'json ';
         }
         if (['image', 'function'].includes(type)) {
             return 'text ';
@@ -202,6 +202,121 @@ var MySqlTranslator = /** @class */ (function (_super) {
             }
         }
     };
+    MySqlTranslator.prototype.translateObjectPredicate = function (predicate, alias, attr) {
+        var _this = this;
+        var stmt = '';
+        var translatePredicate = function (o, p) {
+            var predicate2 = Object.keys(o)[0];
+            if (predicate2.startsWith('$')) {
+                if (stmt) {
+                    stmt += ' and ';
+                }
+                // todo
+                if (predicate2 === '$contains') {
+                    // json_contains，多值的包含关系
+                    var value = JSON.stringify(o[predicate2]);
+                    stmt += "JSON_CONTAINS(".concat(alias, ".").concat(attr, "->>\"$").concat(p, "\", CAST('").concat(value, "' AS JSON)) ");
+                }
+                else if (predicate2 === '$overlaps') {
+                    // json_overlaps，多值的交叉关系
+                    var value = JSON.stringify(o[predicate2]);
+                    stmt += "JSON_OVERLAPS(".concat(alias, ".").concat(attr, "->>\"$").concat(p, "\", CAST('").concat(value, "' AS JSON)) ");
+                }
+                else {
+                    stmt += "".concat(alias, ".").concat(attr, "->>\"$").concat(p, "\" ").concat(_this.translatePredicate(predicate2, o[predicate2]));
+                }
+            }
+            else {
+                // 继续子对象解构
+                translateInner(o, p);
+            }
+        };
+        var translateInner = function (o, p) {
+            if (o instanceof Array) {
+                o.forEach(function (item, idx) {
+                    var p2 = "".concat(p, "[").concat(idx, "]");
+                    if (typeof item !== 'object') {
+                        if (item !== null && item !== undefined) {
+                            if (stmt) {
+                                stmt += ' and ';
+                            }
+                            stmt += "".concat(alias, ".").concat(attr, "->>\"$").concat(p2, "\"");
+                            if (typeof item === 'string') {
+                                stmt += " = '".concat(item, "'");
+                            }
+                            else {
+                                stmt += " = ".concat(item);
+                            }
+                        }
+                    }
+                    else {
+                        translatePredicate(item, p2);
+                    }
+                });
+            }
+            else {
+                for (var key in o) {
+                    var p2 = "".concat(p, ".").concat(key);
+                    if (typeof o[key] !== 'object') {
+                        if (o[key] !== null && o[key] !== undefined) {
+                            if (stmt) {
+                                stmt += ', ';
+                            }
+                            stmt += "".concat(alias, ".").concat(attr, "->>\"$").concat(p2, "\"");
+                            if (typeof o[key] === 'string') {
+                                stmt += " = '".concat(o[key], "'");
+                            }
+                            else {
+                                stmt += " = ".concat(o[key]);
+                            }
+                        }
+                    }
+                    else {
+                        translatePredicate(o[key], p2);
+                    }
+                }
+            }
+        };
+        translatePredicate(predicate, '');
+        return stmt;
+    };
+    MySqlTranslator.prototype.translateObjectProjection = function (projection, alias, attr, prefix) {
+        var stmt = '';
+        var translateInner = function (o, p) {
+            if (o instanceof Array) {
+                o.forEach(function (item, idx) {
+                    var p2 = "".concat(p, "[").concat(idx, "]");
+                    if (typeof item === 'number') {
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        stmt += "".concat(alias, ".").concat(attr, "->>\"$").concat(p2, "\"");
+                        stmt += prefix ? " as `".concat(prefix, ".").concat(attr).concat(p2, "`") : " as `".concat(attr).concat(p2, "`");
+                    }
+                    else if (typeof item === 'object') {
+                        translateInner(item, p2);
+                    }
+                });
+            }
+            else {
+                for (var key in o) {
+                    var p2 = "".concat(p, ".").concat(key);
+                    if (typeof o[key] === 'number') {
+                        if (stmt) {
+                            stmt += ', ';
+                        }
+                        stmt += "".concat(alias, ".").concat(attr, "->>\"$").concat(p2, "\"");
+                        stmt += prefix ? " as `".concat(prefix, ".").concat(attr).concat(p2, "`") : " as `".concat(attr).concat(p2, "`");
+                    }
+                    else {
+                        translateInner(o[key], p2);
+                    }
+                }
+            }
+        };
+        translateInner(projection, '');
+        return stmt;
+    };
     MySqlTranslator.prototype.translateAttrValue = function (dataType, value) {
         if (value === null || value === undefined) {
             return 'null';

package/lib/sqlTranslator.d.ts

@@ -1,20 +1,23 @@
 import { EntityDict, OperateOption, Q_FullTextValue, Ref, RefOrExpression, SelectOption, StorageSchema } from "oak-domain/lib/types";
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { DataType } from "oak-domain/lib/types/schema/DataTypes";
 export interface SqlSelectOption extends SelectOption {
 }
 export interface SqlOperateOption extends OperateOption {
 }
-export declare abstract class SqlTranslator<ED extends EntityDict> {
+export declare abstract class SqlTranslator<ED extends EntityDict & BaseEntityDict> {
     readonly schema: StorageSchema<ED>;
     constructor(schema: StorageSchema<ED>);
     private makeFullSchema;
     protected abstract getDefaultSelectFilter<OP extends SqlSelectOption>(alias: string, option?: OP): string;
     protected abstract translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
+    protected abstract translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
     protected abstract translateAttrValue(dataType: DataType | Ref, value: any): string;
     protected abstract translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
     abstract translateCreateEntity<T extends keyof ED>(entity: T, option: {
         replace?: boolean;
     }): string[];
+    protected abstract translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
     protected abstract populateSelectStmt<T extends keyof ED, OP extends SqlSelectOption>(projectionText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, groupByText?: string, indexFrom?: number, count?: number, option?: OP, selection?: ED[T]['Selection'], aggregation?: ED[T]['Aggregation']): string;
     protected abstract populateUpdateStmt<OP extends SqlOperateOption>(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
     protected abstract populateRemoveStmt<OP extends SqlOperateOption>(removeText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: OP): string;
@@ -36,8 +39,8 @@ export declare abstract class SqlTranslator<ED extends EntityDict> {
      */
     private analyzeJoin;
     private translateComparison;
-    private translateElement;
     private translateEvaluation;
+    protected translatePredicate(predicate: string, value: any, type?: DataType | Ref): string;
     private translateFilter;
     private translateSorter;
     private translateProjection;

package/lib/sqlTranslator.js

@@ -6,6 +6,7 @@ var assert_1 = tslib_1.__importDefault(require("assert"));
 var lodash_1 = require("lodash");
 var types_1 = require("oak-domain/lib/types");
 var relation_1 = require("oak-domain/lib/store/relation");
+var filter_1 = require("oak-domain/lib/store/filter");
 ;
 ;
 var SqlTranslator = /** @class */ (function () {
@@ -207,7 +208,6 @@ var SqlTranslator = /** @class */ (function () {
         var number = initialNumber || 1;
         var projectionRefAlias = {};
         var filterRefAlias = {};
-        var extraWhere = '';
         var alias = "".concat(entity, "_").concat(number++);
         var from = " `".concat(this.getStorageName(entity), "` `").concat(alias, "` ");
         var aliasDict = {
@@ -280,7 +280,7 @@ var SqlTranslator = /** @class */ (function () {
                     }
                     else {
                         // 不支持一对多
-                        (0, assert_1.default)(rel === 0 || rel === 1);
+                        // assert(rel === 0 || rel === 1);
                     }
                 }
             });
@@ -431,7 +431,6 @@ var SqlTranslator = /** @class */ (function () {
             from: from,
             projectionRefAlias: projectionRefAlias,
             filterRefAlias: filterRefAlias,
-            extraWhere: extraWhere,
             currentNumber: number,
         };
     };
@@ -445,7 +444,12 @@ var SqlTranslator = /** @class */ (function () {
             $ne: '<>',
         };
         if (Object.keys(SQL_OP).includes(attr)) {
-            return " ".concat(SQL_OP[attr], " ").concat(this.translateAttrValue(type, value));
+            if (type) {
+                return " ".concat(SQL_OP[attr], " ").concat(this.translateAttrValue(type, value));
+            }
+            else {
+                return " ".concat(SQL_OP[attr], " ").concat(value);
+            }
         }
         switch (attr) {
             case '$startsWith': {
@@ -462,22 +466,8 @@ var SqlTranslator = /** @class */ (function () {
             }
         }
     };
-    SqlTranslator.prototype.translateElement = function (attr, value) {
-        (0, assert_1.default)(attr === '$exists'); // only support one operator now
-        if (value) {
-            return ' is not null';
-        }
-        return ' is null';
-    };
     SqlTranslator.prototype.translateEvaluation = function (attr, value, entity, alias, type, initialNumber, refAlias) {
         switch (attr) {
-            case '$text': {
-                // fulltext search
-                return {
-                    stmt: this.translateFullTextSearch(value, entity, alias),
-                    currentNumber: initialNumber,
-                };
-            }
             case '$in':
             case '$nin': {
                 var IN_OP = {
@@ -485,65 +475,75 @@ var SqlTranslator = /** @class */ (function () {
                     $nin: 'not in',
                 };
                 if (value instanceof Array) {
-                    var values = value.map(function (v) {
-                        if (['varchar', 'char', 'text', 'nvarchar', 'ref', 'enum'].includes(type)) {
-                            return "'".concat(v, "'");
-                        }
-                        else {
-                            return "".concat(v);
-                        }
-                    });
-                    if (values.length > 0) {
-                        return {
-                            stmt: " ".concat(IN_OP[attr], "(").concat(values.join(','), ")"),
-                            currentNumber: initialNumber,
-                        };
-                    }
-                    else {
-                        if (attr === '$in') {
-                            return {
-                                stmt: ' in (null)',
-                                currentNumber: initialNumber,
-                            };
-                        }
-                        else {
-                            return {
-                                stmt: ' is not null',
-                                currentNumber: initialNumber,
-                            };
-                        }
-                    }
+                    return {
+                        stmt: this.translatePredicate(attr, value, type),
+                        currentNumber: initialNumber,
+                    };
                 }
                 else {
+                    (0, assert_1.default)(false, '子查询已经改写为一对多的形式');
                     // sub query
-                    var _a = this.translateSelectInner(value.entity, value, initialNumber, refAlias, undefined), subQueryStmt = _a.stmt, currentNumber = _a.currentNumber;
+                    /* const { stmt: subQueryStmt, currentNumber } = this.translateSelectInner(value.entity, value, initialNumber, refAlias, undefined);
                     return {
-                        stmt: " ".concat(IN_OP[attr], "(").concat(subQueryStmt, ")"),
-                        currentNumber: currentNumber,
-                    };
+                        stmt: ` ${IN_OP[attr]}(${subQueryStmt})`,
+                        currentNumber,
+                    }; */
                 }
             }
             default: {
-                (0, assert_1.default)('$between' === attr);
-                var values = value.map(function (v) {
-                    if (['varchar', 'char', 'text', 'nvarchar', 'ref'].includes(type)) {
-                        return "'".concat(v, "'");
-                    }
-                    else {
-                        return "".concat(v);
-                    }
-                });
-                return {
-                    stmt: " between ".concat(values[0], " and ").concat(values[1]),
-                    currentNumber: initialNumber,
-                };
+                throw new Error("".concat(attr, " is not evaluation predicate"));
             }
         }
     };
-    SqlTranslator.prototype.translateFilter = function (entity, selection, aliasDict, filterRefAlias, initialNumber, extraWhere, option) {
+    SqlTranslator.prototype.translatePredicate = function (predicate, value, type) {
+        if (['$gt', '$gte', '$lt', '$lte', '$eq', '$ne', '$startsWith', '$endsWith', '$includes'].includes(predicate)) {
+            return this.translateComparison(predicate, value, type);
+        }
+        else if (['$in', '$nin'].includes(predicate)) {
+            (0, assert_1.default)(value instanceof Array);
+            var IN_OP = {
+                $in: 'in',
+                $nin: 'not in',
+            };
+            var values = value.map(function (v) {
+                if (type && ['varchar', 'char', 'text', 'nvarchar', 'ref', 'enum'].includes(type) || typeof v === 'string') {
+                    return "'".concat(v, "'");
+                }
+                else {
+                    return "".concat(v);
+                }
+            });
+            if (values.length > 0) {
+                return " ".concat(IN_OP[predicate], "(").concat(values.join(','), ")");
+            }
+            if (predicate === '$in') {
+                return ' in (null)';
+            }
+            return ' is not null';
+        }
+        else if (predicate === '$between') {
+            var values = value.map(function (v) {
+                if (type && ['varchar', 'char', 'text', 'nvarchar', 'ref', 'enum'].includes(type) || typeof v === 'string') {
+                    return "'".concat(v, "'");
+                }
+                else {
+                    return "".concat(v);
+                }
+            });
+            // between是所有数据库都支持的语法吗？
+            return " between ".concat(values[0], " and ").concat(values[1]);
+        }
+        else {
+            (0, assert_1.default)(predicate === '$exists');
+            if (value) {
+                return ' is not null';
+            }
+            return ' is null';
+        }
+    };
+    SqlTranslator.prototype.translateFilter = function (entity, filter, aliasDict, filterRefAlias, initialNumber, option) {
         var _this = this;
         var schema = this.schema;
-        var filter = selection.filter;
         var currentNumber = initialNumber;
         var translateInner = function (entity2, path, filter2, type) {
             var alias = aliasDict[path];
@@ -552,11 +552,11 @@ var SqlTranslator = /** @class */ (function () {
             if (filter2) {
                 var attrs = Object.keys(filter2).filter(function (ele) { return !ele.startsWith('#'); });
                 attrs.forEach(function (attr) {
+                    var _a;
                     if (whereText) {
                         whereText += ' and ';
                     }
                     if (['$and', '$or', '$xor', '$not'].includes(attr)) {
-                        var result = '';
                         whereText += '(';
                         switch (attr) {
                             case '$and':
@@ -564,7 +564,7 @@ var SqlTranslator = /** @class */ (function () {
                             case '$xor': {
                                 var logicQueries_1 = filter2[attr];
                                 logicQueries_1.forEach(function (logicQuery, index) {
-                                    var sql = translateInner(entity2, path, logicQuery);
+                                    var sql = translateInner(entity2, path, logicQuery, 'ref'); // 只要传个值就行了，应该无所谓
                                     if (sql) {
                                         whereText += " (".concat(sql, ")");
                                         if (index < logicQueries_1.length - 1) {
@@ -577,30 +577,22 @@ var SqlTranslator = /** @class */ (function () {
                             default: {
                                 (0, assert_1.default)(attr === '$not');
                                 var logicQuery = filter2[attr];
-                                var sql = translateInner(entity2, path, logicQuery);
+                                var sql = translateInner(entity2, path, logicQuery, 'ref'); // 只要传个值就行了，应该无所谓
                                 if (sql) {
-                                    whereText += " not (".concat(translateInner(entity2, path, logicQuery), ")");
+                                    whereText += " not (".concat(sql, ")");
                                     break;
                                 }
                             }
                         }
                         whereText += ')';
                     }
+                    else if (attr === '$text') {
+                        whereText += "(".concat(_this.translateFullTextSearch(filter2[attr], entity2, alias), ")");
+                    }
                     else if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
                         // expression
                         whereText += " (".concat(_this.translateExpression(entity2, alias, filter2[attr], filterRefAlias), ")");
                     }
-                    else if (['$gt', '$gte', '$lt', '$lte', '$eq', '$ne', '$startsWith', '$endsWith', '$includes'].includes(attr)) {
-                        whereText += _this.translateComparison(attr, filter2[attr], type);
-                    }
-                    else if (['$exists'].includes(attr)) {
-                        whereText += _this.translateElement(attr, filter2[attr]);
-                    }
-                    else if (['$text', '$in', '$nin', '$between'].includes(attr)) {
-                        var _a = _this.translateEvaluation(attr, filter2[attr], entity2, alias, type, initialNumber, filterRefAlias), stmt = _a.stmt, cn2 = _a.currentNumber;
-                        whereText += stmt;
-                        currentNumber = cn2;
-                    }
                     else {
                         var rel = (0, relation_1.judgeRelation)(_this.schema, entity2, attr);
                         if (rel === 2) {
@@ -609,12 +601,91 @@ var SqlTranslator = /** @class */ (function () {
                         else if (typeof rel === 'string') {
                             whereText += " (".concat(translateInner(rel, "".concat(path).concat(attr, "/"), filter2[attr]), ")");
                         }
+                        else if (rel instanceof Array) {
+                            var subEntity = rel[0], foreignKey = rel[1];
+                            var predicate = (filter2[attr]['#sqp'] || 'in');
+                            /**
+                             *
+                            * in代表外键连接后至少有一行数据
+                            * not in代表外键连接后一行也不能有
+                            * all代表反外键连接条件的一行也不能有（符合的是否至少要有一行？直觉上没这个限制）
+                            * not all 代表反外键连接条件的至少有一行
+                            *
+                            * 目前将这种子查询翻译成了exists查询，当外表很大而子查询结果集很小时可能有性能问题，取决于MySQL执行器的能力
+                            * by Xc 20230726
+                             */
+                            var refAlia = Object.keys(filterRefAlias).find(function (ele) { return filterRefAlias[ele][0] === alias; });
+                            var refAlia2 = refAlia || alias; // alias一定是唯一的，可以用来作为node id
+                            if (!refAlia) {
+                                (0, assert_1.default)(!filterRefAlias[refAlia2]);
+                                Object.assign(filterRefAlias, (_a = {},
+                                    _a[refAlia2] = [alias, entity2],
+                                    _a));
+                            }
+                            var fk = foreignKey || 'entityId';
+                            var joinFilter = ['not in', 'in'].includes(predicate) ? {
+                                $expr12: {
+                                    $eq: [
+                                        {
+                                            '#attr': fk,
+                                        },
+                                        {
+                                            '#refId': refAlia2,
+                                            '#refAttr': 'id',
+                                        }
+                                    ],
+                                }
+                            } : {
+                                $expr12: {
+                                    $ne: [
+                                        {
+                                            '#attr': fk,
+                                        },
+                                        {
+                                            '#refId': refAlia2,
+                                            '#refAttr': 'id',
+                                        }
+                                    ],
+                                }
+                            };
+                            if (!foreignKey) {
+                                Object.assign(joinFilter, {
+                                    entity: entity2,
+                                });
+                            }
+                            var _b = _this.translateSelectInner(subEntity, {
+                                data: {
+                                    id: 1,
+                                },
+                                filter: (0, filter_1.combineFilters)(subEntity, _this.schema, [joinFilter, filter2[attr]]),
+                                indexFrom: 0,
+                                count: 1,
+                            }, currentNumber, filterRefAlias, option), stmt = _b.stmt, ct2 = _b.currentNumber;
+                            currentNumber = ct2;
+                            var PREDICATE_DICT = {
+                                'in': 'exists',
+                                'not in': 'not exists',
+                                'all': 'not exists',
+                                'not all': 'exists',
+                            };
+                            whereText += " ".concat(PREDICATE_DICT[predicate], " (").concat(stmt, ")");
+                        }
                         else {
                             (0, assert_1.default)(attributes.hasOwnProperty(attr), "\u975E\u6CD5\u7684\u5C5E\u6027".concat(attr));
                             var type2 = attributes[attr].type;
-                            //                                 assert (type2 !== 'ref');
-                            if (typeof filter2[attr] === 'object' && Object.keys(filter2[attr])[0] && Object.keys(filter2[attr])[0].startsWith('$')) {
-                                whereText += " (`".concat(alias, "`.`").concat(attr, "` ").concat(translateInner(entity2, path, filter2[attr], type2), ")");
+                            // assert (type2 !== 'ref');
+                            if (typeof filter2[attr] === 'object') {
+                                if (['object', 'array'].includes(type2)) {
+                                    // 对object数据的深层次查询，这里调用数据库所支持的属性对象级查询，如mysql中的json查询
+                                    whereText += "(".concat(_this.translateObjectPredicate(filter2[attr], alias, attr), ")");
+                                }
+                                else {
+                                    (0, assert_1.default)(Object.keys(filter2[attr]).length === 1);
+                                    var predicate = Object.keys(filter2[attr])[0];
+                                    (0, assert_1.default)(predicate.startsWith('$'));
+                                    // 对属性上的谓词处理
+                                    whereText += " (`".concat(alias, "`.`").concat(attr, "` ").concat(_this.translatePredicate(predicate, filter2[attr][predicate], type2), ")");
+                                }
                             }
                             else {
                                 whereText += " (`".concat(alias, "`.`").concat(attr, "` = ").concat(_this.translateAttrValue(type2, filter2[attr]), ")");
@@ -629,14 +700,8 @@ var SqlTranslator = /** @class */ (function () {
             return whereText;
         };
         var where = translateInner(entity, './', filter);
-        if (extraWhere && where) {
-            return {
-                stmt: "".concat(extraWhere, " and ").concat(where),
-                currentNumber: currentNumber,
-            };
-        }
         return {
-            stmt: extraWhere || where,
+            stmt: where,
             currentNumber: currentNumber,
         };
     };
@@ -733,6 +798,12 @@ var SqlTranslator = /** @class */ (function () {
                                 }
                             }
                         }
+                        else if (typeof projection2[attr] === 'object') {
+                            // 对JSON对象的取值
+                            (0, assert_1.default)(!disableAs);
+                            (0, assert_1.default)(['object', 'array'].includes(type));
+                            projText += " ".concat(_this.translateObjectProjection(projection2[attr], alias, attr, prefix2));
+                        }
                         else {
                             (0, assert_1.default)(typeof projection2 === 'string');
                             if (disableAs) {
@@ -767,11 +838,11 @@ var SqlTranslator = /** @class */ (function () {
             projection: data,
             filter: filter,
             sorter: sorter,
-        }, initialNumber), fromText = _a.from, aliasDict = _a.aliasDict, projectionRefAlias = _a.projectionRefAlias, extraWhere = _a.extraWhere, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
+        }, initialNumber), fromText = _a.from, aliasDict = _a.aliasDict, projectionRefAlias = _a.projectionRefAlias, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
         (0, assert_1.default)((0, lodash_1.intersection)((0, lodash_1.keys)(refAlias), (0, lodash_1.keys)(filterRefAlias)).length === 0, 'filter中的#node结点定义有重复');
         (0, lodash_1.assign)(refAlias, filterRefAlias);
         var projText = this.translateProjection(entity, data, aliasDict, projectionRefAlias).projText;
-        var _b = this.translateFilter(entity, selection, aliasDict, refAlias, currentNumber, extraWhere, option), filterText = _b.stmt, currentNumber2 = _b.currentNumber;
+        var _b = this.translateFilter(entity, filter, aliasDict, refAlias, currentNumber, option), filterText = _b.stmt, currentNumber2 = _b.currentNumber;
         var sorterText = sorter && this.translateSorter(entity, sorter, aliasDict);
         return {
             stmt: this.populateSelectStmt(projText, fromText, aliasDict, filterText, sorterText, undefined, indexFrom, count, option, selection),
@@ -793,7 +864,7 @@ var SqlTranslator = /** @class */ (function () {
             aggregation: data,
             filter: filter,
             sorter: sorter,
-        }, 1), fromText = _a.from, aliasDict = _a.aliasDict, projectionRefAlias = _a.projectionRefAlias, extraWhere = _a.extraWhere, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
+        }, 1), fromText = _a.from, aliasDict = _a.aliasDict, projectionRefAlias = _a.projectionRefAlias, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
         var projText = '';
         var groupByText = '';
         for (var k in data) {
@@ -834,7 +905,7 @@ var SqlTranslator = /** @class */ (function () {
                 }
             }
         }
-        var filterText = this.translateFilter(entity, aggregation, aliasDict, {}, currentNumber, extraWhere, option).stmt;
+        var filterText = this.translateFilter(entity, filter, aliasDict, {}, currentNumber, option).stmt;
         var sorterText = sorter && this.translateSorter(entity, sorter, aliasDict);
         return this.populateSelectStmt(projText, fromText, aliasDict, filterText, sorterText, groupByText, indexFrom, count, option, undefined, aggregation);
     };
@@ -842,9 +913,9 @@ var SqlTranslator = /** @class */ (function () {
         var filter = selection.filter, count = selection.count;
         var _a = this.analyzeJoin(entity, {
             filter: filter,
-        }), fromText = _a.from, aliasDict = _a.aliasDict, extraWhere = _a.extraWhere, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
+        }), fromText = _a.from, aliasDict = _a.aliasDict, filterRefAlias = _a.filterRefAlias, currentNumber = _a.currentNumber;
         var projText = 'count(1) cnt';
-        var filterText = this.translateFilter(entity, selection, aliasDict, filterRefAlias, currentNumber, extraWhere, option).stmt;
+        var filterText = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, option).stmt;
         if (count) {
             var subQuerySql = this.populateSelectStmt('1', fromText, aliasDict, filterText, undefined, undefined, undefined, undefined, option, Object.assign({}, selection, { indexFrom: 0, count: count }));
             return "select count(1) cnt from (".concat(subQuerySql, ") __tmp");
@@ -854,9 +925,9 @@ var SqlTranslator = /** @class */ (function () {
     SqlTranslator.prototype.translateRemove = function (entity, operation, option) {
         var filter = operation.filter, sorter = operation.sorter, indexFrom = operation.indexFrom, count = operation.count;
         (0, assert_1.default)(!sorter, '当前remove不支持sorter行为');
-        var _a = this.analyzeJoin(entity, { filter: filter, sorter: sorter }), aliasDict = _a.aliasDict, filterRefAlias = _a.filterRefAlias, extraWhere = _a.extraWhere, fromText = _a.from, currentNumber = _a.currentNumber;
+        var _a = this.analyzeJoin(entity, { filter: filter, sorter: sorter }), aliasDict = _a.aliasDict, filterRefAlias = _a.filterRefAlias, fromText = _a.from, currentNumber = _a.currentNumber;
         var alias = aliasDict['./'];
-        var filterText = this.translateFilter(entity, operation, aliasDict, filterRefAlias, currentNumber, extraWhere, { includedDeleted: true }).stmt;
+        var filterText = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber, { includedDeleted: true }).stmt;
         // const sorterText = sorter && sorter.length > 0 ? this.translateSorter(entity, sorter, aliasDict) : undefined;
         return this.populateRemoveStmt(alias, fromText, aliasDict, filterText, /* sorterText */ undefined, indexFrom, count, option);
     };
@@ -864,7 +935,7 @@ var SqlTranslator = /** @class */ (function () {
         var attributes = this.schema[entity].attributes;
         var filter = operation.filter, sorter = operation.sorter, indexFrom = operation.indexFrom, count = operation.count, data = operation.data;
         (0, assert_1.default)(!sorter, '当前update不支持sorter行为');
-        var _a = this.analyzeJoin(entity, { filter: filter, sorter: sorter }), aliasDict = _a.aliasDict, filterRefAlias = _a.filterRefAlias, extraWhere = _a.extraWhere, fromText = _a.from, currentNumber = _a.currentNumber;
+        var _a = this.analyzeJoin(entity, { filter: filter, sorter: sorter }), aliasDict = _a.aliasDict, filterRefAlias = _a.filterRefAlias, fromText = _a.from, currentNumber = _a.currentNumber;
         var alias = aliasDict['./'];
         var updateText = '';
         for (var attr in data) {
@@ -875,7 +946,7 @@ var SqlTranslator = /** @class */ (function () {
             var value = this.translateAttrValue(attributes[attr].type, data[attr]);
             updateText += "`".concat(alias, "`.`").concat(attr, "` = ").concat(value);
         }
-        var filterText = this.translateFilter(entity, operation, aliasDict, filterRefAlias, currentNumber, extraWhere).stmt;
+        var filterText = this.translateFilter(entity, filter, aliasDict, filterRefAlias, currentNumber).stmt;
         // const sorterText = sorter && this.translateSorter(entity, sorter, aliasDict);
         return this.populateUpdateStmt(updateText, fromText, aliasDict, filterText, /* sorterText */ undefined, indexFrom, count, option);
     };
@@ -892,7 +963,7 @@ var SqlTranslator = /** @class */ (function () {
         return sql;
     };
     SqlTranslator.prototype.escapeStringValue = function (value) {
-        var result = "'".concat(value.replace(/'/g, '\\\''), "'");
+        var result = "'".concat(value.replace(/'/g, '\\\'').replace(/"/g, '\\\"'), "'");
         return result;
     };
     return SqlTranslator;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oak-db",
-	"version": "2.2.10",
+	"version": "3.0.0",
 	"description": "oak-db",
 	"main": "lib/index",
 	"author": {
@@ -18,7 +18,7 @@
 		"lodash": "^4.17.21",
 		"mysql": "^2.18.1",
 		"mysql2": "^2.3.3",
-		"oak-domain": "^2.6.9",
+		"oak-domain": "^3.0.0",
 		"uuid": "^8.3.2"
 	},
 	"license": "ISC",
@@ -28,10 +28,11 @@
 		"@types/mocha": "^9.1.1",
 		"@types/node": "^17.0.42",
 		"@types/uuid": "^8.3.4",
+		"cross-env": "^7.0.3",
 		"mocha": "^10.0.0",
-		"oak-general-business": "^2.5.10",
+		"oak-general-business": "^3.0.0",
 		"ts-node": "~10.9.1",
 		"tslib": "^2.4.0",
 		"typescript": "~4.7.4"
 	}
-}
+}