oak-domain 1.1.14 → 2.0.2

package/lib/store/filter.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
+exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.judgeValueRelation = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
+var types_1 = require("../types");
 var lodash_1 = require("../utils/lodash");
+var relation_1 = require("./relation");
 function addFilterSegment() {
     var filters = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -96,6 +98,546 @@ function combineFilters(filters, union) {
 }
 exports.combineFilters = combineFilters;
 /**
+ * 判断value1表达的单个属性查询与同属性上value2表达的查询是包容还是相斥
+ * 相容即value1所表达的查询结果一定被value2表达的查询结果所包含，例如：
+ * value1: {
+ *  $eq: 12
+ * }
+ * value2: {
+ *  $gt: 8,
+ * }
+ * 此时value1相容value2
+ *
+ * 相斥即value1所表达的查询结果与value2一定毫无联系，例如：
+ * value1: {
+ *  $gt: 8,
+ * }
+ * value2: {
+ *  $lt: 2,
+ * }
+ *
+ *
+ * @param value1
+ * @param value2
+ * @attention: 1)这里的测试不够充分，有些算子之间的相容或相斥可能有遗漏, 2)有新的算子加入需要修改代码
+ */
+function judgeValueRelation(value1, value2, contained) {
+    if (typeof value1 === 'object') {
+        var attr = Object.keys(value1)[0];
+        if (['$gt', '$lt', '$gte', '$lte', '$eq', '$ne', '$startsWith', '$endsWith', '$includes'].includes(attr)) {
+            switch (attr) {
+                case '$gt': {
+                    if (contained) {
+                        // 包容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return ['$gt', '$gte'].includes(attr2) && value2[attr2] <= value1.$gt;
+                        }
+                        return false;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return ['$lt', '$lte', '$eq'].includes(attr2) && value2[attr2] <= value1.$gt
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$gt || ele > value1.$gt; }));
+                    }
+                    return value2 <= value1.$gt;
+                }
+                case '$gte': {
+                    if (contained) {
+                        // 包容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return ['$gte'].includes(attr2) && value2[attr2] <= value1.$gte
+                                || ['$gt'].includes(attr2) && value2[attr2] < value1.$gte;
+                        }
+                        return false;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return ['$lt'].includes(attr2) && value2[attr2] <= value1.$gte
+                            || ['$eq', '$lte'].includes(attr2) && value2[attr2] < value1.gte
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$gte || ele >= value1.$gte; }));
+                    }
+                    return value2 < value1.$gte;
+                }
+                case '$lt': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return ['$lt', '$lte'].includes(attr2) && value2[attr2] >= value1.$lt;
+                        }
+                        return false;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return ['$gt', '$gte', '$eq'].includes(attr2) && value2[attr2] >= value1.$lt
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$gt || ele < value1.$lt; }));
+                    }
+                    return value2 >= value1.$gt;
+                }
+                case '$lte': {
+                    if (contained) {
+                        // 包容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return ['$lte'].includes(attr2) && value2[attr2] >= value1.$lte
+                                || ['$lt'].includes(attr2) && value2[attr2] > value1.$lte;
+                        }
+                        return false;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return ['$gt'].includes(attr2) && value2[attr2] >= value1.$lte
+                            || ['$eq', '$gte'].includes(attr2) && value2[attr2] > value1.lte
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$lte || ele <= value1.$lte; }));
+                    }
+                    return value2 > value1.$gte;
+                }
+                case '$eq': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$eq' && value2[attr2] === value1.$eq || attr2 === '$ne' && value2[attr2] !== value1.$eq
+                                || attr2 === '$gt' && value2[attr2] < value1.$eq || attr2 === '$lt' && value2[attr2] > value1.$eq
+                                || attr2 === '$gte' && value2[attr2] <= value1.$eq || attr2 === '$lte' && value2[attr2] >= value1.$eq
+                                || attr2 === '$startsWith' && value1.$eq.startsWith(value2[attr2])
+                                || attr2 === '$endsWith' && value1.$eq.endsWith(value2[attr2])
+                                || attr2 === '$includes' && value1.$eq.includes(value2[attr2])
+                                || attr2 === '$in' && value2[attr2] instanceof Array && value2[attr2].includes(value1.$eq)
+                                || attr2 === '$nin' && value2[attr2] instanceof Array && !value2[attr2].includes(value1.$eq)
+                                || attr2 === '$between' && value2[attr2][0] <= value1.$eq && value2[attr2][1] >= value1.$eq
+                                || attr2 === '$exists' && value2[attr2] === true;
+                        }
+                        return value2 === value1.$eq;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$eq' && value2[attr2] !== value1.$eq || attr2 === '$gt' && value2[attr2] >= value1.$eq
+                            || attr2 === '$lt' && value2[attr2] <= value1.$eq
+                            || attr2 === '$gte' && value2[attr2] > value1.$eq || attr2 === '$lte' && value2[attr2] < value1.$eq
+                            || attr2 === '$startsWith' && !value1.$eq.startsWith(value2[attr2])
+                            || attr2 === '$endsWith' && !value1.$eq.endsWith(value2[attr2])
+                            || attr2 === '$includes' && !value1.$eq.includes(value2[attr2])
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !value2[attr2].includes(value1.$eq)
+                            || attr2 === '$between' && (value2[attr2][0] > value1.$eq || value2[attr2][1] < value1.$eq)
+                            || attr2 === '$exists' && value2[attr2] === false;
+                    }
+                    return value2 !== value1.$eq;
+                }
+                case '$ne': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$ne' && value2[attr2] === value1.$ne;
+                        }
+                        return false;
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$eq' && value2[attr2] === value1.$ne;
+                    }
+                    return value2 === value1.$ne;
+                }
+                case '$startsWith': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$startsWith' && typeof (value2[attr2]) === 'string'
+                                && value1.$startsWith.startsWith(value2[attr2]);
+                        }
+                        return typeof value2 === 'string' && value1.$startsWith.startsWith(value2);
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$startsWith' && typeof (value2[attr2]) === 'string'
+                            && !value1.$startsWith.startsWith(value2[attr2]) && !value2[attr2].startsWith(value1.$startsWith)
+                            || attr2 === '$eq' && !value2[attr2].startsWith(value1.$startsWith);
+                    }
+                    return !value2.startsWith(value1.$startsWith);
+                }
+                case '$endsWith': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$endsWith' && typeof (value2[attr2]) === 'string'
+                                && value1.$startsWith.endsWith(value2[attr2]);
+                        }
+                        return typeof value2 === 'string' && value1.$startsWith.endsWith(value2);
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$startsWith' && typeof (value2[attr2]) === 'string'
+                            && !value1.$startsWith.endsWith(value2[attr2]) && !value2[attr2].endsWith(value1.$startsWith)
+                            || attr2 === '$eq' && !value2[attr2].endsWith(value1.$startsWith);
+                    }
+                    return !value2.endsWith(value1.$startsWith);
+                }
+                case '$includes': {
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return ['$includes', '$startsWith', '$endsWith'].includes(attr2)
+                                && typeof (value2[attr2]) === 'string'
+                                && (value2[attr2]).includes(value1.$includes);
+                        }
+                        return typeof value2 === 'string' && value2.includes(value1.$includes);
+                    }
+                    // 互斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$eq' && !value2[attr2].includes(value1.$includes)
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !value2[attr2].find(function (ele) { return ele.includes(value1.$includes); });
+                    }
+                    return typeof value2 === 'string' && !value2.includes(value1.$includes);
+                }
+                default: {
+                    (0, assert_1.default)(false, "\u4E0D\u80FD\u5904\u7406\u7684\u7B97\u5B50\u300C".concat(attr, "\u300D"));
+                }
+            }
+        }
+        else if (['$exists'].includes(attr)) {
+            (0, assert_1.default)(attr === '$exists');
+            if (contained) {
+                if (typeof value2 === 'object') {
+                    var attr2 = Object.keys(value2)[0];
+                    return attr2 === '$exists' && value2[attr2] === value1.$exists;
+                }
+                return false;
+            }
+            return typeof value2 === 'object' && value2.$exists === !(value1.$exists);
+        }
+        else if (['$in', '$nin', '$between'].includes(attr)) {
+            switch (attr) {
+                case '$in': {
+                    if (contained) {
+                        // 相容
+                        if (value1.$in instanceof Array) {
+                            if (typeof value2 === 'object') {
+                                var attr2 = Object.keys(value2)[0];
+                                if (attr2 === '$in') {
+                                    return value2[attr2] instanceof Array && (0, lodash_1.difference)(value1.$in, value2[attr2]).length === 0;
+                                }
+                                else if (attr2 === '$nin') {
+                                    return value2[attr2] instanceof Array && (0, lodash_1.intersection)(value1.$in, value2[attr2]).length === 0;
+                                }
+                                else if (attr2 === '$exists') {
+                                    return value2[attr2] === true;
+                                }
+                                else if (['$gt', '$gte', '$lt', '$lte', '$between'].includes(attr2)) {
+                                    var min33_1, max33_1;
+                                    value1.$in.forEach(function (ele) {
+                                        if (!min33_1 || min33_1 > ele) {
+                                            min33_1 = ele;
+                                        }
+                                        if (!max33_1 || max33_1 < ele) {
+                                            max33_1 = ele;
+                                        }
+                                    });
+                                    return attr2 === '$gt' && value2[attr2] < min33_1 || attr2 === '$gte' && value2[attr2] <= min33_1
+                                        || attr2 === '$lt' && value2[attr2] > max33_1 || attr2 === '$lte' && value2[attr2] >= max33_1
+                                        || attr2 === '$between' && value2[attr2][0] < min33_1 && value2[attr2][1] > max33_1;
+                                }
+                            }
+                        }
+                        return false;
+                    }
+                    // 相斥
+                    if (value1.$in instanceof Array) {
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            if (attr2 === '$in') {
+                                return (0, lodash_1.intersection)(value2[attr2], value1.$in).length === 0;
+                            }
+                            else if (attr2 === '$eq') {
+                                return !value1.$in.includes(value2[attr2]);
+                            }
+                            else if (attr2 === '$exists') {
+                                return value2[attr2] === false;
+                            }
+                            else if (['$gt', '$gte', '$lt', '$lte', '$between'].includes(attr2)) {
+                                var min44_1, max44_1;
+                                value1.$in.forEach(function (ele) {
+                                    if (!min44_1 || min44_1 > ele) {
+                                        min44_1 = ele;
+                                    }
+                                    if (!max44_1 || max44_1 < ele) {
+                                        max44_1 = ele;
+                                    }
+                                });
+                                return attr2 === '$gt' && value2[attr2] >= max44_1 || attr2 === '$gte' && value2[attr2] > max44_1
+                                    || attr2 === '$lt' && value2[attr2] <= min44_1 || attr2 === '$lte' && value2[attr2] < min44_1
+                                    || attr2 === '$between' && (value2[attr2][0] > max44_1 || value2[attr2][1] < min44_1);
+                            }
+                        }
+                        return !value1.$in.includes(value2);
+                    }
+                    return false;
+                }
+                case '$nin': {
+                    if (contained) {
+                        // 相容
+                        if (value1.$nin instanceof Array) {
+                            if (typeof value2 === 'object') {
+                                var attr2 = Object.keys(value2)[0];
+                                if (attr2 === '$nin') {
+                                    return value2[attr2] instanceof Array && (0, lodash_1.intersection)(value2[attr2], value1.$nin).length === 0;
+                                }
+                            }
+                        }
+                        return false;
+                    }
+                    // 相斥
+                    if (value1.$nin instanceof Array) {
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            if (attr2 === '$in') {
+                                return value2[attr2] instanceof Array && (0, lodash_1.difference)(value2[attr2], value1.$nin).length === 0;
+                            }
+                        }
+                    }
+                    return false;
+                }
+                case '$between': {
+                    (0, assert_1.default)(value1.$between instanceof Array);
+                    if (contained) {
+                        // 相容
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            if (['$gt', '$gte', '$lt', '$lte', '$between', '$eq'].includes(attr2)) {
+                                return attr2 === '$between' && value2[attr2][0] <= value1.$between[0] && value2[attr2][1] >= value1.$between[1]
+                                    || attr2 === '$gt' && value2[attr2] < value1.$between[0] || attr2 === '$gte' && value2[attr2] <= value1.$between[0]
+                                    || attr2 === '$lt' && value2[attr2] > value1.$between[1] || attr2 === '$lte' && value2[attr2] >= value1.$between[1];
+                            }
+                            else if (attr2 === '$exists') {
+                                return value2[attr2] === true;
+                            }
+                        }
+                        return false;
+                    }
+                    // 相斥
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        if (['$gt', '$gte', '$lt', '$lte', '$between', '$eq'].includes(attr2)) {
+                            return attr2 === '$between' && (value2[attr2][0] > value1.$between[1] || value2[attr2][1] < value1.$between[0])
+                                || attr2 === '$gt' && value2[attr2] > value1.$between[1] || attr2 === '$gte' && value2[attr2] >= value1.$between[1]
+                                || attr2 === '$lt' && value2[attr2] < value1.$between[0] || attr2 === '$lte' && value2[attr2] <= value1.$between[0]
+                                || attr2 === '$eq' && (value2[attr2] > value1.$between[1] || value2[attr2] < value1.$between[0]);
+                        }
+                        else if (attr2 === '$exists') {
+                            return value2[attr2] === false;
+                        }
+                        else if (attr2 === '$in' && value2[attr2] instanceof Array) {
+                            return !value2[attr2].find(function (ele) { return ele >= value1.$between[0] && ele <= value1.$between[1]; });
+                        }
+                        return false;
+                    }
+                }
+                default: {
+                    (0, assert_1.default)(false, "\u6682\u4E0D\u652F\u6301\u7684\u7B97\u5B50".concat(attr));
+                }
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        // value1是一个等值查询
+        if (contained) {
+            // 相容
+            if (typeof value2 === 'object') {
+                var attr2 = Object.keys(value2)[0];
+                return attr2 === '$eq' && value2[attr2] === value1 || attr2 === '$ne' && value2[attr2] !== value1
+                    || attr2 === '$gt' && value2[attr2] < value1 || attr2 === '$lt' && value2[attr2] > value1
+                    || attr2 === '$gte' && value2[attr2] <= value1 || attr2 === '$lte' && value2[attr2] >= value1
+                    || attr2 === '$startsWith' && value1.startsWith(value2[attr2])
+                    || attr2 === '$endsWith' && value1.endsWith(value2[attr2])
+                    || attr2 === '$includes' && value1.includes(value2[attr2])
+                    || attr2 === '$in' && value2[attr2] instanceof Array && value2[attr2].includes(value1)
+                    || attr2 === '$nin' && value2[attr2] instanceof Array && !value2[attr2].includes(value1)
+                    || attr2 === '$between' && value2[attr2][0] <= value1 && value2[attr2][1] >= value1
+                    || attr2 === '$exists' && value2[attr2] === true;
+            }
+            return value2 === value1;
+        }
+        // 互斥
+        if (typeof value2 === 'object') {
+            var attr2 = Object.keys(value2)[0];
+            return attr2 === '$eq' && value2[attr2] !== value1 || attr2 === '$gt' && value2[attr2] >= value1
+                || attr2 === '$lt' && value2[attr2] <= value1
+                || attr2 === '$gte' && value2[attr2] > value1 || attr2 === '$lte' && value2[attr2] < value1
+                || attr2 === '$startsWith' && !value1.startsWith(value2[attr2])
+                || attr2 === '$endsWith' && !value1.endsWith(value2[attr2])
+                || attr2 === '$includes' && !value1.includes(value2[attr2])
+                || attr2 === '$in' && value2[attr2] instanceof Array && !value2[attr2].includes(value1)
+                || attr2 === '$between' && (value2[attr2][0] > value1 || value2[attr2][1] < value1)
+                || attr2 === '$exists' && value2[attr2] === false;
+        }
+        return value2 !== value1;
+    }
+}
+exports.judgeValueRelation = judgeValueRelation;
+function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilterAttrValue, contained) {
+    var _a;
+    for (var attr2 in filter) {
+        if (['$and', '$or', '$not'].includes(attr2)) {
+            switch (attr2) {
+                case '$and':
+                case '$or':
+                case '$xor': {
+                    var logicQueries = filter[attr2];
+                    var results = logicQueries.map(function (logicQuery) { return judgeFilter2ValueRelation(entity, schema, attr, logicQuery, conditionalFilterAttrValue, contained); });
+                    // 如果filter的多个算子是and关系，则只要有一个包含此条件就是包含，只要有一个与此条件相斥就是相斥
+                    // 如果filter的多个算子是or关系，则必须所有的条件都包含此条件才是包含，必须所有的条件都与此条件相斥才是相斥
+                    if (attr2 === '$and') {
+                        if (results.includes(true)) {
+                            return true;
+                        }
+                    }
+                    else if (attr2 === '$or') {
+                        if (!results.includes(false)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false);
+                    }
+                    break;
+                }
+                case '$not': {
+                    /*
+                    * 若filter的not条件被conditionalFilterAttrValue包容，则说明两者互斥
+                    * 若filter的not条件被conditionalFilterAttrValue的not条件所包容，则说明此条件包容conditionalFilterAttrValue
+                    *   但两条规则都没法应用，会无限递归
+                    */
+                    var logicQuery = filter[attr2];
+                    /* if (contained && judgeFilterRelation(entity, schema, {
+                        [attr2]: {
+                            $not: conditionalFilterAttrValue
+                        }
+                    }, logicQuery, contained)) {
+                        return true;
+                    } */
+                    if (!contained && judgeFilterRelation(entity, schema, (_a = {}, _a[attr2] = conditionalFilterAttrValue, _a), logicQuery, contained)) {
+                        return true;
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+        }
+        else if (attr2.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+            return false;
+        }
+        else if (attr2.toLowerCase() === '$text') {
+            return false;
+        }
+        else {
+            if (attr === attr2) {
+                var rel = (0, relation_1.judgeRelation)(schema, entity, attr2);
+                if (rel === 1) {
+                    return judgeValueRelation(filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else if (rel === 2) {
+                    return judgeFilterRelation(attr2, schema, filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else if (typeof rel === 'string') {
+                    return judgeFilterRelation(rel, schema, filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else {
+                    (0, assert_1.default)(false);
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ * @param contained: true代表filter包容conditionalFilter, false代表filter与conditionalFilter相斥
+ */
+function judgeFilterRelation(entity, schema, filter, conditionalFilter, contained) {
+    for (var attr in conditionalFilter) {
+        if (['$and', '$or', '$not'].includes(attr)) {
+            switch (attr) {
+                case '$and':
+                case '$or': {
+                    var logicQueries = conditionalFilter[attr];
+                    var results = logicQueries.map(function (logicQuery) { return judgeFilterRelation(entity, schema, filter, logicQuery, contained); });
+                    if (contained) {
+                        // 如果是包容关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当被filter所包容
+                        if (results.includes(false)) {
+                            return false;
+                        }
+                    }
+                    else if (!contained) {
+                        // 如果是相斥关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当与filter所相斥
+                        if (!results.includes(true)) {
+                            return false;
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false);
+                    }
+                    break;
+                }
+                case '$not': {
+                    /**
+                     * 若filter与not所定义的filter相斥，则filter与conditionalFilter相容
+                     * 若filter与not所定义的filter相容，则filter与conditionalFilter相斥
+                     */
+                    var logicQuery = conditionalFilter[attr];
+                    if (judgeFilterRelation(entity, schema, filter, logicQuery, !contained)) {
+                        return true;
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error("\u6682\u4E0D\u652F\u6301\u7684\u903B\u8F91\u7B97\u5B50".concat(attr));
+                }
+            }
+        }
+        else if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+            return false;
+        }
+        else if (attr.toLowerCase() === '$text') {
+            return false;
+        }
+        else {
+            if (contained && !judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilter[attr], contained)) {
+                // 相容关系只要有一个不相容就不相容
+                return false;
+            }
+            if (!contained && judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilter[attr], contained)) {
+                // 相斥关系只要有一个相斥就相斥
+                return true;
+            }
+        }
+    }
+    // 到这里说明不能否定其相容（所以要返回相容），也不能肯定其相斥（所以要返回不相斥）
+    return contained;
+}
+/**
+ *
  * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
  * filter = {
  *      a: 1
@@ -110,9 +652,10 @@ exports.combineFilters = combineFilters;
  * @param schema
  * @param filter
  * @param conditionalFilter
+ * @returns
  */
 function contains(entity, schema, filter, conditionalFilter) {
-    // todo
+    // return judgeFilterRelation(entity, schema, filter, conditionalFilter, true);
     return false;
 }
 exports.contains = contains;
@@ -132,6 +675,7 @@ exports.contains = contains;
  */
 function repel(entity, schema, filter1, filter2) {
     // todo
+    // return judgeFilterRelation(entity, schema, filter1, filter2, false);
     return false;
 }
 exports.repel = repel;
@@ -284,3 +828,28 @@ function makeTreeDescendantFilter(entity, parentKey, filter, level, includeAll,
     return currentLevelInFilter;
 }
 exports.makeTreeDescendantFilter = makeTreeDescendantFilter;
+function checkFilterContains(entity, context, contained, filter) {
+    if (!filter) {
+        throw new types_1.OakRowInconsistencyException();
+    }
+    var schema = context.getSchema();
+    // 优先判断两个条件是否相容
+    if (contains(entity, schema, filter, contained)) {
+        return true;
+    }
+    // 再判断加上了conditionalFilter后取得的行数是否缩减
+    var filter2 = combineFilters([filter, {
+            $not: contained,
+        }]);
+    var count = context.count(entity, {
+        filter: filter2,
+    }, {
+        dontCollect: true,
+        blockTrigger: true,
+    });
+    if (count instanceof Promise) {
+        return count.then(function (count2) { return count2 === 0; });
+    }
+    return count === 0;
+}
+exports.checkFilterContains = checkFilterContains;

package/lib/store/modi.d.ts

@@ -1,12 +1,13 @@
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { UniversalContext } from '../store/UniversalContext';
 import { OpSchema as Modi } from '../base-app-domain/Modi/Schema';
-import { Checker, Operation, StorageSchema, EntityDict, Context, OperateOption, Trigger } from '../types';
+import { Operation, StorageSchema, RowChecker, EntityDict, OperateOption, Trigger } from '../types';
+import { AsyncContext } from './AsyncRowStore';
+import { SyncContext } from './SyncRowStore';
 export declare function createOperationsFromModies(modies: Modi[]): Array<{
     operation: Operation<string, Object, Object>;
     entity: string;
 }>;
-export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends UniversalContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends UniversalContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];
-export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];
+export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): RowChecker<ED, keyof ED, Cxt>[];
+export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];