Enhance DECIMAL/Numeric support: update README, add precision/scale validation, and modify example to handle price as string

Author: flarco

README.md

@@ -96,10 +96,36 @@ func main() {
 | `bool` | BIT |
 | `int8`, `int16`, `int32`, `int64` | TINYINT, SMALLINT, INTEGER, BIGINT |
 | `float32`, `float64` | REAL, DOUBLE |
-| `string` | CHAR, VARCHAR, TEXT |
+| `string` | CHAR, VARCHAR, TEXT, DECIMAL, NUMERIC |
 | `[]byte` | BINARY, VARBINARY, BLOB |
 | `time.Time` | DATE, TIME, TIMESTAMP |
 
+## Decimal Precision
+
+DECIMAL and NUMERIC columns are returned as `string` to preserve full precision (avoiding float64 rounding errors). Use the `DecimalSize()` method on column types to get precision and scale metadata:
+
+```go
+rows, _ := db.Query("SELECT price FROM products")
+defer rows.Close()
+
+cols, _ := rows.ColumnTypes()
+for _, col := range cols {
+    if prec, scale, ok := col.DecimalSize(); ok {
+        fmt.Printf("Column %s: DECIMAL(%d,%d)\n", col.Name(), prec, scale)
+    }
+}
+```
+
+For arbitrary-precision arithmetic, use a decimal library like [shopspring/decimal](https://github.com/shopspring/decimal):
+
+```go
+import "github.com/shopspring/decimal"
+
+var priceStr string
+rows.Scan(&priceStr)
+price, _ := decimal.NewFromString(priceStr)
+```
+
 ## Transactions
 
 ```go
@@ -155,10 +181,11 @@ go build ./examples/basic/
 ### What It Tests
 
 - Connection and ping
-- Table creation with various data types (INTEGER, VARCHAR, FLOAT, BOOLEAN/BIT, TIMESTAMP, BINARY)
+- Table creation with various data types (INTEGER, VARCHAR, FLOAT, BOOLEAN/BIT, TIMESTAMP, BINARY, DECIMAL)
 - Prepared statement parameter binding
 - Data insertion and retrieval
 - Value equality validation (verifies inserted values match retrieved values)
+- Decimal precision/scale metadata (validates `ColumnTypePrecisionScale` returns correct values)
 - Transaction rollback (inserts row, rolls back, verifies not persisted)
 - Transaction commit (inserts row, commits, verifies persisted)
 - Table cleanup

examples/basic/main.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
@@ -94,6 +95,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active BIT,
 					created_at DATETIME2,
 					data VARBINARY(100),
+					price DECIMAL(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE %s", tableName),
@@ -109,6 +111,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active BOOLEAN,
 					created_at TIMESTAMP,
 					data BYTEA,
+					price DECIMAL(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName),
@@ -124,6 +127,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active TINYINT(1),
 					created_at DATETIME(3),
 					data VARBINARY(100),
+					price DECIMAL(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName),
@@ -139,6 +143,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active INTEGER,
 					created_at TEXT,
 					data BLOB,
+					price DECIMAL(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName),
@@ -154,6 +159,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active NUMBER(1),
 					created_at TIMESTAMP,
 					data RAW(100),
+					price NUMBER(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE %s", tableName),
@@ -170,6 +176,7 @@ func getDDLTemplates(dbType DBType, tableName string) DDLTemplates {
 					active SMALLINT,
 					created_at TIMESTAMP,
 					data VARBINARY(100),
+					price DECIMAL(10,2),
 					PRIMARY KEY (id)
 				)`, tableName),
 			DropTable:  fmt.Sprintf("DROP TABLE %s", tableName),
@@ -251,21 +258,22 @@ func runTest(db *sql.DB, _ DBType, tableName string, ddl DDLTemplates) error {
 		active    bool
 		createdAt time.Time
 		data      []byte
+		price     string // DECIMAL as string to preserve precision
 	}{
-		{1, "Alice", 123.45, true, time.Date(2024, 1, 15, 10, 30, 0, 0, time.UTC), []byte{0x01, 0x02, 0x03}},
-		{2, "Bob", 678.90, false, time.Date(2024, 2, 20, 14, 45, 0, 0, time.UTC), []byte{0x04, 0x05, 0x06}},
-		{3, "Charlie", 0.0, true, time.Date(2024, 3, 25, 9, 0, 0, 0, time.UTC), nil},
+		{1, "Alice", 123.45, true, time.Date(2024, 1, 15, 10, 30, 0, 0, time.UTC), []byte{0x01, 0x02, 0x03}, "12345.67"},
+		{2, "Bob", 678.90, false, time.Date(2024, 2, 20, 14, 45, 0, 0, time.UTC), []byte{0x04, 0x05, 0x06}, "9999.99"},
+		{3, "Charlie", 0.0, true, time.Date(2024, 3, 25, 9, 0, 0, 0, time.UTC), nil, "0.01"},
 	}
 
-	insertSQL := fmt.Sprintf("INSERT INTO %s (id, name, value, active, created_at, data) VALUES (?, ?, ?, ?, ?, ?)", tableName)
+	insertSQL := fmt.Sprintf("INSERT INTO %s (id, name, value, active, created_at, data, price) VALUES (?, ?, ?, ?, ?, ?, ?)", tableName)
 	stmt, err := db.Prepare(insertSQL)
 	if err != nil {
 		return fmt.Errorf("failed to prepare insert: %w", err)
 	}
 	defer stmt.Close()
 
 	for _, row := range testRows {
-		result, err := stmt.Exec(row.id, row.name, row.value, row.active, row.createdAt, row.data)
+		result, err := stmt.Exec(row.id, row.name, row.value, row.active, row.createdAt, row.data, row.price)
 		if err != nil {
 			return fmt.Errorf("failed to insert row %d: %w", row.id, err)
 		}
@@ -275,7 +283,7 @@ func runTest(db *sql.DB, _ DBType, tableName string, ddl DDLTemplates) error {
 
 	// Select and validate rows
 	log.Println("Selecting rows back...")
-	selectSQL := fmt.Sprintf("SELECT id, name, value, active, created_at, data FROM %s ORDER BY id", tableName)
+	selectSQL := fmt.Sprintf("SELECT id, name, value, active, created_at, data, price FROM %s ORDER BY id", tableName)
 	rows, err := db.Query(selectSQL)
 	if err != nil {
 		return fmt.Errorf("failed to query rows: %w", err)
@@ -289,6 +297,28 @@ func runTest(db *sql.DB, _ DBType, tableName string, ddl DDLTemplates) error {
 	}
 	log.Printf("Columns: %v", columns)
 
+	// Validate DECIMAL precision/scale metadata
+	colTypes, err := rows.ColumnTypes()
+	if err != nil {
+		return fmt.Errorf("failed to get column types: %w", err)
+	}
+	for _, col := range colTypes {
+		if col.Name() == "price" {
+			prec, scale, ok := col.DecimalSize()
+			if !ok {
+				return fmt.Errorf("price column: DecimalSize() returned ok=false, expected ok=true")
+			}
+			log.Printf("  Column 'price': DECIMAL(%d,%d)", prec, scale)
+			if prec != 10 {
+				return fmt.Errorf("price column: expected precision=10, got %d", prec)
+			}
+			if scale != 2 {
+				return fmt.Errorf("price column: expected scale=2, got %d", scale)
+			}
+			log.Println("  ✓ DECIMAL precision/scale metadata validated")
+		}
+	}
+
 	// Fetch and validate rows
 	rowCount := 0
 	for rows.Next() {
@@ -298,13 +328,14 @@ func runTest(db *sql.DB, _ DBType, tableName string, ddl DDLTemplates) error {
 		var active sql.NullBool
 		var createdAt sql.NullTime
 		var data []byte
+		var price sql.NullString // DECIMAL scanned as string to preserve precision
 
-		if err := rows.Scan(&id, &name, &value, &active, &createdAt, &data); err != nil {
+		if err := rows.Scan(&id, &name, &value, &active, &createdAt, &data, &price); err != nil {
 			return fmt.Errorf("failed to scan row: %w", err)
 		}
 
-		log.Printf("  Row %d: id=%d, name=%v, value=%v, active=%v, created_at=%v, data=%v",
-			rowCount+1, id, name.String, value.Float64, active.Bool, createdAt.Time, data)
+		log.Printf("  Row %d: id=%d, name=%v, value=%v, active=%v, created_at=%v, data=%v, price=%v",
+			rowCount+1, id, name.String, value.Float64, active.Bool, createdAt.Time, data, price.String)
 
 		// Validate against expected values
 		expected := testRows[rowCount]
@@ -343,6 +374,13 @@ func runTest(db *sql.DB, _ DBType, tableName string, ddl DDLTemplates) error {
 				}
 			}
 		}
+		// Compare DECIMAL price - parse as float for comparison since string format may vary
+		// (e.g., ".01" vs "0.01" depending on database)
+		expectedPrice, _ := strconv.ParseFloat(expected.price, 64)
+		gotPrice, _ := strconv.ParseFloat(price.String, 64)
+		if expectedPrice != gotPrice {
+			return fmt.Errorf("row %d: expected price=%q (%v), got %q (%v)", rowCount+1, expected.price, expectedPrice, price.String, gotPrice)
+		}
 
 		log.Printf("  Row %d: ✓ all values match expected", rowCount+1)
 		rowCount++

rows.go

@@ -14,6 +14,7 @@ type Rows struct {
 	columns   []string
 	colTypes  []SQLSMALLINT
 	colSizes  []SQLULEN
+	decDigits []SQLSMALLINT // decimal digits (scale) for NUMERIC/DECIMAL types
 	nullable  []SQLSMALLINT
 	closed    bool
 	closeStmt bool // Whether to close the statement when rows are closed
@@ -39,18 +40,20 @@ func newRows(stmt *Stmt, closeStmt bool) (*Rows, error) {
 	columns := make([]string, numCols)
 	colTypes := make([]SQLSMALLINT, numCols)
 	colSizes := make([]SQLULEN, numCols)
+	decDigits := make([]SQLSMALLINT, numCols)
 	nullable := make([]SQLSMALLINT, numCols)
 
 	colName := make([]byte, 256)
 	for i := SQLUSMALLINT(1); i <= SQLUSMALLINT(numCols); i++ {
-		nameLen, dataType, colSize, _, nullableVal, ret := DescribeCol(stmt.stmt, i, colName)
+		nameLen, dataType, colSize, decDigitsVal, nullableVal, ret := DescribeCol(stmt.stmt, i, colName)
 		if !IsSuccess(ret) {
 			return nil, NewError(SQL_HANDLE_STMT, SQLHANDLE(stmt.stmt))
 		}
 
 		columns[i-1] = string(colName[:nameLen])
 		colTypes[i-1] = dataType
 		colSizes[i-1] = colSize
+		decDigits[i-1] = decDigitsVal
 		nullable[i-1] = nullableVal
 	}
 
@@ -59,6 +62,7 @@ func newRows(stmt *Stmt, closeStmt bool) (*Rows, error) {
 		columns:   columns,
 		colTypes:  colTypes,
 		colSizes:  colSizes,
+		decDigits: decDigits,
 		nullable:  nullable,
 		closeStmt: closeStmt,
 	}, nil
@@ -423,8 +427,10 @@ func (r *Rows) ColumnTypeScanType(index int) reflect.Type {
 		return reflect.TypeOf(int64(0))
 	case SQL_REAL:
 		return reflect.TypeOf(float32(0))
-	case SQL_FLOAT, SQL_DOUBLE, SQL_NUMERIC, SQL_DECIMAL:
+	case SQL_FLOAT, SQL_DOUBLE:
 		return reflect.TypeOf(float64(0))
+	case SQL_NUMERIC, SQL_DECIMAL:
+		return reflect.TypeOf("") // String preserves decimal precision
 	case SQL_CHAR, SQL_VARCHAR, SQL_LONGVARCHAR, SQL_WCHAR, SQL_WVARCHAR, SQL_WLONGVARCHAR:
 		return reflect.TypeOf("")
 	case SQL_BINARY, SQL_VARBINARY, SQL_LONGVARBINARY:
@@ -523,6 +529,20 @@ func (r *Rows) ColumnTypeNullable(index int) (nullable, ok bool) {
 	}
 }
 
+// ColumnTypePrecisionScale returns the precision and scale for NUMERIC/DECIMAL types
+func (r *Rows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) {
+	if index < 0 || index >= len(r.colTypes) {
+		return 0, 0, false
+	}
+	switch r.colTypes[index] {
+	case SQL_NUMERIC, SQL_DECIMAL:
+		// colSize = precision (total digits), decDigits = scale (digits after decimal)
+		return int64(r.colSizes[index]), int64(r.decDigits[index]), true
+	default:
+		return 0, 0, false
+	}
+}
+
 // HasNextResultSet checks if there are more result sets
 func (r *Rows) HasNextResultSet() bool {
 	return MoreResults(r.stmt.stmt) == SQL_SUCCESS
@@ -548,24 +568,27 @@ func (r *Rows) NextResultSet() error {
 	columns := make([]string, numCols)
 	colTypes := make([]SQLSMALLINT, numCols)
 	colSizes := make([]SQLULEN, numCols)
+	decDigits := make([]SQLSMALLINT, numCols)
 	nullable := make([]SQLSMALLINT, numCols)
 
 	colName := make([]byte, 256)
 	for i := SQLUSMALLINT(1); i <= SQLUSMALLINT(numCols); i++ {
-		nameLen, dataType, colSize, _, nullableVal, ret := DescribeCol(r.stmt.stmt, i, colName)
+		nameLen, dataType, colSize, decDigitsVal, nullableVal, ret := DescribeCol(r.stmt.stmt, i, colName)
 		if !IsSuccess(ret) {
 			return NewError(SQL_HANDLE_STMT, SQLHANDLE(r.stmt.stmt))
 		}
 
 		columns[i-1] = string(colName[:nameLen])
 		colTypes[i-1] = dataType
 		colSizes[i-1] = colSize
+		decDigits[i-1] = decDigitsVal
 		nullable[i-1] = nullableVal
 	}
 
 	r.columns = columns
 	r.colTypes = colTypes
 	r.colSizes = colSizes
+	r.decDigits = decDigits
 	r.nullable = nullable
 
 	return nil
@@ -578,5 +601,6 @@ var (
 	_ driver.RowsColumnTypeDatabaseTypeName = (*Rows)(nil)
 	_ driver.RowsColumnTypeLength           = (*Rows)(nil)
 	_ driver.RowsColumnTypeNullable         = (*Rows)(nil)
+	_ driver.RowsColumnTypePrecisionScale   = (*Rows)(nil)
 	_ driver.RowsNextResultSet              = (*Rows)(nil)
 )