Refactor Enum writer

Author: Giorgi

DuckDB.NET.Data/DuckDBAppender.cs

@@ -74,6 +74,11 @@ public void Close()
                 logicalType.Dispose();
             }
 
+            foreach (var writer in vectorWriters)
+            {
+                writer.Dispose();
+            }
+
             var state = NativeMethods.Appender.DuckDBAppenderClose(nativeAppender);
             if (!state.IsSuccess())
             {

DuckDB.NET.Data/DuckDBAppenderRow.cs

@@ -70,7 +70,7 @@ public void EndRow()
 
     #region Append Enum
 
-    public DuckDBAppenderRow AppendValue<TEnum>(TEnum value) where TEnum : Enum => AppendValueInternal(value);
+    public DuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum => AppendValueInternal(value);
 
     #endregion
 

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

@@ -9,40 +9,40 @@ namespace DuckDB.NET.Data.Internal.Writer;
 internal sealed unsafe class EnumVectorDataWriter : VectorDataWriterBase
 {
     private readonly DuckDBType enumType;
+    private readonly DuckDBLogicalType logicalType;
 
     private readonly uint enumDictionarySize;
 
-    private readonly Dictionary<string, uint> enumValues;
+    private readonly Dictionary<string, uint> enumValues = [];
 
     public EnumVectorDataWriter(IntPtr vector, void* vectorData, DuckDBLogicalType logicalType, DuckDBType columnType) : base(vector, vectorData, columnType)
     {
+        this.logicalType = logicalType;
+
         enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);
         enumDictionarySize = NativeMethods.LogicalType.DuckDBEnumDictionarySize(logicalType);
 
-        uint maxEnumDictionarySize = enumType switch
+        var maxEnumDictionarySize = enumType switch
         {
             DuckDBType.UnsignedTinyInt => byte.MaxValue,
             DuckDBType.UnsignedSmallInt => ushort.MaxValue,
             DuckDBType.UnsignedInteger => uint.MaxValue,
             _ => throw new NotSupportedException($"The internal enum type must be utinyint, usmallint, or uinteger."),
         };
-        if (enumDictionarySize > maxEnumDictionarySize)
-        {
-            // This exception should only be thrown if the DuckDB library has a bug.
-            throw new InvalidOperationException($"The internal enum type is \"{enumType}\" but the enum dictionary size is greater than {maxEnumDictionarySize}.");
-        }
-       
-        enumValues = [];
-        for (uint index = 0; index < enumDictionarySize; index++)
-        {
-            string enumValueName = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, index).ToManagedString();
-            enumValues.Add(enumValueName, index);
-        }
     }
 
     internal override bool AppendString(string value, int rowIndex)
     {
-        if (enumValues.TryGetValue(value, out uint enumValue))
+        if (enumValues.Count == 0)
+        {
+            for (uint index = 0; index < enumDictionarySize; index++)
+            {
+                var enumValueName = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, index).ToManagedString();
+                enumValues.Add(enumValueName, index);
+            }
+        }
+
+        if (enumValues.TryGetValue(value, out var enumValue))
         {
             // The following casts to byte and ushort are safe because we ensure in the constructor that the value enumDictionarySize is not too high.
             return enumType switch
@@ -59,7 +59,7 @@ internal override bool AppendString(string value, int rowIndex)
 
     internal override bool AppendEnum<TEnum>(TEnum value, int rowIndex)
     {
-        ulong enumValue = ConvertEnumValueToUInt64(value);
+        var enumValue = ConvertEnumValueToUInt64(value);
         if (enumValue < enumDictionarySize)
         {
             // The following casts to byte, ushort and uint are safe because we ensure in the constructor that the value enumDictionarySize is not too high.
@@ -72,12 +72,12 @@ internal override bool AppendEnum<TEnum>(TEnum value, int rowIndex)
             };
         }
 
-        throw new InvalidOperationException($"Failed to write Enum column because the value is outside the range (0-{enumDictionarySize-1}).");
+        throw new InvalidOperationException($"Failed to write Enum column because the value is outside the range (0-{enumDictionarySize - 1}).");
     }
 
     private static ulong ConvertEnumValueToUInt64<TEnum>(TEnum value) where TEnum : Enum
     {
-        return Convert.GetTypeCode(value) switch
+        return value.GetTypeCode() switch
         {
             TypeCode.SByte => (ulong)Convert.ToSByte(value),
             TypeCode.Byte => Convert.ToByte(value),
@@ -90,4 +90,10 @@ private static ulong ConvertEnumValueToUInt64<TEnum>(TEnum value) where TEnum :
             _ => throw new InvalidOperationException($"Failed to convert the enum value {value} to ulong."),
         };
     }
+
+    public override void Dispose()
+    {
+        logicalType.Dispose();
+        base.Dispose();
+    }
 }

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

@@ -10,14 +10,15 @@ internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
 {
     private ulong offset = 0;
     private readonly ulong arraySize;
+    private readonly DuckDBLogicalType childType;
     private readonly VectorDataWriterBase listItemWriter;
 
     public bool IsList => ColumnType == DuckDBType.List;
     private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;
 
     public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)
     {
-        using var childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);
+        childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);
         var childVector = IsList ? NativeMethods.Vectors.DuckDBListVectorGetChild(vector) : NativeMethods.Vectors.DuckDBArrayVectorGetChild(vector);
 
         arraySize = IsList ? 0 : (ulong)NativeMethods.LogicalType.DuckDBArrayVectorGetSize(logicalType);
@@ -81,6 +82,7 @@ internal override bool AppendCollection(ICollection value, int rowIndex)
 #endif
             IEnumerable<DateTimeOffset> items => WriteItems(items),
             IEnumerable<DateTimeOffset?> items => WriteItems(items),
+            IEnumerable<object> items => WriteItems(items),
 
             _ => WriteItemsFallback(value),
         };
@@ -159,4 +161,10 @@ private void ResizeVector(int rowIndex, ulong count)
 
         listItemWriter.InitializerWriter();
     }
+
+    public override void Dispose()
+    {
+        listItemWriter.Dispose();
+        childType.Dispose();
+    }
 }

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

@@ -6,7 +6,7 @@
 
 namespace DuckDB.NET.Data.Internal.Writer;
 
-internal unsafe class VectorDataWriterBase(IntPtr vector, void* vectorData, DuckDBType columnType)
+internal unsafe class VectorDataWriterBase(IntPtr vector, void* vectorData, DuckDBType columnType) : IDisposable
 {
     private ulong* validity;
 
@@ -118,4 +118,9 @@ internal void InitializerWriter()
         validity = default;
         vectorData = NativeMethods.Vectors.DuckDBVectorGetData(Vector);
     }
+
+    public virtual void Dispose()
+    {
+        
+    }
 }