[FEAT] Converting a Row to a JSON string

### What changes were proposed in this pull request? This PR adds JSON serialization capability to the Row interface by implementing a `ToJsonString()` method. The implementation includes: - Added `ToJsonString()` method to the Row interface that converts Row data to a JSON string representation - Implemented comprehensive `convertToJsonValue()` function that handles all Spark data types including: - Basic types (bool, string, integers, floats) - Binary data (base64 encoded) - Decimal types (decimal128/256 as string representations) - Arrow timestamp and date types (RFC3339 and ISO date formats) - Arrays and nested structures with recursive conversion - Maps with string keys (validates non-string keys return errors) - Custom types using reflection fallback for underlying basic types - Added extensive test suite with 238 lines covering all supported data types and error scenarios ### Why are the changes needed? This feature enables users to easily serialize Row data to JSON format, which is essential for: - Data export and interoperability with other systems - Debugging and logging Row contents in human-readable format - Integration with REST APIs and web services that expect JSON - Data analysis workflows that require JSON output Currently, there's no built-in way to convert Row data to JSON, forcing users to manually iterate through fields and handle type conversions. ### Does this PR introduce _any_ user-facing change? Yes. This PR adds a new public method `ToJsonString() (string, error)` to the Row interface. Users can now call this method on any Row instance to get a JSON string representation: ```go row := // ... get a Row from DataFrame operations jsonStr, err := row.ToJsonString() if err != nil { // handle conversion error } // jsonStr contains: {"field1": "value1", "field2": 42, ...} ``` ### How was this patch tested? Added comprehensive unit tests in spark/sql/types/row_json_test.go covering: - Basic data types: strings, integers, floats, booleans, nil values - Binary data: byte arrays converted to base64 encoding - Decimal types: decimal128 and decimal256 number representations - Temporal types: Arrow timestamps, Date32, Date64, and Go time.Time - Collection types: arrays with recursive element conversion - Map types: both map[string]any and map[any]any with string key validation - Nested structures: complex combinations of arrays and maps - Error cases: invalid map keys and conversion failures - JSON validity: all outputs are verified to be valid JSON through round-trip parsing Tests ensure both successful conversions produce expected JSON and error cases properly return meaningful error messages. Closes #162 from grundprinzip/json_value. Authored-by: Martin Grund <martin.grund@databricks.com> Signed-off-by: Martin Grund <martin.grund@databricks.com>

Author: grundprinzip

spark/sql/types/row.go

@@ -17,7 +17,16 @@
 package types
 
 import (
+"encoding/base64"
+"encoding/json"
+"fmt"
 "maps"
+"reflect"
+"time"
+
+"github.com/apache/arrow-go/v18/arrow"
+"github.com/apache/arrow-go/v18/arrow/decimal128"
+"github.com/apache/arrow-go/v18/arrow/decimal256"
 )
 
 type Row interface {
@@ -32,6 +41,9 @@ type Row interface {
 // Len returns the number of fields within a [Row].
 Len() int
 FieldNames() []string
+// ToJsonString converts the Row to a JSON string representation.
+// Returns an error if the row contains data that cannot be properly represented in JSON.
+ToJsonString() (string, error)
 }
 
 type rowImpl struct {
@@ -70,3 +82,156 @@ func (r *rowImpl) FieldNames() []string {
 }
 return names
 }
+
+func (r *rowImpl) ToJsonString() (string, error) {
+jsonMap := make(map[string]any)
+fieldNames := r.FieldNames()
+
+for i, fieldName := range fieldNames {
+value := r.values[i]
+convertedValue, err := convertToJsonValue(value)
+if err != nil {
+return "", fmt.Errorf("failed to convert field '%s': %w", fieldName, err)
+}
+jsonMap[fieldName] = convertedValue
+}
+
+jsonBytes, err := json.Marshal(jsonMap)
+if err != nil {
+return "", fmt.Errorf("failed to marshal JSON: %w", err)
+}
+
+return string(jsonBytes), nil
+}
+
+func convertToJsonValue(value any) (any, error) {
+if value == nil {
+return nil, nil
+}
+
+switch v := value.(type) {
+case bool, string, int8, int16, int32, int64, float32, float64:
+return v, nil
+
+case []byte:
+return base64.StdEncoding.EncodeToString(v), nil
+
+case decimal128.Num:
+return v.BigInt().String(), nil
+
+case decimal256.Num:
+return v.BigInt().String(), nil
+
+case arrow.Timestamp:
+epochUs := int64(v)
+t := time.Unix(epochUs/1000000, (epochUs%1000000)*1000).UTC()
+return t.Format(time.RFC3339), nil
+
+case arrow.Date32:
+epochDays := int64(v)
+epochTime := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC).AddDate(0, 0, int(epochDays))
+return epochTime.Format("2006-01-02"), nil
+
+case arrow.Date64:
+epochMs := int64(v)
+t := time.Unix(epochMs/1000, (epochMs%1000)*1000000).UTC()
+return t.Format("2006-01-02"), nil
+
+case time.Time:
+if v.IsZero() {
+return nil, nil
+}
+return v.Format(time.RFC3339), nil
+
+case []any:
+result := make([]any, len(v))
+for i, item := range v {
+convertedItem, err := convertToJsonValue(item)
+if err != nil {
+return nil, fmt.Errorf("failed to convert array element at index %d: %w", i, err)
+}
+result[i] = convertedItem
+}
+return result, nil
+
+case map[any]any:
+result := make(map[string]any)
+for key, val := range v {
+keyStr, ok := key.(string)
+if !ok {
+return nil, fmt.Errorf("map key must be string for JSON conversion, got %T", key)
+}
+convertedVal, err := convertToJsonValue(val)
+if err != nil {
+return nil, fmt.Errorf("failed to convert map value for key '%s': %w", keyStr, err)
+}
+result[keyStr] = convertedVal
+}
+return result, nil
+
+case map[string]any:
+result := make(map[string]any)
+for key, val := range v {
+convertedVal, err := convertToJsonValue(val)
+if err != nil {
+return nil, fmt.Errorf("failed to convert map value for key '%s': %w", key, err)
+}
+result[key] = convertedVal
+}
+return result, nil
+
+default:
+// Use reflection to handle custom types that have basic types as their underlying type.
+// For example, a custom type like "type MyInt int32" would not match the explicit
+// int32 case above, but would match reflect.Int32 here. This ensures we can still
+// convert custom integer, float, bool, and string types to their JSON representations.
+rv := reflect.ValueOf(value)
+switch rv.Kind() {
+case reflect.Slice, reflect.Array:
+length := rv.Len()
+result := make([]any, length)
+for i := 0; i < length; i++ {
+convertedItem, err := convertToJsonValue(rv.Index(i).Interface())
+if err != nil {
+return nil, fmt.Errorf("failed to convert array element at index %d: %w", i, err)
+}
+result[i] = convertedItem
+}
+return result, nil
+
+case reflect.Map:
+if rv.Type().Key().Kind() != reflect.String {
+return nil, fmt.Errorf("map key must be string for JSON conversion, got %s", rv.Type().Key().Kind())
+}
+result := make(map[string]any)
+for _, key := range rv.MapKeys() {
+keyStr := key.String()
+val := rv.MapIndex(key)
+convertedVal, err := convertToJsonValue(val.Interface())
+if err != nil {
+return nil, fmt.Errorf("failed to convert map value for key '%s': %w", keyStr, err)
+}
+result[keyStr] = convertedVal
+}
+return result, nil
+
+case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+return rv.Int(), nil
+
+case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+return rv.Uint(), nil
+
+case reflect.Float32, reflect.Float64:
+return rv.Float(), nil
+
+case reflect.Bool:
+return rv.Bool(), nil
+
+case reflect.String:
+return rv.String(), nil
+
+default:
+return fmt.Sprintf("%v", value), nil
+}
+}
+}