12084884944

Committed 29 Nov 2024 12:37PM UTC coverage: 89.839% (-0.04%) from 89.881%

Build # 12084884944

Build Type

push

github

Committed by

Giorgi

Commit Message

Rename conflicting table function

Run Details

1055 of 1209 branches covered (87.26%)

Branch coverage included in aggregate %.

2075 of 2275 relevant lines covered (91.21%)

824654.22 hits per line

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

94.44

/DuckDB.NET.Data/DuckDBAppender.cs

﻿using DuckDB.NET.Data.Internal;
using DuckDB.NET.Data.Internal.Writer;
using DuckDB.NET.Native;
using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace DuckDB.NET.Data;

public class DuckDBAppender : IDisposable
{
    private bool closed;
    private readonly Native.DuckDBAppender nativeAppender;
    private readonly string qualifiedTableName;

    private ulong rowCount;

    private readonly DuckDBLogicalType[] logicalTypes;
    private readonly DuckDBDataChunk dataChunk;
    private readonly VectorDataWriterBase[] vectorWriters;

    internal DuckDBAppender(Native.DuckDBAppender appender, string qualifiedTableName)
    {
        nativeAppender = appender;
        this.qualifiedTableName = qualifiedTableName;

        var columnCount = NativeMethods.Appender.DuckDBAppenderColumnCount(nativeAppender);

        vectorWriters = new VectorDataWriterBase[columnCount];
        logicalTypes = new DuckDBLogicalType[columnCount];
        var logicalTypeHandles = new IntPtr[columnCount];

        for (ulong index = 0; index < columnCount; index++)
        {
            logicalTypes[index] = NativeMethods.Appender.DuckDBAppenderColumnType(nativeAppender, index);
            logicalTypeHandles[index] = logicalTypes[index].DangerousGetHandle();
        }

        dataChunk = NativeMethods.DataChunks.DuckDBCreateDataChunk(logicalTypeHandles, columnCount);
    }

    public DuckDBAppenderRow CreateRow()
    {
        if (closed)
        {
            throw new InvalidOperationException("Appender is already closed");
        }

        if (rowCount % DuckDBGlobalData.VectorSize == 0)
        {
            AppendDataChunk();

            InitVectorWriters();

            rowCount = 0;
        }

        rowCount++;
        return new DuckDBAppenderRow(qualifiedTableName, vectorWriters, rowCount - 1);
    }

    public void Close()
    {
        closed = true;

        try
        {
            AppendDataChunk();

            foreach (var logicalType in logicalTypes)
            {
                logicalType.Dispose();
            }

            foreach (var writer in vectorWriters)
            {
                writer?.Dispose();
            }

            dataChunk.Dispose();

            var state = NativeMethods.Appender.DuckDBAppenderClose(nativeAppender);
            if (!state.IsSuccess())
            {
                ThrowLastError(nativeAppender);
            }
        }
        finally
        {
            nativeAppender.Close();
        }
    }

    public void Dispose()
    {
        if (!closed)
        {
            Close();
        }
    }

    private void InitVectorWriters()
    {
        for (long index = 0; index < vectorWriters.LongLength; index++)
        {
            var vector = NativeMethods.DataChunks.DuckDBDataChunkGetVector(dataChunk, index);

            vectorWriters[index]?.Dispose();
            vectorWriters[index] = VectorDataWriterFactory.CreateWriter(vector, logicalTypes[index]);
        }
    }

    private void AppendDataChunk()
    {
        NativeMethods.DataChunks.DuckDBDataChunkSetSize(dataChunk, rowCount);
        var state = NativeMethods.Appender.DuckDBAppendDataChunk(nativeAppender, dataChunk);

        if (!state.IsSuccess())
        {
            ThrowLastError(nativeAppender);
        }

        NativeMethods.DataChunks.DuckDBDataChunkReset(dataChunk);
    }

    [DoesNotReturn]
    [StackTraceHidden]
    internal static void ThrowLastError(Native.DuckDBAppender appender)
    {
        var errorMessage = NativeMethods.Appender.DuckDBAppenderError(appender).ToManagedString(false);

        throw new DuckDBException(errorMessage);
    }
}

1	using DuckDB.NET.Data.Internal;
2	using DuckDB.NET.Data.Internal.Writer;
3	using DuckDB.NET.Native;
4	using System;
5	using System.Diagnostics;
6	using System.Diagnostics.CodeAnalysis;
7
8	namespace DuckDB.NET.Data;
9
10	public class DuckDBAppender : IDisposable
11	{
12	private bool closed;
13	private readonly Native.DuckDBAppender nativeAppender;
14	private readonly string qualifiedTableName;
15
16	private ulong rowCount;
17
18	private readonly DuckDBLogicalType[] logicalTypes;
19	private readonly DuckDBDataChunk dataChunk;
20	private readonly VectorDataWriterBase[] vectorWriters;
21
22	internal DuckDBAppender(Native.DuckDBAppender appender, string qualifiedTableName)	177✔
23	{
24	nativeAppender = appender;	177✔
25	this.qualifiedTableName = qualifiedTableName;	177✔
26
27	var columnCount = NativeMethods.Appender.DuckDBAppenderColumnCount(nativeAppender);	177✔
28
29	vectorWriters = new VectorDataWriterBase[columnCount];	177✔
30	logicalTypes = new DuckDBLogicalType[columnCount];	177✔
31	var logicalTypeHandles = new IntPtr[columnCount];	177✔
32
33	for (ulong index = 0; index < columnCount; index++)	1,512✔
34	{
35	logicalTypes[index] = NativeMethods.Appender.DuckDBAppenderColumnType(nativeAppender, index);	579✔
36	logicalTypeHandles[index] = logicalTypes[index].DangerousGetHandle();	579✔
37	}
38
39	dataChunk = NativeMethods.DataChunks.DuckDBCreateDataChunk(logicalTypeHandles, columnCount);	177✔
40	}	177✔
41
42	public DuckDBAppenderRow CreateRow()
43	{
44	if (closed)	354,975✔
45	{
46	throw new InvalidOperationException("Appender is already closed");	3✔
47	}
48
49	if (rowCount % DuckDBGlobalData.VectorSize == 0)	354,972✔
50	{
51	AppendDataChunk();	234✔
52
53	InitVectorWriters();	234✔
54
55	rowCount = 0;	234✔
56	}
57
58	rowCount++;	354,972✔
59	return new DuckDBAppenderRow(qualifiedTableName, vectorWriters, rowCount - 1);	354,972✔
60	}
61
62	public void Close()
63	{
64	closed = true;	174✔
65
66	try
67	{
68	AppendDataChunk();	174✔
69
70	foreach (var logicalType in logicalTypes)	1,488✔
71	{
72	logicalType.Dispose();	570✔
73	}
74
75	foreach (var writer in vectorWriters)	1,488✔
76	{
77	writer?.Dispose();	570✔
78	}
79
80	dataChunk.Dispose();	174✔
81
82	var state = NativeMethods.Appender.DuckDBAppenderClose(nativeAppender);	174✔
83	if (!state.IsSuccess())	174!
84	{
85	ThrowLastError(nativeAppender);	×
86	}
87	}	174✔
88	finally
89	{
90	nativeAppender.Close();	174✔
91	}	174✔
92	}	174✔
93
94	public void Dispose()
95	{
96	if (!closed)	171✔
97	{
98	Close();	165✔
99	}
100	}	171✔
101
102	private void InitVectorWriters()
103	{
104	for (long index = 0; index < vectorWriters.LongLength; index++)	1,848✔
105	{
106	var vector = NativeMethods.DataChunks.DuckDBDataChunkGetVector(dataChunk, index);	690✔
107
108	vectorWriters[index]?.Dispose();	690✔
109	vectorWriters[index] = VectorDataWriterFactory.CreateWriter(vector, logicalTypes[index]);	690✔
110	}
111	}	234✔
112
113	private void AppendDataChunk()
114	{
115	NativeMethods.DataChunks.DuckDBDataChunkSetSize(dataChunk, rowCount);	408✔
116	var state = NativeMethods.Appender.DuckDBAppendDataChunk(nativeAppender, dataChunk);	408✔
117
118	if (!state.IsSuccess())	408!
119	{
120	ThrowLastError(nativeAppender);	×
121	}
122
123	NativeMethods.DataChunks.DuckDBDataChunkReset(dataChunk);	408✔
124	}	408✔
125
126	[DoesNotReturn]
127	[StackTraceHidden]
128	internal static void ThrowLastError(Native.DuckDBAppender appender)
129	{
130	var errorMessage = NativeMethods.Appender.DuckDBAppenderError(appender).ToManagedString(false);	3✔
131
132	throw new DuckDBException(errorMessage);	3✔
133	}
134	}

Giorgi / DuckDB.NET / 12084884944

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