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

91.67

/DuckDB.NET.Data/DuckDBCommand.cs

﻿using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;

namespace DuckDB.NET.Data;

public class DuckDBCommand : DbCommand
{
    private DuckDBConnection? connection;
    private readonly DuckDBParameterCollection parameters = new();

    protected override DbTransaction? DbTransaction { get; set; }
    protected override DbParameterCollection DbParameterCollection => parameters;

    public new virtual DuckDBParameterCollection Parameters => parameters;

    public override int CommandTimeout { get; set; }
    public override CommandType CommandType { get; set; }
    public override bool DesignTimeVisible { get; set; }
    public override UpdateRowSource UpdatedRowSource { get; set; }

    /// <summary>
    /// A flag to determine whether to use streaming mode or not when executing a query. Defaults to false.
    /// In streaming mode DuckDB will use less RAM but query execution might be slower. Applies only to queries that return a result-set.
    /// </summary>
    /// <remarks>
    /// Streaming mode uses `duckdb_execute_prepared_streaming` and `duckdb_stream_fetch_chunk`, non-streaming (materialized) mode uses `duckdb_execute_prepared` and `duckdb_result_get_chunk`.
    /// </remarks>
    public bool UseStreamingMode { get; set; } = false;

    private string commandText = string.Empty;

    [AllowNull]
    [DefaultValue("")]
    public override string CommandText
    {
        get => commandText;
        set
        {
            // TODO: We shouldn't be able to change the CommandText when the command is in execution (requires CommandState implementation)
            commandText = value ?? string.Empty;
        }
    }

    protected override DbConnection? DbConnection
    {
        get => connection;
        set => connection = (DuckDBConnection?)value;
    }

    public DuckDBCommand()
    { }

    public DuckDBCommand(string commandText)
    {
        CommandText = commandText;
    }

    public DuckDBCommand(string commandText, DuckDBConnection connection)
        : this(commandText)
    {
        Connection = connection;
    }

    public override void Cancel() => connection?.NativeConnection.Interrupt();

    public override int ExecuteNonQuery()
    {
        EnsureConnectionOpen();

        var results = PreparedStatement.PreparedStatement.PrepareMultiple(connection!.NativeConnection, CommandText, parameters, UseStreamingMode);

        var count = 0;

        foreach (var result in results)
        {
            var current = result;
            count += (int)NativeMethods.Query.DuckDBRowsChanged(ref current);
            result.Close();
        }

        return count;
    }

    public override object? ExecuteScalar()
    {
        EnsureConnectionOpen();

        using var reader = ExecuteReader();
        return reader.Read() ? reader.GetValue(0) : null;
    }

    public new DuckDBDataReader ExecuteReader()
    {
        return (DuckDBDataReader)base.ExecuteReader();
    }

    public new DuckDBDataReader ExecuteReader(CommandBehavior behavior)
    {
        return (DuckDBDataReader)base.ExecuteReader(behavior);
    }

    protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
    {
        EnsureConnectionOpen();

        var results = PreparedStatement.PreparedStatement.PrepareMultiple(connection!.NativeConnection, CommandText, parameters, UseStreamingMode);

        var reader = new DuckDBDataReader(this, results, behavior);

        return reader;
    }

    public override void Prepare() { }

    protected override DbParameter CreateDbParameter() => new DuckDBParameter();

    internal void CloseConnection() => Connection!.Close();

    private void EnsureConnectionOpen([CallerMemberName] string operation = "")
    {
        if (Connection is null || Connection.State != ConnectionState.Open)
        {
            throw new InvalidOperationException($"{operation} requires an open connection");
        }
    }
}

1	using System.ComponentModel;
2	using System.Diagnostics.CodeAnalysis;
3	using System.Runtime.CompilerServices;
4
5	namespace DuckDB.NET.Data;
6
7	public class DuckDBCommand : DbCommand
8	{
9	private DuckDBConnection? connection;
10	private readonly DuckDBParameterCollection parameters = new();	80,718✔
11
12	protected override DbTransaction? DbTransaction { get; set; }	80,709✔
13	protected override DbParameterCollection DbParameterCollection => parameters;	390✔
14
15	public new virtual DuckDBParameterCollection Parameters => parameters;	1,242✔
16
UNCOV 17	public override int CommandTimeout { get; set; }	×
18	public override CommandType CommandType { get; set; }	60,441✔
UNCOV 19	public override bool DesignTimeVisible { get; set; }	×
UNCOV 20	public override UpdateRowSource UpdatedRowSource { get; set; }	×
21
22	/// <summary>
23	/// A flag to determine whether to use streaming mode or not when executing a query. Defaults to false.
24	/// In streaming mode DuckDB will use less RAM but query execution might be slower. Applies only to queries that return a result-set.
25	/// </summary>
26	/// <remarks>
27	/// Streaming mode uses `duckdb_execute_prepared_streaming` and `duckdb_stream_fetch_chunk`, non-streaming (materialized) mode uses `duckdb_execute_prepared` and `duckdb_result_get_chunk`.
28	/// </remarks>
29	public bool UseStreamingMode { get; set; } = false;	157,767✔
30
31	private string commandText = string.Empty;	80,718✔
32
33	[AllowNull]
34	[DefaultValue("")]
35	public override string CommandText
36	{
37	get => commandText;	157,755✔
38	set
39	{
40	// TODO: We shouldn't be able to change the CommandText when the command is in execution (requires CommandState implementation)
41	commandText = value ?? string.Empty;	138,645!
42	}	138,645✔
43	}
44
45	protected override DbConnection? DbConnection
46	{
47	get => connection;	354,423✔
48	set => connection = (DuckDBConnection?)value;	80,715✔
49	}
50
51	public DuckDBCommand()	80,712✔
52	{ }	80,712✔
53
54	public DuckDBCommand(string commandText)	6✔
55	{
56	CommandText = commandText;	6✔
57	}	6✔
58
59	public DuckDBCommand(string commandText, DuckDBConnection connection)
60	: this(commandText)	3✔
61	{
62	Connection = connection;	3✔
63	}	3✔
64
65	public override void Cancel() => connection?.NativeConnection.Interrupt();	12!
66
67	public override int ExecuteNonQuery()
68	{
69	EnsureConnectionOpen();	118,218✔
70
71	var results = PreparedStatement.PreparedStatement.PrepareMultiple(connection!.NativeConnection, CommandText, parameters, UseStreamingMode);	118,218✔
72
73	var count = 0;	118,218✔
74
75	foreach (var result in results)	472,980✔
76	{
77	var current = result;	118,272✔
78	count += (int)NativeMethods.Query.DuckDBRowsChanged(ref current);	118,272✔
79	result.Close();	118,272✔
80	}
81
82	return count;	118,176✔
83	}
84
85	public override object? ExecuteScalar()
86	{
87	EnsureConnectionOpen();	19,461✔
88
89	using var reader = ExecuteReader();	19,458✔
90	return reader.Read() ? reader.GetValue(0) : null;	19,452✔
91	}	19,452✔
92
93	public new DuckDBDataReader ExecuteReader()
94	{
95	return (DuckDBDataReader)base.ExecuteReader();	39,354✔
96	}
97
98	public new DuckDBDataReader ExecuteReader(CommandBehavior behavior)
99	{
100	return (DuckDBDataReader)base.ExecuteReader(behavior);	9✔
101	}
102
103	protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
104	{
105	EnsureConnectionOpen();	39,528✔
106
107	var results = PreparedStatement.PreparedStatement.PrepareMultiple(connection!.NativeConnection, CommandText, parameters, UseStreamingMode);	39,528✔
108
109	var reader = new DuckDBDataReader(this, results, behavior);	39,528✔
110
111	return reader;	39,504✔
112	}
113
114	public override void Prepare() { }	3✔
115
116	protected override DbParameter CreateDbParameter() => new DuckDBParameter();	69✔
117
118	internal void CloseConnection() => Connection!.Close();	6✔
119
120	private void EnsureConnectionOpen([CallerMemberName] string operation = "")
121	{
122	if (Connection is null \|\| Connection.State != ConnectionState.Open)	177,207✔
123	{
124	throw new InvalidOperationException($"{operation} requires an open connection");	3✔
125	}
126	}	177,204✔
127	}

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