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): case sensitive (#2329)

Dushusira6761dda2cd3
diff --git a/packages/engine-formula/src/engine/utils/object-compare.ts b/packages/engine-formula/src/engine/utils/object-compare.ts
index 55dd1cc6b6..47f013c4ee 100644
--- a/packages/engine-formula/src/engine/utils/object-compare.ts
+++ b/packages/engine-formula/src/engine/utils/object-compare.ts
@@ -47,7 +47,7 @@ export function findCompareToken(str: string): [compareToken, BaseValueObject] {
* 2. >=apple*: normal value, >apple: obtains the same effect as >=apple*
* 3. <apple*: normal value, <=apple: obtains the same effect as <apple*
*/
-export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken) {
+export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken, isCaseSensitive?: boolean) {
if (!operator) {
// Only strings can extract comparison symbols, other types of values are 'equal to'
// TODO: criteria: 32, ">32", B5, "3?", "apple*", "*~?", TODAY(), ">"&A1:B3
@@ -61,7 +61,7 @@ export function valueObjectCompare(range: BaseValueObject, criteria: BaseValueOb
}
}
- return range.compare(criteria, operator);
+ return range.compare(criteria, operator, isCaseSensitive);
}
/**
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 fb08f0dba1..d30d63dcd5 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
@@ -713,7 +713,8 @@ export class ArrayValueObject extends BaseValueObject {
) {
const compareFunc = getCompare();
- const value = valueObject.getValue().toString();
+ // case insensitive
+ const value = valueObject.getValue().toString().toLocaleLowerCase();
let start = 0;
let end = searchArray.length - 1;
@@ -730,7 +731,8 @@ export class ArrayValueObject extends BaseValueObject {
} else {
const compareToValue = compareTo.getValue();
- compare = compareFunc(compareToValue.toString(), value);
+ // case insensitive
+ compare = compareFunc(compareToValue.toString().toLocaleLowerCase(), value);
}
if (compare === 0) {
@@ -917,8 +919,8 @@ export class ArrayValueObject extends BaseValueObject {
});
}
- override compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {
- return this._batchOperator(valueObject, BatchOperatorType.COMPARE, operator);
+ override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {
+ return this._batchOperator(valueObject, BatchOperatorType.COMPARE, operator, isCaseSensitive);
}
override concatenateFront(valueObject: BaseValueObject): BaseValueObject {
@@ -1353,7 +1355,8 @@ export class ArrayValueObject extends BaseValueObject {
private _batchOperator(
valueObject: BaseValueObject,
batchOperatorType: BatchOperatorType,
- operator?: compareToken
+ operator?: compareToken,
+ isCaseSensitive?: boolean
): BaseValueObject {
const valueList: BaseValueObject[] = [];
@@ -1381,7 +1384,7 @@ export class ArrayValueObject extends BaseValueObject {
valueList.push(list[0][c] as BaseValueObject);
}
} else {
- return this._batchOperatorArray(valueObject, batchOperatorType, operator);
+ return this._batchOperatorArray(valueObject, batchOperatorType, operator, isCaseSensitive);
}
} else {
for (let c = 0; c < columnCount; c++) {
@@ -1393,7 +1396,7 @@ export class ArrayValueObject extends BaseValueObject {
for (let c = 0; c < columnCount; c++) {
const value = valueList[c];
- this._batchOperatorValue(value, c, result, batchOperatorType, operator);
+ this._batchOperatorValue(value, c, result, batchOperatorType, operator, isCaseSensitive);
}
const newArray = this._createNewArray(result, rowCount, columnCount);
@@ -1408,7 +1411,8 @@ export class ArrayValueObject extends BaseValueObject {
column: number,
result: BaseValueObject[][],
batchOperatorType: BatchOperatorType,
- operator?: compareToken
+ operator?: compareToken,
+ isCaseSensitive?: boolean
) {
const rowCount = this._rowCount;
@@ -1474,7 +1478,7 @@ export class ArrayValueObject extends BaseValueObject {
currentValue = BooleanValueObject.create(rowValue);
}
- const matchResult = currentValue.compare(valueObject, operator as compareToken);
+ const matchResult = currentValue.compare(valueObject, operator as compareToken, isCaseSensitive);
if ((matchResult as BooleanValueObject).getValue() === true) {
rowPositions.forEach((index) => {
if (index >= startRow && index <= startRow + rowCount - 1) {
@@ -1545,7 +1549,7 @@ export class ArrayValueObject extends BaseValueObject {
if (!operator) {
result[r][column] = ErrorValueObject.create(ErrorType.VALUE);
} else {
- result[r][column] = currentValue.compare(valueObject, operator as compareToken);
+ result[r][column] = currentValue.compare(valueObject, operator as compareToken, isCaseSensitive);
}
break;
case BatchOperatorType.CONCATENATE_FRONT:
@@ -1614,7 +1618,8 @@ export class ArrayValueObject extends BaseValueObject {
private _batchOperatorArray(
valueObject: BaseValueObject,
batchOperatorType: BatchOperatorType,
- operator?: compareToken
+ operator?: compareToken,
+ isCaseSensitive?: boolean
) {
let rowCount = (valueObject as ArrayValueObject).getRowCount();
let columnCount = (valueObject as ArrayValueObject).getColumnCount();
@@ -1686,7 +1691,7 @@ export class ArrayValueObject extends BaseValueObject {
if (!operator) {
rowList[c] = ErrorValueObject.create(ErrorType.VALUE);
} else {
- rowList[c] = currentValue.compare(opValue, operator as compareToken);
+ rowList[c] = currentValue.compare(opValue, operator as compareToken, isCaseSensitive);
}
break;
case BatchOperatorType.CONCATENATE_FRONT:
diff --git a/packages/engine-formula/src/engine/value-object/base-value-object.ts b/packages/engine-formula/src/engine/value-object/base-value-object.ts
index 44faf35313..37cb4c9863 100644
--- a/packages/engine-formula/src/engine/value-object/base-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/base-value-object.ts
@@ -177,7 +177,7 @@ export class BaseValueObject extends ObjectClassType {
return ErrorValueObject.create(ErrorType.NAME);
}
- compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {
+ compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive: boolean = false): BaseValueObject {
/** abstract */
return ErrorValueObject.create(ErrorType.NAME);
}
diff --git a/packages/engine-formula/src/engine/value-object/primitive-object.ts b/packages/engine-formula/src/engine/value-object/primitive-object.ts
index 065d677478..3261dd7bb4 100644
--- a/packages/engine-formula/src/engine/value-object/primitive-object.ts
+++ b/packages/engine-formula/src/engine/value-object/primitive-object.ts
@@ -702,61 +702,69 @@ export class NumberValueObject extends BaseValueObject {
override compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject {
const currentValue = this.getValue();
let result = false;
+
if (typeof value === 'string') {
- switch (operator) {
- case compareToken.EQUALS:
- case compareToken.GREATER_THAN:
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = false;
- break;
- case compareToken.LESS_THAN:
- case compareToken.LESS_THAN_OR_EQUAL:
- case compareToken.NOT_EQUAL:
- result = true;
- break;
- }
+ result = this._compareString(operator);
} else if (typeof value === 'number') {
- if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
- result = this._compareInfinity(currentValue, value, operator);
- } else {
- switch (operator) {
- case compareToken.EQUALS:
- result = Big(currentValue).eq(value);
- break;
- case compareToken.GREATER_THAN:
- result = Big(currentValue).gt(value);
- break;
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = Big(currentValue).gte(value);
- break;
- case compareToken.LESS_THAN:
- result = Big(currentValue).lt(value);
- break;
- case compareToken.LESS_THAN_OR_EQUAL:
- result = Big(currentValue).lte(value);
- break;
- case compareToken.NOT_EQUAL:
- result = !Big(currentValue).eq(value);
- break;
- }
- }
+ result = this._compareNumber(currentValue, value, operator);
} else if (typeof value === 'boolean') {
- switch (operator) {
- case compareToken.EQUALS:
- case compareToken.GREATER_THAN:
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = false;
- break;
- case compareToken.LESS_THAN:
- case compareToken.LESS_THAN_OR_EQUAL:
- case compareToken.NOT_EQUAL:
- result = true;
- break;
- }
+ result = this._compareBoolean(operator);
}
+
return BooleanValueObject.create(result);
}
+ private _compareString(operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.EQUALS:
+ case compareToken.GREATER_THAN:
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return false;
+ case compareToken.LESS_THAN:
+ case compareToken.LESS_THAN_OR_EQUAL:
+ case compareToken.NOT_EQUAL:
+ return true;
+ }
+ }
+
+ private _compareNumber(currentValue: number, value: number, operator: compareToken): boolean {
+ if (!Number.isFinite(currentValue) || !Number.isFinite(value)) {
+ return this._compareInfinity(currentValue, value, operator);
+ } else {
+ return this._compareFiniteNumber(currentValue, value, operator);
+ }
+ }
+
+ private _compareFiniteNumber(currentValue: number, value: number, operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.EQUALS:
+ return Big(currentValue).eq(value);
+ case compareToken.GREATER_THAN:
+ return Big(currentValue).gt(value);
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return Big(currentValue).gte(value);
+ case compareToken.LESS_THAN:
+ return Big(currentValue).lt(value);
+ case compareToken.LESS_THAN_OR_EQUAL:
+ return Big(currentValue).lte(value);
+ case compareToken.NOT_EQUAL:
+ return !Big(currentValue).eq(value);
+ }
+ }
+
+ private _compareBoolean(operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.EQUALS:
+ case compareToken.GREATER_THAN:
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return false;
+ case compareToken.LESS_THAN:
+ case compareToken.LESS_THAN_OR_EQUAL:
+ case compareToken.NOT_EQUAL:
+ return true;
+ }
+ }
+
override pow(valueObject: BaseValueObject): BaseValueObject {
if (valueObject.isArray()) {
return valueObject.powInverse(this);
@@ -1254,76 +1262,85 @@ export class StringValueObject extends BaseValueObject {
return StringValueObject.create(this.concatenate(valueObject.getValue(), ConcatenateType.BACK));
}
- override compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject {
+ override compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject {
if (valueObject.isArray()) {
// const o = valueObject.getReciprocal();
// if (o.isError()) {
// return o;
// }
- return valueObject.compare(this, reverseCompareOperator(operator));
+ return valueObject.compare(this, reverseCompareOperator(operator), isCaseSensitive);
}
- return this.compareBy(valueObject.getValue(), operator);
+ return this.compareBy(valueObject.getValue(), operator, isCaseSensitive);
}
- override compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject {
- const currentValue = this.getValue();
+ override compareBy(value: string | number | boolean, operator: compareToken, isCaseSensitive: boolean = false): BaseValueObject {
+ let currentValue = this.getValue();
let result = false;
+
if (typeof value === 'string') {
- if (isWildcard(value)) {
- return this._checkWildcard(value, operator);
+ // Case sensitivity needs to be considered, most functions are case-insensitive, like VLOOKUP/HLOOKUP/XLOOKUP/MATCH/COUNTIF/COUNTIFS/SUMIF/SUMIFS/SEARCH/FIND(in SUBSTITUTE)
+ // A few functions are case-sensitive, like EXACT/FIND/FINDB/REPLACE/REPLACEB/MIDB
+ if (!isCaseSensitive) {
+ currentValue = currentValue.toLocaleLowerCase();
+ value = value.toLocaleLowerCase();
}
- switch (operator) {
- case compareToken.EQUALS:
- result = currentValue === value;
- break;
- case compareToken.GREATER_THAN:
- result = currentValue > value;
- break;
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = currentValue >= value;
- break;
- case compareToken.LESS_THAN:
- result = currentValue < value;
- break;
- case compareToken.LESS_THAN_OR_EQUAL:
- result = currentValue <= value;
- break;
- case compareToken.NOT_EQUAL:
- result = currentValue !== value;
- break;
+ if (isWildcard(value)) {
+ return this._checkWildcard(value, operator);
}
+ result = this._compareString(currentValue, value, operator);
} else if (typeof value === 'number') {
- switch (operator) {
- case compareToken.NOT_EQUAL:
- case compareToken.GREATER_THAN:
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = true;
- break;
-
- case compareToken.EQUALS:
- case compareToken.LESS_THAN:
- case compareToken.LESS_THAN_OR_EQUAL:
- result = false;
- break;
- }
+ result = this._compareNumber(operator);
} else if (typeof value === 'boolean') {
- switch (operator) {
- case compareToken.EQUALS:
- case compareToken.GREATER_THAN:
- case compareToken.GREATER_THAN_OR_EQUAL:
- result = false;
- break;
- case compareToken.LESS_THAN:
- case compareToken.LESS_THAN_OR_EQUAL:
- case compareToken.NOT_EQUAL:
- result = true;
- break;
- }
+ result = this._compareBoolean(operator);
}
+
return BooleanValueObject.create(result);
}
+ private _compareString(currentValue: string, value: string, operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.EQUALS:
+ return currentValue === value;
+ case compareToken.GREATER_THAN:
+ return currentValue > value;
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return currentValue >= value;
+ case compareToken.LESS_THAN:
+ return currentValue < value;
+ case compareToken.LESS_THAN_OR_EQUAL:
+ return currentValue <= value;
+ case compareToken.NOT_EQUAL:
+ return currentValue !== value;
+ }
+ }
+
+ private _compareNumber(operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.NOT_EQUAL:
+ case compareToken.GREATER_THAN:
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return true;
+ case compareToken.EQUALS:
+ case compareToken.LESS_THAN:
+ case compareToken.LESS_THAN_OR_EQUAL:
+ return false;
+ }
+ }
+
+ private _compareBoolean(operator: compareToken): boolean {
+ switch (operator) {
+ case compareToken.EQUALS:
+ case compareToken.GREATER_THAN:
+ case compareToken.GREATER_THAN_OR_EQUAL:
+ return false;
+ case compareToken.LESS_THAN:
+ case compareToken.LESS_THAN_OR_EQUAL:
+ case compareToken.NOT_EQUAL:
+ return true;
+ }
+ }
+
override convertToNumberObjectValue() {
return createNumberValueObjectByRawValue(this.getValue());
}
diff --git a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
index d8b8e1c36b..79f8d9ceeb 100644
--- a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
@@ -46,6 +46,11 @@ const arrayValueObject2 = ArrayValueObject.create(/*ts*/ `{
3, "Third"
}`);
+const arrayValueObject3 = ArrayValueObject.create(/*ts*/ `{
+ "First",1;
+ "Second",2;
+}`);
+
const matchArrayValueObject = ArrayValueObject.create(/*ts*/ `{
1, 3;
4, 6;
@@ -229,6 +234,16 @@ describe('Test vlookup', () => {
) as BaseValueObject;
expect(getObjectValue(resultObject)).toStrictEqual([['First', 'First', 'First', 'First'], ['Fourth', 'Fourth', 'Fourth', 'Fourth'], ['Eighth', 'Eighth', 'Eighth', 'Eighth']]);
});
+
+ it('LookupValue is string, case sensitive', async () => {
+ const resultObject = textFunction.calculate(
+ StringValueObject.create('second'),
+ arrayValueObject3.clone(),
+ NumberValueObject.create(2),
+ NumberValueObject.create(0)
+ ) as BaseValueObject;
+ expect(getObjectValue(resultObject)).toStrictEqual([[2]]);
+ });
});
describe('Approximate match', () => {
diff --git a/packages/engine-formula/src/functions/lookup/vlookup/index.ts b/packages/engine-formula/src/functions/lookup/vlookup/index.ts
index 73ed48fd2a..12732ce055 100644
--- a/packages/engine-formula/src/functions/lookup/vlookup/index.ts
+++ b/packages/engine-formula/src/functions/lookup/vlookup/index.ts
@@ -61,44 +61,62 @@ export class Vlookup extends BaseFunction {
// Otherwise colIndexNum takes the first value
if (isSingleValueObject(lookupValue) && isSingleValueObject(rangeLookup) && colIndexNum.isArray()) {
- lookupValue = lookupValue.isArray() ? (lookupValue as ArrayValueObject).getFirstCell() : lookupValue;
+ return this._handleArrayColIndexNum(lookupValue, tableArray, colIndexNum, rangeLookup);
+ }
- const rangeLookupValue = this.getZeroOrOneByOneDefault(rangeLookup);
+ return this._handleNonArrayColIndexNum(lookupValue, tableArray, colIndexNum, rangeLookup);
+ }
- if (rangeLookupValue == null) {
- return ErrorValueObject.create(ErrorType.VALUE);
- }
+ private _handleArrayColIndexNum(
+ lookupValue: BaseValueObject,
+ tableArray: BaseValueObject,
+ colIndexNum: BaseValueObject,
+ rangeLookup: BaseValueObject
+ ) {
+ lookupValue = lookupValue.isArray() ? (lookupValue as ArrayValueObject).getFirstCell() : lookupValue;
- let errorValue: BaseValueObject | undefined;
- const result: BaseValueObject[][] = [];
+ const rangeLookupValue = this.getZeroOrOneByOneDefault(rangeLookup);
- (colIndexNum as ArrayValueObject).iterator((colIndexNumValueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => {
- if (colIndexNumValueObject === null || colIndexNumValueObject === undefined) {
- errorValue = ErrorValueObject.create(ErrorType.VALUE);
- return false;
- }
+ if (rangeLookupValue == null) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
- const searchObject = this._handleTableArray(lookupValue, tableArray, colIndexNumValueObject, rangeLookupValue);
+ let errorValue: BaseValueObject | undefined;
+ const result: BaseValueObject[][] = [];
- if (searchObject.isError()) {
- errorValue = searchObject;
- return false;
- }
+ (colIndexNum as ArrayValueObject).iterator((colIndexNumValueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => {
+ if (colIndexNumValueObject === null || colIndexNumValueObject === undefined) {
+ errorValue = ErrorValueObject.create(ErrorType.VALUE);
+ return false;
+ }
- if (result[rowIndex] === undefined) {
- result[rowIndex] = [];
- }
+ const searchObject = this._handleTableArray(lookupValue, tableArray, colIndexNumValueObject, rangeLookupValue);
- result[rowIndex][columnIndex] = searchObject;
- });
+ if (searchObject.isError()) {
+ errorValue = searchObject;
+ return false;
+ }
- if (errorValue) {
- return errorValue;
+ if (result[rowIndex] === undefined) {
+ result[rowIndex] = [];
}
- return createNewArray(result, result.length, result[0].length, this.unitId || '', this.subUnitId || '');
+ result[rowIndex][columnIndex] = searchObject;
+ });
+
+ if (errorValue) {
+ return errorValue;
}
+ return createNewArray(result, result.length, result[0].length, this.unitId || '', this.subUnitId || '');
+ }
+
+ private _handleNonArrayColIndexNum(
+ lookupValue: BaseValueObject,
+ tableArray: BaseValueObject,
+ colIndexNum: BaseValueObject,
+ rangeLookup: BaseValueObject
+ ) {
// max row length
const maxRowLength = Math.max(
lookupValue.isArray() ? (lookupValue as ArrayValueObject).getRowCount() : 1,