feat(serial): add support for passing time.Duration

trinodb · Sep 12, 2024 · 06334b1 · 06334b1
1 parent 806af86
commit 06334b1
Show file tree

Hide file tree

Showing 3 changed files with 156 additions and 2 deletions.
diff --git a/README.md b/README.md
@@ -262,11 +262,11 @@ types:
   passed to Trino as a time with a time zone
 * the result of `trino.Timestamp(year, month, day, hour, minute, second,
   nanosecond)` - passed to Trino as a timestamp without a time zone
+* `time.Duration` - passed to Trino as an interval day to second (precision can be lost for very large durations)
 
 It's not yet possible to pass:
 * `float32` or `float64`
 * `byte`
-* `time.Duration`
 * `json.RawMessage`
 * maps
 

diff --git a/trino/serial.go b/trino/serial.go
@@ -163,7 +163,7 @@ func Serial(v interface{}) (string, error) {
 		return "TIMESTAMP " + time.Time(x).Format("'2006-01-02 15:04:05.999999999 Z07:00'"), nil
 
 	case time.Duration:
-		return "", UnsupportedArgError{"time.Duration"}
+		return serialDuration(x), nil
 
 		// TODO - json.RawMesssage should probably be matched to 'JSON' in Trino
 	case json.RawMessage:
@@ -208,3 +208,66 @@ func serialSlice(v []interface{}) (string, error) {
 
 	return "ARRAY[" + strings.Join(ss, ", ") + "]", nil
 }
+
+const (
+	// The trino interval string seems to support nr up to certain values
+	// These where safe on trino 454
+	minIntervalValue = -2099999999
+	maxIntervalValue = 2099999999
+	// for seconds with milliseconds there seems to just be a max nr of digits
+	maxIntervalStrLenWithDot        = 11 // 123456789.1 and 12345678.91 are valid
+	maxIntervalStrLenWithDotAndSign = 12 // -123456789.1 and -12345678.91 are valid
+)
+
+func serialDuration(dur time.Duration) string {
+	millisDur := dur.Milliseconds()
+	if millisDur%(60*60*1000) == 0 { // hours
+		return serialHoursInterval(millisDur / 60 / 60 / 1000)
+	} else if millisDur%(60*1000) == 0 { // minutes
+		return serialMinutesInterval(millisDur / 60 / 1000)
+	} else if millisDur%(1000) == 0 { // seconds
+		return serialSecondsInterval(millisDur / 1000)
+	} else { // milliseconds
+		return serialMillisecondsInterval(millisDur)
+	}
+}
+
+func serialHoursInterval(nrOfHours int64) string {
+	// no need for check, can not be > 2099999999 or < -2099999999 hours are outside of time.Duration range
+	return "INTERVAL '" + strconv.FormatInt(nrOfHours, 10) + "' HOUR"
+}
+
+func serialMinutesInterval(nrOfMinutes int64) string {
+	// no need for check, can not be > 2099999999 or < -2099999999 minutes are outside of time.Duration range
+	return "INTERVAL '" + strconv.FormatInt(nrOfMinutes, 10) + "' MINUTE"
+}
+
+func serialSecondsInterval(nrOfSeconds int64) string {
+	if nrOfSeconds < minIntervalValue || nrOfSeconds > maxIntervalValue {
+		if nrOfSeconds >= 0 {
+			return serialMinutesInterval((nrOfSeconds + 30) / 60) // round to minutes
+		} else {
+			return serialMinutesInterval((nrOfSeconds - 30) / 60)
+		}
+	}
+	return "INTERVAL '" + strconv.FormatInt(nrOfSeconds, 10) + "' SECOND"
+}
+
+func serialMillisecondsInterval(nrOfMillis int64) string {
+	intervalNr := strconv.FormatInt(nrOfMillis/1000, 10) + "."
+	if nrOfMillis < 0 {
+		intervalNr += fmt.Sprintf("%03d", -(nrOfMillis % 1000))
+	} else {
+		intervalNr += fmt.Sprintf("%03d", nrOfMillis%1000)
+	}
+	intervalNr = strings.TrimRight(intervalNr, "0")
+	if nrOfMillis < 0 && len(intervalNr) > maxIntervalStrLenWithDotAndSign ||
+		nrOfMillis > 0 && len(intervalNr) > maxIntervalStrLenWithDot {
+		if nrOfMillis >= 0 {
+			return serialSecondsInterval((nrOfMillis + 500) / 1000) // round to seconds
+		} else {
+			return serialSecondsInterval((nrOfMillis - 500) / 1000)
+		}
+	}
+	return "INTERVAL '" + intervalNr + "' SECOND"
+}
diff --git a/trino/serial_test.go b/trino/serial_test.go
@@ -15,6 +15,7 @@
 package trino
 
 import (
+	"math"
 	"testing"
 	"time"
 
@@ -160,6 +161,96 @@ func TestSerial(t *testing.T) {
 			value:          time.Date(2017, 7, 10, 11, 34, 25, 123456, time.UTC),
 			expectedSerial: "TIMESTAMP '2017-07-10 11:34:25.000123456 Z'",
 		},
+		{
+			name:           "duration",
+			value:          10*time.Second + 5*time.Millisecond,
+			expectedSerial: "INTERVAL '10.005' SECOND",
+		},
+		{
+			name:           "duration with negative value",
+			value:          -(10*time.Second + 5*time.Millisecond),
+			expectedSerial: "INTERVAL '-10.005' SECOND",
+		},
+		{
+			name:           "minute duration",
+			value:          10 * time.Minute,
+			expectedSerial: "INTERVAL '10' MINUTE",
+		},
+		{
+			name:           "hour duration",
+			value:          23 * time.Hour,
+			expectedSerial: "INTERVAL '23' HOUR",
+		},
+		{
+			name:           "max hour duration",
+			value:          (math.MaxInt64 / time.Hour) * time.Hour,
+			expectedSerial: "INTERVAL '2562047' HOUR",
+		},
+		{
+			name:           "min hour duration",
+			value:          (math.MinInt64 / time.Hour) * time.Hour,
+			expectedSerial: "INTERVAL '-2562047' HOUR",
+		},
+		{
+			name:           "max minute duration",
+			value:          (math.MaxInt64 / time.Minute) * time.Minute,
+			expectedSerial: "INTERVAL '153722867' MINUTE",
+		},
+		{
+			name:           "min minute duration",
+			value:          (math.MinInt64 / time.Minute) * time.Minute,
+			expectedSerial: "INTERVAL '-153722867' MINUTE",
+		},
+		{
+			name:           "too big second duration",
+			value:          (math.MaxInt64 / time.Second) * time.Second,
+			expectedSerial: "INTERVAL '153722867' MINUTE",
+		},
+		{
+			name:           "too small second duration",
+			value:          (math.MinInt64 / time.Second) * time.Second,
+			expectedSerial: "INTERVAL '-153722867' MINUTE",
+		},
+		{
+			name:           "too big millisecond duration rounds to seconds",
+			value:          time.Millisecond*912 + time.Second*12345678,
+			expectedSerial: "INTERVAL '12345679' SECOND",
+		},
+		{
+			name:           "too small millisecond duration rounds to seconds",
+			value:          -(time.Millisecond*910 + time.Second*123456789),
+			expectedSerial: "INTERVAL '-123456790' SECOND",
+		},
+		{
+			name:           "max duration",
+			value:          time.Duration(math.MaxInt64),
+			expectedSerial: "INTERVAL '153722867' MINUTE",
+		},
+		{
+			name:           "min duration",
+			value:          time.Duration(math.MinInt64),
+			expectedSerial: "INTERVAL '-153722867' MINUTE",
+		},
+		{
+			name:           "max allowed second duration",
+			value:          maxIntervalValue * time.Second,
+			expectedSerial: "INTERVAL '2099999999' SECOND",
+		},
+		{
+			name:           "min allowed second duration",
+			value:          minIntervalValue * time.Second,
+			expectedSerial: "INTERVAL '-2099999999' SECOND",
+		},
+		{
+			name:           "max allowed second with milliseconds duration",
+			value:          999999999*time.Second + 900*time.Millisecond,
+			expectedSerial: "INTERVAL '999999999.9' SECOND",
+		},
+		{
+			name:           "min allowed second with milliseconds duration",
+			value:          -999999999*time.Second - 900*time.Millisecond,
+			expectedSerial: "INTERVAL '-999999999.9' SECOND",
+		},
 		{
 			name:           "nil",
 			value:          nil,