12063721251

Committed 28 Nov 2024 06:32AM UTC coverage: 88.995% (+0.04%) from 88.958%

Build # 12063721251

Build Type

push

github

Committed by

Giorgi

Commit Message

Do not throw if parameter index isn't found

Run Details

1146 of 1326 branches covered (86.43%)

Branch coverage included in aggregate %.

2121 of 2345 relevant lines covered (90.45%)

772904.74 hits per line

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

84.11

/DuckDB.NET.Data/Internal/ClrToDuckDBConverter.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Numerics;
using DuckDB.NET.Data.Extensions;
using DuckDB.NET.Native;

namespace DuckDB.NET.Data.Internal;

internal static class ClrToDuckDBConverter
{
    public static DuckDBValue ToDuckDBValue(this object? value)
    {
        if (value.IsNull())
        {
            return NativeMethods.Value.DuckDBCreateNullValue();
        }

        return value switch
        {
            bool val => NativeMethods.Value.DuckDBCreateBool(val),

            sbyte val => NativeMethods.Value.DuckDBCreateInt8(val),
            short val => NativeMethods.Value.DuckDBCreateInt16(val),
            int val => NativeMethods.Value.DuckDBCreateInt32(val),
            long val => NativeMethods.Value.DuckDBCreateInt64(val),

            byte val => NativeMethods.Value.DuckDBCreateUInt8(val),
            ushort val => NativeMethods.Value.DuckDBCreateUInt16(val),
            uint val => NativeMethods.Value.DuckDBCreateUInt32(val),
            ulong val => NativeMethods.Value.DuckDBCreateUInt64(val),

            float val => NativeMethods.Value.DuckDBCreateFloat(val),
            double val => NativeMethods.Value.DuckDBCreateDouble(val),

            decimal val => DecimalToDuckDBValue(val),
            BigInteger val => NativeMethods.Value.DuckDBCreateHugeInt(new DuckDBHugeInt(val)),

            string val => StringToDuckDBValue(val),
            Guid val => GuidToDuckDBValue(val),
            DateTime val => NativeMethods.Value.DuckDBCreateTimestamp(NativeMethods.DateTimeHelpers.DuckDBToTimestamp(DuckDBTimestamp.FromDateTime(val))),
            TimeSpan val => NativeMethods.Value.DuckDBCreateInterval(val),
            DuckDBDateOnly val => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(val)),
            DuckDBTimeOnly val => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(val)),
#if NET6_0_OR_GREATER
            DateOnly val => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(val)),
            TimeOnly val => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(val)),
#endif
            DateTimeOffset val => DateTimeOffsetToDuckDBValue(val),
            byte[] val => NativeMethods.Value.DuckDBCreateBlob(val, val.Length),

            ICollection val => CreateCollectionValue(val),
            _ => throw new InvalidCastException($"Cannot convert value of type {value.GetType().FullName} to DuckDBValue.")
        };
    }

    private static DuckDBValue DateTimeOffsetToDuckDBValue(DateTimeOffset val)
    {
        var duckDBToTime = NativeMethods.DateTimeHelpers.DuckDBToTime((DuckDBTimeOnly)val.DateTime);
        var duckDBCreateTimeTz = NativeMethods.DateTimeHelpers.DuckDBCreateTimeTz(duckDBToTime.Micros, (int)val.Offset.TotalSeconds);
        return NativeMethods.Value.DuckDBCreateTimeTz(duckDBCreateTimeTz);
    }

    private static DuckDBValue GuidToDuckDBValue(Guid value)
    {
        using var handle = value.ToString().ToUnmanagedString();
        return NativeMethods.Value.DuckDBCreateVarchar(handle);
    }

    private static DuckDBValue DecimalToDuckDBValue(decimal value)
    {
        using var handle = value.ToString(CultureInfo.InvariantCulture).ToUnmanagedString();
        return NativeMethods.Value.DuckDBCreateVarchar(handle);
    }

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

    private static DuckDBValue CreateCollectionValue(ICollection collection)
    {
        return collection switch
        {
            ICollection<bool> items => CreateCollectionValue(DuckDBType.Boolean, items),
            ICollection<bool?> items => CreateCollectionValue(DuckDBType.Boolean, items),

            ICollection<sbyte> items => CreateCollectionValue(DuckDBType.TinyInt, items),
            ICollection<sbyte?> items => CreateCollectionValue(DuckDBType.TinyInt, items),
            ICollection<short> items => CreateCollectionValue(DuckDBType.SmallInt, items),
            ICollection<short?> items => CreateCollectionValue(DuckDBType.SmallInt, items),
            ICollection<int> items => CreateCollectionValue(DuckDBType.Integer, items),
            ICollection<int?> items => CreateCollectionValue(DuckDBType.Integer, items),
            ICollection<long> items => CreateCollectionValue(DuckDBType.BigInt, items),
            ICollection<long?> items => CreateCollectionValue(DuckDBType.BigInt, items),

            ICollection<byte> items => CreateCollectionValue(DuckDBType.UnsignedTinyInt, items),
            ICollection<byte?> items => CreateCollectionValue(DuckDBType.UnsignedTinyInt, items),
            ICollection<ushort> items => CreateCollectionValue(DuckDBType.UnsignedSmallInt, items),
            ICollection<ushort?> items => CreateCollectionValue(DuckDBType.UnsignedSmallInt, items),
            ICollection<uint> items => CreateCollectionValue(DuckDBType.UnsignedInteger, items),
            ICollection<uint?> items => CreateCollectionValue(DuckDBType.UnsignedInteger, items),
            ICollection<ulong> items => CreateCollectionValue(DuckDBType.UnsignedBigInt, items),
            ICollection<ulong?> items => CreateCollectionValue(DuckDBType.UnsignedBigInt, items),

            ICollection<float> items => CreateCollectionValue(DuckDBType.Float, items),
            ICollection<float?> items => CreateCollectionValue(DuckDBType.Float, items),
            ICollection<double> items => CreateCollectionValue(DuckDBType.Double, items),
            ICollection<double?> items => CreateCollectionValue(DuckDBType.Double, items),

            ICollection<decimal> items => CreateCollectionValue(DuckDBType.Varchar, items),
            ICollection<decimal?> items => CreateCollectionValue(DuckDBType.Varchar, items),
            ICollection<BigInteger> items => CreateCollectionValue(DuckDBType.HugeInt, items),
            ICollection<BigInteger?> items => CreateCollectionValue(DuckDBType.HugeInt, items),

            ICollection<string> items => CreateCollectionValue(DuckDBType.Varchar, items),
            ICollection<Guid> items => CreateCollectionValue(DuckDBType.Varchar, items),
            ICollection<Guid?> items => CreateCollectionValue(DuckDBType.Varchar, items),
            ICollection<DateTime> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<DateTime?> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<TimeSpan> items => CreateCollectionValue(DuckDBType.Interval, items),
            ICollection<TimeSpan?> items => CreateCollectionValue(DuckDBType.Interval, items),
            ICollection<DuckDBDateOnly> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<DuckDBDateOnly?> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<DuckDBTimeOnly> items => CreateCollectionValue(DuckDBType.Time, items),
            ICollection<DuckDBTimeOnly?> items => CreateCollectionValue(DuckDBType.Time, items),
#if NET6_0_OR_GREATER
            ICollection<DateOnly> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<DateOnly?> items => CreateCollectionValue(DuckDBType.Date, items),
            ICollection<TimeOnly> items => CreateCollectionValue(DuckDBType.Time, items),
            ICollection<TimeOnly?> items => CreateCollectionValue(DuckDBType.Time, items),
#endif
            ICollection<DateTimeOffset> items => CreateCollectionValue(DuckDBType.TimeTz, items),
            ICollection<DateTimeOffset?> items => CreateCollectionValue(DuckDBType.TimeTz, items),
            _ => throw new InvalidOperationException($"Cannot convert collection type {collection.GetType().FullName} to DuckDBValue.")
        };
    }

    private static DuckDBValue CreateCollectionValue<T>(DuckDBType duckDBType, ICollection<T> collection)
    {
        using var listItemType = NativeMethods.LogicalType.DuckDBCreateLogicalType(duckDBType);

        var values = new DuckDBValue[collection.Count];

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

        return NativeMethods.Value.DuckDBCreateListValue(listItemType, values, collection.Count);
    }

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

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

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

            (DuckDBType.TinyInt, _) => NativeMethods.Value.DuckDBCreateInt8(ConvertTo<sbyte>()),
            (DuckDBType.SmallInt, _) => NativeMethods.Value.DuckDBCreateInt16(ConvertTo<short>()),
            (DuckDBType.Integer, _) => NativeMethods.Value.DuckDBCreateInt32(ConvertTo<int>()),
            (DuckDBType.BigInt, _) => NativeMethods.Value.DuckDBCreateInt64(ConvertTo<long>()),

            (DuckDBType.UnsignedTinyInt, _) => NativeMethods.Value.DuckDBCreateUInt8(ConvertTo<byte>()),
            (DuckDBType.UnsignedSmallInt, _) => NativeMethods.Value.DuckDBCreateUInt16(ConvertTo<ushort>()),
            (DuckDBType.UnsignedInteger, _) => NativeMethods.Value.DuckDBCreateUInt32(ConvertTo<uint>()),
            (DuckDBType.UnsignedBigInt, _) => NativeMethods.Value.DuckDBCreateUInt64(ConvertTo<ulong>()),

            (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) => GuidToDuckDBValue(value),

            (DuckDBType.Timestamp, DateTime value) => NativeMethods.Value.DuckDBCreateTimestamp(NativeMethods.DateTimeHelpers.DuckDBToTimestamp(DuckDBTimestamp.FromDateTime(value))),
            (DuckDBType.Interval, TimeSpan value) => NativeMethods.Value.DuckDBCreateInterval(value),
            (DuckDBType.Date, DuckDBDateOnly value) => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(value)),
            (DuckDBType.Time, DuckDBTimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),
#if NET6_0_OR_GREATER
            (DuckDBType.Date, DateOnly value) => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(value)),
            (DuckDBType.Time, TimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),
#endif
            (DuckDBType.TimeTz, DateTimeOffset value) => DateTimeOffsetToDuckDBValue(value),
            (DuckDBType.Blob, byte[] value) => NativeMethods.Value.DuckDBCreateBlob(value, value.Length),
            (DuckDBType.List, ICollection value) => CreateCollectionValue(value),
            (DuckDBType.Array, ICollection value) => CreateCollectionValue(value),
            _ => throw new InvalidOperationException($"Cannot bind parameter type {item.GetType().FullName} to column of type {duckDBType}")
        };

        T ConvertTo<T>()
        {
            try
            {
                return (T)Convert.ChangeType(item, typeof(T));
            }
            catch (Exception)
            {
                throw new ArgumentOutOfRangeException($"Cannot bind parameter type {item.GetType().FullName} to column of type {duckDBType}");
            }
        }
    }
}

1	using System;
2	using System.Collections;
3	using System.Collections.Generic;
4	using System.Globalization;
5	using System.Numerics;
6	using DuckDB.NET.Data.Extensions;
7	using DuckDB.NET.Native;
8
9	namespace DuckDB.NET.Data.Internal;
10
11	internal static class ClrToDuckDBConverter
12	{
13	public static DuckDBValue ToDuckDBValue(this object? value)
14	{
15	if (value.IsNull())	7,860✔
16	{
17	return NativeMethods.Value.DuckDBCreateNullValue();	3,247✔
18	}
19
20	return value switch	4,613!
21	{	4,613✔
22	bool val => NativeMethods.Value.DuckDBCreateBool(val),	184✔
23		4,613✔
24	sbyte val => NativeMethods.Value.DuckDBCreateInt8(val),	177✔
25	short val => NativeMethods.Value.DuckDBCreateInt16(val),	210✔
26	int val => NativeMethods.Value.DuckDBCreateInt32(val),	162✔
27	long val => NativeMethods.Value.DuckDBCreateInt64(val),	243✔
28		4,613✔
29	byte val => NativeMethods.Value.DuckDBCreateUInt8(val),	156✔
30	ushort val => NativeMethods.Value.DuckDBCreateUInt16(val),	208✔
31	uint val => NativeMethods.Value.DuckDBCreateUInt32(val),	141✔
32	ulong val => NativeMethods.Value.DuckDBCreateUInt64(val),	174✔
33		4,613✔
34	float val => NativeMethods.Value.DuckDBCreateFloat(val),	238✔
35	double val => NativeMethods.Value.DuckDBCreateDouble(val),	156✔
36		4,613✔
37	decimal val => DecimalToDuckDBValue(val),	133✔
38	BigInteger val => NativeMethods.Value.DuckDBCreateHugeInt(new DuckDBHugeInt(val)),	147✔
39		4,613✔
40	string val => StringToDuckDBValue(val),	166✔
41	Guid val => GuidToDuckDBValue(val),	189✔
42	DateTime val => NativeMethods.Value.DuckDBCreateTimestamp(NativeMethods.DateTimeHelpers.DuckDBToTimestamp(DuckDBTimestamp.FromDateTime(val))),	358✔
43	TimeSpan val => NativeMethods.Value.DuckDBCreateInterval(val),	283✔
44	DuckDBDateOnly val => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(val)),	174✔
45	DuckDBTimeOnly val => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(val)),	168✔
46	#if NET6_0_OR_GREATER	4,613✔
47	DateOnly val => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(val)),	260✔
48	TimeOnly val => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(val)),	245✔
49	#endif	4,613✔
50	DateTimeOffset val => DateTimeOffsetToDuckDBValue(val),	441✔
51	byte[] val => NativeMethods.Value.DuckDBCreateBlob(val, val.Length),	×
52		4,613✔
53	ICollection val => CreateCollectionValue(val),	×
54	_ => throw new InvalidCastException($"Cannot convert value of type {value.GetType().FullName} to DuckDBValue.")	×
55	};	4,613✔
56	}
57
58	private static DuckDBValue DateTimeOffsetToDuckDBValue(DateTimeOffset val)
59	{
60	var duckDBToTime = NativeMethods.DateTimeHelpers.DuckDBToTime((DuckDBTimeOnly)val.DateTime);	459✔
61	var duckDBCreateTimeTz = NativeMethods.DateTimeHelpers.DuckDBCreateTimeTz(duckDBToTime.Micros, (int)val.Offset.TotalSeconds);	459✔
62	return NativeMethods.Value.DuckDBCreateTimeTz(duckDBCreateTimeTz);	459✔
63	}
64
65	private static DuckDBValue GuidToDuckDBValue(Guid value)
66	{
67	using var handle = value.ToString().ToUnmanagedString();	210✔
68	return NativeMethods.Value.DuckDBCreateVarchar(handle);	210✔
69	}	210✔
70
71	private static DuckDBValue DecimalToDuckDBValue(decimal value)
72	{
73	using var handle = value.ToString(CultureInfo.InvariantCulture).ToUnmanagedString();	181✔
74	return NativeMethods.Value.DuckDBCreateVarchar(handle);	181✔
75	}	181✔
76
77	private static DuckDBValue StringToDuckDBValue(string value)
78	{
79	using var handle = value.ToUnmanagedString();	238✔
80	return NativeMethods.Value.DuckDBCreateVarchar(handle);	238✔
81	}	238✔
82
83	private static DuckDBValue CreateCollectionValue(ICollection collection)
84	{
85	return collection switch	132!
86	{	132✔
87	ICollection<bool> items => CreateCollectionValue(DuckDBType.Boolean, items),	×
88	ICollection<bool?> items => CreateCollectionValue(DuckDBType.Boolean, items),	6✔
89		132✔
90	ICollection<sbyte> items => CreateCollectionValue(DuckDBType.TinyInt, items),	×
91	ICollection<sbyte?> items => CreateCollectionValue(DuckDBType.TinyInt, items),	6✔
92	ICollection<short> items => CreateCollectionValue(DuckDBType.SmallInt, items),	×
93	ICollection<short?> items => CreateCollectionValue(DuckDBType.SmallInt, items),	6✔
94	ICollection<int> items => CreateCollectionValue(DuckDBType.Integer, items),	×
95	ICollection<int?> items => CreateCollectionValue(DuckDBType.Integer, items),	6✔
96	ICollection<long> items => CreateCollectionValue(DuckDBType.BigInt, items),	×
97	ICollection<long?> items => CreateCollectionValue(DuckDBType.BigInt, items),	6✔
98		132✔
99	ICollection<byte> items => CreateCollectionValue(DuckDBType.UnsignedTinyInt, items),	×
100	ICollection<byte?> items => CreateCollectionValue(DuckDBType.UnsignedTinyInt, items),	6✔
101	ICollection<ushort> items => CreateCollectionValue(DuckDBType.UnsignedSmallInt, items),	×
102	ICollection<ushort?> items => CreateCollectionValue(DuckDBType.UnsignedSmallInt, items),	6✔
103	ICollection<uint> items => CreateCollectionValue(DuckDBType.UnsignedInteger, items),	×
104	ICollection<uint?> items => CreateCollectionValue(DuckDBType.UnsignedInteger, items),	6✔
105	ICollection<ulong> items => CreateCollectionValue(DuckDBType.UnsignedBigInt, items),	×
106	ICollection<ulong?> items => CreateCollectionValue(DuckDBType.UnsignedBigInt, items),	6✔
107		132✔
108	ICollection<float> items => CreateCollectionValue(DuckDBType.Float, items),	×
109	ICollection<float?> items => CreateCollectionValue(DuckDBType.Float, items),	6✔
110	ICollection<double> items => CreateCollectionValue(DuckDBType.Double, items),	×
111	ICollection<double?> items => CreateCollectionValue(DuckDBType.Double, items),	6✔
112		132✔
113	ICollection<decimal> items => CreateCollectionValue(DuckDBType.Varchar, items),	×
114	ICollection<decimal?> items => CreateCollectionValue(DuckDBType.Varchar, items),	6✔
115	ICollection<BigInteger> items => CreateCollectionValue(DuckDBType.HugeInt, items),	×
116	ICollection<BigInteger?> items => CreateCollectionValue(DuckDBType.HugeInt, items),	6✔
117		132✔
118	ICollection<string> items => CreateCollectionValue(DuckDBType.Varchar, items),	6✔
119	ICollection<Guid> items => CreateCollectionValue(DuckDBType.Varchar, items),	×
120	ICollection<Guid?> items => CreateCollectionValue(DuckDBType.Varchar, items),	6✔
121	ICollection<DateTime> items => CreateCollectionValue(DuckDBType.Date, items),	6✔
122	ICollection<DateTime?> items => CreateCollectionValue(DuckDBType.Date, items),	×
123	ICollection<TimeSpan> items => CreateCollectionValue(DuckDBType.Interval, items),	6✔
124	ICollection<TimeSpan?> items => CreateCollectionValue(DuckDBType.Interval, items),	×
125	ICollection<DuckDBDateOnly> items => CreateCollectionValue(DuckDBType.Date, items),	×
126	ICollection<DuckDBDateOnly?> items => CreateCollectionValue(DuckDBType.Date, items),	6✔
127	ICollection<DuckDBTimeOnly> items => CreateCollectionValue(DuckDBType.Time, items),	×
128	ICollection<DuckDBTimeOnly?> items => CreateCollectionValue(DuckDBType.Time, items),	6✔
129	#if NET6_0_OR_GREATER	132✔
130	ICollection<DateOnly> items => CreateCollectionValue(DuckDBType.Date, items),	×
131	ICollection<DateOnly?> items => CreateCollectionValue(DuckDBType.Date, items),	6✔
132	ICollection<TimeOnly> items => CreateCollectionValue(DuckDBType.Time, items),	6✔
133	ICollection<TimeOnly?> items => CreateCollectionValue(DuckDBType.Time, items),	×
134	#endif	132✔
135	ICollection<DateTimeOffset> items => CreateCollectionValue(DuckDBType.TimeTz, items),	6✔
136	ICollection<DateTimeOffset?> items => CreateCollectionValue(DuckDBType.TimeTz, items),	×
137	_ => throw new InvalidOperationException($"Cannot convert collection type {collection.GetType().FullName} to DuckDBValue.")	×
138	};	132✔
139	}
140
141	private static DuckDBValue CreateCollectionValue<T>(DuckDBType duckDBType, ICollection<T> collection)
142	{
143	using var listItemType = NativeMethods.LogicalType.DuckDBCreateLogicalType(duckDBType);	132✔
144
145	var values = new DuckDBValue[collection.Count];	132✔
146
147	var index = 0;	132✔
148	foreach (var item in collection)	15,984✔
149	{
150	var duckDBValue = item.ToDuckDBValue();	7,860✔
151	values[index] = duckDBValue;	7,860✔
152	index++;	7,860✔
153	}
154
155	return NativeMethods.Value.DuckDBCreateListValue(listItemType, values, collection.Count);	132✔
156	}	132✔
157
158	public static DuckDBValue ToDuckDBValue(this object? item, DuckDBLogicalType logicalType)
159	{
160	if (item.IsNull())	699✔
161	{
162	return NativeMethods.Value.DuckDBCreateNullValue();	24✔
163	}
164
165	var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(logicalType);	675✔
166
167	return (duckDBType, item) switch	675!
168	{	675✔
169	(DuckDBType.Boolean, bool value) => NativeMethods.Value.DuckDBCreateBool(value),	3✔
170		675✔
171	(DuckDBType.TinyInt, _) => NativeMethods.Value.DuckDBCreateInt8(ConvertTo<sbyte>()),	18✔
172	(DuckDBType.SmallInt, _) => NativeMethods.Value.DuckDBCreateInt16(ConvertTo<short>()),	18✔
173	(DuckDBType.Integer, _) => NativeMethods.Value.DuckDBCreateInt32(ConvertTo<int>()),	108✔
174	(DuckDBType.BigInt, _) => NativeMethods.Value.DuckDBCreateInt64(ConvertTo<long>()),	21✔
175		675✔
176	(DuckDBType.UnsignedTinyInt, _) => NativeMethods.Value.DuckDBCreateUInt8(ConvertTo<byte>()),	18✔
177	(DuckDBType.UnsignedSmallInt, _) => NativeMethods.Value.DuckDBCreateUInt16(ConvertTo<ushort>()),	18✔
178	(DuckDBType.UnsignedInteger, _) => NativeMethods.Value.DuckDBCreateUInt32(ConvertTo<uint>()),	18✔
179	(DuckDBType.UnsignedBigInt, _) => NativeMethods.Value.DuckDBCreateUInt64(ConvertTo<ulong>()),	18✔
180		675✔
181	(DuckDBType.Float, float value) => NativeMethods.Value.DuckDBCreateFloat(value),	3✔
182	(DuckDBType.Double, double value) => NativeMethods.Value.DuckDBCreateDouble(value),	3✔
183		675✔
184	(DuckDBType.Decimal, decimal value) => DecimalToDuckDBValue(value),	48✔
185	(DuckDBType.HugeInt, BigInteger value) => NativeMethods.Value.DuckDBCreateHugeInt(new DuckDBHugeInt(value)),	6✔
186		675✔
187	(DuckDBType.Varchar, string value) => StringToDuckDBValue(value),	72✔
188	(DuckDBType.Uuid, Guid value) => GuidToDuckDBValue(value),	21✔
189		675✔
190	(DuckDBType.Timestamp, DateTime value) => NativeMethods.Value.DuckDBCreateTimestamp(NativeMethods.DateTimeHelpers.DuckDBToTimestamp(DuckDBTimestamp.FromDateTime(value))),	36✔
191	(DuckDBType.Interval, TimeSpan value) => NativeMethods.Value.DuckDBCreateInterval(value),	×
192	(DuckDBType.Date, DuckDBDateOnly value) => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(value)),	18✔
193	(DuckDBType.Time, DuckDBTimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),	36✔
194	#if NET6_0_OR_GREATER	675✔
195	(DuckDBType.Date, DateOnly value) => NativeMethods.Value.DuckDBCreateDate(NativeMethods.DateTimeHelpers.DuckDBToDate(value)),	9✔
196	(DuckDBType.Time, TimeOnly value) => NativeMethods.Value.DuckDBCreateTime(NativeMethods.DateTimeHelpers.DuckDBToTime(value)),	18✔
197	#endif	675✔
198	(DuckDBType.TimeTz, DateTimeOffset value) => DateTimeOffsetToDuckDBValue(value),	18✔
199	(DuckDBType.Blob, byte[] value) => NativeMethods.Value.DuckDBCreateBlob(value, value.Length),	3✔
200	(DuckDBType.List, ICollection value) => CreateCollectionValue(value),	66✔
201	(DuckDBType.Array, ICollection value) => CreateCollectionValue(value),	66✔
202	_ => throw new InvalidOperationException($"Cannot bind parameter type {item.GetType().FullName} to column of type {duckDBType}")	12✔
203	};	675✔
204
205	T ConvertTo<T>()
206	{
207	try
208	{
209	return (T)Convert.ChangeType(item, typeof(T));	237✔
210	}
211	catch (Exception)	×
212	{
213	throw new ArgumentOutOfRangeException($"Cannot bind parameter type {item.GetType().FullName} to column of type {duckDBType}");	×
214	}
215	}	237✔
216	}
217	}

Giorgi / DuckDB.NET / 12063721251

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