1981 lines
84 KiB
JavaScript
1981 lines
84 KiB
JavaScript
import { cloneDeep, get, groupBy, set, unset, uniqBy, uniq, differenceBy, intersectionBy, pull, pick } from 'oak-domain/lib/utils/lodash';
|
||
import { assert } from 'oak-domain/lib/utils/assert';
|
||
import { DeleteAtAttribute, CreateAtAttribute, UpdateAtAttribute } from "oak-domain/lib/types/Entity";
|
||
import { EXPRESSION_PREFIX, SUB_QUERY_PREDICATE_KEYWORD } from 'oak-domain/lib/types/Demand';
|
||
import { OakCongruentRowExists, OakException } from 'oak-domain/lib/types/Exception';
|
||
import { isRefAttrNode } from 'oak-domain/lib/types/Demand';
|
||
import { judgeRelation } from 'oak-domain/lib/store/relation';
|
||
// Expression引入，下方声明改为any防止报错
|
||
import { execOp, isExpression, opMultipleParams } from 'oak-domain/lib/types/Expression';
|
||
import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
|
||
import { CascadeStore, polishSelection } from 'oak-domain/lib/store/CascadeStore';
|
||
import { SeqAttribute } from 'oak-domain/lib/types';
|
||
import { combineFilters, getRelevantIds } from 'oak-domain/lib/store/filter';
|
||
;
|
||
;
|
||
class OakExpressionUnresolvedException extends OakException {
|
||
}
|
||
function showWarningAttributeMiss(entity, attr) {
|
||
console.warn(`attribute miss: entity: ${entity}, attr: ${attr}`);
|
||
}
|
||
;
|
||
export default class TreeStore extends CascadeStore {
|
||
store;
|
||
seq;
|
||
activeTxnDict;
|
||
stat;
|
||
getNextSeq(entity) {
|
||
if (this.seq[entity]) {
|
||
const seq = this.seq[entity];
|
||
this.seq[entity]++;
|
||
return seq;
|
||
}
|
||
this.seq[entity] = 2;
|
||
return 1;
|
||
}
|
||
setMaxSeq(entity, seq) {
|
||
if (this.seq[entity]) {
|
||
if (this.seq[entity] < seq) {
|
||
this.seq[entity] = seq;
|
||
}
|
||
}
|
||
else {
|
||
this.seq[entity] = seq;
|
||
}
|
||
}
|
||
/* treeStore改成同步以后不会再出现
|
||
private async waitOnTxn(id: string, context: Cxt) {
|
||
// 先检查自己的等待者中有没有id，以避免死锁
|
||
const myId = context.getCurrentTxnId()!;
|
||
const { waitList: myWaitList } = this.activeTxnDict[myId];
|
||
if (myWaitList.find(
|
||
ele => ele.id === id
|
||
)) {
|
||
throw new OakDeadlock();
|
||
}
|
||
const { waitList } = this.activeTxnDict[id];
|
||
const p = new Promise(
|
||
(resolve) => waitList.push({
|
||
id: myId,
|
||
fn: resolve,
|
||
})
|
||
);
|
||
await p;
|
||
} */
|
||
supportMultipleCreate() {
|
||
return false;
|
||
}
|
||
supportManyToOneJoin() {
|
||
return false;
|
||
}
|
||
resetInitialData(data, stat) {
|
||
this.store = {};
|
||
const now = Date.now();
|
||
const schema = this.getSchema();
|
||
for (const entity in data) {
|
||
if (!schema[entity]) {
|
||
throw new Error(`reset unknown entity:[${entity}]`);
|
||
}
|
||
const { attributes } = schema[entity];
|
||
this.store[entity] = {};
|
||
for (const row of data[entity]) {
|
||
for (const key in attributes) {
|
||
if (row[key] === undefined) {
|
||
Object.assign(row, {
|
||
[key]: null,
|
||
});
|
||
}
|
||
}
|
||
/**
|
||
* 处理初始化数据
|
||
*/
|
||
if (!row[CreateAtAttribute]) {
|
||
Object.assign(row, {
|
||
[CreateAtAttribute]: now,
|
||
});
|
||
}
|
||
if (!row[DeleteAtAttribute]) {
|
||
Object.assign(row, {
|
||
[DeleteAtAttribute]: null,
|
||
});
|
||
}
|
||
if (!row[UpdateAtAttribute]) {
|
||
Object.assign(row, {
|
||
[UpdateAtAttribute]: now,
|
||
});
|
||
}
|
||
if (!row[SeqAttribute]) {
|
||
const seq = this.getNextSeq(entity);
|
||
Object.assign(row, {
|
||
[SeqAttribute]: seq,
|
||
});
|
||
}
|
||
else {
|
||
this.setMaxSeq(entity, row[SeqAttribute] + 1);
|
||
}
|
||
assert(row.id && !row.id.includes('.'));
|
||
set(this.store, `${entity}.${row.id}.$current`, row);
|
||
}
|
||
}
|
||
if (stat) {
|
||
this.stat = stat;
|
||
}
|
||
}
|
||
getCurrentData(keys) {
|
||
const result = {};
|
||
for (const entity in this.store) {
|
||
if (keys && !keys.includes(entity)) {
|
||
continue;
|
||
}
|
||
result[entity] = [];
|
||
for (const rowId in this.store[entity]) {
|
||
result[entity]?.push(this.store[entity][rowId]['$current']);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
constructor(storageSchema) {
|
||
super(storageSchema);
|
||
this.store = {};
|
||
this.activeTxnDict = {};
|
||
this.stat = {
|
||
create: 0,
|
||
update: 0,
|
||
remove: 0,
|
||
commit: 0,
|
||
};
|
||
this.seq = {};
|
||
}
|
||
constructRow(node, context, option) {
|
||
if (context.getCurrentTxnId() && node.$txnId === context.getCurrentTxnId()) {
|
||
if (!node.$next) {
|
||
// 如果要求返回delete数据，返回带$$deleteAt$$的行
|
||
// bug fixed，这里如果是自己create再删除，data也是null
|
||
if (node.$current && option?.includedDeleted) {
|
||
return Object.assign({}, node.$current, {
|
||
[DeleteAtAttribute]: 1,
|
||
});
|
||
}
|
||
return null;
|
||
}
|
||
else if (!node.$current) {
|
||
// 本事务创建的，若在cache中$$createAt$$和$$updateAt$$置为1
|
||
return Object.assign({}, node.$current, node.$next, context instanceof SyncContext && {
|
||
[CreateAtAttribute]: 1,
|
||
[UpdateAtAttribute]: 1,
|
||
});
|
||
}
|
||
else {
|
||
// 本事务更新的，若在cache中$$updateAt$$置为1
|
||
return Object.assign({}, node.$current, node.$next, context instanceof SyncContext && {
|
||
[UpdateAtAttribute]: 1,
|
||
});
|
||
}
|
||
}
|
||
return {
|
||
...node.$current,
|
||
};
|
||
}
|
||
testFilterFns(node, nodeDict, exprResolveFns, fns) {
|
||
const { self, otm, mto } = fns;
|
||
// 三种filterFn是and的关系，有一个失败就返回false，优先判断顺序：self -> mto -> otm
|
||
for (const f of self) {
|
||
if (!f(node, nodeDict, exprResolveFns)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (const f of mto) {
|
||
if (!f(node, nodeDict, exprResolveFns)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (const f of otm) {
|
||
if (!f(node, nodeDict, exprResolveFns)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
translateLogicFilter(entity, projection, filter, attr, context, option) {
|
||
const self = [];
|
||
const otm = [];
|
||
const mto = [];
|
||
switch (attr) {
|
||
case '$and': {
|
||
const filters = filter[attr];
|
||
const fns = filters.map((ele) => this.translateFilterInner(entity, projection, ele, context, option));
|
||
self.push(...(fns.map(ele => ele.self).flat()));
|
||
otm.push(...(fns.map(ele => ele.otm).flat()));
|
||
mto.push(...(fns.map(ele => ele.mto).flat()));
|
||
break;
|
||
}
|
||
case '$or': {
|
||
const filters = filter[attr];
|
||
const fns = filters.map((ele) => this.translateFilterInner(entity, projection, ele, context, option));
|
||
/**
|
||
* 对于or的情况，按最坏的一种判定来计算，同时对所有的判定也可以排序，先计算代价最轻的
|
||
*/
|
||
fns.sort((ele1, ele2) => {
|
||
if (ele2.mto.length > 0) {
|
||
return -1;
|
||
}
|
||
else if (ele1.mto.length > 0) {
|
||
return 1;
|
||
}
|
||
else if (ele2.otm.length > 0) {
|
||
return -1;
|
||
}
|
||
else if (ele1.otm.length > 0) {
|
||
return 1;
|
||
}
|
||
return 0;
|
||
});
|
||
const fn = (node, nodeDict, exprResolveFns) => {
|
||
for (const fn of fns) {
|
||
if (this.testFilterFns(node, nodeDict, exprResolveFns, fn)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
const last = fns[fns.length - 1];
|
||
if (last.mto.length > 0) {
|
||
mto.push(fn);
|
||
}
|
||
else if (last.otm.length > 0) {
|
||
otm.push(fn);
|
||
}
|
||
else {
|
||
self.push(fn);
|
||
}
|
||
break;
|
||
}
|
||
case '$not': {
|
||
const filter2 = filter[attr];
|
||
const filterFn = this.translateFilterInner(entity, projection, filter2, context, option);
|
||
const fn = (node, nodeDict, exprResolveFns) => {
|
||
if (this.testFilterFns(node, nodeDict, exprResolveFns, filterFn)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
};
|
||
if (filterFn.otm.length > 0) {
|
||
otm.push(fn);
|
||
}
|
||
else if (filterFn.mto.length > 0) {
|
||
mto.push(fn);
|
||
}
|
||
else {
|
||
self.push(fn);
|
||
}
|
||
break;
|
||
}
|
||
default: {
|
||
assert(false, `${attr}算子暂不支持`);
|
||
}
|
||
}
|
||
return {
|
||
self,
|
||
otm,
|
||
mto,
|
||
};
|
||
}
|
||
/**
|
||
* 对表达式中某个结点的翻译，有三种情况：
|
||
* 1、结点是一个表达式，此时递归翻译其子结点
|
||
* 2、结点是一个常量，直接返回
|
||
* 3、结点引用了某个属性，此时返回一个函数（ExprNodeTranslator），该函数在实际执行时对某行进行处理，又可能有两种case：
|
||
* 3.1、得到结果，此时返回结果的值（常量）
|
||
* 3.2、还欠缺某些外部结点的值才能得到结果，此时返回一个函数（ExprLaterCheckFn），此函数可以在执行中获得更多结点之后再调用并得到结果的值
|
||
* @param entity
|
||
* @param expression
|
||
* @param context
|
||
* @returns
|
||
*/
|
||
translateExpressionNode(entity,
|
||
// expression: Expression<keyof ED[T]['Schema']> | RefAttr<keyof ED[T]['Schema']> | ExpressionConstant,
|
||
expression, context, option) {
|
||
if (isExpression(expression)) {
|
||
const op = Object.keys(expression)[0];
|
||
const option2 = expression[op];
|
||
if (opMultipleParams(op)) {
|
||
const paramsTranslated = option2.map(
|
||
// const paramsTranslated = (option2 as (Expression<keyof ED[T]['Schema']> | RefAttr<keyof ED[T]['Schema']>)[]).map(
|
||
ele => this.translateExpressionNode(entity, ele, context, option2));
|
||
return (row, nodeDict) => {
|
||
let later = false;
|
||
let results = paramsTranslated.map((ele) => {
|
||
if (typeof ele === 'function') {
|
||
const r = ele(row, nodeDict);
|
||
if (typeof r === 'function') {
|
||
later = true;
|
||
}
|
||
return r;
|
||
}
|
||
return ele;
|
||
});
|
||
if (!later) {
|
||
return execOp(op, results);
|
||
}
|
||
const laterCheckFn = (nodeDict2) => {
|
||
results = results.map((ele) => {
|
||
if (typeof ele === 'function') {
|
||
const r = ele(nodeDict2);
|
||
return r;
|
||
}
|
||
return ele;
|
||
});
|
||
if (results.find(ele => typeof ele === 'function')) {
|
||
return laterCheckFn;
|
||
}
|
||
return execOp(op, results);
|
||
};
|
||
return laterCheckFn;
|
||
};
|
||
}
|
||
else {
|
||
const paramsTranslated = this.translateExpressionNode(entity, option2, context, option2);
|
||
if (typeof paramsTranslated === 'function') {
|
||
return (row, nodeDict) => {
|
||
let result = paramsTranslated(row, nodeDict);
|
||
if (typeof result === 'function') {
|
||
const laterCheckFn = (nodeDict2) => {
|
||
result = result(nodeDict2);
|
||
if (typeof result === 'function') {
|
||
return laterCheckFn;
|
||
}
|
||
return result;
|
||
};
|
||
return laterCheckFn;
|
||
}
|
||
return execOp(op, result);
|
||
};
|
||
}
|
||
else {
|
||
return () => {
|
||
return execOp(op, paramsTranslated);
|
||
};
|
||
}
|
||
}
|
||
}
|
||
else if (isRefAttrNode(expression)) {
|
||
// 是RefAttr结点
|
||
return (row, nodeDict) => {
|
||
if (expression.hasOwnProperty('#attr')) {
|
||
// 说明是本结点的属性;
|
||
const attr = row[expression['#attr']];
|
||
if (attr === undefined && option?.warnWhenAttributeMiss) {
|
||
showWarningAttributeMiss(entity, expression['#attr']);
|
||
}
|
||
return attr;
|
||
}
|
||
else {
|
||
assert(expression.hasOwnProperty('#refId'));
|
||
const { ['#refId']: refId, ['#refAttr']: refAttr } = expression;
|
||
if (nodeDict.hasOwnProperty(refId)) {
|
||
return nodeDict[refId][refAttr];
|
||
}
|
||
// 引用的结点还没有取到，此时需要在未来的某个时刻再检查
|
||
const laterCheckFn = (nodeDict2) => {
|
||
if (nodeDict2.hasOwnProperty(refId)) {
|
||
return nodeDict2[refId][refAttr];
|
||
}
|
||
return laterCheckFn;
|
||
};
|
||
return laterCheckFn;
|
||
}
|
||
};
|
||
}
|
||
else {
|
||
// 是常量结点
|
||
return expression;
|
||
}
|
||
}
|
||
translateExpression(entity,
|
||
// expression: Expression<keyof ED[T]['Schema']>,
|
||
expression, context, option) {
|
||
const expr = this.translateExpressionNode(entity, expression, context, option);
|
||
return (row, nodeDict) => {
|
||
if (typeof expr !== 'function') {
|
||
return expr;
|
||
}
|
||
const result = expr(row, nodeDict);
|
||
return result;
|
||
};
|
||
}
|
||
translateFulltext(entity, filter, context, option) {
|
||
// 全文索引查找
|
||
const { [entity]: { indexes } } = this.getSchema();
|
||
const fulltextIndex = indexes.find(ele => ele.config && ele.config.type === 'fulltext');
|
||
const { attributes } = fulltextIndex;
|
||
const { $search } = filter;
|
||
return (node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (row) {
|
||
for (const attr of attributes) {
|
||
const { name } = attr;
|
||
const value = row[name];
|
||
if (value === undefined && option?.warnWhenAttributeMiss) {
|
||
showWarningAttributeMiss(entity, name);
|
||
}
|
||
if (typeof value === 'string' && row[name].includes($search)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
}
|
||
translatePredicate(entity, path, predicate, value, option) {
|
||
switch (predicate) {
|
||
case '$gt': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data > value;
|
||
};
|
||
}
|
||
case '$lt': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data < value;
|
||
};
|
||
}
|
||
case '$gte': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data >= value;
|
||
};
|
||
}
|
||
case '$lte': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data <= value;
|
||
};
|
||
}
|
||
case '$eq': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data === value;
|
||
};
|
||
}
|
||
case '$ne': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data !== value;
|
||
};
|
||
}
|
||
case '$between': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['number', 'string'].includes(typeof data) && data >= value[0] && data <= value[1];
|
||
};
|
||
}
|
||
case '$mod': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return typeof data === 'number' && data % value[0] === value[1];
|
||
};
|
||
}
|
||
case '$startsWith': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['string'].includes(typeof data) && data.startsWith(value);
|
||
};
|
||
}
|
||
case '$endsWith': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['string'].includes(typeof data) && data.endsWith(value);
|
||
};
|
||
}
|
||
case '$includes': {
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return ['string'].includes(typeof data) && data.includes(value);
|
||
};
|
||
}
|
||
case '$exists': {
|
||
assert(typeof value === 'boolean');
|
||
return (row) => {
|
||
// JsonFilter有可能是根结点，path为空
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
if (value) {
|
||
return ![null, undefined].includes(data);
|
||
}
|
||
else {
|
||
return [null, undefined].includes(data);
|
||
}
|
||
};
|
||
}
|
||
case '$in': {
|
||
assert(value instanceof Array);
|
||
return (row) => {
|
||
const data = get(row, path);
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return value.includes(data);
|
||
};
|
||
}
|
||
case '$nin': {
|
||
assert(value instanceof Array);
|
||
return (row) => {
|
||
const data = get(row, path);
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return !value.includes(data);
|
||
};
|
||
}
|
||
case '$contains': {
|
||
// json中的多值查询
|
||
const array = value instanceof Array ? value : [value];
|
||
return (row) => {
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return differenceBy(array, data, (value) => {
|
||
if (typeof value === 'object') {
|
||
return JSON.stringify(value);
|
||
}
|
||
return value;
|
||
}).length === 0;
|
||
};
|
||
}
|
||
case '$overlaps': {
|
||
// json中的多值查询
|
||
const array = value instanceof Array ? value : [value];
|
||
return (row) => {
|
||
const data = path ? get(row, path) : row;
|
||
data === undefined && option?.warnWhenAttributeMiss && showWarningAttributeMiss(entity, path);
|
||
return intersectionBy(array, data, (value) => {
|
||
if (typeof value === 'object') {
|
||
return JSON.stringify(value);
|
||
}
|
||
return value;
|
||
}).length > 0;
|
||
};
|
||
}
|
||
case '$length': {
|
||
// json中的数组长度查询
|
||
const length = value;
|
||
return (row) => {
|
||
const data = path ? get(row, path) : row;
|
||
assert(data instanceof Array, '$length operator can only used on array attribute');
|
||
if (typeof length === 'number') {
|
||
return data.length === length;
|
||
}
|
||
else {
|
||
const op = Object.keys(length)[0];
|
||
return this.translatePredicate(entity, 'length', op, length[op], option)(data);
|
||
}
|
||
};
|
||
}
|
||
default: {
|
||
throw new Error(`predicate ${predicate} is not recoganized`);
|
||
}
|
||
}
|
||
}
|
||
translateObjectPredicate(entity, filter) {
|
||
const fns = [];
|
||
const translatePredicateInner = (p, path, fns2) => {
|
||
if (p instanceof Array) {
|
||
p.forEach((ele, idx) => {
|
||
const path2 = `${path}[${idx}]`;
|
||
if (typeof ele !== 'object') {
|
||
if (![null, undefined].includes(ele)) {
|
||
fns2.push(this.translatePredicate(entity, path2, '$eq', ele));
|
||
}
|
||
}
|
||
else {
|
||
translatePredicateInner(ele, path2, fns2);
|
||
}
|
||
});
|
||
}
|
||
else {
|
||
for (const attr in p) {
|
||
if (attr === '$and') {
|
||
p[attr].forEach((p2) => translatePredicateInner(p2, path, fns2));
|
||
}
|
||
else if (attr === '$or') {
|
||
const fnsOr = [];
|
||
p[attr].forEach((p2) => translatePredicateInner(p2, path, fnsOr));
|
||
fns2.push((value) => {
|
||
for (const fnOr of fnsOr) {
|
||
if (fnOr(value)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
});
|
||
}
|
||
else if (attr.startsWith('$')) {
|
||
assert(Object.keys(p).length === 1);
|
||
fns2.push(this.translatePredicate(entity, path, attr, p[attr]));
|
||
}
|
||
else {
|
||
const attr2 = attr.startsWith('.') ? attr.slice(1) : attr;
|
||
const path2 = path ? `${path}.${attr2}` : attr2;
|
||
if (typeof p[attr] !== 'object') {
|
||
fns2.push(this.translatePredicate(entity, path2, '$eq', p[attr]));
|
||
}
|
||
else {
|
||
translatePredicateInner(p[attr], path2, fns2);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
translatePredicateInner(filter, '', fns);
|
||
return (value) => {
|
||
for (const fn of fns) {
|
||
if (!fn(value)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
};
|
||
}
|
||
translateAttribute(entity, filter, attr, context, option) {
|
||
if (!['object', 'array'].includes(this.getSchema()[entity].attributes[attr]?.type)) {
|
||
if (typeof filter !== 'object') {
|
||
return (node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (row) {
|
||
const value = row[attr];
|
||
if (value === undefined && option?.warnWhenAttributeMiss) {
|
||
showWarningAttributeMiss(entity, attr);
|
||
}
|
||
return value === filter;
|
||
}
|
||
return false;
|
||
};
|
||
}
|
||
else {
|
||
const predicate = Object.keys(filter)[0];
|
||
assert(Object.keys(filter).length === 1 && predicate.startsWith('$'));
|
||
if (['$in', '$nin'].includes(predicate) && !(filter[predicate] instanceof Array)) {
|
||
throw new Error('子查询已经改用一对多的外键连接方式');
|
||
}
|
||
else {
|
||
const fn = this.translatePredicate(entity, attr, predicate, filter[predicate], option);
|
||
return (node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
return fn(row);
|
||
};
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
// 对象的内部查询
|
||
if (typeof filter !== 'object') {
|
||
// 支持filter全值相等的查询方式
|
||
assert(typeof filter === 'string');
|
||
return (node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
return row.hasOwnProperty(attr) && JSON.stringify(row[attr]) === filter;
|
||
};
|
||
}
|
||
else {
|
||
const fn = this.translateObjectPredicate(entity, filter);
|
||
return (node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
return fn(row[attr]);
|
||
};
|
||
}
|
||
}
|
||
}
|
||
translateFilterInner(entity, projection, filter, context, option) {
|
||
const self = [];
|
||
const otm = [];
|
||
const mto = [];
|
||
let nodeId;
|
||
for (const attr in filter) {
|
||
if (attr === '#id') {
|
||
nodeId = filter['#id'];
|
||
}
|
||
else if (['$and', '$or', '$xor', '$not'].includes(attr)) {
|
||
const filterFns = this.translateLogicFilter(entity, projection, filter, attr, context, option);
|
||
self.push(...(filterFns.self));
|
||
otm.push(...(filterFns.otm));
|
||
mto.push(...(filterFns.mto));
|
||
}
|
||
else if (attr.toLowerCase().startsWith(EXPRESSION_PREFIX)) {
|
||
const fn = this.translateExpression(entity, filter[attr], context, option);
|
||
// expression上先假设大都是只查询自身和外层的属性，不一定对。by Xc 20230824
|
||
self.push((node, nodeDict, exprResolveFns) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
const result = fn(row, nodeDict);
|
||
if (typeof result === 'function') {
|
||
exprResolveFns.push(result);
|
||
}
|
||
return !!result;
|
||
});
|
||
}
|
||
else if (attr.toLowerCase() === '$text') {
|
||
self.push(this.translateFulltext(entity, filter[attr], context, option));
|
||
}
|
||
else {
|
||
// 属性级过滤
|
||
const relation = judgeRelation(this.getSchema(), entity, attr);
|
||
if (relation === 1) {
|
||
// 行本身的属性
|
||
self.push(this.translateAttribute(entity, filter[attr], attr, context, option));
|
||
}
|
||
else if (relation === 2) {
|
||
// 基于entity/entityId的指针
|
||
const filterFn = this.translateFilter(attr, projection[attr] || {}, filter[attr], context, option);
|
||
mto.push((node, nodeDict, exprResolveFns) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
if (row.entityId === undefined || row.entity === undefined) {
|
||
if (option?.warnWhenAttributeMiss) {
|
||
showWarningAttributeMiss(entity, 'entity/entityId');
|
||
}
|
||
return false; // 若不能确定，认定为条件不满足
|
||
}
|
||
if (row.entity !== attr) {
|
||
return false;
|
||
}
|
||
if (row.entityId === null) {
|
||
return false;
|
||
}
|
||
const node2 = get(this.store, `${attr}.${row.entityId}`);
|
||
if (!node2) {
|
||
return false;
|
||
}
|
||
return filterFn(node2, nodeDict, exprResolveFns);
|
||
});
|
||
}
|
||
else if (typeof relation === 'string') {
|
||
// 只能是基于普通属性的外键
|
||
const filterFn = this.translateFilter(relation, projection[attr] || {}, filter[attr], context, option);
|
||
mto.push((node, nodeDict, exprResolveFns) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
if (row[`${attr}Id`]) {
|
||
const node2 = get(this.store, `${relation}.${row[`${attr}Id`]}`);
|
||
if (!node2) {
|
||
return false;
|
||
}
|
||
return filterFn(node2, nodeDict, exprResolveFns);
|
||
}
|
||
if (row[`${attr}Id`] === undefined) {
|
||
if (option?.warnWhenAttributeMiss) {
|
||
showWarningAttributeMiss(entity, `${attr}Id`);
|
||
}
|
||
}
|
||
return false;
|
||
});
|
||
}
|
||
else if (relation instanceof Array) {
|
||
// 一对多的子查询
|
||
const [otmEntity, otmForeignKey] = relation;
|
||
const predicate = filter[attr][SUB_QUERY_PREDICATE_KEYWORD] || 'in';
|
||
const fk = otmForeignKey || 'entityId';
|
||
const otmProjection = {
|
||
id: 1,
|
||
[fk]: 1,
|
||
};
|
||
/**
|
||
* in代表外键连接后至少有一行数据
|
||
* not in代表外键连接后一行也不能有
|
||
* all代表反连接条件的一行也不能有（符合的是否至少要有一行？直觉上没这个限制）
|
||
* not all 代表反连接条件的至少有一行
|
||
*
|
||
* 此时还没有确定父行，只有查询中明确带有id的查询可以先执行，否则不执行，暂先这个逻辑 by Xc 20230725
|
||
*/
|
||
const makeAfterLogic = () => {
|
||
otm.push((node, nodeDict) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
/**
|
||
* in代表外键连接后至少有一行数据
|
||
* not in代表外键连接后一行也不能有
|
||
* all代表反连接条件的一行也不能有（符合的是否至少要有一行？直觉上没这个限制）
|
||
* not all 代表反连接条件的至少有一行
|
||
*/
|
||
const otmOriginFilter = !otmForeignKey ? Object.assign({
|
||
entity,
|
||
}, cloneDeep(filter[attr])) : cloneDeep(filter[attr]);
|
||
const otmFilter = ['not in', 'in'].includes(predicate) ? combineFilters(otmEntity, this.getSchema(), [
|
||
otmOriginFilter, {
|
||
[fk]: row.id,
|
||
}
|
||
]) : {
|
||
$not: otmOriginFilter,
|
||
[fk]: row.id,
|
||
};
|
||
const subQuerySet = (this.selectAbjointRow(otmEntity, {
|
||
data: otmProjection,
|
||
filter: otmFilter,
|
||
indexFrom: 0,
|
||
count: 1,
|
||
}, context, {
|
||
...option,
|
||
nodeDict,
|
||
dontCollect: true,
|
||
warnWhenAttributeMiss: false, // 一对多连接不必要考虑这个属性缺失
|
||
})).map((ele) => {
|
||
return (ele)[fk];
|
||
});
|
||
switch (predicate) {
|
||
case 'in':
|
||
case 'not all': {
|
||
return subQuerySet.length > 0;
|
||
}
|
||
case 'not in':
|
||
case 'all': {
|
||
return subQuerySet.length === 0;
|
||
}
|
||
default: {
|
||
throw new Error(`illegal sqp: ${predicate}`);
|
||
}
|
||
}
|
||
});
|
||
};
|
||
if (filter.id && typeof filter.id === 'string') {
|
||
const otmOriginFilter = !otmForeignKey ? Object.assign({
|
||
entity,
|
||
}, cloneDeep(filter[attr])) : cloneDeep(filter[attr]);
|
||
const otmFilter = ['not in', 'in'].includes(predicate) ? combineFilters(otmEntity, this.getSchema(), [
|
||
otmOriginFilter, {
|
||
[fk]: filter.id,
|
||
}
|
||
]) : {
|
||
$not: otmOriginFilter,
|
||
[fk]: filter.id,
|
||
};
|
||
try {
|
||
const subQuerySet = (this.selectAbjointRow(otmEntity, {
|
||
data: otmProjection,
|
||
filter: otmFilter,
|
||
indexFrom: 0,
|
||
count: 1,
|
||
}, context, {
|
||
...option,
|
||
dontCollect: true,
|
||
warnWhenAttributeMiss: false, // 一对多连接不必要考虑这个属性缺失
|
||
})).map((ele) => {
|
||
return (ele)[fk];
|
||
});
|
||
self.push((node) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
switch (predicate) {
|
||
case 'in':
|
||
case 'not all': {
|
||
return subQuerySet.length > 0;
|
||
}
|
||
case 'not in':
|
||
case 'all': {
|
||
return subQuerySet.length === 0;
|
||
}
|
||
default: {
|
||
throw new Error(`illegal sqp: ${predicate}`);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
catch (err) {
|
||
if (err instanceof OakExpressionUnresolvedException) {
|
||
makeAfterLogic();
|
||
}
|
||
else {
|
||
throw err;
|
||
}
|
||
}
|
||
}
|
||
else if (!option?.disableSubQueryHashjoin) {
|
||
/**
|
||
* 尝试用hashjoin将内表数组取出，因为memory中的表都不会太大，且用不了索引（未来优化了可能可以用id直接取值），因而用hash应当会更快
|
||
*/
|
||
try {
|
||
const subQueryRows = this.selectAbjointRow(otmEntity, {
|
||
data: otmProjection,
|
||
filter: filter[attr],
|
||
}, context, {
|
||
...option,
|
||
dontCollect: true,
|
||
warnWhenAttributeMiss: false, // 一对多连接不必要考虑这个属性缺失
|
||
});
|
||
const buckets = groupBy(subQueryRows, fk);
|
||
otm.push((node, nodeDict) => {
|
||
const row = this.constructRow(node, context, option);
|
||
if (!row) {
|
||
return false;
|
||
}
|
||
switch (predicate) {
|
||
case 'in': {
|
||
return (buckets[row.id]?.length > 0);
|
||
}
|
||
case 'not in': {
|
||
return (!buckets[row.id] || buckets[row.id].length === 0);
|
||
}
|
||
case 'all': {
|
||
return (buckets[row.id]?.length > 0 && Object.keys(buckets).length === 1);
|
||
}
|
||
case 'not all': {
|
||
return Object.keys(buckets).length > 1 || !buckets.hasOwnProperty(row.id);
|
||
}
|
||
default: {
|
||
assert(false, `unrecoganized sqp operator: ${predicate}`);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
catch (err) {
|
||
if (err instanceof OakExpressionUnresolvedException) {
|
||
makeAfterLogic();
|
||
}
|
||
else {
|
||
throw err;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
makeAfterLogic();
|
||
}
|
||
}
|
||
else {
|
||
// metadata
|
||
assert(relation === 0);
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
self,
|
||
otm,
|
||
mto,
|
||
nodeId,
|
||
};
|
||
}
|
||
translateFilter(entity, projection, filter, context, option) {
|
||
const filterFns = this.translateFilterInner(entity, projection, filter, context, option);
|
||
const { nodeId } = filterFns;
|
||
return (node, nodeDict, exprResolveFns) => {
|
||
if (nodeId) {
|
||
assert(!nodeDict.hasOwnProperty(nodeId), `Filter中的nodeId「${nodeId}」出现了多次`);
|
||
Object.assign(nodeDict, {
|
||
[nodeId]: this.constructRow(node, context, option),
|
||
});
|
||
}
|
||
return this.testFilterFns(node, nodeDict, exprResolveFns, filterFns);
|
||
};
|
||
}
|
||
translateSorter(entity, sorter, context, option) {
|
||
const compare = (row1, row2, entity2, sortAttr, direction) => {
|
||
const row11 = row1;
|
||
const row22 = row2;
|
||
assert(Object.keys(sortAttr).length === 1);
|
||
const attr = Object.keys(sortAttr)[0];
|
||
const relation = judgeRelation(this.getSchema(), entity2, attr);
|
||
if (relation === 1 || relation === 0) {
|
||
const getAttrOrExprValue = (r) => {
|
||
if (sortAttr[attr] === 1) {
|
||
return r[attr];
|
||
}
|
||
else {
|
||
// 改变策略，让所有需要获得的值在projection上取得
|
||
assert(typeof sortAttr[attr] === 'string' && sortAttr[attr].startsWith('$expr'));
|
||
return r[sortAttr[attr]];
|
||
}
|
||
};
|
||
const v1 = row1 && getAttrOrExprValue(row11);
|
||
const v2 = row2 && getAttrOrExprValue(row22);
|
||
if ([null, undefined].includes(v1) || [null, undefined].includes(v2)) {
|
||
if ([null, undefined].includes(v1) && [null, undefined].includes(v2)) {
|
||
return 0;
|
||
}
|
||
if ([null, undefined].includes(v1)) {
|
||
if (direction === 'asc') {
|
||
return -1;
|
||
}
|
||
return 1;
|
||
}
|
||
if (direction === 'desc') {
|
||
return 1;
|
||
}
|
||
return -1;
|
||
}
|
||
const attrDef = this.getSchema()[entity2].attributes[attr];
|
||
// 处理enum，现在enum是按定义enum的顺序从小到大排列
|
||
if (attrDef?.type === 'enum') {
|
||
const enums = attrDef.enumeration;
|
||
const i1 = enums.indexOf(v1);
|
||
const i2 = enums.indexOf(v2);
|
||
assert(i1 >= 0 && i2 >= 0);
|
||
return direction === 'asc' ? i1 - i2 : i2 - i1;
|
||
}
|
||
else {
|
||
// createAt为1时被认为是最大的（新建）
|
||
if (['$$createAt$$', '$$updateAt$$'].includes(attr)) {
|
||
if (v1 === 1) {
|
||
return direction === 'asc' ? 1 : -1;
|
||
}
|
||
else if (v2 === 1) {
|
||
return direction === 'asc' ? -1 : 1;
|
||
}
|
||
}
|
||
if (v1 > v2) {
|
||
if (direction === 'desc') {
|
||
return -1;
|
||
}
|
||
else {
|
||
return 1;
|
||
}
|
||
}
|
||
else if (v1 < v2) {
|
||
if (direction === 'desc') {
|
||
return 1;
|
||
}
|
||
else {
|
||
return -1;
|
||
}
|
||
}
|
||
else {
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
if (relation === 2) {
|
||
assert(row11['entity'] === row22['entity']);
|
||
assert(row11.entity === attr);
|
||
const node1 = this.store[row11.entity] && this.store[row11.entity][row11.entityId];
|
||
const node2 = this.store[row22.entity] && this.store[row22.entity][row22.entityId];
|
||
const row111 = node1 && this.constructRow(node1, context, option);
|
||
const row222 = node2 && this.constructRow(node2, context, option);
|
||
return compare(row111, row222, row11['entity'], sortAttr[attr], direction);
|
||
}
|
||
else {
|
||
assert(typeof relation === 'string');
|
||
const node1 = this.store[relation] && this.store[relation][row11[`${attr}Id`]];
|
||
const node2 = this.store[relation] && this.store[relation][row22[`${attr}Id`]];
|
||
const row111 = node1 && this.constructRow(node1, context, option);
|
||
const row222 = node2 && this.constructRow(node2, context, option);
|
||
return compare(row111, row222, relation, sortAttr[attr], direction);
|
||
}
|
||
}
|
||
};
|
||
return (row1, row2) => {
|
||
for (const sorterElement of sorter) {
|
||
const { $attr, $direction } = sorterElement;
|
||
const result = compare(row1, row2, entity, $attr, $direction);
|
||
if (result !== 0) {
|
||
return result;
|
||
}
|
||
}
|
||
return 0;
|
||
};
|
||
}
|
||
/**
|
||
* 目标行，如果有id过滤条件可直接取
|
||
* @param entity
|
||
* @param selection
|
||
* @returns
|
||
*/
|
||
getEntityNodes(entity, selection, context) {
|
||
const { filter } = selection;
|
||
const ids = getRelevantIds(filter);
|
||
if (this.store[entity]) {
|
||
if (ids.length > 0) {
|
||
const entityNodes = pick(this.store[entity], ids);
|
||
return Object.values(entityNodes);
|
||
}
|
||
return Object.values(this.store[entity]);
|
||
}
|
||
return [];
|
||
}
|
||
selectAbjointRow(entity, selection, context, option) {
|
||
const { data, filter } = selection;
|
||
const nodeDict = option?.nodeDict;
|
||
const filterFn = filter && this.translateFilter(entity, data, filter, context, option);
|
||
const entityNodes = this.getEntityNodes(entity, selection, context);
|
||
const nodes = [];
|
||
for (const n of entityNodes) {
|
||
if (n.$txnId && n.$txnId !== context.getCurrentTxnId() && n.$current === null) {
|
||
continue;
|
||
}
|
||
assert(!n.$txnId || n.$txnId === context.getCurrentTxnId());
|
||
const exprResolveFns = [];
|
||
const nodeDict2 = {};
|
||
if (nodeDict) {
|
||
Object.assign(nodeDict2, nodeDict);
|
||
}
|
||
// 如果没有filterFn，要保证行不为null(本事务remove的case)
|
||
if (filterFn ? filterFn(n, nodeDict2, exprResolveFns) : this.constructRow(n, context, option)) {
|
||
// 如果有延时处理的expression，在这里加以判断，此时所有在filter中的node应该都已经加以遍历了
|
||
let exprResult = true;
|
||
if (exprResolveFns.length > 0) {
|
||
for (const fn of exprResolveFns) {
|
||
const result = fn(nodeDict2);
|
||
if (typeof result === 'function') {
|
||
throw new OakExpressionUnresolvedException();
|
||
}
|
||
if (!!!result) {
|
||
exprResult = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (exprResult) {
|
||
nodes.push(n);
|
||
}
|
||
}
|
||
}
|
||
const rows = nodes.map((node) => this.constructRow(node, context, option));
|
||
const rows2 = this.formResult(entity, rows, selection, context, option);
|
||
return rows2;
|
||
}
|
||
updateAbjointRow(entity, operation, context, option) {
|
||
const { data, action, id: operId } = operation;
|
||
switch (action) {
|
||
case 'create': {
|
||
const { id } = data;
|
||
assert(id);
|
||
// const node = this.store[entity] && (this.store[entity]!)[id as string];
|
||
// const row = node && this.constructRow(node, context) || {};
|
||
/* if (row) {
|
||
throw new OakError(RowStore.$$LEVEL, RowStore.$$CODES.primaryKeyConfilict);
|
||
} */
|
||
if (this.store[entity] && (this.store[entity])[id]) {
|
||
const node = this.store[entity] && (this.store[entity])[id];
|
||
throw new OakCongruentRowExists(entity, this.constructRow(node, context, option));
|
||
}
|
||
if (!data.$$seq$$) {
|
||
const seq = this.getNextSeq(entity);
|
||
data.$$seq$$ = seq;
|
||
}
|
||
const node2 = {
|
||
$txnId: context.getCurrentTxnId(),
|
||
$current: null,
|
||
$next: data,
|
||
$path: `${entity}.${id}`,
|
||
};
|
||
if (!this.store[entity]) {
|
||
this.store[entity] = {};
|
||
}
|
||
set(this.store, `${entity}.${id}`, node2);
|
||
this.addToTxnNode(node2, context, 'create', data[CreateAtAttribute]);
|
||
return 1;
|
||
}
|
||
default: {
|
||
const selection = {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
filter: operation.filter,
|
||
indexFrom: operation.indexFrom,
|
||
count: operation.count,
|
||
};
|
||
const rows = this.selectAbjointRow(entity, selection, context, { dontCollect: true });
|
||
const ids = rows.map(ele => ele.id);
|
||
for (const id of ids) {
|
||
let alreadyDirtyNode = false;
|
||
const node = (this.store[entity])[id];
|
||
assert(node && (!node.$txnId || node.$txnId == context.getCurrentTxnId()));
|
||
if (!node.$txnId) {
|
||
node.$txnId = context.getCurrentTxnId();
|
||
}
|
||
else {
|
||
assert(node.$txnId === context.getCurrentTxnId());
|
||
alreadyDirtyNode = true;
|
||
}
|
||
node.$path = `${entity}.${id}`;
|
||
if (action === 'remove') {
|
||
node.$next = null;
|
||
if (!alreadyDirtyNode) {
|
||
// 如果已经更新过的结点就不能再加了，会形成循环
|
||
this.addToTxnNode(node, context, 'remove', data[DeleteAtAttribute]);
|
||
}
|
||
}
|
||
else {
|
||
node.$next = Object.assign(node.$next || {}, data);
|
||
if (!alreadyDirtyNode) {
|
||
// 如果已经更新过的结点就不能再加了，会形成循环
|
||
this.addToTxnNode(node, context, 'update', data[UpdateAtAttribute]);
|
||
}
|
||
}
|
||
}
|
||
return rows.length;
|
||
}
|
||
}
|
||
}
|
||
async selectAbjointRowAsync(entity, selection, context, option) {
|
||
return this.selectAbjointRow(entity, selection, context, option);
|
||
}
|
||
async updateAbjointRowAsync(entity, operation, context, option) {
|
||
return this.updateAbjointRow(entity, operation, context, option);
|
||
}
|
||
operateSync(entity, operation, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
return super.operateSync(entity, operation, context, option);
|
||
}
|
||
async operateAsync(entity, operation, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
return super.operateAsync(entity, operation, context, option);
|
||
}
|
||
/**
|
||
* 计算最终结果集当中的函数，这个函数可能测试不够充分
|
||
* @param entity
|
||
* @param projection
|
||
* @param data
|
||
* @param nodeDict
|
||
* @param context
|
||
*/
|
||
formExprInResult(entity, projection, data, nodeDict, context) {
|
||
const laterExprDict = {};
|
||
for (const attr in projection) {
|
||
if (attr.startsWith(EXPRESSION_PREFIX)) {
|
||
const ExprNodeTranslator = this.translateExpression(entity, projection[attr], context, {});
|
||
const exprResult = ExprNodeTranslator(data, nodeDict);
|
||
if (typeof exprResult === 'function') {
|
||
Object.assign(laterExprDict, {
|
||
[attr]: exprResult,
|
||
});
|
||
}
|
||
else {
|
||
Object.assign(data, {
|
||
[attr]: exprResult,
|
||
});
|
||
}
|
||
}
|
||
else if (attr === '#id') {
|
||
const nodeId = projection[attr];
|
||
assert(!nodeDict.hasOwnProperty(nodeId), `Filter中的nodeId「${nodeId}」出现了多次`);
|
||
Object.assign(nodeDict, {
|
||
[nodeId]: data,
|
||
});
|
||
}
|
||
}
|
||
for (const attr in projection) {
|
||
const rel = this.judgeRelation(entity, attr);
|
||
if (rel === 1) {
|
||
}
|
||
else if (rel === 2) {
|
||
if (data[attr]) {
|
||
this.formExprInResult(attr, projection[attr], data[attr], nodeDict, context);
|
||
}
|
||
}
|
||
else if (typeof rel === 'string') {
|
||
if (data[attr]) {
|
||
const result2 = {};
|
||
this.formExprInResult(rel, projection[attr], data[attr], nodeDict, context);
|
||
}
|
||
}
|
||
else if (rel instanceof Array) {
|
||
if (!attr.endsWith('$$aggr')) {
|
||
if (data[attr] && data[attr] instanceof Array) {
|
||
data[attr].map((ele) => this.formExprInResult(rel[0], projection[attr].data, ele, nodeDict, context));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (const attr in laterExprDict) {
|
||
const exprResult = laterExprDict[attr](nodeDict);
|
||
// projection是不应出现计算不出来的情况
|
||
assert(typeof exprResult !== 'function', 'data中的expr无法计算，请检查命名与引用的一致性');
|
||
Object.assign(data, {
|
||
[attr]: exprResult,
|
||
});
|
||
}
|
||
}
|
||
formResult(entity, rows, selection, context, option) {
|
||
const { data, sorter, indexFrom, count } = selection;
|
||
const findAvailableExprName = (current) => {
|
||
let counter = 1;
|
||
while (counter < 20) {
|
||
const exprName = `$expr${counter++}`;
|
||
if (!current.includes(exprName)) {
|
||
return exprName;
|
||
}
|
||
}
|
||
assert(false, '找不到可用的expr命名');
|
||
};
|
||
const sortToProjection = (entity2, proj, sort) => {
|
||
Object.keys(sort).forEach((attr) => {
|
||
// 要把sorter中的expr运算提到这里做掉，否则异步运算无法排序
|
||
if (attr.startsWith('$expr') && typeof sort[attr] === 'object') {
|
||
const attrName = findAvailableExprName(Object.keys(proj));
|
||
Object.assign(proj, {
|
||
[attrName]: sort[attr],
|
||
});
|
||
Object.assign(sort, {
|
||
[attr]: attrName,
|
||
});
|
||
}
|
||
const rel = judgeRelation(this.getSchema(), entity2, attr);
|
||
if (rel === 2 || typeof rel === 'string') {
|
||
if (!proj[attr]) {
|
||
Object.assign(proj, {
|
||
[attr]: {},
|
||
});
|
||
}
|
||
const entity3 = typeof rel === 'string' ? rel : attr;
|
||
sortToProjection(entity3, proj[attr], sort[attr]);
|
||
}
|
||
else if (rel === 1) {
|
||
Object.assign(proj, {
|
||
[attr]: 1,
|
||
});
|
||
}
|
||
});
|
||
};
|
||
if (sorter) {
|
||
sorter.forEach((ele) => {
|
||
sortToProjection(entity, data, ele.$attr);
|
||
});
|
||
}
|
||
// 先计算projection，formResult只处理abjoint的行，不需要考虑expression和一对多多对一关系
|
||
let rows2 = [];
|
||
const { data: projection } = selection;
|
||
for (const row of rows) {
|
||
const result = {};
|
||
for (const attr in projection) {
|
||
const rel = this.judgeRelation(entity, attr);
|
||
if (rel === 1) {
|
||
if (row[attr] === undefined) {
|
||
if (process.env.NODE_ENV === 'development') {
|
||
console.warn(`对象${entity}上的属性${attr}缺失，可能会影响上层使用结果，请确定`);
|
||
}
|
||
// break;
|
||
}
|
||
else if (typeof projection[attr] === 'number') {
|
||
Object.assign(result, {
|
||
[attr]: row[attr],
|
||
});
|
||
}
|
||
else {
|
||
// object数据的深层次select
|
||
Object.assign(result, {
|
||
[attr]: {},
|
||
});
|
||
const assignIner = (dest, proj, source) => {
|
||
if (proj instanceof Array) {
|
||
assert(dest instanceof Array);
|
||
assert(source instanceof Array);
|
||
proj.forEach((attr, idx) => {
|
||
if (typeof attr === 'number') {
|
||
dest[idx] = source[idx];
|
||
}
|
||
else if (typeof attr === 'object') {
|
||
dest[idx] = {};
|
||
assignIner(dest[idx], attr, source[idx]);
|
||
}
|
||
});
|
||
}
|
||
else {
|
||
for (const attr in proj) {
|
||
if (typeof proj[attr] === 'number') {
|
||
dest[attr] = source[attr];
|
||
}
|
||
else if (typeof proj[attr] === 'object') {
|
||
dest[attr] = proj[attr] instanceof Array ? [] : {};
|
||
assignIner(dest[attr], proj[attr], source[attr]);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
assignIner(result[attr], projection[attr], row[attr]);
|
||
}
|
||
}
|
||
}
|
||
// 这三个属性在前台cache中可能表达特殊语义的，需要返回
|
||
if (!selection.distinct) {
|
||
if (row[DeleteAtAttribute]) {
|
||
Object.assign(result, {
|
||
[DeleteAtAttribute]: row[DeleteAtAttribute],
|
||
});
|
||
}
|
||
if (row[UpdateAtAttribute]) {
|
||
Object.assign(result, {
|
||
[UpdateAtAttribute]: row[UpdateAtAttribute],
|
||
});
|
||
}
|
||
if (row[CreateAtAttribute]) {
|
||
Object.assign(result, {
|
||
[CreateAtAttribute]: row[CreateAtAttribute],
|
||
});
|
||
}
|
||
}
|
||
rows2.push(result);
|
||
}
|
||
// 再计算sorter
|
||
if (sorter) {
|
||
const sorterFn = this.translateSorter(entity, sorter, context, option);
|
||
rows2.sort(sorterFn);
|
||
}
|
||
// 用indexFrom和count来截断
|
||
if (typeof indexFrom === 'number') {
|
||
rows2 = rows2.slice(indexFrom, indexFrom + count);
|
||
}
|
||
// 如果有distinct再计算distinct
|
||
if (selection.distinct) {
|
||
rows2 = uniqBy(rows2, (ele) => JSON.stringify(ele));
|
||
}
|
||
return rows2;
|
||
}
|
||
/**
|
||
* 本函数把结果中的相应属性映射成一个字符串，用于GroupBy
|
||
* @param entity
|
||
* @param row
|
||
* @param projection
|
||
*/
|
||
mappingProjectionOnRow(entity, row, projection) {
|
||
let key = '';
|
||
let result = {};
|
||
const values = [];
|
||
const mappingIter = (entity2, row2, p2, result2) => {
|
||
const keys = Object.keys(p2).sort((ele1, ele2) => ele1 < ele2 ? -1 : 1);
|
||
for (const k of keys) {
|
||
const rel = this.judgeRelation(entity2, k);
|
||
if (rel === 2) {
|
||
result2[k] = {};
|
||
if (row2[k]) {
|
||
mappingIter(k, row2[k], p2[k], result2[k]);
|
||
}
|
||
}
|
||
else if (typeof rel === 'string') {
|
||
result2[k] = {};
|
||
if (row2[k]) {
|
||
mappingIter(rel, row2[k], p2[k], result2[k]);
|
||
}
|
||
}
|
||
else {
|
||
assert([0, 1].includes(rel));
|
||
result2[k] = row2[k];
|
||
assert(['string', 'number', 'boolean'].includes(typeof row2[k]) || row2[k] === null);
|
||
key += `${row2[k]}`;
|
||
values.push(row2[k]);
|
||
}
|
||
}
|
||
};
|
||
mappingIter(entity, row, projection, result);
|
||
return {
|
||
result,
|
||
key,
|
||
values,
|
||
};
|
||
}
|
||
calcAggregation(entity, rows, aggregationData) {
|
||
const ops = Object.keys(aggregationData).filter(ele => ele !== '#aggr' && ele.startsWith('#'));
|
||
const result = {};
|
||
const results = {};
|
||
for (const row of rows) {
|
||
for (const op of ops) {
|
||
const { values } = this.mappingProjectionOnRow(entity, row, aggregationData[op]);
|
||
assert(values.length === 1, `聚合运算中，${op}的目标属性多于1个`);
|
||
if (results[op]) {
|
||
results[op].push(values[0]);
|
||
}
|
||
else {
|
||
results[op] = [values[0]];
|
||
}
|
||
/* if (op.startsWith('#max')) {
|
||
if (![undefined, null].includes(values[0]) && (!result.hasOwnProperty(op) || result[op] < values[0])) {
|
||
result[op] = values[0];
|
||
}
|
||
}
|
||
else if (op.startsWith('#min')) {
|
||
if (![undefined, null].includes(values[0]) && (!result.hasOwnProperty(op) || result[op] > values[0])) {
|
||
result[op] = values[0];
|
||
}
|
||
}
|
||
else if (op.startsWith('#sum')) {
|
||
if (![undefined, null].includes(values[0])) {
|
||
assert(typeof values[0] === 'number', '只有number类型的属性才可以计算sum');
|
||
if (!result.hasOwnProperty(op)) {
|
||
result[op] = values[0];
|
||
}
|
||
else {
|
||
result[op] += values[0];
|
||
}
|
||
}
|
||
}
|
||
else if (op.startsWith('#count')) {
|
||
if (![undefined, null].includes(values[0])) {
|
||
if (!result.hasOwnProperty(op)) {
|
||
result[op] = 1;
|
||
}
|
||
else {
|
||
result[op] += 1;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
assert(op.startsWith('#avg'));
|
||
if (![undefined, null].includes(values[0])) {
|
||
assert(typeof values[0] === 'number', '只有number类型的属性才可以计算avg');
|
||
if (!result.hasOwnProperty(op)) {
|
||
result[op] = {
|
||
total: values[0],
|
||
count: 1,
|
||
};
|
||
}
|
||
else {
|
||
result[op].total += values[0];
|
||
result[op].count += 1;
|
||
}
|
||
}
|
||
} */
|
||
}
|
||
}
|
||
const { distinct } = aggregationData;
|
||
for (const op in results) {
|
||
if (op.startsWith('#max')) {
|
||
result[op] = null;
|
||
results[op].forEach((ele) => {
|
||
if (![undefined, null].includes(ele) && (result[op] === null || result[op] < ele)) {
|
||
result[op] = ele;
|
||
}
|
||
});
|
||
}
|
||
else if (op.startsWith('#min')) {
|
||
result[op] = null;
|
||
results[op].forEach((ele) => {
|
||
if (![undefined, null].includes(ele) && (result[op] === null || result[op] > ele)) {
|
||
result[op] = ele;
|
||
}
|
||
});
|
||
}
|
||
else if (op.startsWith('#sum')) {
|
||
result[op] = 0;
|
||
const data = distinct ? uniq(results[op]) : results[op];
|
||
data.forEach((ele) => {
|
||
if (typeof ele === 'number') {
|
||
result[op] += ele;
|
||
}
|
||
});
|
||
}
|
||
else if (op.startsWith('#count')) {
|
||
result[op] = 0;
|
||
const data = distinct ? uniq(results[op]) : results[op];
|
||
data.forEach((ele) => {
|
||
if (![undefined, null].includes(ele)) {
|
||
result[op] += 1;
|
||
}
|
||
});
|
||
}
|
||
else if (op.startsWith('#avg')) {
|
||
result[op] = 0;
|
||
const data = (distinct ? uniq(results[op]) : results[op]).filter(ele => ![undefined, null].includes(ele));
|
||
let count = 0;
|
||
data.forEach((ele) => {
|
||
if (typeof ele === 'number') {
|
||
result[op] += ele;
|
||
count += 1;
|
||
}
|
||
});
|
||
result[op] = result[op] / count;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
formAggregation(entity, rows, aggregationData) {
|
||
const { "#aggr": aggrExpr } = aggregationData;
|
||
if (aggrExpr) {
|
||
const groups = groupBy(rows, (row) => {
|
||
const { key } = this.mappingProjectionOnRow(entity, row, aggrExpr);
|
||
return key;
|
||
});
|
||
const result = Object.keys(groups).map((ele) => {
|
||
const aggr = this.calcAggregation(entity, groups[ele], aggregationData);
|
||
const { result: r } = this.mappingProjectionOnRow(entity, groups[ele][0], aggrExpr);
|
||
aggr['#data'] = r;
|
||
return aggr;
|
||
});
|
||
return result;
|
||
}
|
||
const aggr = this.calcAggregation(entity, rows, aggregationData);
|
||
return [aggr];
|
||
}
|
||
selectSync(entity, selection, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
const result = super.selectSync(entity, selection, context, option);
|
||
// 在这里再计算所有的表达式
|
||
result.forEach((ele) => this.formExprInResult(entity, selection.data, ele, {}, context));
|
||
return result;
|
||
}
|
||
async selectAsync(entity, selection, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
const result = await super.selectAsync(entity, selection, context, option);
|
||
// 在这里再计算所有的表达式
|
||
result.forEach((ele) => this.formExprInResult(entity, selection.data, ele, {}, context));
|
||
return result;
|
||
}
|
||
aggregateAbjointRowSync(entity, aggregation, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
const { data, filter, sorter, indexFrom, count } = aggregation;
|
||
const p = {};
|
||
for (const k in data) {
|
||
Object.assign(p, cloneDeep(data[k]));
|
||
}
|
||
const selection = {
|
||
data: p,
|
||
filter,
|
||
sorter,
|
||
indexFrom,
|
||
count,
|
||
};
|
||
const result = this.cascadeSelect(entity, selection, context, Object.assign({}, option, {
|
||
dontCollect: true,
|
||
}));
|
||
// 在这里再计算所有的表达式
|
||
result.forEach((ele) => this.formExprInResult(entity, selection.data, ele, {}, context));
|
||
// 最后计算Aggregation
|
||
return this.formAggregation(entity, result, aggregation.data);
|
||
}
|
||
async aggregateAbjointRowAsync(entity, aggregation, context, option) {
|
||
assert(context.getCurrentTxnId());
|
||
const { data, filter, sorter, indexFrom, count } = aggregation;
|
||
const p = {};
|
||
for (const k in data) {
|
||
Object.assign(p, cloneDeep(data[k]));
|
||
}
|
||
const selection = {
|
||
data: p,
|
||
filter,
|
||
sorter,
|
||
indexFrom,
|
||
count,
|
||
};
|
||
polishSelection(this.getSchema(), entity, selection);
|
||
const result = await this.cascadeSelectAsync(entity, selection, context, Object.assign({}, option, {
|
||
dontCollect: true,
|
||
}));
|
||
// 在这里再计算所有的表达式
|
||
result.forEach((ele) => this.formExprInResult(entity, selection.data, ele, {}, context));
|
||
// 最后计算Aggregation
|
||
return this.formAggregation(entity, result, aggregation.data);
|
||
}
|
||
countAbjointRow(entity, selection, context, option) {
|
||
const selection2 = Object.assign({}, selection, {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
});
|
||
const result = this.selectAbjointRow(entity, selection2, context, Object.assign({}, option, {
|
||
dontCollect: true,
|
||
}));
|
||
return typeof selection.count === 'number' ? Math.min(result.length, selection.count) : result.length;
|
||
}
|
||
async countAbjointRowAsync(entity, selection, context, option) {
|
||
const selection2 = Object.assign({}, selection, {
|
||
data: {
|
||
id: 1,
|
||
},
|
||
});
|
||
const result = await this.selectAbjointRowAsync(entity, selection2, context, Object.assign({}, option, {
|
||
dontCollect: true,
|
||
}));
|
||
return typeof selection.count === 'number' && selection.count > 0 ? Math.min(result.length, selection.count) : result.length;
|
||
}
|
||
addToTxnNode(node, context, action, updateAt) {
|
||
const txnNode = this.activeTxnDict[context.getCurrentTxnId()];
|
||
assert(txnNode);
|
||
if (!node.$nextNode) {
|
||
// 如果nextNode有值，说明这个结点已经在链表中了
|
||
if (txnNode.nodeHeader) {
|
||
node.$nextNode = txnNode.nodeHeader;
|
||
txnNode.nodeHeader = node;
|
||
}
|
||
else {
|
||
txnNode.nodeHeader = node;
|
||
}
|
||
}
|
||
txnNode[action]++;
|
||
txnNode.lastUpdateTs = updateAt;
|
||
}
|
||
getStat() {
|
||
return this.stat;
|
||
}
|
||
beginSync() {
|
||
const uuid = `${Math.random()}`;
|
||
assert(!this.activeTxnDict.hasOwnProperty(uuid));
|
||
Object.assign(this.activeTxnDict, {
|
||
[uuid]: {
|
||
create: 0,
|
||
update: 0,
|
||
remove: 0,
|
||
waitList: [],
|
||
},
|
||
});
|
||
return uuid;
|
||
}
|
||
commitCallbacks = [];
|
||
onCommit(callback) {
|
||
this.commitCallbacks.push(callback);
|
||
return () => pull(this.commitCallbacks, callback);
|
||
}
|
||
addToOperationResult(result, entity, action) {
|
||
if (result[entity]) {
|
||
if (result[entity][action]) {
|
||
result[entity][action]++;
|
||
}
|
||
else {
|
||
Object.assign(result[entity], {
|
||
[action]: 1,
|
||
});
|
||
}
|
||
}
|
||
else {
|
||
Object.assign(result, {
|
||
[entity]: {
|
||
[action]: 1,
|
||
},
|
||
});
|
||
}
|
||
}
|
||
commitLogic(uuid) {
|
||
assert(this.activeTxnDict.hasOwnProperty(uuid), uuid);
|
||
let node = this.activeTxnDict[uuid].nodeHeader;
|
||
const result = {};
|
||
while (node) {
|
||
const node2 = node.$nextNode;
|
||
if (node.$txnId === uuid) {
|
||
assert(node.$path);
|
||
const entity = node.$path?.split('.')[0];
|
||
if (node.$next) {
|
||
// create/update
|
||
node.$current = Object.assign(node.$current || {}, node.$next);
|
||
if (node.$current) {
|
||
this.addToOperationResult(result, entity, 'create');
|
||
}
|
||
else {
|
||
this.addToOperationResult(result, entity, 'update');
|
||
}
|
||
unset(node, '$txnId');
|
||
unset(node, '$next');
|
||
unset(node, '$path');
|
||
unset(node, '$nextNode');
|
||
}
|
||
else {
|
||
// remove
|
||
this.addToOperationResult(result, entity, 'remove');
|
||
unset(this.store, node.$path);
|
||
unset(node, '$txnId');
|
||
}
|
||
}
|
||
else {
|
||
// 同一行被同一事务更新多次
|
||
assert(node.$txnId === undefined);
|
||
}
|
||
node = node2;
|
||
}
|
||
if (this.activeTxnDict[uuid].create || this.activeTxnDict[uuid].update || this.activeTxnDict[uuid].remove) {
|
||
this.stat.create += this.activeTxnDict[uuid].create;
|
||
this.stat.update += this.activeTxnDict[uuid].update;
|
||
this.stat.remove += this.activeTxnDict[uuid].remove;
|
||
this.stat.commit++;
|
||
}
|
||
// 唤起等待者
|
||
for (const waiter of this.activeTxnDict[uuid].waitList) {
|
||
waiter.fn();
|
||
}
|
||
unset(this.activeTxnDict, uuid);
|
||
return result;
|
||
}
|
||
commitSync(uuid) {
|
||
const result = this.commitLogic(uuid);
|
||
// 这里无法等待callback完成，callback最好自身保证顺序（前端cache应当具备的特征）
|
||
this.commitCallbacks.forEach(callback => callback(result));
|
||
}
|
||
rollbackSync(uuid) {
|
||
assert(this.activeTxnDict.hasOwnProperty(uuid));
|
||
let node = this.activeTxnDict[uuid].nodeHeader;
|
||
while (node) {
|
||
const node2 = node.$nextNode;
|
||
if (node.$txnId === uuid) {
|
||
if (node.$current) {
|
||
// update/remove
|
||
unset(node, '$txnId');
|
||
unset(node, '$next');
|
||
unset(node, '$path');
|
||
unset(node, '$nextNode');
|
||
}
|
||
else {
|
||
// create
|
||
assert(node.$path);
|
||
unset(this.store, node.$path);
|
||
unset(node, '$txnId');
|
||
}
|
||
}
|
||
else {
|
||
// 该结点被同一事务反复处理
|
||
assert(node.$txnId === undefined);
|
||
}
|
||
node = node2;
|
||
}
|
||
// 唤起等待者
|
||
for (const waiter of this.activeTxnDict[uuid].waitList) {
|
||
waiter.fn();
|
||
}
|
||
unset(this.activeTxnDict, uuid);
|
||
}
|
||
async beginAsync() {
|
||
return this.beginSync();
|
||
}
|
||
async commitAsync(uuid) {
|
||
const result = this.commitLogic(uuid);
|
||
for (const fn of this.commitCallbacks) {
|
||
await fn(result);
|
||
}
|
||
}
|
||
async rollbackAsync(uuid) {
|
||
return this.rollbackSync(uuid);
|
||
}
|
||
// 将输入的OpRecord同步到数据中
|
||
sync(opRecords, context, option) {
|
||
const option2 = Object.assign({}, option, {
|
||
dontCollect: true,
|
||
dontCreateOper: true,
|
||
});
|
||
const result = {};
|
||
for (const record of opRecords) {
|
||
switch (record.a) {
|
||
case 'c': {
|
||
const { e, d } = record;
|
||
if (d instanceof Array) {
|
||
for (const dd of d) {
|
||
assert(dd[UpdateAtAttribute], `获取的${e}对象数据没有update时间戳`);
|
||
if (!this.store[e]?.[dd.id]) {
|
||
// 有可能后台通过socket等途径先把数据推到了前台，这里直接忽略就行了
|
||
this.updateAbjointRow(e, {
|
||
id: 'dummy',
|
||
action: 'create',
|
||
data: dd,
|
||
}, context, option2);
|
||
this.addToOperationResult(result, e, 'create');
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
assert(d[UpdateAtAttribute], `获取的${e}对象数据没有update时间戳`);
|
||
if (!this.store[e]?.[d.id]) {
|
||
this.updateAbjointRow(e, {
|
||
id: 'dummy',
|
||
action: 'create',
|
||
data: d,
|
||
}, context, option2);
|
||
this.addToOperationResult(result, e, 'create');
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case 'r': {
|
||
const { e, f, d } = record;
|
||
this.updateAbjointRow(e, {
|
||
id: 'dummy',
|
||
action: 'remove',
|
||
data: {},
|
||
filter: f,
|
||
}, context, option2);
|
||
this.addToOperationResult(result, e, 'remove');
|
||
break;
|
||
}
|
||
case 's': {
|
||
const { d } = record;
|
||
for (const entity in d) {
|
||
for (const id in d[entity]) {
|
||
assert(d[entity][id][UpdateAtAttribute], `获取的${entity}对象数据没有update时间戳`);
|
||
if (!this.store[entity]?.[id]) {
|
||
this.updateAbjointRow(entity, {
|
||
id: 'dummy',
|
||
action: 'create',
|
||
data: d[entity][id],
|
||
}, context, option2);
|
||
this.addToOperationResult(result, entity, 'create');
|
||
}
|
||
else if (this.store[entity]?.[id]) {
|
||
const row = this.constructRow(this.store[entity][id], context);
|
||
if (row[UpdateAtAttribute] <= d[entity][id][UpdateAtAttribute]) {
|
||
this.updateAbjointRow(entity, {
|
||
id: 'dummy',
|
||
action: 'update',
|
||
data: d[entity][id],
|
||
filter: {
|
||
id,
|
||
},
|
||
}, context, option2);
|
||
this.addToOperationResult(result, entity, 'update');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
default: {
|
||
const { e, d, f } = record;
|
||
assert(d[UpdateAtAttribute], `获取的${e}对象数据没有update时间戳`);
|
||
// 只更新满足条件的行的更新时间戳比自己小的（BM项目中出现过socket推送的状态先回的情况）
|
||
this.updateAbjointRow(e, {
|
||
id: 'dummy',
|
||
action: 'update',
|
||
data: d,
|
||
filter: combineFilters(e, this.getSchema(), [f, {
|
||
[UpdateAtAttribute]: {
|
||
$lte: d[UpdateAtAttribute],
|
||
}
|
||
}]),
|
||
}, context, option2);
|
||
this.addToOperationResult(result, e, 'update');
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// 在txn提交时应该call过了，这里看上去是多余的
|
||
/* this.commitCallbacks.forEach(
|
||
callback => callback(result)
|
||
); */
|
||
}
|
||
// 这里要返回当前store的数据状态，如果有事务正在更新，返回更新的时间戳，否则返回整个store的commit值
|
||
// 前台使用
|
||
getLastUpdateTs() {
|
||
for (const uuid in this.activeTxnDict) {
|
||
if (this.activeTxnDict[uuid].lastUpdateTs) {
|
||
return this.activeTxnDict[uuid].lastUpdateTs;
|
||
}
|
||
}
|
||
return this.stat.commit;
|
||
}
|
||
}
|