Bind List

Author: Giorgi

DuckDB.NET.Bindings/DuckDBNativeObjects.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Numerics;
 using System.Runtime.InteropServices;
 
 namespace DuckDB.NET.Native;

DuckDB.NET.Bindings/NativeMethods/NativeMethods.Value.cs

@@ -7,6 +7,9 @@ public partial class NativeMethods
 {
     public static class Value
     {
+        [DllImport(DuckDbLibrary, CallingConvention = CallingConvention.Cdecl, EntryPoint = "duckdb_destroy_value")]
+        public static extern void DuckDBDestroyValue(out IntPtr config);
+        
         [DllImport(DuckDbLibrary, CallingConvention = CallingConvention.Cdecl, EntryPoint = "duckdb_create_varchar")]
         public static extern DuckDBValue DuckDBCreateVarchar(SafeUnmanagedMemoryHandle value);
 
@@ -66,8 +69,8 @@ public static class Value
 
         [DllImport(DuckDbLibrary, CallingConvention = CallingConvention.Cdecl, EntryPoint = "duckdb_create_blob")]
         public static extern DuckDBValue DuckDBCreateBlob([In] byte[] value, long length);
-
-        [DllImport(DuckDbLibrary, CallingConvention = CallingConvention.Cdecl, EntryPoint = "duckdb_destroy_value")]
-        public static extern void DuckDBDestroyValue(out IntPtr config);
+        
+        [DllImport(DuckDbLibrary, CallingConvention = CallingConvention.Cdecl, EntryPoint = "duckdb_create_list_value")]
+        public static extern DuckDBValue DuckDBCreateListValue(DuckDBLogicalType logicalType, IntPtr[] values, long count);
     }
 }

DuckDB.NET.Data/DuckDBParameter.cs

@@ -14,6 +14,8 @@ public class DuckDBParameter : DbParameter
 
     public override DbType DbType { get; set; }
 
+    public DuckDBParameterType DuckDBType { get; set; }
+
 #if NET6_0_OR_GREATER
     [AllowNull]
 #endif
@@ -74,4 +76,9 @@ public DuckDBParameter(string name, DbType type, object? value)
 
     public override void ResetDbType()
         => DbType = DefaultDbType;
+}
+
+public enum DuckDBParameterType
+{
+    List
 }

DuckDB.NET.Data/Internal/DuckDBTypeMap.cs

@@ -1,8 +1,10 @@
 using DuckDB.NET.Data.Extensions;
 using DuckDB.NET.Native;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq;
 using System.Numerics;
 
 namespace DuckDB.NET.Data.Internal;
@@ -76,6 +78,8 @@ public static DbType GetDbTypeForValue(object? value)
         {
             return dbType;
         }
+
+        return DbType.Object;
         throw new InvalidOperationException($"Values of type {type.FullName} are not supported.");
     }
 
@@ -89,3 +93,36 @@ public static DuckDBLogicalType GetLogicalType<T>()
         throw new InvalidOperationException($"Cannot map type {typeof(T).FullName} to DuckDBType.");
     }
 }
+
+internal static class ValueConverter
+{
+    public static DuckDBValue ToDuckDBValue(this object value)
+    {
+        return value switch
+        {
+            int intValue => NativeMethods.Value.DuckDBCreateInt32(intValue),
+            long longValue => NativeMethods.Value.DuckDBCreateInt64(longValue),
+            ICollection<int> ints => CreateListValue(DuckDBType.Integer, ints),
+            _ => throw new InvalidCastException(
+                $"Cannot convert value of type {value.GetType().FullName} to DuckDBValue.")
+        };
+    }
+
+    private static DuckDBValue CreateListValue<T>(DuckDBType duckDBType, ICollection<T> collection)
+    {
+        using var logicalType = NativeMethods.LogicalType.DuckDBCreateLogicalType(duckDBType);
+        
+        var values = new IntPtr[collection.Count];
+        
+        var index = 0;
+        foreach (var item in collection)
+        {
+            using var duckDBValue = item.ToDuckDBValue();
+            values[index] = duckDBValue.DangerousGetHandle();
+            index++;
+        }
+        
+        return NativeMethods.Value.DuckDBCreateListValue(logicalType,
+            collection.Select(i => i.ToDuckDBValue().DangerousGetHandle()).ToArray(), collection.Count);
+    }
+}

DuckDB.NET.Data/Internal/PreparedStatement.cs

@@ -186,13 +186,15 @@ private static void BindParameter(DuckDBPreparedStatement preparedStatement, lon
             return;
         }
 
-        if (!ValueCreators.TryGetValue(parameter.DbType, out var func))
-        {
-            throw new InvalidOperationException($"Unable to bind value of type {parameter.DbType}.");
-        }
+        // if (!ValueCreators.TryGetValue(parameter.DbType, out var func))
+        // {
+        //     throw new InvalidOperationException($"Unable to bind value of type {parameter.DbType}.");
+        // }
+
+        var duckDBValue2 = parameter.Value!.ToDuckDBValue();
 
-        using var duckDBValue = func(parameter.Value!);
-        var result = NativeMethods.PreparedStatements.DuckDBBindValue(preparedStatement, index, duckDBValue);
+        //using var duckDBValue = func(parameter.Value!);
+        var result = NativeMethods.PreparedStatements.DuckDBBindValue(preparedStatement, index, duckDBValue2);
 
         if (!result.IsSuccess())
         {

DuckDB.NET.Data/Internal/Writer/ListVectorDataWriter.cs

@@ -13,7 +13,7 @@ internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
     private readonly DuckDBLogicalType childType;
     private readonly VectorDataWriterBase listItemWriter;
 
-    public bool IsList => ColumnType == DuckDBType.List;
+    private bool IsList => ColumnType == DuckDBType.List;
     private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;
 
     public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)

DuckDB.NET.Test/Parameters/ListParameterTests.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using DuckDB.NET.Data;
+using FluentAssertions;
+using Xunit;
+
+namespace DuckDB.NET.Test.Parameters;
+
+public class ListParameterTests(DuckDBDatabaseFixture db) : DuckDBTestBase(db)
+{
+    [Fact]
+    public void CanBindList()
+    {
+        Command.CommandText = "Select ?";
+        var parameter = new DuckDBParameter(new List<int> {1,2,3});
+        
+        Command.Parameters.Add(parameter);
+
+        using var reader = Command.ExecuteReader();
+        reader.Read();
+        reader.GetFieldValue<List<int>>(0).Should().BeEquivalentTo(new List<int>{1,2,3});
+    }
+}