6455368055

Committed 09 Oct 2023 10:24AM UTC coverage: 87.63% (-0.2%) from 87.852%

Build # 6455368055

Build Type

push

github

Committed by

Giorgi

Commit Message

Revert "Dynamic experiment"

Run Details

300 of 354 branches covered (0.0%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

883 of 996 relevant lines covered (88.65%)

16244.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.97

/DuckDB.NET.Data/VectorDataReader.cs

﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Numerics;
using System.Text;

namespace DuckDB.NET.Data;

internal class VectorDataReader : IDisposable
{
    private const int InlineStringMaxLength = 12;

    private readonly IntPtr vector;
    private readonly unsafe void* dataPointer;
    private readonly unsafe ulong* validityMaskPointer;
    private readonly DuckDBLogicalType logicalType;
    internal Type ClrType { get; }
    internal DuckDBType ColumnDuckDBType { get; }

    private readonly VectorDataReader listDataReader;

    private readonly byte scale;
    private readonly DuckDBType decimalType;
    private readonly DuckDBType enumType;

    internal unsafe VectorDataReader(IntPtr vector, void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType)
    {
        this.vector = vector;
        this.dataPointer = dataPointer;
        this.validityMaskPointer = validityMaskPointer;
        
        ColumnDuckDBType = columnType;

        logicalType = NativeMethods.DataChunks.DuckDBVectorGetColumnType(vector);

        ClrType = ColumnDuckDBType switch
        {
            DuckDBType.Invalid => throw new DuckDBException("Invalid type"),
            DuckDBType.Boolean => typeof(bool),
            DuckDBType.TinyInt => typeof(sbyte),
            DuckDBType.SmallInt => typeof(short),
            DuckDBType.Integer => typeof(int),
            DuckDBType.BigInt => typeof(long),
            DuckDBType.UnsignedTinyInt => typeof(byte),
            DuckDBType.UnsignedSmallInt => typeof(ushort),
            DuckDBType.UnsignedInteger => typeof(uint),
            DuckDBType.UnsignedBigInt => typeof(ulong),
            DuckDBType.Float => typeof(float),
            DuckDBType.Double => typeof(double),
            DuckDBType.Timestamp => typeof(DateTime),
            DuckDBType.Interval => typeof(DuckDBInterval),
            DuckDBType.Date => typeof(DuckDBDateOnly),
            DuckDBType.Time => typeof(DuckDBTimeOnly),
            DuckDBType.HugeInt => typeof(BigInteger),
            DuckDBType.Varchar => typeof(string),
            DuckDBType.Decimal => typeof(decimal),
            DuckDBType.Blob => typeof(Stream),
            DuckDBType.Enum => typeof(Enum),
            DuckDBType.List => typeof(List<>),
            var type => throw new ArgumentException($"Unrecognised type {type} ({(int)type})")
        };

        switch (ColumnDuckDBType)
        {
            case DuckDBType.Enum:
                enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);
                break;
            case DuckDBType.Decimal:
                scale = NativeMethods.LogicalType.DuckDBDecimalScale(logicalType);
                decimalType = NativeMethods.LogicalType.DuckDBDecimalInternalType(logicalType);
                break;
            case DuckDBType.List:
                {
                    using var childType = NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType);
                    var type = NativeMethods.LogicalType.DuckDBGetTypeId(childType);

                    var childVector = NativeMethods.DataChunks.DuckDBListVectorGetChild(vector);

                    var childVectorData = NativeMethods.DataChunks.DuckDBVectorGetData(childVector);
                    var childVectorValidity = NativeMethods.DataChunks.DuckDBVectorGetValidity(childVector);

                    listDataReader = new VectorDataReader(childVector, childVectorData, childVectorValidity, type);
                    break;
                }
        }
    }

    internal unsafe bool IsValid(ulong offset)
    {
        var validityMaskEntryIndex = offset / 64;
        var validityBitIndex = (int)(offset % 64);

        var validityMaskEntryPtr = validityMaskPointer + validityMaskEntryIndex;
        var validityBit = 1ul << validityBitIndex;

        var isValid = (*validityMaskEntryPtr & validityBit) != 0;
        return isValid;
    }

    internal unsafe T GetFieldData<T>(ulong offset) where T : unmanaged => *((T*)dataPointer + offset);

    internal decimal GetDecimal(ulong offset)
    {
        var pow = (decimal)Math.Pow(10, scale);
        switch (decimalType)
        {
            case DuckDBType.SmallInt:
                return decimal.Divide(GetFieldData<short>(offset), pow);
            case DuckDBType.Integer:
                return decimal.Divide(GetFieldData<int>(offset), pow);
            case DuckDBType.BigInt:
                return decimal.Divide(GetFieldData<long>(offset), pow);
            case DuckDBType.HugeInt:
                {
                    var hugeInt = GetBigInteger(offset);

                    var result = (decimal)BigInteger.DivRem(hugeInt, (BigInteger)pow, out var remainder);

                    result += decimal.Divide((decimal)remainder, pow);
                    return result;
                }
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    internal unsafe string GetString(ulong offset)
    {
        var data = (DuckDBString*)dataPointer + offset;
        var length = *(int*)data;

        var pointer = length <= InlineStringMaxLength
            ? data->value.inlined.inlined
            : data->value.pointer.ptr;

        return new string(pointer, 0, length, Encoding.UTF8);
    }

    internal unsafe Stream GetStream(ulong offset)
    {
        var data = (DuckDBString*)dataPointer + offset;
        var length = *(int*)data;

        if (length <= InlineStringMaxLength)
        {
            var value = new string(data->value.inlined.inlined, 0, length, Encoding.UTF8);
            return new MemoryStream(Encoding.UTF8.GetBytes(value), false);
        }

        return new UnmanagedMemoryStream((byte*)data->value.pointer.ptr, length, length, FileAccess.Read);
    }

    internal unsafe DateTime GetDateTime(ulong offset)
    {
        if (ColumnDuckDBType == DuckDBType.Date)
        {
            return GetDateOnly(offset).ToDateTime();
        }
        var data = (DuckDBTimestampStruct*)dataPointer + offset;
        return data->ToDateTime();
    }

    internal unsafe BigInteger GetBigInteger(ulong offset)
    {
        var data = (DuckDBHugeInt*)dataPointer + offset;
        return data->ToBigInteger();
    }

    internal object GetEnum(ulong offset, Type returnType)
    {
        long enumValue = enumType switch
        {
            DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),
            DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),
            DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),
            _ => -1
        };

        if (returnType == typeof(string))
        {
            var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, enumValue).ToManagedString();
            return value;
        }

        var underlyingType = Nullable.GetUnderlyingType(returnType);
        if (underlyingType != null)
        {
            if (!IsValid(offset))
            {
                return default;
            }
            returnType = underlyingType;
        }

        var enumItem = Enum.Parse(returnType, enumValue.ToString(CultureInfo.InvariantCulture));
        return enumItem;
    }

    internal unsafe object GetList(ulong offset, Type returnType)
    {
        var listData = (DuckDBListEntry*)dataPointer + offset;

        var genericArgument = returnType?.GetGenericArguments()[0];

        var nullableType = genericArgument == null ? null : Nullable.GetUnderlyingType(genericArgument);
        var allowNulls = returnType != null && (!genericArgument.IsValueType || nullableType != null);

        var list = Activator.CreateInstance(returnType) as IList;

        var targetType = returnType.GetGenericArguments()[0];

        if (Nullable.GetUnderlyingType(targetType) != null)
        {
            targetType = targetType.GetGenericArguments()[0];
        }

        for (ulong i = 0; i < listData->Length; i++)
        {
            var childOffset = i + listData->Offset;
            if (listDataReader.IsValid(childOffset))
            {
                var item = listDataReader.GetValue(childOffset, targetType);
                list.Add(item);
            }
            else
            {
                if (allowNulls)
                {
                    list.Add(null);
                }
                else
                {
                    throw new NullReferenceException("The list contains null value");
                }
            }
        }

        return list;
    }

    internal object GetValue(ulong offset, Type targetType = null)
    {
        return ColumnDuckDBType switch
        {
            DuckDBType.Invalid => throw new DuckDBException("Invalid type"),
            DuckDBType.Boolean => GetFieldData<bool>(offset),
            DuckDBType.TinyInt => GetFieldData<sbyte>(offset),
            DuckDBType.SmallInt => GetFieldData<short>(offset),
            DuckDBType.Integer => GetFieldData<int>(offset),
            DuckDBType.BigInt => GetFieldData<long>(offset),
            DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),
            DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),
            DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),
            DuckDBType.UnsignedBigInt => GetFieldData<ulong>(offset),
            DuckDBType.Float => GetFieldData<float>(offset),
            DuckDBType.Double => GetFieldData<double>(offset),
            DuckDBType.Timestamp => GetDateTime(offset),
            DuckDBType.Interval => GetFieldData<DuckDBInterval>(offset),
            DuckDBType.Date => GetDate(offset, targetType),
            DuckDBType.Time => GetTime(offset, targetType),
            DuckDBType.HugeInt => GetBigInteger(offset),
            DuckDBType.Varchar => GetString(offset),
            DuckDBType.Decimal => GetDecimal(offset),
            DuckDBType.Blob => GetStream(offset),
            DuckDBType.List => GetList(offset, targetType ?? typeof(List<>).MakeGenericType(listDataReader.ClrType)),
            DuckDBType.Enum => GetEnum(offset, targetType ?? typeof(string)),
            var type => throw new ArgumentException($"Unrecognised type {type} ({(int)type}) in column {offset + 1}")
        };
    }

    private DuckDBTimeOnly GetTime(ulong offset)
    {
        return NativeMethods.DateTime.DuckDBFromTime(GetFieldData<DuckDBTime>(offset));
    }

    private DuckDBDateOnly GetDateOnly(ulong offset)
    {
        return NativeMethods.DateTime.DuckDBFromDate(GetFieldData<DuckDBDate>(offset));
    }

    private object GetDate(ulong offset, Type targetType)
    {
        var dateOnly = GetDateOnly(offset);
        if (targetType == typeof(DateTime))
        {
            return (DateTime)dateOnly;
        }

#if NET6_0_OR_GREATER
        if (targetType == typeof(DateOnly))
        {
            return (DateOnly)dateOnly;
        }
#endif

        return dateOnly;
    }

    private object GetTime(ulong offset, Type targetType)
    {
        var timeOnly = GetTime(offset);
        if (targetType == typeof(DateTime))
        {
            return (DateTime)timeOnly;
        }

#if NET6_0_OR_GREATER
        if (targetType == typeof(TimeOnly))
        {
            return (TimeOnly)timeOnly;
        }
#endif

        return timeOnly;
    }

    public void Dispose()
    {
        listDataReader?.Dispose();
        logicalType?.Dispose();
    }
}

1	using System;
2	using System.Collections;
3	using System.Collections.Generic;
4	using System.Globalization;
5	using System.IO;
6	using System.Numerics;
7	using System.Text;
8
9	namespace DuckDB.NET.Data;
10
11	internal class VectorDataReader : IDisposable
12	{
13	private const int InlineStringMaxLength = 12;
14
15	private readonly IntPtr vector;
16	private readonly unsafe void* dataPointer;
17	private readonly unsafe ulong* validityMaskPointer;
18	private readonly DuckDBLogicalType logicalType;
19	internal Type ClrType { get; }	309✔
20	internal DuckDBType ColumnDuckDBType { get; }	4,193✔
21
22	private readonly VectorDataReader listDataReader;
23
24	private readonly byte scale;
25	private readonly DuckDBType decimalType;
26	private readonly DuckDBType enumType;
27
28	internal unsafe VectorDataReader(IntPtr vector, void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType)	1,162✔
29	{
30	this.vector = vector;	1,162✔
31	this.dataPointer = dataPointer;	1,162✔
32	this.validityMaskPointer = validityMaskPointer;	1,162✔
33
34	ColumnDuckDBType = columnType;	1,162✔
35
36	logicalType = NativeMethods.DataChunks.DuckDBVectorGetColumnType(vector);	1,162✔
37
38	ClrType = ColumnDuckDBType switch	1,162!
39	{	1,162✔
40	DuckDBType.Invalid => throw new DuckDBException("Invalid type"),	×
41	DuckDBType.Boolean => typeof(bool),	18✔
42	DuckDBType.TinyInt => typeof(sbyte),	42✔
43	DuckDBType.SmallInt => typeof(short),	42✔
44	DuckDBType.Integer => typeof(int),	207✔
45	DuckDBType.BigInt => typeof(long),	123✔
46	DuckDBType.UnsignedTinyInt => typeof(byte),	42✔
47	DuckDBType.UnsignedSmallInt => typeof(ushort),	42✔
48	DuckDBType.UnsignedInteger => typeof(uint),	42✔
49	DuckDBType.UnsignedBigInt => typeof(ulong),	42✔
50	DuckDBType.Float => typeof(float),	9✔
51	DuckDBType.Double => typeof(double),	22✔
52	DuckDBType.Timestamp => typeof(DateTime),	63✔
53	DuckDBType.Interval => typeof(DuckDBInterval),	9✔
54	DuckDBType.Date => typeof(DuckDBDateOnly),	39✔
55	DuckDBType.Time => typeof(DuckDBTimeOnly),	57✔
56	DuckDBType.HugeInt => typeof(BigInteger),	9✔
57	DuckDBType.Varchar => typeof(string),	106✔
58	DuckDBType.Decimal => typeof(decimal),	172✔
59	DuckDBType.Blob => typeof(Stream),	12✔
60	DuckDBType.Enum => typeof(Enum),	12✔
61	DuckDBType.List => typeof(List<>),	52✔
62	var type => throw new ArgumentException($"Unrecognised type {type} ({(int)type})")	×
63	};	1,162✔
64
65	switch (ColumnDuckDBType)	1,162✔
66	{
67	case DuckDBType.Enum:
68	enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);	12✔
69	break;	12✔
70	case DuckDBType.Decimal:
71	scale = NativeMethods.LogicalType.DuckDBDecimalScale(logicalType);	172✔
72	decimalType = NativeMethods.LogicalType.DuckDBDecimalInternalType(logicalType);	172✔
73	break;	172✔
74	case DuckDBType.List:
75	{
76	using var childType = NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType);	52✔
77	var type = NativeMethods.LogicalType.DuckDBGetTypeId(childType);	52✔
78
79	var childVector = NativeMethods.DataChunks.DuckDBListVectorGetChild(vector);	52✔
80
81	var childVectorData = NativeMethods.DataChunks.DuckDBVectorGetData(childVector);	52✔
82	var childVectorValidity = NativeMethods.DataChunks.DuckDBVectorGetValidity(childVector);	52✔
83
84	listDataReader = new VectorDataReader(childVector, childVectorData, childVectorValidity, type);	52✔
85	break;	52✔
86	}
87	}
88	}	52✔
89
90	internal unsafe bool IsValid(ulong offset)
91	{
92	var validityMaskEntryIndex = offset / 64;	61,530✔
93	var validityBitIndex = (int)(offset % 64);	61,530✔
94
95	var validityMaskEntryPtr = validityMaskPointer + validityMaskEntryIndex;	61,530✔
96	var validityBit = 1ul << validityBitIndex;	61,530✔
97
98	var isValid = (*validityMaskEntryPtr & validityBit) != 0;	61,530✔
99	return isValid;	61,530✔
100	}
101
102	internal unsafe T GetFieldData<T>(ulong offset) where T : unmanaged => ((T)dataPointer + offset);	31,416✔
103
104	internal decimal GetDecimal(ulong offset)
105	{
106	var pow = (decimal)Math.Pow(10, scale);	192✔
107	switch (decimalType)	192!
108	{
109	case DuckDBType.SmallInt:
110	return decimal.Divide(GetFieldData<short>(offset), pow);	18✔
111	case DuckDBType.Integer:
112	return decimal.Divide(GetFieldData<int>(offset), pow);	12✔
113	case DuckDBType.BigInt:
114	return decimal.Divide(GetFieldData<long>(offset), pow);	24✔
115	case DuckDBType.HugeInt:
116	{
117	var hugeInt = GetBigInteger(offset);	138✔
118
119	var result = (decimal)BigInteger.DivRem(hugeInt, (BigInteger)pow, out var remainder);	138✔
120
121	result += decimal.Divide((decimal)remainder, pow);	138✔
122	return result;	138✔
123	}
124	default:
125	throw new ArgumentOutOfRangeException();	×
126	}
127	}
128
129	internal unsafe string GetString(ulong offset)
130	{
131	var data = (DuckDBString*)dataPointer + offset;	30,135✔
132	var length = (int)data;	30,135✔
133
134	var pointer = length <= InlineStringMaxLength	30,135✔
135	? data->value.inlined.inlined	30,135✔
136	: data->value.pointer.ptr;	30,135✔
137
138	return new string(pointer, 0, length, Encoding.UTF8);	30,135✔
139	}
140
141	internal unsafe Stream GetStream(ulong offset)
142	{
143	var data = (DuckDBString*)dataPointer + offset;	12✔
144	var length = (int)data;	12✔
145
146	if (length <= InlineStringMaxLength)	12✔
147	{
148	var value = new string(data->value.inlined.inlined, 0, length, Encoding.UTF8);	9✔
149	return new MemoryStream(Encoding.UTF8.GetBytes(value), false);	9✔
150	}
151
152	return new UnmanagedMemoryStream((byte*)data->value.pointer.ptr, length, length, FileAccess.Read);	3✔
153	}
154
155	internal unsafe DateTime GetDateTime(ulong offset)
156	{
157	if (ColumnDuckDBType == DuckDBType.Date)	117✔
158	{
159	return GetDateOnly(offset).ToDateTime();	9✔
160	}
161	var data = (DuckDBTimestampStruct*)dataPointer + offset;	108✔
162	return data->ToDateTime();	108✔
163	}
164
165	internal unsafe BigInteger GetBigInteger(ulong offset)
166	{
167	var data = (DuckDBHugeInt*)dataPointer + offset;	147✔
168	return data->ToBigInteger();	147✔
169	}
170
171	internal object GetEnum(ulong offset, Type returnType)
172	{
173	long enumValue = enumType switch	42!
174	{	42✔
175	DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),	42✔
176	DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),	×
177	DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),	×
178	_ => -1	×
179	};	42✔
180
181	if (returnType == typeof(string))	42✔
182	{
183	var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, enumValue).ToManagedString();	9✔
184	return value;	9✔
185	}
186
187	var underlyingType = Nullable.GetUnderlyingType(returnType);	33✔
188	if (underlyingType != null)	33✔
189	{
190	if (!IsValid(offset))	15✔
191	{
192	return default;	3✔
193	}
194	returnType = underlyingType;	12✔
195	}
196
197	var enumItem = Enum.Parse(returnType, enumValue.ToString(CultureInfo.InvariantCulture));	30✔
198	return enumItem;	30✔
199	}
200
201	internal unsafe object GetList(ulong offset, Type returnType)
202	{
203	var listData = (DuckDBListEntry*)dataPointer + offset;	90✔
204
205	var genericArgument = returnType?.GetGenericArguments()[0];	90!
206
207	var nullableType = genericArgument == null ? null : Nullable.GetUnderlyingType(genericArgument);	90!
208	var allowNulls = returnType != null && (!genericArgument.IsValueType \|\| nullableType != null);	90!
209
210	var list = Activator.CreateInstance(returnType) as IList;	90✔
211
212	var targetType = returnType.GetGenericArguments()[0];	90✔
213
214	if (Nullable.GetUnderlyingType(targetType) != null)	90✔
215	{
216	targetType = targetType.GetGenericArguments()[0];	21✔
217	}
218
219	for (ulong i = 0; i < listData->Length; i++)	600✔
220	{
221	var childOffset = i + listData->Offset;	213✔
222	if (listDataReader.IsValid(childOffset))	213✔
223	{
224	var item = listDataReader.GetValue(childOffset, targetType);	192✔
225	list.Add(item);	192✔
226	}
227	else
228	{
229	if (allowNulls)	21✔
230	{
231	list.Add(null);	18✔
232	}
233	else
234	{
235	throw new NullReferenceException("The list contains null value");	3✔
236	}
237	}
238	}
239
240	return list;	87✔
241	}
242
243	internal object GetValue(ulong offset, Type targetType = null)
244	{
245	return ColumnDuckDBType switch	1,539!
246	{	1,539✔
247	DuckDBType.Invalid => throw new DuckDBException("Invalid type"),	×
248	DuckDBType.Boolean => GetFieldData<bool>(offset),	66✔
249	DuckDBType.TinyInt => GetFieldData<sbyte>(offset),	96✔
250	DuckDBType.SmallInt => GetFieldData<short>(offset),	78✔
251	DuckDBType.Integer => GetFieldData<int>(offset),	189✔
252	DuckDBType.BigInt => GetFieldData<long>(offset),	153✔
253	DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),	78✔
254	DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),	96✔
255	DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),	96✔
256	DuckDBType.UnsignedBigInt => GetFieldData<ulong>(offset),	96✔
257	DuckDBType.Float => GetFieldData<float>(offset),	60✔
258	DuckDBType.Double => GetFieldData<double>(offset),	81✔
259	DuckDBType.Timestamp => GetDateTime(offset),	90✔
260	DuckDBType.Interval => GetFieldData<DuckDBInterval>(offset),	9✔
261	DuckDBType.Date => GetDate(offset, targetType),	45✔
262	DuckDBType.Time => GetTime(offset, targetType),	60✔
263	DuckDBType.HugeInt => GetBigInteger(offset),	9✔
264	DuckDBType.Varchar => GetString(offset),	99✔
265	DuckDBType.Decimal => GetDecimal(offset),	105✔
266	DuckDBType.Blob => GetStream(offset),	×
267	DuckDBType.List => GetList(offset, targetType ?? typeof(List<>).MakeGenericType(listDataReader.ClrType)),	24✔
268	DuckDBType.Enum => GetEnum(offset, targetType ?? typeof(string)),	9✔
UNCOV 269	var type => throw new ArgumentException($"Unrecognised type {type} ({(int)type}) in column {offset + 1}")	×
270	};	1,539✔
271	}
272
273	private DuckDBTimeOnly GetTime(ulong offset)
274	{
275	return NativeMethods.DateTime.DuckDBFromTime(GetFieldData<DuckDBTime>(offset));	60✔
276	}
277
278	private DuckDBDateOnly GetDateOnly(ulong offset)
279	{
280	return NativeMethods.DateTime.DuckDBFromDate(GetFieldData<DuckDBDate>(offset));	54✔
281	}
282
283	private object GetDate(ulong offset, Type targetType)
284	{
285	var dateOnly = GetDateOnly(offset);	45✔
286	if (targetType == typeof(DateTime))	45✔
287	{
288	return (DateTime)dateOnly;	12✔
289	}
290
291	#if NET6_0_OR_GREATER
292	if (targetType == typeof(DateOnly))	33✔
293	{
294	return (DateOnly)dateOnly;	6✔
295	}
296	#endif
297
298	return dateOnly;	27✔
299	}
300
301	private object GetTime(ulong offset, Type targetType)
302	{
303	var timeOnly = GetTime(offset);	60✔
304	if (targetType == typeof(DateTime))	60!
305	{
306	return (DateTime)timeOnly;	×
307	}
308
309	#if NET6_0_OR_GREATER
310	if (targetType == typeof(TimeOnly))	60✔
311	{
312	return (TimeOnly)timeOnly;	6✔
313	}
314	#endif
315
316	return timeOnly;	54✔
317	}
318
319	public void Dispose()
320	{
321	listDataReader?.Dispose();	37✔
322	logicalType?.Dispose();	37!
323	}	37✔
324	}

Giorgi / DuckDB.NET / 6455368055

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous