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

91.43

/DuckDB.NET.Data/DataChunk/Reader/StringVectorDataReader.cs

﻿using System.IO;
using System.Text;

namespace DuckDB.NET.Data.DataChunk.Reader;

internal sealed class StringVectorDataReader : VectorDataReaderBase
{
    internal unsafe StringVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)
    {
    }

    protected override T GetValidValue<T>(ulong offset, Type targetType)
    {
        return DuckDBType switch
        {
            DuckDBType.Bit => GetBitString<T>(offset),
            DuckDBType.Blob => (T)(object)GetStream(offset),
            DuckDBType.Varchar => (T)(object)GetString(offset),
            _ => base.GetValidValue<T>(offset, targetType)
        };
    }

    internal override object GetValue(ulong offset, Type targetType)
    {
        return DuckDBType switch
        {
            DuckDBType.Bit => GetBitString(offset),
            DuckDBType.Blob => GetStream(offset),
            DuckDBType.Varchar => GetString(offset),
            _ => base.GetValue(offset, targetType)
        };
    }

    private T GetBitString<T>(ulong offset)
    {
        if (typeof(T) == typeof(string))
        {
            return (T)(object)GetBitString(offset);
        }

        if (typeof(T) == typeof(BitArray))
        {
            return (T)(object)GetBitStringAsBitArray(offset);
        }

        return base.GetValue<T>(offset);
    }

    private string GetBitString(ulong offset)
    {
        var bitArray = GetBitStringAsBitArray(offset);

        return string.Create(bitArray.Length, bitArray, (chars, array) =>
        {
            for (int index = 0; index < array.Length; index++)
            {
                chars[index] = array[index] ? '1' : '0';
            }
        });
    }

    //Copied from https://github.com/duckdb/duckdb/blob/8a17511028d306561d88da9425f9e0e88dedd70c/src/common/types/bit.cpp#L63
    private unsafe BitArray GetBitStringAsBitArray(ulong offset)
    {
        var bits = (DuckDBString*)DataPointer + offset;
        var data = bits->Data;

        var bitLength = (bits->Length - 1) * 8 - *data;

        var output = new BitArray(bitLength);
        var outputIndex = 0;

        for (var bitIndex = *data; bitIndex < 8; bitIndex++)
        {
            output[outputIndex++] = (*(data + 1) & (1 << (7 - bitIndex))) > 0;
        }

        for (var byteIndex = 2; byteIndex < bits->Length; byteIndex++)
        {
            for (var bitIndex = 0; bitIndex < 8; bitIndex++)
            {
                output[outputIndex++] = (*(data + byteIndex) & (1 << (7 - bitIndex))) > 0;
            }
        }

        return output;
    }

    private unsafe string GetString(ulong offset)
    {
        var data = (DuckDBString*)DataPointer + offset;

        return new string(data->Data, 0, data->Length, Encoding.UTF8);
    }

    private unsafe Stream GetStream(ulong offset)
    {
        var data = (DuckDBString*)DataPointer + offset;

        return new UnmanagedMemoryStream((byte*)data->Data, data->Length, data->Length, FileAccess.Read);
    }
}

1	using System.IO;
2	using System.Text;
3
4	namespace DuckDB.NET.Data.DataChunk.Reader;
5
6	internal sealed class StringVectorDataReader : VectorDataReaderBase
7	{
8	internal unsafe StringVectorDataReader(void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)	2,844✔
9	{
10	}	2,844✔
11
12	protected override T GetValidValue<T>(ulong offset, Type targetType)
13	{
14	return DuckDBType switch	30,273!
15	{	30,273✔
16	DuckDBType.Bit => GetBitString<T>(offset),	12✔
17	DuckDBType.Blob => (T)(object)GetStream(offset),	24✔
18	DuckDBType.Varchar => (T)(object)GetString(offset),	30,237✔
UNCOV 19	_ => base.GetValidValue<T>(offset, targetType)	×
20	};	30,273✔
21	}
22
23	internal override object GetValue(ulong offset, Type targetType)
24	{
25	return DuckDBType switch	816,809!
26	{	816,809✔
27	DuckDBType.Bit => GetBitString(offset),	9✔
28	DuckDBType.Blob => GetStream(offset),	3✔
29	DuckDBType.Varchar => GetString(offset),	816,797✔
UNCOV 30	_ => base.GetValue(offset, targetType)	×
31	};	816,809✔
32	}
33
34	private T GetBitString<T>(ulong offset)
35	{
36	if (typeof(T) == typeof(string))	12✔
37	{
38	return (T)(object)GetBitString(offset);	9✔
39	}
40
41	if (typeof(T) == typeof(BitArray))	3!
42	{
43	return (T)(object)GetBitStringAsBitArray(offset);	3✔
44	}
45
UNCOV 46	return base.GetValue<T>(offset);	×
47	}
48
49	private string GetBitString(ulong offset)
50	{
51	var bitArray = GetBitStringAsBitArray(offset);	18✔
52
53	return string.Create(bitArray.Length, bitArray, (chars, array) =>	18✔
54	{	18✔
55	for (int index = 0; index < array.Length; index++)	612✔
56	{	18✔
57	chars[index] = array[index] ? '1' : '0';	288✔
58	}	18✔
59	});	36✔
60	}
61
62	//Copied from https://github.com/duckdb/duckdb/blob/8a17511028d306561d88da9425f9e0e88dedd70c/src/common/types/bit.cpp#L63
63	private unsafe BitArray GetBitStringAsBitArray(ulong offset)
64	{
65	var bits = (DuckDBString*)DataPointer + offset;	21✔
66	var data = bits->Data;	21✔
67
68	var bitLength = (bits->Length - 1) * 8 - *data;	21✔
69
70	var output = new BitArray(bitLength);	21✔
71	var outputIndex = 0;	21✔
72
73	for (var bitIndex = *data; bitIndex < 8; bitIndex++)	258✔
74	{
75	output[outputIndex++] = (*(data + 1) & (1 << (7 - bitIndex))) > 0;	108✔
76	}
77
78	for (var byteIndex = 2; byteIndex < bits->Length; byteIndex++)	96✔
79	{
80	for (var bitIndex = 0; bitIndex < 8; bitIndex++)	486✔
81	{
82	output[outputIndex++] = (*(data + byteIndex) & (1 << (7 - bitIndex))) > 0;	216✔
83	}
84	}
85
86	return output;	21✔
87	}
88
89	private unsafe string GetString(ulong offset)
90	{
91	var data = (DuckDBString*)DataPointer + offset;	847,034✔
92
93	return new string(data->Data, 0, data->Length, Encoding.UTF8);	847,034✔
94	}
95
96	private unsafe Stream GetStream(ulong offset)
97	{
98	var data = (DuckDBString*)DataPointer + offset;	27✔
99
100	return new UnmanagedMemoryStream((byte*)data->Data, data->Length, data->Length, FileAccess.Read);	27✔
101	}
102	}

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