• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

Giorgi / DuckDB.NET / 21786443631

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

push

github

Giorgi
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.

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
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
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc