Support binding ICollection parameters when DuckDB type is unknown

When a parameter's DuckDB type can't be inferred (e.g. unnest($p) where
the prepared statement reports an ambiguous type), fall back to building
a list from the CLR element type so collections bind correctly.

Add UnnestTests covering string/int/long/double/decimal lists, nulls,
and nested int lists.

Author: Giorgi

DuckDB.NET.Data/PreparedStatement/ClrToDuckDBConverter.cs

@@ -93,6 +93,7 @@ public static DuckDBValue ToDuckDBValue(this object? item, DuckDBLogicalType log
             (DuckDBType.Blob, byte[] value) => NativeMethods.Value.DuckDBCreateBlob(value, value.Length),
             (DuckDBType.List, ICollection value) => CreateCollectionValue(logicalType, value, true, dbType),
             (DuckDBType.Array, ICollection value) => CreateCollectionValue(logicalType, value, false, dbType),
+            (_, ICollection value) when item is not byte[] => CreateListFromClrType(value, dbType),
             _ when ValueCreators.TryGetValue(dbType, out var converter) => converter(item),
             _ => NativeMethods.Value.DuckDBCreateVarchar(item.ToString())
         };
@@ -120,23 +121,42 @@ bool TryConvertTo<T>(out T result) where T : struct
 
     private static DuckDBValue CreateCollectionValue(DuckDBLogicalType logicalType, ICollection collection, bool isList, DbType dbType)
     {
-        using var collectionItemType = isList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) :
-                                                NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);
+        using var childType = isList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) :
+                                       NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);
 
-        var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(collectionItemType);
+        var values = BuildValues(childType, collection, dbType);
 
+        return isList ? NativeMethods.Value.DuckDBCreateListValue(childType, values, collection.Count)
+                      : NativeMethods.Value.DuckDBCreateArrayValue(childType, values, collection.Count);
+    }
+
+    private static DuckDBValue CreateListFromClrType(ICollection collection, DbType dbType)
+    {
+        var elementType = collection.GetType().GetInterface(typeof(IEnumerable<>).Name)?.GetGenericArguments()[0];
+
+        if (elementType == null)
+        {
+            return NativeMethods.Value.DuckDBCreateVarchar(collection.ToString());
+        }
+
+        using var childType = elementType.GetLogicalType();
+        var values = BuildValues(childType, collection, dbType);
+
+        return NativeMethods.Value.DuckDBCreateListValue(childType, values, collection.Count);
+    }
+
+    private static DuckDBValue[] BuildValues(DuckDBLogicalType childType, ICollection collection, DbType dbType)
+    {
+        var childDuckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(childType);
         var values = new DuckDBValue[collection.Count];
 
         var index = 0;
         foreach (var item in collection)
         {
-            var duckDBValue = item.ToDuckDBValue(collectionItemType, duckDBType, dbType);
-            values[index] = duckDBValue;
-            index++;
+            values[index++] = item.ToDuckDBValue(childType, childDuckDBType, dbType);
         }
 
-        return isList ? NativeMethods.Value.DuckDBCreateListValue(collectionItemType, values, collection.Count)
-                      : NativeMethods.Value.DuckDBCreateArrayValue(collectionItemType, values, collection.Count);
+        return values;
     }
 
     private static DuckDBValue DecimalToDuckDBValue(decimal value)

DuckDB.NET.Test/UnnestTests.cs

@@ -0,0 +1,130 @@
+namespace DuckDB.NET.Test;
+
+public class UnnestTests(DuckDBDatabaseFixture db) : DuckDBTestBase(db)
+{
+    [Fact]
+    public void UnnestStringList()
+    {
+        var names = new List<string> { "Bob", "Sam" };
+        Command.CommandText = "SELECT unnest($names);";
+        Command.Parameters.Add(new DuckDBParameter("names", names));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<string>();
+        while (reader.Read())
+        {
+            results.Add(reader.GetString(0));
+        }
+
+        results.Should().BeEquivalentTo(names);
+    }
+
+    [Fact]
+    public void UnnestStringListWithNull()
+    {
+        var names = new List<string> { "Bob", null, "Sam" };
+        Command.CommandText = "SELECT unnest($names);";
+        Command.Parameters.Add(new DuckDBParameter("names", names));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<string>();
+        while (reader.Read())
+        {
+            results.Add(reader.IsDBNull(0) ? null : reader.GetString(0));
+        }
+
+        results.Should().BeEquivalentTo(names);
+    }
+
+    [Fact]
+    public void UnnestIntList()
+    {
+        var numbers = new List<int> { 1, 2, 3, 42 };
+        Command.CommandText = "SELECT unnest($numbers);";
+        Command.Parameters.Add(new DuckDBParameter("numbers", numbers));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<int>();
+        while (reader.Read())
+        {
+            results.Add(reader.GetInt32(0));
+        }
+
+        results.Should().BeEquivalentTo(numbers);
+    }
+
+    [Fact]
+    public void UnnestLongList()
+    {
+        var numbers = new List<long> { 1L, 2L, long.MaxValue };
+        Command.CommandText = "SELECT unnest($numbers);";
+        Command.Parameters.Add(new DuckDBParameter("numbers", numbers));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<long>();
+        while (reader.Read())
+        {
+            results.Add(reader.GetInt64(0));
+        }
+
+        results.Should().BeEquivalentTo(numbers);
+    }
+
+    [Fact]
+    public void UnnestDoubleList()
+    {
+        var numbers = new List<double> { 1.5, 2.5, 3.14 };
+        Command.CommandText = "SELECT unnest($numbers);";
+        Command.Parameters.Add(new DuckDBParameter("numbers", numbers));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<double>();
+        while (reader.Read())
+        {
+            results.Add(reader.GetDouble(0));
+        }
+
+        results.Should().BeEquivalentTo(numbers);
+    }
+
+    [Fact]
+    public void UnnestDecimalList()
+    {
+        var numbers = new List<decimal> { 1.1m, 2.22m, 3.333m };
+        Command.CommandText = "SELECT unnest($numbers);";
+        Command.Parameters.Add(new DuckDBParameter("numbers", numbers));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<decimal>();
+        while (reader.Read())
+        {
+            results.Add(reader.GetDecimal(0));
+        }
+
+        results.Should().BeEquivalentTo(numbers);
+    }
+
+    [Fact]
+    public void UnnestNestedIntList()
+    {
+        var nested = new List<List<int>> { new() { 1, 2 }, new() { 3, 4, 5 } };
+        Command.CommandText = "SELECT unnest($nested);";
+        Command.Parameters.Add(new DuckDBParameter("nested", nested));
+
+        using var reader = Command.ExecuteReader();
+
+        var results = new List<List<int>>();
+        while (reader.Read())
+        {
+            results.Add(((IEnumerable<int>)reader.GetValue(0)).ToList());
+        }
+
+        results.Should().BeEquivalentTo(nested);
+    }
+}