21786556530

Committed 07 Feb 2026 08:39PM UTC coverage: 89.155% (-0.07%) from 89.223%

Build # 21786556530

Build Type

push

github

Committed by

Giorgi

Commit Message

Added support for clearing in-progress adapter

Requires DuckDB 1.5

Run Details

1199 of 1393 branches covered (86.07%)

Branch coverage included in aggregate %.

6 of 8 new or added lines in 1 file covered. (75.0%)

193 existing lines in 43 files now uncovered.

2336 of 2572 relevant lines covered (90.82%)

557295.56 hits per line

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

94.56

/DuckDB.NET.Data/PreparedStatement/ClrToDuckDBConverter.cs

namespace DuckDB.NET.Data.PreparedStatement;

internal static class ClrToDuckDBConverter
{
    private static readonly Dictionary<DbType, Func<object, DuckDBValue>> ValueCreators = new()
    {
        { DbType.Guid, value => NativeMethods.Value.DuckDBCreateUuid(((Guid)value).ToHugeInt(false)) },
        { DbType.Currency, value => DecimalToDuckDBValue((decimal)value) },
        { DbType.Boolean, value => NativeMethods.Value.DuckDBCreateBool((bool)value) },
        { DbType.SByte, value => NativeMethods.Value.DuckDBCreateInt8((sbyte)value) },
        { DbType.Int16, value => NativeMethods.Value.DuckDBCreateInt16((short)value) },
        { DbType.Int32, value => NativeMethods.Value.DuckDBCreateInt32((int)value) },
        { DbType.Int64, value => NativeMethods.Value.DuckDBCreateInt64((long)value) },
        { DbType.Byte, value => NativeMethods.Value.DuckDBCreateUInt8((byte)value) },
        { DbType.UInt16, value => NativeMethods.Value.DuckDBCreateUInt16((ushort)value) },
        { DbType.UInt32, value => NativeMethods.Value.DuckDBCreateUInt32((uint)value) },
        { DbType.UInt64, value => NativeMethods.Value.DuckDBCreateUInt64((ulong)value) },
        { DbType.Single, value => NativeMethods.Value.DuckDBCreateFloat((float)value) },
        { DbType.Double, value => NativeMethods.Value.DuckDBCreateDouble((double)value) },
        { DbType.String, value => StringToDuckDBValue((string?)value) },
        { DbType.VarNumeric, value => NativeMethods.Value.DuckDBCreateHugeInt(new((BigInteger)value)) },
        { DbType.Binary, value =>
            {
                var bytes = (byte[])value;
                return NativeMethods.Value.DuckDBCreateBlob(bytes, bytes.Length);
            }
        },
        { DbType.Date, value =>
            {
                var date = (value is DateOnly dateOnly ? (DuckDBDateOnly)dateOnly : (DuckDBDateOnly)value).ToDuckDBDate();
                return NativeMethods.Value.DuckDBCreateDate(date);
            }
        },
        { DbType.Time, value =>
            {
                var time = NativeMethods.DateTimeHelpers.DuckDBToTime(value is TimeOnly timeOnly ? (DuckDBTimeOnly)timeOnly : (DuckDBTimeOnly)value);
                return NativeMethods.Value.DuckDBCreateTime(time);
            }
        },
        { DbType.DateTime, value =>
            {
                var dateTime = (value is DateTime dt ? (DuckDBTimestamp)dt : (DuckDBTimestamp)value).ToDuckDBTimestampStruct();
                return NativeMethods.Value.DuckDBCreateTimestamp(dateTime);
            }
        },
        { DbType.DateTimeOffset, value => NativeMethods.Value.DuckDBCreateTimestampTz(((DateTimeOffset)value).ToTimestampStruct()) },
    };

    public static DuckDBValue ToDuckDBValue(this object? item, DuckDBLogicalType logicalType, DuckDBType duckDBType, DbType dbType)
    {
        if (item.IsNull())
        {
            return NativeMethods.Value.DuckDBCreateNullValue();
        }

        return (duckDBType, item) switch
        {
            (DuckDBType.Boolean, bool value) => NativeMethods.Value.DuckDBCreateBool(value),

            (DuckDBType.TinyInt, _) => TryConvertTo<sbyte>(out var result) ? NativeMethods.Value.DuckDBCreateInt8(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.SmallInt, _) => TryConvertTo<short>(out var result) ? NativeMethods.Value.DuckDBCreateInt16(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.Integer, _) => TryConvertTo<int>(out var result) ? NativeMethods.Value.DuckDBCreateInt32(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.BigInt, _) => TryConvertTo<long>(out var result) ? NativeMethods.Value.DuckDBCreateInt64(result) : StringToDuckDBValue(item.ToString()),

            (DuckDBType.UnsignedTinyInt, _) => TryConvertTo<byte>(out var result) ? NativeMethods.Value.DuckDBCreateUInt8(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.UnsignedSmallInt, _) => TryConvertTo<ushort>(out var result) ? NativeMethods.Value.DuckDBCreateUInt16(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.UnsignedInteger, _) => TryConvertTo<uint>(out var result) ? NativeMethods.Value.DuckDBCreateUInt32(result) : StringToDuckDBValue(item.ToString()),
            (DuckDBType.UnsignedBigInt, _) => TryConvertTo<ulong>(out var result) ? NativeMethods.Value.DuckDBCreateUInt64(result) : StringToDuckDBValue(item.ToString()),

            (DuckDBType.Float, float value) => NativeMethods.Value.DuckDBCreateFloat(value),
            (DuckDBType.Double, double value) => NativeMethods.Value.DuckDBCreateDouble(value),

            (DuckDBType.Decimal, decimal value) => DecimalToDuckDBValue(value),
            (DuckDBType.HugeInt, BigInteger value) => NativeMethods.Value.DuckDBCreateHugeInt(new DuckDBHugeInt(value)),

            (DuckDBType.Varchar, string value) => StringToDuckDBValue(value),
            (DuckDBType.Uuid, Guid value) => NativeMethods.Value.DuckDBCreateUuid(value.ToHugeInt(false)),

            (DuckDBType.Timestamp, DateTime value) => NativeMethods.Value.DuckDBCreateTimestamp(value.ToTimestampStruct(duckDBType)),
            (DuckDBType.TimestampS, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampS(value.ToTimestampStruct(duckDBType)),
            (DuckDBType.TimestampMs, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampMs(value.ToTimestampStruct(duckDBType)),
            (DuckDBType.TimestampNs, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampNs(value.ToTimestampStruct(duckDBType)),
            (DuckDBType.TimestampTz, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampTz(value.ToTimestampStruct(duckDBType)),
            (DuckDBType.TimestampTz, DateTimeOffset value) => NativeMethods.Value.DuckDBCreateTimestampTz(value.ToTimestampStruct()),
            (DuckDBType.Interval, TimeSpan value) => NativeMethods.Value.DuckDBCreateInterval(value),
            (DuckDBType.Date, DateTime value) => NativeMethods.Value.DuckDBCreateDate(((DuckDBDateOnly)value).ToDuckDBDate()),
            (DuckDBType.Date, DuckDBDateOnly value) => NativeMethods.Value.DuckDBCreateDate(value.ToDuckDBDate()),
            (DuckDBType.Time, DateTime value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime((DuckDBTimeOnly)value)),
            (DuckDBType.Time, DuckDBTimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),
            (DuckDBType.Date, DateOnly value) => NativeMethods.Value.DuckDBCreateDate(((DuckDBDateOnly)value).ToDuckDBDate()),
            (DuckDBType.Time, TimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),
            (DuckDBType.TimeTz, DateTimeOffset value) => NativeMethods.Value.DuckDBCreateTimeTz(value.ToTimeTzStruct()),
            (DuckDBType.Blob, byte[] value) => NativeMethods.Value.DuckDBCreateBlob(value, value.Length),
            (DuckDBType.List, ICollection value) => CreateCollectionValue(logicalType, value, true, dbType),
            (DuckDBType.Array, ICollection value) => CreateCollectionValue(logicalType, value, false, dbType),
            _ when ValueCreators.TryGetValue(dbType, out var converter) => converter(item),
            _ => StringToDuckDBValue(item.ToString())
        };

        bool TryConvertTo<T>(out T result) where T : struct
        {
            try
            {
                if (item is T parsable)
                {
                    result = parsable;
                    return true;
                }

                result = (T)Convert.ChangeType(item, typeof(T));
                return true;
            }
            catch (Exception)
            {
                result = default;
                return false;
            }
        }
    }

    private static DuckDBValue CreateCollectionValue(DuckDBLogicalType logicalType, ICollection collection, bool isList, DbType dbType)
    {
        using var collectionItemType = isList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) :
                                                NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);

        var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(collectionItemType);

        var values = new DuckDBValue[collection.Count];

        var index = 0;
        foreach (var item in collection)
        {
            var duckDBValue = item.ToDuckDBValue(collectionItemType, duckDBType, dbType);
            values[index] = duckDBValue;
            index++;
        }

        return isList ? NativeMethods.Value.DuckDBCreateListValue(collectionItemType, values, collection.Count)
                      : NativeMethods.Value.DuckDBCreateArrayValue(collectionItemType, values, collection.Count);
    }

    private static DuckDBValue StringToDuckDBValue(string? value)
    {
        using var handle = value.ToUnmanagedString();
        return NativeMethods.Value.DuckDBCreateVarchar(handle);
    }

    private static DuckDBValue DecimalToDuckDBValue(decimal value)
    {
        var bits = decimal.GetBits(value);
        var scale = (byte)((bits[3] >> 16) & 0x7F);

        var power = Math.Pow(10, scale);

        var integralPart = decimal.Truncate(value);
        var fractionalPart = value - integralPart;

        var result = BigInteger.Multiply(new BigInteger(integralPart), new BigInteger(power));

        result += new BigInteger(decimal.Multiply(fractionalPart, (decimal)power));

        var width = integralPart == 0 ? scale + 1 : (int)Math.Floor(BigInteger.Log10(BigInteger.Abs(result))) + 1;

        return NativeMethods.Value.DuckDBCreateDecimal(new DuckDBDecimal((byte)width, scale, new DuckDBHugeInt(result)));
    }
}

1	namespace DuckDB.NET.Data.PreparedStatement;
2
3	internal static class ClrToDuckDBConverter
4	{
5	private static readonly Dictionary<DbType, Func<object, DuckDBValue>> ValueCreators = new()	3✔
6	{	3✔
7	{ DbType.Guid, value => NativeMethods.Value.DuckDBCreateUuid(((Guid)value).ToHugeInt(false)) },	3✔
8	{ DbType.Currency, value => DecimalToDuckDBValue((decimal)value) },	33✔
9	{ DbType.Boolean, value => NativeMethods.Value.DuckDBCreateBool((bool)value) },	3✔
10	{ DbType.SByte, value => NativeMethods.Value.DuckDBCreateInt8((sbyte)value) },	3✔
11	{ DbType.Int16, value => NativeMethods.Value.DuckDBCreateInt16((short)value) },	3✔
12	{ DbType.Int32, value => NativeMethods.Value.DuckDBCreateInt32((int)value) },	18✔
13	{ DbType.Int64, value => NativeMethods.Value.DuckDBCreateInt64((long)value) },	3✔
14	{ DbType.Byte, value => NativeMethods.Value.DuckDBCreateUInt8((byte)value) },	3✔
15	{ DbType.UInt16, value => NativeMethods.Value.DuckDBCreateUInt16((ushort)value) },	3✔
16	{ DbType.UInt32, value => NativeMethods.Value.DuckDBCreateUInt32((uint)value) },	3✔
17	{ DbType.UInt64, value => NativeMethods.Value.DuckDBCreateUInt64((ulong)value) },	3✔
18	{ DbType.Single, value => NativeMethods.Value.DuckDBCreateFloat((float)value) },	12✔
19	{ DbType.Double, value => NativeMethods.Value.DuckDBCreateDouble((double)value) },	12✔
20	{ DbType.String, value => StringToDuckDBValue((string?)value) },	12✔
21	{ DbType.VarNumeric, value => NativeMethods.Value.DuckDBCreateHugeInt(new((BigInteger)value)) },	3✔
22	{ DbType.Binary, value =>	3✔
23	{	3✔
UNCOV 24	var bytes = (byte[])value;	×
UNCOV 25	return NativeMethods.Value.DuckDBCreateBlob(bytes, bytes.Length);	×
26	}	3✔
27	},	3✔
28	{ DbType.Date, value =>	3✔
29	{	3✔
30	var date = (value is DateOnly dateOnly ? (DuckDBDateOnly)dateOnly : (DuckDBDateOnly)value).ToDuckDBDate();	3!
31	return NativeMethods.Value.DuckDBCreateDate(date);	3✔
32	}	3✔
33	},	3✔
34	{ DbType.Time, value =>	3✔
35	{	3✔
36	var time = NativeMethods.DateTimeHelpers.DuckDBToTime(value is TimeOnly timeOnly ? (DuckDBTimeOnly)timeOnly : (DuckDBTimeOnly)value);	3!
37	return NativeMethods.Value.DuckDBCreateTime(time);	3✔
38	}	3✔
39	},	3✔
40	{ DbType.DateTime, value =>	3✔
41	{	3✔
42	var dateTime = (value is DateTime dt ? (DuckDBTimestamp)dt : (DuckDBTimestamp)value).ToDuckDBTimestampStruct();	33✔
43	return NativeMethods.Value.DuckDBCreateTimestamp(dateTime);	33✔
44	}	3✔
45	},	3✔
46	{ DbType.DateTimeOffset, value => NativeMethods.Value.DuckDBCreateTimestampTz(((DateTimeOffset)value).ToTimestampStruct()) },	3✔
47	};	3✔
48
49	public static DuckDBValue ToDuckDBValue(this object? item, DuckDBLogicalType logicalType, DuckDBType duckDBType, DbType dbType)
50	{
51	if (item.IsNull())	11,036✔
52	{
53	return NativeMethods.Value.DuckDBCreateNullValue();	4,089✔
54	}
55
56	return (duckDBType, item) switch	6,947✔
57	{	6,947✔
58	(DuckDBType.Boolean, bool value) => NativeMethods.Value.DuckDBCreateBool(value),	301✔
59		6,947✔
60	(DuckDBType.TinyInt, _) => TryConvertTo<sbyte>(out var result) ? NativeMethods.Value.DuckDBCreateInt8(result) : StringToDuckDBValue(item.ToString()),	265!
61	(DuckDBType.SmallInt, _) => TryConvertTo<short>(out var result) ? NativeMethods.Value.DuckDBCreateInt16(result) : StringToDuckDBValue(item.ToString()),	293!
62	(DuckDBType.Integer, _) => TryConvertTo<int>(out var result) ? NativeMethods.Value.DuckDBCreateInt32(result) : StringToDuckDBValue(item.ToString()),	326✔
63	(DuckDBType.BigInt, _) => TryConvertTo<long>(out var result) ? NativeMethods.Value.DuckDBCreateInt64(result) : StringToDuckDBValue(item.ToString()),	256!
64		6,947✔
65	(DuckDBType.UnsignedTinyInt, _) => TryConvertTo<byte>(out var result) ? NativeMethods.Value.DuckDBCreateUInt8(result) : StringToDuckDBValue(item.ToString()),	300!
66	(DuckDBType.UnsignedSmallInt, _) => TryConvertTo<ushort>(out var result) ? NativeMethods.Value.DuckDBCreateUInt16(result) : StringToDuckDBValue(item.ToString()),	275!
67	(DuckDBType.UnsignedInteger, _) => TryConvertTo<uint>(out var result) ? NativeMethods.Value.DuckDBCreateUInt32(result) : StringToDuckDBValue(item.ToString()),	173!
68	(DuckDBType.UnsignedBigInt, _) => TryConvertTo<ulong>(out var result) ? NativeMethods.Value.DuckDBCreateUInt64(result) : StringToDuckDBValue(item.ToString()),	196!
69		6,947✔
70	(DuckDBType.Float, float value) => NativeMethods.Value.DuckDBCreateFloat(value),	196✔
71	(DuckDBType.Double, double value) => NativeMethods.Value.DuckDBCreateDouble(value),	116✔
72		6,947✔
73	(DuckDBType.Decimal, decimal value) => DecimalToDuckDBValue(value),	344✔
74	(DuckDBType.HugeInt, BigInteger value) => NativeMethods.Value.DuckDBCreateHugeInt(new DuckDBHugeInt(value)),	258✔
75		6,947✔
76	(DuckDBType.Varchar, string value) => StringToDuckDBValue(value),	284✔
77	(DuckDBType.Uuid, Guid value) => NativeMethods.Value.DuckDBCreateUuid(value.ToHugeInt(false)),	262✔
78		6,947✔
79	(DuckDBType.Timestamp, DateTime value) => NativeMethods.Value.DuckDBCreateTimestamp(value.ToTimestampStruct(duckDBType)),	36✔
80	(DuckDBType.TimestampS, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampS(value.ToTimestampStruct(duckDBType)),	18✔
81	(DuckDBType.TimestampMs, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampMs(value.ToTimestampStruct(duckDBType)),	18✔
82	(DuckDBType.TimestampNs, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampNs(value.ToTimestampStruct(duckDBType)),	18✔
83	(DuckDBType.TimestampTz, DateTime value) => NativeMethods.Value.DuckDBCreateTimestampTz(value.ToTimestampStruct(duckDBType)),	18✔
84	(DuckDBType.TimestampTz, DateTimeOffset value) => NativeMethods.Value.DuckDBCreateTimestampTz(value.ToTimestampStruct()),	18✔
85	(DuckDBType.Interval, TimeSpan value) => NativeMethods.Value.DuckDBCreateInterval(value),	291✔
86	(DuckDBType.Date, DateTime value) => NativeMethods.Value.DuckDBCreateDate(((DuckDBDateOnly)value).ToDuckDBDate()),	441✔
87	(DuckDBType.Date, DuckDBDateOnly value) => NativeMethods.Value.DuckDBCreateDate(value.ToDuckDBDate()),	164✔
88	(DuckDBType.Time, DateTime value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime((DuckDBTimeOnly)value)),	18✔
89	(DuckDBType.Time, DuckDBTimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),	332✔
90	(DuckDBType.Date, DateOnly value) => NativeMethods.Value.DuckDBCreateDate(((DuckDBDateOnly)value).ToDuckDBDate()),	166✔
91	(DuckDBType.Time, TimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),	364✔
92	(DuckDBType.TimeTz, DateTimeOffset value) => NativeMethods.Value.DuckDBCreateTimeTz(value.ToTimeTzStruct()),	642✔
93	(DuckDBType.Blob, byte[] value) => NativeMethods.Value.DuckDBCreateBlob(value, value.Length),	3✔
94	(DuckDBType.List, ICollection value) => CreateCollectionValue(logicalType, value, true, dbType),	330✔
95	(DuckDBType.Array, ICollection value) => CreateCollectionValue(logicalType, value, false, dbType),	66✔
96	_ when ValueCreators.TryGetValue(dbType, out var converter) => converter(item),	318!
UNCOV 97	_ => StringToDuckDBValue(item.ToString())	×
98	};	6,947✔
99
100	bool TryConvertTo<T>(out T result) where T : struct
101	{
102	try
103	{
104	if (item is T parsable)	2,084✔
105	{
106	result = parsable;	2,069✔
107	return true;	2,069✔
108	}
109
110	result = (T)Convert.ChangeType(item, typeof(T));	15✔
111	return true;	6✔
112	}
113	catch (Exception)	9✔
114	{
115	result = default;	9✔
116	return false;	9✔
117	}
118	}	2,084✔
119	}
120
121	private static DuckDBValue CreateCollectionValue(DuckDBLogicalType logicalType, ICollection collection, bool isList, DbType dbType)
122	{
123	using var collectionItemType = isList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) :	396✔
124	NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);	396✔
125
126	var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(collectionItemType);	396✔
127
128	var values = new DuckDBValue[collection.Count];	396✔
129
130	var index = 0;	396✔
131	foreach (var item in collection)	20,716✔
132	{
133	var duckDBValue = item.ToDuckDBValue(collectionItemType, duckDBType, dbType);	9,962✔
134	values[index] = duckDBValue;	9,962✔
135	index++;	9,962✔
136	}
137
138	return isList ? NativeMethods.Value.DuckDBCreateListValue(collectionItemType, values, collection.Count)	396✔
139	: NativeMethods.Value.DuckDBCreateArrayValue(collectionItemType, values, collection.Count);	396✔
140	}	396✔
141
142	private static DuckDBValue StringToDuckDBValue(string? value)
143	{
144	using var handle = value.ToUnmanagedString();	305✔
145	return NativeMethods.Value.DuckDBCreateVarchar(handle);	305✔
146	}	305✔
147
148	private static DuckDBValue DecimalToDuckDBValue(decimal value)
149	{
150	var bits = decimal.GetBits(value);	377✔
151	var scale = (byte)((bits[3] >> 16) & 0x7F);	377✔
152
153	var power = Math.Pow(10, scale);	377✔
154
155	var integralPart = decimal.Truncate(value);	377✔
156	var fractionalPart = value - integralPart;	377✔
157
158	var result = BigInteger.Multiply(new BigInteger(integralPart), new BigInteger(power));	377✔
159
160	result += new BigInteger(decimal.Multiply(fractionalPart, (decimal)power));	377✔
161
162	var width = integralPart == 0 ? scale + 1 : (int)Math.Floor(BigInteger.Log10(BigInteger.Abs(result))) + 1;	377✔
163
164	return NativeMethods.Value.DuckDBCreateDecimal(new DuckDBDecimal((byte)width, scale, new DuckDBHugeInt(result)));	377✔
165	}
166	}

Giorgi / DuckDB.NET / 21786556530

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