msgpack_ext: added String() function for interval

Added function for converting interval type to string, added tests for
this function. Added test for decimal conversion.

Closes #322

Co-authored-by: Oleg Jukovec <oleg.jukovec@gmail.com>

Author: babyTsakhes

CHANGELOG.md

@@ -22,6 +22,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   to free used data directly by calling (#493).
 * Resources allocated for a `Future` object created by the `Connection` type
   could be released with the `Future.Release()` call.
+* Added function String() for type interval (#322).
 
 ### Changed
 

datetime/example_test.go

@@ -161,7 +161,7 @@ func ExampleDatetime_Interval() {
 	ival := dtFirst.Interval(dtSecond)
 	fmt.Printf("%v", ival)
 	// Output:
-	// {2 2 0 -11 0 -1 0 0 0}
+	// +2 years, 2 months, -11 days, -1 minute
 }
 
 // ExampleDatetime_Add demonstrates how to add an Interval to a Datetime value.
@@ -278,7 +278,7 @@ func ExampleInterval_Add() {
 
 	fmt.Printf("%v", ival)
 	// Output:
-	// {11 2 3 0 0 30 10 0 1}
+	// +11 years, 2 months, 3 weeks, 30 minutes, 10 seconds
 }
 
 // ExampleInterval_Sub demonstrates how to subtract two intervals.
@@ -298,5 +298,5 @@ func ExampleInterval_Sub() {
 
 	fmt.Printf("%v", ival)
 	// Output:
-	// {-9 2 3 0 0 -30 10 0 1}
+	// -9 years, 2 months, 3 weeks, -30 minutes, 10 seconds
 }

datetime/interval.go

@@ -2,7 +2,9 @@ package datetime
 
 import (
 	"bytes"
+	"fmt"
 	"reflect"
+	"strings"
 
 	"github.com/vmihailenco/msgpack/v5"
 )
@@ -216,6 +218,73 @@ func decodeInterval(d *msgpack.Decoder, v reflect.Value) (err error) {
 	return nil
 }
 
+// Returns a human-readable string representation of the interval.
+var intervalFields = [8]struct {
+	sing string
+	plur string
+}{
+	{"year", "years"},
+	{"month", "months"},
+	{"week", "weeks"},
+	{"day", "days"},
+	{"hour", "hours"},
+	{"minute", "minutes"},
+	{"second", "seconds"},
+	{"nanosecond", "nanoseconds"},
+}
+
+func (ival Interval) String() string {
+	values := [8]int64{
+		ival.Year,
+		ival.Month,
+		ival.Week,
+		ival.Day,
+		ival.Hour,
+		ival.Min,
+		ival.Sec,
+		ival.Nsec,
+	}
+
+	parts := make([]string, 0, 8)
+	first := true
+	hasNonZero := false
+
+	for i, field := range intervalFields {
+		value := values[i]
+		if value == 0 {
+			continue
+		}
+
+		hasNonZero = true
+		var sign string
+		var absValue int64
+
+		if value < 0 {
+			sign = "-"
+			absValue = -value
+		} else {
+			if first {
+				sign = "+"
+			}
+			absValue = value
+		}
+
+		unit := field.plur
+		if absValue == 1 {
+			unit = field.sing
+		}
+
+		parts = append(parts, fmt.Sprintf("%s%d %s", sign, absValue, unit))
+		first = false
+	}
+
+	if !hasNonZero {
+		return "0 seconds"
+	}
+
+	return strings.Join(parts, ", ")
+}
+
 func init() {
 	msgpack.RegisterExtEncoder(interval_extId, Interval{},
 		func(e *msgpack.Encoder, v reflect.Value) (ret []byte, err error) {

datetime/interval_test.go

@@ -10,6 +10,8 @@ import (
 	"github.com/tarantool/go-tarantool/v3/test_helpers"
 )
 
+var _ fmt.Stringer = Interval{}
+
 func TestIntervalAdd(t *testing.T) {
 	orig := Interval{
 		Year:   1,
@@ -133,3 +135,266 @@ func TestIntervalTarantoolEncoding(t *testing.T) {
 		})
 	}
 }
+
+func TestIntervalString(t *testing.T) {
+	tests := []struct {
+		name     string
+		interval Interval
+		expected string
+	}{
+		{
+			name:     "empty interval",
+			interval: Interval{},
+			expected: "0 seconds",
+		},
+		{
+			name: "single positive year",
+			interval: Interval{
+				Year: 1,
+			},
+			expected: "+1 year",
+		},
+		{
+			name: "single negative year",
+			interval: Interval{
+				Year: -1,
+			},
+			expected: "-1 year",
+		},
+		{
+			name: "multiple positive years",
+			interval: Interval{
+				Year: 5,
+			},
+			expected: "+5 years",
+		},
+		{
+			name: "multiple positive components",
+			interval: Interval{
+				Year:  1,
+				Month: 2,
+				Day:   3,
+			},
+			expected: "+1 year, 2 months, 3 days",
+		},
+		{
+			name: "positive components without sign after first",
+			interval: Interval{
+				Hour: 1,
+				Min:  30,
+				Sec:  45,
+			},
+			expected: "+1 hour, 30 minutes, 45 seconds",
+		},
+		{
+			name: "mixed signs",
+			interval: Interval{
+				Year:  -1,
+				Month: 2,
+				Week:  -3,
+				Day:   4,
+				Hour:  -5,
+				Min:   6,
+				Sec:   -7,
+				Nsec:  9,
+			},
+			expected: "-1 year, 2 months, -3 weeks, 4 days, -5 hours, 6 minutes," +
+				" -7 seconds, 9 nanoseconds",
+		},
+		{
+			name: "positive seconds with nanoseconds",
+			interval: Interval{
+				Sec:  5,
+				Nsec: 123456789,
+			},
+			expected: "+5 seconds, 123456789 nanoseconds",
+		},
+		{
+			name: "negative seconds with nanoseconds",
+			interval: Interval{
+				Sec:  -5,
+				Nsec: -123456789,
+			},
+			expected: "-5 seconds, -123456789 nanoseconds",
+		},
+		{
+			name: "only positive nanoseconds",
+			interval: Interval{
+				Nsec: 500000000,
+			},
+			expected: "+500000000 nanoseconds",
+		},
+		{
+			name: "only negative nanoseconds",
+			interval: Interval{
+				Nsec: -500000000,
+			},
+			expected: "-500000000 nanoseconds",
+		},
+		{
+			name: "complex interval",
+			interval: Interval{
+				Year:  1,
+				Month: 6,
+				Week:  2,
+				Day:   3,
+				Hour:  12,
+				Min:   30,
+				Sec:   45,
+				Nsec:  123456789,
+			},
+			expected: "+1 year, 6 months, 2 weeks, 3 days, 12 hours, 30 minutes," +
+				" 45 seconds, 123456789 nanoseconds",
+		},
+		{
+			name: "all negative components",
+			interval: Interval{
+				Year: -1,
+				Day:  -2,
+				Hour: -3,
+			},
+			expected: "-1 year, -2 days, -3 hours",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.interval.String()
+			if result != tt.expected {
+				t.Errorf("Interval.String() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+func TestIntervalString_WroksWithFmt(t *testing.T) {
+	ival := Interval{Hour: 2, Min: 30}
+	result := ival.String()
+	expected := "+2 hours, 30 minutes"
+	if result != expected {
+		t.Errorf("fmt.Sprintf('%%s') = %v, want %v", result, expected)
+	}
+
+	result = fmt.Sprintf("%v", ival)
+	if result != expected {
+		t.Errorf("fmt.Sprintf('%%v') = %v, want %v", result, expected)
+	}
+}
+
+func TestIntervalString_FromTarantool(t *testing.T) {
+	skipIfDatetimeUnsupported(t)
+
+	conn := test_helpers.ConnectWithValidation(t, dialer, opts)
+	defer conn.Close()
+
+	testCases := []struct {
+		luaExpr  string
+		expected string
+	}{
+		{
+			"return require('datetime').interval.new({})",
+			"0 seconds",
+		},
+		{
+			"return require('datetime').interval.new({year = 1})",
+			"+1 year",
+		},
+		{
+			"return require('datetime').interval.new({year = -1})",
+			"-1 year",
+		},
+		{
+			"return require('datetime').interval.new({year = 5})",
+			"+5 years",
+		},
+		{
+			"return require('datetime').interval.new({year = 1, month = 2, day = 3})",
+			"+1 year, 2 months, 3 days",
+		},
+		{
+			"return require('datetime').interval.new({hour = 1, min = 30, sec = 45})",
+			"+1 hour, 30 minutes, 45 seconds",
+		},
+		{
+			"return require('datetime').interval.new({year = -1, month = 2, week = -3, day = 4," +
+				" hour = -5, min = 6, sec = -7, nsec = 9})",
+			"-1 year, 2 months, -3 weeks, 4 days, -5 hours, 6 minutes, -7 seconds, 9 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({sec = 5, nsec = 123456789})",
+			"+5 seconds, 123456789 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({sec = -5, nsec = -123456789})",
+			"-5 seconds, -123456789 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({nsec = 500000000})",
+			"+500000000 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({nsec = -500000000})",
+			"-500000000 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({year = 1, month = 6, week = 2, day = 3," +
+				" hour = 12, min = 30, sec = 45, nsec = 123456789})",
+			"+1 year, 6 months, 2 weeks, 3 days, 12 hours, 30 minutes, 45 seconds," +
+				" 123456789 nanoseconds",
+		},
+		{
+			"return require('datetime').interval.new({year = -1, day = -2, hour = -3})",
+			"-1 year, -2 days, -3 hours",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.expected, func(t *testing.T) {
+			data, err := conn.Do(tarantool.NewEvalRequest(tc.luaExpr)).Get()
+			if err != nil {
+				t.Fatalf("Eval failed: %s", err)
+			}
+			if len(data) != 1 {
+				t.Fatalf("Expected 1 result, got %d", len(data))
+			}
+			ival, ok := data[0].(Interval)
+			if !ok {
+				t.Fatalf("Result is not Interval: %T", data[0])
+			}
+			if got := ival.String(); got != tc.expected {
+				t.Errorf("String() = %q, want %q", got, tc.expected)
+			}
+		})
+	}
+}
+
+func TestIntervalString_EdgeCases(t *testing.T) {
+	tests := []struct {
+		name     string
+		interval Interval
+	}{
+		{
+			name:     "max values",
+			interval: Interval{Year: 1<<63 - 1, Month: 1<<63 - 1},
+		},
+		{
+			name:     "min values",
+			interval: Interval{Year: -1 << 63, Month: -1 << 63},
+		},
+		{
+			name:     "mixed signs complex",
+			interval: Interval{Year: 1, Month: -1, Day: 1, Hour: -1},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.interval.String()
+			if result == "" {
+				t.Error("Interval.String() returned empty string")
+			}
+			if len(result) > 1000 {
+				t.Error("Interval.String() returned unexpectedly long string")
+			}
+		})
+	}
+}