Serialize nonempty dicts as lists-of-pairs for untyped table insertion

src/DataStax.AstraDB.DataApi/Core/Commands/Command.cs

@@ -196,6 +196,11 @@ internal string Serialize<T>(T input, JsonSerializerOptions serializeOptions = n
         if (commandOptions.InputConverter != null)
         {
             serializeOptions.Converters.Add(commandOptions.InputConverter);
+            // For untyped Row serialization, add TableDictionaryConverter to handle nested dictionaries
+            if (commandOptions.InputConverter is SimpleDictionaryConverter)
+            {
+                serializeOptions.Converters.Add(new TableDictionaryConverter());
+            }
         }
         if (log)
         {

src/DataStax.AstraDB.DataApi/SerDes/SimpleDictionaryConverter.cs

@@ -104,11 +104,19 @@ private static void WriteValue(Utf8JsonWriter writer, object? value, JsonSeriali
             if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
             {
                 var keyType = type.GetGenericArguments()[0];
-                if (keyType != typeof(string))
+                var dict = (System.Collections.IDictionary)value;
+
+                // Empty dictionaries remain as {}
+                if (dict.Count == 0)
                 {
+                    writer.WriteStartObject();
+                    writer.WriteEndObject();
+                }
+                else
+                {
+                    // Non-empty: [[k1,v1],[k2,v2],...]
                     var valueType = type.GetGenericArguments()[1];
                     writer.WriteStartArray();
-                    var dict = (System.Collections.IDictionary)value;
                     foreach (var key in dict.Keys)
                     {
                         writer.WriteStartArray();
@@ -117,8 +125,8 @@ private static void WriteValue(Utf8JsonWriter writer, object? value, JsonSeriali
                         writer.WriteEndArray();
                     }
                     writer.WriteEndArray();
-                    return;
                 }
+                return;
             }
         }
         JsonSerializer.Serialize(writer, value, options);

src/DataStax.AstraDB.DataApi/SerDes/TableDictionaryConverter.cs

@@ -0,0 +1,87 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace DataStax.AstraDB.DataApi.SerDes;
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+/// <summary>
+/// Converter factory for serializing dictionaries in table operations.
+/// Non-empty dictionaries are serialized as [[k1,v1],[k2,v2],...] format.
+/// Empty dictionaries are serialized as {}.
+/// </summary>
+internal class TableDictionaryConverter : JsonConverterFactory
+{
+    public override bool CanConvert(Type typeToConvert)
+    {
+        if (!typeToConvert.IsGenericType)
+            return false;
+
+        return typeToConvert.GetGenericTypeDefinition() == typeof(Dictionary<,>);
+    }
+
+    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        Type keyType = typeToConvert.GetGenericArguments()[0];
+        Type valueType = typeToConvert.GetGenericArguments()[1];
+
+        JsonConverter converter = (JsonConverter)Activator.CreateInstance(
+            typeof(TableDictionaryConverterInner<,>).MakeGenericType(keyType, valueType),
+            BindingFlags.Instance | BindingFlags.Public,
+            binder: null,
+            args: null,
+            culture: null)!;
+
+        return converter;
+    }
+
+    private class TableDictionaryConverterInner<TKey, TValue> : JsonConverter<Dictionary<TKey, TValue>>
+    {
+        public override Dictionary<TKey, TValue> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            // For table operations, we primarily need write support
+            // Read support can be added if needed for deserialization
+            throw new NotImplementedException("TableDictionaryConverter is designed for serialization only");
+        }
+
+        public override void Write(Utf8JsonWriter writer, Dictionary<TKey, TValue> value, JsonSerializerOptions options)
+        {
+            if (value.Count == 0)
+            {
+                // Empty dictionaries remain as {}
+                writer.WriteStartObject();
+                writer.WriteEndObject();
+            }
+            else
+            {
+                // Non-empty dictionaries: [[k1,v1],[k2,v2],...]
+                writer.WriteStartArray();
+                foreach (var kvp in value)
+                {
+                    writer.WriteStartArray();
+                    JsonSerializer.Serialize(writer, kvp.Key, options);
+                    JsonSerializer.Serialize(writer, kvp.Value, options);
+                    writer.WriteEndArray();
+                }
+                writer.WriteEndArray();
+            }
+        }
+    }
+}

src/DataStax.AstraDB.DataApi/Tables/Table.cs

@@ -705,10 +705,10 @@
     /// <summary>
     /// Find rows in the table.
     /// 
     /// The Find() methods return a <see cref="FindEnumerator{T,T,TableSortBuilder{T}}"/> object that can be used to further structure the query
     /// by adding Sort, Projection, Skip, Limit, etc. to affect the final results.
     /// 
     /// The <see cref="FindEnumerator{T,T,TableSortBuilder{T}}"/> object can be directly enumerated both synchronously and asynchronously.
     /// Secondarily, the results can be paged through manually by using the results of <see cref="FindEnumerator{T,T,TableSortBuilder{T}}.ToCursor()"/>.
     /// </summary>
     /// <returns></returns>
@@ -1057,6 +1057,11 @@
         commandOptions.SerializeDateAsDollarDate = false;
         if (typeof(TResult) == typeof(Row))
         {
+            // Register SimpleDictionaryConverter for untyped Row serialization
+            if (isInsert && typeof(T) == typeof(Row))
+            {
+                commandOptions.InputConverter = new SimpleDictionaryConverter();
+            }
             return commandOptions;
         }
         if (isInsert)