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

85.91

/DuckDB.NET.Data/DataChunk/Writer/ListVectorDataWriter.cs

﻿using DuckDB.NET.Data.Common;

namespace DuckDB.NET.Data.DataChunk.Writer;

internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
{
    private ulong offset = 0;
    private readonly ulong arraySize;
    private readonly DuckDBLogicalType childType;
    private readonly VectorDataWriterBase listItemWriter;

    private bool IsList => ColumnType == DuckDBType.List;
    private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;

    public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)
    {
        childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);
        var childVector = IsList ? NativeMethods.Vectors.DuckDBListVectorGetChild(vector) : NativeMethods.Vectors.DuckDBArrayVectorGetChild(vector);

        arraySize = IsList ? 0 : (ulong)NativeMethods.LogicalType.DuckDBArrayVectorGetSize(logicalType);
        listItemWriter = VectorDataWriterFactory.CreateWriter(childVector, childType);
    }

    internal override bool AppendCollection(ICollection value, ulong rowIndex)
    {
        var count = (ulong)value.Count;

        ResizeVector(rowIndex % DuckDBGlobalData.VectorSize, count);

        _ = value switch
        {
            IEnumerable<bool> items => WriteItems(items),
            IEnumerable<bool?> items => WriteItems(items),

            IEnumerable<sbyte> items => WriteItems(items),
            IEnumerable<sbyte?> items => WriteItems(items),
            IEnumerable<short> items => WriteItems(items),
            IEnumerable<short?> items => WriteItems(items),
            IEnumerable<int> items => WriteItems(items),
            IEnumerable<int?> items => WriteItems(items),
            IEnumerable<long> items => WriteItems(items),
            IEnumerable<long?> items => WriteItems(items),
            IEnumerable<byte> items => WriteItems(items),
            IEnumerable<byte?> items => WriteItems(items),
            IEnumerable<ushort> items => WriteItems(items),
            IEnumerable<ushort?> items => WriteItems(items),
            IEnumerable<uint> items => WriteItems(items),
            IEnumerable<uint?> items => WriteItems(items),
            IEnumerable<ulong> items => WriteItems(items),
            IEnumerable<ulong?> items => WriteItems(items),

            IEnumerable<float> items => WriteItems(items),
            IEnumerable<float?> items => WriteItems(items),
            IEnumerable<double> items => WriteItems(items),
            IEnumerable<double?> items => WriteItems(items),

            IEnumerable<decimal> items => WriteItems(items),
            IEnumerable<decimal?> items => WriteItems(items),
            IEnumerable<BigInteger> items => WriteItems(items),
            IEnumerable<BigInteger?> items => WriteItems(items),

            IEnumerable<string> items => WriteItems(items),
            IEnumerable<Guid> items => WriteItems(items),
            IEnumerable<Guid?> items => WriteItems(items),
            IEnumerable<DateTime> items => WriteItems(items),
            IEnumerable<DateTime?> items => WriteItems(items),
            IEnumerable<TimeSpan> items => WriteItems(items),
            IEnumerable<TimeSpan?> items => WriteItems(items),
            IEnumerable<DuckDBDateOnly> items => WriteItems(items),
            IEnumerable<DuckDBDateOnly?> items => WriteItems(items),
            IEnumerable<DuckDBTimeOnly> items => WriteItems(items),
            IEnumerable<DuckDBTimeOnly?> items => WriteItems(items),
            IEnumerable<DateOnly> items => WriteItems(items),
            IEnumerable<DateOnly?> items => WriteItems(items),
            IEnumerable<TimeOnly> items => WriteItems(items),
            IEnumerable<TimeOnly?> items => WriteItems(items),
            IEnumerable<DateTimeOffset> items => WriteItems(items),
            IEnumerable<DateTimeOffset?> items => WriteItems(items),
            IEnumerable<object> items => WriteItems(items),

            _ => WriteItemsFallback(value),
        };

        var duckDBListEntry = new DuckDBListEntry(offset, count);
        var result = !IsList || AppendValueInternal(duckDBListEntry, rowIndex);

        offset += count;

        return result;

        int WriteItems<T>(IEnumerable<T> items)
        {
            if (IsList == false && count != arraySize)
            {
                throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");
            }

            var index = 0ul;

            foreach (var item in items)
            {
                listItemWriter.WriteValue(item, offset + (index++));
            }

            return 0;
        }

        int WriteItemsFallback(IEnumerable items)
        {
            if (IsList == false && count != arraySize)
            {
                throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");
            }

            var index = 0ul;

            foreach (var item in items)
            {
                listItemWriter.WriteValue(item, offset + (index++));
            }

            return 0;
        }
    }

    private void ResizeVector(ulong rowIndex, ulong count)
    {
        //If writing to a list column we need to make sure that enough space is allocated. Not needed for Arrays as DuckDB does it for us.
        if (!IsList || offset + count <= vectorReservedSize) return;

        var factor = 2d;

        if (rowIndex > DuckDBGlobalData.VectorSize * 0.25 && rowIndex < DuckDBGlobalData.VectorSize * 0.5)
        {
            factor = 1.75;
        }

        if (rowIndex > DuckDBGlobalData.VectorSize * 0.5 && rowIndex < DuckDBGlobalData.VectorSize * 0.75)
        {
            factor = 1.5;
        }

        if (rowIndex > DuckDBGlobalData.VectorSize * 0.75)
        {
            factor = 1.25;
        }

        vectorReservedSize = (ulong)Math.Max(vectorReservedSize * factor, offset + count);
        var state = NativeMethods.Vectors.DuckDBListVectorReserve(Vector, vectorReservedSize);

        if (!state.IsSuccess())
        {
            throw new DuckDBException($"Failed to reserve {vectorReservedSize} for the list vector");
        }

        listItemWriter.InitializeWriter();
    }

    public override void Dispose()
    {
        listItemWriter.Dispose();
        childType.Dispose();
    }
}

1	using DuckDB.NET.Data.Common;
2
3	namespace DuckDB.NET.Data.DataChunk.Writer;
4
5	internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
6	{
7	private ulong offset = 0;
8	private readonly ulong arraySize;
9	private readonly DuckDBLogicalType childType;
10	private readonly VectorDataWriterBase listItemWriter;
11
12	private bool IsList => ColumnType == DuckDBType.List;	3,121,515✔
13	private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;	360✔
14
15	public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)	360✔
16	{
17	childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);	360✔
18	var childVector = IsList ? NativeMethods.Vectors.DuckDBListVectorGetChild(vector) : NativeMethods.Vectors.DuckDBArrayVectorGetChild(vector);	360✔
19
20	arraySize = IsList ? 0 : (ulong)NativeMethods.LogicalType.DuckDBArrayVectorGetSize(logicalType);	360✔
21	listItemWriter = VectorDataWriterFactory.CreateWriter(childVector, childType);	360✔
22	}	360✔
23
24	internal override bool AppendCollection(ICollection value, ulong rowIndex)
25	{
26	var count = (ulong)value.Count;	1,040,147✔
27
28	ResizeVector(rowIndex % DuckDBGlobalData.VectorSize, count);	1,040,147✔
29
30	_ = value switch	1,040,147!
31	{	1,040,147✔
32	IEnumerable<bool> items => WriteItems(items),	21,895✔
33	IEnumerable<bool?> items => WriteItems(items),	21,905✔
34		1,040,147✔
35	IEnumerable<sbyte> items => WriteItems(items),	21,951✔
36	IEnumerable<sbyte?> items => WriteItems(items),	21,913✔
37	IEnumerable<short> items => WriteItems(items),	21,880✔
38	IEnumerable<short?> items => WriteItems(items),	22,164✔
39	IEnumerable<int> items => WriteItems(items),	44,076✔
40	IEnumerable<int?> items => WriteItems(items),	21,808✔
41	IEnumerable<long> items => WriteItems(items),	21,847✔
42	IEnumerable<long?> items => WriteItems(items),	21,993✔
43	IEnumerable<byte> items => WriteItems(items),	21,884✔
44	IEnumerable<byte?> items => WriteItems(items),	21,893✔
45	IEnumerable<ushort> items => WriteItems(items),	22,105✔
46	IEnumerable<ushort?> items => WriteItems(items),	21,841✔
47	IEnumerable<uint> items => WriteItems(items),	22,013✔
48	IEnumerable<uint?> items => WriteItems(items),	22,010✔
49	IEnumerable<ulong> items => WriteItems(items),	21,967✔
50	IEnumerable<ulong?> items => WriteItems(items),	21,978✔
51		1,040,147✔
52	IEnumerable<float> items => WriteItems(items),	21,981✔
53	IEnumerable<float?> items => WriteItems(items),	22,123✔
54	IEnumerable<double> items => WriteItems(items),	21,969✔
55	IEnumerable<double?> items => WriteItems(items),	21,920✔
56		1,040,147✔
57	IEnumerable<decimal> items => WriteItems(items),	51,838✔
58	IEnumerable<decimal?> items => WriteItems(items),	21,865✔
59	IEnumerable<BigInteger> items => WriteItems(items),	43,873✔
UNCOV 60	IEnumerable<BigInteger?> items => WriteItems(items),	×
61		1,040,147✔
62	IEnumerable<string> items => WriteItems(items),	73,883✔
63	IEnumerable<Guid> items => WriteItems(items),	51,910✔
64	IEnumerable<Guid?> items => WriteItems(items),	21,900✔
65	IEnumerable<DateTime> items => WriteItems(items),	21,972✔
UNCOV 66	IEnumerable<DateTime?> items => WriteItems(items),	×
67	IEnumerable<TimeSpan> items => WriteItems(items),	21,945✔
UNCOV 68	IEnumerable<TimeSpan?> items => WriteItems(items),	×
UNCOV 69	IEnumerable<DuckDBDateOnly> items => WriteItems(items),	×
UNCOV 70	IEnumerable<DuckDBDateOnly?> items => WriteItems(items),	×
71	IEnumerable<DuckDBTimeOnly> items => WriteItems(items),	×
UNCOV 72	IEnumerable<DuckDBTimeOnly?> items => WriteItems(items),	×
73	IEnumerable<DateOnly> items => WriteItems(items),	×
74	IEnumerable<DateOnly?> items => WriteItems(items),	×
75	IEnumerable<TimeOnly> items => WriteItems(items),	×
76	IEnumerable<TimeOnly?> items => WriteItems(items),	×
77	IEnumerable<DateTimeOffset> items => WriteItems(items),	×
78	IEnumerable<DateTimeOffset?> items => WriteItems(items),	×
79	IEnumerable<object> items => WriteItems(items),	204,000✔
80		1,040,147✔
81	_ => WriteItemsFallback(value),	21,845✔
82	};	1,040,147✔
83
84	var duckDBListEntry = new DuckDBListEntry(offset, count);	1,040,141✔
85	var result = !IsList \|\| AppendValueInternal(duckDBListEntry, rowIndex);	1,040,141✔
86
87	offset += count;	1,040,141✔
88
89	return result;	1,040,141✔
90
91	int WriteItems<T>(IEnumerable<T> items)
92	{
93	if (IsList == false && count != arraySize)	1,018,302✔
94	{
95	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	6✔
96	}
97
98	var index = 0ul;	1,018,296✔
99
100	foreach (var item in items)	51,722,414✔
101	{
102	listItemWriter.WriteValue(item, offset + (index++));	24,842,911✔
103	}
104
105	return 0;	1,018,296✔
106	}
107
108	int WriteItemsFallback(IEnumerable items)
109	{
110	if (IsList == false && count != arraySize)	21,845!
111	{
UNCOV 112	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	×
113	}
114
115	var index = 0ul;	21,845✔
116
117	foreach (var item in items)	1,548,190✔
118	{
119	listItemWriter.WriteValue(item, offset + (index++));	752,250✔
120	}
121
122	return 0;	21,845✔
123	}
124	}
125
126	private void ResizeVector(ulong rowIndex, ulong count)
127	{
128	//If writing to a list column we need to make sure that enough space is allocated. Not needed for Arrays as DuckDB does it for us.
129	if (!IsList \|\| offset + count <= vectorReservedSize) return;	2,078,608✔
130
131	var factor = 2d;	1,686✔
132
133	if (rowIndex > DuckDBGlobalData.VectorSize * 0.25 && rowIndex < DuckDBGlobalData.VectorSize * 0.5)	1,686✔
134	{
135	factor = 1.75;	325✔
136	}
137
138	if (rowIndex > DuckDBGlobalData.VectorSize * 0.5 && rowIndex < DuckDBGlobalData.VectorSize * 0.75)	1,686✔
139	{
140	factor = 1.5;	287✔
141	}
142
143	if (rowIndex > DuckDBGlobalData.VectorSize * 0.75)	1,686✔
144	{
145	factor = 1.25;	148✔
146	}
147
148	vectorReservedSize = (ulong)Math.Max(vectorReservedSize * factor, offset + count);	1,686✔
149	var state = NativeMethods.Vectors.DuckDBListVectorReserve(Vector, vectorReservedSize);	1,686✔
150
151	if (!state.IsSuccess())	1,686!
152	{
UNCOV 153	throw new DuckDBException($"Failed to reserve {vectorReservedSize} for the list vector");	×
154	}
155
156	listItemWriter.InitializeWriter();	1,686✔
157	}	1,686✔
158
159	public override void Dispose()
160	{
161	listItemWriter.Dispose();	351✔
162	childType.Dispose();	351✔
163	}	351✔
164	}

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