Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

perf(formula): calculation speed up (#3738)

Univercea4571fc0ba
diff --git a/packages/core/src/shared/generate.ts b/packages/core/src/shared/generate.ts
index 3c8f1a2cd7..e55a2fba76 100644
--- a/packages/core/src/shared/generate.ts
+++ b/packages/core/src/shared/generate.ts
@@ -19,8 +19,9 @@
* @param val The number or string to be judged
* @returns Result
*/
+const $blank = /\s/g;
export function isRealNum(val: string | number | boolean) {
- if (val === null || val.toString().replace(/\s/g, '') === '') {
+ if (val === null || val.toString().replace($blank, '') === '') {
return false;
}
diff --git a/packages/core/src/shared/r-tree.ts b/packages/core/src/shared/r-tree.ts
index 0f909a29ed..7c0b5c59f1 100644
--- a/packages/core/src/shared/r-tree.ts
+++ b/packages/core/src/shared/r-tree.ts
@@ -89,42 +89,28 @@ export class RTree {
}
}
- search(search: IUnitRange): Map<string, IRTreeItem> {
+ search(search: IUnitRange): IRTreeItem[] {
const { unitId, sheetId: subUnitId, range } = search;
const tree = this._tree.get(unitId)?.get(subUnitId);
if (!tree) {
- return new Map();
+ return [];
}
- const result = new Map<string, IRTreeItem>();
- tree.search({
+
+ return tree.search({
minX: range.startColumn,
minY: range.startRow,
maxX: range.endColumn,
maxY: range.endRow,
- }).forEach((item) => {
- result.set(item.id, {
- unitId,
- sheetId: subUnitId,
- id: item.id,
- range: {
- startColumn: item.minX,
- startRow: item.minY,
- endColumn: item.maxX,
- endRow: item.maxY,
- },
- });
- });
- return result;
+ }) as unknown as IRTreeItem[];
}
bulkSearch(searchList: IUnitRange[]): Map<string, IRTreeItem> {
const result = new Map<string, IRTreeItem>();
for (const search of searchList) {
const items = this.search(search);
- items.forEach((value, key) => {
- result.set(key, value);
- });
- items.clear();
+ for (const item of items) {
+ result.set(item.id, item);
+ }
}
return result;
}
diff --git a/packages/core/src/shared/range.ts b/packages/core/src/shared/range.ts
index e725142b45..790b710732 100644
--- a/packages/core/src/shared/range.ts
+++ b/packages/core/src/shared/range.ts
@@ -20,6 +20,10 @@ import { AbsoluteRefType, RANGE_TYPE } from '../sheets/typedef';
import { Rectangle } from './rectangle';
export function moveRangeByOffset(range: IRange, refOffsetX: number, refOffsetY: number, ignoreAbsolute = false): IRange {
+ if (refOffsetX === 0 && refOffsetY === 0) {
+ return range;
+ }
+
let newRange = { ...range };
const startAbsoluteRefType = newRange.startAbsoluteRefType || AbsoluteRefType.NONE;
diff --git a/packages/engine-formula/src/basics/__tests__/regex.spec.ts b/packages/engine-formula/src/basics/__tests__/regex.spec.ts
index 419d42ac53..3a3bcf360b 100644
--- a/packages/engine-formula/src/basics/__tests__/regex.spec.ts
+++ b/packages/engine-formula/src/basics/__tests__/regex.spec.ts
@@ -15,39 +15,39 @@
*/
import { describe, expect, it } from 'vitest';
-import { isReferenceString, REFERENCE_MULTIPLE_RANGE_REGEX, REFERENCE_REGEX_COLUMN, REFERENCE_REGEX_ROW, REFERENCE_SINGLE_RANGE_REGEX, REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX, REFERENCE_TABLE_SINGLE_COLUMN_REGEX } from '../regex';
+import { isReferenceString, REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX, REFERENCE_TABLE_SINGLE_COLUMN_REGEX, regexTestColumn, regexTestMultipleRange, regexTestRow, regexTestSingeRange } from '../regex';
describe('Test ref regex', () => {
it('Single range', () => {
- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('A1')).toBe(true);
- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('Sheet1!A1')).toBe(true);
- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('[workbook]Sheet1!A1')).toBe(true);
- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('[workbook]\'Sheet-1\'!A1')).toBe(true);
- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('\'[workbook]Sheet1\'!A1')).toBe(true);
+ expect(regexTestSingeRange('A1')).toBe(true);
+ expect(regexTestSingeRange('Sheet1!A1')).toBe(true);
+ expect(regexTestSingeRange('[workbook]Sheet1!A1')).toBe(true);
+ expect(regexTestSingeRange('[workbook]\'Sheet-1\'!A1')).toBe(true);
+ expect(regexTestSingeRange('\'[workbook]Sheet1\'!A1')).toBe(true);
});
it('Multiple range', () => {
- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('A1:B10')).toBe(true);
- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('Sheet1!A1:B10')).toBe(true);
- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('[workbook]Sheet1!A1:B10')).toBe(true);
- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('[workbook]\'Sheet-1\'!A1:B10')).toBe(true);
- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('\'[workbook]Sheet1\'!A1:B10')).toBe(true);
+ expect(regexTestMultipleRange('A1:B10')).toBe(true);
+ expect(regexTestMultipleRange('Sheet1!A1:B10')).toBe(true);
+ expect(regexTestMultipleRange('[workbook]Sheet1!A1:B10')).toBe(true);
+ expect(regexTestMultipleRange('[workbook]\'Sheet-1\'!A1:B10')).toBe(true);
+ expect(regexTestMultipleRange('\'[workbook]Sheet1\'!A1:B10')).toBe(true);
});
it('Row range', () => {
- expect(new RegExp(REFERENCE_REGEX_ROW).test('1:10')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_ROW).test('Sheet1!1:10')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_ROW).test('[workbook]Sheet1!1:10')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_ROW).test('[workbook]\'Sheet-1\'!1:10')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_ROW).test('\'[workbook]Sheet1\'!1:10')).toBe(true);
+ expect(regexTestRow('1:10')).toBe(true);
+ expect(regexTestRow('Sheet1!1:10')).toBe(true);
+ expect(regexTestRow('[workbook]Sheet1!1:10')).toBe(true);
+ expect(regexTestRow('[workbook]\'Sheet-1\'!1:10')).toBe(true);
+ expect(regexTestRow('\'[workbook]Sheet1\'!1:10')).toBe(true);
});
it('Column range', () => {
- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('A:B')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('Sheet1!A:B')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('[workbook]Sheet1!A:B')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('[workbook]\'Sheet-1\'!A:B')).toBe(true);
- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('\'[workbook]Sheet1\'!A:B')).toBe(true);
+ expect(regexTestColumn('A:B')).toBe(true);
+ expect(regexTestColumn('Sheet1!A:B')).toBe(true);
+ expect(regexTestColumn('[workbook]Sheet1!A:B')).toBe(true);
+ expect(regexTestColumn('[workbook]\'Sheet-1\'!A:B')).toBe(true);
+ expect(regexTestColumn('\'[workbook]Sheet1\'!A:B')).toBe(true);
});
it('Table single range', () => {
diff --git a/packages/engine-formula/src/basics/cache-lru.ts b/packages/engine-formula/src/basics/cache-lru.ts
index 57c1bac148..7eb4bf9743 100644
--- a/packages/engine-formula/src/basics/cache-lru.ts
+++ b/packages/engine-formula/src/basics/cache-lru.ts
@@ -19,10 +19,10 @@ import { hashAlgorithm, LRUMap } from '@univerjs/core';
// export const CACHE_FORMULA_AST = new LRUMap<string, AstRootNode>(100000);
export class FormulaAstLRU<T> {
- private _cache: LRUMap<number, T>;
+ private _cache: LRUMap<string, T>;
constructor(cacheCount: number) {
- this._cache = new LRUMap<number, T>(cacheCount);
+ this._cache = new LRUMap<string, T>(cacheCount);
}
set(formulaString: string, node: T) {
@@ -40,6 +40,9 @@ export class FormulaAstLRU<T> {
}
private _hash(formulaString: string) {
- return hashAlgorithm(formulaString);
+ if (formulaString.length <= 64) {
+ return formulaString;
+ }
+ return hashAlgorithm(formulaString).toString();
}
}
diff --git a/packages/engine-formula/src/basics/object-class-type.ts b/packages/engine-formula/src/basics/object-class-type.ts
index 14bbfc21e5..a1f07e7b5e 100644
--- a/packages/engine-formula/src/basics/object-class-type.ts
+++ b/packages/engine-formula/src/basics/object-class-type.ts
@@ -14,11 +14,13 @@
* limitations under the License.
*/
-import { Disposable } from '@univerjs/core';
-
-export class ObjectClassType extends Disposable {
+export class ObjectClassType {
pattern: string = '';
+ dispose() {
+
+ }
+
getPattern() {
return this.pattern;
}
diff --git a/packages/engine-formula/src/basics/regex.ts b/packages/engine-formula/src/basics/regex.ts
index 5289252c3f..43a754a413 100644
--- a/packages/engine-formula/src/basics/regex.ts
+++ b/packages/engine-formula/src/basics/regex.ts
@@ -22,6 +22,8 @@ import { prefixToken, suffixToken } from './token';
export const UNIT_NAME_REGEX = '\\[([^\\[\\]\\/?:"<>|*\\\\]+)\\]'; // '[Book-1.xlsx]Sheet1'!$A$4 gets [Book-1.xlsx] as unitId
+export const UNIT_NAME_REGEX_PRECOMPILING = new RegExp(UNIT_NAME_REGEX);
+
export const SHEET_NAME_REGEX = '((?![\\[\\]\\/?*\\\\]).)*!';
export const ABSOLUTE_SYMBOL = '$';
@@ -38,16 +40,28 @@ export const SIMPLE_SINGLE_RANGE_REGEX = `\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}\\
export const REFERENCE_MULTIPLE_RANGE_REGEX = `^(${prefixToken.AT})?${UNIT_NAME_SHEET_NAME_REGEX}${SIMPLE_SINGLE_RANGE_REGEX}${RANGE_SYMBOL}${SIMPLE_SINGLE_RANGE_REGEX}$`;
+export const REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING = new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX);
+
export const REFERENCE_SINGLE_RANGE_REGEX = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?${SIMPLE_SINGLE_RANGE_REGEX}(${suffixToken.POUND})?$`;
+export const REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING = new RegExp(REFERENCE_SINGLE_RANGE_REGEX);
+
export const REFERENCE_REGEX_ROW = `^${UNIT_NAME_SHEET_NAME_REGEX}\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}${RANGE_SYMBOL}\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}$`;
+export const REFERENCE_REGEX_ROW_PRECOMPILING = new RegExp(REFERENCE_REGEX_ROW);
+
export const REFERENCE_REGEX_COLUMN = `^${UNIT_NAME_SHEET_NAME_REGEX}\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}${RANGE_SYMBOL}\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}$`;
+export const REFERENCE_REGEX_COLUMN_PRECOMPILING = new RegExp(REFERENCE_REGEX_COLUMN);
+
export const REFERENCE_REGEX_SINGLE_ROW = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}$`;
+export const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING = new RegExp(REFERENCE_REGEX_SINGLE_ROW);
+
export const REFERENCE_REGEX_SINGLE_COLUMN = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}$`;
+export const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING = new RegExp(REFERENCE_REGEX_SINGLE_COLUMN);
+
const TABLE_NAME_REGEX = '((?![~!@#$%^&*()_+<>?:,./;’,。、‘:“《》?~!@#¥%……()【】\\[\\]\\/\\\\]).)+';
const TABLE_TITLE_REGEX = '\\[#.+\\]\\s*?,\\s*?';
@@ -62,15 +76,59 @@ export const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = `^(${UNIT_NAME_REGEX})?${TABL
export const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = `^(${UNIT_NAME_REGEX})?${TABLE_NAME_REGEX}(\\[${TABLE_MULTIPLE_COLUMN_REGEX}\\])?$|^${TABLE_NAME_REGEX}(\\[${TABLE_TITLE_REGEX}${TABLE_MULTIPLE_COLUMN_REGEX}\\])?$`; // =Table1[[#Title],[Column1]:[Column2]] | =Table1[[Column1]:[Column2]]
-export const $SUPER_TABLE_COLUMN_REGEX = '[.*?]';
+export const SUPER_TABLE_COLUMN_REGEX = '[.*?]';
-export const $ARRAY_VALUE_REGEX = '{.*?}';
+export const SUPER_TABLE_COLUMN_REGEX_PRECOMPILING = new RegExp(SUPER_TABLE_COLUMN_REGEX, 'g');
+
+export const ARRAY_VALUE_REGEX = '{.*?}';
+
+export const ARRAY_VALUE_REGEX_PRECOMPILING = new RegExp(ARRAY_VALUE_REGEX, 'g');
+
+export function regexTestSingeRange(token: string): boolean {
+ REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING.test(token);
+}
+
+export function regexTestMultipleRange(token: string): boolean {
+ REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING.test(token);
+}
+
+export function regexTestRow(token: string): boolean {
+ REFERENCE_REGEX_ROW_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_REGEX_ROW_PRECOMPILING.test(token);
+}
+
+export function regexTestColumn(token: string): boolean {
+ REFERENCE_REGEX_COLUMN_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_REGEX_COLUMN_PRECOMPILING.test(token);
+}
+
+export function regexTestSingleRow(token: string): boolean {
+ REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING.test(token);
+}
+
+export function regexTestSingleColumn(token: string): boolean {
+ REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING.lastIndex = 0;
+ return REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING.test(token);
+}
+
+export function regexTestSuperTableColumn(token: string): boolean {
+ SUPER_TABLE_COLUMN_REGEX_PRECOMPILING.lastIndex = 0;
+ return SUPER_TABLE_COLUMN_REGEX_PRECOMPILING.test(token);
+}
+
+export function regexTestArrayValue(token: string): boolean {
+ ARRAY_VALUE_REGEX_PRECOMPILING.lastIndex = 0;
+ return ARRAY_VALUE_REGEX_PRECOMPILING.test(token);
+}
export function isReferenceString(refString: string) {
return (
- new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(refString) ||
- new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test(refString) ||
- new RegExp(REFERENCE_REGEX_ROW).test(refString) ||
- new RegExp(REFERENCE_REGEX_COLUMN).test(refString)
+ regexTestSingeRange(refString) ||
+ regexTestMultipleRange(refString) ||
+ regexTestRow(refString) ||
+ regexTestColumn(refString)
);
}
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
index 092582cfd4..722f416657 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
@@ -33,6 +33,7 @@ import { IFormulaCurrentConfigService } from '../../../services/current-data.ser
import { IFunctionService } from '../../../services/function.service';
import { IFormulaRuntimeService } from '../../../services/runtime.service';
import { Interpreter } from '../../interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../utils/ast-node-tool';
import { Lexer } from '../lexer';
import { AstTreeBuilder } from '../parser';
import { createCommandTestBed } from './create-command-test-bed';
@@ -99,7 +100,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.REF);
});
@@ -109,7 +110,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);
});
@@ -119,7 +120,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(1);
});
@@ -129,7 +130,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(-1);
});
@@ -139,7 +140,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(1);
});
@@ -149,7 +150,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(1);
});
@@ -159,7 +160,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(-1);
});
@@ -169,7 +170,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(4);
});
@@ -179,7 +180,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(4);
});
@@ -189,7 +190,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(5);
});
@@ -199,7 +200,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);
});
@@ -209,7 +210,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(3);
});
@@ -219,7 +220,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);
});
@@ -229,7 +230,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.VALUE);
});
@@ -239,7 +240,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NUM);
});
@@ -249,7 +250,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(10);
});
@@ -283,7 +284,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(0.1);
});
@@ -305,7 +306,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual('{1,2,3;4,5,6}');
});
@@ -315,7 +316,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(10);
});
diff --git a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
index 9da4f5674b..64bc150ae1 100644
--- a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
+++ b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
@@ -21,7 +21,8 @@ import { AbsoluteRefType, Disposable, isValidRange, moveRangeByOffset, Tools } f
import { FormulaAstLRU } from '../../basics/cache-lru';
import { ERROR_TYPE_COUNT_ARRAY, ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';
import { isFormulaLexerToken, isTokenCannotBeAtEnd, isTokenCannotPrecedeSuffixToken } from '../../basics/match-token';
-import { REFERENCE_SINGLE_RANGE_REGEX } from '../../basics/regex';
+
+import { regexTestSingeRange } from '../../basics/regex';
import {
matchToken,
OPERATOR_TOKEN_PRIORITY,
@@ -452,7 +453,7 @@ export class LexerTreeBuilder extends Disposable {
if (maybeString === true && preSegmentTrim[preSegmentTrim.length - 1] === matchToken.DOUBLE_QUOTATION && preSegmentTrim[0] !== matchToken.OPEN_BRACES) {
maybeString = false;
this._processPushSequenceNode(sequenceNodes, sequenceNodeType.STRING, preSegment, startIndex, endIndex, deleteEndIndex);
- } else if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(preSegmentNotPrefixToken) && isReferenceStringWithEffectiveColumn(preSegmentNotPrefixToken)) {
+ } else if (regexTestSingeRange(preSegmentNotPrefixToken) && isReferenceStringWithEffectiveColumn(preSegmentNotPrefixToken)) {
this._processPushSequenceNode(sequenceNodes, sequenceNodeType.REFERENCE, preSegment, startIndex, endIndex, deleteEndIndex);
} else if (Tools.isStringNumber(preSegmentTrim)) {
this._processPushSequenceNode(sequenceNodes, sequenceNodeType.NUMBER, preSegment, startIndex, endIndex, deleteEndIndex);
diff --git a/packages/engine-formula/src/engine/analysis/parser.ts b/packages/engine-formula/src/engine/analysis/parser.ts
index 34b657ec67..ce8bf40e0e 100644
--- a/packages/engine-formula/src/engine/analysis/parser.ts
+++ b/packages/engine-formula/src/engine/analysis/parser.ts
@@ -80,13 +80,8 @@ export class AstTreeBuilder extends Disposable {
this._astNodeFactoryList = [];
}
- parse(lexerNode: LexerNode, refOffsetX: number = 0, refOffsetY: number = 0) {
+ parse(lexerNode: LexerNode) {
const astNode = new AstRootNode(DEFAULT_TOKEN_TYPE_ROOT);
-
- this._refOffsetX = refOffsetX;
-
- this._refOffsetY = refOffsetY;
-
const node = this._parse(lexerNode, astNode);
/**
@@ -328,7 +323,7 @@ export class AstTreeBuilder extends Disposable {
break;
}
case NodeType.REFERENCE:
- astNode.setRefOffset(this._refOffsetX, this._refOffsetY);
+ // astNode.setRefOffset(this._refOffsetX, this._refOffsetY);
calculateStack.push(astNode);
break;
case NodeType.ROOT:
@@ -341,7 +336,7 @@ export class AstTreeBuilder extends Disposable {
calculateStack.push(astNode);
break;
case NodeType.PREFIX:
- this._setPrefixRefOffset(astNode);
+ // this._setPrefixRefOffset(astNode);
calculateStack.push(astNode);
break;
case NodeType.SUFFIX:
@@ -360,16 +355,16 @@ export class AstTreeBuilder extends Disposable {
return currentAstNode;
}
- private _setPrefixRefOffset(astNode: BaseAstNode) {
- const children = astNode.getChildren();
- const childrenCount = children.length;
- for (let i = 0; i < childrenCount; i++) {
- const item = children[i];
- if (item.nodeType === NodeType.REFERENCE) {
- item.setRefOffset(this._refOffsetX, this._refOffsetY);
- }
- }
- }
+ // private _setPrefixRefOffset(astNode: BaseAstNode) {
+ // const children = astNode.getChildren();
+ // const childrenCount = children.length;
+ // for (let i = 0; i < childrenCount; i++) {
+ // const item = children[i];
+ // if (item.nodeType === NodeType.REFERENCE) {
+ // item.setRefOffset(this._refOffsetX, this._refOffsetY);
+ // }
+ // }
+ // }
private _checkAstNode(item: LexerNode | string) {
let astNode: Nullable<BaseAstNode> = null;
diff --git a/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts b/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts
index d4a0b81761..9d321c77e2 100644
--- a/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts
+++ b/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts
@@ -15,18 +15,21 @@
*/
import type { Nullable } from '@univerjs/core';
-import { Disposable } from '@univerjs/core';
import { LexerNode } from '../analysis/lexer-node';
import { BaseAstNode } from './base-ast-node';
export const DEFAULT_AST_NODE_FACTORY_Z_INDEX = 100;
-export abstract class BaseAstNodeFactory extends Disposable {
+export abstract class BaseAstNodeFactory {
get zIndex() {
return 0;
}
+ dispose(): void {
+
+ }
+
create(param: LexerNode | string, currentRow?: number, currentColumn?: number): BaseAstNode {
let token;
if (param instanceof LexerNode) {
diff --git a/packages/engine-formula/src/engine/ast-node/base-ast-node.ts b/packages/engine-formula/src/engine/ast-node/base-ast-node.ts
index 59ace9c597..fb0fb676d6 100644
--- a/packages/engine-formula/src/engine/ast-node/base-ast-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/base-ast-node.ts
@@ -18,7 +18,7 @@ import type { Nullable } from '@univerjs/core';
import type { ErrorType } from '../../basics/error-type';
import type { FunctionVariantType } from '../reference-object/base-reference-object';
-import { Disposable } from '@univerjs/core';
+
import { AstNodePromiseType } from '../../basics/common';
import { ErrorValueObject } from '../value-object/base-value-object';
import { NodeType } from './node-type';
@@ -31,7 +31,7 @@ interface IAstNodeNodeJson {
export type LambdaPrivacyVarType = Map<string, Nullable<BaseAstNode>>;
-export class BaseAstNode extends Disposable {
+export class BaseAstNode {
private _children: BaseAstNode[] = [];
private _definedNames: Array<string> = [];
@@ -46,17 +46,13 @@ export class BaseAstNode extends Disposable {
private _address = false;
- private _refOffsetX: number = 0;
-
- private _refOffsetY: number = 0;
-
private _isForcedCalculateFunction = false;
constructor(private _token: string) {
- super();
+
}
- override dispose(): void {
+ dispose(): void {
this._children.forEach((node) => {
node.dispose();
});
@@ -138,18 +134,6 @@ export class BaseAstNode extends Disposable {
/* abstract */
}
- setRefOffset(x: number = 0, y: number = 0) {
- this._refOffsetX = x;
- this._refOffsetY = y;
- }
-
- getRefOffset() {
- return {
- x: this._refOffsetX,
- y: this._refOffsetY,
- };
- }
-
async executeAsync(): Promise<AstNodePromiseType> {
/* abstract */
return Promise.resolve(AstNodePromiseType.SUCCESS);
diff --git a/packages/engine-formula/src/engine/ast-node/reference-node.ts b/packages/engine-formula/src/engine/ast-node/reference-node.ts
index 03bf4d9db0..f03637a9bb 100644
--- a/packages/engine-formula/src/engine/ast-node/reference-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/reference-node.ts
@@ -15,33 +15,34 @@
*/
import type { IAccessor, Nullable } from '@univerjs/core';
-import { Inject, Injector } from '@univerjs/core';
+import type { BaseReferenceObject } from '../reference-object/base-reference-object';
+import { Inject, Injector } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
import {
- $SUPER_TABLE_COLUMN_REGEX,
- REFERENCE_REGEX_SINGLE_COLUMN,
- REFERENCE_REGEX_SINGLE_ROW,
- REFERENCE_SINGLE_RANGE_REGEX,
+ regexTestSingeRange,
+ regexTestSingleColumn,
+ regexTestSingleRow,
} from '../../basics/regex';
import { matchToken } from '../../basics/token';
import { IFormulaCurrentConfigService } from '../../services/current-data.service';
+import { IFunctionService } from '../../services/function.service';
import { IFormulaRuntimeService } from '../../services/runtime.service';
import { ISuperTableService } from '../../services/super-table.service';
import { LexerNode } from '../analysis/lexer-node';
-import type { BaseReferenceObject } from '../reference-object/base-reference-object';
import { CellReferenceObject } from '../reference-object/cell-reference-object';
import { ColumnReferenceObject } from '../reference-object/column-reference-object';
import { RowReferenceObject } from '../reference-object/row-reference-object';
-import { TableReferenceObject } from '../reference-object/table-reference-object';
-import { ErrorValueObject } from '../value-object/base-value-object';
import { prefixHandler } from '../utils/prefixHandler';
-import { IFunctionService } from '../../services/function.service';
+import { ErrorValueObject } from '../value-object/base-value-object';
import { BaseAstNode } from './base-ast-node';
import { BaseAstNodeFactory, DEFAULT_AST_NODE_FACTORY_Z_INDEX } from './base-ast-node-factory';
import { NODE_ORDER_MAP, NodeType } from './node-type';
export class ReferenceNode extends BaseAstNode {
+ private _refOffsetX = 0;
+ private _refOffsetY = 0;
+
constructor(
private _accessor: IAccessor,
private _operatorString: string,
@@ -87,6 +88,18 @@ export class ReferenceNode extends BaseAstNode {
this.setValue(this._referenceObject);
}
}
+
+ setRefOffset(x: number = 0, y: number = 0) {
+ this._refOffsetX = x;
+ this._refOffsetY = y;
+ }
+
+ getRefOffset() {
+ return {
+ x: this._refOffsetX,
+ y: this._refOffsetY,
+ };
+ }
}
export class ReferenceNodeFactory extends BaseAstNodeFactory {
@@ -123,7 +136,7 @@ export class ReferenceNodeFactory extends BaseAstNodeFactory {
}
// const tokenTrim = param.trim();
- // if (new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test(tokenTrim)) {
+ // if (regexTestSingeRange(tokenTrim)) {
// return true;
// }
@@ -134,36 +147,37 @@ export class ReferenceNodeFactory extends BaseAstNodeFactory {
}
let node: Nullable<ReferenceNode>;
- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(tokenTrim)) {
+ if (regexTestSingeRange(tokenTrim)) {
node = new ReferenceNode(this._injector, tokenTrim, new CellReferenceObject(tokenTrim), isPrepareMerge);
} else if (isLexerNode && this._checkParentIsUnionOperator(param as LexerNode)) {
- if (new RegExp(REFERENCE_REGEX_SINGLE_ROW).test(tokenTrim)) {
+ if (regexTestSingleRow(tokenTrim)) {
node = new ReferenceNode(this._injector, tokenTrim, new RowReferenceObject(tokenTrim), isPrepareMerge);
- } else if (new RegExp(REFERENCE_REGEX_SINGLE_COLUMN).test(tokenTrim)) {
+ } else if (regexTestSingleColumn(tokenTrim)) {
node = new ReferenceNode(this._injector, tokenTrim, new ColumnReferenceObject(tokenTrim), isPrepareMerge);
}
- } else {
- const unitId = this._formulaRuntimeService.currentUnitId;
- // parserDataLoader.get
-
- const tableMap = this._superTableService.getTableMap(unitId);
- const $regex = new RegExp($SUPER_TABLE_COLUMN_REGEX, 'g');
- const tableName = tokenTrim.replace($regex, '');
- if (!isLexerNode && tableMap?.has(tableName)) {
- const columnResult = $regex.exec(tokenTrim);
- let columnDataString = '';
- if (columnResult) {
- columnDataString = columnResult[0];
- }
- const tableData = tableMap.get(tableName)!;
- const tableOption = this._superTableService.getTableOptionMap();
- node = new ReferenceNode(
- this._injector,
- tokenTrim,
- new TableReferenceObject(tokenTrim, tableData, columnDataString, tableOption)
- );
- }
}
+ // else {
+ // const unitId = this._formulaRuntimeService.currentUnitId;
+ // // parserDataLoader.get
+
+ // const tableMap = this._superTableService.getTableMap(unitId);
+ // const $regex = $SUPER_TABLE_COLUMN_REGEX_PRECOMPILING;
+ // const tableName = tokenTrim.replace($regex, '');
+ // if (!isLexerNode && tableMap?.has(tableName)) {
+ // const columnResult = $regex.exec(tokenTrim);
+ // let columnDataString = '';
+ // if (columnResult) {
+ // columnDataString = columnResult[0];
+ // }
+ // const tableData = tableMap.get(tableName)!;
+ // const tableOption = this._superTableService.getTableOptionMap();
+ // node = new ReferenceNode(
+ // this._injector,
+ // tokenTrim,
+ // new TableReferenceObject(tokenTrim, tableData, columnDataString, tableOption)
+ // );
+ // }
+ // }
if (node) {
if (atPrefixNode) {
diff --git a/packages/engine-formula/src/engine/dependency/dependency-tree.ts b/packages/engine-formula/src/engine/dependency/dependency-tree.ts
index b8e1602826..06033c7875 100644
--- a/packages/engine-formula/src/engine/dependency/dependency-tree.ts
+++ b/packages/engine-formula/src/engine/dependency/dependency-tree.ts
@@ -24,8 +24,9 @@ import type {
import type { IFormulaDirtyData } from '../../services/current-data.service';
import type { IAllRuntimeData } from '../../services/runtime.service';
-import type { BaseAstNode } from '../ast-node/base-ast-node';
-import { Disposable, generateRandomId } from '@univerjs/core';
+
+import type { IExecuteAstNodeData } from '../utils/ast-node-tool';
+import { generateRandomId } from '@univerjs/core';
export enum FDtreeStateType {
DEFAULT,
@@ -42,10 +43,10 @@ export enum FDtreeStateType {
* A dependency tree, capable of calculating mutual dependencies,
* is used to determine the order of formula calculations.
*/
-export class FormulaDependencyTree extends Disposable {
+export class FormulaDependencyTree {
treeId: string = '';
- node: Nullable<BaseAstNode>;
+ nodeData: Nullable<IExecuteAstNodeData>;
children: Set<FormulaDependencyTree> = new Set();
@@ -74,7 +75,6 @@ export class FormulaDependencyTree extends Disposable {
isCache: boolean = false;
constructor(treeId?: string) {
- super();
if (treeId != null) {
this.treeId = treeId;
} else {
@@ -91,9 +91,7 @@ export class FormulaDependencyTree extends Disposable {
private _state = FDtreeStateType.DEFAULT;
- override dispose(): void {
- super.dispose();
-
+ dispose(): void {
// this.children.forEach((tree) => {
// tree.dispose();
// });
@@ -104,7 +102,9 @@ export class FormulaDependencyTree extends Disposable {
this.parents = new Set();
- this.node?.dispose();
+ this.nodeData?.node.dispose();
+
+ this.nodeData = null;
}
disposeWithChildren() {
@@ -272,83 +272,3 @@ export class FormulaDependencyTree extends Disposable {
this.parents.add(tree);
}
}
-
-// interface IFormulaDependencyTreeCacheItem {
-// unitRangeWithToken: IUnitRangeWithToken;
-// treeList: FormulaDependencyTree[];
-// }
-
-// export class FormulaDependencyTreeCache extends Disposable {
-// private _cacheItems = new Map<string, IFormulaDependencyTreeCacheItem>();
-
-// override dispose(): void {
-// this.clear();
-// }
-
-// size() {
-// return this._cacheItems.size;
-// }
-
-// get length() {
-// return this._cacheItems.size;
-// }
-
-// add(unitRangeWithToken: IUnitRangeWithToken, tree: FormulaDependencyTree) {
-// const { token } = unitRangeWithToken;
-// if (!this._cacheItems.has(token)) {
-// this._cacheItems.set(token, {
-// unitRangeWithToken,
-// treeList: [tree],
-// });
-// return;
-// }
-
-// const cacheItem = this._cacheItems.get(token)!;
-// cacheItem.treeList.push(tree);
-// }
-
-// clear() {
-// this._cacheItems.clear();
-// }
-
-// remove(token: string, tree: FormulaDependencyTree) {
-// if (!this._cacheItems.has(token)) {
-// return;
-// }
-
-// const cacheItem = this._cacheItems.get(token)!;
-// const index = cacheItem.treeList.indexOf(tree);
-// if (index !== -1) {
-// cacheItem.treeList.splice(index, 1);
-// }
-// }
-
-// delete(token: string) {
-// this._cacheItems.delete(token);
-// }
-
-// /**
-// * Determine whether range is dependent on other trees.
-// * @param dependenceTree
-// */
-// dependency(dependenceTree: FormulaDependencyTree) {
-// this._cacheItems.forEach((cacheItem) => {
-// const { unitRangeWithToken, treeList } = cacheItem;
-// const { gridRange } = unitRangeWithToken;
-// const { unitId, sheetId, range } = gridRange;
-
-// if (
-// dependenceTree.unitId === unitId &&
-// dependenceTree.subUnitId === sheetId &&
-// dependenceTree.inRangeData(range)
-// ) {
-// treeList.forEach((tree) => {
-// if (tree === dependenceTree || tree.children.includes(dependenceTree)) {
-// return true;
-// }
-// tree.pushChildren(dependenceTree);
-// });
-// }
-// });
-// }
-// }
diff --git a/packages/engine-formula/src/engine/dependency/formula-dependency.ts b/packages/engine-formula/src/engine/dependency/formula-dependency.ts
index ef901f0d62..f3f11c1212 100644
--- a/packages/engine-formula/src/engine/dependency/formula-dependency.ts
+++ b/packages/engine-formula/src/engine/dependency/formula-dependency.ts
@@ -40,8 +40,8 @@ import { AstTreeBuilder } from '../analysis/parser';
import { ErrorNode } from '../ast-node/base-ast-node';
import { NodeType } from '../ast-node/node-type';
import { Interpreter } from '../interpreter/interpreter';
+import { generateExecuteAstNodeData, type IExecuteAstNodeData } from '../utils/ast-node-tool';
import { FormulaDependencyTree } from './dependency-tree';
-import { generateRandomDependencyTreeId } from './generate-tree-id';
const FORMULA_CACHE_LRU_COUNT = 100000;
@@ -51,6 +51,11 @@ interface IFeatureFormulaParam {
featureId: string;
}
+function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): string {
+ const idNum = dependencyManagerService.getLastTreeId() || 0;
+ return idNum.toString();
+}
+
export class FormulaDependencyGenerator extends Disposable {
private _formulaASTCache = new FormulaAstLRU<AstRootNode>(FORMULA_CACHE_LRU_COUNT);
private _updateRangeFlattenCache = new Map<string, Map<string, IRange[]>>();
@@ -182,6 +187,8 @@ export class FormulaDependencyGenerator extends Disposable {
const treeList: FormulaDependencyTree[] = [];
+ const formulaRefCache = new Map<string, FormulaDependencyTree>();
+
// Recalculation can only be triggered after clearing the cache. For example, if a calculation error is reported for a non-existent formula and a custom formula is registered later, all formulas need to be calculated forcibly.
const forceCalculate = this._currentConfigService.isForceCalculate();
if (forceCalculate) {
@@ -189,9 +196,9 @@ export class FormulaDependencyGenerator extends Disposable {
this._formulaASTCache.clear();
}
- this._registerFormulas(formulaDataKeys, formulaData, unitData, treeList);
+ this._registerFormulas(formulaDataKeys, formulaData, unitData, treeList, formulaRefCache);
- this._registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList);
+ this._registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList, formulaRefCache);
this._registerFeatureFormulas(treeList);
@@ -207,21 +214,57 @@ export class FormulaDependencyGenerator extends Disposable {
tree.unitId
);
- if (tree.node == null) {
+ const { unitId, formula, nodeData } = tree;
+
+ if (nodeData == null) {
continue;
}
- const rangeList = await this._getRangeListByNode(tree.node);
- tree.pushRangeList(rangeList);
+ const { refOffsetX, refOffsetY } = nodeData;
+
+ let applyCacheRange = false;
+ if (refOffsetX !== 0 || refOffsetY !== 0) {
+ const refTreeNode = formulaRefCache.get(`${unitId}${formula}`);
+ if (refTreeNode && refTreeNode.rangeList.length > 0) {
+ tree.pushRangeList(this._moveRangeList(refTreeNode, refOffsetX, refOffsetY));
+ applyCacheRange = true;
+ }
+ }
+
+ if (!applyCacheRange) {
+ const rangeList = await this._getRangeListByNode(nodeData);
+ tree.pushRangeList(rangeList);
+ }
if (!tree.isCache) {
this._dependencyManagerService.addDependencyRTreeCache(tree);
}
}
+ formulaRefCache.clear();
+
return treeList;
}
+ private _moveRangeList(tree: FormulaDependencyTree, refOffsetX: number, refOffsetY: number) {
+ const rangeList = tree.rangeList;
+ const newRangeList = [];
+ for (let i = 0, len = rangeList.length; i < len; i++) {
+ const range = rangeList[i];
+ const newRange = {
+ unitId: tree.unitId,
+ sheetId: tree.subUnitId,
+ range: { ...range.range },
+ };
+ newRange.range.startRow += refOffsetY;
+ newRange.range.endRow += refOffsetY;
+ newRange.range.startColumn += refOffsetX;
+ newRange.range.endColumn += refOffsetX;
+ newRangeList.push(newRange);
+ }
+ return newRangeList;
+ }
+
private _registerFeatureFormulas(treeList: FormulaDependencyTree[]) {
/**
* Register the external application relying on 'ref' into the formula system,
@@ -262,7 +305,7 @@ export class FormulaDependencyGenerator extends Disposable {
return FDtree;
}
- private _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: FormulaDependencyTree[]) {
+ private _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: FormulaDependencyTree[], formulaRefCache: Map<string, FormulaDependencyTree>) {
/**
* Register formulas in doc, slide, and other types of applications.
*/
@@ -286,26 +329,32 @@ export class FormulaDependencyGenerator extends Disposable {
for (const subFormulaDataId of subFormulaDataKeys) {
const treeCache = this._dependencyManagerService.getOtherFormulaDependency(unitId, subUnitId, subFormulaDataId);
+ const formulaDataItem = subFormulaData[subFormulaDataId];
+ const { f: formulaString, x = 0, y = 0 } = formulaDataItem;
+
if (treeCache) {
treeCache.isCache = true;
+ if (x === 0 && y === 0) {
+ formulaRefCache.set(`${unitId}${formulaString}`, treeCache);
+ }
continue;
}
- const formulaDataItem = subFormulaData[subFormulaDataId];
-
- const { f: formulaString } = formulaDataItem;
-
- const node = this._generateAstNode(unitId, formulaString);
+ const nodeData = this._generateAstNode(unitId, formulaString, x, y);
const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));
- FDtree.node = node;
+ FDtree.nodeData = nodeData;
FDtree.formula = formulaString;
FDtree.unitId = unitId;
FDtree.subUnitId = subUnitId;
FDtree.formulaId = subFormulaDataId;
+ if (x === 0 && y === 0) {
+ formulaRefCache.set(`${unitId}${formulaString}`, FDtree);
+ }
+
this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, FDtree);
treeList.push(FDtree);
@@ -314,7 +363,7 @@ export class FormulaDependencyGenerator extends Disposable {
}
}
- private _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: FormulaDependencyTree[]) {
+ private _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: FormulaDependencyTree[], formulaRefCache: Map<string, FormulaDependencyTree>) {
/**
* Register formulas in the sheet.
*/
@@ -335,21 +384,25 @@ export class FormulaDependencyGenerator extends Disposable {
if (formulaDataItem == null) {
return true;
}
- const { f: formulaString, x, y } = formulaDataItem;
+
+ const { f: formulaString, x = 0, y = 0 } = formulaDataItem;
const treeCache = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);
if (treeCache) {
treeCache.isCache = true;
+ if (x === 0 && y === 0) {
+ formulaRefCache.set(`${unitId}${formulaString}`, treeCache);
+ }
return true;
}
- const node = this._generateAstNode(unitId, formulaString, x, y);
+ const nodeData = this._generateAstNode(unitId, formulaString, x, y);
const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));
const sheetItem = unitData[unitId][sheetId];
- FDtree.node = node;
+ FDtree.nodeData = nodeData;
FDtree.formula = formulaString;
FDtree.unitId = unitId;
FDtree.subUnitId = sheetId;
@@ -359,6 +412,10 @@ export class FormulaDependencyGenerator extends Disposable {
FDtree.rowCount = sheetItem.rowCount;
FDtree.columnCount = sheetItem.columnCount;
+ if (x === 0 && y === 0) {
+ formulaRefCache.set(`${unitId}${formulaString}`, FDtree);
+ }
+
this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);
treeList.push(FDtree);
@@ -387,31 +444,38 @@ export class FormulaDependencyGenerator extends Disposable {
}
}
- private _generateAstNode(unitId: string, formulaString: string, refOffsetX: number = 0, refOffsetY: number = 0) {
+ private _generateAstNode(unitId: string, formulaString: string, refOffsetX: number = 0, refOffsetY: number = 0): IExecuteAstNodeData {
// refOffsetX and refOffsetY are separated by -, otherwise x:1 y:10 will be repeated with x:11 y:0
- let astNode: Nullable<AstRootNode> = this._formulaASTCache.get(`${unitId}${formulaString}##${refOffsetX}-${refOffsetY}`);
+ let astNode: Nullable<AstRootNode> = this._formulaASTCache.get(`${unitId}${formulaString}`);
if (astNode && !this._isDirtyDefinedForNode(astNode)) {
- return astNode;
+ // astNode.setRefOffset(refOffsetX, refOffsetY);
+ return generateExecuteAstNodeData(astNode, refOffsetX, refOffsetY);
}
const lexerNode = this._lexer.treeBuilder(formulaString);
if (ERROR_TYPE_SET.has(lexerNode as ErrorType)) {
- return ErrorNode.create(lexerNode as ErrorType);
+ return {
+ node: ErrorNode.create(lexerNode as ErrorType),
+ refOffsetX,
+ refOffsetY,
+ };
}
// suffix Express, 1+(3*4=4)*5+1 convert to 134*4=5*1++
- astNode = this._astTreeBuilder.parse(lexerNode as LexerNode, refOffsetX, refOffsetY);
+ astNode = this._astTreeBuilder.parse(lexerNode as LexerNode);
if (astNode == null) {
throw new Error('astNode is null');
}
- this._formulaASTCache.set(`${unitId}${formulaString}##${refOffsetX}-${refOffsetY}`, astNode);
+ // astNode.setRefOffset(refOffsetX, refOffsetY);
- return astNode;
+ this._formulaASTCache.set(`${unitId}${formulaString}`, astNode);
+
+ return generateExecuteAstNodeData(astNode, refOffsetX, refOffsetY);
}
private _addFlattenCache(unitId: string, sheetId: string, range: IRange) {
@@ -497,12 +561,17 @@ export class FormulaDependencyGenerator extends Disposable {
}
}
- private async _executeNode(node: PreCalculateNodeType | FunctionNode) {
+ private async _executeNode(node: PreCalculateNodeType | FunctionNode, refOffsetX = 0, refOffsetY = 0) {
let value: BaseReferenceObject;
+ const nodeData = {
+ node,
+ refOffsetX,
+ refOffsetY,
+ };
if (this._interpreter.checkAsyncNode(node)) {
- value = (await this._interpreter.executeAsync(node)) as BaseReferenceObject;
+ value = (await this._interpreter.executeAsync(nodeData)) as BaseReferenceObject;
} else {
- value = this._interpreter.execute(node) as BaseReferenceObject;
+ value = this._interpreter.execute(nodeData) as BaseReferenceObject;
}
return value;
}
@@ -512,21 +581,24 @@ export class FormulaDependencyGenerator extends Disposable {
* including references and location functions (such as OFFSET, INDIRECT, INDEX, etc.).
* @param node
*/
- private async _getRangeListByNode(node: BaseAstNode) {
+ private async _getRangeListByNode(nodeData: IExecuteAstNodeData) {
// ref function in offset indirect INDEX
const preCalculateNodeList: PreCalculateNodeType[] = [];
const referenceFunctionList: FunctionNode[] = [];
- this._nodeTraversalRef(node, preCalculateNodeList);
+ const refOffsetX = nodeData.refOffsetX;
+ const refOffsetY = nodeData.refOffsetY;
+
+ this._nodeTraversalRef(nodeData.node, preCalculateNodeList);
- this._nodeTraversalReferenceFunction(node, referenceFunctionList);
+ this._nodeTraversalReferenceFunction(nodeData.node, referenceFunctionList);
const rangeList: IUnitRange[] = [];
for (let i = 0, len = preCalculateNodeList.length; i < len; i++) {
const node = preCalculateNodeList[i];
- const value: BaseReferenceObject = await this._executeNode(node);
+ const value: BaseReferenceObject = await this._executeNode(node, refOffsetX, refOffsetY);
const gridRange = value.toUnitRange();
@@ -537,7 +609,7 @@ export class FormulaDependencyGenerator extends Disposable {
for (let i = 0, len = referenceFunctionList.length; i < len; i++) {
const node = referenceFunctionList[i];
- const value: BaseReferenceObject = await this._executeNode(node);
+ const value: BaseReferenceObject = await this._executeNode(node, refOffsetX, refOffsetY);
const gridRange = value.toUnitRange();
@@ -622,6 +694,12 @@ export class FormulaDependencyGenerator extends Disposable {
}
private _dependencyFeatureCalculation(newTreeList: FormulaDependencyTree[]) {
+ const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();
+
+ if (featureMap.size === 0) {
+ return;
+ }
+
/**
* Clear the dependency relationships of all featureCalculation nodes in the tree.
* Because each execution requires rebuilding the reverse dependencies,
@@ -632,7 +710,6 @@ export class FormulaDependencyGenerator extends Disposable {
let hasFeatureCalculation = false;
- const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();
featureMap.forEach((subUnitMap, _) => {
subUnitMap.forEach((featureMap, _) => {
featureMap.forEach((params, featureId) => {
@@ -778,7 +855,7 @@ export class FormulaDependencyGenerator extends Disposable {
/**
* Detect whether the dirty map contains a defined name.
*/
- const node = tree.node;
+ const node = tree.nodeData?.node;
if (node != null) {
const dirtyDefinedName = this._isDirtyDefinedForNode(node);
if (dirtyDefinedName) {
@@ -789,7 +866,7 @@ export class FormulaDependencyGenerator extends Disposable {
}
private _detectForcedRecalculationNode(tree: FormulaDependencyTree) {
- const node = tree.node;
+ const node = tree.nodeData?.node;
if (node == null) {
return false;
@@ -894,8 +971,9 @@ export class FormulaDependencyGenerator extends Disposable {
* @param treeList
*/
private _calculateRunList(treeList: FormulaDependencyTree[]) {
- let stack = treeList;
+ const stack = treeList;
const formulaRunList = [];
+ const cacheStack: FormulaDependencyTree[] = [];
while (stack.length > 0) {
const tree = stack.pop();
@@ -911,7 +989,8 @@ export class FormulaDependencyGenerator extends Disposable {
continue;
}
- const cacheStack: FormulaDependencyTree[] = [];
+ // It will clear the array.
+ cacheStack.length = 0;
for (const parentTree of tree.parents) {
if (parentTree.isAdded() || tree.isSkip()) {
@@ -925,8 +1004,7 @@ export class FormulaDependencyGenerator extends Disposable {
tree.setSkip();
} else {
tree.setAdded();
- stack.push(tree);
- stack = stack.concat(cacheStack);
+ stack.push(tree, ...cacheStack);
}
}
diff --git a/packages/engine-formula/src/engine/dependency/generate-tree-id.ts b/packages/engine-formula/src/engine/dependency/generate-tree-id.ts
deleted file mode 100644
index 1643cfe6d5..0000000000
--- a/packages/engine-formula/src/engine/dependency/generate-tree-id.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { IDependencyManagerService } from '../../services/dependency-manager.service';
-import { generateRandomId } from '@univerjs/core';
-
-export function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): string {
- let idLength = 4;
- let id = generateRandomId(idLength);
- while (dependencyManagerService.hasTreeIdInCache(id)) {
- id = generateRandomId(++idLength);
- }
- return id;
-}
diff --git a/packages/engine-formula/src/engine/interpreter/interpreter.ts b/packages/engine-formula/src/engine/interpreter/interpreter.ts
index 152c95ec03..8497524d28 100644
--- a/packages/engine-formula/src/engine/interpreter/interpreter.ts
+++ b/packages/engine-formula/src/engine/interpreter/interpreter.ts
@@ -14,10 +14,12 @@
* limitations under the License.
*/
-import type { FunctionNode, LambdaNode } from '../ast-node';
-
import type { BaseAstNode } from '../ast-node/base-ast-node';
+import type { FunctionNode } from '../ast-node/function-node';
+import type { LambdaNode } from '../ast-node/lambda-node';
+import type { ReferenceNode } from '../ast-node/reference-node';
import type { FunctionVariantType } from '../reference-object/base-reference-object';
+import type { IExecuteAstNodeData } from '../utils/ast-node-tool';
import type { PreCalculateNodeType } from '../utils/node-type';
import { Disposable } from '@univerjs/core';
import { AstNodePromiseType } from '../../basics/common';
@@ -32,16 +34,20 @@ export class Interpreter extends Disposable {
super();
}
- async executeAsync(node: BaseAstNode): Promise<FunctionVariantType> {
+ async executeAsync(nodeData: IExecuteAstNodeData): Promise<FunctionVariantType> {
// if (!this._interpreterCalculateProps) {
// return ErrorValueObject.create(ErrorType.ERROR);
// }
- if (!node) {
+ if (!nodeData) {
return Promise.resolve(ErrorValueObject.create(ErrorType.VALUE));
}
- await this._executeAsync(node);
+ const node = nodeData.node;
+ const refOffsetX = nodeData.refOffsetX;
+ const refOffsetY = nodeData.refOffsetY;
+
+ await this._executeAsync(node, refOffsetX, refOffsetY);
const value = node.getValue();
@@ -52,16 +58,20 @@ export class Interpreter extends Disposable {
return Promise.resolve(value);
}
- execute(node: BaseAstNode): FunctionVariantType {
+ execute(nodeData: IExecuteAstNodeData): FunctionVariantType {
// if (!this._interpreterCalculateProps) {
// return ErrorValueObject.create(ErrorType.ERROR);
// }
- if (!node) {
+ if (!nodeData) {
return ErrorValueObject.create(ErrorType.VALUE);
}
- this._execute(node);
+ const node = nodeData.node;
+ const refOffsetX = nodeData.refOffsetX;
+ const refOffsetY = nodeData.refOffsetY;
+
+ this._execute(node, refOffsetX, refOffsetY);
const value = node.getValue();
@@ -101,7 +111,7 @@ export class Interpreter extends Disposable {
}
}
- private async _executeAsync(node: BaseAstNode): Promise<AstNodePromiseType> {
+ private async _executeAsync(node: BaseAstNode, refOffsetX = 0, refOffsetY = 0): Promise<AstNodePromiseType> {
if (this._runtimeService.isStopExecution()) {
return Promise.resolve(AstNodePromiseType.ERROR);
}
@@ -120,7 +130,11 @@ export class Interpreter extends Disposable {
item.execute();
continue;
}
- await this._executeAsync(item);
+ await this._executeAsync(item, refOffsetX, refOffsetY);
+ }
+
+ if (node.nodeType === NodeType.REFERENCE) {
+ (node as ReferenceNode).setRefOffset(refOffsetX, refOffsetY);
}
if (node.nodeType === NodeType.FUNCTION && (node as FunctionNode).isAsync()) {
@@ -132,7 +146,7 @@ export class Interpreter extends Disposable {
return Promise.resolve(AstNodePromiseType.SUCCESS);
}
- private _execute(node: BaseAstNode): AstNodePromiseType {
+ private _execute(node: BaseAstNode, refOffsetX = 0, refOffsetY = 0): AstNodePromiseType {
if (this._runtimeService.isStopExecution()) {
return AstNodePromiseType.ERROR;
}
@@ -151,7 +165,11 @@ export class Interpreter extends Disposable {
item.execute();
continue;
}
- this._execute(item);
+ this._execute(item, refOffsetX, refOffsetY);
+ }
+
+ if (node.nodeType === NodeType.REFERENCE) {
+ (node as ReferenceNode).setRefOffset(refOffsetX, refOffsetY);
}
node.execute();
diff --git a/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts b/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
index 7e7b5d9d53..3f3499c5a3 100644
--- a/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
@@ -17,7 +17,7 @@
import type { IRange } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
-import { deserializeRangeWithSheet } from '../utils/reference';
+import { deserializeRangeWithSheetWithCache } from '../utils/reference';
import { ErrorValueObject } from '../value-object/base-value-object';
import { BaseReferenceObject } from './base-reference-object';
import { RangeReferenceObject } from './range-reference-object';
@@ -25,7 +25,7 @@ import { RangeReferenceObject } from './range-reference-object';
export class CellReferenceObject extends BaseReferenceObject {
constructor(token: string) {
super(token);
- const grid = deserializeRangeWithSheet(token);
+ const grid = deserializeRangeWithSheetWithCache(token);
this.setForcedUnitIdDirect(grid.unitId);
this.setForcedSheetName(grid.sheetName);
this.setRangeData(grid.range);
diff --git a/packages/engine-formula/src/engine/reference-object/column-reference-object.ts b/packages/engine-formula/src/engine/reference-object/column-reference-object.ts
index 9ff9d1495e..5f9488524a 100644
--- a/packages/engine-formula/src/engine/reference-object/column-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/column-reference-object.ts
@@ -18,14 +18,14 @@ import { type IRange, RANGE_TYPE } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
import { matchToken } from '../../basics/token';
-import { deserializeRangeWithSheet } from '../utils/reference';
+import { deserializeRangeWithSheetWithCache } from '../utils/reference';
import { ErrorValueObject } from '../value-object/base-value-object';
import { BaseReferenceObject } from './base-reference-object';
export class ColumnReferenceObject extends BaseReferenceObject {
constructor(token: string) {
super(token);
- const grid = deserializeRangeWithSheet(token);
+ const grid = deserializeRangeWithSheetWithCache(token);
this.setForcedUnitIdDirect(grid.unitId);
this.setForcedSheetName(grid.sheetName);
const range: IRange = {
diff --git a/packages/engine-formula/src/engine/reference-object/row-reference-object.ts b/packages/engine-formula/src/engine/reference-object/row-reference-object.ts
index 72e6f06f9b..99278010b1 100644
--- a/packages/engine-formula/src/engine/reference-object/row-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/row-reference-object.ts
@@ -18,14 +18,14 @@ import { type IRange, RANGE_TYPE } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
import { matchToken } from '../../basics/token';
-import { deserializeRangeWithSheet } from '../utils/reference';
+import { deserializeRangeWithSheetWithCache } from '../utils/reference';
import { ErrorValueObject } from '../value-object/base-value-object';
import { BaseReferenceObject } from './base-reference-object';
export class RowReferenceObject extends BaseReferenceObject {
constructor(token: string) {
super(token);
- const grid = deserializeRangeWithSheet(token);
+ const grid = deserializeRangeWithSheetWithCache(token);
this.setForcedUnitIdDirect(grid.unitId);
this.setForcedSheetName(grid.sheetName);
const range: IRange = {
diff --git a/packages/engine-formula/src/engine/reference-object/table-reference-object.ts b/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
index 9b96c5a274..9d2143c5ef 100644
--- a/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
@@ -16,7 +16,8 @@
import type { ISuperTable } from '../../basics/common';
import { TableOptionType } from '../../basics/common';
-import { $SUPER_TABLE_COLUMN_REGEX } from '../../basics/regex';
+import { regexTestSuperTableColumn } from '../../basics/regex';
+
import { matchToken } from '../../basics/token';
import { BaseReferenceObject } from './base-reference-object';
@@ -115,7 +116,7 @@ export class TableReferenceObject extends BaseReferenceObject {
let startColumn = -1;
let endColumn = -1;
const colonIndex = rightString.indexOf(matchToken.COLON);
- if (new RegExp($SUPER_TABLE_COLUMN_REGEX, 'g').test(rightString)) {
+ if (regexTestSuperTableColumn(rightString)) {
// =Table2[[11111]:[222]]
const startColumnString = rightString.substring(0, colonIndex).substring(1, -1);
const endColumnString = rightString.substring(colonIndex + 1).substring(1, -1);
diff --git a/packages/engine-formula/src/engine/utils/ast-node-tool.ts b/packages/engine-formula/src/engine/utils/ast-node-tool.ts
index 81937700e9..130efc7310 100644
--- a/packages/engine-formula/src/engine/utils/ast-node-tool.ts
+++ b/packages/engine-formula/src/engine/utils/ast-node-tool.ts
@@ -17,6 +17,12 @@
import type { Nullable } from '@univerjs/core';
import type { BaseAstNode } from '../ast-node/base-ast-node';
+export interface IExecuteAstNodeData {
+ node: BaseAstNode;
+ refOffsetX: number;
+ refOffsetY: number;
+}
+
export function getAstNodeTopParent(node: BaseAstNode) {
let parent: Nullable<BaseAstNode> = node;
while (parent?.getParent()) {
@@ -25,3 +31,11 @@ export function getAstNodeTopParent(node: BaseAstNode) {
}
return parent;
}
+
+export function generateExecuteAstNodeData(node: BaseAstNode, refOffsetX: number = 0, refOffsetY: number = 0) {
+ return {
+ node,
+ refOffsetX,
+ refOffsetY,
+ };
+}
diff --git a/packages/engine-formula/src/engine/utils/math-kit.ts b/packages/engine-formula/src/engine/utils/math-kit.ts
index 1757e29e4a..4c09d589b2 100644
--- a/packages/engine-formula/src/engine/utils/math-kit.ts
+++ b/packages/engine-formula/src/engine/utils/math-kit.ts
@@ -23,21 +23,36 @@
import Decimal from 'decimal.js';
export function plus(a: number, b: number): number {
+ const result = a + b;
+ if (Number.isSafeInteger(result)) {
+ return result;
+ }
return new Decimal(a).add(b).toNumber();
}
export function minus(a: number, b: number): number {
+ const result = a - b;
+ if (Number.isSafeInteger(result)) {
+ return result;
+ }
return new Decimal(a).sub(b).toNumber();
}
export function multiply(a: number, b: number): number {
+ const result = a * b;
+ if (Number.isSafeInteger(result)) {
+ return result;
+ }
return new Decimal(a).mul(b).toNumber();
}
export function divide(a: number, b: number): number {
+ const result = a / b;
+ if (Number.isSafeInteger(result)) {
+ return result;
+ }
return new Decimal(a).div(b).toNumber();
}
-
/**
* Rounds a number to a specified number of decimal places.
* @param base The number to round.
diff --git a/packages/engine-formula/src/engine/utils/numfmt-kit.ts b/packages/engine-formula/src/engine/utils/numfmt-kit.ts
index d2ea3863ea..c5e879fb88 100644
--- a/packages/engine-formula/src/engine/utils/numfmt-kit.ts
+++ b/packages/engine-formula/src/engine/utils/numfmt-kit.ts
@@ -195,13 +195,30 @@ export function compareNumfmtPriority(oldPattern: string, pattern: string) {
return oldPattern;
}
+const numberFormatTypeCache = new Map<string, NumberFormatType>();
+
+function getNumberFormatType(pattern: string) {
+ if (numberFormatTypeCache.has(pattern)) {
+ return numberFormatTypeCache.get(pattern)!;
+ }
+
+ const type = getNumberFormatTypeRaw(pattern);
+ numberFormatTypeCache.set(pattern, type);
+
+ return type;
+}
+
+export function clearNumberFormatTypeCache() {
+ numberFormatTypeCache.clear();
+}
+
/**
* Get the type of the number format
*
* @param pattern
* @returns
*/
-function getNumberFormatType(pattern: string): NumberFormatType {
+function getNumberFormatTypeRaw(pattern: string): NumberFormatType {
if (isAccounting(pattern)) {
return NumberFormatType.Accounting;
}
diff --git a/packages/engine-formula/src/engine/utils/prefixHandler.ts b/packages/engine-formula/src/engine/utils/prefixHandler.ts
index f386fbc155..6857ebd68f 100644
--- a/packages/engine-formula/src/engine/utils/prefixHandler.ts
+++ b/packages/engine-formula/src/engine/utils/prefixHandler.ts
@@ -20,19 +20,22 @@ import { prefixToken } from '../../basics/token';
import { FUNCTION_NAMES_META } from '../../functions/meta/function-names';
import { PrefixNode } from '../ast-node/prefix-node';
+const minusRegExp = new RegExp(prefixToken.MINUS, 'g');
+const atRegExp = new RegExp(prefixToken.AT, 'g');
+
export function prefixHandler(tokenTrimParam: string, functionService: IFunctionService, injector: Injector) {
let minusPrefixNode: Nullable<PrefixNode>;
let atPrefixNode: Nullable<PrefixNode>;
let tokenTrim = tokenTrimParam;
const prefix = tokenTrim.slice(0, 2);
let sliceLength = 0;
- if (new RegExp(prefixToken.MINUS, 'g').test(prefix)) {
+ if (prefix[0] === prefixToken.MINUS) {
const functionExecutor = functionService.getExecutor(FUNCTION_NAMES_META.MINUS);
minusPrefixNode = new PrefixNode(injector, prefixToken.MINUS, functionExecutor);
sliceLength++;
}
- if (new RegExp(prefixToken.AT, 'g').test(prefix)) {
+ if (prefix[0] === prefixToken.AT) {
atPrefixNode = new PrefixNode(injector, prefixToken.AT);
if (minusPrefixNode) {
// minusPrefixNode.addChildren(atPrefixNode);
diff --git a/packages/engine-formula/src/engine/utils/reference.ts b/packages/engine-formula/src/engine/utils/reference.ts
index d8f9a0e46f..56b87573bb 100644
--- a/packages/engine-formula/src/engine/utils/reference.ts
+++ b/packages/engine-formula/src/engine/utils/reference.ts
@@ -18,7 +18,7 @@ import type { IRange, IUnitRangeName, IUnitRangeWithName } from '@univerjs/core'
import { AbsoluteRefType, RANGE_TYPE, Tools } from '@univerjs/core';
import { includeFormulaLexerToken } from '../../basics/match-token';
-import { isReferenceString, UNIT_NAME_REGEX } from '../../basics/regex';
+import { isReferenceString, UNIT_NAME_REGEX_PRECOMPILING } from '../../basics/regex';
import { prefixToken, SPACE_TOKEN } from '../../basics/token';
const $ROW_REGEX = /[^0-9]/g;
@@ -201,13 +201,13 @@ export function singleReferenceToGrid(refBody: string) {
}
export function handleRefStringInfo(refString: string) {
- const unitIdMatch = new RegExp(UNIT_NAME_REGEX).exec(refString);
+ const unitIdMatch = UNIT_NAME_REGEX_PRECOMPILING.exec(refString);
let unitId = '';
if (unitIdMatch != null) {
unitId = unitIdMatch[0].trim();
unitId = unitId.slice(1, unitId.length - 1);
- refString = refString.replace(new RegExp(UNIT_NAME_REGEX), '');
+ refString = refString.replace(UNIT_NAME_REGEX_PRECOMPILING, '');
}
const sheetNameIndex = refString.indexOf('!');
@@ -294,6 +294,23 @@ export function deserializeRangeWithSheet(refString: string): IUnitRangeName {
};
}
+const referenceToRangeCache = new Map<string, IUnitRangeName>();
+export function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName {
+ if (referenceToRangeCache.has(refString)) {
+ return referenceToRangeCache.get(refString)!;
+ }
+
+ const result = deserializeRangeWithSheet(refString);
+
+ referenceToRangeCache.set(refString, result);
+
+ return deserializeRangeWithSheet(refString); ;
+}
+
+export function clearReferenceToRangeCache() {
+ referenceToRangeCache.clear();
+}
+
/**
* LOG10 is a formula, google sheet support it on Log10:L
* EXCEL support it on Log10:Log10
diff --git a/packages/engine-formula/src/engine/value-object/array-value-object.ts b/packages/engine-formula/src/engine/value-object/array-value-object.ts
index 475b14d3ba..a31b3c8087 100644
--- a/packages/engine-formula/src/engine/value-object/array-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/array-value-object.ts
@@ -21,7 +21,7 @@ import { isRealNum } from '@univerjs/core';
import { BooleanValue } from '../../basics/common';
import { ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';
import { CELL_INVERTED_INDEX_CACHE } from '../../basics/inverted-index-cache';
-import { $ARRAY_VALUE_REGEX } from '../../basics/regex';
+import { regexTestArrayValue } from '../../basics/regex';
import { compareToken } from '../../basics/token';
import { ArrayBinarySearchType, ArrayOrderSearchType, getCompare } from '../utils/compare';
import { BaseValueObject, ErrorValueObject } from './base-value-object';
@@ -1898,7 +1898,7 @@ export class ValueObjectFactory {
}
const rawValueSingleLine = rawValue.replace(/\n/g, '').replace(/\r/g, '');
- if (!isStringWrappedByDoubleQuotes(rawValueSingleLine) && new RegExp($ARRAY_VALUE_REGEX, 'g').test(rawValueSingleLine)) {
+ if (!isStringWrappedByDoubleQuotes(rawValueSingleLine) && regexTestArrayValue(rawValueSingleLine)) {
return ArrayValueObject.create(rawValueSingleLine);
}
diff --git a/packages/engine-formula/src/engine/value-object/lambda-value-object.ts b/packages/engine-formula/src/engine/value-object/lambda-value-object.ts
index 4e772aabd0..ec834d078f 100644
--- a/packages/engine-formula/src/engine/value-object/lambda-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/lambda-value-object.ts
@@ -16,14 +16,15 @@
import type { Nullable } from '@univerjs/core';
-import { ErrorType } from '../../basics/error-type';
-import { DEFAULT_TOKEN_TYPE_LAMBDA_RUNTIME_PARAMETER } from '../../basics/token-type';
-import { AsyncObject } from '../reference-object/base-reference-object';
-import { BaseValueObject, ErrorValueObject } from './base-value-object';
import type { BaseAstNode } from '../ast-node/base-ast-node';
import type { LambdaParameterNode } from '../ast-node/lambda-parameter-node';
import type { Interpreter } from '../interpreter/interpreter';
import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';
+import { ErrorType } from '../../basics/error-type';
+import { DEFAULT_TOKEN_TYPE_LAMBDA_RUNTIME_PARAMETER } from '../../basics/token-type';
+import { AsyncObject } from '../reference-object/base-reference-object';
+import { generateExecuteAstNodeData } from '../utils/ast-node-tool';
+import { BaseValueObject, ErrorValueObject } from './base-value-object';
function getRootLexerHasValueNode(node: Nullable<BaseAstNode>): Nullable<BaseAstNode> {
if (!node) {
@@ -86,9 +87,9 @@ export class LambdaValueObjectObject extends BaseValueObject {
let value: AsyncObject | BaseValueObject;
if (this._interpreter.checkAsyncNode(this._lambdaNode)) {
- value = new AsyncObject(this._interpreter.executeAsync(this._lambdaNode) as Promise<BaseValueObject>);
+ value = new AsyncObject(this._interpreter.executeAsync(generateExecuteAstNodeData(this._lambdaNode)) as Promise<BaseValueObject>);
} else {
- const o = this._interpreter.execute(this._lambdaNode);
+ const o = this._interpreter.execute(generateExecuteAstNodeData(this._lambdaNode));
if (o.isReferenceObject()) {
value = (o as BaseReferenceObject).toArrayValueObject();
} else {
diff --git a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
index dbe73a6a06..a7e1fcc638 100644
--- a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
+++ b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../basics/error-type';
import { Lexer } from '../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../engine/analysis/parser';
import { Interpreter } from '../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../services/current-data.service';
import { IFunctionService } from '../../services/function.service';
import { IFormulaRuntimeService } from '../../services/runtime.service';
@@ -329,7 +330,7 @@ describe('Test nested functions', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/functions/base-function.ts b/packages/engine-formula/src/functions/base-function.ts
index 479c5c8bcc..930592aad8 100644
--- a/packages/engine-formula/src/functions/base-function.ts
+++ b/packages/engine-formula/src/functions/base-function.ts
@@ -14,11 +14,16 @@
* limitations under the License.
*/
-import { Disposable } from '@univerjs/core';
import type { IRange, Nullable } from '@univerjs/core';
+import type { IFunctionNames } from '../basics/function';
+
+import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
+import type { ArrayBinarySearchType } from '../engine/utils/compare';
+import type { ArrayValueObject } from '../engine/value-object/array-value-object';
+import type { IDefinedNameMapItem } from '../services/defined-names.service';
import { ErrorType } from '../basics/error-type';
-import { REFERENCE_REGEX_SINGLE_COLUMN, REFERENCE_REGEX_SINGLE_ROW, REFERENCE_SINGLE_RANGE_REGEX } from '../basics/regex';
+import { regexTestSingeRange, regexTestSingleColumn, regexTestSingleRow } from '../basics/regex';
import { compareToken } from '../basics/token';
import { CellReferenceObject } from '../engine/reference-object/cell-reference-object';
import { ColumnReferenceObject } from '../engine/reference-object/column-reference-object';
@@ -30,13 +35,8 @@ import { serializeRangeToRefString } from '../engine/utils/reference';
import { convertTonNumber } from '../engine/utils/value-object';
import { type BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
import { NullValueObject, NumberValueObject, type PrimitiveValueType } from '../engine/value-object/primitive-object';
-import type { IFunctionNames } from '../basics/function';
-import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
-import type { ArrayBinarySearchType } from '../engine/utils/compare';
-import type { ArrayValueObject } from '../engine/value-object/array-value-object';
-import type { IDefinedNameMapItem } from '../services/defined-names.service';
-export class BaseFunction extends Disposable {
+export class BaseFunction {
private _unitId: Nullable<string>;
private _subUnitId: Nullable<string>;
private _row: number = -1;
@@ -64,7 +64,7 @@ export class BaseFunction extends Disposable {
maxParams: number = -1;
constructor(private _name: IFunctionNames) {
- super();
+
}
get name() {
@@ -87,6 +87,10 @@ export class BaseFunction extends Disposable {
return this._column;
}
+ dispose() {
+
+ }
+
/**
* In Excel, to inject a defined name into a function that has positioning capabilities,
* such as using the INDIRECT function to reference a named range,
@@ -508,11 +512,11 @@ export class BaseFunction extends Disposable {
let referenceObject: BaseReferenceObject;
- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(token)) {
+ if (regexTestSingeRange(token)) {
referenceObject = new CellReferenceObject(token);
- } else if (new RegExp(REFERENCE_REGEX_SINGLE_ROW).test(token)) {
+ } else if (regexTestSingleRow(token)) {
referenceObject = new RowReferenceObject(token);
- } else if (new RegExp(REFERENCE_REGEX_SINGLE_COLUMN).test(token)) {
+ } else if (regexTestSingleColumn(token)) {
referenceObject = new ColumnReferenceObject(token);
} else {
referenceObject = new RangeReferenceObject(range, sheetId, unitId);
diff --git a/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts b/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
index 6c6b11bd47..d60f63053f 100644
--- a/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -137,7 +138,7 @@ describe('Test rank function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts
index 8b5ee70ba2..4ade2ba6f1 100644
--- a/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts
@@ -26,6 +26,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -199,7 +200,7 @@ describe('Test cell function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
if ((result as ErrorValueObject).isError()) {
return (result as ErrorValueObject).getValue();
diff --git a/packages/engine-formula/src/functions/information/cell/index.ts b/packages/engine-formula/src/functions/information/cell/index.ts
index 96fe8a8e78..2b61dcee80 100644
--- a/packages/engine-formula/src/functions/information/cell/index.ts
+++ b/packages/engine-formula/src/functions/information/cell/index.ts
@@ -15,9 +15,9 @@
*/
import type { IColumnData, IObjectArrayPrimitiveType } from '@univerjs/core';
+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
import { Tools } from '@univerjs/core';
import { ErrorType } from '../../../basics/error-type';
-import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
diff --git a/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts
index 3d3f4c02d0..658083714e 100644
--- a/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts
@@ -26,6 +26,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -137,7 +138,7 @@ describe('Test isformula function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
if ((result as ErrorValueObject).isError()) {
return (result as ErrorValueObject).getValue();
diff --git a/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts
index 7293c5c19e..2930952603 100644
--- a/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts
@@ -25,6 +25,7 @@ import { beforeEach, describe, expect, it } from 'vitest';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -197,7 +198,7 @@ describe('Test isref function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
if ((result as ErrorValueObject).isError()) {
return (result as ErrorValueObject).getValue();
diff --git a/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts
index 78bcfd9dae..fe50b8c46e 100644
--- a/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts
@@ -14,13 +14,16 @@
* limitations under the License.
*/
-import { beforeEach, describe, expect, it } from 'vitest';
import type { Injector } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Bycol } from '../index';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
describe('Test bycol', () => {
// const testFunction = new Bycol(FUNCTION_NAMES_LOGICAL.BYCOL);
@@ -60,36 +61,36 @@ describe('Test bycol', () => {
it('multiply', async () => {
let lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[2, 4, 6],
]);
lexerNode = lexer.treeBuilder('=BYCOL(1,LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(2);
lexerNode = lexer.treeBuilder('=BYCOL({1,2,3;4,5,6},LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);
});
it('value is error', async () => {
let lexerNode = lexer.treeBuilder('=BYCOL(#NAME?,LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},#NAME?)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},1)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
});
});
diff --git a/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts
index 44eb795aea..6f67ef9e1f 100644
--- a/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts
@@ -14,13 +14,16 @@
* limitations under the License.
*/
-import { beforeEach, describe, expect, it } from 'vitest';
import type { Injector } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Byrow } from '../index';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
describe('Test byrow', () => {
// const testFunction = new Byrow(FUNCTION_NAMES_LOGICAL.BYROW);
@@ -60,7 +61,7 @@ describe('Test byrow', () => {
it('multiply', async () => {
let lexerNode = lexer.treeBuilder('=BYROW({1;2;3},LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[2],
[4],
@@ -69,29 +70,29 @@ describe('Test byrow', () => {
lexerNode = lexer.treeBuilder('=BYROW(1,LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(2);
lexerNode = lexer.treeBuilder('=BYROW({1,2,3;4,5,6},LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);
});
it('value is error', async () => {
let lexerNode = lexer.treeBuilder('=BYROW(#NAME?,LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=BYROW({1;2;3},#NAME?)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=BYROW({1;2;3},1)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
});
});
diff --git a/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts
index 491b17355a..9c62b862ea 100644
--- a/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts
@@ -15,14 +15,16 @@
*/
import type { Injector } from '@univerjs/core';
-import { beforeEach, describe, expect, it } from 'vitest';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
+import type { BaseValueObject } from '../../../../engine/value-object/base-value-object';
+import { beforeEach, describe, expect, it } from 'vitest';
import { Lexer } from '../../../../engine/analysis/lexer';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
-import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -30,7 +32,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Makearray } from '../index';
-import type { BaseValueObject } from '../../../../engine/value-object/base-value-object';
describe('Test makearray', () => {
// const testFunction = new Makearray(FUNCTION_NAMES_LOGICAL.MAKEARRAY);
@@ -63,7 +64,7 @@ describe('Test makearray', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = await interpreter.executeAsync(astNode as BaseAstNode);
+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([
[1, 2, 3, 4],
@@ -78,7 +79,7 @@ describe('Test makearray', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = await interpreter.executeAsync(astNode as BaseAstNode);
+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(15);
});
@@ -88,7 +89,7 @@ describe('Test makearray', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = await interpreter.executeAsync(astNode as BaseAstNode);
+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([
[1, 2, 3, 4],
diff --git a/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts
index 2b87ec8c66..2a3b9aaf66 100644
--- a/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts
@@ -14,13 +14,16 @@
* limitations under the License.
*/
-import { beforeEach, describe, expect, it } from 'vitest';
import type { Injector } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Map } from '../index';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
describe('Test map', () => {
// const testFunction = new Map(FUNCTION_NAMES_LOGICAL.MAP);
@@ -60,7 +61,7 @@ describe('Test map', () => {
it('multiply', async () => {
let lexerNode = lexer.treeBuilder('=MAP({1;2;3},LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[2],
[4],
@@ -69,12 +70,12 @@ describe('Test map', () => {
lexerNode = lexer.treeBuilder('=MAP(1,LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(2);
lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[2, 4, 6],
[8, 10, 12],
@@ -82,7 +83,7 @@ describe('Test map', () => {
lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},1,LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[1, ErrorType.NA, ErrorType.NA],
[ErrorType.NA, ErrorType.NA, ErrorType.NA],
@@ -90,7 +91,7 @@ describe('Test map', () => {
lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},{1,2},LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[1, 4, ErrorType.NA],
[ErrorType.NA, ErrorType.NA, ErrorType.NA],
@@ -100,17 +101,17 @@ describe('Test map', () => {
it('value is error', async () => {
let lexerNode = lexer.treeBuilder('=MAP(#NAME?,LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=MAP({1;2;3},#NAME?)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=MAP({1;2;3},1)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
});
});
diff --git a/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts
index 6ecdb3d779..eeedeca1c7 100644
--- a/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts
@@ -14,13 +14,16 @@
* limitations under the License.
*/
-import { beforeEach, describe, expect, it } from 'vitest';
import type { Injector } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Reduce } from '../index';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
describe('Test reduce', () => {
// const testFunction = new Reduce(FUNCTION_NAMES_LOGICAL.REDUCE);
@@ -60,17 +61,17 @@ describe('Test reduce', () => {
it('multiply', async () => {
let lexerNode = lexer.treeBuilder('=REDUCE(1,{1;2;3},LAMBDA(x,y,x*y))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(6);
lexerNode = lexer.treeBuilder('=REDUCE(1,{1;2;3},LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
lexerNode = lexer.treeBuilder('=REDUCE({1,a,#NAME?;4,5,6},1,LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[1, ErrorType.VALUE, ErrorType.NAME],
[4, 5, 6],
@@ -80,12 +81,12 @@ describe('Test reduce', () => {
it('value is error', async () => {
let lexerNode = lexer.treeBuilder('=REDUCE(#NAME?,1,LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=REDUCE({1;2;3},#NAME?,LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[ErrorType.NAME],
[ErrorType.NAME],
@@ -94,7 +95,7 @@ describe('Test reduce', () => {
lexerNode = lexer.treeBuilder('=REDUCE({1;2;3},1,#NAME?)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[ErrorType.NAME],
[ErrorType.NAME],
@@ -103,7 +104,7 @@ describe('Test reduce', () => {
lexerNode = lexer.treeBuilder('=REDUCE(1,1,1)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
});
});
diff --git a/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts
index 95f3086f43..aedfc866e8 100644
--- a/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts
@@ -14,13 +14,16 @@
* limitations under the License.
*/
-import { beforeEach, describe, expect, it } from 'vitest';
import type { Injector } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFunctionService } from '../../../../services/function.service';
import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';
import { FUNCTION_NAMES_LOGICAL } from '../../function-names';
import { Lambda } from '../../lambda';
import { Scan } from '../index';
-import type { LexerNode } from '../../../../engine/analysis/lexer-node';
-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
describe('Test scan', () => {
// const testFunction = new Scan(FUNCTION_NAMES_LOGICAL.SCAN);
@@ -60,7 +61,7 @@ describe('Test scan', () => {
it('multiply', async () => {
let lexerNode = lexer.treeBuilder('=SCAN(1,{1;2;3},LAMBDA(x,y,x*y))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[1],
[2],
@@ -69,17 +70,17 @@ describe('Test scan', () => {
lexerNode = lexer.treeBuilder('=SCAN(1,1,LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(1);
lexerNode = lexer.treeBuilder('=SCAN(1,{1;2;3},LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
lexerNode = lexer.treeBuilder('=SCAN("test",{1;2;3},LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[ErrorType.VALUE],
[ErrorType.VALUE],
@@ -88,12 +89,12 @@ describe('Test scan', () => {
lexerNode = lexer.treeBuilder('=SCAN({1,a,#NAME?;4,5,6},1,LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);
lexerNode = lexer.treeBuilder('=SCAN(1,{1,2,#NAME?;4,5,6},LAMBDA(x,y,x*y))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual([
[1, 2, ErrorType.NAME],
[ErrorType.NAME, ErrorType.NAME, ErrorType.NAME],
@@ -103,22 +104,22 @@ describe('Test scan', () => {
it('value is error', async () => {
let lexerNode = lexer.treeBuilder('=SCAN(#NAME?,1,LAMBDA(x,x*2))');
let astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- let result = await interpreter.executeAsync(astNode as BaseAstNode);
+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=SCAN({1;2;3},#NAME?,LAMBDA(x,x*2))');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=SCAN(1,1,#NAME?)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);
lexerNode = lexer.treeBuilder('=SCAN({1},1,1)');
astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- result = await interpreter.executeAsync(astNode as BaseAstNode);
+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));
expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);
});
});
diff --git a/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts
index e84a9c42f2..44cdc6def5 100644
--- a/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts
@@ -25,6 +25,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -91,7 +92,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(1);
});
@@ -100,7 +101,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([[3]]);
});
@@ -109,7 +110,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([[3, 4, 5, 6]]);
});
@@ -118,7 +119,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -127,7 +128,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -136,7 +137,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -145,7 +146,7 @@ describe('Test column', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
diff --git a/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts
index 93a4679189..0c4e0da2fe 100644
--- a/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -90,7 +91,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -99,7 +100,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(4);
});
@@ -108,7 +109,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -117,7 +118,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -126,7 +127,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -135,7 +136,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -144,7 +145,7 @@ describe('Test columns', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
diff --git a/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts b/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts
index dedfcffe5c..fe2f6675d7 100644
--- a/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -196,7 +197,7 @@ describe('Test index', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts b/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts
index 8da095b7d4..653f52f0f6 100644
--- a/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts
@@ -25,6 +25,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -95,7 +96,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);
});
@@ -105,7 +106,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);
});
@@ -115,7 +116,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([
[ErrorType.VALUE, ErrorType.VALUE, ErrorType.VALUE, ErrorType.VALUE],
@@ -131,7 +132,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);
});
@@ -141,7 +142,7 @@ describe('Test indirect', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);
});
diff --git a/packages/engine-formula/src/functions/lookup/indirect/index.ts b/packages/engine-formula/src/functions/lookup/indirect/index.ts
index 5e808de115..08a783ef0d 100644
--- a/packages/engine-formula/src/functions/lookup/indirect/index.ts
+++ b/packages/engine-formula/src/functions/lookup/indirect/index.ts
@@ -14,17 +14,17 @@
* limitations under the License.
*/
+import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import { ErrorType } from '../../../basics/error-type';
-import { REFERENCE_REGEX_COLUMN, REFERENCE_REGEX_ROW, REFERENCE_SINGLE_RANGE_REGEX } from '../../../basics/regex';
+import { regexTestColumn, regexTestRow, regexTestSingeRange } from '../../../basics/regex';
import { operatorToken } from '../../../basics/token';
-import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';
import { CellReferenceObject } from '../../../engine/reference-object/cell-reference-object';
import { ColumnReferenceObject } from '../../../engine/reference-object/column-reference-object';
import { RangeReferenceObject } from '../../../engine/reference-object/range-reference-object';
import { RowReferenceObject } from '../../../engine/reference-object/row-reference-object';
import { deserializeRangeForR1C1 } from '../../../engine/utils/r1c1-reference';
-import { deserializeRangeWithSheet } from '../../../engine/utils/reference';
-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { deserializeRangeWithSheetWithCache } from '../../../engine/utils/reference';
import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
@@ -93,18 +93,18 @@ export class Indirect extends BaseFunction {
return this._setDefault(rangeReferenceObject);
}
- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(refTextV)) {
+ if (regexTestSingeRange(refTextV)) {
return this._setDefault(new CellReferenceObject(refTextV));
}
- if (new RegExp(REFERENCE_REGEX_ROW).test(refTextV)) {
+ if (regexTestRow(refTextV)) {
return this._setDefault(new RowReferenceObject(refTextV));
}
- if (new RegExp(REFERENCE_REGEX_COLUMN).test(refTextV)) {
+ if (regexTestColumn(refTextV)) {
return this._setDefault(new ColumnReferenceObject(refTextV));
}
- const gridRange = deserializeRangeWithSheet(refTextV);
+ const gridRange = deserializeRangeWithSheetWithCache(refTextV);
const { range, sheetName, unitId } = gridRange;
diff --git a/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts
index 564e072f08..f3f99b92be 100644
--- a/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -191,7 +192,7 @@ describe('Test offset', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts
index 6975346459..e71fe924a7 100644
--- a/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts
@@ -25,6 +25,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -91,7 +92,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toStrictEqual(1);
});
@@ -100,7 +101,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([[5]]);
});
@@ -109,7 +110,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ArrayValueObject).toValue()).toStrictEqual([[5], [6], [7], [8], [9], [10]]);
});
@@ -118,7 +119,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -127,7 +128,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -136,7 +137,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -145,7 +146,7 @@ describe('Test row', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
diff --git a/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts
index 237dccfcbf..da0986705b 100644
--- a/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -90,7 +91,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -99,7 +100,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(2);
});
@@ -108,7 +109,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);
});
@@ -117,7 +118,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -126,7 +127,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -135,7 +136,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
@@ -144,7 +145,7 @@ describe('Test rows', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
expect((result as BaseValueObject).getValue()).toBe(1);
});
diff --git a/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts
index 66f6e7f489..db9370347b 100644
--- a/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts
@@ -26,6 +26,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { stripErrorMargin } from '../../../../engine/utils/math-kit';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
@@ -189,7 +190,7 @@ describe('Test subtotal', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
if ((result as ErrorValueObject).isError()) {
return (result as ErrorValueObject).getValue();
diff --git a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
index a595fb7a85..5e2a96d5d6 100644
--- a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts
@@ -26,6 +26,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -208,7 +209,7 @@ describe('Test isref function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
if ((result as ErrorValueObject).isError()) {
return (result as ErrorValueObject).getValue();
diff --git a/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
index 6adeeb002f..35454d6a93 100644
--- a/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -145,7 +146,7 @@ describe('Test rank function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
index 74dbb5884c..ab5d20726a 100644
--- a/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
@@ -24,6 +24,7 @@ import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
import { AstTreeBuilder } from '../../../../engine/analysis/parser';
import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
@@ -145,7 +146,7 @@ describe('Test rank function', () => {
const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
- const result = interpreter.execute(astNode as BaseAstNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
return getObjectValue(result);
};
diff --git a/packages/engine-formula/src/services/calculate-formula.service.ts b/packages/engine-formula/src/services/calculate-formula.service.ts
index cc1d4a7c8c..5c9cb5c741 100644
--- a/packages/engine-formula/src/services/calculate-formula.service.ts
+++ b/packages/engine-formula/src/services/calculate-formula.service.ts
@@ -260,11 +260,11 @@ export class CalculateFormulaService extends Disposable {
}
const tree = treeList[i];
- const astNode = tree.node;
+ const nodeData = tree.nodeData;
const getDirtyData = tree.getDirtyData;
let value: FunctionVariantType;
- if (astNode == null && getDirtyData == null) {
+ if (nodeData == null && getDirtyData == null) {
throw new Error('AstNode or executor is null');
}
@@ -288,11 +288,11 @@ export class CalculateFormulaService extends Disposable {
this._runtimeService.setRuntimeFeatureCellData(tree.featureId, runtimeCellData);
this._runtimeService.setRuntimeFeatureRange(tree.featureId, dirtyRanges);
- } else if (astNode != null) {
- if (interpreter.checkAsyncNode(astNode)) {
- value = await interpreter.executeAsync(astNode);
+ } else if (nodeData != null) {
+ if (interpreter.checkAsyncNode(nodeData.node)) {
+ value = await interpreter.executeAsync(nodeData);
} else {
- value = interpreter.execute(astNode);
+ value = interpreter.execute(nodeData);
}
if (tree.formulaId != null) {
@@ -327,6 +327,8 @@ export class CalculateFormulaService extends Disposable {
this._runtimeService.markedAsNoFunctionsExecuted();
}
+ this._runtimeService.clearReferenceAndNumberformatCache();
+
return this._runtimeService.getAllRuntimeData();
}
diff --git a/packages/engine-formula/src/services/dependency-manager.service.ts b/packages/engine-formula/src/services/dependency-manager.service.ts
index 67751c0425..caef14704f 100644
--- a/packages/engine-formula/src/services/dependency-manager.service.ts
+++ b/packages/engine-formula/src/services/dependency-manager.service.ts
@@ -67,7 +67,7 @@ export interface IDependencyManagerService {
searchDependency(search: IUnitRange[]): Map<string, IRTreeItem>;
- hasTreeIdInCache(treeId: string): boolean;
+ getLastTreeId(): number;
clearDependencyAll(): void;
@@ -90,14 +90,14 @@ export class DependencyManagerService extends Disposable implements IDependencyM
private _dependencyRTreeCache: RTree = new RTree();
- private _dependencyTreeIdsCache: Set<string> = new Set();
+ private _dependencyTreeIdLast: number = 0;
override dispose(): void {
this._otherFormulaData = {};
this._featureFormulaData = {};
this._formulaData = {};
this._dependencyRTreeCache.dispose();
- this._clearTreeIdCache();
+ this._restDependencyTreeId();
}
/**
@@ -107,47 +107,60 @@ export class DependencyManagerService extends Disposable implements IDependencyM
getAllTree() {
const trees: FormulaDependencyTree[] = [];
- Object.values(this._otherFormulaData).forEach((unit) => {
- if (unit == null) {
- return true;
+ const resetAndPush = (item: FormulaDependencyTree) => {
+ if (item) {
+ item.resetState();
+ trees.push(item);
}
- Object.values(unit).forEach((sheet) => {
- Object.values(sheet).forEach((formula) => {
- if (formula) {
- formula.resetState();
- trees.push(formula);
+ };
+
+ // _otherFormulaData
+ for (const unitKey in this._otherFormulaData) {
+ const unit = this._otherFormulaData[unitKey];
+ if (!unit) continue;
+
+ for (const sheetKey in unit) {
+ const sheet = unit[sheetKey];
+ for (const formulaKey in sheet) {
+ if (sheet[formulaKey] == null) {
+ continue;
}
- });
- });
- });
-
- Object.values(this._featureFormulaData).forEach((unit) => {
- if (unit == null) {
- return true;
+ resetAndPush(sheet[formulaKey]);
+ }
}
- Object.values(unit).forEach((sheet) => {
- Object.values(sheet).forEach((feature) => {
- if (feature) {
- feature.resetState();
- trees.push(feature);
- }
- });
- });
- });
+ }
- Object.values(this._formulaData).map((unit) => {
- if (unit == null) {
- return [];
+ // _featureFormulaData
+ for (const unitKey in this._featureFormulaData) {
+ const unit = this._featureFormulaData[unitKey];
+ if (!unit) continue;
+
+ for (const sheetKey in unit) {
+ const sheet = unit[sheetKey];
+ for (const featureKey in sheet) {
+ if (sheet[featureKey] == null) {
+ continue;
+ }
+ resetAndPush(sheet[featureKey]);
+ }
}
- return Object.values(unit).forEach((sheet) => {
- return sheet.forValue((row, col, item) => {
- if (item) {
- item.resetState();
- trees.push(item);
+ }
+
+ // _formulaData
+ for (const unitKey in this._formulaData) {
+ const unit = this._formulaData[unitKey];
+ if (!unit) continue;
+
+ for (const sheetKey in unit) {
+ const sheet = unit[sheetKey];
+ sheet.forValue((row, col, item) => {
+ if (item == null) {
+ return true;
}
+ resetAndPush(item);
});
- });
- });
+ }
+ }
return trees;
}
@@ -175,32 +188,27 @@ export class DependencyManagerService extends Disposable implements IDependencyM
*/
private _buildDependencyTree(allTrees: FormulaDependencyTree[], shouldBeBuildTrees: FormulaDependencyTree[]) {
const shouldBeBuildTreeMap = new Map<string, FormulaDependencyTree>();
- shouldBeBuildTrees.forEach((tree) => shouldBeBuildTreeMap.set(tree.treeId, tree));
+ for (let i = 0; i < shouldBeBuildTrees.length; i++) {
+ const tree = shouldBeBuildTrees[i];
+ shouldBeBuildTreeMap.set(tree.treeId, tree);
+ }
- allTrees.forEach((tree) => {
+ for (let i = 0; i < allTrees.length; i++) {
+ const tree = allTrees[i];
const RTreeItem = tree.toRTreeItem();
+
const searchResults = this._dependencyRTreeCache.search(RTreeItem);
- searchResults.forEach((searchResult) => {
+ for (let j = 0; j < searchResults.length; j++) {
+ const searchResult = searchResults[j];
const shouldBeBuildTree = shouldBeBuildTreeMap.get(searchResult.id);
- if (shouldBeBuildTree) {
- if (tree === shouldBeBuildTree || shouldBeBuildTree.hasChildren(tree)) {
- return;
- }
+
+ if (shouldBeBuildTree && tree !== shouldBeBuildTree && !shouldBeBuildTree.hasChildren(tree)) {
shouldBeBuildTree.pushChildren(tree);
}
- });
-
- // shouldBeBuildTrees.forEach((shouldBeBuildTree) => {
- // if (tree === shouldBeBuildTree || shouldBeBuildTree.children.includes(tree)) {
- // return true;
- // }
+ }
+ }
- // if (shouldBeBuildTree.dependency(tree)) {
- // shouldBeBuildTree.pushChildren(tree);
- // }
- // });
- });
shouldBeBuildTreeMap.clear();
}
@@ -211,36 +219,29 @@ export class DependencyManagerService extends Disposable implements IDependencyM
*/
private _buildReverseDependency(allTrees: FormulaDependencyTree[], dependencyTrees: FormulaDependencyTree[]) {
const allTreeMap = new Map<string, FormulaDependencyTree>();
- allTrees.forEach((tree) => allTreeMap.set(tree.treeId, tree));
- dependencyTrees.forEach((tree) => {
+ for (let i = 0; i < allTrees.length; i++) {
+ const tree = allTrees[i];
+ allTreeMap.set(tree.treeId, tree);
+ }
+
+ for (let i = 0; i < dependencyTrees.length; i++) {
+ const tree = dependencyTrees[i];
const RTreeItem = tree.toRTreeItem();
+
const searchResults = this._dependencyRTreeCache.search(RTreeItem);
- searchResults.forEach((searchResult) => {
+ for (let j = 0; j < searchResults.length; j++) {
+ const searchResult = searchResults[j];
const allTree = allTreeMap.get(searchResult.id);
- if (allTree) {
- if (tree === allTree || allTree.hasChildren(tree)) {
- return;
- }
+
+ if (allTree && tree !== allTree && !allTree.hasChildren(tree)) {
allTree.pushChildren(tree);
}
- });
- });
+ }
+ }
allTreeMap.clear();
-
- // allTrees.forEach((tree) => {
- // dependencyTrees?.forEach((dependencyTree) => {
- // if (tree === dependencyTree || tree.children.includes(dependencyTree)) {
- // return true;
- // }
-
- // if (tree.dependency(dependencyTree)) {
- // tree.pushChildren(dependencyTree);
- // }
- // });
- // });
}
/**
@@ -279,7 +280,7 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._featureFormulaData = {};
this._formulaData = {};
this._dependencyRTreeCache.clear();
- this._clearTreeIdCache();
+ this._restDependencyTreeId();
}
addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree) {
@@ -291,8 +292,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
}
this._otherFormulaData[unitId]![sheetId][formulaId] = dependencyTree;
-
- this._addTreeIdToCache(dependencyTree);
}
removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]) {
@@ -302,8 +301,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCache(deleteTree);
this.clearDependencyForTree(deleteTree);
delete this._otherFormulaData[unitId]![sheetId][formulaId];
-
- this._removeTreeIdFromCache(deleteTree);
});
}
}
@@ -321,7 +318,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCacheById(unitId, sheetId);
Object.values(this._otherFormulaData[unitId]![sheetId]).forEach((formula) => {
this.clearDependencyForTree(formula);
- this._removeTreeIdFromCache(formula);
});
this._otherFormulaData[unitId]![sheetId] = {};
@@ -334,7 +330,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCacheById(unitId, sheetId);
Object.values(unitOtherData[sheetId]!).forEach((formula) => {
this.clearDependencyForTree(formula);
- this._removeTreeIdFromCache(formula);
});
});
@@ -351,8 +346,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
}
this._featureFormulaData[unitId]![sheetId][featureId] = dependencyTree;
-
- this._addTreeIdToCache(dependencyTree);
}
removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]) {
@@ -362,8 +355,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCache(deleteTree);
this.clearDependencyForTree(deleteTree);
delete this._featureFormulaData[unitId]![sheetId][featureId];
-
- this._removeTreeIdFromCache(deleteTree);
});
}
}
@@ -374,7 +365,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
Object.values(this._featureFormulaData[unitId]![sheetId]).forEach((feature) => {
this._removeDependencyRTreeCache(feature);
this.clearDependencyForTree(feature);
- this._removeTreeIdFromCache(feature);
});
this._featureFormulaData[unitId]![sheetId] = {};
@@ -387,7 +377,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCacheById(unitId, sheetId);
Object.values(unitFeatureData[sheetId]!).forEach((feature) => {
this.clearDependencyForTree(feature);
- this._removeTreeIdFromCache(feature);
});
});
@@ -407,8 +396,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._formulaData[unitId]![sheetId] = new ObjectMatrix<Nullable<FormulaDependencyTree>>();
}
this._formulaData[unitId]![sheetId].setValue(row, column, dependencyTree);
-
- this._addTreeIdToCache(dependencyTree);
}
removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number) {
@@ -417,8 +404,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCache(deleteTree);
this.clearDependencyForTree(deleteTree);
this._formulaData[unitId]![sheetId].realDeleteValue(row, column);
-
- this._removeTreeIdFromCache(deleteTree);
}
}
@@ -427,7 +412,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCacheById(unitId, sheetId);
this._formulaData[unitId]![sheetId].forValue((row, column, item) => {
this.clearDependencyForTree(item);
- this._removeTreeIdFromCache(item);
});
this._formulaData[unitId]![sheetId].reset();
@@ -440,7 +424,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._removeDependencyRTreeCacheById(unitId, sheetId);
unitFormulaData[sheetId].forValue((row, column, item) => {
this.clearDependencyForTree(item);
- this._removeTreeIdFromCache(item);
});
});
@@ -453,7 +436,7 @@ export class DependencyManagerService extends Disposable implements IDependencyM
this._featureFormulaData = {};
this._formulaData = {};
this._dependencyRTreeCache.clear();
- this._clearTreeIdCache();
+ this._restDependencyTreeId();
}
getFormulaDependency(unitId: string, sheetId: string, row: number, column: number) {
@@ -469,23 +452,14 @@ export class DependencyManagerService extends Disposable implements IDependencyM
}));
}
- private _addTreeIdToCache(tree: FormulaDependencyTree) {
- this._dependencyTreeIdsCache.add(tree.treeId);
- }
-
- private _removeTreeIdFromCache(tree: Nullable<FormulaDependencyTree>) {
- if (tree == null) {
- return;
- }
- this._dependencyTreeIdsCache.delete(tree.treeId);
- }
-
- private _clearTreeIdCache() {
- this._dependencyTreeIdsCache.clear();
+ private _restDependencyTreeId() {
+ this._dependencyTreeIdLast = 0;
}
- hasTreeIdInCache(treeId: string) {
- return this._dependencyTreeIdsCache.has(treeId);
+ getLastTreeId() {
+ const id = this._dependencyTreeIdLast;
+ this._dependencyTreeIdLast++;
+ return id;
}
private _removeDependencyRTreeCacheById(unitId: string, sheetId: string) {
@@ -508,11 +482,10 @@ export class DependencyManagerService extends Disposable implements IDependencyM
if (this._formulaData[unitId]) {
Object.values(this._formulaData[unitId]).forEach((sheet) => {
sheet.forValue((row, column, tree) => {
- if (tree?.node?.hasDefinedName(definedName)) {
+ if (tree?.nodeData?.node.hasDefinedName(definedName)) {
this._removeDependencyRTreeCache(tree);
this.clearDependencyForTree(tree);
sheet.realDeleteValue(row, column);
- this._removeTreeIdFromCache(tree);
}
});
});
diff --git a/packages/engine-formula/src/services/runtime.service.ts b/packages/engine-formula/src/services/runtime.service.ts
index 82cb58d722..1fc391e581 100644
--- a/packages/engine-formula/src/services/runtime.service.ts
+++ b/packages/engine-formula/src/services/runtime.service.ts
@@ -30,6 +30,8 @@ import { isInDirtyRange } from '../basics/dirty';
import { ErrorType } from '../basics/error-type';
import { CELL_INVERTED_INDEX_CACHE } from '../basics/inverted-index-cache';
import { getRuntimeFeatureCell } from '../engine/utils/get-runtime-feature-cell';
+import { clearNumberFormatTypeCache } from '../engine/utils/numfmt-kit';
+import { clearReferenceToRangeCache } from '../engine/utils/reference';
import { objectValueToCellValue } from '../engine/utils/value-object';
import { type BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
import { IFormulaCurrentConfigService } from './current-data.service';
@@ -174,6 +176,8 @@ export interface IFormulaRuntimeService {
setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;
setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;
+
+ clearReferenceAndNumberformatCache(): void;
}
export class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {
@@ -253,6 +257,7 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
this.reset();
this._runtimeFeatureCellData = {};
this._runtimeFeatureRange = {};
+ this.clearReferenceAndNumberformatCache();
}
enableCycleDependency() {
@@ -363,6 +368,11 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
this._completedFormulasCount = 0;
}
+ clearReferenceAndNumberformatCache() {
+ clearNumberFormatTypeCache();
+ clearReferenceToRangeCache();
+ }
+
setCurrent(row: number, column: number, rowCount: number, columnCount: number, sheetId: string, unitId: string) {
this._currentRow = row;
this._currentColumn = column;
diff --git a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
index d81e37dad5..8fca0ef8be 100644
--- a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
+++ b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts
@@ -15,8 +15,10 @@
*/
import type { ICommandInfo, IExecutionOptions, IRange, Nullable, Workbook, Worksheet } from '@univerjs/core';
+import type { ISetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
import type { IAfterRender$Info, IBasicFrameInfo, IExtendFrameInfo, IRenderContext, IRenderModule, ISummaryFrameInfo, ITimeMetric, IViewportInfos, Scene } from '@univerjs/engine-render';
import { CommandType, ICommandService, IContextService, Inject, Optional, Rectangle, RxDisposable } from '@univerjs/core';
+import { SetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';
import {
Rect,
ScrollBar,
@@ -29,8 +31,8 @@ import {
} from '@univerjs/engine-render';
import { COMMAND_LISTENER_SKELETON_CHANGE, COMMAND_LISTENER_VALUE_CHANGE, MoveRangeMutation, SetRangeValuesMutation, SetWorksheetActiveOperation } from '@univerjs/sheets';
import { ITelemetryService } from '@univerjs/telemetry';
-import { Subject, withLatestFrom } from 'rxjs';
+import { Subject, withLatestFrom } from 'rxjs';
import {
SHEET_COMPONENT_HEADER_LAYER_INDEX,
SHEET_COMPONENT_MAIN_LAYER_INDEX,
@@ -424,6 +426,13 @@ export class SheetRenderController extends RxDisposable implements IRenderModule
private _markUnitDirty(unitId: string, command: ICommandInfo) {
const { mainComponent: spreadsheet, scene } = this._context;
+ if (command.id === SetFormulaCalculationNotificationMutation.id) {
+ const params = command.params as ISetFormulaCalculationNotificationMutation;
+ if (params.stageInfo != null) {
+ return;
+ }
+ }
+
if (spreadsheet) {
spreadsheet.makeDirty(); // refresh spreadsheet
}