msgpack: add string() for decimal, datetime. interval

Added a benchmark, which shows that the code for decimal is optimized two or more times for string conversion than the code from the library. Added a datetime, Interval type conversion function to a string, added tests for this function.

Added #322

Author: babyTsakhes

decimal/decimal.go

@@ -24,7 +24,6 @@ import (
 	"math"
 	"reflect"
 	"strconv"
-	"strings"
 
 	"github.com/shopspring/decimal"
 	"github.com/vmihailenco/msgpack/v5"
@@ -180,8 +179,7 @@ func (d Decimal) String() string {
 // StringFromInt64 is an internal method for converting int64
 // and scale to a string (for numbers up to 19 digits).
 func (d Decimal) stringFromInt64(value int64, scale int) string {
-
-	var buf [48]byte
+	var buf [64]byte
 	pos := 0
 
 	negative := value < 0
@@ -197,7 +195,13 @@ func (d Decimal) stringFromInt64(value int64, scale int) string {
 	str := strconv.FormatInt(value, 10)
 	length := len(str)
 
+	// Special case: zero value.
+	if value == 0 {
+		return "0" // Always return "0" regardless of scale.
+	}
+
 	if scale == 0 {
+		// No fractional part.
 		if pos+length > len(buf) {
 			return d.Decimal.String()
 		}
@@ -207,8 +211,23 @@ func (d Decimal) stringFromInt64(value int64, scale int) string {
 	}
 
 	if scale >= length {
+		// Numbers like 0.00123.
+		// Count trailing zeros in the fractional part.
+		trailingZeros := 0
+		// In this case, the fractional part consists of (scale-length) zeros followed by the number.
+		// We need to count trailing zeros in the actual number part.
+		for i := length - 1; i >= 0 && str[i] == '0'; i-- {
+			trailingZeros++
+		}
 
-		required := 2 + (scale - length) + length
+		effectiveDigits := length - trailingZeros
+
+		// If all digits are zeros after leading zeros, we need to adjust.
+		if effectiveDigits == 0 {
+			return "0"
+		}
+
+		required := 2 + (scale - length) + effectiveDigits
 		if pos+required > len(buf) {
 			return d.Decimal.String()
 		}
@@ -217,39 +236,63 @@ func (d Decimal) stringFromInt64(value int64, scale int) string {
 		buf[pos+1] = '.'
 		pos += 2
 
+		// Add leading zeros.
 		zeros := scale - length
 		for i := 0; i < zeros; i++ {
 			buf[pos] = '0'
 			pos++
 		}
 
-		copy(buf[pos:], str)
-		pos += length
+		// Copy only significant digits (without trailing zeros).
+		copy(buf[pos:], str[:effectiveDigits])
+		pos += effectiveDigits
 	} else {
-
+		// Numbers like 123.45.
 		integerLen := length - scale
 
-		required := integerLen + 1 + scale
+		// Count trailing zeros in fractional part.
+		trailingZeros := 0
+		for i := length - 1; i >= integerLen && str[i] == '0'; i-- {
+			trailingZeros++
+		}
+
+		effectiveScale := scale - trailingZeros
+
+		// If all fractional digits are zeros, return just integer part.
+		if effectiveScale == 0 {
+			if pos+integerLen > len(buf) {
+				return d.Decimal.String()
+			}
+			copy(buf[pos:], str[:integerLen])
+			pos += integerLen
+			return string(buf[:pos])
+		}
+
+		required := integerLen + 1 + effectiveScale
 		if pos+required > len(buf) {
 			return d.Decimal.String()
 		}
 
+		// Integer part.
 		copy(buf[pos:], str[:integerLen])
 		pos += integerLen
 
+		// Decimal point.
 		buf[pos] = '.'
 		pos++
 
-		copy(buf[pos:], str[integerLen:])
-		pos += scale
+		// Fractional part without trailing zeros.
+		fractionalEnd := integerLen + effectiveScale
+		copy(buf[pos:], str[integerLen:fractionalEnd])
+		pos += effectiveScale
 	}
 
 	return string(buf[:pos])
 }
 func (d Decimal) handleMinInt64(scale int) string {
 	const minInt64Str = "9223372036854775808"
 
-	var buf [48]byte
+	var buf [64]byte
 	pos := 0
 
 	buf[pos] = '-'
@@ -259,19 +302,29 @@ func (d Decimal) handleMinInt64(scale int) string {
 
 	if scale == 0 {
 		if pos+length > len(buf) {
-			return "-" + minInt64Str // Fallback.
+			return "-" + minInt64Str
 		}
 		copy(buf[pos:], minInt64Str)
 		pos += length
 		return string(buf[:pos])
 	}
 
 	if scale >= length {
-		required := 2 + (scale - length) + length
+		// Count trailing zeros in the actual number part.
+		trailingZeros := 0
+		for i := length - 1; i >= 0 && minInt64Str[i] == '0'; i-- {
+			trailingZeros++
+		}
+
+		effectiveDigits := length - trailingZeros
+
+		if effectiveDigits == 0 {
+			return "0"
+		}
+
+		required := 2 + (scale - length) + effectiveDigits
 		if pos+required > len(buf) {
-			// Fallback.
-			result := "0." + strings.Repeat("0", scale-length) + minInt64Str
-			return "-" + result
+			return d.Decimal.String()
 		}
 
 		buf[pos] = '0'
@@ -284,13 +337,31 @@ func (d Decimal) handleMinInt64(scale int) string {
 			pos++
 		}
 
-		copy(buf[pos:], minInt64Str)
-		pos += length
+		copy(buf[pos:], minInt64Str[:effectiveDigits])
+		pos += effectiveDigits
 	} else {
 		integerLen := length - scale
-		required := integerLen + 1 + scale
+
+		// Count trailing zeros for minInt64Str fractional part.
+		trailingZeros := 0
+		for i := length - 1; i >= integerLen && minInt64Str[i] == '0'; i-- {
+			trailingZeros++
+		}
+
+		effectiveScale := scale - trailingZeros
+
+		if effectiveScale == 0 {
+			if pos+integerLen > len(buf) {
+				return d.Decimal.String()
+			}
+			copy(buf[pos:], minInt64Str[:integerLen])
+			pos += integerLen
+			return string(buf[:pos])
+		}
+
+		required := integerLen + 1 + effectiveScale
 		if pos+required > len(buf) {
-			return d.Decimal.String() // Fallback
+			return d.Decimal.String()
 		}
 
 		copy(buf[pos:], minInt64Str[:integerLen])
@@ -299,8 +370,9 @@ func (d Decimal) handleMinInt64(scale int) string {
 		buf[pos] = '.'
 		pos++
 
-		copy(buf[pos:], minInt64Str[integerLen:])
-		pos += scale
+		fractionalEnd := integerLen + effectiveScale
+		copy(buf[pos:], minInt64Str[integerLen:fractionalEnd])
+		pos += effectiveScale
 	}
 
 	return string(buf[:pos])

decimal/decimal_test.go

@@ -900,12 +900,12 @@ func TestDecimalTrailingZeros(t *testing.T) {
 		input    string
 		expected string
 	}{
-		{"100.00", "100.00"},
-		{"0.00", "0.00"},
-		{"0.000", "0.000"},
-		{"1.000", "1.000"},
-		{"123.4500", "123.4500"},
-		{"0.00100", "0.00100"},
+		{"100.00", "100"},
+		{"0.00", "0"},
+		{"0.000", "0"},
+		{"1.000", "1"},
+		{"123.4500", "123.45"},
+		{"0.00100", "0.001"},
 	}
 
 	for _, tt := range tests {