Improve cell read performance by optimizing XML parsing (qax-os#2116)

- Rows iterator speedup about 20%, memory allocation reduce about 10%
- Update unit test
- Extends time out to 50 minutes in GitHub Action for made TestZip64 stable

Author: shcabin

.github/workflows/go.yml

@@ -29,7 +29,7 @@ jobs:
       run: go build -v .
 
     - name: Test
-      run: env GO111MODULE=on go test -v -timeout 30m -race ./... -coverprofile='coverage.txt' -covermode=atomic
+      run: env GO111MODULE=on go test -v -timeout 50m -race ./... -coverprofile='coverage.txt' -covermode=atomic
 
     - name: Codecov
       uses: codecov/codecov-action@v5

rows.go

@@ -231,7 +231,7 @@ func (rows *Rows) rowXMLHandler(rowIterator *rowXMLIterator, xmlElement *xml.Sta
 	if rowIterator.inElement == "c" {
 		rowIterator.cellCol++
 		colCell := xlsxC{}
-		_ = rows.decoder.DecodeElement(&colCell, xmlElement)
+		colCell.cellXMLHandler(rows.decoder, xmlElement)
 		if colCell.R != "" {
 			if rowIterator.cellCol, _, rowIterator.err = CellNameToCoordinates(colCell.R); rowIterator.err != nil {
 				return
@@ -244,6 +244,63 @@ func (rows *Rows) rowXMLHandler(rowIterator *rowXMLIterator, xmlElement *xml.Sta
 	}
 }
 
+// cellXMLAttrHandler parse the cell XML element attributes of the worksheet.
+func (cell *xlsxC) cellXMLAttrHandler(start *xml.StartElement) error {
+	for _, attr := range start.Attr {
+		switch attr.Name.Local {
+		case "r":
+			cell.R = attr.Value
+		case "s":
+			val, err := strconv.ParseInt(attr.Value, 10, 64)
+			if err != nil {
+				return err
+			}
+			if math.MinInt <= val && val <= math.MaxInt {
+				cell.S = int(val)
+			}
+		case "t":
+			cell.T = attr.Value
+		default:
+		}
+	}
+	return nil
+}
+
+// cellXMLHandler parse the cell XML element of the worksheet.
+func (cell *xlsxC) cellXMLHandler(decoder *xml.Decoder, start *xml.StartElement) error {
+	cell.XMLName = start.Name
+	err := cell.cellXMLAttrHandler(start)
+	if err != nil {
+		return err
+	}
+	for {
+		tok, err := decoder.Token()
+		if err != nil {
+			return err
+		}
+		var se xml.StartElement
+		switch el := tok.(type) {
+		case xml.StartElement:
+			se = el
+			switch se.Name.Local {
+			case "v":
+				err = decoder.DecodeElement(&cell.V, &se)
+			case "f":
+				err = decoder.DecodeElement(&cell.F, &se)
+			case "is":
+				err = decoder.DecodeElement(&cell.IS, &se)
+			}
+			if err != nil {
+				return err
+			}
+		case xml.EndElement:
+			if el == start.End() {
+				return nil
+			}
+		}
+	}
+}
+
 // Rows returns a rows iterator, used for streaming reading data for a
 // worksheet with a large data. This function is concurrency safe. For
 // example:

rows_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"path/filepath"
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -1157,6 +1158,66 @@ func TestNumberFormats(t *testing.T) {
 	assert.Equal(t, "2019/3/19", result, "A1")
 }
 
+func TestCellXMLHandler(t *testing.T) {
+	var (
+		content      = []byte(fmt.Sprintf(`<worksheet xmlns="%s"><sheetData><row r="1"><c r="A1" t="s"><v>10</v></c><c r="B1"><is><t>String</t></is></c></row><row r="2"><c r="A2" s="4" t="str"><f>2*A1</f><v>0</v></c><c r="C2" s="1"><f>A3</f><v>2422.3000000000002</v></c><c r="D2" t="d"><v>2022-10-22T15:05:29Z</v></c><c r="F2"></c><c r="G2"></c></row></sheetData></worksheet>`, NameSpaceSpreadSheet.Value))
+		expected, ws xlsxWorksheet
+		row          *xlsxRow
+	)
+	assert.NoError(t, xml.Unmarshal(content, &expected))
+	decoder := xml.NewDecoder(bytes.NewReader(content))
+	rows := Rows{decoder: decoder}
+	for {
+		token, _ := decoder.Token()
+		if token == nil {
+			break
+		}
+		switch element := token.(type) {
+		case xml.StartElement:
+			if element.Name.Local == "row" {
+				r, err := strconv.Atoi(element.Attr[0].Value)
+				assert.NoError(t, err)
+				ws.SheetData.Row = append(ws.SheetData.Row, xlsxRow{R: r})
+				row = &ws.SheetData.Row[len(ws.SheetData.Row)-1]
+			}
+			if element.Name.Local == "c" {
+				colCell := xlsxC{}
+				assert.NoError(t, colCell.cellXMLHandler(rows.decoder, &element))
+				row.C = append(row.C, colCell)
+			}
+		}
+	}
+	assert.Equal(t, expected.SheetData.Row, ws.SheetData.Row)
+
+	for _, rowXML := range []string{
+		`<row spans="1:17" r="1"><c r="A1" t="s" s="A"><v>10</v></c></row></sheetData></worksheet>`, // s need number
+		`<row spans="1:17" r="1"><c r="A1"><v>10</v>    </row></sheetData></worksheet>`,             // missing </c>
+		`<row spans="1:17" r="1"><c r="B1"><is><t>`,                                                 // incorrect data
+	} {
+		ws := xlsxWorksheet{}
+		content := []byte(fmt.Sprintf(`<worksheet xmlns="%s"><sheetData>%s</sheetData></worksheet>`, NameSpaceSpreadSheet.Value, rowXML))
+		expected := xml.Unmarshal(content, &ws)
+		assert.Error(t, expected)
+		decoder := xml.NewDecoder(bytes.NewReader(content))
+		rows := Rows{decoder: decoder}
+		for {
+			token, _ := decoder.Token()
+			if token == nil {
+				break
+			}
+			switch element := token.(type) {
+			case xml.StartElement:
+				if element.Name.Local == "c" {
+					colCell := xlsxC{}
+					err := colCell.cellXMLHandler(rows.decoder, &element)
+					assert.Error(t, err)
+					assert.Equal(t, expected, err)
+				}
+			}
+		}
+	}
+}
+
 func BenchmarkRows(b *testing.B) {
 	f, _ := OpenFile(filepath.Join("test", "Book1.xlsx"))
 	for i := 0; i < b.N; i++ {