6449684618

Committed 08 Oct 2023 08:01PM UTC coverage: 87.852% (+0.05%) from 87.798%

Build # 6449684618

Build Type

push

github

Committed by

Giorgi

Commit Message

Add tests

Run Details

303 of 354 branches covered (0.0%)

Branch coverage included in aggregate %.

13 of 13 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%)

16169.7 hits per line

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

89.93

/DuckDB.NET.Data/VectorDataReader.cs

﻿using System;
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 T GetEnum<T>(ulong offset)
    {
        long enumValue = enumType switch
        {
            DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),
            DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),
            DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),
            _ => -1
        };

        var targetType = typeof(T);

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

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

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

    private unsafe List<T> BuildList<T>(List<T> list, DuckDBListEntry* listData, bool allowNulls)
    {
        var targetType = typeof(T);

        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<T>(childOffset, targetType);
                list.Add(item);
            }
            else
            {
                if (allowNulls)
                {
                    list.Add((T)(object)null);
                }
                else
                {
                    throw new NullReferenceException("The list contains null value");
                }
            }
        }

        return list;
    }

    internal unsafe List<T> GetList<T>(ulong offset, List<T> list)
    {
        var listData = (DuckDBListEntry*)dataPointer + offset;
        return BuildList(list, listData, !typeof(T).IsValueType);
    }

    internal unsafe List<T?> GetList<T>(ulong offset, List<T?> list) where T : struct
    {
        var listData = (DuckDBListEntry*)dataPointer + offset;
        return BuildList(list, listData, true);
    }

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

Giorgi / DuckDB.NET / 6449684618

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