Fixed calculation issues in FILTER and LAMBDA functions (#2186)

swmal · web-flow · commit c107d1a028c0 · 2025-11-27T12:57:23.000+01:00
diff --git a/src/EPPlus/FormulaParsing/DependencyChain/LambdaInvoker.cs b/src/EPPlus/FormulaParsing/DependencyChain/LambdaInvoker.cs
@@ -60,6 +60,7 @@ internal static CompileResult InvokeLambdaFunction(RpnOptimizedDependencyChain d
                     }
                 }
             }
+            f.OnLambdaInvoked();
             return result;
         }
     }
diff --git a/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs b/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs
@@ -1179,7 +1179,6 @@ private static FormulaRangeAddress[] ExecuteNextToken(RpnOptimizedDependencyChai
                             CompileResult lambdaResult = LambdaInvoker.InvokeLambdaFunction(depChain, f);
                             if (lambdaResult != null)
                                 PushResult(depChain._parsingContext, f, lambdaResult);
-                            f.OnLambdaInvoked();
                         }
                         else if(f._funcStack.Count > 0)
                         {
@@ -1257,6 +1256,11 @@ private static FormulaRangeAddress[] ExecuteNextToken(RpnOptimizedDependencyChai
                             }
 
                             var r = ExecFunc(depChain, f, funcExp);
+                            if(funcExp.ExecutesLambda)
+                            {
+                                // these functions will always invoke at least one LAMBDA
+                                f.OnLambdaInvoked();
+                            }
                             funcExp.OnDispose();
                             if (r.ResultType == CompileResultType.DynamicArray_AlwaysSetCellAsDynamic)
                             {
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/ByCol.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/ByCol.cs
@@ -28,6 +28,8 @@ internal class ByCol : ExcelFunction
 
         public override string NamespacePrefix => "_xlfn.";
 
+        public override bool ExecutesLambda => true;
+
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             var range = ArgToRangeInfo(arguments, 0);
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/ByRow.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/ByRow.cs
@@ -28,6 +28,8 @@ internal class ByRow : ExcelFunction
 
         public override string NamespacePrefix => "_xlfn.";
 
+        public override bool ExecutesLambda => true;
+
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             var range = ArgToRangeInfo(arguments, 0);
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/IfError.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/IfError.cs
@@ -33,8 +33,7 @@ public override void ConfigureArrayBehaviour(ArrayBehaviourConfig config)
             config.SetArrayParameterIndexes(0, 1);
         }
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
-        {
-            
+        { 
             var arg1 = arguments[0];
             var arg2 = arguments[1];
             if (arg1.ValueIsExcelError)
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Map.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Map.cs
@@ -62,6 +62,8 @@ public object GetByIndex(int index)
 
         public override string NamespacePrefix => "_xlfn.";
 
+        public override bool ExecutesLambda => true;
+
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             var lastArg = arguments.LastOrDefault();
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Reduce.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Reduce.cs
@@ -31,6 +31,8 @@ internal class Reduce : ExcelFunction
 
         public override string NamespacePrefix => "_xlfn.";
 
+        public override bool ExecutesLambda => true;
+
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             object initialValue = null;
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Scan.cs b/src/EPPlus/FormulaParsing/Excel/Functions/Logical/Scan.cs
@@ -28,6 +28,8 @@ internal class Scan : ExcelFunction
 
         public override string NamespacePrefix => "_xlfn.";
 
+        public override bool ExecutesLambda => true;
+
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             if (arguments[0].IsExcelRange)
diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/Filter.cs b/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/Filter.cs
@@ -51,7 +51,7 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 return CompileResult.GetErrorResult(eErrorType.Value);
             }
 
-            if(s1.NumberOfRows==s2.NumberOfRows)
+            if(s1.NumberOfRows==s2.NumberOfRows & s1.NumberOfRows > 1)
             {
                 return FilterOnRow(arg1, arg2, arg3);
             }
@@ -79,7 +79,7 @@ private static CompileResult FilterOnRow(IRangeInfo arg1, IRangeInfo arg2, Funct
             var s1 = arg1.Size;
             var s2 = arg2.Size;
 
-            if (s2.NumberOfCols != 1)
+            if (s2.NumberOfCols != 1 && s1.NumberOfCols != s2.NumberOfCols)
             {
                 return CompileResult.GetDynamicArrayResultError(eErrorType.Value);
             }
@@ -127,7 +127,7 @@ private static CompileResult FilterOnColumn(IRangeInfo arg1, IRangeInfo arg2, Fu
             var s1 = arg1.Size;
             var s2 = arg2.Size;
 
-            if (s2.NumberOfRows != 1)
+            if (s2.NumberOfRows != 1 && s1.NumberOfRows != s2.NumberOfRows)
             {
                 return CompileResult.GetDynamicArrayResultError(eErrorType.Value);
             }
@@ -149,13 +149,14 @@ private static CompileResult FilterOnColumn(IRangeInfo arg1, IRangeInfo arg2, Fu
                 }
                 if (boolValue != 0)
                 {
-                    var row = new List<object>();
-
-                    for (int r = 0; r < s1.NumberOfCols; r++)
+                    for (int r = 0; r < s1.NumberOfRows; r++)
                     {
-                        row.Add(arg1.GetOffset(r, c));
+                        if (filteredData.Count <= r)
+                        {
+                            filteredData.Add(new List<object>());
+                        }
+                        filteredData[r].Add(arg1.GetOffset(r, c));
                     }
-                    filteredData.Add(row);
                 }
             }
             if (filteredData.Count == 0)
diff --git a/src/EPPlusTest/FormulaParsing/Excel/Functions/Logical/MapTests.cs b/src/EPPlusTest/FormulaParsing/Excel/Functions/Logical/MapTests.cs
@@ -200,5 +200,23 @@ public void Map_Xleta_Attribute_IsNumber()
             Assert.AreEqual(false, sheet.Cells["B2"].Value);  // "hello" → FALSE
             Assert.AreEqual(false, sheet.Cells["B3"].Value);  // "" → FALSE
         }
+
+        [TestMethod]
+        public void Map_ShouldWorkInsideOtherFunction()
+        {
+            using var package = new ExcelPackage();
+            var sheet = package.Workbook.Worksheets.Add("Sheet1");
+
+            sheet.Cells["A1"].Value = 1;
+            sheet.Cells["A2"].Formula = "1/0";
+            sheet.Cells["A3"].Value = 3;
+
+            sheet.Cells["B1"].Formula = "IFERROR(MAP(A1:A3, _xleta.SUM), \"Error!\")";
+            sheet.Calculate();
+
+            Assert.AreEqual(1d, sheet.Cells["B1"].Value);
+            Assert.AreEqual("Error!", sheet.Cells["B2"].Value);
+            Assert.AreEqual(3d, sheet.Cells["B3"].Value);
+        }
     }
 }
diff --git a/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/FilterTests.cs b/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/FilterTests.cs
@@ -0,0 +1,71 @@
+﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OfficeOpenXml;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EPPlusTest.FormulaParsing.Excel.Functions.RefAndLookup
+{
+    [TestClass]
+    public class FilterTests
+    {
+        ExcelPackage _package;
+        ExcelWorksheet _ws;
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            _package = new ExcelPackage();
+            _ws = _package.Workbook.Worksheets.Add("Sheet1");
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _ws = null;
+            _package.Dispose();
+        }
+
+        [TestMethod]
+        public void ShouldFilterOnRow()
+        {
+            _ws.Cells["A1"].Value = 1;
+            _ws.Cells["B1"].Value = 2;
+            _ws.Cells["C1"].Value = 3;
+            _ws.Cells["A2"].Value = 4;
+            _ws.Cells["B2"].Value = 5;
+            _ws.Cells["C2"].Value = 6;
+            _ws.Cells["A3"].Value = 1;
+            _ws.Cells["B3"].Value = 5;
+            _ws.Cells["C3"].Value = 7;
+
+            _ws.Cells["D1"].Formula = "FILTER(A1:C3,A1:A3=1)";
+            _ws.Calculate();
+            Assert.AreEqual(1, _ws.Cells["D1"].Value);
+            Assert.AreEqual(2, _ws.Cells["E1"].Value);
+            Assert.AreEqual(1, _ws.Cells["D2"].Value);
+            Assert.AreEqual(5, _ws.Cells["E2"].Value);
+        }
+
+        [TestMethod]
+        public void ShouldFilterOnColumn()
+        {
+            _ws.Cells["A1"].Value = 1;
+            _ws.Cells["B1"].Value = 2;
+            _ws.Cells["C1"].Value = 3;
+            _ws.Cells["A2"].Value = 4;
+            _ws.Cells["B2"].Value = 5;
+            _ws.Cells["C2"].Value = 6;
+            _ws.Cells["A3"].Value = 1;
+            _ws.Cells["B3"].Value = 5;
+            _ws.Cells["C3"].Value = 7;
+
+            _ws.Cells["D1"].Formula = "FILTER(A1:C3,A1:C1=1)";
+            _ws.Calculate();
+            Assert.AreEqual(1, _ws.Cells["D1"].Value);
+            Assert.AreEqual(4, _ws.Cells["D2"].Value);
+            Assert.AreEqual(1, _ws.Cells["D3"].Value);
+        }
+    }
+}
diff --git a/src/EPPlusTest/Issues/FormulaCalculationIssues.cs b/src/EPPlusTest/Issues/FormulaCalculationIssues.cs

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,7 @@ internal static CompileResult InvokeLambdaFunction(RpnOptimizedDependencyChain d`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`}`
	`63`	`+ f.OnLambdaInvoked();`
`63`	`64`	`return result;`
`64`	`65`	`}`
`65`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1179,7 +1179,6 @@ private static FormulaRangeAddress[] ExecuteNextToken(RpnOptimizedDependencyChai`
`1179`	`1179`	`CompileResult lambdaResult = LambdaInvoker.InvokeLambdaFunction(depChain, f);`
`1180`	`1180`	`if (lambdaResult != null)`
`1181`	`1181`	`PushResult(depChain._parsingContext, f, lambdaResult);`
`1182`		`- f.OnLambdaInvoked();`
`1183`	`1182`	`}`
`1184`	`1183`	`else if(f._funcStack.Count > 0)`
`1185`	`1184`	`{`
`@@ -1257,6 +1256,11 @@ private static FormulaRangeAddress[] ExecuteNextToken(RpnOptimizedDependencyChai`
`1257`	`1256`	`}`
`1258`	`1257`
`1259`	`1258`	`var r = ExecFunc(depChain, f, funcExp);`
	`1259`	`+ if(funcExp.ExecutesLambda)`
	`1260`	`+ {`
	`1261`	`+ // these functions will always invoke at least one LAMBDA`
	`1262`	`+ f.OnLambdaInvoked();`
	`1263`	`+ }`
`1260`	`1264`	`funcExp.OnDispose();`
`1261`	`1265`	`if (r.ResultType == CompileResultType.DynamicArray_AlwaysSetCellAsDynamic)`
`1262`	`1266`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ internal class ByCol : ExcelFunction`
`28`	`28`
`29`	`29`	`public override string NamespacePrefix => "_xlfn.";`
`30`	`30`
	`31`	`+ public override bool ExecutesLambda => true;`
	`32`	`+`
`31`	`33`	`public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)`
`32`	`34`	`{`
`33`	`35`	`var range = ArgToRangeInfo(arguments, 0);`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ internal class ByRow : ExcelFunction`
`28`	`28`
`29`	`29`	`public override string NamespacePrefix => "_xlfn.";`
`30`	`30`
	`31`	`+ public override bool ExecutesLambda => true;`
	`32`	`+`
`31`	`33`	`public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)`
`32`	`34`	`{`
`33`	`35`	`var range = ArgToRangeInfo(arguments, 0);`
Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,8 @@ public object GetByIndex(int index)`
`62`	`62`
`63`	`63`	`public override string NamespacePrefix => "_xlfn.";`
`64`	`64`
	`65`	`+ public override bool ExecutesLambda => true;`
	`66`	`+`
`65`	`67`	`public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)`
`66`	`68`	`{`
`67`	`69`	`var lastArg = arguments.LastOrDefault();`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,8 @@ internal class Reduce : ExcelFunction`
`31`	`31`
`32`	`32`	`public override string NamespacePrefix => "_xlfn.";`
`33`	`33`
	`34`	`+ public override bool ExecutesLambda => true;`
	`35`	`+`
`34`	`36`	`public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)`
`35`	`37`	`{`
`36`	`38`	`object initialValue = null;`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ internal class Scan : ExcelFunction`
`28`	`28`
`29`	`29`	`public override string NamespacePrefix => "_xlfn.";`
`30`	`30`
	`31`	`+ public override bool ExecutesLambda => true;`
	`32`	`+`
`31`	`33`	`public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)`
`32`	`34`	`{`
`33`	`35`	`if (arguments[0].IsExcelRange)`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing`
`51`	`51`	`return CompileResult.GetErrorResult(eErrorType.Value);`
`52`	`52`	`}`
`53`	`53`
`54`		`- if(s1.NumberOfRows==s2.NumberOfRows)`
	`54`	`+ if(s1.NumberOfRows==s2.NumberOfRows & s1.NumberOfRows > 1)`
`55`	`55`	`{`
`56`	`56`	`return FilterOnRow(arg1, arg2, arg3);`
`57`	`57`	`}`
`@@ -79,7 +79,7 @@ private static CompileResult FilterOnRow(IRangeInfo arg1, IRangeInfo arg2, Funct`
`79`	`79`	`var s1 = arg1.Size;`
`80`	`80`	`var s2 = arg2.Size;`
`81`	`81`
`82`		`- if (s2.NumberOfCols != 1)`
	`82`	`+ if (s2.NumberOfCols != 1 && s1.NumberOfCols != s2.NumberOfCols)`
`83`	`83`	`{`
`84`	`84`	`return CompileResult.GetDynamicArrayResultError(eErrorType.Value);`
`85`	`85`	`}`
`@@ -127,7 +127,7 @@ private static CompileResult FilterOnColumn(IRangeInfo arg1, IRangeInfo arg2, Fu`
`127`	`127`	`var s1 = arg1.Size;`
`128`	`128`	`var s2 = arg2.Size;`
`129`	`129`
`130`		`- if (s2.NumberOfRows != 1)`
	`130`	`+ if (s2.NumberOfRows != 1 && s1.NumberOfRows != s2.NumberOfRows)`
`131`	`131`	`{`
`132`	`132`	`return CompileResult.GetDynamicArrayResultError(eErrorType.Value);`
`133`	`133`	`}`
`@@ -149,13 +149,14 @@ private static CompileResult FilterOnColumn(IRangeInfo arg1, IRangeInfo arg2, Fu`
`149`	`149`	`}`
`150`	`150`	`if (boolValue != 0)`
`151`	`151`	`{`
`152`		`- var row = new List<object>();`
`153`		`-`
`154`		`- for (int r = 0; r < s1.NumberOfCols; r++)`
	`152`	`+ for (int r = 0; r < s1.NumberOfRows; r++)`
`155`	`153`	`{`
`156`		`- row.Add(arg1.GetOffset(r, c));`
	`154`	`+ if (filteredData.Count <= r)`
	`155`	`+ {`
	`156`	`+ filteredData.Add(new List<object>());`
	`157`	`+ }`
	`158`	`+ filteredData[r].Add(arg1.GetOffset(r, c));`
`157`	`159`	`}`
`158`		`- filteredData.Add(row);`
`159`	`160`	`}`
`160`	`161`	`}`
`161`	`162`	`if (filteredData.Count == 0)`