11718008911

Committed 07 Nov 2024 06:48AM UTC coverage: 89.937% (+0.09%) from 89.848%

Build # 11718008911

Build Type

push

github

Committed by

Giorgi

Commit Message

Merge branch 'develop'

Run Details

1063 of 1216 branches covered (87.42%)

Branch coverage included in aggregate %.

256 of 275 new or added lines in 15 files covered. (93.09%)

1 existing line in 1 file now uncovered.

2083 of 2282 relevant lines covered (91.28%)

833852.27 hits per line

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

87.04

/DuckDB.NET.Bindings/DuckDBWrapperObjects.cs

﻿using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.CompilerServices;

namespace DuckDB.NET.Native;

public class DuckDBDatabase() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.Startup.DuckDBClose(out handle);
        return true;
    }
}

public class DuckDBNativeConnection() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.Startup.DuckDBDisconnect(out handle);
        return true;
    }

    public void Interrupt()
    {
        NativeMethods.Startup.DuckDBInterrupt(this);
    }
}

public class DuckDBPreparedStatement() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.PreparedStatements.DuckDBDestroyPrepare(out handle);
        return true;
    }
}

public class DuckDBConfig() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.Configuration.DuckDBDestroyConfig(out handle);
        return true;
    }
}

public class DuckDBAppender() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        return NativeMethods.Appender.DuckDBDestroyAppender(out handle) == DuckDBState.Success;
    }
}

public class DuckDBExtractedStatements() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.ExtractStatements.DuckDBDestroyExtracted(out handle);

        return true;
    }
}

public class DuckDBLogicalType() : SafeHandleZeroOrMinusOneIsInvalid(true)
{
    protected override bool ReleaseHandle()
    {
        NativeMethods.LogicalType.DuckDBDestroyLogicalType(out handle);
        return true;
    }
}

public class DuckDBDataChunk : SafeHandleZeroOrMinusOneIsInvalid
{
    public DuckDBDataChunk() : base(true)
    {
    }

    public DuckDBDataChunk(IntPtr chunk) : base(false)
    {
        SetHandle(chunk);
    }

    protected override bool ReleaseHandle()
    {
        NativeMethods.DataChunks.DuckDBDestroyDataChunk(out handle);
        return true;
    }
}

public class DuckDBValue() : SafeHandleZeroOrMinusOneIsInvalid(true), IDuckDBValueReader
{
    private DuckDBValue[] childValues = [];

    protected override bool ReleaseHandle()
    {
        foreach (var value in childValues)
        {
            value.Dispose();
        }
        
        NativeMethods.Value.DuckDBDestroyValue(out handle);
        return true;
    }

    internal void SetChildValues(DuckDBValue[] values)
    {
        childValues = values;
    }

    public T GetValue<T>()
    {
        var logicalType = NativeMethods.Value.DuckDBGetValueType(this);

        //Logical type is part of the duckdb_value object and it shouldn't be released separately
        //It will get released when the duckdb_value object is destroyed below.
        var add = false;
        logicalType.DangerousAddRef(ref add);

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

        return duckDBType switch
        {
            DuckDBType.Boolean => Cast(NativeMethods.Value.DuckDBGetBool(this)),

            DuckDBType.TinyInt => Cast(NativeMethods.Value.DuckDBGetInt8(this)),
            DuckDBType.SmallInt => Cast(NativeMethods.Value.DuckDBGetInt16(this)),
            DuckDBType.Integer => Cast(NativeMethods.Value.DuckDBGetInt32(this)),
            DuckDBType.BigInt => Cast(NativeMethods.Value.DuckDBGetInt64(this)),

            DuckDBType.UnsignedTinyInt => Cast(NativeMethods.Value.DuckDBGetUInt8(this)),
            DuckDBType.UnsignedSmallInt => Cast(NativeMethods.Value.DuckDBGetUInt16(this)),
            DuckDBType.UnsignedInteger => Cast(NativeMethods.Value.DuckDBGetUInt32(this)),
            DuckDBType.UnsignedBigInt => Cast(NativeMethods.Value.DuckDBGetUInt64(this)),

            DuckDBType.Float => Cast(NativeMethods.Value.DuckDBGetFloat(this)),
            DuckDBType.Double => Cast(NativeMethods.Value.DuckDBGetDouble(this)),
            
            DuckDBType.Decimal => Cast(decimal.Parse(NativeMethods.Value.DuckDBGetVarchar(this))),
            DuckDBType.Uuid => Cast(new Guid(NativeMethods.Value.DuckDBGetVarchar(this))),
            
            //DuckDBType.HugeInt => expr,
            //DuckDBType.UnsignedHugeInt => expr,
            
            DuckDBType.Varchar => Cast(NativeMethods.Value.DuckDBGetVarchar(this)),
            
            //DuckDBType.Date => expr,
            //DuckDBType.Time => expr,
            //DuckDBType.TimeTz => expr,
            //DuckDBType.Interval => expr,
            DuckDBType.Timestamp => Cast(NativeMethods.DateTimeHelpers.DuckDBFromTimestamp(NativeMethods.Value.DuckDBGetTimestamp(this)).ToDateTime()),
            //DuckDBType.TimestampS => expr,
            //DuckDBType.TimestampMs => expr,
            //DuckDBType.TimestampNs => expr,
            //DuckDBType.TimestampTz => expr,
            _ => throw new NotImplementedException($"Cannot read value of type {typeof(T).FullName}")
        };

        T Cast<TSource>(TSource value)
        {
            return Unsafe.As<TSource, T>(ref value);
        }
    }
}

1	using Microsoft.Win32.SafeHandles;
2	using System;
3	using System.Runtime.CompilerServices;
4
5	namespace DuckDB.NET.Native;
6
7	public class DuckDBDatabase() : SafeHandleZeroOrMinusOneIsInvalid(true)	56,672✔
8	{
9	protected override bool ReleaseHandle()
10	{
11	NativeMethods.Startup.DuckDBClose(out handle);	56,670✔
12	return true;	56,670✔
13	}
14	}
15
16	public class DuckDBNativeConnection() : SafeHandleZeroOrMinusOneIsInvalid(true)	64,926✔
17	{
18	protected override bool ReleaseHandle()
19	{
20	NativeMethods.Startup.DuckDBDisconnect(out handle);	64,924✔
21	return true;	64,924✔
22	}
23
24	public void Interrupt()
25	{
26	NativeMethods.Startup.DuckDBInterrupt(this);	3✔
27	}	3✔
28	}
29
30	public class DuckDBPreparedStatement() : SafeHandleZeroOrMinusOneIsInvalid(true)	219,309✔
31	{
32	protected override bool ReleaseHandle()
33	{
34	NativeMethods.PreparedStatements.DuckDBDestroyPrepare(out handle);	219,303✔
35	return true;	219,303✔
36	}
37	}
38
39	public class DuckDBConfig() : SafeHandleZeroOrMinusOneIsInvalid(true)	56,672✔
40	{
41	protected override bool ReleaseHandle()
42	{
43	NativeMethods.Configuration.DuckDBDestroyConfig(out handle);	56,672✔
44	return true;	56,672✔
45	}
46	}
47
48	public class DuckDBAppender() : SafeHandleZeroOrMinusOneIsInvalid(true)	171✔
49	{
50	protected override bool ReleaseHandle()
51	{
52	return NativeMethods.Appender.DuckDBDestroyAppender(out handle) == DuckDBState.Success;	171✔
53	}
54	}
55
56	public class DuckDBExtractedStatements() : SafeHandleZeroOrMinusOneIsInvalid(true)	219,201✔
57	{
58	protected override bool ReleaseHandle()
59	{
60	NativeMethods.ExtractStatements.DuckDBDestroyExtracted(out handle);	219,195✔
61
62	return true;	219,195✔
63	}
64	}
65
66	public class DuckDBLogicalType() : SafeHandleZeroOrMinusOneIsInvalid(true)	88,474✔
67	{
68	protected override bool ReleaseHandle()
69	{
70	NativeMethods.LogicalType.DuckDBDestroyLogicalType(out handle);	87,970✔
71	return true;	87,970✔
72	}
73	}
74
75	public class DuckDBDataChunk : SafeHandleZeroOrMinusOneIsInvalid
76	{
77	public DuckDBDataChunk() : base(true)	64,600✔
78	{
79	}	64,600✔
80
81	public DuckDBDataChunk(IntPtr chunk) : base(false)	105✔
82	{
83	SetHandle(chunk);	105✔
84	}	105✔
85
86	protected override bool ReleaseHandle()
87	{
88	NativeMethods.DataChunks.DuckDBDestroyDataChunk(out handle);	64,178✔
89	return true;	64,178✔
90	}
91	}
92
93	public class DuckDBValue() : SafeHandleZeroOrMinusOneIsInvalid(true), IDuckDBValueReader	8,443✔
94	{
95	private DuckDBValue[] childValues = [];	8,443✔
96
97	protected override bool ReleaseHandle()
98	{
99	foreach (var value in childValues)	32,308✔
100	{
101	value.Dispose();	7,711✔
102	}
103
104	NativeMethods.Value.DuckDBDestroyValue(out handle);	8,443✔
105	return true;	8,443✔
106	}
107
108	internal void SetChildValues(DuckDBValue[] values)
109	{
110	childValues = values;	132✔
111	}	132✔
112
113	public T GetValue<T>()
114	{
115	var logicalType = NativeMethods.Value.DuckDBGetValueType(this);	45✔
116
117	//Logical type is part of the duckdb_value object and it shouldn't be released separately
118	//It will get released when the duckdb_value object is destroyed below.
119	var add = false;	45✔
120	logicalType.DangerousAddRef(ref add);	45✔
121
122	var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(logicalType);	45✔
123
124	return duckDBType switch	45!
125	{	45✔
126	DuckDBType.Boolean => Cast(NativeMethods.Value.DuckDBGetBool(this)),	3✔
127		45✔
128	DuckDBType.TinyInt => Cast(NativeMethods.Value.DuckDBGetInt8(this)),	3✔
129	DuckDBType.SmallInt => Cast(NativeMethods.Value.DuckDBGetInt16(this)),	3✔
130	DuckDBType.Integer => Cast(NativeMethods.Value.DuckDBGetInt32(this)),	3✔
131	DuckDBType.BigInt => Cast(NativeMethods.Value.DuckDBGetInt64(this)),	3✔
132		45✔
133	DuckDBType.UnsignedTinyInt => Cast(NativeMethods.Value.DuckDBGetUInt8(this)),	3✔
134	DuckDBType.UnsignedSmallInt => Cast(NativeMethods.Value.DuckDBGetUInt16(this)),	3✔
135	DuckDBType.UnsignedInteger => Cast(NativeMethods.Value.DuckDBGetUInt32(this)),	3✔
136	DuckDBType.UnsignedBigInt => Cast(NativeMethods.Value.DuckDBGetUInt64(this)),	3✔
137		45✔
138	DuckDBType.Float => Cast(NativeMethods.Value.DuckDBGetFloat(this)),	3✔
139	DuckDBType.Double => Cast(NativeMethods.Value.DuckDBGetDouble(this)),	3✔
140		45✔
141	DuckDBType.Decimal => Cast(decimal.Parse(NativeMethods.Value.DuckDBGetVarchar(this))),	3✔
142	DuckDBType.Uuid => Cast(new Guid(NativeMethods.Value.DuckDBGetVarchar(this))),	3✔
143		45✔
144	//DuckDBType.HugeInt => expr,	45✔
145	//DuckDBType.UnsignedHugeInt => expr,	45✔
146		45✔
147	DuckDBType.Varchar => Cast(NativeMethods.Value.DuckDBGetVarchar(this)),	3✔
148		45✔
149	//DuckDBType.Date => expr,	45✔
150	//DuckDBType.Time => expr,	45✔
151	//DuckDBType.TimeTz => expr,	45✔
152	//DuckDBType.Interval => expr,	45✔
153	DuckDBType.Timestamp => Cast(NativeMethods.DateTimeHelpers.DuckDBFromTimestamp(NativeMethods.Value.DuckDBGetTimestamp(this)).ToDateTime()),	3✔
154	//DuckDBType.TimestampS => expr,	45✔
155	//DuckDBType.TimestampMs => expr,	45✔
156	//DuckDBType.TimestampNs => expr,	45✔
157	//DuckDBType.TimestampTz => expr,	45✔
NEW 158	_ => throw new NotImplementedException($"Cannot read value of type {typeof(T).FullName}")	×
159	};	45✔
160
161	T Cast<TSource>(TSource value)
162	{
163	return Unsafe.As<TSource, T>(ref value);	45✔
164	}
165	}
166	}

Giorgi / DuckDB.NET / 11718008911

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