Bug #61841 - Unnecessary long computation when evaluating VLOOKUP on all column reference

antony-liu · antony-liu · commit b2f805f61660 · 2026-02-28T19:51:54.000+08:00
diff --git a/main/HSSF/UserModel/HSSFEvaluationSheet.cs b/main/HSSF/UserModel/HSSFEvaluationSheet.cs
@@ -29,10 +29,12 @@ public class HSSFEvaluationSheet : IEvaluationSheet
     {
 
         private readonly HSSFSheet _hs;
+        private int _lastDefinedRow = -1;
 
         public HSSFEvaluationSheet(HSSFSheet hs)
         {
             _hs = hs;
+            _lastDefinedRow = _hs.LastRowNum;
         }
 
         public HSSFSheet HSSFSheet
@@ -42,6 +44,19 @@ public HSSFSheet HSSFSheet
                 return _hs;
             }
         }
+
+        /* (non-Javadoc)
+         * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()
+         * @since POI 4.0.0
+         */
+        public int LastRowNum
+        {
+            get
+            {
+                return _lastDefinedRow;
+            }
+        }
+
         public IEvaluationCell GetCell(int rowIndex, int columnIndex)
         {
             HSSFRow row = (HSSFRow)_hs.GetRow(rowIndex);
@@ -59,7 +74,7 @@ public IEvaluationCell GetCell(int rowIndex, int columnIndex)
 
         public void ClearAllCachedResultValues()
         {
-            // nothing to do
+            _lastDefinedRow = _hs.LastRowNum;
         }
     }
 }
diff --git a/main/SS/Formula/CellEvaluationFrame.cs b/main/SS/Formula/CellEvaluationFrame.cs
@@ -71,13 +71,13 @@ private CellCacheEntry[] GetSensitiveInputCells()
             }
             return _sensitiveInputCells.ToArray();
         }
-        public void AddUsedBlankCell(int bookIndex, int sheetIndex, int rowIndex, int columnIndex)
+        public void AddUsedBlankCell(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex, int rowIndex, int columnIndex)
         {
             if (_usedBlankCellGroup == null)
             {
                 _usedBlankCellGroup = new FormulaUsedBlankCellSet();
             }
-            _usedBlankCellGroup.AddCell(bookIndex, sheetIndex, rowIndex, columnIndex);
+            _usedBlankCellGroup.AddCell(evalWorkbook, bookIndex, sheetIndex, rowIndex, columnIndex);
         }
 
         public void UpdateFormulaResult(ValueEval result)
diff --git a/main/SS/Formula/Eval/Forked/ForkedEvaluationSheet.cs b/main/SS/Formula/Eval/Forked/ForkedEvaluationSheet.cs
@@ -47,6 +47,18 @@ public ForkedEvaluationSheet(IEvaluationSheet masterSheet)
             _sharedCellsByRowCol = new Dictionary<RowColKey, ForkedEvaluationCell>();
         }
 
+        /* (non-Javadoc)
+         * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()
+         * @since POI 4.0.0
+         */
+        public int LastRowNum
+        {
+            get
+            {
+                return _masterSheet.LastRowNum;
+            }
+        }
+
         public IEvaluationCell GetCell(int rowIndex, int columnIndex)
         {
             RowColKey key = new RowColKey(rowIndex, columnIndex);
diff --git a/main/SS/Formula/EvaluationSheet.cs b/main/SS/Formula/EvaluationSheet.cs
@@ -39,5 +39,11 @@ public interface IEvaluationSheet
          * @see EvaluationWorkbook#clearAllCachedResultValues()
          */
         void ClearAllCachedResultValues();
+
+        /**
+         * @return last row index referenced on this sheet, for evaluation optimization
+         * @since POI 4.0.0
+         */
+        public int LastRowNum { get; }
     }
 }
diff --git a/main/SS/Formula/EvaluationTracker.cs b/main/SS/Formula/EvaluationTracker.cs
@@ -133,7 +133,7 @@ public void AcceptFormulaDependency(CellCacheEntry cce)
             }
         }
 
-        public void AcceptPlainValueDependency(int bookIndex, int sheetIndex,
+        public void AcceptPlainValueDependency(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex,
                 int rowIndex, int columnIndex, ValueEval value)
         {
             // Tell the currently evaluating cell frame that it Has a dependency on the specified
@@ -147,7 +147,7 @@ public void AcceptPlainValueDependency(int bookIndex, int sheetIndex,
                 CellEvaluationFrame consumingFrame = (CellEvaluationFrame)_evaluationFrames[prevFrameIndex];
                 if (value == BlankEval.instance)
                 {
-                    consumingFrame.AddUsedBlankCell(bookIndex, sheetIndex, rowIndex, columnIndex);
+                    consumingFrame.AddUsedBlankCell(evalWorkbook, bookIndex, sheetIndex, rowIndex, columnIndex);
                 }
                 else
                 {
diff --git a/main/SS/Formula/FormulaUsedBlankCellSet.cs b/main/SS/Formula/FormulaUsedBlankCellSet.cs
@@ -62,15 +62,19 @@ private  class BlankCellSheetGroup
             private int _firstColumnIndex;
             private int _lastColumnIndex;
             private BlankCellRectangleGroup _currentRectangleGroup;
+            private int _lastDefinedRow;
 
-            public BlankCellSheetGroup()
+            public BlankCellSheetGroup(int lastDefinedRow)
             {
                 _rectangleGroups = [];
                 _currentRowIndex = -1;
+                _lastDefinedRow = lastDefinedRow;
             }
 
             public void AddCell(int rowIndex, int columnIndex)
             {
+                if(rowIndex > _lastDefinedRow)
+                    return;
                 if (_currentRowIndex == -1)
                 {
                     _currentRowIndex = rowIndex;
@@ -107,6 +111,8 @@ public void AddCell(int rowIndex, int columnIndex)
 
             public bool ContainsCell(int rowIndex, int columnIndex)
             {
+                if(rowIndex > _lastDefinedRow)
+                    return true;
                 for (int i = _rectangleGroups.Count - 1; i >= 0; i--)
                 {
                     BlankCellRectangleGroup bcrg = (BlankCellRectangleGroup)_rectangleGroups[i];
@@ -203,20 +209,20 @@ public FormulaUsedBlankCellSet()
             _sheetGroupsByBookSheet = new Hashtable();
         }
 
-        public void AddCell(int bookIndex, int sheetIndex, int rowIndex, int columnIndex)
+        public void AddCell(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex, int rowIndex, int columnIndex)
         {
-            BlankCellSheetGroup sbcg = GetSheetGroup(bookIndex, sheetIndex);
+            BlankCellSheetGroup sbcg = GetSheetGroup(evalWorkbook, bookIndex, sheetIndex);
             sbcg.AddCell(rowIndex, columnIndex);
         }
 
-        private BlankCellSheetGroup GetSheetGroup(int bookIndex, int sheetIndex)
+        private BlankCellSheetGroup GetSheetGroup(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex)
         {
             BookSheetKey key = new BookSheetKey(bookIndex, sheetIndex);
 
             BlankCellSheetGroup result = (BlankCellSheetGroup)_sheetGroupsByBookSheet[key];
             if (result == null)
             {
-                result = new BlankCellSheetGroup();
+                result = new BlankCellSheetGroup(evalWorkbook.GetSheet(sheetIndex).LastRowNum);
                 _sheetGroupsByBookSheet[key]= result;
             }
             return result;
diff --git a/main/SS/Formula/WorkbookEvaluator.cs b/main/SS/Formula/WorkbookEvaluator.cs
@@ -407,7 +407,7 @@ private ValueEval EvaluateAny(IEvaluationCell srcCell, int sheetIndex,
                 result = GetValueFromNonFormulaCell(srcCell);
                 if (shouldCellDependencyBeRecorded)
                 {
-                    tracker.AcceptPlainValueDependency(_workbookIx, sheetIndex, rowIndex, columnIndex, result);
+                    tracker.AcceptPlainValueDependency(_workbook, _workbookIx, sheetIndex, rowIndex, columnIndex, result);
                 }
                 return result;
             }
diff --git a/ooxml/XSSF/Streaming/SXSSFEvaluationSheet.cs b/ooxml/XSSF/Streaming/SXSSFEvaluationSheet.cs
@@ -22,17 +22,31 @@ namespace NPOI.XSSF.Streaming
     public class SXSSFEvaluationSheet : IEvaluationSheet //XSSFEvaluationSheet
     {
         private readonly SXSSFSheet _xs;
+        private int _lastDefinedRow = -1;
 
         public SXSSFEvaluationSheet(SXSSFSheet sheet)
         {
             _xs = sheet;
+            _lastDefinedRow = _xs.LastRowNum;
         }
 
         public SXSSFSheet GetSXSSFSheet()
         {
             return _xs;
         }
 
+        /* (non-Javadoc)
+         * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()
+         * @since POI 4.0.0
+         */
+        public int LastRowNum
+        {
+            get
+            {
+                return _lastDefinedRow;
+            }
+        }
+
         public IEvaluationCell GetCell(int rowIndex, int columnIndex)
         {
             SXSSFRow row = (SXSSFRow)_xs.GetRow(rowIndex);                
@@ -58,7 +72,7 @@ public IEvaluationCell GetCell(int rowIndex, int columnIndex)
 
         public void ClearAllCachedResultValues()
         {
-            // nothing to do
+            _lastDefinedRow = _xs.LastRowNum;
         }
     }
 }
diff --git a/ooxml/XSSF/UserModel/XSSFEvaluationSheet.cs b/ooxml/XSSF/UserModel/XSSFEvaluationSheet.cs
@@ -33,26 +33,46 @@ public class XSSFEvaluationSheet : IEvaluationSheet
 
         private readonly XSSFSheet _xs;
         private Dictionary<CellKey, IEvaluationCell> _cellCache;
+        private int _lastDefinedRow = -1;
 
         public XSSFEvaluationSheet(ISheet sheet)
         {
             _xs = (XSSFSheet)sheet;
+            _lastDefinedRow = _xs.LastRowNum;
         }
 
         public XSSFEvaluationSheet()
         {
 
         }
 
+        /* (non-Javadoc)
+         * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()
+         * @since POI 4.0.0
+         */
+        public int LastRowNum
+        {
+            get
+            {
+                return _lastDefinedRow;
+            }
+        }
+
         public void ClearAllCachedResultValues()
         {
             _cellCache = null;
+            _lastDefinedRow = _xs.LastRowNum;
         }
 
         public XSSFSheet XSSFSheet => _xs;
         
         public IEvaluationCell GetCell(int rowIndex, int columnIndex)
         {
+            // shortcut evaluation if reference is outside the bounds of existing data
+            // see issue #61841 for impact on VLOOKUP in particular
+            if(rowIndex > _lastDefinedRow)
+                return null;
+
             // cache for performance: ~30% speedup due to caching
             if (_cellCache == null)
             {
diff --git a/testcases/ooxml/SS/Formula/Functions/TestVlookup.cs b/testcases/ooxml/SS/Formula/Functions/TestVlookup.cs
@@ -0,0 +1,51 @@
+﻿/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+==================================================================== */
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace TestCases.SS.Formula.Functions
+{
+    using NPOI.SS.UserModel;
+    using NPOI.XSSF;
+    using NUnit.Framework;
+    using NUnit.Framework.Legacy;
+
+    /// <summary>
+    /// Test the VLOOKUP function
+    /// </summary>
+    [TestFixture]
+    public class TestVlookup
+    {
+
+        [Test]
+        public void TestFullColumnAreaRef61841()
+        {
+            IWorkbook wb = XSSFTestDataSamples.OpenSampleWorkbook("VLookupFullColumn.xlsx");
+            IFormulaEvaluator feval = wb.GetCreationHelper().CreateFormulaEvaluator();
+            feval.EvaluateAll();
+            ClassicAssert.AreEqual("Value1", feval.Evaluate(wb.GetSheetAt(0).GetRow(3).GetCell(1)).StringValue, "Wrong lookup value");
+            ClassicAssert.AreEqual(CellType.Error, feval.Evaluate(wb.GetSheetAt(0).GetRow(4).GetCell(1)).CellType, "Lookup should return #N/A");
+        }
+
+    }
+}
+
diff --git a/testcases/test-data/spreadsheet/VLookupFullColumn.xlsx b/testcases/test-data/spreadsheet/VLookupFullColumn.xlsx

Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,12 @@ public class HSSFEvaluationSheet : IEvaluationSheet`
`29`	`29`	`{`
`30`	`30`
`31`	`31`	`private readonly HSSFSheet _hs;`
	`32`	`+ private int _lastDefinedRow = -1;`
`32`	`33`
`33`	`34`	`public HSSFEvaluationSheet(HSSFSheet hs)`
`34`	`35`	`{`
`35`	`36`	`_hs = hs;`
	`37`	`+ _lastDefinedRow = _hs.LastRowNum;`
`36`	`38`	`}`
`37`	`39`
`38`	`40`	`public HSSFSheet HSSFSheet`
`@@ -42,6 +44,19 @@ public HSSFSheet HSSFSheet`
`42`	`44`	`return _hs;`
`43`	`45`	`}`
`44`	`46`	`}`
	`47`	`+`
	`48`	`+ /* (non-Javadoc)`
	`49`	`+ * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()`
	`50`	`+ * @since POI 4.0.0`
	`51`	`+ */`
	`52`	`+ public int LastRowNum`
	`53`	`+ {`
	`54`	`+ get`
	`55`	`+ {`
	`56`	`+ return _lastDefinedRow;`
	`57`	`+ }`
	`58`	`+ }`
	`59`	`+`
`45`	`60`	`public IEvaluationCell GetCell(int rowIndex, int columnIndex)`
`46`	`61`	`{`
`47`	`62`	`HSSFRow row = (HSSFRow)_hs.GetRow(rowIndex);`
`@@ -59,7 +74,7 @@ public IEvaluationCell GetCell(int rowIndex, int columnIndex)`
`59`	`74`
`60`	`75`	`public void ClearAllCachedResultValues()`
`61`	`76`	`{`
`62`		`- // nothing to do`
	`77`	`+ _lastDefinedRow = _hs.LastRowNum;`
`63`	`78`	`}`
`64`	`79`	`}`
`65`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,13 +71,13 @@ private CellCacheEntry[] GetSensitiveInputCells()`
`71`	`71`	`}`
`72`	`72`	`return _sensitiveInputCells.ToArray();`
`73`	`73`	`}`
`74`		`- public void AddUsedBlankCell(int bookIndex, int sheetIndex, int rowIndex, int columnIndex)`
	`74`	`+ public void AddUsedBlankCell(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex, int rowIndex, int columnIndex)`
`75`	`75`	`{`
`76`	`76`	`if (_usedBlankCellGroup == null)`
`77`	`77`	`{`
`78`	`78`	`_usedBlankCellGroup = new FormulaUsedBlankCellSet();`
`79`	`79`	`}`
`80`		`- _usedBlankCellGroup.AddCell(bookIndex, sheetIndex, rowIndex, columnIndex);`
	`80`	`+ _usedBlankCellGroup.AddCell(evalWorkbook, bookIndex, sheetIndex, rowIndex, columnIndex);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public void UpdateFormulaResult(ValueEval result)`
Original file line number	Diff line number	Diff line change
`@@ -39,5 +39,11 @@ public interface IEvaluationSheet`
`39`	`39`	`* @see EvaluationWorkbook#clearAllCachedResultValues()`
`40`	`40`	`*/`
`41`	`41`	`void ClearAllCachedResultValues();`
	`42`	`+`
	`43`	`+ /**`
	`44`	`+ * @return last row index referenced on this sheet, for evaluation optimization`
	`45`	`+ * @since POI 4.0.0`
	`46`	`+ */`
	`47`	`+ public int LastRowNum { get; }`
`42`	`48`	`}`
`43`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ public void AcceptFormulaDependency(CellCacheEntry cce)`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`		`- public void AcceptPlainValueDependency(int bookIndex, int sheetIndex,`
	`136`	`+ public void AcceptPlainValueDependency(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex,`
`137`	`137`	`int rowIndex, int columnIndex, ValueEval value)`
`138`	`138`	`{`
`139`	`139`	`// Tell the currently evaluating cell frame that it Has a dependency on the specified`
`@@ -147,7 +147,7 @@ public void AcceptPlainValueDependency(int bookIndex, int sheetIndex,`
`147`	`147`	`CellEvaluationFrame consumingFrame = (CellEvaluationFrame)_evaluationFrames[prevFrameIndex];`
`148`	`148`	`if (value == BlankEval.instance)`
`149`	`149`	`{`
`150`		`- consumingFrame.AddUsedBlankCell(bookIndex, sheetIndex, rowIndex, columnIndex);`
	`150`	`+ consumingFrame.AddUsedBlankCell(evalWorkbook, bookIndex, sheetIndex, rowIndex, columnIndex);`
`151`	`151`	`}`
`152`	`152`	`else`
`153`	`153`	`{`
Original file line number	Diff line number	Diff line change
`@@ -62,15 +62,19 @@ private class BlankCellSheetGroup`
`62`	`62`	`private int _firstColumnIndex;`
`63`	`63`	`private int _lastColumnIndex;`
`64`	`64`	`private BlankCellRectangleGroup _currentRectangleGroup;`
	`65`	`+ private int _lastDefinedRow;`
`65`	`66`
`66`		`- public BlankCellSheetGroup()`
	`67`	`+ public BlankCellSheetGroup(int lastDefinedRow)`
`67`	`68`	`{`
`68`	`69`	`_rectangleGroups = [];`
`69`	`70`	`_currentRowIndex = -1;`
	`71`	`+ _lastDefinedRow = lastDefinedRow;`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`public void AddCell(int rowIndex, int columnIndex)`
`73`	`75`	`{`
	`76`	`+ if(rowIndex > _lastDefinedRow)`
	`77`	`+ return;`
`74`	`78`	`if (_currentRowIndex == -1)`
`75`	`79`	`{`
`76`	`80`	`_currentRowIndex = rowIndex;`
`@@ -107,6 +111,8 @@ public void AddCell(int rowIndex, int columnIndex)`
`107`	`111`
`108`	`112`	`public bool ContainsCell(int rowIndex, int columnIndex)`
`109`	`113`	`{`
	`114`	`+ if(rowIndex > _lastDefinedRow)`
	`115`	`+ return true;`
`110`	`116`	`for (int i = _rectangleGroups.Count - 1; i >= 0; i--)`
`111`	`117`	`{`
`112`	`118`	`BlankCellRectangleGroup bcrg = (BlankCellRectangleGroup)_rectangleGroups[i];`
`@@ -203,20 +209,20 @@ public FormulaUsedBlankCellSet()`
`203`	`209`	`_sheetGroupsByBookSheet = new Hashtable();`
`204`	`210`	`}`
`205`	`211`
`206`		`- public void AddCell(int bookIndex, int sheetIndex, int rowIndex, int columnIndex)`
	`212`	`+ public void AddCell(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex, int rowIndex, int columnIndex)`
`207`	`213`	`{`
`208`		`- BlankCellSheetGroup sbcg = GetSheetGroup(bookIndex, sheetIndex);`
	`214`	`+ BlankCellSheetGroup sbcg = GetSheetGroup(evalWorkbook, bookIndex, sheetIndex);`
`209`	`215`	`sbcg.AddCell(rowIndex, columnIndex);`
`210`	`216`	`}`
`211`	`217`
`212`		`- private BlankCellSheetGroup GetSheetGroup(int bookIndex, int sheetIndex)`
	`218`	`+ private BlankCellSheetGroup GetSheetGroup(IEvaluationWorkbook evalWorkbook, int bookIndex, int sheetIndex)`
`213`	`219`	`{`
`214`	`220`	`BookSheetKey key = new BookSheetKey(bookIndex, sheetIndex);`
`215`	`221`
`216`	`222`	`BlankCellSheetGroup result = (BlankCellSheetGroup)_sheetGroupsByBookSheet[key];`
`217`	`223`	`if (result == null)`
`218`	`224`	`{`
`219`		`- result = new BlankCellSheetGroup();`
	`225`	`+ result = new BlankCellSheetGroup(evalWorkbook.GetSheet(sheetIndex).LastRowNum);`
`220`	`226`	`_sheetGroupsByBookSheet[key]= result;`
`221`	`227`	`}`
`222`	`228`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -407,7 +407,7 @@ private ValueEval EvaluateAny(IEvaluationCell srcCell, int sheetIndex,`
`407`	`407`	`result = GetValueFromNonFormulaCell(srcCell);`
`408`	`408`	`if (shouldCellDependencyBeRecorded)`
`409`	`409`	`{`
`410`		`- tracker.AcceptPlainValueDependency(_workbookIx, sheetIndex, rowIndex, columnIndex, result);`
	`410`	`+ tracker.AcceptPlainValueDependency(_workbook, _workbookIx, sheetIndex, rowIndex, columnIndex, result);`
`411`	`411`	`}`
`412`	`412`	`return result;`
`413`	`413`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,17 +22,31 @@ namespace NPOI.XSSF.Streaming`
`22`	`22`	`public class SXSSFEvaluationSheet : IEvaluationSheet //XSSFEvaluationSheet`
`23`	`23`	`{`
`24`	`24`	`private readonly SXSSFSheet _xs;`
	`25`	`+ private int _lastDefinedRow = -1;`
`25`	`26`
`26`	`27`	`public SXSSFEvaluationSheet(SXSSFSheet sheet)`
`27`	`28`	`{`
`28`	`29`	`_xs = sheet;`
	`30`	`+ _lastDefinedRow = _xs.LastRowNum;`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`public SXSSFSheet GetSXSSFSheet()`
`32`	`34`	`{`
`33`	`35`	`return _xs;`
`34`	`36`	`}`
`35`	`37`
	`38`	`+ /* (non-Javadoc)`
	`39`	`+ * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()`
	`40`	`+ * @since POI 4.0.0`
	`41`	`+ */`
	`42`	`+ public int LastRowNum`
	`43`	`+ {`
	`44`	`+ get`
	`45`	`+ {`
	`46`	`+ return _lastDefinedRow;`
	`47`	`+ }`
	`48`	`+ }`
	`49`	`+`
`36`	`50`	`public IEvaluationCell GetCell(int rowIndex, int columnIndex)`
`37`	`51`	`{`
`38`	`52`	`SXSSFRow row = (SXSSFRow)_xs.GetRow(rowIndex);`
`@@ -58,7 +72,7 @@ public IEvaluationCell GetCell(int rowIndex, int columnIndex)`
`58`	`72`
`59`	`73`	`public void ClearAllCachedResultValues()`
`60`	`74`	`{`
`61`		`- // nothing to do`
	`75`	`+ _lastDefinedRow = _xs.LastRowNum;`
`62`	`76`	`}`
`63`	`77`	`}`
`64`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,26 +33,46 @@ public class XSSFEvaluationSheet : IEvaluationSheet`
`33`	`33`
`34`	`34`	`private readonly XSSFSheet _xs;`
`35`	`35`	`private Dictionary<CellKey, IEvaluationCell> _cellCache;`
	`36`	`+ private int _lastDefinedRow = -1;`
`36`	`37`
`37`	`38`	`public XSSFEvaluationSheet(ISheet sheet)`
`38`	`39`	`{`
`39`	`40`	`_xs = (XSSFSheet)sheet;`
	`41`	`+ _lastDefinedRow = _xs.LastRowNum;`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`public XSSFEvaluationSheet()`
`43`	`45`	`{`
`44`	`46`
`45`	`47`	`}`
`46`	`48`
	`49`	`+ /* (non-Javadoc)`
	`50`	`+ * @see org.apache.poi.ss.formula.EvaluationSheet#getlastRowNum()`
	`51`	`+ * @since POI 4.0.0`
	`52`	`+ */`
	`53`	`+ public int LastRowNum`
	`54`	`+ {`
	`55`	`+ get`
	`56`	`+ {`
	`57`	`+ return _lastDefinedRow;`
	`58`	`+ }`
	`59`	`+ }`
	`60`	`+`
`47`	`61`	`public void ClearAllCachedResultValues()`
`48`	`62`	`{`
`49`	`63`	`_cellCache = null;`
	`64`	`+ _lastDefinedRow = _xs.LastRowNum;`
`50`	`65`	`}`
`51`	`66`
`52`	`67`	`public XSSFSheet XSSFSheet => _xs;`
`53`	`68`
`54`	`69`	`public IEvaluationCell GetCell(int rowIndex, int columnIndex)`
`55`	`70`	`{`
	`71`	`+ // shortcut evaluation if reference is outside the bounds of existing data`
	`72`	`+ // see issue #61841 for impact on VLOOKUP in particular`
	`73`	`+ if(rowIndex > _lastDefinedRow)`
	`74`	`+ return null;`
	`75`	`+`
`56`	`76`	`// cache for performance: ~30% speedup due to caching`
`57`	`77`	`if (_cellCache == null)`
`58`	`78`	`{`