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

84.62

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

﻿using System.Globalization;
using System.Runtime.CompilerServices;

namespace DuckDB.NET.Data.DataChunk.Reader;

internal sealed class EnumVectorDataReader : VectorDataReaderBase
{
    private readonly DuckDBType enumType;
    private readonly DuckDBLogicalType logicalType;

    internal unsafe EnumVectorDataReader(IntPtr vector, void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)
    {
        logicalType = NativeMethods.Vectors.DuckDBVectorGetColumnType(vector);
        enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);
    }

    protected override T GetValidValue<T>(ulong offset, Type targetType)
    {
        if (DuckDBType != DuckDBType.Enum)
        {
            return base.GetValidValue<T>(offset, targetType);
        }

        switch (enumType)
        {
            case DuckDBType.UnsignedTinyInt:
            {
                var enumValue = GetFieldData<byte>(offset);
                return ToEnumOrString(enumValue);
            }
            case DuckDBType.UnsignedSmallInt:
            {
                var enumValue = GetFieldData<ushort>(offset);
                return ToEnumOrString(enumValue);
            }
            case DuckDBType.UnsignedInteger:
            {
                var enumValue = GetFieldData<uint>(offset);
                return ToEnumOrString(enumValue);
            }
            default:
                throw new DuckDBException($"Invalid type {DuckDBType} ({(int)DuckDBType}) for column {ColumnName}");
        }

        T ToEnumOrString<TSource>(TSource enumValue) where TSource: unmanaged
        {
            if (typeof(T) == typeof(string))
            {
                var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, Convert.ToInt64(enumValue)).ToManagedString();
                return (T)(object)value;
            }
            return Unsafe.As<TSource, T>(ref enumValue);
        }
    }

    internal override object GetValue(ulong offset, Type targetType)
    {
        if (DuckDBType == DuckDBType.Enum)
        {
            return GetEnum(offset, targetType);
        }

        return base.GetValue(offset, targetType);
    }

    private object GetEnum(ulong offset, Type returnType)
    {
        long enumValue = enumType switch
        {
            DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),
            DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),
            DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),
            _ => -1
        };

        if (returnType == typeof(string))
        {
            var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, enumValue).ToManagedString();
            return value;
        }
        
        var enumItem = Enum.Parse(returnType, enumValue.ToString(CultureInfo.InvariantCulture));
        return enumItem;
    }

    public override void Dispose()
    {
        logicalType.Dispose();
        base.Dispose();
    }
}

1	using System.Globalization;
2	using System.Runtime.CompilerServices;
3
4	namespace DuckDB.NET.Data.DataChunk.Reader;
5
6	internal sealed class EnumVectorDataReader : VectorDataReaderBase
7	{
8	private readonly DuckDBType enumType;
9	private readonly DuckDBLogicalType logicalType;
10
11	internal unsafe EnumVectorDataReader(IntPtr vector, void* dataPointer, ulong* validityMaskPointer, DuckDBType columnType, string columnName) : base(dataPointer, validityMaskPointer, columnType, columnName)	573✔
12	{
13	logicalType = NativeMethods.Vectors.DuckDBVectorGetColumnType(vector);	573✔
14	enumType = NativeMethods.LogicalType.DuckDBEnumInternalType(logicalType);	573✔
15	}	573✔
16
17	protected override T GetValidValue<T>(ulong offset, Type targetType)
18	{
19	if (DuckDBType != DuckDBType.Enum)	36!
20	{
UNCOV 21	return base.GetValidValue<T>(offset, targetType);	×
22	}
23
24	switch (enumType)	36!
25	{
26	case DuckDBType.UnsignedTinyInt:
27	{
28	var enumValue = GetFieldData<byte>(offset);	24✔
29	return ToEnumOrString(enumValue);	24✔
30	}
31	case DuckDBType.UnsignedSmallInt:
32	{
33	var enumValue = GetFieldData<ushort>(offset);	6✔
34	return ToEnumOrString(enumValue);	6✔
35	}
36	case DuckDBType.UnsignedInteger:
37	{
38	var enumValue = GetFieldData<uint>(offset);	6✔
39	return ToEnumOrString(enumValue);	6✔
40	}
41	default:
UNCOV 42	throw new DuckDBException($"Invalid type {DuckDBType} ({(int)DuckDBType}) for column {ColumnName}");	×
43	}
44
45	T ToEnumOrString<TSource>(TSource enumValue) where TSource: unmanaged
46	{
47	if (typeof(T) == typeof(string))	36✔
48	{
49	var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, Convert.ToInt64(enumValue)).ToManagedString();	24✔
50	return (T)(object)value;	24✔
51	}
52	return Unsafe.As<TSource, T>(ref enumValue);	12✔
53	}
54	}
55
56	internal override object GetValue(ulong offset, Type targetType)
57	{
58	if (DuckDBType == DuckDBType.Enum)	1,124,361!
59	{
60	return GetEnum(offset, targetType);	1,124,361✔
61	}
62
UNCOV 63	return base.GetValue(offset, targetType);	×
64	}
65
66	private object GetEnum(ulong offset, Type returnType)
67	{
68	long enumValue = enumType switch	1,124,361!
69	{	1,124,361✔
70	DuckDBType.UnsignedTinyInt => GetFieldData<byte>(offset),	1,124,337✔
71	DuckDBType.UnsignedSmallInt => GetFieldData<ushort>(offset),	12✔
72	DuckDBType.UnsignedInteger => GetFieldData<uint>(offset),	12✔
UNCOV 73	_ => -1	×
74	};	1,124,361✔
75
76	if (returnType == typeof(string))	1,124,361✔
77	{
78	var value = NativeMethods.LogicalType.DuckDBEnumDictionaryValue(logicalType, enumValue).ToManagedString();	559,939✔
79	return value;	559,939✔
80	}
81
82	var enumItem = Enum.Parse(returnType, enumValue.ToString(CultureInfo.InvariantCulture));	564,422✔
83	return enumItem;	564,422✔
84	}
85
86	public override void Dispose()
87	{
88	logicalType.Dispose();	84✔
89	base.Dispose();	84✔
90	}	84✔
91	}

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