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.

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.ts
index 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.ts
index 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();
}
}