22323392380

Committed 23 Feb 2026 07:25PM UTC coverage: 89.658% (-0.008%) from 89.666%

Build # 22323392380

Build Type

push

github

Committed by

Giorgi

Commit Message

Throw on invalid enum internal type instead of returning -1

Run Details

1237 of 1437 branches covered (86.08%)

Branch coverage included in aggregate %.

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

6 existing lines in 2 files now uncovered.

2543 of 2779 relevant lines covered (91.51%)

471972.16 hits per line

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

92.86

/DuckDB.NET.Data/DuckDBAppenderRow.cs

﻿using DuckDB.NET.Data.DataChunk.Writer;

namespace DuckDB.NET.Data;

public class DuckDBAppenderRow : IDuckDBAppenderRow
{
    private int columnIndex = 0;
    private readonly string qualifiedTableName;
    private readonly VectorDataWriterBase[] vectorWriters;
    private readonly ulong rowIndex;
    private readonly DuckDBDataChunk dataChunk;
    private readonly Native.DuckDBAppender nativeAppender;

    internal DuckDBAppenderRow(string qualifiedTableName, VectorDataWriterBase[] vectorWriters,
                               ulong rowIndex, DuckDBDataChunk dataChunk, Native.DuckDBAppender nativeAppender)
    {
        this.qualifiedTableName = qualifiedTableName;
        this.vectorWriters = vectorWriters;
        this.rowIndex = rowIndex;
        this.dataChunk = dataChunk;
        this.nativeAppender = nativeAppender;
    }

    public void EndRow()
    {
        if (columnIndex < vectorWriters.Length)
        {
            throw new InvalidOperationException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you specified only {columnIndex} values");
        }
    }

    public IDuckDBAppenderRow AppendNullValue()
    {
        CheckColumnAccess();
        vectorWriters[columnIndex].WriteNull(rowIndex);
        columnIndex++;
        return this;
    }

    public IDuckDBAppenderRow AppendValue(bool? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(byte[]? value) => AppendSpan(value);

    public IDuckDBAppenderRow AppendValue(Span<byte> value) => AppendSpan(value);

    public IDuckDBAppenderRow AppendValue(string? value) => AppendValueInternalClass(value);

    public IDuckDBAppenderRow AppendValue(decimal? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(Guid? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(BigInteger? value) => AppendValueInternalStruct(value);

    #region Append Signed Int

    public IDuckDBAppenderRow AppendValue(sbyte? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(short? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(int? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(long? value) => AppendValueInternalStruct(value);

    #endregion

    #region Append Unsigned Int

    public IDuckDBAppenderRow AppendValue(byte? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(ushort? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(uint? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(ulong? value) => AppendValueInternalStruct(value);

    #endregion

    #region Append Enum

    public IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum
    {
        CheckColumnAccess();

        if (value != null)
        {
            vectorWriters[columnIndex].WriteValue(value, rowIndex);
        }
        else
        {
            vectorWriters[columnIndex].WriteNull(rowIndex);
        }

        columnIndex++;
        return this;
    }

    #endregion

    #region Append Float

    public IDuckDBAppenderRow AppendValue(float? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(double? value) => AppendValueInternalStruct(value);

    #endregion

    #region Append Temporal
    public IDuckDBAppenderRow AppendValue(DateOnly? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(TimeOnly? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(DateTime? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(DateTimeOffset? value) => AppendValueInternalStruct(value);

    public IDuckDBAppenderRow AppendValue(TimeSpan? value) => AppendValueInternalStruct(value);

    #endregion

    #region Composite Types

    public IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value) => AppendValueInternalClass(value);

    #endregion

    public IDuckDBAppenderRow AppendDefault()
    {
        CheckColumnAccess();

        var state = NativeMethods.Appender.DuckDBAppendDefaultToChunk(nativeAppender, dataChunk, columnIndex, rowIndex);

        if (state == DuckDBState.Error)
        {
            DuckDBAppender.ThrowLastError(nativeAppender);
        }

        columnIndex++;
        return this;
    }

    private DuckDBAppenderRow AppendValueInternalStruct<T>(T? value) where T : struct
    {
        CheckColumnAccess();

        if (value.HasValue)
        {
            vectorWriters[columnIndex].WriteValue(value.Value, rowIndex);
        }
        else
        {
            vectorWriters[columnIndex].WriteNull(rowIndex);
        }

        columnIndex++;
        return this;
    }

    private DuckDBAppenderRow AppendValueInternalClass<T>(T? value) where T : class
    {
        CheckColumnAccess();

        vectorWriters[columnIndex].WriteValue(value, rowIndex);

        columnIndex++;
        return this;
    }

    private unsafe IDuckDBAppenderRow AppendSpan(Span<byte> val)
    {
        if (val == null)
        {
            return AppendNullValue();
        }

        CheckColumnAccess();

        fixed (byte* pSource = val)
        {
            vectorWriters[columnIndex].AppendBlob(pSource, val.Length, rowIndex);
        }

        columnIndex++;
        return this;
    }

    private void CheckColumnAccess()
    {
        if (columnIndex >= vectorWriters.Length)
        {
            throw new IndexOutOfRangeException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you are trying to append value for column {columnIndex + 1}");
        }
    }
}

public interface IDuckDBAppenderRow
{
    void EndRow();
    IDuckDBAppenderRow AppendNullValue();
    IDuckDBAppenderRow AppendValue(bool? value);
    IDuckDBAppenderRow AppendValue(byte[]? value);
    IDuckDBAppenderRow AppendValue(Span<byte> value);
    IDuckDBAppenderRow AppendValue(string? value);
    IDuckDBAppenderRow AppendValue(decimal? value);
    IDuckDBAppenderRow AppendValue(Guid? value);
    IDuckDBAppenderRow AppendValue(BigInteger? value);
    IDuckDBAppenderRow AppendValue(sbyte? value);
    IDuckDBAppenderRow AppendValue(short? value);
    IDuckDBAppenderRow AppendValue(int? value);
    IDuckDBAppenderRow AppendValue(long? value);
    IDuckDBAppenderRow AppendValue(byte? value);
    IDuckDBAppenderRow AppendValue(ushort? value);
    IDuckDBAppenderRow AppendValue(uint? value);
    IDuckDBAppenderRow AppendValue(ulong? value);
    IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum;
    IDuckDBAppenderRow AppendValue(float? value);
    IDuckDBAppenderRow AppendValue(double? value);
    IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value);
    IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value);
    IDuckDBAppenderRow AppendValue(DateTime? value);
    IDuckDBAppenderRow AppendValue(DateTimeOffset? value);
    IDuckDBAppenderRow AppendValue(TimeSpan? value);
    IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value);
    IDuckDBAppenderRow AppendDefault();
}

1	using DuckDB.NET.Data.DataChunk.Writer;
2
3	namespace DuckDB.NET.Data;
4
5	public class DuckDBAppenderRow : IDuckDBAppenderRow
6	{
7	private int columnIndex = 0;
8	private readonly string qualifiedTableName;
9	private readonly VectorDataWriterBase[] vectorWriters;
10	private readonly ulong rowIndex;
11	private readonly DuckDBDataChunk dataChunk;
12	private readonly Native.DuckDBAppender nativeAppender;
13
14	internal DuckDBAppenderRow(string qualifiedTableName, VectorDataWriterBase[] vectorWriters,	430,047✔
15	ulong rowIndex, DuckDBDataChunk dataChunk, Native.DuckDBAppender nativeAppender)	430,047✔
16	{
17	this.qualifiedTableName = qualifiedTableName;	430,047✔
18	this.vectorWriters = vectorWriters;	430,047✔
19	this.rowIndex = rowIndex;	430,047✔
20	this.dataChunk = dataChunk;	430,047✔
21	this.nativeAppender = nativeAppender;	430,047✔
22	}	430,047✔
23
24	public void EndRow()
25	{
26	if (columnIndex < vectorWriters.Length)	430,029✔
27	{
28	throw new InvalidOperationException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you specified only {columnIndex} values");	3✔
29	}
30	}	430,026✔
31
32	public IDuckDBAppenderRow AppendNullValue()
33	{
34	CheckColumnAccess();	81✔
35	vectorWriters[columnIndex].WriteNull(rowIndex);	81✔
36	columnIndex++;	81✔
37	return this;	81✔
38	}
39
40	public IDuckDBAppenderRow AppendValue(bool? value) => AppendValueInternalStruct(value);	69✔
41
42	public IDuckDBAppenderRow AppendValue(byte[]? value) => AppendSpan(value);	6✔
43
44	public IDuckDBAppenderRow AppendValue(Span<byte> value) => AppendSpan(value);	3✔
45
46	public IDuckDBAppenderRow AppendValue(string? value) => AppendValueInternalClass(value);	45,120✔
47
48	public IDuckDBAppenderRow AppendValue(decimal? value) => AppendValueInternalStruct(value);	327✔
49
50	public IDuckDBAppenderRow AppendValue(Guid? value) => AppendValueInternalStruct(value);	105,003✔
51
52	public IDuckDBAppenderRow AppendValue(BigInteger? value) => AppendValueInternalStruct(value);	60✔
53
54	#region Append Signed Int
55
56	public IDuckDBAppenderRow AppendValue(sbyte? value) => AppendValueInternalStruct(value);	75,084✔
57
58	public IDuckDBAppenderRow AppendValue(short? value) => AppendValueInternalStruct(value);	60✔
59
60	public IDuckDBAppenderRow AppendValue(int? value) => AppendValueInternalStruct(value);	324,810✔
61
62	public IDuckDBAppenderRow AppendValue(long? value) => AppendValueInternalStruct(value);	60✔
63
64	#endregion
65
66	#region Append Unsigned Int
67
68	public IDuckDBAppenderRow AppendValue(byte? value) => AppendValueInternalStruct(value);	66✔
69
70	public IDuckDBAppenderRow AppendValue(ushort? value) => AppendValueInternalStruct(value);	60✔
71
72	public IDuckDBAppenderRow AppendValue(uint? value) => AppendValueInternalStruct(value);	60✔
73
74	public IDuckDBAppenderRow AppendValue(ulong? value) => AppendValueInternalStruct(value);	60✔
75
76	#endregion
77
78	#region Append Enum
79
80	public IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum
81	{
82	CheckColumnAccess();	15✔
83
84	if (value != null)	15!
85	{
86	vectorWriters[columnIndex].WriteValue(value, rowIndex);	15✔
87	}
88	else
89	{
UNCOV 90	vectorWriters[columnIndex].WriteNull(rowIndex);	×
91	}
92
93	columnIndex++;	12✔
94	return this;	12✔
95	}
96
97	#endregion
98
99	#region Append Float
100
101	public IDuckDBAppenderRow AppendValue(float? value) => AppendValueInternalStruct(value);	66✔
102
103	public IDuckDBAppenderRow AppendValue(double? value) => AppendValueInternalStruct(value);	120✔
104
105	#endregion
106
107	#region Append Temporal
UNCOV 108	public IDuckDBAppenderRow AppendValue(DateOnly? value) => AppendValueInternalStruct(value);	×
109
UNCOV 110	public IDuckDBAppenderRow AppendValue(TimeOnly? value) => AppendValueInternalStruct(value);	×
111
112	public IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value) => AppendValueInternalStruct(value);	120✔
113
114	public IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value) => AppendValueInternalStruct(value);	60✔
115
116	public IDuckDBAppenderRow AppendValue(DateTime? value) => AppendValueInternalStruct(value);	15,336✔
117
118	public IDuckDBAppenderRow AppendValue(DateTimeOffset? value) => AppendValueInternalStruct(value);	120✔
119
120	public IDuckDBAppenderRow AppendValue(TimeSpan? value) => AppendValueInternalStruct(value);	60✔
121
122	#endregion
123
124	#region Composite Types
125
126	public IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value) => AppendValueInternalClass(value);	498,006✔
127
128	#endregion
129
130	public IDuckDBAppenderRow AppendDefault()
131	{
132	CheckColumnAccess();	75,015✔
133
134	var state = NativeMethods.Appender.DuckDBAppendDefaultToChunk(nativeAppender, dataChunk, columnIndex, rowIndex);	75,015✔
135
136	if (state == DuckDBState.Error)	75,015!
137	{
UNCOV 138	DuckDBAppender.ThrowLastError(nativeAppender);	×
139	}
140
141	columnIndex++;	75,015✔
142	return this;	75,015✔
143	}
144
145	private DuckDBAppenderRow AppendValueInternalStruct<T>(T? value) where T : struct
146	{
147	CheckColumnAccess();	521,601✔
148
149	if (value.HasValue)	521,601✔
150	{
151	vectorWriters[columnIndex].WriteValue(value.Value, rowIndex);	521,598✔
152	}
153	else
154	{
155	vectorWriters[columnIndex].WriteNull(rowIndex);	3✔
156	}
157
158	columnIndex++;	521,598✔
159	return this;	521,598✔
160	}
161
162	private DuckDBAppenderRow AppendValueInternalClass<T>(T? value) where T : class
163	{
164	CheckColumnAccess();	543,126✔
165
166	vectorWriters[columnIndex].WriteValue(value, rowIndex);	543,123✔
167
168	columnIndex++;	543,114✔
169	return this;	543,114✔
170	}
171
172	private unsafe IDuckDBAppenderRow AppendSpan(Span<byte> val)
173	{
174	if (val == null)	9✔
175	{
176	return AppendNullValue();	3✔
177	}
178
179	CheckColumnAccess();	6✔
180
181	fixed (byte* pSource = val)	6✔
182	{
183	vectorWriters[columnIndex].AppendBlob(pSource, val.Length, rowIndex);	6✔
184	}
185
186	columnIndex++;	6✔
187	return this;	6✔
188	}
189
190	private void CheckColumnAccess()
191	{
192	if (columnIndex >= vectorWriters.Length)	1,139,844✔
193	{
194	throw new IndexOutOfRangeException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you are trying to append value for column {columnIndex + 1}");	3✔
195	}
196	}	1,139,841✔
197	}
198
199	public interface IDuckDBAppenderRow
200	{
201	void EndRow();
202	IDuckDBAppenderRow AppendNullValue();
203	IDuckDBAppenderRow AppendValue(bool? value);
204	IDuckDBAppenderRow AppendValue(byte[]? value);
205	IDuckDBAppenderRow AppendValue(Span<byte> value);
206	IDuckDBAppenderRow AppendValue(string? value);
207	IDuckDBAppenderRow AppendValue(decimal? value);
208	IDuckDBAppenderRow AppendValue(Guid? value);
209	IDuckDBAppenderRow AppendValue(BigInteger? value);
210	IDuckDBAppenderRow AppendValue(sbyte? value);
211	IDuckDBAppenderRow AppendValue(short? value);
212	IDuckDBAppenderRow AppendValue(int? value);
213	IDuckDBAppenderRow AppendValue(long? value);
214	IDuckDBAppenderRow AppendValue(byte? value);
215	IDuckDBAppenderRow AppendValue(ushort? value);
216	IDuckDBAppenderRow AppendValue(uint? value);
217	IDuckDBAppenderRow AppendValue(ulong? value);
218	IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum;
219	IDuckDBAppenderRow AppendValue(float? value);
220	IDuckDBAppenderRow AppendValue(double? value);
221	IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value);
222	IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value);
223	IDuckDBAppenderRow AppendValue(DateTime? value);
224	IDuckDBAppenderRow AppendValue(DateTimeOffset? value);
225	IDuckDBAppenderRow AppendValue(TimeSpan? value);
226	IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value);
227	IDuckDBAppenderRow AppendDefault();
228	}

Giorgi / DuckDB.NET / 22323392380

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