feat(tests): add comprehensive range format tests for Excel dataset retrieval

Author: flarco

core/dbio/filesys/sheet_test.go

@@ -99,6 +99,52 @@ func TestExcel(t *testing.T) {
 	os.RemoveAll("test/test.excel6.xlsx")
 }
 
+func TestExcelRangeFormats(t *testing.T) {
+	t.Parallel()
+
+	xls, err := iop.NewExcelFromFile("test/test.excel2.xlsx")
+	if !assert.NoError(t, err) {
+		return
+	}
+
+	// Test standard range format "A1:H29"
+	data, err := xls.GetDatasetFromRange(xls.Sheets[0], "A1:H29")
+	assert.NoError(t, err)
+	assert.Equal(t, 8, len(data.Columns))
+	assert.Equal(t, 28, len(data.Rows))
+
+	// Test row-only range format "1:10" - should detect columns with data
+	data, err = xls.GetDatasetFromRange(xls.Sheets[0], "1:10")
+	assert.NoError(t, err)
+	assert.Greater(t, len(data.Columns), 0, "should detect columns with data")
+	assert.Equal(t, 9, len(data.Rows)) // rows 1-10 = 10 rows, minus header = 9
+
+	// Test partial range format "A1:C" - should extend to last row
+	data, err = xls.GetDatasetFromRange(xls.Sheets[0], "A1:C")
+	assert.NoError(t, err)
+	assert.Equal(t, 3, len(data.Columns))
+	assert.Greater(t, len(data.Rows), 100, "should extend to last row")
+
+	// Test single row range "5:5"
+	data, err = xls.GetDatasetFromRange(xls.Sheets[0], "5:5")
+	assert.NoError(t, err)
+	assert.Greater(t, len(data.Columns), 0)
+
+	// Test error: reversed row range "10:5"
+	_, err = xls.GetDatasetFromRange(xls.Sheets[0], "10:5")
+	assert.Error(t, err, "should error on reversed row range")
+	assert.Contains(t, err.Error(), "reversed")
+
+	// Test error: reversed row range in standard format "A10:C5"
+	_, err = xls.GetDatasetFromRange(xls.Sheets[0], "A10:C5")
+	assert.Error(t, err, "should error on reversed row range")
+	assert.Contains(t, err.Error(), "reversed")
+
+	// Test error: invalid range format
+	_, err = xls.GetDatasetFromRange(xls.Sheets[0], "invalid")
+	assert.Error(t, err, "should error on invalid range format")
+}
+
 func TestGoogleSheet(t *testing.T) {
 
 	url := "https://docs.google.com/spreadsheets/d/1Wo7d_2oiYpWy1hYGqHIy0DSPWki24Xif3FnlRjNGzo4/edit#gid=0"

core/dbio/iop/sheet_excel.go

@@ -31,12 +31,13 @@ func NewExcelDataset(reader io.Reader, props map[string]string) (data Dataset, e
 	sheetName := props["sheet"]
 	sheetRange := ""
 
-	if sheetName == "" {
-		sheetName = xls.Sheets[0]
-	} else if sheetNameArr := strings.Split(sheetName, "!"); len(sheetNameArr) == 2 {
+	if sheetNameArr := strings.Split(sheetName, "!"); len(sheetNameArr) == 2 {
 		sheetName = sheetNameArr[0]
 		sheetRange = sheetNameArr[1]
 	}
+	if sheetName == "" {
+		sheetName = xls.Sheets[0] // if sheet is blank, use first
+	}
 
 	if sheetRange != "" {
 		data, err = xls.GetDatasetFromRange(sheetName, sheetRange)
@@ -139,13 +140,27 @@ func (xls *Excel) GetDataset(sheet string) (data Dataset) {
 }
 
 // GetDatasetFromRange returns a dataset of the provided sheet / range
-// cellRange example: `$AH$13:$AI$20` or `AH13:AI20` or `A:E`
+// cellRange examples:
+//   - `$AH$13:$AI$20` or `AH13:AI20` - standard cell range
+//   - `A:E` - column range (all rows)
+//   - `9:15` - row range (detects columns with data)
+//   - `A4:C` - partial range (extends to last row)
 func (xls *Excel) GetDatasetFromRange(sheet, cellRange string) (data Dataset, err error) {
 
 	regexAlpha := *regexp.MustCompile(`[^a-zA-Z]`)
 	regexNum := *regexp.MustCompile(`[^0-9]`)
 
-	cellRange = strings.ReplaceAll(cellRange, "$", "")
+	allRows, err := xls.File.GetRows(sheet)
+	if err != nil {
+		return data, g.Error(err, "could not get rows")
+	}
+
+	// Normalize range format (handles row-only and partial ranges)
+	cellRange, err = xls.normalizeRange(cellRange, allRows)
+	if err != nil {
+		return data, g.Error(err, "could not normalize range")
+	}
+
 	rangeArr := strings.Split(cellRange, ":")
 	if len(rangeArr) != 2 {
 		err = g.Error(err, "Invalid range: "+cellRange)
@@ -159,11 +174,6 @@ func (xls *Excel) GetDatasetFromRange(sheet, cellRange string) (data Dataset, er
 	rowStart := cast.ToInt(regexNum.ReplaceAllString(rangeArr[0], "")) - 1
 	rowEnd := cast.ToInt(regexNum.ReplaceAllString(rangeArr[1], "")) - 1
 
-	allRows, err := xls.File.GetRows(sheet)
-	if err != nil {
-		return data, g.Error(err, "could not get rows")
-	}
-
 	if rowStart == -1 {
 		rowStart = 0
 	}
@@ -265,6 +275,107 @@ func (xls *Excel) TitleToNumber(s string) int {
 	return sum - 1
 }
 
+// NumberToTitle converts a 0-based column index to Excel column letters.
+// For example: 0 -> "A", 25 -> "Z", 26 -> "AA"
+func (xls *Excel) NumberToTitle(n int) string {
+	result := ""
+	for n >= 0 {
+		result = string(rune('A'+n%26)) + result
+		n = n/26 - 1
+	}
+	return result
+}
+
+// normalizeRange normalizes various range formats into standard Excel range notation.
+// Supported formats:
+//   - "9:15" (row-only) -> "A9:<lastCol>15" (detects last column with data)
+//   - "A4:C" (partial) -> "A4:C<lastRow>" (extends to last row)
+//   - "A4:C8" (standard) -> "A4:C8" (no change)
+func (xls *Excel) normalizeRange(cellRange string, allRows [][]string) (string, error) {
+	regexAlpha := regexp.MustCompile(`[^a-zA-Z]`)
+	regexNum := regexp.MustCompile(`[^0-9]`)
+	regexRowOnly := regexp.MustCompile(`^\d+:\d+$`)
+
+	cellRange = strings.ReplaceAll(cellRange, "$", "")
+	rangeArr := strings.Split(cellRange, ":")
+	if len(rangeArr) != 2 {
+		return "", g.Error("invalid range format: %s", cellRange)
+	}
+
+	startPart := rangeArr[0]
+	endPart := rangeArr[1]
+
+	// Check if it's a row-only range like "9:15"
+	if regexRowOnly.MatchString(cellRange) {
+		rowStart := cast.ToInt(startPart)
+		rowEnd := cast.ToInt(endPart)
+
+		if rowStart <= 0 || rowEnd <= 0 {
+			return "", g.Error("invalid row numbers in range: %s", cellRange)
+		}
+		if rowStart > rowEnd {
+			return "", g.Error("row range %d:%d is reversed", rowStart, rowEnd)
+		}
+
+		// Convert to 0-based indices
+		rowStartIdx := rowStart - 1
+		rowEndIdx := rowEnd - 1
+
+		if rowStartIdx >= len(allRows) {
+			return "", g.Error("row range %d:%d exceeds sheet bounds (max row: %d)", rowStart, rowEnd, len(allRows))
+		}
+
+		// Scan rows to find max column with data (limit to SampleSize rows for performance)
+		maxCol := 0
+		scannedRows := 0
+		for r := rowStartIdx; r <= rowEndIdx && r < len(allRows); r++ {
+			if len(allRows[r]) > maxCol {
+				maxCol = len(allRows[r])
+			}
+			scannedRows++
+			if scannedRows >= SampleSize {
+				break
+			}
+		}
+
+		if maxCol == 0 {
+			return "", g.Error("no data found in row range %d:%d", rowStart, rowEnd)
+		}
+
+		// Convert to column letter (maxCol is count, so subtract 1 for 0-based index)
+		endCol := xls.NumberToTitle(maxCol - 1)
+		return g.F("A%d:%s%d", rowStart, endCol, rowEnd), nil
+	}
+
+	// Extract column and row parts
+	_ = regexAlpha.ReplaceAllString(startPart, "") // startCol - not needed for normalization
+	endCol := regexAlpha.ReplaceAllString(endPart, "")
+	startRowStr := regexNum.ReplaceAllString(startPart, "")
+	endRowStr := regexNum.ReplaceAllString(endPart, "")
+
+	// Check for partial range like "A4:C" (has start row but no end row)
+	if startRowStr != "" && endRowStr == "" && endCol != "" {
+		startRow := cast.ToInt(startRowStr)
+		if startRow <= 0 {
+			return "", g.Error("invalid start row in range: %s", cellRange)
+		}
+		// Extend to last row
+		return g.F("%s:%s%d", startPart, endCol, len(allRows)), nil
+	}
+
+	// Validate row order if both rows are specified
+	if startRowStr != "" && endRowStr != "" {
+		startRow := cast.ToInt(startRowStr)
+		endRow := cast.ToInt(endRowStr)
+		if startRow > endRow {
+			return "", g.Error("row range %d:%d is reversed", startRow, endRow)
+		}
+	}
+
+	// Standard format or column-only format (A:E), return as-is
+	return cellRange, nil
+}
+
 // WriteSheet write a datastream into a sheet
 // mode can be: `new`, `append` or `overwrite`. Default is `new`
 func (xls *Excel) WriteSheet(shtName string, ds *Datastream, mode string) (err error) {