Bound synthesized rows in v1 OpenXml queries

src/MiniExcel/OpenXml/ExcelOpenXmlSheetReader.cs

@@ -84,32 +84,32 @@ public IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, st
 
     public IEnumerable<IDictionary<string, object>> QueryRange(bool useHeaderRow, string sheetName, int startRowIndex, int startColumnIndex, int? endRowIndex, int? endColumnIndex)
     {
-        if (startRowIndex <= 0)
+        if (startRowIndex is <= 0 or > ReferenceHelper.MaxRowNumber)
         {
-            throw new ArgumentOutOfRangeException(nameof(startRowIndex), "Start row index is 1-based and must be greater than 0.");
+            throw new ArgumentOutOfRangeException(nameof(startRowIndex), $"Start row index must be between 1 and {ReferenceHelper.MaxRowNumber}.");
         }
-        if (startColumnIndex <= 0)
+        if (startColumnIndex is <= 0 or > ReferenceHelper.MaxColumnNumber)
         {
-            throw new ArgumentOutOfRangeException(nameof(startColumnIndex), "Start column index is 1-based and must be greater than 0.");
+            throw new ArgumentOutOfRangeException(nameof(startColumnIndex), $"Start column index must be between 1 and {ReferenceHelper.MaxColumnNumber}.");
         }
         // convert to 0-based
         startColumnIndex--;
         startRowIndex--;
 
         if (endRowIndex.HasValue)
         {
-            if (endRowIndex.Value <= 0)
+            if (endRowIndex.Value is <= 0 or > ReferenceHelper.MaxRowNumber)
             {
-                throw new ArgumentOutOfRangeException(nameof(endRowIndex), "End row index is 1-based and must be greater than 0.");
+                throw new ArgumentOutOfRangeException(nameof(endRowIndex), $"End row index must be between 1 and {ReferenceHelper.MaxRowNumber}.");
             }
             // convert to 0-based
             endRowIndex--;
         }
         if (endColumnIndex.HasValue)
         {
-            if (endColumnIndex.Value <= 0)
+            if (endColumnIndex.Value is <= 0 or > ReferenceHelper.MaxColumnNumber)
             {
-                throw new ArgumentOutOfRangeException(nameof(endColumnIndex), "End column index is 1-based and must be greater than 0.");
+                throw new ArgumentOutOfRangeException(nameof(endColumnIndex), $"End column index must be between 1 and {ReferenceHelper.MaxColumnNumber}.");
             }
             // convert to 0-based
             endColumnIndex--;
@@ -164,15 +164,29 @@ internal IEnumerable<IDictionary<string, object>> InternalQueryRange(bool useHea
                     var headRows = new Dictionary<int, string>();
                     int rowIndex = -1;
                     bool isFirstRow = true;
+                    long synthesizedCellCount = 0;
                     while (!reader.EOF)
                     {
                         if (XmlReaderHelper.IsStartElement(reader, "row", _ns))
                         {
                             var nextRowIndex = rowIndex + 1;
-                            if (int.TryParse(reader.GetAttribute("r"), out int arValue))
-                                rowIndex = arValue - 1; // The row attribute is 1-based
+                            var rowAttribute = reader.GetAttribute("r");
+                            if (rowAttribute != null)
+                            {
+                                if (!int.TryParse(rowAttribute, NumberStyles.None, CultureInfo.InvariantCulture, out var rowNumber)
+                                    || rowNumber is < 1 or > ReferenceHelper.MaxRowNumber)
+                                {
+                                    throw new InvalidDataException($"Row index '{rowAttribute}' is outside Excel's valid range.");
+                                }
+
+                                rowIndex = rowNumber - 1; // The row attribute is 1-based
+                            }
                             else
+                            {
                                 rowIndex++;
+                                if (rowIndex >= ReferenceHelper.MaxRowNumber)
+                                    throw new InvalidDataException("The worksheet contains more rows than Excel supports.");
+                            }
 
                             if (rowIndex < startRowIndex)
                             {
@@ -188,6 +202,24 @@ internal IEnumerable<IDictionary<string, object>> InternalQueryRange(bool useHea
                                 break;
                             }
 
+                            if (!_config.IgnoreEmptyRows && _config.MaxSynthesizedCells.HasValue)
+                            {
+                                var expectedRowIndex = isFirstRow ? startRowIndex : nextRowIndex;
+                                var emptyRowCount = Math.Max(0, rowIndex - expectedRowIndex);
+                                var columnCount = useHeaderRow
+                                    ? Math.Max(1, headRows.Count)
+                                    : Math.Max(1, maxColumnIndex - startColumnIndex + 1);
+
+                                var selfClosingRowCount = reader.IsEmptyElement ? 1 : 0;
+                                synthesizedCellCount += (long)(emptyRowCount + selfClosingRowCount) * columnCount;
+
+                                if (synthesizedCellCount > _config.MaxSynthesizedCells.Value)
+                                {
+                                    throw new InvalidDataException(
+                                        $"The worksheet exceeds the configured limit of {_config.MaxSynthesizedCells.Value} synthesized empty cells.");
+                                }
+                            }
+
                             foreach (var row in QueryRow(reader, isFirstRow, startRowIndex, nextRowIndex, rowIndex, startColumnIndex, endColumnIndex, maxColumnIndex, withoutCR, useHeaderRow, headRows, _mergeCells))
                             {
                                 if (isFirstRow)
@@ -643,6 +675,8 @@ private CellAndColumn ReadCellAndSetColumnIndex(XmlReader reader, int columnInde
         //TODO:need to check only need nextColumnIndex or columnIndex
         else if (ReferenceHelper.ParseReference(aR, out int referenceColumn, out _))
             newColumnIndex = referenceColumn - 1; // ParseReference is 1-based
+        else if (!string.IsNullOrEmpty(aR) && referenceColumn > ReferenceHelper.MaxColumnNumber)
+            throw new InvalidDataException($"Cell reference '{aR}' is invalid.");
         else
             newColumnIndex = columnIndex;
 

src/MiniExcel/OpenXml/OpenXmlConfiguration.cs

@@ -17,6 +17,12 @@ public class OpenXmlConfiguration : Configuration
     public bool WriteEmptyStringAsNull { get; set; } = false;
     public bool TrimColumnNames { get; set; } = true;
     public bool IgnoreEmptyRows { get; set; } = false;
+
+    /// <summary>
+    /// Maximum number of cells that may be synthesized for implicit empty rows during a query.
+    /// Each synthesized row counts as at least one cell. Set to <see langword="null" /> to disable the limit.
+    /// </summary>
+    public long? MaxSynthesizedCells { get; set; } = 100_000;
     public bool EnableSharedStringCache { get; set; } = true;
     public long SharedStringCacheSize { get; set; } = 5 * 1024 * 1024;
 

src/MiniExcel/Utils/ReferenceHelper.cs

@@ -2,6 +2,9 @@
 
 internal static class ReferenceHelper
 {
+    public const int MaxColumnNumber = 16_384;
+    public const int MaxRowNumber = 1_048_576;
+
     public static string GetCellNumber(string cell)
     {
         return cell
@@ -70,6 +73,8 @@ public static bool ParseReference(string value, out int column, out int row)
                 position++;
                 column *= 26;
                 column += c - offset;
+                if (column > MaxColumnNumber)
+                    return false;
                 continue;
             }
 
@@ -105,6 +110,6 @@ public static bool ParseReference(string value, out int column, out int row)
             row = row * 10 + digit;
         }
 
-        return row > 0;
+        return row is > 0 and <= MaxRowNumber;
     }
 }

tests/MiniExcelTests/MiniExcelIssueAsyncTests.cs

@@ -18,6 +18,25 @@
 {
     private readonly ITestOutputHelper _output = output;
 
+    [Fact]
+    public async Task QueryAsyncRejectsRowIndexOutsideWorksheetLimits()
+    {
+        using var path = AutoDeletingPath.Create();
+        MiniExcel.SaveAs(path.ToString(), new[] { new { Value = "control" } });
+        Helpers.ReplaceFirstSheetXml(path.ToString(), """
+            <?xml version="1.0" encoding="utf-8"?>
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+                <dimension ref="A1" />
+                <sheetData>
+                    <row r="2000000000"><c r="A2000000000" t="str"><v>x</v></c></row>
+                </sheetData>
+            </worksheet>
+            """);
+
+        var rows = await MiniExcel.QueryAsync(path.ToString());
+        Assert.Throws<InvalidDataException>(() => rows.First());
+    }
+
     [Fact]
     public async Task Issue997()
     {
@@ -33,7 +52,7 @@
             ["Empty cells"] = new[]
             {
                 new { Name = "Name", Amount = "Amount" },
                 new { Name = "Charlie", Amount = (string)null }
             }
         };
         MiniExcel.SaveAs(xlsx, sheets, printHeader: false);
@@ -352,7 +371,7 @@
 
     private class Issue243Dto
     {
         public string Name { get; set; }
         public int Age { get; set; }
         public DateTime InDate { get; set; }
     }
@@ -486,11 +505,11 @@
         var sheets = new DataSet();
 
         var users = JsonConvert.DeserializeObject<DataTable>(JsonConvert.SerializeObject(new[] { new { Name = "Jack", Age = 25 }, new { Name = "Mike", Age = 44 } }));
         users.TableName = "users";
         sheets.Tables.Add(users);
 
         var department = JsonConvert.DeserializeObject<DataTable>(JsonConvert.SerializeObject(new[] { new { ID = "01", Name = "HR" }, new { ID = "02", Name = "IT" } }));
         department.TableName = "department";
         sheets.Tables.Add(department);
 
         var rowsWritten = await MiniExcel.SaveAsAsync(path, sheets);

tests/MiniExcelTests/MiniExcelIssueTests.cs

@@ -29,6 +29,86 @@
 {
     private readonly ITestOutputHelper _output = output;
 
+    [Theory]
+    [InlineData("1048577")]
+    [InlineData("2000000000")]
+    public void QueryRejectsRowIndexOutsideWorksheetLimits(string rowNumber)
+    {
+        using var path = AutoDeletingPath.Create();
+        MiniExcel.SaveAs(path.ToString(), new[] { new { Value = "control" } });
+        Helpers.ReplaceFirstSheetXml(path.ToString(), $"""
+            <?xml version="1.0" encoding="utf-8"?>
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+                <dimension ref="A1" />
+                <sheetData>
+                    <row r="{rowNumber}"><c r="A{rowNumber}" t="str"><v>x</v></c></row>
+                </sheetData>
+            </worksheet>
+            """);
+
+        Assert.Throws<InvalidDataException>(() => MiniExcel.Query(path.ToString()).First());
+    }
+
+    [Fact]
+    public void QueryRejectsDimensionOutsideWorksheetLimits()
+    {
+        using var path = AutoDeletingPath.Create();
+        MiniExcel.SaveAs(path.ToString(), new[] { new { Value = "control" } });
+        Helpers.ReplaceFirstSheetXml(path.ToString(), """
+            <?xml version="1.0" encoding="utf-8"?>
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+                <dimension ref="A1:XFE1" />
+                <sheetData><row r="1"><c r="A1" t="str"><v>x</v></c></row></sheetData>
+            </worksheet>
+            """);
+
+        Assert.Throws<InvalidDataException>(() => MiniExcel.Query(path.ToString()).First());
+    }
+
+    [Fact]
+    public void QueryRangeAcceptsMaximumWorksheetCoordinates()
+    {
+        using var path = AutoDeletingPath.Create();
+        MiniExcel.SaveAs(path.ToString(), new[] { new { Value = "control" } });
+        Helpers.ReplaceFirstSheetXml(path.ToString(), """
+            <?xml version="1.0" encoding="utf-8"?>
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+                <dimension ref="XFD1048576" />
+                <sheetData>
+                    <row r="1048576"><c r="XFD1048576" t="str"><v>x</v></c></row>
+                </sheetData>
+            </worksheet>
+            """);
+
+        var row = MiniExcel.QueryRange(
+            path.ToString(),
+            startRowIndex: ReferenceHelper.MaxRowNumber,
+            startColumnIndex: ReferenceHelper.MaxColumnNumber,
+            endRowIndex: ReferenceHelper.MaxRowNumber,
+            endColumnIndex: ReferenceHelper.MaxColumnNumber).Single();
+
+        Assert.Equal("x", row.XFD);
+    }
+
+    [Fact]
+    public void QueryRejectsWorksheetExceedingSynthesizedCellLimit()
+    {
+        using var path = AutoDeletingPath.Create();
+        MiniExcel.SaveAs(path.ToString(), new[] { new { Value = "control" } });
+        Helpers.ReplaceFirstSheetXml(path.ToString(), """
+            <?xml version="1.0" encoding="utf-8"?>
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+                <dimension ref="A1:XFD1048576" />
+                <sheetData>
+                    <row r="1048576"><c r="XFD1048576" t="str"><v>x</v></c></row>
+                </sheetData>
+            </worksheet>
+            """);
+
+        var exception = Assert.Throws<InvalidDataException>(() => MiniExcel.Query(path.ToString()).First());
+        Assert.Contains("synthesized empty cells", exception.Message);
+    }
+
     /// <summary>
     /// https://github.com/mini-software/MiniExcel/issues/549
     /// </summary>
@@ -406,7 +486,7 @@
         var sheets = MiniExcel.GetSheetNames(path);
         foreach (var sheetName in sheets)
         {
             var dt = MiniExcel.QueryAsDataTable(path, useHeaderRow: true, sheetName: sheetName, configuration: config);
         }
     }
 

tests/MiniExcelTests/MiniExcelOpenXmlTests.cs

@@ -166,6 +166,8 @@ public void ParseValidCellReference(string reference, int expectedColumn, int ex
     [InlineData("A0")]
     [InlineData("A1x")]
     [InlineData("A2147483648")]
+    [InlineData("A1048577")]
+    [InlineData("XFE1")]
     public void RejectInvalidCellReference(string reference)
     {
         Assert.False(MiniExcelLibs.Utils.ReferenceHelper.ParseReference(reference, out _, out _));

tests/MiniExcelTests/Utils/Helpers.cs

@@ -76,6 +76,21 @@ internal static string GetZipFileContent(string zipPath, string filePath)
         return doc.ToString();
     }
 
+    internal static void ReplaceFirstSheetXml(string path, string worksheetXml)
+    {
+        using var stream = File.Open(path, FileMode.Open, FileAccess.ReadWrite);
+        using var archive = new ZipArchive(stream, ZipArchiveMode.Update, false, Encoding.UTF8);
+        var sheet = archive.Entries.Single(w =>
+            w.FullName.StartsWith("xl/worksheets/sheet1", StringComparison.OrdinalIgnoreCase) ||
+            w.FullName.StartsWith("/xl/worksheets/sheet1", StringComparison.OrdinalIgnoreCase));
+        var entryName = sheet.FullName;
+        sheet.Delete();
+
+        var replacement = archive.CreateEntry(entryName);
+        using var writer = new StreamWriter(replacement.Open(), new UTF8Encoding(false));
+        writer.Write(worksheetXml);
+    }
+
     internal static string? GetFirstSheetDimensionRefValue(string path)
     {
         var ns = new XmlNamespaceManager(new NameTable());