moved precision time calculation

substrait-io · Jan 11, 2025 · f139052 · f139052
1 parent 363a610
commit f139052
Show file tree

Hide file tree

Showing 3 changed files with 65 additions and 42 deletions.
diff --git a/expr/literals.go b/expr/literals.go
@@ -25,7 +25,7 @@ import (
 // via ==
 type PrimitiveLiteralValue interface {
 	bool | int8 | int16 | ~int32 | ~int64 |
-	float32 | float64 | ~string
+		float32 | float64 | ~string
 }
 
 type nestedLiteral interface {
@@ -156,7 +156,7 @@ func (t *PrimitiveLiteral[T]) String() string {
 	return fmt.Sprintf("%s(%s)", t.Type.String(), t.ValueString())
 }
 func (t *PrimitiveLiteral[T]) ValueString() string {
-	if lit, ok := any(t.Value).(types.TimeConverter); ok {
+	if lit, ok := any(t.Value).(types.TimePrinter); ok {
 		return lit.ToTimeString()
 	}
 	return fmt.Sprintf("%v", t.Value)
@@ -450,42 +450,13 @@ type ProtoLiteral struct {
 	Type  types.Type
 }
 
-func timeFromPrecisionUnits(units int64, precision types.TimePrecision) time.Time {
-	var tm time.Time
-	switch precision {
-	case types.PrecisionSeconds:
-		tm = time.Unix(units, 0)
-	case types.PrecisionDeciSeconds:
-		tm = time.Unix(units/10, units%10*100000000)
-	case types.PrecisionCentiSeconds:
-		tm = time.Unix(units/100, units%100*10000000)
-	case types.PrecisionMilliSeconds:
-		tm = time.UnixMilli(units)
-	case types.PrecisionEMinus4Seconds:
-		tm = time.Unix(units/10000, units%10000*100000)
-	case types.PrecisionEMinus5Seconds:
-		tm = time.Unix(units/100000, units%100000*10000)
-	case types.PrecisionMicroSeconds:
-		tm = time.UnixMicro(units)
-	case types.PrecisionEMinus7Seconds:
-		tm = time.Unix(units/10000000, units%10000000*100)
-	case types.PrecisionEMinus8Seconds:
-		tm = time.Unix(units/100000000, units%100000000*10)
-	case types.PrecisionNanoSeconds:
-		tm = time.Unix(units/1000000000, units%1000000000)
-	default:
-		panic("unsupported precision")
-	}
-	return tm
-}
-
 func (t *ProtoLiteral) ValueString() string {
 	switch literalType := t.Type.(type) {
 	case *types.PrecisionTimestampType:
-		tm := timeFromPrecisionUnits(t.Value.(int64), literalType.Precision)
+		tm := types.Timestamp(t.Value.(int64)).ToPrecisionTime(literalType.Precision)
 		return tm.UTC().Format("2006-01-02 15:04:05.999999999")
 	case *types.PrecisionTimestampTzType:
-		tm := timeFromPrecisionUnits(t.Value.(int64), literalType.Precision)
+		tm := types.TimestampTz(t.Value.(int64)).ToPrecisionTime(literalType.Precision)
 		return tm.UTC().Format(time.RFC3339Nano)
 	case *types.DecimalType:
 		return decimalBytesToString([16]byte(t.Value.([]byte)), literalType.Scale)
@@ -610,7 +581,7 @@ func getNullability(nullable bool) types.Nullability {
 
 type newPrimitiveLiteralTypes interface {
 	bool | int8 | int16 | ~int32 | ~int64 |
-	float32 | float64 | string
+		float32 | float64 | string
 }
 
 func NewPrimitiveLiteral[T newPrimitiveLiteralTypes](val T, nullable bool) Literal {
@@ -722,9 +693,9 @@ func NewFixedBinaryLiteral(val types.FixedBinary, nullable bool) *ByteSliceLiter
 
 type allLiteralTypes interface {
 	PrimitiveLiteralValue | nestedLiteral | MapLiteralValue |
-	[]byte | types.UUID | types.FixedBinary | *types.IntervalYearToMonth |
-	*types.IntervalDayToSecond | *types.VarChar | *types.Decimal | *types.UserDefinedLiteral |
-	*types.PrecisionTimestamp | *types.PrecisionTimestampTz
+		[]byte | types.UUID | types.FixedBinary | *types.IntervalYearToMonth |
+		*types.IntervalDayToSecond | *types.VarChar | *types.Decimal | *types.UserDefinedLiteral |
+		*types.PrecisionTimestamp | *types.PrecisionTimestampTz
 }
 
 func NewLiteral[T allLiteralTypes](val T, nullable bool) (Literal, error) {

diff --git a/expr/string_test.go b/expr/string_test.go
@@ -74,7 +74,7 @@ func TestLiteralToValueString(t *testing.T) {
 		{literal.NewString("99.30"), "99.30"},
 		{MustLiteral(literal.NewDate(365)), "1971-01-01"},
 		{MustLiteral(literal.NewTimeFromString("12:34:56")), "12:34:56"},
-		{MustLiteral(literal.NewTimestampFromString("2021-03-05T12:34:56")), "2021-03-05T12:34:56Z"},
+		{MustLiteral(literal.NewTimestampFromString("2021-03-05T12:34:56")), "2021-03-05 12:34:56"},
 		{MustLiteral(literal.NewTimestampTZFromString("2021-03-05T12:34:56")), "2021-03-05T12:34:56Z"},
 		// Test the first implementation.
 		{MustLiteral(literal.NewIntervalYearsToMonth(5, 4)), "5 years, 4 months"},

diff --git a/types/types.go b/types/types.go
@@ -389,6 +389,13 @@ type (
 	}
 
 	TimeConverter interface {
+		// ToTime converts the current value into a time.Time assuming microsecond precision.
+		ToTime() time.Time
+		// ToPrecisionTime converts the current value using the provided precision into a time.Time.
+		ToPrecisionTime(precision TimePrecision) time.Time
+	}
+
+	TimePrinter interface {
 		// ToTimeString returns a human consumable version of the current value.
 		ToTimeString() string
 	}
@@ -1560,17 +1567,62 @@ func (d Date) ToTimeString() string {
 	return date.String()
 }
 
+func timeFromPrecisionUnits(units int64, precision TimePrecision) time.Time {
+	var tm time.Time
+	switch precision {
+	case PrecisionSeconds:
+		tm = time.Unix(units, 0)
+	case PrecisionDeciSeconds:
+		tm = time.Unix(units/10, units%10*100000000)
+	case PrecisionCentiSeconds:
+		tm = time.Unix(units/100, units%100*10000000)
+	case PrecisionMilliSeconds:
+		tm = time.UnixMilli(units)
+	case PrecisionEMinus4Seconds:
+		tm = time.Unix(units/10000, units%10000*100000)
+	case PrecisionEMinus5Seconds:
+		tm = time.Unix(units/100000, units%100000*10000)
+	case PrecisionMicroSeconds:
+		tm = time.UnixMicro(units)
+	case PrecisionEMinus7Seconds:
+		tm = time.Unix(units/10000000, units%10000000*100)
+	case PrecisionEMinus8Seconds:
+		tm = time.Unix(units/100000000, units%100000000*10)
+	case PrecisionNanoSeconds:
+		tm = time.Unix(units/1000000000, units%1000000000)
+	default:
+		panic("unsupported precision")
+	}
+	return tm
+}
+
 func (t Time) ToTimeString() string {
 	tm := time.UnixMicro(int64(t))
 	return tm.UTC().Format(time.TimeOnly)
 }
 
+func (t Timestamp) ToTime() time.Time {
+	return time.UnixMicro(int64(t))
+}
+
+func (t Timestamp) ToPrecisionTime(precision TimePrecision) time.Time {
+	return timeFromPrecisionUnits(int64(t), precision)
+}
+
 func (t Timestamp) ToTimeString() string {
-	tm := time.UnixMicro(int64(t))
-	return tm.UTC().Format(time.RFC3339)
+	tm := any(t).(TimeConverter).ToTime()
+	return tm.UTC().Format("2006-01-02 15:04:05.999999999")
+}
+
+func (t TimestampTz) ToTime() time.Time {
+	return time.UnixMicro(int64(t))
+}
+
+func (t TimestampTz) ToPrecisionTime(precision TimePrecision) time.Time {
+	return timeFromPrecisionUnits(int64(t), precision)
 }
 
 func (t TimestampTz) ToTimeString() string {
-	tm := time.UnixMicro(int64(t))
-	return tm.UTC().Format(time.RFC3339)
+	tm := any(t).(TimeConverter).ToTime()
+	return tm.UTC().Format(time.RFC3339Nano)
 }