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.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
fix(formula): fix sumif formula range and sumRange different dimensions (#3853)
wpxp123456faf7936059f5
diff --git a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.tsindex 5dbcf666f5..e498008ee9 100644--- a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts@@ -14,99 +14,258 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+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 { ErrorValueObject } from '../../../../engine/value-object/base-value-object';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_MATH } from '../../function-names';import { Sumif } from '../index';-import { StringValueObject } from '../../../../engine/value-object/primitive-object';-import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';-import { ErrorType } from '../../../../basics/error-type';++const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: true,+ t: CellValueType.BOOLEAN,+ },+ 2: {+ v: 'Ada',+ t: CellValueType.STRING,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: false,+ t: CellValueType.BOOLEAN,+ },+ 2: {+ v: 'test1',+ t: CellValueType.STRING,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: null,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 'test12',+ t: CellValueType.STRING,+ },+ 3: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: null,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 'Univer',+ t: CellValueType.STRING,+ },+ 3: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};describe('Test sumif function', () => {- const testFunction = new Sumif(FUNCTION_NAMES_MATH.SUMIF);+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;- describe('Sumif', () => {- it('Range and criteria', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- 1;- 4;- 44;- 444- }`);+ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;- const criteria = StringValueObject.create('>40');+ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toBe(488);+ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, different type', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- true- }`);+ const sheetItem = testBed.sheetData[testBed.sheetId];++ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );++ functionService.registerExecutors(+ new Sumif(FUNCTION_NAMES_MATH.SUMIF)+ );++ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);++ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const criteria = StringValueObject.create('>');+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1- }`);+ return getObjectValue(result);+ };+ });++ describe('Sumif', () => {+ it('Range and criteria', async () => {+ const result = await calculate('=SUMIF(A1:A4,">40")');+ expect(result).toBe(488);+ });- const resultObject = testFunction.calculate(range, criteria, sumRange);- expect(resultObject.getValue()).toBe(0);+ it('Range and criteria, different type', async () => {+ const result = await calculate('=SUMIF(B1,">4",A1)');+ expect(result).toBe(0);});it('Sum range with wildcard asterisk', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- Ada;- test1;- test12;- Univer- }`);-- const criteria = StringValueObject.create('test*');-- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1;- 1- }`);-- const resultObject = testFunction.calculate(range, criteria, sumRange);- expect(resultObject.getValue()).toBe(2);+ const result = await calculate('=SUMIF(C1:C4,"test*",A1:A4)');+ expect(result).toBe(48);});it('ArrayValueObject range and ArrayValueObject criteria', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- 1;- 4;- 44;- 444- }`);-- const criteria = ArrayValueObject.create(/*ts*/ `{- 4;- 4;- 44;- 444- }`);-- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[4], [4], [44], [444]]);+ const result = await calculate('=SUMIF(A1:A4,D1:D4)');+ expect(result).toStrictEqual([+ [4],+ [4],+ [44],+ [444],+ ]);++ const result2 = await calculate('=SUMIF(A1:A4,E1:E4)');+ expect(result2).toStrictEqual([+ [0],+ [4],+ [44],+ [444],+ ]);++ const result3 = await calculate('=SUMIF(A1:A4,A2)');+ expect(result3).toBe(4);});- it('Includes REF error', async () => {- const range = ErrorValueObject.create(ErrorType.REF);-- const criteria = ArrayValueObject.create(/*ts*/ `{- 4;- 4;- 44;- 444- }`);-- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toStrictEqual(ErrorType.REF);++ it('Includes error', async () => {+ const error = ErrorValueObject.create(ErrorType.NAME);++ const result = await calculate(`=SUMIF(${error},A1:A4)`);+ expect(result).toStrictEqual([+ [ErrorType.NAME],+ [ErrorType.NAME],+ [ErrorType.NAME],+ [ErrorType.NAME],+ ]);++ const result2 = await calculate(`=SUMIF(A1:A4,${error})`);+ expect(result2).toBe(ErrorType.NAME);++ const result3 = await calculate(`=SUMIF(A1:A4,">40",${error})`);+ expect(result3).toBe(ErrorType.NAME);+ });++ it('Range or sumRange is not referenceObject', async () => {+ const result = await calculate('=SUMIF(1,"test*",A1:A4)');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range length is not equal to sumRange length', async () => {+ const result = await calculate('=SUMIF(A1:A4,">40",E1:E2)');+ expect(result).toBe(488);});});});diff --git a/packages/engine-formula/src/functions/math/sumif/index.ts b/packages/engine-formula/src/functions/math/sumif/index.tsindex 5ef802103f..eac0859ec4 100644--- a/packages/engine-formula/src/functions/math/sumif/index.ts+++ b/packages/engine-formula/src/functions/math/sumif/index.ts@@ -14,10 +14,11 @@* limitations under the License.*/+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { ErrorType } from '../../../basics/error-type';import { findCompareToken, valueObjectCompare } from '../../../engine/utils/object-compare';import { filterSameValueObjectResult } from '../../../engine/utils/value-object';-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -26,9 +27,31 @@ export class Sumif extends BaseFunction {override maxParams = 3;- override calculate(range: BaseValueObject, criteria: BaseValueObject, sumRange?: BaseValueObject) {+ override needsReferenceObject = true;++ override calculate(range: FunctionVariantType, criteria: FunctionVariantType, sumRange?: FunctionVariantType): BaseValueObject {+ let _criteria = criteria;++ if (criteria.isReferenceObject()) {+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();+ }++ if (_criteria.isArray()) {+ const resultArray = (_criteria as ArrayValueObject).mapValue((criteriaObject) => this._handleSingleObject(range, criteriaObject, sumRange));++ if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;+ }++ return this._handleSingleObject(range, _criteria as BaseValueObject, sumRange);+ }++ private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, sumRange?: FunctionVariantType): BaseValueObject {if (range.isError()) {- return range;+ return range as ErrorValueObject;}if (criteria.isError()) {@@ -36,39 +59,46 @@ export class Sumif extends BaseFunction {}if (sumRange?.isError()) {- return sumRange;+ return sumRange as ErrorValueObject;}- if (!range.isArray() || (sumRange && !sumRange.isArray())) {+ if (!range.isReferenceObject() || (sumRange && !sumRange.isReferenceObject())) {return ErrorValueObject.create(ErrorType.VALUE);}- if (criteria.isArray()) {- return criteria.map((criteriaItem) => this._handleSingleObject(range, criteriaItem, sumRange));- }+ const _range = (range as BaseReferenceObject).toArrayValueObject();- return this._handleSingleObject(range, criteria, sumRange);- }-- private _handleSingleObject(range: BaseValueObject, criteria: BaseValueObject, sumRange?: BaseValueObject) {- let resultArrayObject = valueObjectCompare(range, criteria);+ let resultArrayObject = valueObjectCompare(_range, criteria);const [, criteriaStringObject] = findCompareToken(`${criteria.getValue()}`);// When comparing non-numbers and numbers, it does not take the result- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteriaStringObject);+ resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteriaStringObject);- // sumRange has the same dimensions as range- const sumRangeArray = sumRange- ? (sumRange as ArrayValueObject).slice(- [0, (range as ArrayValueObject).getRowCount()],- [0, (range as ArrayValueObject).getColumnCount()]- )- : (range as ArrayValueObject);+ const rangeRowCount = _range.getRowCount();+ const rangeColumnCount = _range.getColumnCount();- if (!sumRangeArray) {- return ErrorValueObject.create(ErrorType.VALUE);+ let _sumRange = _range;++ if (sumRange) {+ _sumRange = (sumRange as BaseReferenceObject).toArrayValueObject();++ const sumRangeRowCount = _sumRange.getRowCount();+ const sumRangeColumnCount = _sumRange.getColumnCount();++ // sumRange has different dimensions than range, then adjust sumRange dimensions to match range dimensions+ // TODO: @DR-Univer The current situation is that the cell value in the extended range changes,+ // but it is not within the formula parameter range, so it will not trigger the formula to recalculate.+ if (rangeRowCount !== sumRangeRowCount || rangeColumnCount !== sumRangeColumnCount) {+ const rangeData = (sumRange as BaseReferenceObject).getRangeData();+ rangeData.endRow = rangeData.startRow + rangeRowCount - 1;+ rangeData.endColumn = rangeData.startColumn + rangeColumnCount - 1;++ (sumRange as BaseReferenceObject).setRangeData(rangeData);++ _sumRange = (sumRange as BaseReferenceObject).toArrayValueObject();+ }}- return sumRangeArray.pick(resultArrayObject as ArrayValueObject).sum();+ return _sumRange.pick(resultArrayObject as ArrayValueObject).sum();}}