21786443631

Committed 07 Feb 2026 08:33PM UTC coverage: 89.223% (-0.2%) from 89.45%

Build # 21786443631

Build Type

push

github

Committed by

Giorgi

Commit Message

Drop netstandard2.0 and net6.0 target frameworks

Update target frameworks to net8.0 and net10.0,
remove all conditional compilation directives for
NET5_0_OR_GREATER, NET6_0_OR_GREATER, and
NET8_0_OR_GREATER. Delete polyfills and shims that
were only needed for older frameworks. Remove
[Experimental] attributes from scalar/table function
APIs.

Run Details

1197 of 1389 branches covered (86.18%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 8 files covered. (100.0%)

14 existing lines in 8 files now uncovered.

2330 of 2564 relevant lines covered (90.87%)

557293.59 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 System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;
using DuckDB.NET.Data.Common;
using DuckDB.NET.Native;

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 System;
2	using System.Collections;
3	using System.Collections.Generic;
4	using System.Numerics;
5	using DuckDB.NET.Data.Common;
6	using DuckDB.NET.Native;
7
8	namespace DuckDB.NET.Data.DataChunk.Writer;
9
10	internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
11	{
12	private ulong offset = 0;
13	private readonly ulong arraySize;
14	private readonly DuckDBLogicalType childType;
15	private readonly VectorDataWriterBase listItemWriter;
16
17	private bool IsList => ColumnType == DuckDBType.List;	3,124,014✔
18	private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;	360✔
19
20	public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)	360✔
21	{
22	childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);	360✔
23	var childVector = IsList ? NativeMethods.Vectors.DuckDBListVectorGetChild(vector) : NativeMethods.Vectors.DuckDBArrayVectorGetChild(vector);	360✔
24
25	arraySize = IsList ? 0 : (ulong)NativeMethods.LogicalType.DuckDBArrayVectorGetSize(logicalType);	360✔
26	listItemWriter = VectorDataWriterFactory.CreateWriter(childVector, childType);	360✔
27	}	360✔
28
29	internal override bool AppendCollection(ICollection value, ulong rowIndex)
30	{
31	var count = (ulong)value.Count;	1,040,980✔
32
33	ResizeVector(rowIndex % DuckDBGlobalData.VectorSize, count);	1,040,980✔
34
35	_ = value switch	1,040,980!
36	{	1,040,980✔
37	IEnumerable<bool> items => WriteItems(items),	22,257✔
38	IEnumerable<bool?> items => WriteItems(items),	21,930✔
39		1,040,980✔
40	IEnumerable<sbyte> items => WriteItems(items),	21,894✔
41	IEnumerable<sbyte?> items => WriteItems(items),	22,147✔
42	IEnumerable<short> items => WriteItems(items),	21,932✔
43	IEnumerable<short?> items => WriteItems(items),	21,840✔
44	IEnumerable<int> items => WriteItems(items),	43,975✔
45	IEnumerable<int?> items => WriteItems(items),	22,061✔
46	IEnumerable<long> items => WriteItems(items),	22,191✔
47	IEnumerable<long?> items => WriteItems(items),	21,792✔
48	IEnumerable<byte> items => WriteItems(items),	22,054✔
49	IEnumerable<byte?> items => WriteItems(items),	21,807✔
50	IEnumerable<ushort> items => WriteItems(items),	21,948✔
51	IEnumerable<ushort?> items => WriteItems(items),	22,225✔
52	IEnumerable<uint> items => WriteItems(items),	22,061✔
53	IEnumerable<uint?> items => WriteItems(items),	21,906✔
54	IEnumerable<ulong> items => WriteItems(items),	21,787✔
55	IEnumerable<ulong?> items => WriteItems(items),	21,847✔
56		1,040,980✔
57	IEnumerable<float> items => WriteItems(items),	22,061✔
58	IEnumerable<float?> items => WriteItems(items),	22,061✔
59	IEnumerable<double> items => WriteItems(items),	21,822✔
60	IEnumerable<double?> items => WriteItems(items),	21,996✔
61		1,040,980✔
62	IEnumerable<decimal> items => WriteItems(items),	51,909✔
63	IEnumerable<decimal?> items => WriteItems(items),	21,697✔
64	IEnumerable<BigInteger> items => WriteItems(items),	44,095✔
65	IEnumerable<BigInteger?> items => WriteItems(items),	×
66		1,040,980✔
67	IEnumerable<string> items => WriteItems(items),	73,790✔
68	IEnumerable<Guid> items => WriteItems(items),	52,164✔
69	IEnumerable<Guid?> items => WriteItems(items),	21,863✔
70	IEnumerable<DateTime> items => WriteItems(items),	21,987✔
71	IEnumerable<DateTime?> items => WriteItems(items),	×
72	IEnumerable<TimeSpan> items => WriteItems(items),	22,062✔
73	IEnumerable<TimeSpan?> items => WriteItems(items),	×
74	IEnumerable<DuckDBDateOnly> items => WriteItems(items),	×
75	IEnumerable<DuckDBDateOnly?> items => WriteItems(items),	×
76	IEnumerable<DuckDBTimeOnly> items => WriteItems(items),	×
77	IEnumerable<DuckDBTimeOnly?> items => WriteItems(items),	×
UNCOV 78	IEnumerable<DateOnly> items => WriteItems(items),	×
79	IEnumerable<DateOnly?> items => WriteItems(items),	×
80	IEnumerable<TimeOnly> items => WriteItems(items),	×
81	IEnumerable<TimeOnly?> items => WriteItems(items),	×
UNCOV 82	IEnumerable<DateTimeOffset> items => WriteItems(items),	×
83	IEnumerable<DateTimeOffset?> items => WriteItems(items),	×
84	IEnumerable<object> items => WriteItems(items),	204,000✔
85		1,040,980✔
86	_ => WriteItemsFallback(value),	21,819✔
87	};	1,040,980✔
88
89	var duckDBListEntry = new DuckDBListEntry(offset, count);	1,040,974✔
90	var result = !IsList \|\| AppendValueInternal(duckDBListEntry, rowIndex);	1,040,974✔
91
92	offset += count;	1,040,974✔
93
94	return result;	1,040,974✔
95
96	int WriteItems<T>(IEnumerable<T> items)
97	{
98	if (IsList == false && count != arraySize)	1,019,161✔
99	{
100	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	6✔
101	}
102
103	var index = 0ul;	1,019,155✔
104
105	foreach (var item in items)	51,753,832✔
106	{
107	listItemWriter.WriteValue(item, offset + (index++));	24,857,761✔
108	}
109
110	return 0;	1,019,155✔
111	}
112
113	int WriteItemsFallback(IEnumerable items)
114	{
115	if (IsList == false && count != arraySize)	21,819!
116	{
117	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	×
118	}
119
120	var index = 0ul;	21,819✔
121
122	foreach (var item in items)	1,529,680✔
123	{
124	listItemWriter.WriteValue(item, offset + (index++));	743,021✔
125	}
126
127	return 0;	21,819✔
128	}
129	}
130
131	private void ResizeVector(ulong rowIndex, ulong count)
132	{
133	//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.
134	if (!IsList \|\| offset + count <= vectorReservedSize) return;	2,080,271✔
135
136	var factor = 2d;	1,689✔
137
138	if (rowIndex > DuckDBGlobalData.VectorSize * 0.25 && rowIndex < DuckDBGlobalData.VectorSize * 0.5)	1,689✔
139	{
140	factor = 1.75;	318✔
141	}
142
143	if (rowIndex > DuckDBGlobalData.VectorSize * 0.5 && rowIndex < DuckDBGlobalData.VectorSize * 0.75)	1,689✔
144	{
145	factor = 1.5;	291✔
146	}
147
148	if (rowIndex > DuckDBGlobalData.VectorSize * 0.75)	1,689✔
149	{
150	factor = 1.25;	147✔
151	}
152
153	vectorReservedSize = (ulong)Math.Max(vectorReservedSize * factor, offset + count);	1,689✔
154	var state = NativeMethods.Vectors.DuckDBListVectorReserve(Vector, vectorReservedSize);	1,689✔
155
156	if (!state.IsSuccess())	1,689!
157	{
158	throw new DuckDBException($"Failed to reserve {vectorReservedSize} for the list vector");	×
159	}
160
161	listItemWriter.InitializeWriter();	1,689✔
162	}	1,689✔
163
164	public override void Dispose()
165	{
166	listItemWriter.Dispose();	351✔
167	childType.Dispose();	351✔
168	}	351✔
169	}

Giorgi / DuckDB.NET / 21786443631

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