10928927861

Committed 18 Sep 2024 07:34PM UTC coverage: 89.835%. Remained the same

Build # 10928927861

Build Type

push

github

Committed by

Giorgi

Commit Message

Make properties read-only

Run Details

918 of 1052 branches covered (87.26%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

1910 of 2096 relevant lines covered (91.13%)

885429.07 hits per line

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

66.67

/DuckDB.NET.Bindings/DuckDBNativeObjects.cs

﻿using System;
using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using System.Runtime.InteropServices;

namespace DuckDB.NET.Native;

public enum DuckDBState
{
    Success = 0,
    Error = 1
}

public enum DuckDBType
{
    Invalid = 0,
    // bool
    Boolean = 1,
    // int8_t
    TinyInt = 2,
    // int16_t
    SmallInt = 3,
    // int32_t
    Integer = 4,
    // int64_t
    BigInt = 5,
    // uint8_t
    UnsignedTinyInt = 6,
    // uint16_t
    UnsignedSmallInt = 7,
    // uint32_t
    UnsignedInteger = 8,
    // uint64_t
    UnsignedBigInt = 9,
    // float
    Float = 10,
    // double
    Double = 11,
    // duckdb_timestamp
    Timestamp = 12,
    // duckdb_date
    Date = 13,
    // duckdb_time
    Time = 14,
    // duckdb_interval
    Interval = 15,
    // duckdb_hugeint
    HugeInt = 16,
    // duckdb_uhugeint
    UnsignedHugeInt = 32,
    // const char*
    Varchar = 17,
    // duckdb_blob
    Blob = 18,
    //decimal
    Decimal = 19,
    // duckdb_timestamp, in seconds
    TimestampS = 20,
    // duckdb_timestamp, in milliseconds
    TimestampMs = 21,
    // duckdb_timestamp, in nanoseconds
    TimestampNs = 22,
    // enum type, only useful as logical type
    Enum = 23,
    // list type, only useful as logical type
    List = 24,
    // duckdb_array, only useful as logical type
    Array = 33,
    // struct type, only useful as logical type
    Struct = 25,
    // map type, only useful as logical type
    Map = 26,
    // duckdb_hugeint
    Uuid = 27,
    // union type, only useful as logical type
    Union = 28,
    // duckdb_bit
    Bit = 29,
    // duckdb_time_tz
    TimeTz = 30,
    // duckdb_timestamp
    TimestampTz = 31,
    // ANY type
    Any = 34,
    // duckdb_varint
    VarInt = 35,
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBResult : IDisposable
{
    [Obsolete]
    private long ColumnCount;

    [Obsolete]
    private long RowCount;

    [Obsolete]
    private long RowsChanged;

    [Obsolete]
    private IntPtr columns;

    [Obsolete]
    private IntPtr ErrorMessage;

    private IntPtr internal_data;

    public void Dispose()
    {
        NativeMethods.Query.DuckDBDestroyResult(ref this);
    }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBDate
{
    public int Days { get; set; }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBTime
{
    public long Micros { get; set; }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBTimeTzStruct
{
    public ulong Bits { get; set; }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBTimeTz
{
    public DuckDBTimeOnly Time { get; set; }
    public int Offset { get; set; }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBTimestampStruct
{
    public long Micros { get; set; }

    public readonly DateTime ToDateTime()
    {
        var ticks = Micros * 10 + Utils.UnixEpochTicks;
        return new DateTime(ticks);
    }
}

[StructLayout(LayoutKind.Sequential)]
public readonly struct DuckDBBlob : IDisposable
{
    public IntPtr Data { get; }

    public long Size { get; }

    public void Dispose()
    {
        NativeMethods.Helpers.DuckDBFree(Data);
    }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBListEntry(ulong offset, ulong length)
{
    public ulong Offset { get; private set; } = offset;
    public ulong Length { get; private set; } = length;
}

public struct DuckDBString
{
    public _value_e__Union value;

    private const int InlineStringMaxLength = 12;

    public readonly int Length => (int)value.inlined.length;

    public readonly unsafe sbyte* Data
    {
        get
        {
            if (Length <= InlineStringMaxLength)
            {
                fixed (sbyte* pointerToFirst = value.inlined.inlined)
                {
                    return pointerToFirst;
                }
            }
            else
            {
                return value.pointer.ptr;
            }
        }
    }

    [StructLayout(LayoutKind.Explicit)]
    public partial struct _value_e__Union
    {
        [FieldOffset(0)]
        public DuckDBStringPointer pointer;

        [FieldOffset(0)]
        public DuckDBStringInlined inlined;

        public unsafe partial struct DuckDBStringPointer
        {
            public uint length;

            public fixed sbyte prefix[4];

            public sbyte* ptr;
        }

        public unsafe partial struct DuckDBStringInlined
        {
            public uint length;

            public fixed sbyte inlined[12];
        }
    }
}

[StructLayout(LayoutKind.Sequential)]
public struct DuckDBQueryProgressType
{
    public double Percentage { get; }
    public ulong RowsProcessed { get; }
    public ulong TotalRowsToProcess { get; }
}

1	using System;
2	using System.Diagnostics.CodeAnalysis;
3	using System.Numerics;
4	using System.Runtime.InteropServices;
5
6	namespace DuckDB.NET.Native;
7
8	public enum DuckDBState
9	{
10	Success = 0,
11	Error = 1
12	}
13
14	public enum DuckDBType
15	{
16	Invalid = 0,
17	// bool
18	Boolean = 1,
19	// int8_t
20	TinyInt = 2,
21	// int16_t
22	SmallInt = 3,
23	// int32_t
24	Integer = 4,
25	// int64_t
26	BigInt = 5,
27	// uint8_t
28	UnsignedTinyInt = 6,
29	// uint16_t
30	UnsignedSmallInt = 7,
31	// uint32_t
32	UnsignedInteger = 8,
33	// uint64_t
34	UnsignedBigInt = 9,
35	// float
36	Float = 10,
37	// double
38	Double = 11,
39	// duckdb_timestamp
40	Timestamp = 12,
41	// duckdb_date
42	Date = 13,
43	// duckdb_time
44	Time = 14,
45	// duckdb_interval
46	Interval = 15,
47	// duckdb_hugeint
48	HugeInt = 16,
49	// duckdb_uhugeint
50	UnsignedHugeInt = 32,
51	// const char*
52	Varchar = 17,
53	// duckdb_blob
54	Blob = 18,
55	//decimal
56	Decimal = 19,
57	// duckdb_timestamp, in seconds
58	TimestampS = 20,
59	// duckdb_timestamp, in milliseconds
60	TimestampMs = 21,
61	// duckdb_timestamp, in nanoseconds
62	TimestampNs = 22,
63	// enum type, only useful as logical type
64	Enum = 23,
65	// list type, only useful as logical type
66	List = 24,
67	// duckdb_array, only useful as logical type
68	Array = 33,
69	// struct type, only useful as logical type
70	Struct = 25,
71	// map type, only useful as logical type
72	Map = 26,
73	// duckdb_hugeint
74	Uuid = 27,
75	// union type, only useful as logical type
76	Union = 28,
77	// duckdb_bit
78	Bit = 29,
79	// duckdb_time_tz
80	TimeTz = 30,
81	// duckdb_timestamp
82	TimestampTz = 31,
83	// ANY type
84	Any = 34,
85	// duckdb_varint
86	VarInt = 35,
87	}
88
89	[StructLayout(LayoutKind.Sequential)]
90	public struct DuckDBResult : IDisposable
91	{
92	[Obsolete]
93	private long ColumnCount;
94
95	[Obsolete]
96	private long RowCount;
97
98	[Obsolete]
99	private long RowsChanged;
100
101	[Obsolete]
102	private IntPtr columns;
103
104	[Obsolete]
105	private IntPtr ErrorMessage;
106
107	private IntPtr internal_data;
108
109	public void Dispose()
110	{
111	NativeMethods.Query.DuckDBDestroyResult(ref this);	187,170✔
112	}	187,170✔
113	}
114
115	[StructLayout(LayoutKind.Sequential)]
116	public struct DuckDBDate
117	{
118	public int Days { get; set; }	×
119	}
120
121	[StructLayout(LayoutKind.Sequential)]
122	public struct DuckDBTime
123	{
124	public long Micros { get; set; }	60✔
125	}
126
127	[StructLayout(LayoutKind.Sequential)]
128	public struct DuckDBTimeTzStruct
129	{
130	public ulong Bits { get; set; }	×
131	}
132
133	[StructLayout(LayoutKind.Sequential)]
134	public struct DuckDBTimeTz
135	{
136	public DuckDBTimeOnly Time { get; set; }	102✔
137	public int Offset { get; set; }	102✔
138	}
139
140	[StructLayout(LayoutKind.Sequential)]
141	public struct DuckDBTimestampStruct
142	{
143	public long Micros { get; set; }	46,770✔
144
145	public readonly DateTime ToDateTime()
146	{
147	var ticks = Micros * 10 + Utils.UnixEpochTicks;	15,438✔
148	return new DateTime(ticks);	15,438✔
149	}
150	}
151
152	[StructLayout(LayoutKind.Sequential)]
153	public readonly struct DuckDBBlob : IDisposable
154	{
155	public IntPtr Data { get; }	×
156
157	public long Size { get; }	×
158
159	public void Dispose()
160	{
161	NativeMethods.Helpers.DuckDBFree(Data);	×
162	}	×
163	}
164
165	[StructLayout(LayoutKind.Sequential)]
166	public struct DuckDBListEntry(ulong offset, ulong length)
167	{
168	public ulong Offset { get; private set; } = offset;	1,897,849✔
169	public ulong Length { get; private set; } = length;	1,897,882✔
170	}
171
172	public struct DuckDBString
173	{
174	public _value_e__Union value;
175
176	private const int InlineStringMaxLength = 12;
177
178	public readonly int Length => (int)value.inlined.length;	2,934,063✔
179
180	public readonly unsafe sbyte* Data
181	{
182	get
183	{
184	if (Length <= InlineStringMaxLength)	1,124,109✔
185	{	368,678✔
186	fixed (sbyte* pointerToFirst = value.inlined.inlined)	368,678✔
187	{
188	return pointerToFirst;	368,678✔
189	}
190	}
191	else
192	{
193	return value.pointer.ptr;	755,431✔
194	}
195	}
196	}
197
198	[StructLayout(LayoutKind.Explicit)]
199	public partial struct _value_e__Union
200	{
201	[FieldOffset(0)]
202	public DuckDBStringPointer pointer;
203
204	[FieldOffset(0)]
205	public DuckDBStringInlined inlined;
206
207	public unsafe partial struct DuckDBStringPointer
208	{
209	public uint length;
210
211	public fixed sbyte prefix[4];
212
213	public sbyte* ptr;
214	}
215
216	public unsafe partial struct DuckDBStringInlined
217	{
218	public uint length;
219
220	public fixed sbyte inlined[12];
221	}
222	}
223	}
224
225	[StructLayout(LayoutKind.Sequential)]
226	public struct DuckDBQueryProgressType
227	{
NEW 228	public double Percentage { get; }	×
NEW 229	public ulong RowsProcessed { get; }	×
NEW 230	public ulong TotalRowsToProcess { get; }	×
231	}

Giorgi / DuckDB.NET / 10928927861

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