Optimize data reader hot path performance

Giorgi · Giorgi · commit 2b74ee9a07ec · 2026-03-12T17:41:52.000+04:00
diff --git a/DuckDB.NET.Data/DataChunk/Reader/BooleanVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/BooleanVectorDataReader.cs
@@ -6,13 +6,13 @@ internal unsafe BooleanVectorDataReader(void* dataPointer, ulong* validityMaskPo
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType != DuckDBType.Boolean)
         {
-            return base.GetValidValue<T>(offset, targetType);
+            return base.GetValidValue<T>(offset);
         }
-        
+
         var value = GetFieldData<bool>(offset);
         return (T)(object)value; //JIT will optimize the casts at least for not nullable T
     }
diff --git a/DuckDB.NET.Data/DataChunk/Reader/DateTimeVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/DateTimeVectorDataReader.cs
@@ -2,37 +2,32 @@
 
 internal sealed class DateTimeVectorDataReader : VectorDataReaderBase
 {
-    private static readonly Type DateTimeType = typeof(DateTime);
-    private static readonly Type DateTimeOffsetType = typeof(DateTimeOffset);
-    private static readonly Type DateOnlyType = typeof(DateOnly);
-    private static readonly Type TimeOnlyType = typeof(TimeOnly);
-
     internal unsafe DateTimeVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType == DuckDBType.Date)
         {
             var (dateOnly, isFinite) = GetDateOnly(offset);
 
             if (!isFinite)
             {
-                if (targetType == DateTimeType || targetType == DateOnlyType)
+                if (typeof(T) == typeof(DateTime) || typeof(T) == typeof(DateOnly))
                 {
                     ThrowInfinityDateException();
                 }
 
                 return (T)(object)dateOnly;
             }
 
-            if (targetType == DateTimeType)
+            if (typeof(T) == typeof(DateTime))
             {
                 return (T)(object)(DateTime)dateOnly;
             }
 
-            if (targetType == DateOnlyType)
+            if (typeof(T) == typeof(DateOnly))
             {
                 return (T)(object)(DateOnly)dateOnly;
             }
@@ -44,12 +39,12 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)
         {
             var timeOnly = GetTimeOnly(offset);
 
-            if (targetType == DateTimeType)
+            if (typeof(T) == typeof(DateTime))
             {
                 return (T)(object)(DateTime)timeOnly;
             }
 
-            if (targetType == TimeOnlyType)
+            if (typeof(T) == typeof(TimeOnly))
             {
                 return (T)(object)(TimeOnly)timeOnly;
             }
@@ -61,7 +56,7 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)
         {
             var timeTz = GetTimeTz(offset);
 
-            if (targetType == DateTimeOffsetType)
+            if (typeof(T) == typeof(DateTimeOffset))
             {
                 var dateTimeOffset = new DateTimeOffset(timeTz.Time.ToDateTime(), TimeSpan.FromSeconds(timeTz.Offset));
                 return (T)(object)dateTimeOffset;
@@ -74,18 +69,18 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)
         {
             DuckDBType.Timestamp or DuckDBType.TimestampS or
             DuckDBType.TimestampTz or DuckDBType.TimestampMs or
-            DuckDBType.TimestampNs => ReadTimestamp<T>(offset, targetType),
-            _ => base.GetValidValue<T>(offset, targetType)
+            DuckDBType.TimestampNs => ReadTimestamp<T>(offset),
+            _ => base.GetValidValue<T>(offset)
         };
     }
 
-    private T ReadTimestamp<T>(ulong offset, Type targetType)
+    private T ReadTimestamp<T>(ulong offset)
     {
         var timestampStruct = GetFieldData<DuckDBTimestampStruct>(offset);
 
         if (!timestampStruct.IsFinite(DuckDBType))
         {
-            if (targetType == DateTimeType || targetType == DateTimeOffsetType)
+            if (typeof(T) == typeof(DateTime) || typeof(T) == typeof(DateTimeOffset))
             {
                 ThrowInfinityTimestampException();
             }
@@ -95,12 +90,12 @@ private T ReadTimestamp<T>(ulong offset, Type targetType)
 
         var (timestamp, additionalTicks) = timestampStruct.ToDuckDBTimestamp(DuckDBType);
 
-        if (targetType == DateTimeType)
+        if (typeof(T) == typeof(DateTime))
         {
             return (T)(object)timestamp.ToDateTime().AddTicks(additionalTicks);
         }
 
-        if (targetType == DateTimeOffsetType)
+        if (typeof(T) == typeof(DateTimeOffset))
         {
             var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);
             return (T)(object)new DateTimeOffset(dateTime, TimeSpan.Zero);
@@ -148,20 +143,20 @@ private object GetDate(ulong offset, Type targetType)
 
         if (!isFinite)
         {
-            if (targetType == DateTimeType || targetType == DateOnlyType)
+            if (targetType == typeof(DateTime) || targetType == typeof(DateOnly))
             {
                 ThrowInfinityDateException();
             }
 
             return dateOnly;
         }
 
-        if (targetType == DateTimeType)
+        if (targetType == typeof(DateTime))
         {
             return (DateTime)dateOnly;
         }
 
-        if (targetType == DateOnlyType)
+        if (targetType == typeof(DateOnly))
         {
             return (DateOnly)dateOnly;
         }
@@ -172,12 +167,12 @@ private object GetDate(ulong offset, Type targetType)
     private object GetTime(ulong offset, Type targetType)
     {
         var timeOnly = GetTimeOnly(offset);
-        if (targetType == DateTimeType)
+        if (targetType == typeof(DateTime))
         {
             return (DateTime)timeOnly;
         }
 
-        if (targetType == TimeOnlyType)
+        if (targetType == typeof(TimeOnly))
         {
             return (TimeOnly)timeOnly;
         }
@@ -191,7 +186,7 @@ private object GetDateTime(ulong offset, Type targetType)
 
         if (!timestampStruct.IsFinite(DuckDBType))
         {
-            if (targetType == DateTimeType || targetType == DateTimeOffsetType)
+            if (targetType == typeof(DateTime) || targetType == typeof(DateTimeOffset))
             {
                 ThrowInfinityTimestampException();
             }
@@ -201,14 +196,14 @@ private object GetDateTime(ulong offset, Type targetType)
 
         var (timestamp, additionalTicks) = timestampStruct.ToDuckDBTimestamp(DuckDBType);
 
-        if (targetType == DateTimeType)
+        if (targetType == typeof(DateTime))
         {
             var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);
 
             return dateTime;
         }
 
-        if (targetType == DateTimeOffsetType)
+        if (targetType == typeof(DateTimeOffset))
         {
             var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);
             return new DateTimeOffset(dateTime, TimeSpan.Zero);
@@ -221,7 +216,7 @@ private object GetDateTimeOffset(ulong offset, Type targetType)
     {
         var timeTz = GetTimeTz(offset);
 
-        if (targetType == DateTimeOffsetType)
+        if (targetType == typeof(DateTimeOffset))
         {
             return new DateTimeOffset(timeTz.Time.ToDateTime(), TimeSpan.FromSeconds(timeTz.Offset));
         }
diff --git a/DuckDB.NET.Data/DataChunk/Reader/DecimalVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/DecimalVectorDataReader.cs
@@ -27,11 +27,11 @@ internal unsafe DecimalVectorDataReader(IntPtr vector, void* dataPointer, ulong*
 
     internal byte Precision { get; }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType != DuckDBType.Decimal)
         {
-            return base.GetValidValue<T>(offset, targetType);
+            return base.GetValidValue<T>(offset);
         }
 
         var value = GetDecimal(offset);
diff --git a/DuckDB.NET.Data/DataChunk/Reader/EnumVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/EnumVectorDataReader.cs
@@ -14,11 +14,11 @@ internal unsafe EnumVectorDataReader(IntPtr vector, void* dataPointer, ulong* va
         enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType != DuckDBType.Enum)
         {
-            return base.GetValidValue<T>(offset, targetType);
+            return base.GetValidValue<T>(offset);
         }
 
         switch (enumType)
diff --git a/DuckDB.NET.Data/DataChunk/Reader/GuidVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/GuidVectorDataReader.cs
@@ -6,11 +6,11 @@ internal unsafe GuidVectorDataReader(void* dataPointer, ulong* validityMaskPoint
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType != DuckDBType.Uuid)
         {
-            return base.GetValidValue<T>(offset, targetType);
+            return base.GetValidValue<T>(offset);
         }
 
         var hugeInt = GetFieldData<DuckDBHugeInt>(offset);
diff --git a/DuckDB.NET.Data/DataChunk/Reader/IntervalVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/IntervalVectorDataReader.cs
@@ -2,19 +2,17 @@
 
 internal sealed class IntervalVectorDataReader : VectorDataReaderBase
 {
-    private static readonly Type TimeSpanType = typeof(TimeSpan);
-
     internal unsafe IntervalVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         if (DuckDBType == DuckDBType.Interval)
         {
             var interval = GetFieldData<DuckDBInterval>(offset);
 
-            if (targetType == TimeSpanType)
+            if (typeof(T) == typeof(TimeSpan))
             {
                 var timeSpan = (TimeSpan)interval;
                 return (T)(object)timeSpan;
@@ -23,7 +21,7 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)
             return (T)(object)interval;
         }
 
-        return base.GetValidValue<T>(offset, targetType);
+        return base.GetValidValue<T>(offset);
     }
 
     internal override object GetValue(ulong offset, Type targetType)
@@ -39,7 +37,7 @@ private object GetInterval(ulong offset, Type targetType)
     {
         var interval = GetFieldData<DuckDBInterval>(offset);
 
-        if (targetType == TimeSpanType)
+        if (targetType == typeof(TimeSpan))
         {
             return (TimeSpan)interval;
         }
diff --git a/DuckDB.NET.Data/DataChunk/Reader/NumericVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/NumericVectorDataReader.cs
@@ -11,14 +11,14 @@ internal unsafe NumericVectorDataReader(void* dataPointer, ulong* validityMaskPo
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         var isFloatingNumericType = TypeExtensions.IsFloatingNumericType<T>();
         var isIntegralNumericType = TypeExtensions.IsIntegralNumericType<T>();
 
         if (!(isIntegralNumericType || isFloatingNumericType))
         {
-            return base.GetValidValue<T>(offset, targetType);
+            return base.GetValidValue<T>(offset);
         }
 
         //If T is integral type and column is also integral read the data and use Unsafe.As<> or Convert.ChangeType to change type
@@ -39,15 +39,15 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)
                 DuckDBType.HugeInt => GetBigInteger<T>(offset, false),
                 DuckDBType.UnsignedHugeInt => GetBigInteger<T>(offset, true),
                 DuckDBType.VarInt => GetBigInteger<T>(offset),
-                _ => base.GetValidValue<T>(offset, targetType)
+                _ => base.GetValidValue<T>(offset)
             };
         }
 
         return DuckDBType switch
         {
             DuckDBType.Float => (T)(object)GetFieldData<float>(offset),
             DuckDBType.Double => (T)(object)GetFieldData<double>(offset),
-            _ => base.GetValidValue<T>(offset, targetType)
+            _ => base.GetValidValue<T>(offset)
         };
     }
 
diff --git a/DuckDB.NET.Data/DataChunk/Reader/StringVectorDataReader.cs b/DuckDB.NET.Data/DataChunk/Reader/StringVectorDataReader.cs
@@ -1,4 +1,4 @@
-﻿using System.IO;
+using System.IO;
 using System.Text;
 
 namespace DuckDB.NET.Data.DataChunk.Reader;
@@ -9,14 +9,14 @@ internal unsafe StringVectorDataReader(void* dataPointer, ulong* validityMaskPoi
     {
     }
 
-    protected override T GetValidValue<T>(ulong offset, Type targetType)
+    protected override T GetValidValue<T>(ulong offset)
     {
         return DuckDBType switch
         {
             DuckDBType.Bit => GetBitString<T>(offset),
             DuckDBType.Blob => (T)(object)GetStream(offset),
             DuckDBType.Varchar => (T)(object)GetString(offset),
-            _ => base.GetValidValue<T>(offset, targetType)
+            _ => base.GetValidValue<T>(offset)
         };
     }
 
@@ -99,4 +99,4 @@ private unsafe Stream GetStream(ulong offset)
 
         return new UnmanagedMemoryStream((byte*)data->Data, data->Length, data->Length, FileAccess.Read);
     }
-}
+}
diff --git a/DuckDB.NET.Data/DataChunk/Reader/VectorDataReaderBase.cs b/DuckDB.NET.Data/DataChunk/Reader/VectorDataReaderBase.cs
@@ -45,10 +45,13 @@ public unsafe bool IsValid(ulong offset)
         return isValid;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public T GetValue<T>(ulong offset) => GetValue<T>(offset, strict: false);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal T GetValueStrict<T>(ulong offset) => GetValue<T>(offset, strict: true);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal T GetValue<T>(ulong offset, bool strict)
     {
         // When T is Nullable<TUnderlying> (e.g. int?), we can't call GetValidValue<int>() directly
@@ -62,7 +65,7 @@ internal T GetValue<T>(ulong offset, bool strict)
 
         if (IsValid(offset))
         {
-            return GetValidValue<T>(offset, typeof(T));
+            return GetValidValue<T>(offset);
         }
 
         if (strict || !NullableHandler<T>.IsReferenceType)
@@ -77,9 +80,8 @@ internal T GetValue<T>(ulong offset, bool strict)
     /// </summary>
     /// <typeparam name="T">Type of the return value</typeparam>
     /// <param name="offset">Position to read the data from</param>
-    /// <param name="targetType">Type of the return value</param>
     /// <returns>Data at the specified offset</returns>
-    protected virtual T GetValidValue<T>(ulong offset, Type targetType) => (T)GetValue(offset, targetType);
+    protected virtual T GetValidValue<T>(ulong offset) => (T)GetValue(offset, typeof(T));
 
     public object GetValue(ulong offset)
     {
@@ -215,7 +217,7 @@ static NullableHandler()
         // For T = int?, builds a delegate equivalent to:
         //   (VectorDataReaderBase reader, ulong offset) =>
         //       reader.IsValid(offset)
-        //           ? (int?)reader.GetValidValue<int>(offset, typeof(int))
+        //           ? (int?)reader.GetValidValue<int>(offset)
         //           : default(int?)
         private static Func<VectorDataReaderBase, ulong, T> Compile()
         {
@@ -229,7 +231,7 @@ private static Func<VectorDataReaderBase, ulong, T> Compile()
             var methodInfo = typeof(VectorDataReaderBase).GetMethod(nameof(GetValidValue), BindingFlags.Instance | BindingFlags.NonPublic)!;
             var genericGetValidValue = methodInfo.MakeGenericMethod(underlyingType);
 
-            var getValidValue = Expression.Call(reader, genericGetValidValue, offset, Expression.Constant(underlyingType));
+            var getValidValue = Expression.Call(reader, genericGetValidValue, offset);
 
             var body = Expression.Condition(isValid, Expression.Convert(getValidValue, type), Expression.Default(type));
 
diff --git a/DuckDB.NET.Data/DuckDBDataReader.cs b/DuckDB.NET.Data/DuckDBDataReader.cs
diff --git a/DuckDB.NET.Data/Extensions/TypeExtensions.cs b/DuckDB.NET.Data/Extensions/TypeExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ internal unsafe BooleanVectorDataReader(void* dataPointer, ulong* validityMaskPo`
`6`	`6`	`{`
`7`	`7`	`}`
`8`	`8`
`9`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`9`	`+ protected override T GetValidValue<T>(ulong offset)`
`10`	`10`	`{`
`11`	`11`	`if (DuckDBType != DuckDBType.Boolean)`
`12`	`12`	`{`
`13`		`- return base.GetValidValue<T>(offset, targetType);`
	`13`	`+ return base.GetValidValue<T>(offset);`
`14`	`14`	`}`
`15`		`-`
	`15`	`+`
`16`	`16`	`var value = GetFieldData<bool>(offset);`
`17`	`17`	`return (T)(object)value; //JIT will optimize the casts at least for not nullable T`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,37 +2,32 @@`
`2`	`2`
`3`	`3`	`internal sealed class DateTimeVectorDataReader : VectorDataReaderBase`
`4`	`4`	`{`
`5`		`- private static readonly Type DateTimeType = typeof(DateTime);`
`6`		`- private static readonly Type DateTimeOffsetType = typeof(DateTimeOffset);`
`7`		`- private static readonly Type DateOnlyType = typeof(DateOnly);`
`8`		`- private static readonly Type TimeOnlyType = typeof(TimeOnly);`
`9`		`-`
`10`	`5`	`internal unsafe DateTimeVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)`
`11`	`6`	`{`
`12`	`7`	`}`
`13`	`8`
`14`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`9`	`+ protected override T GetValidValue<T>(ulong offset)`
`15`	`10`	`{`
`16`	`11`	`if (DuckDBType == DuckDBType.Date)`
`17`	`12`	`{`
`18`	`13`	`var (dateOnly, isFinite) = GetDateOnly(offset);`
`19`	`14`
`20`	`15`	`if (!isFinite)`
`21`	`16`	`{`
`22`		`- if (targetType == DateTimeType \|\| targetType == DateOnlyType)`
	`17`	`+ if (typeof(T) == typeof(DateTime) \|\| typeof(T) == typeof(DateOnly))`
`23`	`18`	`{`
`24`	`19`	`ThrowInfinityDateException();`
`25`	`20`	`}`
`26`	`21`
`27`	`22`	`return (T)(object)dateOnly;`
`28`	`23`	`}`
`29`	`24`
`30`		`- if (targetType == DateTimeType)`
	`25`	`+ if (typeof(T) == typeof(DateTime))`
`31`	`26`	`{`
`32`	`27`	`return (T)(object)(DateTime)dateOnly;`
`33`	`28`	`}`
`34`	`29`
`35`		`- if (targetType == DateOnlyType)`
	`30`	`+ if (typeof(T) == typeof(DateOnly))`
`36`	`31`	`{`
`37`	`32`	`return (T)(object)(DateOnly)dateOnly;`
`38`	`33`	`}`
`@@ -44,12 +39,12 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)`
`44`	`39`	`{`
`45`	`40`	`var timeOnly = GetTimeOnly(offset);`
`46`	`41`
`47`		`- if (targetType == DateTimeType)`
	`42`	`+ if (typeof(T) == typeof(DateTime))`
`48`	`43`	`{`
`49`	`44`	`return (T)(object)(DateTime)timeOnly;`
`50`	`45`	`}`
`51`	`46`
`52`		`- if (targetType == TimeOnlyType)`
	`47`	`+ if (typeof(T) == typeof(TimeOnly))`
`53`	`48`	`{`
`54`	`49`	`return (T)(object)(TimeOnly)timeOnly;`
`55`	`50`	`}`
`@@ -61,7 +56,7 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)`
`61`	`56`	`{`
`62`	`57`	`var timeTz = GetTimeTz(offset);`
`63`	`58`
`64`		`- if (targetType == DateTimeOffsetType)`
	`59`	`+ if (typeof(T) == typeof(DateTimeOffset))`
`65`	`60`	`{`
`66`	`61`	`var dateTimeOffset = new DateTimeOffset(timeTz.Time.ToDateTime(), TimeSpan.FromSeconds(timeTz.Offset));`
`67`	`62`	`return (T)(object)dateTimeOffset;`
`@@ -74,18 +69,18 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)`
`74`	`69`	`{`
`75`	`70`	`DuckDBType.Timestamp or DuckDBType.TimestampS or`
`76`	`71`	`DuckDBType.TimestampTz or DuckDBType.TimestampMs or`
`77`		`- DuckDBType.TimestampNs => ReadTimestamp<T>(offset, targetType),`
`78`		`- _ => base.GetValidValue<T>(offset, targetType)`
	`72`	`+ DuckDBType.TimestampNs => ReadTimestamp<T>(offset),`
	`73`	`+ _ => base.GetValidValue<T>(offset)`
`79`	`74`	`};`
`80`	`75`	`}`
`81`	`76`
`82`		`- private T ReadTimestamp<T>(ulong offset, Type targetType)`
	`77`	`+ private T ReadTimestamp<T>(ulong offset)`
`83`	`78`	`{`
`84`	`79`	`var timestampStruct = GetFieldData<DuckDBTimestampStruct>(offset);`
`85`	`80`
`86`	`81`	`if (!timestampStruct.IsFinite(DuckDBType))`
`87`	`82`	`{`
`88`		`- if (targetType == DateTimeType \|\| targetType == DateTimeOffsetType)`
	`83`	`+ if (typeof(T) == typeof(DateTime) \|\| typeof(T) == typeof(DateTimeOffset))`
`89`	`84`	`{`
`90`	`85`	`ThrowInfinityTimestampException();`
`91`	`86`	`}`
`@@ -95,12 +90,12 @@ private T ReadTimestamp<T>(ulong offset, Type targetType)`
`95`	`90`
`96`	`91`	`var (timestamp, additionalTicks) = timestampStruct.ToDuckDBTimestamp(DuckDBType);`
`97`	`92`
`98`		`- if (targetType == DateTimeType)`
	`93`	`+ if (typeof(T) == typeof(DateTime))`
`99`	`94`	`{`
`100`	`95`	`return (T)(object)timestamp.ToDateTime().AddTicks(additionalTicks);`
`101`	`96`	`}`
`102`	`97`
`103`		`- if (targetType == DateTimeOffsetType)`
	`98`	`+ if (typeof(T) == typeof(DateTimeOffset))`
`104`	`99`	`{`
`105`	`100`	`var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);`
`106`	`101`	`return (T)(object)new DateTimeOffset(dateTime, TimeSpan.Zero);`
`@@ -148,20 +143,20 @@ private object GetDate(ulong offset, Type targetType)`
`148`	`143`
`149`	`144`	`if (!isFinite)`
`150`	`145`	`{`
`151`		`- if (targetType == DateTimeType \|\| targetType == DateOnlyType)`
	`146`	`+ if (targetType == typeof(DateTime) \|\| targetType == typeof(DateOnly))`
`152`	`147`	`{`
`153`	`148`	`ThrowInfinityDateException();`
`154`	`149`	`}`
`155`	`150`
`156`	`151`	`return dateOnly;`
`157`	`152`	`}`
`158`	`153`
`159`		`- if (targetType == DateTimeType)`
	`154`	`+ if (targetType == typeof(DateTime))`
`160`	`155`	`{`
`161`	`156`	`return (DateTime)dateOnly;`
`162`	`157`	`}`
`163`	`158`
`164`		`- if (targetType == DateOnlyType)`
	`159`	`+ if (targetType == typeof(DateOnly))`
`165`	`160`	`{`
`166`	`161`	`return (DateOnly)dateOnly;`
`167`	`162`	`}`
`@@ -172,12 +167,12 @@ private object GetDate(ulong offset, Type targetType)`
`172`	`167`	`private object GetTime(ulong offset, Type targetType)`
`173`	`168`	`{`
`174`	`169`	`var timeOnly = GetTimeOnly(offset);`
`175`		`- if (targetType == DateTimeType)`
	`170`	`+ if (targetType == typeof(DateTime))`
`176`	`171`	`{`
`177`	`172`	`return (DateTime)timeOnly;`
`178`	`173`	`}`
`179`	`174`
`180`		`- if (targetType == TimeOnlyType)`
	`175`	`+ if (targetType == typeof(TimeOnly))`
`181`	`176`	`{`
`182`	`177`	`return (TimeOnly)timeOnly;`
`183`	`178`	`}`
`@@ -191,7 +186,7 @@ private object GetDateTime(ulong offset, Type targetType)`
`191`	`186`
`192`	`187`	`if (!timestampStruct.IsFinite(DuckDBType))`
`193`	`188`	`{`
`194`		`- if (targetType == DateTimeType \|\| targetType == DateTimeOffsetType)`
	`189`	`+ if (targetType == typeof(DateTime) \|\| targetType == typeof(DateTimeOffset))`
`195`	`190`	`{`
`196`	`191`	`ThrowInfinityTimestampException();`
`197`	`192`	`}`
`@@ -201,14 +196,14 @@ private object GetDateTime(ulong offset, Type targetType)`
`201`	`196`
`202`	`197`	`var (timestamp, additionalTicks) = timestampStruct.ToDuckDBTimestamp(DuckDBType);`
`203`	`198`
`204`		`- if (targetType == DateTimeType)`
	`199`	`+ if (targetType == typeof(DateTime))`
`205`	`200`	`{`
`206`	`201`	`var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);`
`207`	`202`
`208`	`203`	`return dateTime;`
`209`	`204`	`}`
`210`	`205`
`211`		`- if (targetType == DateTimeOffsetType)`
	`206`	`+ if (targetType == typeof(DateTimeOffset))`
`212`	`207`	`{`
`213`	`208`	`var dateTime = timestamp.ToDateTime().AddTicks(additionalTicks);`
`214`	`209`	`return new DateTimeOffset(dateTime, TimeSpan.Zero);`
`@@ -221,7 +216,7 @@ private object GetDateTimeOffset(ulong offset, Type targetType)`
`221`	`216`	`{`
`222`	`217`	`var timeTz = GetTimeTz(offset);`
`223`	`218`
`224`		`- if (targetType == DateTimeOffsetType)`
	`219`	`+ if (targetType == typeof(DateTimeOffset))`
`225`	`220`	`{`
`226`	`221`	`return new DateTimeOffset(timeTz.Time.ToDateTime(), TimeSpan.FromSeconds(timeTz.Offset));`
`227`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,11 @@ internal unsafe DecimalVectorDataReader(IntPtr vector, void* dataPointer, ulong*`
`27`	`27`
`28`	`28`	`internal byte Precision { get; }`
`29`	`29`
`30`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`30`	`+ protected override T GetValidValue<T>(ulong offset)`
`31`	`31`	`{`
`32`	`32`	`if (DuckDBType != DuckDBType.Decimal)`
`33`	`33`	`{`
`34`		`- return base.GetValidValue<T>(offset, targetType);`
	`34`	`+ return base.GetValidValue<T>(offset);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`var value = GetDecimal(offset);`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,11 @@ internal unsafe EnumVectorDataReader(IntPtr vector, void* dataPointer, ulong* va`
`14`	`14`	`enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);`
`15`	`15`	`}`
`16`	`16`
`17`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`17`	`+ protected override T GetValidValue<T>(ulong offset)`
`18`	`18`	`{`
`19`	`19`	`if (DuckDBType != DuckDBType.Enum)`
`20`	`20`	`{`
`21`		`- return base.GetValidValue<T>(offset, targetType);`
	`21`	`+ return base.GetValidValue<T>(offset);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`switch (enumType)`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ internal unsafe GuidVectorDataReader(void* dataPointer, ulong* validityMaskPoint`
`6`	`6`	`{`
`7`	`7`	`}`
`8`	`8`
`9`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`9`	`+ protected override T GetValidValue<T>(ulong offset)`
`10`	`10`	`{`
`11`	`11`	`if (DuckDBType != DuckDBType.Uuid)`
`12`	`12`	`{`
`13`		`- return base.GetValidValue<T>(offset, targetType);`
	`13`	`+ return base.GetValidValue<T>(offset);`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`var hugeInt = GetFieldData<DuckDBHugeInt>(offset);`
Original file line number	Diff line number	Diff line change
`@@ -2,19 +2,17 @@`
`2`	`2`
`3`	`3`	`internal sealed class IntervalVectorDataReader : VectorDataReaderBase`
`4`	`4`	`{`
`5`		`- private static readonly Type TimeSpanType = typeof(TimeSpan);`
`6`		`-`
`7`	`5`	`internal unsafe IntervalVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)`
`8`	`6`	`{`
`9`	`7`	`}`
`10`	`8`
`11`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`9`	`+ protected override T GetValidValue<T>(ulong offset)`
`12`	`10`	`{`
`13`	`11`	`if (DuckDBType == DuckDBType.Interval)`
`14`	`12`	`{`
`15`	`13`	`var interval = GetFieldData<DuckDBInterval>(offset);`
`16`	`14`
`17`		`- if (targetType == TimeSpanType)`
	`15`	`+ if (typeof(T) == typeof(TimeSpan))`
`18`	`16`	`{`
`19`	`17`	`var timeSpan = (TimeSpan)interval;`
`20`	`18`	`return (T)(object)timeSpan;`
`@@ -23,7 +21,7 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)`
`23`	`21`	`return (T)(object)interval;`
`24`	`22`	`}`
`25`	`23`
`26`		`- return base.GetValidValue<T>(offset, targetType);`
	`24`	`+ return base.GetValidValue<T>(offset);`
`27`	`25`	`}`
`28`	`26`
`29`	`27`	`internal override object GetValue(ulong offset, Type targetType)`
`@@ -39,7 +37,7 @@ private object GetInterval(ulong offset, Type targetType)`
`39`	`37`	`{`
`40`	`38`	`var interval = GetFieldData<DuckDBInterval>(offset);`
`41`	`39`
`42`		`- if (targetType == TimeSpanType)`
	`40`	`+ if (targetType == typeof(TimeSpan))`
`43`	`41`	`{`
`44`	`42`	`return (TimeSpan)interval;`
`45`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,14 @@ internal unsafe NumericVectorDataReader(void* dataPointer, ulong* validityMaskPo`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`14`	`+ protected override T GetValidValue<T>(ulong offset)`
`15`	`15`	`{`
`16`	`16`	`var isFloatingNumericType = TypeExtensions.IsFloatingNumericType<T>();`
`17`	`17`	`var isIntegralNumericType = TypeExtensions.IsIntegralNumericType<T>();`
`18`	`18`
`19`	`19`	`if (!(isIntegralNumericType \|\| isFloatingNumericType))`
`20`	`20`	`{`
`21`		`- return base.GetValidValue<T>(offset, targetType);`
	`21`	`+ return base.GetValidValue<T>(offset);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`//If T is integral type and column is also integral read the data and use Unsafe.As<> or Convert.ChangeType to change type`
`@@ -39,15 +39,15 @@ protected override T GetValidValue<T>(ulong offset, Type targetType)`
`39`	`39`	`DuckDBType.HugeInt => GetBigInteger<T>(offset, false),`
`40`	`40`	`DuckDBType.UnsignedHugeInt => GetBigInteger<T>(offset, true),`
`41`	`41`	`DuckDBType.VarInt => GetBigInteger<T>(offset),`
`42`		`- _ => base.GetValidValue<T>(offset, targetType)`
	`42`	`+ _ => base.GetValidValue<T>(offset)`
`43`	`43`	`};`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`return DuckDBType switch`
`47`	`47`	`{`
`48`	`48`	`DuckDBType.Float => (T)(object)GetFieldData<float>(offset),`
`49`	`49`	`DuckDBType.Double => (T)(object)GetFieldData<double>(offset),`
`50`		`- _ => base.GetValidValue<T>(offset, targetType)`
	`50`	`+ _ => base.GetValidValue<T>(offset)`
`51`	`51`	`};`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System.IO;`
	`1`	`+using System.IO;`
`2`	`2`	`using System.Text;`
`3`	`3`
`4`	`4`	`namespace DuckDB.NET.Data.DataChunk.Reader;`
`@@ -9,14 +9,14 @@ internal unsafe StringVectorDataReader(void* dataPointer, ulong* validityMaskPoi`
`9`	`9`	`{`
`10`	`10`	`}`
`11`	`11`
`12`		`- protected override T GetValidValue<T>(ulong offset, Type targetType)`
	`12`	`+ protected override T GetValidValue<T>(ulong offset)`
`13`	`13`	`{`
`14`	`14`	`return DuckDBType switch`
`15`	`15`	`{`
`16`	`16`	`DuckDBType.Bit => GetBitString<T>(offset),`
`17`	`17`	`DuckDBType.Blob => (T)(object)GetStream(offset),`
`18`	`18`	`DuckDBType.Varchar => (T)(object)GetString(offset),`
`19`		`- _ => base.GetValidValue<T>(offset, targetType)`
	`19`	`+ _ => base.GetValidValue<T>(offset)`
`20`	`20`	`};`
`21`	`21`	`}`
`22`	`22`
`@@ -99,4 +99,4 @@ private unsafe Stream GetStream(ulong offset)`
`99`	`99`
`100`	`100`	`return new UnmanagedMemoryStream((byte*)data->Data, data->Length, data->Length, FileAccess.Read);`
`101`	`101`	`}`
`102`		`-}`
	`102`	`+}`