10460156994

Committed 19 Aug 2024 08:05PM UTC coverage: 89.935% (-0.3%) from 90.251%

Build # 10460156994

Build Type

push

github

Committed by

Giorgi

Commit Message

Check for null

Run Details

878 of 1006 branches covered (87.28%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

18 existing lines in 4 files now uncovered.

1767 of 1935 relevant lines covered (91.32%)

819430.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.04

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

﻿using DuckDB.NET.Native;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;

namespace DuckDB.NET.Data.Internal.Writer;

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

    public 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, int rowIndex)
    {
        var count = (ulong)value.Count;

        ResizeVector(rowIndex % (int)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),
#if NET6_0_OR_GREATER
            IEnumerable<DateOnly> items => WriteItems(items),
            IEnumerable<DateOnly?> items => WriteItems(items),
            IEnumerable<TimeOnly> items => WriteItems(items),
            IEnumerable<TimeOnly?> items => WriteItems(items),
#endif
            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 = 0;

            foreach (var item in items)
            {
                listItemWriter.AppendValue(item, (int)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 = 0;

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

            return 0;
        }
    }

    private void ResizeVector(int 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.InitializerWriter();
    }

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

1	using DuckDB.NET.Native;
2	using System;
3	using System.Collections;
4	using System.Collections.Generic;
5	using System.Numerics;
6
7	namespace DuckDB.NET.Data.Internal.Writer;
8
9	internal sealed unsafe class ListVectorDataWriter : VectorDataWriterBase
10	{
11	private ulong offset = 0;
12	private readonly ulong arraySize;
13	private readonly DuckDBLogicalType childType;
14	private readonly VectorDataWriterBase listItemWriter;
15
16	public bool IsList => ColumnType == DuckDBType.List;	2,852,244✔
17	private ulong vectorReservedSize = DuckDBGlobalData.VectorSize;	315✔
18
19	public ListVectorDataWriter(IntPtr vector, void* vectorData, DuckDBType columnType, DuckDBLogicalType logicalType) : base(vector, vectorData, columnType)	315✔
20	{
21	childType = IsList ? NativeMethods.LogicalType.DuckDBListTypeChildType(logicalType) : NativeMethods.LogicalType.DuckDBArrayTypeChildType(logicalType);	315✔
22	var childVector = IsList ? NativeMethods.Vectors.DuckDBListVectorGetChild(vector) : NativeMethods.Vectors.DuckDBArrayVectorGetChild(vector);	315✔
23
24	arraySize = IsList ? 0 : (ulong)NativeMethods.LogicalType.DuckDBArrayVectorGetSize(logicalType);	315✔
25	listItemWriter = VectorDataWriterFactory.CreateWriter(childVector, childType);	315✔
26	}	315✔
27
28	internal override bool AppendCollection(ICollection value, int rowIndex)
29	{
30	var count = (ulong)value.Count;	950,435✔
31
32	ResizeVector(rowIndex % (int)DuckDBGlobalData.VectorSize, count);	950,435✔
33
34	_ = value switch	950,435!
35	{	950,435✔
36	IEnumerable<bool> items => WriteItems(items),	22,065✔
37	IEnumerable<bool?> items => WriteItems(items),	21,954✔
38		950,435✔
39	IEnumerable<sbyte> items => WriteItems(items),	21,920✔
40	IEnumerable<sbyte?> items => WriteItems(items),	22,133✔
41	IEnumerable<short> items => WriteItems(items),	21,794✔
42	IEnumerable<short?> items => WriteItems(items),	21,927✔
43	IEnumerable<int> items => WriteItems(items),	43,859✔
44	IEnumerable<int?> items => WriteItems(items),	22,016✔
45	IEnumerable<long> items => WriteItems(items),	22,211✔
46	IEnumerable<long?> items => WriteItems(items),	21,867✔
47	IEnumerable<byte> items => WriteItems(items),	22,058✔
48	IEnumerable<byte?> items => WriteItems(items),	22,042✔
49	IEnumerable<ushort> items => WriteItems(items),	21,972✔
50	IEnumerable<ushort?> items => WriteItems(items),	21,905✔
51	IEnumerable<uint> items => WriteItems(items),	22,075✔
52	IEnumerable<uint?> items => WriteItems(items),	22,175✔
53	IEnumerable<ulong> items => WriteItems(items),	21,867✔
54	IEnumerable<ulong?> items => WriteItems(items),	21,780✔
55		950,435✔
56	IEnumerable<float> items => WriteItems(items),	22,029✔
57	IEnumerable<float?> items => WriteItems(items),	21,903✔
58	IEnumerable<double> items => WriteItems(items),	21,937✔
59	IEnumerable<double?> items => WriteItems(items),	22,035✔
60		950,435✔
61	IEnumerable<decimal> items => WriteItems(items),	21,869✔
62	IEnumerable<decimal?> items => WriteItems(items),	22,004✔
63	IEnumerable<BigInteger> items => WriteItems(items),	43,853✔
UNCOV 64	IEnumerable<BigInteger?> items => WriteItems(items),	×
65		950,435✔
66	IEnumerable<string> items => WriteItems(items),	43,958✔
67	IEnumerable<Guid> items => WriteItems(items),	21,918✔
68	IEnumerable<Guid?> items => WriteItems(items),	21,779✔
69	IEnumerable<DateTime> items => WriteItems(items),	21,826✔
UNCOV 70	IEnumerable<DateTime?> items => WriteItems(items),	×
71	IEnumerable<TimeSpan> items => WriteItems(items),	21,932✔
72	IEnumerable<TimeSpan?> items => WriteItems(items),	×
73	IEnumerable<DuckDBDateOnly> items => WriteItems(items),	×
74	IEnumerable<DuckDBDateOnly?> items => WriteItems(items),	×
75	IEnumerable<DuckDBTimeOnly> items => WriteItems(items),	×
UNCOV 76	IEnumerable<DuckDBTimeOnly?> items => WriteItems(items),	×
77	#if NET6_0_OR_GREATER	950,435✔
78	IEnumerable<DateOnly> items => WriteItems(items),	×
79	IEnumerable<DateOnly?> items => WriteItems(items),	×
80	IEnumerable<TimeOnly> items => WriteItems(items),	×
UNCOV 81	IEnumerable<TimeOnly?> items => WriteItems(items),	×
82	#endif	950,435✔
83	IEnumerable<DateTimeOffset> items => WriteItems(items),	×
UNCOV 84	IEnumerable<DateTimeOffset?> items => WriteItems(items),	×
85	IEnumerable<object> items => WriteItems(items),	204,000✔
86		950,435✔
87	_ => WriteItemsFallback(value),	21,772✔
88	};	950,435✔
89
90	var duckDBListEntry = new DuckDBListEntry(offset, count);	950,429✔
91	var result = !IsList \|\| AppendValueInternal(duckDBListEntry, rowIndex);	950,429✔
92
93	offset += count;	950,429✔
94
95	return result;	950,429✔
96
97	int WriteItems<T>(IEnumerable<T> items)
98	{
99	if (IsList == false && count != arraySize)	928,663✔
100	{
101	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	6✔
102	}
103
104	var index = 0;	928,657✔
105
106	foreach (var item in items)	51,257,940✔
107	{
108	listItemWriter.AppendValue(item, (int)offset + (index++));	24,700,313✔
109	}
110
111	return 0;	928,657✔
112	}
113
114	int WriteItemsFallback(IEnumerable items)
115	{
116	if (IsList == false && count != arraySize)	21,772!
117	{
UNCOV 118	throw new InvalidOperationException($"Column has Array size of {arraySize} but the specified value has size of {count}");	×
119	}
120
121	var index = 0;	21,772✔
122
123	foreach (var item in items)	1,538,054✔
124	{
125	listItemWriter.AppendValue(item, (int)offset + (index++));	747,255✔
126	}
127
128	return 0;	21,772✔
129	}
130	}
131
132	private void ResizeVector(int rowIndex, ulong count)
133	{
134	//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.
135	if (!IsList \|\| offset + count <= vectorReservedSize) return;	1,899,229✔
136
137	var factor = 2d;	1,641✔
138
139	if (rowIndex > DuckDBGlobalData.VectorSize * 0.25 && rowIndex < DuckDBGlobalData.VectorSize * 0.5)	1,641✔
140	{
141	factor = 1.75;	315✔
142	}
143
144	if (rowIndex > DuckDBGlobalData.VectorSize * 0.5 && rowIndex < DuckDBGlobalData.VectorSize * 0.75)	1,641✔
145	{
146	factor = 1.5;	292✔
147	}
148
149	if (rowIndex > DuckDBGlobalData.VectorSize * 0.75)	1,641✔
150	{
151	factor = 1.25;	143✔
152	}
153
154	vectorReservedSize = (ulong)Math.Max(vectorReservedSize * factor, offset + count);	1,641✔
155	var state = NativeMethods.Vectors.DuckDBListVectorReserve(Vector, vectorReservedSize);	1,641✔
156
157	if (!state.IsSuccess())	1,641!
158	{
UNCOV 159	throw new DuckDBException($"Failed to reserve {vectorReservedSize} for the list vector");	×
160	}
161
162	listItemWriter.InitializerWriter();	1,641✔
163	}	1,641✔
164
165	public override void Dispose()
166	{
167	listItemWriter.Dispose();	306✔
168	childType.Dispose();	306✔
169	}	306✔
170	}

Giorgi / DuckDB.NET / 10460156994

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