feat: add ValueString() to all literal types (#102)

Adds the functionality QueryString() functionality requested in #100 .

expr/builder_test.go

@@ -29,8 +29,8 @@ func TestExprBuilder(t *testing.T) {
 		err      string
 	}{
 		{"literal", "i8?(5)", b.Wrap(expr.NewLiteral(int8(5), true)), ""},
-		{"preciseTimeStampliteral", "precisiontimestamp?<3>(123456)", b.Wrap(expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), nil), ""},
-		{"preciseTimeStampTzliteral", "precisiontimestamptz?<6>(123456)", b.Wrap(expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), nil), ""},
+		{"preciseTimeStampliteral", "precisiontimestamp?<3>(1970-01-01 00:02:03.456)", b.Wrap(expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), nil), ""},
+		{"preciseTimeStampTzliteral", "precisiontimestamptz?<6>(1970-01-01T00:00:00.123456Z)", b.Wrap(expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), nil), ""},
 		{"simple add", "add(.field(1) => i8, i8(5)) => i8?",
 			b.ScalarFunc(addID).Args(
 				b.RootRef(expr.NewStructFieldRef(1)),
@@ -64,7 +64,7 @@ func TestExprBuilder(t *testing.T) {
 			b.WindowFunc(rankID), "invalid expression: non-decomposable window or agg function '{https://github.com/substrait-io/substrait/blob/main/extensions/functions_arithmetic.yaml rank}' must use InitialToResult phase"},
 		{"window func", "rank(; phase: AGGREGATION_PHASE_INITIAL_TO_RESULT, invocation: AGGREGATION_INVOCATION_UNSPECIFIED) => i64?",
 			b.WindowFunc(rankID).Phase(types.AggPhaseInitialToResult), ""},
-		{"nested funcs", "add(extract(YEAR, date(10957)) => i64, rank(; phase: AGGREGATION_PHASE_INITIAL_TO_RESULT, invocation: AGGREGATION_INVOCATION_ALL) => i64?) => i64?",
+		{"nested funcs", "add(extract(YEAR, date(2000-01-01)) => i64, rank(; phase: AGGREGATION_PHASE_INITIAL_TO_RESULT, invocation: AGGREGATION_INVOCATION_ALL) => i64?) => i64?",
 			b.ScalarFunc(addID).Args(
 				b.ScalarFunc(extractID).Args(b.Enum("YEAR"),
 					b.Wrap(expr.NewLiteral(types.Date(10957), false))),

expr/interval_compound_literal.go

@@ -90,8 +90,11 @@ func intervalCompoundLiteralFromProto(l *proto.Expression_Literal) Literal {
 func (IntervalCompoundLiteral) isRootRef()            {}
 func (m IntervalCompoundLiteral) GetType() types.Type { return m.getType() }
 func (m IntervalCompoundLiteral) String() string {
-	return fmt.Sprintf("%s(years:%d,months:%d, days:%d, seconds:%d subseconds:%d)",
-		m.getType(), m.Years, m.Months, m.Days, m.Seconds, m.SubSeconds)
+	return fmt.Sprintf("%s(%s)", m.getType(), m.ValueString())
+}
+func (m IntervalCompoundLiteral) ValueString() string {
+	return fmt.Sprintf("%d years, %d months, %d days, %d seconds, %d subseconds",
+		m.Years, m.Months, m.Days, m.Seconds, m.SubSeconds)
 }
 func (m IntervalCompoundLiteral) Equals(rhs Expression) bool {
 	if other, ok := rhs.(IntervalCompoundLiteral); ok {

expr/interval_year_to_month.go

@@ -49,7 +49,10 @@ func intervalYearToMonthLiteralFromProto(l *proto.Expression_Literal) Literal {
 func (IntervalYearToMonthLiteral) isRootRef()            {}
 func (m IntervalYearToMonthLiteral) GetType() types.Type { return m.getType() }
 func (m IntervalYearToMonthLiteral) String() string {
-	return fmt.Sprintf("%s(years:%d,months:%d)", m.getType(), m.Years, m.Months)
+	return fmt.Sprintf("%s(%s)", m.getType(), m.ValueString())
+}
+func (m IntervalYearToMonthLiteral) ValueString() string {
+	return fmt.Sprintf("%d years, %d months", m.Years, m.Months)
 }
 func (m IntervalYearToMonthLiteral) Equals(rhs Expression) bool {
 	if other, ok := rhs.(IntervalYearToMonthLiteral); ok {

expr/literals.go

@@ -6,9 +6,13 @@ package expr
 
 import (
 	"bytes"
+	"encoding/hex"
 	"fmt"
 	"reflect"
+	"strings"
+	"time"
 
+	"github.com/google/uuid"
 	substraitgo "github.com/substrait-io/substrait-go/v3"
 	"github.com/substrait-io/substrait-go/v3/proto"
 	"github.com/substrait-io/substrait-go/v3/types"
@@ -84,6 +88,8 @@ type Literal interface {
 	ToProto() *proto.Expression
 	ToProtoLiteral() *proto.Expression_Literal
 	Visit(VisitFunc) Expression
+	// ValueString returns a human presentable representation of just the literal's value.
+	ValueString() string
 }
 
 // A NullLiteral is a typed null, so it just contains its type
@@ -101,6 +107,9 @@ func (*NullLiteral) isRootRef() {}
 func (n *NullLiteral) String() string {
 	return "null(" + n.Type.String() + ")"
 }
+func (n *NullLiteral) ValueString() string {
+	return "null"
+}
 
 func (n *NullLiteral) GetType() types.Type { return n.Type }
 func (n *NullLiteral) ToProtoLiteral() *proto.Expression_Literal {
@@ -144,7 +153,13 @@ type PrimitiveLiteral[T PrimitiveLiteralValue] struct {
 
 func (*PrimitiveLiteral[T]) isRootRef() {}
 func (t *PrimitiveLiteral[T]) String() string {
-	return fmt.Sprintf("%s(%v)", t.Type, t.Value)
+	return fmt.Sprintf("%s(%s)", t.Type.String(), t.ValueString())
+}
+func (t *PrimitiveLiteral[T]) ValueString() string {
+	if lit, ok := any(t.Value).(types.TimePrinter); ok {
+		return lit.ToTimeString()
+	}
+	return fmt.Sprintf("%v", t.Value)
 }
 func (t *PrimitiveLiteral[T]) GetType() types.Type { return t.Type }
 func (t *PrimitiveLiteral[T]) ToProtoLiteral() *proto.Expression_Literal {
@@ -220,6 +235,17 @@ func (*NestedLiteral[T]) isRootRef() {}
 func (t *NestedLiteral[T]) String() string {
 	return fmt.Sprintf("%s(%v)", t.Type, t.Value)
 }
+func (t *NestedLiteral[T]) ValueString() string {
+	switch x := any(t.Value).(type) {
+	case ListLiteralValue:
+		var items []string
+		for _, item := range x {
+			items = append(items, item.ValueString())
+		}
+		return fmt.Sprintf("[%s]", strings.Join(items, ", "))
+	}
+	return fmt.Sprintf("%v", t.Value)
+}
 func (t *NestedLiteral[T]) GetType() types.Type { return t.Type }
 func (t *NestedLiteral[T]) ToProtoLiteral() *proto.Expression_Literal {
 	lit := &proto.Expression_Literal{
@@ -291,7 +317,10 @@ type MapLiteral struct {
 
 func (*MapLiteral) isRootRef() {}
 func (t *MapLiteral) String() string {
-	return fmt.Sprintf("%s(%v)", t.Type, t.Value)
+	return fmt.Sprintf("%s(%s)", t.Type, t.ValueString())
+}
+func (t *MapLiteral) ValueString() string {
+	return fmt.Sprintf("%v", t.Value)
 }
 func (t *MapLiteral) GetType() types.Type { return t.Type }
 func (t *MapLiteral) ToProtoLiteral() *proto.Expression_Literal {
@@ -344,7 +373,7 @@ func (t *MapLiteral) ToProtoFuncArg() *proto.FunctionArgument {
 func (t *MapLiteral) Visit(VisitFunc) Expression { return t }
 func (*MapLiteral) IsScalar() bool               { return true }
 
-// ByteSliceLiteral is any literal that is represnted as a byte slice.
+// ByteSliceLiteral is any literal that is represented as a byte slice.
 // As opposed to a string literal which can be compared with ==, a byte
 // slice needs to use something like bytes.Equal
 type ByteSliceLiteral[T ~[]byte] struct {
@@ -354,8 +383,23 @@ type ByteSliceLiteral[T ~[]byte] struct {
 
 func (*ByteSliceLiteral[T]) isRootRef() {}
 func (t *ByteSliceLiteral[T]) String() string {
-	return fmt.Sprintf("%s(%v)", t.Type, t.Value)
+	return fmt.Sprintf("%s(%s)", t.Type, t.ValueString())
 }
+func (t *ByteSliceLiteral[T]) ValueString() string {
+	switch x := any(t.Value).(type) {
+	case types.UUID:
+		u, err := uuid.FromBytes(x[:])
+		if err != nil {
+			return fmt.Sprintf("%v", t.Value)
+		}
+		return u.String()
+	case types.FixedBinary:
+		return "0x" + hex.EncodeToString(x[:])
+	default:
+		return fmt.Sprintf("%v", t.Value)
+	}
+}
+
 func (t *ByteSliceLiteral[T]) GetType() types.Type { return t.Type }
 func (t *ByteSliceLiteral[T]) ToProtoLiteral() *proto.Expression_Literal {
 	lit := &proto.Expression_Literal{
@@ -408,19 +452,34 @@ type ProtoLiteral struct {
 
 func (t *ProtoLiteral) ValueString() string {
 	switch literalType := t.Type.(type) {
-	case *types.PrecisionTimestampType, *types.PrecisionTimestampTzType:
-		return fmt.Sprintf("%d", t.Value)
+	case *types.PrecisionTimestampType:
+		tm := types.Timestamp(t.Value.(int64)).ToPrecisionTime(literalType.Precision)
+		return tm.UTC().Format("2006-01-02 15:04:05.999999999")
+	case *types.PrecisionTimestampTzType:
+		tm := types.TimestampTz(t.Value.(int64)).ToPrecisionTime(literalType.Precision)
+		return tm.UTC().Format(time.RFC3339Nano)
 	case *types.DecimalType:
-		decBytes, _ := t.Value.([]byte)
-		return decimalBytesToString([16]byte(decBytes), literalType.Scale)
+		return decimalBytesToString([16]byte(t.Value.([]byte)), literalType.Scale)
+	case *types.IntervalYearType:
+		x, _ := t.Value.(*proto.Expression_Literal_IntervalYearToMonth)
+		// Validity is required by construction.
+		return fmt.Sprintf("%d years, %d months", x.GetYears(), x.GetMonths())
+	case *types.IntervalDayType:
+		x, _ := t.Value.(*proto.Expression_Literal_IntervalDayToSecond)
+		// Validity is required by construction.
+		return fmt.Sprintf("%d days, %d seconds, %d subseconds", x.GetDays(), x.GetSeconds(), x.GetSubseconds())
 	}
 	return fmt.Sprintf("%s", t.Value)
 }
 
 func (*ProtoLiteral) isRootRef()            {}
 func (t *ProtoLiteral) GetType() types.Type { return t.Type }
 func (t *ProtoLiteral) String() string {
-	return fmt.Sprintf("%s(%s)", t.GetType(), t.ValueString())
+	switch literalType := t.Type.(type) {
+	case *types.PrecisionTimestampType, *types.PrecisionTimestampTzType:
+		return fmt.Sprintf("%s(%s)", literalType, t.ValueString())
+	}
+	return fmt.Sprintf("%s(%s)", t.Type, t.ValueString())
 }
 func (t *ProtoLiteral) ToProtoLiteral() *proto.Expression_Literal {
 	lit := &proto.Expression_Literal{

expr/string_test.go

@@ -39,14 +39,14 @@ func TestLiteralToString(t *testing.T) {
 		}, true), "list?<map?<string, char<3>>>([map?<string, char<3>>([{string(foo) char<3>(bar)} {string(baz) char<3>(bar)}])])"},
 		{MustLiteral(expr.NewLiteral(float32(1.5), false)), "fp32(1.5)"},
 		{MustLiteral(expr.NewLiteral(&types.VarChar{Value: "foobar", Length: 7}, true)), "varchar?<7>(foobar)"},
-		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "precisiontimestamp?<0>(123456)"},
-		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "precisiontimestamp?<3>(123456)"},
-		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "precisiontimestamp?<6>(123456)"},
-		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "precisiontimestamp?<9>(123456)"},
-		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "precisiontimestamptz?<0>(123456)"},
-		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "precisiontimestamptz?<3>(123456)"},
-		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "precisiontimestamptz?<6>(123456)"},
-		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "precisiontimestamptz?<9>(123456)"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "precisiontimestamp?<0>(1970-01-02 10:17:36)"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "precisiontimestamp?<3>(1970-01-01 00:02:03.456)"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "precisiontimestamp?<6>(1970-01-01 00:00:00.123456)"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "precisiontimestamp?<9>(1970-01-01 00:00:00.000123456)"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "precisiontimestamptz?<0>(1970-01-02T10:17:36Z)"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "precisiontimestamptz?<3>(1970-01-01T00:02:03.456Z)"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "precisiontimestamptz?<6>(1970-01-01T00:00:00.123456Z)"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "precisiontimestamptz?<9>(1970-01-01T00:00:00.000123456Z)"},
 		{MustLiteral(literal.NewDecimalFromString("12.345")), "decimal<5,3>(12.345)"},
 		{MustLiteral(literal.NewDecimalFromString("-12.345")), "decimal<5,3>(-12.345)"},
 	}
@@ -58,6 +58,95 @@ func TestLiteralToString(t *testing.T) {
 	}
 }
 
+func TestLiteralToValueString(t *testing.T) {
+	tests := []struct {
+		t   expr.Literal
+		exp string
+	}{
+		{expr.NewNullLiteral(&types.Float32Type{}), "null"},
+		{literal.NewBool(true), "true"},
+		{literal.NewInt8(12), "12"},
+		{expr.NewPrimitiveLiteral[int8](0, true), "0"},
+		{literal.NewInt16(0), "0"},
+		{literal.NewInt32(99), "99"},
+		{literal.NewFloat32(99.10), "99.1"},
+		{literal.NewFloat64(99.20), "99.2"},
+		{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-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"},
+		// Test the other implementation.
+		{&expr.IntervalYearToMonthLiteral{Years: 7, Months: 6}, "7 years, 6 months"},
+		{MustLiteral(literal.NewIntervalDaysToSecond(5, 4, 3)), "5 days, 4 seconds, 3 subseconds"},
+		{t: &expr.IntervalCompoundLiteral{
+			Years: 5, Months: 4, Days: 3,
+			Seconds: 2, SubSeconds: 1, SubSecondPrecision: types.PrecisionMicroSeconds,
+			Nullability: types.NullabilityRequired}, exp: "5 years, 4 months, 3 days, 2 seconds, 1 subseconds"},
+		{MustLiteral(literal.NewUUIDFromBytes(
+			[]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16})),
+			"01020304-0506-0708-090a-0b0c0d0e0f10"},
+		{MustLiteral(literal.NewFixedChar("text")), "text"},
+		{MustLiteral(literal.NewFixedBinary([]byte{1, 2, 3})), "0x010203"},
+		{MustLiteral(literal.NewVarChar("vartext")), "vartext"},
+		{expr.NewNestedLiteral(expr.ListLiteralValue{
+			expr.NewNestedLiteral(expr.MapLiteralValue{
+				{
+					Key:   expr.NewPrimitiveLiteral("foo", false),
+					Value: expr.NewFixedCharLiteral(types.FixedChar("bar"), false),
+				},
+				{
+					Key:   expr.NewPrimitiveLiteral("baz", false),
+					Value: expr.NewFixedCharLiteral(types.FixedChar("bar"), false),
+				},
+			}, true),
+		}, true), "[[{string(foo) char<3>(bar)} {string(baz) char<3>(bar)}]]"},
+		{expr.NewNestedLiteral(expr.MapLiteralValue{
+			{
+				Key:   expr.NewPrimitiveLiteral("foo", false),
+				Value: expr.NewFixedCharLiteral(types.FixedChar("bar"), false),
+			},
+			{
+				Key:   expr.NewPrimitiveLiteral("baz", false),
+				Value: expr.NewFixedCharLiteral(types.FixedChar("bar"), false),
+			},
+		}, true), "[{string(foo) char<3>(bar)} {string(baz) char<3>(bar)}]"},
+		{MustLiteral(expr.NewLiteral(float32(1.5), false)), "1.5"},
+		{MustLiteral(expr.NewLiteral(&types.VarChar{Value: "foobar", Length: 7}, true)), "foobar"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "1970-01-02 10:17:36"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionDeciSeconds, types.NullabilityNullable), "1970-01-01 03:25:45.6"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionCentiSeconds, types.NullabilityNullable), "1970-01-01 00:20:34.56"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "1970-01-01 00:02:03.456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionEMinus4Seconds, types.NullabilityNullable), "1970-01-01 00:00:12.3456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionEMinus5Seconds, types.NullabilityNullable), "1970-01-01 00:00:01.23456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "1970-01-01 00:00:00.123456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionEMinus7Seconds, types.NullabilityNullable), "1970-01-01 00:00:00.0123456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionEMinus8Seconds, types.NullabilityNullable), "1970-01-01 00:00:00.00123456"},
+		{expr.NewPrecisionTimestampLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "1970-01-01 00:00:00.000123456"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionSeconds, types.NullabilityNullable), "1970-01-02T10:17:36Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionDeciSeconds, types.NullabilityNullable), "1970-01-01T03:25:45.6Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionCentiSeconds, types.NullabilityNullable), "1970-01-01T00:20:34.56Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMilliSeconds, types.NullabilityNullable), "1970-01-01T00:02:03.456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionEMinus4Seconds, types.NullabilityNullable), "1970-01-01T00:00:12.3456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionEMinus5Seconds, types.NullabilityNullable), "1970-01-01T00:00:01.23456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionMicroSeconds, types.NullabilityNullable), "1970-01-01T00:00:00.123456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionEMinus7Seconds, types.NullabilityNullable), "1970-01-01T00:00:00.0123456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionEMinus8Seconds, types.NullabilityNullable), "1970-01-01T00:00:00.00123456Z"},
+		{expr.NewPrecisionTimestampTzLiteral(123456, types.PrecisionNanoSeconds, types.NullabilityNullable), "1970-01-01T00:00:00.000123456Z"},
+		{MustLiteral(literal.NewDecimalFromString("12.345")), "12.345"},
+		{MustLiteral(literal.NewDecimalFromString("-12.345")), "-12.345"},
+		{MustLiteral(literal.NewList([]expr.Literal{literal.NewInt8(2), literal.NewInt8(4), literal.NewInt8(6)})), "[2, 4, 6]"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.t.String(), func(t *testing.T) {
+			assert.Equal(t, tt.exp, tt.t.ValueString())
+		})
+	}
+}
+
 func TestLiteralToStringBrokenDecimal(t *testing.T) {
 	brokenDecimalLit, _ := literal.NewDecimalFromString("1234.56")
 	brokenDecimalLitAsProtoLit := brokenDecimalLit.(*expr.ProtoLiteral)

go.mod

@@ -7,6 +7,7 @@ go 1.22.0
 toolchain go1.22.3
 
 require (
+	cloud.google.com/go v0.118.0
 	github.com/antlr4-go/antlr/v4 v4.13.1
 	github.com/cockroachdb/apd/v3 v3.2.1
 	github.com/creasty/defaults v1.8.0
@@ -30,9 +31,7 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rogpeppe/go-internal v1.12.0 // indirect
-	golang.org/x/crypto v0.30.0 // indirect
 	golang.org/x/sys v0.28.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 )

go.sum

@@ -1,3 +1,5 @@
+cloud.google.com/go v0.118.0 h1:tvZe1mgqRxpiVa3XlIGMiPcEUbP1gNXELgD4y/IXmeQ=
+cloud.google.com/go v0.118.0/go.mod h1:zIt2pkedt/mo+DQjcT4/L3NDxzHPR29j5HcclNH+9PM=
 github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ=
 github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw=
 github.com/cockroachdb/apd/v3 v3.2.1 h1:U+8j7t0axsIgvQUqthuNm82HIrYXodOV2iWLWtEaIwg=
@@ -59,8 +61,8 @@ github.com/substrait-io/substrait v0.63.1/go.mod h1:MPFNw6sToJgpD5Z2rj0rQrdP/Oq8
 github.com/substrait-io/substrait-go v1.2.0 h1:3ZNRkc8FYD7ifCagKEOZQtUcgMceMQfwo2N1NGaK4Q4=
 github.com/substrait-io/substrait-go v1.2.0/go.mod h1:IPsy24rdjp/buXR+T8ENl6QCnSCS6h+uM8P+GaZez7c=
 golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY=
-golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 h1:e66Fs6Z+fZTbFBAxKfP3PALWBtpfqks2bwGcexMxgtk=
 golang.org/x/exp v0.0.0-20240909161429-701f63a606c0/go.mod h1:2TbTHSBQa924w8M6Xs1QcRcFwyucIwBGpK1p2f1YFFY=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=