msgpack_ext: added string() function for decimal

 Added function for converting decimal type to string, added tests for this function. Fixed function name. Added test for decimal conversion. Added benchmark test confirming that using self-written function is faster than using function from library.

Added #322

Author: babyTsakhes

CHANGELOG.md

@@ -15,6 +15,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 * Added missing IPROTO feature flags to greeting negotiation
   (iproto.IPROTO_FEATURE_IS_SYNC, iproto.IPROTO_FEATURE_INSERT_ARROW) (#466).
 * Added Future.cond (sync.Cond) and Future.finished bool. Added Future.finish() marks Future as done (#496).
+* Added function String() for type datetime, decimal (#322).
 
 ### Changed
 

decimal/decimal.go

@@ -21,7 +21,9 @@ package decimal
 
 import (
 	"fmt"
+	"math"
 	"reflect"
+	"strconv"
 
 	"github.com/shopspring/decimal"
 	"github.com/vmihailenco/msgpack/v5"
@@ -96,7 +98,7 @@ func (d Decimal) MarshalMsgpack() ([]byte, error) {
 	//  +--------+-------------------+------------+===============+
 	//  | MP_EXT | length (optional) | MP_DECIMAL | PackedDecimal |
 	//  +--------+-------------------+------------+===============+
-	strBuf := d.String()
+	strBuf := d.Decimal.String()
 	bcdBuf, err := encodeStringToBCD(strBuf)
 	if err != nil {
 		return nil, fmt.Errorf("msgpack: can't encode string (%s) to a BCD buffer: %w", strBuf, err)
@@ -144,6 +146,247 @@ func decimalDecoder(d *msgpack.Decoder, v reflect.Value, extLen int) error {
 	return ptr.UnmarshalMsgpack(b)
 }
 
+// This method converts the decimal type to a string.
+// Use shopspring/decimal by default.
+// String - optimized version for Tarantool Decimal
+// taking into account the limitations of int64 and support for large numbers via fallback
+// Tarantool decimal has 38 digits, which can exceed int64.
+// Therefore, we cannot use int64 for all cases.
+// For the general case, use shopspring/decimal.String().
+// For cases where it is known that numbers contain less than 26 characters,
+// you can use the optimized version.
+func (d Decimal) String() string {
+	coefficient := d.Decimal.Coefficient() // Note: In shopspring/decimal
+	// the number is stored as coefficient *10^exponent,  where exponent can be negative.
+	exponent := d.Decimal.Exponent()
+
+	// If exponent is positive, then we use the standard method.
+	if exponent > 0 {
+		return d.Decimal.String()
+	}
+
+	scale := -exponent
+
+	if !coefficient.IsInt64() {
+		return d.Decimal.String()
+	}
+
+	int64Value := coefficient.Int64()
+
+	return d.stringFromInt64(int64Value, int(scale))
+}
+
+// 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 [64]byte
+	pos := 0
+
+	negative := value < 0
+	if negative {
+		if value == math.MinInt64 {
+			return d.handleMinInt64(scale)
+		}
+		buf[pos] = '-'
+		pos++
+		value = -value
+	}
+
+	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()
+		}
+		copy(buf[pos:], str)
+		pos += length
+		return string(buf[:pos])
+	}
+
+	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++
+		}
+
+		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()
+		}
+
+		buf[pos] = '0'
+		buf[pos+1] = '.'
+		pos += 2
+
+		// Add leading zeros.
+		zeros := scale - length
+		for i := 0; i < zeros; i++ {
+			buf[pos] = '0'
+			pos++
+		}
+
+		// Copy only significant digits (without trailing zeros).
+		copy(buf[pos:], str[:effectiveDigits])
+		pos += effectiveDigits
+	} else {
+		// Numbers like 123.45.
+		integerLen := length - 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++
+
+		// 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 [64]byte
+	pos := 0
+
+	buf[pos] = '-'
+	pos++
+
+	length := len(minInt64Str)
+
+	if scale == 0 {
+		if pos+length > len(buf) {
+			return "-" + minInt64Str
+		}
+		copy(buf[pos:], minInt64Str)
+		pos += length
+		return string(buf[:pos])
+	}
+
+	if scale >= 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) {
+			return d.Decimal.String()
+		}
+
+		buf[pos] = '0'
+		buf[pos+1] = '.'
+		pos += 2
+
+		zeros := scale - length
+		for i := 0; i < zeros; i++ {
+			buf[pos] = '0'
+			pos++
+		}
+
+		copy(buf[pos:], minInt64Str[:effectiveDigits])
+		pos += effectiveDigits
+	} else {
+		integerLen := length - 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()
+		}
+
+		copy(buf[pos:], minInt64Str[:integerLen])
+		pos += integerLen
+
+		buf[pos] = '.'
+		pos++
+
+		fractionalEnd := integerLen + effectiveScale
+		copy(buf[pos:], minInt64Str[integerLen:fractionalEnd])
+		pos += effectiveScale
+	}
+
+	return string(buf[:pos])
+}
+
+func MustMakeDecimal(src string) Decimal {
+	dec, err := MakeDecimalFromString(src)
+	if err != nil {
+		panic(fmt.Sprintf("MustMakeDecimalFromString: %v", err))
+	}
+	return dec
+}
+
 func init() {
 	msgpack.RegisterExtDecoder(decimalExtID, Decimal{}, decimalDecoder)
 	msgpack.RegisterExtEncoder(decimalExtID, Decimal{}, decimalEncoder)