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

93.94

/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() => AppendValueInternal<int?>(null); //Doesn't matter what type T we pass to Append when passing null.

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

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

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

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

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

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

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

    #region Append Signed Int

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

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

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

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

    #endregion

    #region Append Unsigned Int

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

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

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

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

    #endregion

    #region Append Enum

    public IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum => AppendValueInternal(value);

    #endregion

    #region Append Float

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

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

    #endregion

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

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

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

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


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

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

    public IDuckDBAppenderRow AppendValue(TimeSpan? value)
    {
        return AppendValueInternal(value);
    }

    #endregion

    #region Composite Types

    public IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value) => AppendValueInternal(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 AppendValueInternal<T>(T? value)
    {
        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,	429,990✔
15	ulong rowIndex, DuckDBDataChunk dataChunk, Native.DuckDBAppender nativeAppender)	429,990✔
16	{
17	this.qualifiedTableName = qualifiedTableName;	429,990✔
18	this.vectorWriters = vectorWriters;	429,990✔
19	this.rowIndex = rowIndex;	429,990✔
20	this.dataChunk = dataChunk;	429,990✔
21	this.nativeAppender = nativeAppender;	429,990✔
22	}	429,990✔
23
24	public void EndRow()
25	{
26	if (columnIndex < vectorWriters.Length)	429,972✔
27	{
28	throw new InvalidOperationException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you specified only {columnIndex} values");	3✔
29	}
30	}	429,969✔
31
32	public IDuckDBAppenderRow AppendNullValue() => AppendValueInternal<int?>(null); //Doesn't matter what type T we pass to Append when passing null.	81✔
33
34	public IDuckDBAppenderRow AppendValue(bool? value) => AppendValueInternal(value);	69✔
35
36	public IDuckDBAppenderRow AppendValue(byte[]? value) => AppendSpan(value);	6✔
37
38	public IDuckDBAppenderRow AppendValue(Span<byte> value) => AppendSpan(value);	3✔
39
40	public IDuckDBAppenderRow AppendValue(string? value) => AppendValueInternal(value);	45,120✔
41
42	public IDuckDBAppenderRow AppendValue(decimal? value) => AppendValueInternal(value);	270✔
43
44	public IDuckDBAppenderRow AppendValue(Guid? value) => AppendValueInternal(value);	105,003✔
45
46	public IDuckDBAppenderRow AppendValue(BigInteger? value) => AppendValueInternal(value);	60✔
47
48	#region Append Signed Int
49
50	public IDuckDBAppenderRow AppendValue(sbyte? value) => AppendValueInternal(value);	75,084✔
51
52	public IDuckDBAppenderRow AppendValue(short? value) => AppendValueInternal(value);	60✔
53
54	public IDuckDBAppenderRow AppendValue(int? value) => AppendValueInternal(value);	324,810✔
55
56	public IDuckDBAppenderRow AppendValue(long? value) => AppendValueInternal(value);	60✔
57
58	#endregion
59
60	#region Append Unsigned Int
61
62	public IDuckDBAppenderRow AppendValue(byte? value) => AppendValueInternal(value);	66✔
63
64	public IDuckDBAppenderRow AppendValue(ushort? value) => AppendValueInternal(value);	60✔
65
66	public IDuckDBAppenderRow AppendValue(uint? value) => AppendValueInternal(value);	60✔
67
68	public IDuckDBAppenderRow AppendValue(ulong? value) => AppendValueInternal(value);	60✔
69
70	#endregion
71
72	#region Append Enum
73
74	public IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum => AppendValueInternal(value);	15✔
75
76	#endregion
77
78	#region Append Float
79
80	public IDuckDBAppenderRow AppendValue(float? value) => AppendValueInternal(value);	66✔
81
82	public IDuckDBAppenderRow AppendValue(double? value) => AppendValueInternal(value);	120✔
83
84	#endregion
85
86	#region Append Temporal
UNCOV 87	public IDuckDBAppenderRow AppendValue(DateOnly? value) => AppendValueInternal(value);	×
88
UNCOV 89	public IDuckDBAppenderRow AppendValue(TimeOnly? value) => AppendValueInternal(value);	×
90
91	public IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value) => AppendValueInternal(value);	120✔
92
93	public IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value) => AppendValueInternal(value);	60✔
94
95
96	public IDuckDBAppenderRow AppendValue(DateTime? value) => AppendValueInternal(value);	15,336✔
97
98	public IDuckDBAppenderRow AppendValue(DateTimeOffset? value) => AppendValueInternal(value);	120✔
99
100	public IDuckDBAppenderRow AppendValue(TimeSpan? value)
101	{
102	return AppendValueInternal(value);	60✔
103	}
104
105	#endregion
106
107	#region Composite Types
108
109	public IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value) => AppendValueInternal(value);	498,006✔
110
111	#endregion
112
113	public IDuckDBAppenderRow AppendDefault()
114	{
115	CheckColumnAccess();	75,015✔
116
117	var state = NativeMethods.Appender.DuckDBAppendDefaultToChunk(nativeAppender, dataChunk, columnIndex, rowIndex);	75,015✔
118
119	if (state == DuckDBState.Error)	75,015!
120	{
UNCOV 121	DuckDBAppender.ThrowLastError(nativeAppender);	×
122	}
123
124	columnIndex++;	75,015✔
125	return this;	75,015✔
126	}
127
128	private DuckDBAppenderRow AppendValueInternal<T>(T? value)
129	{
130	CheckColumnAccess();	1,064,766✔
131
132	vectorWriters[columnIndex].WriteValue(value, rowIndex);	1,064,763✔
133
134	columnIndex++;	1,064,748✔
135
136	return this;	1,064,748✔
137	}
138
139	private unsafe IDuckDBAppenderRow AppendSpan(Span<byte> val)
140	{
141	if (val == null)	9✔
142	{
143	return AppendNullValue();	3✔
144	}
145
146	CheckColumnAccess();	6✔
147
148	fixed (byte* pSource = val)	6✔
149	{
150	vectorWriters[columnIndex].AppendBlob(pSource, val.Length, rowIndex);	6✔
151	}
152
153	columnIndex++;	6✔
154	return this;	6✔
155	}
156
157	private void CheckColumnAccess()
158	{
159	if (columnIndex >= vectorWriters.Length)	1,139,787✔
160	{
161	throw new IndexOutOfRangeException($"The table {qualifiedTableName} has {vectorWriters.Length} columns but you are trying to append value for column {columnIndex + 1}");	3✔
162	}
163	}	1,139,784✔
164	}
165
166	public interface IDuckDBAppenderRow
167	{
168	void EndRow();
169	IDuckDBAppenderRow AppendNullValue();
170	IDuckDBAppenderRow AppendValue(bool? value);
171	IDuckDBAppenderRow AppendValue(byte[]? value);
172	IDuckDBAppenderRow AppendValue(Span<byte> value);
173	IDuckDBAppenderRow AppendValue(string? value);
174	IDuckDBAppenderRow AppendValue(decimal? value);
175	IDuckDBAppenderRow AppendValue(Guid? value);
176	IDuckDBAppenderRow AppendValue(BigInteger? value);
177	IDuckDBAppenderRow AppendValue(sbyte? value);
178	IDuckDBAppenderRow AppendValue(short? value);
179	IDuckDBAppenderRow AppendValue(int? value);
180	IDuckDBAppenderRow AppendValue(long? value);
181	IDuckDBAppenderRow AppendValue(byte? value);
182	IDuckDBAppenderRow AppendValue(ushort? value);
183	IDuckDBAppenderRow AppendValue(uint? value);
184	IDuckDBAppenderRow AppendValue(ulong? value);
185	IDuckDBAppenderRow AppendValue<TEnum>(TEnum? value) where TEnum : Enum;
186	IDuckDBAppenderRow AppendValue(float? value);
187	IDuckDBAppenderRow AppendValue(double? value);
188	IDuckDBAppenderRow AppendValue(DuckDBDateOnly? value);
189	IDuckDBAppenderRow AppendValue(DuckDBTimeOnly? value);
190	IDuckDBAppenderRow AppendValue(DateTime? value);
191	IDuckDBAppenderRow AppendValue(DateTimeOffset? value);
192	IDuckDBAppenderRow AppendValue(TimeSpan? value);
193	IDuckDBAppenderRow AppendValue<T>(IEnumerable<T>? value);
194	IDuckDBAppenderRow AppendDefault();
195	}

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