12063721251

Committed 28 Nov 2024 06:32AM UTC coverage: 88.995% (+0.04%) from 88.958%

Build # 12063721251

Build Type

push

github

Committed by

Giorgi

Commit Message

Do not throw if parameter index isn't found

Run Details

1146 of 1326 branches covered (86.43%)

Branch coverage included in aggregate %.

2121 of 2345 relevant lines covered (90.45%)

772904.74 hits per line

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

92.77

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

using System;
using System.Collections.Generic;
using System.Linq;
using DuckDB.NET.Data.Extensions;
using DuckDB.NET.Native;

namespace DuckDB.NET.Data.Internal;

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);
                    using var result = preparedStatement.Execute(parameters, useStreamingMode);
                    yield return result;
                }
                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.Dispose();

            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);
        using var duckDBValue = parameter.Value.ToDuckDBValue(parameterLogicalType);

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

Giorgi / DuckDB.NET / 12063721251

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