msgpack: add string() for decimal

Added a decimal type conversion function to a string, added tests for this function.

Added #322

Author: babyTsakhes

decimal/decimal.go

@@ -21,7 +21,10 @@ package decimal
 
 import (
 	"fmt"
+	"math"
 	"reflect"
+	"strconv"
+	"strings"
 
 	"github.com/shopspring/decimal"
 	"github.com/vmihailenco/msgpack/v5"
@@ -144,6 +147,145 @@ 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.
+// StringOptimized - 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 [32]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)
+
+	if scale == 0 {
+		copy(buf[pos:], str)
+		pos += length
+		return string(buf[:pos])
+	}
+
+	if scale >= length {
+		buf[pos] = '0'
+		buf[pos+1] = '.'
+		pos += 2
+
+		zeros := scale - length
+		for i := 0; i < zeros; i++ {
+			buf[pos] = '0'
+			pos++
+		}
+
+		copy(buf[pos:], str)
+		pos += length
+	} else {
+		integerLen := length - scale
+		copy(buf[pos:], str[:integerLen])
+		pos += integerLen
+
+		fractionalPart := str[integerLen:]
+
+		fractionalPart = strings.TrimRight(fractionalPart, "0")
+
+		if len(fractionalPart) > 0 {
+			buf[pos] = '.'
+			pos++
+			copy(buf[pos:], fractionalPart)
+			pos += len(fractionalPart)
+		}
+	}
+
+	return string(buf[:pos])
+}
+
+func (d Decimal) handleMinInt64(scale int) string {
+
+	const minInt64Str = "9223372036854775808"
+
+	if scale == 0 {
+		return "-" + minInt64Str
+	}
+
+	var buf [32]byte
+	pos := 0
+
+	buf[pos] = '-'
+	pos++
+
+	length := len(minInt64Str)
+
+	if scale >= length {
+		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)
+		pos += length
+	} else {
+		integerLen := length - scale
+		copy(buf[pos:], minInt64Str[:integerLen])
+		pos += integerLen
+
+		buf[pos] = '.'
+		pos++
+
+		copy(buf[pos:], minInt64Str[integerLen:])
+		pos += scale
+	}
+
+	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)

decimal/decimal_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/assert"
 	"github.com/vmihailenco/msgpack/v5"
 
 	. "github.com/tarantool/go-tarantool/v3"
@@ -701,3 +702,154 @@ func TestMain(m *testing.M) {
 	code := runTestMain(m)
 	os.Exit(code)
 }
+
+func TestDecimalStringOptimized(t *testing.T) {
+	tests := []struct {
+		name             string
+		input            string
+		expected         string
+		willUseOptimized bool
+	}{
+		{
+			name:             "small positive decimal",
+			input:            "123.45",
+			expected:         "123.45",
+			willUseOptimized: true,
+		},
+		{
+			name:             "small negative decimal",
+			input:            "-123.45",
+			expected:         "-123.45",
+			willUseOptimized: true,
+		},
+		{
+			name:             "zero",
+			input:            "0",
+			expected:         "0",
+			willUseOptimized: true,
+		},
+		{
+			name:             "integer",
+			input:            "12345",
+			expected:         "12345",
+			willUseOptimized: true,
+		},
+		{
+			name:             "small decimal with leading zeros",
+			input:            "0.00123",
+			expected:         "0.00123",
+			willUseOptimized: true,
+		},
+		{
+			name:             "max int64",
+			input:            "9223372036854775807",
+			expected:         "9223372036854775807",
+			willUseOptimized: true,
+		},
+		{
+			name:             "min int64",
+			input:            "-9223372036854775808",
+			expected:         "-9223372036854775808",
+			willUseOptimized: true,
+		},
+		{
+			name:     "number beyond int64 range",
+			input:    "9223372036854775808",
+			expected: "9223372036854775808",
+		},
+		{
+			name:             "very large decimal",
+			input:            "123456789012345678901234567890.123456789",
+			expected:         "123456789012345678901234567890.123456789",
+			willUseOptimized: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dec, err := MakeDecimalFromString(tt.input)
+			assert.NoError(t, err)
+
+			result := dec.String()
+
+			assert.Equal(t, tt.expected, result)
+
+			assert.Equal(t, dec.Decimal.String(), result)
+		})
+	}
+}
+
+func TestTarantoolBCDCompatibility(t *testing.T) {
+
+	testCases := []string{
+		"123.45",
+		"-123.45",
+		"0.001",
+		"100.00",
+		"999999.999999",
+	}
+
+	for _, input := range testCases {
+		t.Run(input, func(t *testing.T) {
+
+			dec, err := MakeDecimalFromString(input)
+			assert.NoError(t, err)
+
+			msgpackData, err := dec.MarshalMsgpack()
+			assert.NoError(t, err)
+
+			var dec2 Decimal
+			err = dec2.UnmarshalMsgpack(msgpackData)
+			assert.NoError(t, err)
+
+			originalStr := dec.String()
+			roundtripStr := dec2.String()
+
+			assert.Equal(t, originalStr, roundtripStr,
+				"BCD roundtrip failed for input: %s", input)
+		})
+	}
+}
+
+func TestRealTarantoolUsage(t *testing.T) {
+
+	operations := []struct {
+		name string
+		data map[string]interface{}
+	}{
+		{
+			name: "insert operation",
+			data: map[string]interface{}{
+				"id":      1,
+				"amount":  MustMakeDecimal("123.45"),
+				"balance": MustMakeDecimal("-500.00"),
+			},
+		},
+		{
+			name: "update operation",
+			data: map[string]interface{}{
+				"id":       2,
+				"price":    MustMakeDecimal("99.99"),
+				"quantity": MustMakeDecimal("1000.000"),
+			},
+		},
+	}
+
+	for _, op := range operations {
+		t.Run(op.name, func(t *testing.T) {
+
+			for key, value := range op.data {
+				if dec, isDecimal := value.(Decimal); isDecimal {
+					str := dec.String()
+
+					assert.NotEmpty(t, str)
+					assert.Contains(t, []string{".", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-"}, string(str[0]))
+
+					assert.Equal(t, dec.Decimal.String(), str)
+
+					t.Logf("%s: %s", key, str)
+				}
+			}
+		})
+	}
+}