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

92.77

/DuckDB.NET.Data/PreparedStatement/PreparedStatement.cs

using System.Linq;

namespace DuckDB.NET.Data.PreparedStatement;

internal sealed class PreparedStatement : IDisposable
{
    private readonly DuckDBPreparedStatement statement;

    private PreparedStatement(DuckDBPreparedStatement statement)
    {
        this.statement = statement;
    }

    public static IEnumerable<DuckDBResult> PrepareMultiple(DuckDBNativeConnection connection, string query, DuckDBParameterCollection parameters, bool useStreamingMode)
    {
        using var unmanagedQuery = query.ToUnmanagedString();

        var statementCount = NativeMethods.ExtractStatements.DuckDBExtractStatements(connection, unmanagedQuery, out var extractedStatements);

        using (extractedStatements)
        {
            if (statementCount <= 0)
            {
                var error = NativeMethods.ExtractStatements.DuckDBExtractStatementsError(extractedStatements);
                throw new DuckDBException(error.ToManagedString(false));
            }

            for (int index = 0; index < statementCount; index++)
            {
                var status = NativeMethods.ExtractStatements.DuckDBPrepareExtractedStatement(connection, extractedStatements, index, out var statement);

                if (status.IsSuccess())
                {
                    using var preparedStatement = new PreparedStatement(statement);
                    yield return preparedStatement.Execute(parameters, useStreamingMode);
                }
                else
                {
                    var errorMessage = NativeMethods.PreparedStatements.DuckDBPrepareError(statement).ToManagedString(false);

                    throw new DuckDBException(string.IsNullOrEmpty(errorMessage) ? "DuckDBQuery failed" : errorMessage);
                }
            }
        }
    }

    private DuckDBResult Execute(DuckDBParameterCollection parameterCollection, bool useStreamingMode)
    {
        BindParameters(statement, parameterCollection);

        var status = useStreamingMode
            ? NativeMethods.PreparedStatements.DuckDBExecutePreparedStreaming(statement, out var queryResult)
            : NativeMethods.PreparedStatements.DuckDBExecutePrepared(statement, out queryResult);

        if (!status.IsSuccess())
        {
            var errorMessage = NativeMethods.Query.DuckDBResultError(ref queryResult).ToManagedString(false);
            var errorType = NativeMethods.Query.DuckDBResultErrorType(ref queryResult);
            queryResult.Close();

            if (string.IsNullOrEmpty(errorMessage))
            {
                errorMessage = "DuckDB execution failed";
            }

            if (errorType == DuckDBErrorType.Interrupt)
            {
                throw new OperationCanceledException();
            }

            throw new DuckDBException(errorMessage, errorType);
        }

        return queryResult;
    }

    private static void BindParameters(DuckDBPreparedStatement preparedStatement, DuckDBParameterCollection parameterCollection)
    {
        var expectedParameters = NativeMethods.PreparedStatements.DuckDBParams(preparedStatement);
        if (parameterCollection.Count < expectedParameters)
        {
            throw new InvalidOperationException($"Invalid number of parameters. Expected {expectedParameters}, got {parameterCollection.Count}");
        }

        if (parameterCollection.OfType<DuckDBParameter>().Any(p => !string.IsNullOrEmpty(p.ParameterName)))
        {
            foreach (DuckDBParameter param in parameterCollection)
            {
                var state = NativeMethods.PreparedStatements.DuckDBBindParameterIndex(preparedStatement, out var index, param.ParameterName.ToUnmanagedString());
                if (state.IsSuccess())
                {
                    BindParameter(preparedStatement, index, param);
                }
            }
        }
        else
        {
            for (var i = 0; i < expectedParameters; ++i)
            {
                var param = parameterCollection[i];
                BindParameter(preparedStatement, i + 1, param);
            }
        }
    }

    private static void BindParameter(DuckDBPreparedStatement preparedStatement, long index, DuckDBParameter parameter)
    {
        using var parameterLogicalType = NativeMethods.PreparedStatements.DuckDBParamLogicalType(preparedStatement, index);
        var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(parameterLogicalType);

        using var duckDBValue = parameter.Value.ToDuckDBValue(parameterLogicalType, duckDBType, parameter.DbType);

        var result = NativeMethods.PreparedStatements.DuckDBBindValue(preparedStatement, index, duckDBValue);

        if (!result.IsSuccess())
        {
            var errorMessage = NativeMethods.PreparedStatements.DuckDBPrepareError(preparedStatement).ToManagedString(false);
            throw new InvalidOperationException($"Unable to bind parameter {index}: {errorMessage}");
        }
    }

    public void Dispose()
    {
        statement.Dispose();
    }
}

1	using System.Linq;
2
3	namespace DuckDB.NET.Data.PreparedStatement;
4
5	internal sealed class PreparedStatement : IDisposable
6	{
7	private readonly DuckDBPreparedStatement statement;
8
9	private PreparedStatement(DuckDBPreparedStatement statement)	157,848✔
10	{
11	this.statement = statement;	157,848✔
12	}	157,848✔
13
14	public static IEnumerable<DuckDBResult> PrepareMultiple(DuckDBNativeConnection connection, string query, DuckDBParameterCollection parameters, bool useStreamingMode)
15	{
16	using var unmanagedQuery = query.ToUnmanagedString();	157,746✔
17
18	var statementCount = NativeMethods.ExtractStatements.DuckDBExtractStatements(connection, unmanagedQuery, out var extractedStatements);	157,746✔
19
20	using (extractedStatements)	157,746✔
21	{
22	if (statementCount <= 0)	157,746✔
23	{
24	var error = NativeMethods.ExtractStatements.DuckDBExtractStatementsError(extractedStatements);	3✔
25	throw new DuckDBException(error.ToManagedString(false));	3✔
26	}
27
28	for (int index = 0; index < statementCount; index++)	552,468✔
29	{
30	var status = NativeMethods.ExtractStatements.DuckDBPrepareExtractedStatement(connection, extractedStatements, index, out var statement);	157,854✔
31
32	if (status.IsSuccess())	157,854✔
33	{
34	using var preparedStatement = new PreparedStatement(statement);	157,848✔
35	yield return preparedStatement.Execute(parameters, useStreamingMode);	157,848✔
36	}	118,491✔
37	else
38	{
39	var errorMessage = NativeMethods.PreparedStatements.DuckDBPrepareError(statement).ToManagedString(false);	6✔
40
41	throw new DuckDBException(string.IsNullOrEmpty(errorMessage) ? "DuckDBQuery failed" : errorMessage);	6!
42	}
43	}
44	}	118,380✔
45	}	118,380✔
46
47	private DuckDBResult Execute(DuckDBParameterCollection parameterCollection, bool useStreamingMode)
48	{
49	BindParameters(statement, parameterCollection);	157,848✔
50
51	var status = useStreamingMode	157,830✔
52	? NativeMethods.PreparedStatements.DuckDBExecutePreparedStreaming(statement, out var queryResult)	157,830✔
53	: NativeMethods.PreparedStatements.DuckDBExecutePrepared(statement, out queryResult);	157,830✔
54
55	if (!status.IsSuccess())	157,830✔
56	{
57	var errorMessage = NativeMethods.Query.DuckDBResultError(ref queryResult).ToManagedString(false);	42✔
58	var errorType = NativeMethods.Query.DuckDBResultErrorType(ref queryResult);	42✔
59	queryResult.Close();	42✔
60
61	if (string.IsNullOrEmpty(errorMessage))	42!
62	{
UNCOV 63	errorMessage = "DuckDB execution failed";	×
64	}
65
66	if (errorType == DuckDBErrorType.Interrupt)	42✔
67	{
68	throw new OperationCanceledException();	12✔
69	}
70
71	throw new DuckDBException(errorMessage, errorType);	30✔
72	}
73
74	return queryResult;	157,788✔
75	}
76
77	private static void BindParameters(DuckDBPreparedStatement preparedStatement, DuckDBParameterCollection parameterCollection)
78	{
79	var expectedParameters = NativeMethods.PreparedStatements.DuckDBParams(preparedStatement);	157,848✔
80	if (parameterCollection.Count < expectedParameters)	157,848✔
81	{
82	throw new InvalidOperationException($"Invalid number of parameters. Expected {expectedParameters}, got {parameterCollection.Count}");	18✔
83	}
84
85	if (parameterCollection.OfType<DuckDBParameter>().Any(p => !string.IsNullOrEmpty(p.ParameterName)))	159,405✔
86	{
87	foreach (DuckDBParameter param in parameterCollection)	672✔
88	{
89	var state = NativeMethods.PreparedStatements.DuckDBBindParameterIndex(preparedStatement, out var index, param.ParameterName.ToUnmanagedString());	204✔
90	if (state.IsSuccess())	204✔
91	{
92	BindParameter(preparedStatement, index, param);	174✔
93	}
94	}
95	}
96	else
97	{
98	for (var i = 0; i < expectedParameters; ++i)	317,196✔
99	{
100	var param = parameterCollection[i];	900✔
101	BindParameter(preparedStatement, i + 1, param);	900✔
102	}
103	}
104	}	157,830✔
105
106	private static void BindParameter(DuckDBPreparedStatement preparedStatement, long index, DuckDBParameter parameter)
107	{
108	using var parameterLogicalType = NativeMethods.PreparedStatements.DuckDBParamLogicalType(preparedStatement, index);	1,074✔
109	var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(parameterLogicalType);	1,074✔
110
111	using var duckDBValue = parameter.Value.ToDuckDBValue(parameterLogicalType, duckDBType, parameter.DbType);	1,074✔
112
113	var result = NativeMethods.PreparedStatements.DuckDBBindValue(preparedStatement, index, duckDBValue);	1,074✔
114
115	if (!result.IsSuccess())	1,074!
116	{
UNCOV 117	var errorMessage = NativeMethods.PreparedStatements.DuckDBPrepareError(preparedStatement).ToManagedString(false);	×
UNCOV 118	throw new InvalidOperationException($"Unable to bind parameter {index}: {errorMessage}");	×
119	}
120	}	2,148✔
121
122	public void Dispose()
123	{
124	statement.Dispose();	157,188✔
125	}	157,188✔
126	}

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