Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix: Cassandra query results displaying protobuf structure for complex types (#18219)

Vincent Huang543c71674552
diff --git a/backend/plugin/db/cassandra/cassandra.go b/backend/plugin/db/cassandra/cassandra.go
index cfcb168bc3..1e11b90242 100644
--- a/backend/plugin/db/cassandra/cassandra.go
+++ b/backend/plugin/db/cassandra/cassandra.go
@@ -3,26 +3,23 @@ package cassandra
import (
"context"
"database/sql"
- "encoding/base64"
"encoding/json"
"fmt"
+ "log/slog"
"math/big"
- "reflect"
"time"
- "unicode/utf8"
"connectrpc.com/connect"
"github.com/cockroachdb/cockroachdb-parser/pkg/util/timeofday"
"github.com/gocql/gocql"
"github.com/pkg/errors"
"google.golang.org/protobuf/proto"
- "google.golang.org/protobuf/runtime/protoimpl"
"google.golang.org/protobuf/types/known/durationpb"
- "google.golang.org/protobuf/types/known/structpb"
"google.golang.org/protobuf/types/known/timestamppb"
"gopkg.in/inf.v0"
"github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/log"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
"github.com/bytebase/bytebase/backend/plugin/db"
@@ -357,17 +354,19 @@ func convertRowValue(v any) *v1pb.RowValue {
}
default:
- value, err := newValue(v)
+ // Handle complex types (LIST, MAP, SET, UDT) by converting to JSON strings
+ jsonBytes, err := json.Marshal(v)
if err != nil {
+ slog.Error("failed to marshal Cassandra complex value", log.BBError(err))
return &v1pb.RowValue{
Kind: &v1pb.RowValue_StringValue{
- StringValue: fmt.Sprintf("failed to marshal value, err: %v", err),
+ StringValue: fmt.Sprintf("%v", v),
},
}
}
return &v1pb.RowValue{
- Kind: &v1pb.RowValue_ValueValue{
- ValueValue: value,
+ Kind: &v1pb.RowValue_StringValue{
+ StringValue: string(jsonBytes),
},
}
}
@@ -379,148 +378,3 @@ func formatAddress(host, port string) string {
}
return host + ":" + port
}
-
-func newValue(v any) (*structpb.Value, error) {
- switch v := v.(type) {
- case nil:
- return newNullValue(), nil
- case bool:
- return newBoolValue(v), nil
- case int:
- return newNumberValue(float64(v)), nil
- case int8:
- return newNumberValue(float64(v)), nil
- case int16:
- return newNumberValue(float64(v)), nil
- case int32:
- return newNumberValue(float64(v)), nil
- case int64:
- return newNumberValue(float64(v)), nil
- case uint:
- return newNumberValue(float64(v)), nil
- case uint8:
- return newNumberValue(float64(v)), nil
- case uint16:
- return newNumberValue(float64(v)), nil
- case uint32:
- return newNumberValue(float64(v)), nil
- case uint64:
- return newNumberValue(float64(v)), nil
- case float32:
- return newNumberValue(float64(v)), nil
- case float64:
- return newNumberValue(float64(v)), nil
- case json.Number:
- n, err := v.Float64()
- if err != nil {
- return nil, protoimpl.X.NewError("invalid number format %q, expected a float64: %v", v, err)
- }
- return newNumberValue(n), nil
- case string:
- if !utf8.ValidString(v) {
- return nil, protoimpl.X.NewError("invalid UTF-8 in string: %q", v)
- }
- return newStringValue(v), nil
- case []byte:
- s := base64.StdEncoding.EncodeToString(v)
- return newStringValue(s), nil
- case map[string]any:
- v2, err := newStruct(v)
- if err != nil {
- return nil, err
- }
- return newStructValue(v2), nil
- case []any:
- v2, err := newList(v)
- if err != nil {
- return nil, err
- }
- return newListValue(v2), nil
- default:
- if reflect.TypeOf(v).Kind() == reflect.Ptr {
- if reflect.ValueOf(v).IsNil() {
- return newNullValue(), nil
- }
- return newValue(reflect.ValueOf(v).Elem().Interface())
- }
- if reflect.TypeOf(v).Kind() == reflect.Slice || reflect.TypeOf(v).Kind() == reflect.Array {
- s := reflect.ValueOf(v)
- x := &structpb.ListValue{Values: make([]*structpb.Value, s.Len())}
- for i := 0; i < s.Len(); i++ {
- v2, err := newValue(s.Index(i).Interface())
- if err != nil {
- return nil, err
- }
- x.Values[i] = v2
- }
- return newListValue(x), nil
- }
- if reflect.TypeOf(v).Kind() == reflect.Map {
- m := reflect.ValueOf(v)
- x := &structpb.Struct{Fields: make(map[string]*structpb.Value, m.Len())}
- for _, k := range m.MapKeys() {
- if !utf8.ValidString(k.String()) {
- return nil, protoimpl.X.NewError("invalid UTF-8 in string: %q", k.String())
- }
- v2, err := newValue(m.MapIndex(k).Interface())
- if err != nil {
- return nil, err
- }
- x.Fields[k.String()] = v2
- }
- return newStructValue(x), nil
- }
- return nil, protoimpl.X.NewError("invalid type: %T", v)
- }
-}
-
-func newList(v []any) (*structpb.ListValue, error) {
- x := &structpb.ListValue{Values: make([]*structpb.Value, len(v))}
- for i, v := range v {
- var err error
- x.Values[i], err = newValue(v)
- if err != nil {
- return nil, err
- }
- }
- return x, nil
-}
-
-func newStruct(v map[string]any) (*structpb.Struct, error) {
- x := &structpb.Struct{Fields: make(map[string]*structpb.Value, len(v))}
- for k, v := range v {
- if !utf8.ValidString(k) {
- return nil, protoimpl.X.NewError("invalid UTF-8 in string: %q", k)
- }
- var err error
- x.Fields[k], err = newValue(v)
- if err != nil {
- return nil, err
- }
- }
- return x, nil
-}
-
-func newNullValue() *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_NullValue{NullValue: structpb.NullValue_NULL_VALUE}}
-}
-
-func newBoolValue(v bool) *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_BoolValue{BoolValue: v}}
-}
-
-func newNumberValue(v float64) *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_NumberValue{NumberValue: v}}
-}
-
-func newStringValue(v string) *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_StringValue{StringValue: v}}
-}
-
-func newStructValue(v *structpb.Struct) *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_StructValue{StructValue: v}}
-}
-
-func newListValue(v *structpb.ListValue) *structpb.Value {
- return &structpb.Value{Kind: &structpb.Value_ListValue{ListValue: v}}
-}
diff --git a/backend/plugin/db/cassandra/cassandra_test.go b/backend/plugin/db/cassandra/cassandra_test.go
new file mode 100644
index 0000000000..7741e385c9
--- /dev/null
+++ b/backend/plugin/db/cassandra/cassandra_test.go
@@ -0,0 +1,144 @@
+package cassandra
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
+ "github.com/bytebase/bytebase/backend/plugin/db/util"
+)
+
+func TestConvertRowValueComplexTypes(t *testing.T) {
+ tests := []struct {
+ name string
+ value any
+ expected *v1pb.RowValue
+ }{
+ {
+ name: "nil value",
+ value: nil,
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{
+ StringValue: "null",
+ }},
+ },
+ {
+ name: "list of integers",
+ value: []any{1, 2, 3},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{
+ StringValue: "[1,2,3]",
+ }},
+ },
+ {
+ name: "map of string to int",
+ value: map[string]any{"a": 1, "b": 2},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{
+ StringValue: `{"a":1,"b":2}`,
+ }},
+ },
+ {
+ name: "nested list",
+ value: []any{[]any{1, 2}, []any{3, 4}},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{
+ StringValue: "[[1,2],[3,4]]",
+ }},
+ },
+ {
+ name: "array of maps",
+ value: []any{map[string]any{"id": 1}, map[string]any{"id": 2}},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{
+ StringValue: `[{"id":1},{"id":2}]`,
+ }},
+ },
+ {
+ name: "empty list",
+ value: []any{},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: "[]"}},
+ },
+ {
+ name: "empty map",
+ value: map[string]any{},
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: "{}"}},
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ a := require.New(t)
+ result := convertRowValue(tt.value)
+ a.Equal(tt.expected, result)
+ })
+ }
+}
+
+func TestConvertRowValuePrimitives(t *testing.T) {
+ tests := []struct {
+ name string
+ value any
+ expected *v1pb.RowValue
+ }{
+ {
+ name: "string pointer",
+ value: func() *string {
+ s := "hello"
+ return &s
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_StringValue{StringValue: "hello"}},
+ },
+ {
+ name: "nil string pointer",
+ value: func() *string {
+ return nil
+ }(),
+ expected: util.NullRowValue,
+ },
+ {
+ name: "int64 pointer",
+ value: func() *int64 {
+ i := int64(42)
+ return &i
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_Int64Value{Int64Value: 42}},
+ },
+ {
+ name: "bool pointer true",
+ value: func() *bool {
+ b := true
+ return &b
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_BoolValue{BoolValue: true}},
+ },
+ {
+ name: "bool pointer false",
+ value: func() *bool {
+ b := false
+ return &b
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_BoolValue{BoolValue: false}},
+ },
+ {
+ name: "float64 pointer",
+ value: func() *float64 {
+ f := 3.14159
+ return &f
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_DoubleValue{DoubleValue: 3.14159}},
+ },
+ {
+ name: "bytes pointer",
+ value: func() *[]byte {
+ b := []byte("hello")
+ return &b
+ }(),
+ expected: &v1pb.RowValue{Kind: &v1pb.RowValue_BytesValue{BytesValue: []byte("hello")}},
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ a := require.New(t)
+ result := convertRowValue(tt.value)
+ a.Equal(tt.expected, result)
+ })
+ }
+}