14560492056

Committed 20 Apr 2025 02:36PM UTC coverage: 89.854% (+0.02%) from 89.838%

Build # 14560492056

Build Type

Pull #258

github

Committed by

web-flow

Commit Message

Merge 01861257f into 1b48eeca0

Pull Request Pull Request #258: Cache prepared statements

Run Details

1114 of 1277 branches covered (87.24%)

Branch coverage included in aggregate %.

91 of 95 new or added lines in 3 files covered. (95.79%)

1 existing line in 1 file now uncovered.

2154 of 2360 relevant lines covered (91.27%)

747266.09 hits per line

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

91.53

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

using DuckDB.NET.Native;
using System;
using System.Linq;

namespace DuckDB.NET.Data.PreparedStatement;

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

    internal bool UseStreamingMode { get; set; }

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

    internal DuckDBResult Execute()
    {
        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.Dispose();

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

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

            throw new DuckDBException(errorMessage, errorType);
        }

        return queryResult;
    }

    internal void BindParameters(DuckDBParameterCollection parameterCollection)
    {
        var expectedParameters = NativeMethods.PreparedStatements.DuckDBParams(statement);
        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(statement, out var index, param.ParameterName.ToUnmanagedString());
                if (state.IsSuccess())
                {
                    BindParameter(index, param);
                }
            }
        }
        else
        {
            for (var i = 0; i < expectedParameters; ++i)
            {
                var param = parameterCollection[i];
                BindParameter(i + 1, param);
            }
        }
    }

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

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

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

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

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

1	using DuckDB.NET.Native;
2	using System;
3	using System.Linq;
4
5	namespace DuckDB.NET.Data.PreparedStatement;
6
7	internal sealed class PreparedStatement : IDisposable
8	{
9	private readonly DuckDBPreparedStatement statement;
10
11	internal bool UseStreamingMode { get; set; }	315,158✔
12
13	internal PreparedStatement(DuckDBPreparedStatement statement)	138,485✔
14	{
15	this.statement = statement;	138,485✔
16	}	138,485✔
17
18	internal DuckDBResult Execute()
19	{
20	var status = UseStreamingMode	157,579✔
21	? NativeMethods.PreparedStatements.DuckDBExecutePreparedStreaming(statement, out var queryResult)	157,579✔
22	: NativeMethods.PreparedStatements.DuckDBExecutePrepared(statement, out queryResult);	157,579✔
23
24	if (!status.IsSuccess())	157,579✔
25	{
26	var errorMessage = NativeMethods.Query.DuckDBResultError(ref queryResult).ToManagedString(false);	42✔
27	var errorType = NativeMethods.Query.DuckDBResultErrorType(ref queryResult);	42✔
28	queryResult.Dispose();	42✔
29
30	if (string.IsNullOrEmpty(errorMessage))	42!
31	{
32	errorMessage = "DuckDB execution failed";	×
33	}
34
35	if (errorType == DuckDBErrorType.Interrupt)	42✔
36	{
37	throw new OperationCanceledException();	12✔
38	}
39
40	throw new DuckDBException(errorMessage, errorType);	30✔
41	}
42
43	return queryResult;	157,537✔
44	}
45
46	internal void BindParameters(DuckDBParameterCollection parameterCollection)
47	{
48	var expectedParameters = NativeMethods.PreparedStatements.DuckDBParams(statement);	157,597✔
49	if (parameterCollection.Count < expectedParameters)	157,597✔
50	{
51	throw new InvalidOperationException($"Invalid number of parameters. Expected {expectedParameters}, got {parameterCollection.Count}");	18✔
52	}
53
54	if (parameterCollection.OfType<DuckDBParameter>().Any(p => !string.IsNullOrEmpty(p.ParameterName)))	158,980✔
55	{
56	foreach (DuckDBParameter param in parameterCollection)	672✔
57	{
58	var state = NativeMethods.PreparedStatements.DuckDBBindParameterIndex(statement, out var index, param.ParameterName.ToUnmanagedString());	204✔
59	if (state.IsSuccess())	204✔
60	{
61	BindParameter(index, param);	174✔
62	}
63	}
64	}
65	else
66	{
67	for (var i = 0; i < expectedParameters; ++i)	316,346✔
68	{
69	var param = parameterCollection[i];	726✔
70	BindParameter(i + 1, param);	726✔
71	}
72	}
73	}	157,579✔
74
75	private void BindParameter(long index, DuckDBParameter parameter)
76	{
77	using var parameterLogicalType = NativeMethods.PreparedStatements.DuckDBParamLogicalType(statement, index);	900✔
78	var duckDBType = NativeMethods.LogicalType.DuckDBGetTypeId(parameterLogicalType);	900✔
79
80	using var duckDBValue = parameter.Value.ToDuckDBValue(parameterLogicalType, duckDBType);	900✔
81
82	var result = NativeMethods.PreparedStatements.DuckDBBindValue(statement, index, duckDBValue);	900✔
83
84	if (!result.IsSuccess())	900!
85	{
NEW 86	var errorMessage = NativeMethods.PreparedStatements.DuckDBPrepareError(statement).ToManagedString(false);	×
87	throw new InvalidOperationException($"Unable to bind parameter {index}: {errorMessage}");	×
88	}
89	}	1,800✔
90
91	public void Dispose()
92	{
93	statement.Dispose();	138,477✔
94	}	138,477✔
95	}

Giorgi / DuckDB.NET / 14560492056

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