20383681089

Committed 19 Dec 2025 10:02PM UTC coverage: 89.294% (+0.03%) from 89.262%

Build # 20383681089

Build Type

push

github

Committed by

Giorgi

Commit Message

Drop .Net Standard support

Run Details

1183 of 1379 branches covered (85.79%)

Branch coverage included in aggregate %.

19 of 22 new or added lines in 13 files covered. (86.36%)

16 existing lines in 9 files now uncovered.

2295 of 2516 relevant lines covered (91.22%)

567948.85 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,117,741✔
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,038,889✔
32
33	ResizeVector(rowIndex % DuckDBGlobalData.VectorSize, count);	1,038,889✔
34
35	_ = value switch	1,038,889!
36	{	1,038,889✔
37	IEnumerable<bool> items => WriteItems(items),	22,076✔
38	IEnumerable<bool?> items => WriteItems(items),	22,263✔
39		1,038,889✔
40	IEnumerable<sbyte> items => WriteItems(items),	21,950✔
41	IEnumerable<sbyte?> items => WriteItems(items),	22,072✔
42	IEnumerable<short> items => WriteItems(items),	21,833✔
43	IEnumerable<short?> items => WriteItems(items),	21,825✔
44	IEnumerable<int> items => WriteItems(items),	43,374✔
45	IEnumerable<int?> items => WriteItems(items),	22,007✔
46	IEnumerable<long> items => WriteItems(items),	21,853✔
47	IEnumerable<long?> items => WriteItems(items),	21,838✔
48	IEnumerable<byte> items => WriteItems(items),	21,893✔
49	IEnumerable<byte?> items => WriteItems(items),	21,849✔
50	IEnumerable<ushort> items => WriteItems(items),	21,894✔
51	IEnumerable<ushort?> items => WriteItems(items),	21,807✔
52	IEnumerable<uint> items => WriteItems(items),	21,924✔
53	IEnumerable<uint?> items => WriteItems(items),	21,940✔
54	IEnumerable<ulong> items => WriteItems(items),	21,888✔
55	IEnumerable<ulong?> items => WriteItems(items),	21,812✔
56		1,038,889✔
57	IEnumerable<float> items => WriteItems(items),	22,186✔
58	IEnumerable<float?> items => WriteItems(items),	22,012✔
59	IEnumerable<double> items => WriteItems(items),	21,806✔
60	IEnumerable<double?> items => WriteItems(items),	21,929✔
61		1,038,889✔
62	IEnumerable<decimal> items => WriteItems(items),	51,820✔
63	IEnumerable<decimal?> items => WriteItems(items),	21,869✔
64	IEnumerable<BigInteger> items => WriteItems(items),	43,877✔
65	IEnumerable<BigInteger?> items => WriteItems(items),	×
66		1,038,889✔
67	IEnumerable<string> items => WriteItems(items),	73,803✔
68	IEnumerable<Guid> items => WriteItems(items),	51,787✔
69	IEnumerable<Guid?> items => WriteItems(items),	21,854✔
70	IEnumerable<DateTime> items => WriteItems(items),	22,052✔
71	IEnumerable<DateTime?> items => WriteItems(items),	×
72	IEnumerable<TimeSpan> items => WriteItems(items),	21,761✔
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,038,889✔
86	_ => WriteItemsFallback(value),	22,035✔
87	};	1,038,889✔
88
89	var duckDBListEntry = new DuckDBListEntry(offset, count);	1,038,883✔
90	var result = !IsList \|\| AppendValueInternal(duckDBListEntry, rowIndex);	1,038,883✔
91
92	offset += count;	1,038,883✔
93
94	return result;	1,038,883✔
95
96	int WriteItems<T>(IEnumerable<T> items)
97	{
98	if (IsList == false && count != arraySize)	1,016,854✔
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,016,848✔
104
105	foreach (var item in items)	51,723,020✔
106	{
107	listItemWriter.WriteValue(item, offset + (index++));	24,844,662✔
108	}
109
110	return 0;	1,016,848✔
111	}
112
113	int WriteItemsFallback(IEnumerable items)
114	{
115	if (IsList == false && count != arraySize)	22,035!
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;	22,035✔
121
122	foreach (var item in items)	1,537,198✔
123	{
124	listItemWriter.WriteValue(item, offset + (index++));	746,564✔
125	}
126
127	return 0;	22,035✔
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,076,102✔
135
136	var factor = 2d;	1,676✔
137
138	if (rowIndex > DuckDBGlobalData.VectorSize * 0.25 && rowIndex < DuckDBGlobalData.VectorSize * 0.5)	1,676✔
139	{
140	factor = 1.75;	310✔
141	}
142
143	if (rowIndex > DuckDBGlobalData.VectorSize * 0.5 && rowIndex < DuckDBGlobalData.VectorSize * 0.75)	1,676✔
144	{
145	factor = 1.5;	296✔
146	}
147
148	if (rowIndex > DuckDBGlobalData.VectorSize * 0.75)	1,676✔
149	{
150	factor = 1.25;	129✔
151	}
152
153	vectorReservedSize = (ulong)Math.Max(vectorReservedSize * factor, offset + count);	1,676✔
154	var state = NativeMethods.Vectors.DuckDBListVectorReserve(Vector, vectorReservedSize);	1,676✔
155
156	if (!state.IsSuccess())	1,676!
157	{
158	throw new DuckDBException($"Failed to reserve {vectorReservedSize} for the list vector");	×
159	}
160
161	listItemWriter.InitializeWriter();	1,676✔
162	}	1,676✔
163
164	public override void Dispose()
165	{
166	listItemWriter.Dispose();	351✔
167	childType.Dispose();	351✔
168	}	351✔
169	}

Giorgi / DuckDB.NET / 20383681089

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