perf: optimize Rows.Columns with cell reuse and pre-allocation

- Add xlsxC.reset() method to clear cell struct for reuse
- Add cellBuf field to Rows struct for per-cell allocation avoidance
- Add numCols field to learn column count for slice pre-allocation
- Use colRefToIndex fast path when FastReadMode has preloaded SST
- Skip sharedStringsReader call when fastSSTLoaded is true

These optimizations reduce allocations in the traditional Rows.Columns()
path, complementing the FastRows raw parser for read-heavy workloads.

Author: AdamDrewsTR

rows.go

@@ -94,6 +94,10 @@ type Rows struct {
 	decoder                 *xml.Decoder
 	token                   xml.Token
 	curRowOpts, seekRowOpts RowOpts
+	// Reusable cell struct to avoid per-cell allocation
+	cellBuf xlsxC
+	// Learned column count for pre-allocation
+	numCols int
 }
 
 // Next will return true if it finds the next row element.
@@ -155,11 +159,18 @@ func (rows *Rows) Columns(opts ...Options) ([]string, error) {
 	if rows.curRow > rows.seekRow {
 		return nil, nil
 	}
+	// Pre-allocate cells slice based on learned column count
 	var rowIterator rowXMLIterator
+	if rows.numCols > 0 {
+		rowIterator.cells = make([]string, 0, rows.numCols)
+	}
 	var token xml.Token
 	rows.rawCellValue = rows.f.getOptions(opts...).RawCellValue
-	if rows.sst, rowIterator.err = rows.f.sharedStringsReader(); rowIterator.err != nil {
-		return rowIterator.cells, rowIterator.err
+	// Fast path: skip sharedStringsReader if FastReadMode already loaded SST
+	if !rows.f.fastSSTLoaded {
+		if rows.sst, rowIterator.err = rows.f.sharedStringsReader(); rowIterator.err != nil {
+			return rowIterator.cells, rowIterator.err
+		}
 	}
 	for {
 		if rows.token != nil {
@@ -181,6 +192,10 @@ func (rows *Rows) Columns(opts ...Options) ([]string, error) {
 				rows.seekRowOpts = extractRowOpts(xmlElement.Attr)
 				if rows.curRow > rows.seekRow {
 					rows.token = nil
+					// Learn column count for next row's pre-allocation
+					if rows.numCols == 0 && len(rowIterator.cells) > 0 {
+						rows.numCols = len(rowIterator.cells)
+					}
 					return rowIterator.cells, rowIterator.err
 				}
 			}
@@ -191,6 +206,9 @@ func (rows *Rows) Columns(opts ...Options) ([]string, error) {
 			rows.token = nil
 		case xml.EndElement:
 			if xmlElement.Name.Local == "sheetData" {
+				if rows.numCols == 0 && len(rowIterator.cells) > 0 {
+					rows.numCols = len(rowIterator.cells)
+				}
 				return rowIterator.cells, rowIterator.err
 			}
 		}
@@ -250,15 +268,20 @@ type rowXMLIterator struct {
 func (rows *Rows) rowXMLHandler(rowIterator *rowXMLIterator, xmlElement *xml.StartElement, raw bool) {
 	if rowIterator.inElement == "c" {
 		rowIterator.cellCol++
-		colCell := xlsxC{}
-		_ = colCell.cellXMLHandler(rows.decoder, xmlElement)
-		if colCell.R != "" {
-			if rowIterator.cellCol, _, rowIterator.err = CellNameToCoordinates(colCell.R); rowIterator.err != nil {
+		// Reuse cell buffer to avoid per-cell allocation
+		cell := &rows.cellBuf
+		cell.reset()
+		_ = cell.cellXMLHandler(rows.decoder, xmlElement)
+		if cell.R != "" {
+			// Use fast inline column parser when FastReadMode is enabled
+			if rows.f.fastSSTLoaded {
+				rowIterator.cellCol = colRefToIndex(cell.R)
+			} else if rowIterator.cellCol, _, rowIterator.err = CellNameToCoordinates(cell.R); rowIterator.err != nil {
 				return
 			}
 		}
 		blank := rowIterator.cellCol - len(rowIterator.cells)
-		if val, _ := colCell.getValueFrom(rows.f, rows.sst, raw); val != "" || colCell.F != nil {
+		if val, _ := cell.getValueFrom(rows.f, rows.sst, raw); val != "" || cell.F != nil {
 			rowIterator.cells = append(appendSpace(blank, rowIterator.cells), val)
 		}
 	}

rows_test.go

@@ -2575,3 +2575,35 @@ func TestRowsFastPeekError(t *testing.T) {
 		fr2.Close()
 	}
 }
+
+func TestRowsColumnsWithFastSSTLoaded(t *testing.T) {
+	// Exercise the colRefToIndex fast path in rowXMLHandler when fastSSTLoaded=true
+	f := NewFile()
+	defer f.Close()
+	f.SetCellValue("Sheet1", "A1", "hello")
+	f.SetCellValue("Sheet1", "B1", "world")
+	f.SetCellValue("Sheet1", "A2", "foo")
+
+	buf, err := f.WriteToBuffer()
+	require.NoError(t, err)
+
+	f2, err := OpenReader(buf, Options{FastReadMode: true})
+	require.NoError(t, err)
+	defer f2.Close()
+
+	rows, err := f2.Rows("Sheet1")
+	require.NoError(t, err)
+	defer rows.Close()
+
+	// First row — triggers colRefToIndex fast path
+	assert.True(t, rows.Next())
+	cols, err := rows.Columns()
+	assert.NoError(t, err)
+	assert.Equal(t, []string{"hello", "world"}, cols)
+
+	// Second row — exercises numCols pre-allocation
+	assert.True(t, rows.Next())
+	cols, err = rows.Columns()
+	assert.NoError(t, err)
+	assert.Equal(t, []string{"foo"}, cols)
+}

xmlWorksheet.go

@@ -515,6 +515,22 @@ type xlsxC struct {
 	f        string
 }
 
+// reset clears the cell struct for reuse, avoiding allocation of a new struct.
+func (c *xlsxC) reset() {
+	c.XMLName = xml.Name{}
+	c.XMLSpace = xml.Attr{}
+	c.R = ""
+	c.S = 0
+	c.T = ""
+	c.Cm = nil
+	c.Vm = nil
+	c.Ph = nil
+	c.F = nil
+	c.V = ""
+	c.IS = nil
+	c.f = ""
+}
+
 // xlsxF represents a formula for the cell. The formula expression is
 // contained in the character node of this element.
 type xlsxF struct {