// Copyright (C) 2026, The Duplicati Team
// https://duplicati.com, hello@duplicati.com
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Duplicati.Library.Utility;
using Microsoft.Data.Sqlite;
#nullable enable
namespace Duplicati.Library.Main.Database;
///
/// Extension method for
///
public static partial class ExtensionMethods
{
///
/// Converts the value at the given index in the reader to an Int64.
///
/// The to read from.
/// The index of the value to convert.
/// The default value to return if the value is null or cannot be converted.
/// The converted Int64 value, or the default value if the conversion fails.
public static long ConvertValueToInt64(this SqliteDataReader reader, int index, long defaultvalue = -1)
{
try
{
if (!reader.IsDBNull(index))
return reader.GetInt64(index);
}
catch { }
return defaultvalue;
}
///
/// Converts the value at the given index in the reader to a string.
///
/// The to read from.
/// The index of the value to convert.
/// The converted string value, or null if the value is null or cannot be converted.
public static string? ConvertValueToString(this SqliteDataReader reader, int index)
{
var v = reader.GetValue(index);
if (v == null || v == DBNull.Value)
return null;
return v.ToString();
}
///
/// Creates a new with the given command text.
///
/// The to create the command for.
/// The command text to set for the command.
/// A new with the command text set.
public static SqliteCommand CreateCommand(this SqliteConnection self, string cmdtext)
{
return CreateCommandAsync(self, cmdtext, default).Await();
}
///
/// Creates a new with the given command text and prepares it asynchronously.
///
/// The to create the command for.
/// The command text to set for the command.
/// Cancellation token to cancel the operation.
/// A new with the command text set and prepared asynchronously.
public static async Task CreateCommandAsync(this SqliteConnection self, string cmdtext, CancellationToken cancellationToken)
{
var cmd = self.CreateCommand()
.SetCommandAndParameters(cmdtext);
await cmd.PrepareAsync(cancellationToken).ConfigureAwait(false);
return cmd;
}
///
/// Creates a new with the given transaction.
///
/// The to create the command for.
/// The to set for the command.
/// A new with the transaction set.
public static SqliteCommand CreateCommand(this SqliteConnection self, SqliteTransaction transaction)
{
var cmd = self.CreateCommand();
cmd.SetTransaction(transaction);
return cmd;
}
///
/// Creates a new with the given reusable transaction.
///
/// The to create the command for.
/// The to set for the command.
/// A new with the transaction set.
internal static SqliteCommand CreateCommand(this SqliteConnection self, ReusableTransaction rtr)
{
return self.CreateCommand(rtr.Transaction);
}
///
/// Executes the command asynchronously and returns the number of rows affected.
///
/// The instance to execute on.
/// The command text to execute.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the number of rows affected.
public static async Task ExecuteNonQueryAsync(this SqliteCommand self, string? cmdtext, CancellationToken cancellationToken)
{
return await ExecuteNonQueryAsync(self, true, cmdtext, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the number of rows affected.
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the number of rows affected.
public static async Task ExecuteNonQueryAsync(this SqliteCommand self, string cmd, Dictionary values, CancellationToken cancellationToken)
{
return await ExecuteNonQueryAsync(self, true, cmd, values, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the number of rows affected.
/// This method bypasses logging unless explicitly activated to avoid slowdowns caused by logging.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the number of rows affected.
public static Task ExecuteNonQueryPerformanceSensitiveAsync(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
{
if (!writeLog)
return self.ExecuteNonQueryAsync(cancellationToken);
return ExecuteNonQueryAsync(self, writeLog, cancellationToken);
}
///
/// Executes the command asynchronously and returns the number of rows affected.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the number of rows affected.
public static async Task ExecuteNonQueryAsync(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
{
return await ExecuteNonQueryAsync(self, writeLog, null, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the number of rows affected.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the number of rows affected.
public static async Task ExecuteNonQueryAsync(this SqliteCommand self, bool writeLog, string? cmd, Dictionary? values, CancellationToken cancellationToken)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteNonQueryAsync"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteNonQueryAsync", string.Format("ExecuteNonQueryAsync: {0}", self.GetPrintableCommandText())) : null)
return await self.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns a .
///
/// The instance to execute on.
/// The command text to execute.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the .
public static async Task ExecuteReaderAsync(this SqliteCommand self, string cmdtext, CancellationToken cancellationToken)
{
return await ExecuteReaderAsync(self, true, cmdtext, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns a .
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the .
public static async Task ExecuteReaderAsync(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
{
return await ExecuteReaderAsync(self, writeLog, null, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns a .
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the .
public static async Task ExecuteReaderAsync(this SqliteCommand self, string cmdtext, Dictionary? values, CancellationToken cancellationToken)
{
return await ExecuteReaderAsync(self, true, cmdtext, values, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns a .
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the .
public static async Task ExecuteReaderAsync(this SqliteCommand self, bool writeLog, string? cmdtext, Dictionary? values, CancellationToken cancellationToken)
{
if (cmdtext != null)
self.SetCommandAndParameters(cmdtext);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteReaderAsync"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteReader", string.Format("ExecuteReader: {0}", self.GetPrintableCommandText())) : null)
return await self.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns an enumerable of .
///
/// The instance to execute on.
/// Cancellation token to cancel the operation.
/// An asynchronous enumerable of .
public static IAsyncEnumerable ExecuteReaderEnumerableAsync(this SqliteCommand self, CancellationToken cancellationToken)
{
return ExecuteReaderEnumerableAsync(self, true, null, null, cancellationToken);
}
///
/// Executes the command asynchronously and returns an enumerable of .
///
/// The instance to execute on.
/// The command text to execute.
/// Cancellation token to cancel the operation.
/// An asynchronous enumerable of .
public static IAsyncEnumerable ExecuteReaderEnumerableAsync(this SqliteCommand self, string cmdtext, CancellationToken cancellationToken)
{
return ExecuteReaderEnumerableAsync(self, true, cmdtext, null, cancellationToken);
}
///
/// Executes the command asynchronously and returns an enumerable of .
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// Cancellation token to cancel the operation.
/// An asynchronous enumerable of .
public static IAsyncEnumerable ExecuteReaderEnumerableAsync(this SqliteCommand self, string cmdtext, Dictionary? values, CancellationToken cancellationToken)
{
return ExecuteReaderEnumerableAsync(self, true, cmdtext, values, cancellationToken);
}
///
/// Executes the command asynchronously and returns an enumerable of .
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// An asynchronous enumerable of .
public static async IAsyncEnumerable ExecuteReaderEnumerableAsync(this SqliteCommand self, bool writeLog, string? cmdtext, Dictionary? values, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
{
if (cmdtext != null)
self.SetCommandAndParameters(cmdtext);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteReaderEnumerableAsync"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteReaderEnumerableAsync", $"ExecuteReaderEnumerableAsync: {self.GetPrintableCommandText()}") : null)
await using (var rd = await self.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
while (await rd.ReadAsync(cancellationToken).ConfigureAwait(false))
yield return rd;
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set.
///
/// The instance to execute on.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set, or null if no rows are returned.
public static async Task ExecuteScalarAsync(this SqliteCommand self, CancellationToken cancellationToken)
{
return await self.ExecuteScalarAsync(true, null, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set.
///
/// The instance to execute on.
/// The command text to execute.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set, or null if no rows are returned.
public static async Task ExecuteScalarAsync(this SqliteCommand self, string cmdtext, CancellationToken cancellationToken)
{
return await self.ExecuteScalarAsync(true, cmdtext, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set, or null if no rows are returned.
public static async Task ExecuteScalarAsync(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
{
return await self.ExecuteScalarAsync(writeLog, null, null, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set.
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set, or null if no rows are returned.
public static async Task ExecuteScalarAsync(this SqliteCommand self, string cmdtext, Dictionary? values, CancellationToken cancellationToken)
{
return await self.ExecuteScalarAsync(true, cmdtext, values, cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set, or null if no rows are returned.
public static async Task ExecuteScalarAsync(this SqliteCommand self, bool writeLog, string? cmd, Dictionary? values, CancellationToken cancellationToken)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteScalarAsync"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteScalarAsync", string.Format("ExecuteScalarAsync: {0}", self.GetPrintableCommandText())) : null)
return await self.ExecuteScalarAsync(cancellationToken)
.ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or -1 if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, null, null, -1, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// The default value to return if no rows are returned or the value cannot be converted.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or -1 if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, long defaultvalue, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, null, null, defaultvalue, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or -1 if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, writeLog, null, null, -1, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static async Task ExecuteScalarInt64PerformanceSensitiveAsync(this SqliteCommand self, bool writeLog, CancellationToken cancellationToken)
{
if (!writeLog)
{
await using (var rd = await self.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
if (await rd.ReadAsync(cancellationToken).ConfigureAwait(false))
return ConvertValueToInt64(rd, 0, -1);
return -1;
}
return await ExecuteScalarInt64Async(self, writeLog, null, null, cancellationToken).ConfigureAwait(false);
}
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The default value to return if no rows are returned or the value cannot be converted.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, bool writeLog, long defaultvalue, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, writeLog, null, null, defaultvalue, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// The command text to execute.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, string? cmd, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, cmd, null, -1, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// The command text to execute.
/// The default value to return if no rows are returned or the value cannot be converted.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, string? cmd, long defaultvalue, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, cmd, null, defaultvalue, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, string? cmd, Dictionary? values, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, cmd, values, -1, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// The command text to execute.
/// The values to use as parameters.
/// The default value to return if no rows are returned or the value cannot be converted.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, string? cmd, Dictionary? values, long defaultvalue, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, true, cmd, values, defaultvalue, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static Task ExecuteScalarInt64Async(this SqliteCommand self, bool writeLog, string? cmd, Dictionary? values, CancellationToken cancellationToken)
=> ExecuteScalarInt64Async(self, writeLog, cmd, values, -1, cancellationToken);
///
/// Executes the command asynchronously and returns the first column of the first row in the result set as an Int64.
///
/// The instance to execute on.
/// Whether to write a log entry.
/// The command text to execute.
/// The values to set as parameters.
/// The default value to return if no rows are returned or the value cannot be converted.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the first column of the first row in the result set as an Int64, or the default value if no rows are returned or the value cannot be converted.
public static async Task ExecuteScalarInt64Async(this SqliteCommand self, bool writeLog, string? cmd, Dictionary? values, long defaultvalue, CancellationToken cancellationToken)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteScalarInt64Async"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteScalarInt64Async", string.Format("ExecuteScalarInt64Async: {0}", self.GetPrintableCommandText())) : null)
await using (var rd = await self.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
if (await rd.ReadAsync(cancellationToken).ConfigureAwait(false))
return ConvertValueToInt64(rd, 0, defaultvalue);
return defaultvalue;
}
///
/// Expands an IN clause parameter in a SqliteCommand by replacing the parameter with multiple parameters for each value in the collection.
///
/// The to expand the IN clause parameter for.
/// The name of the original parameter to replace, must start with '@'.
/// The collection of values to expand the IN clause with.
/// The type of the values in the collection.
/// The modified with the IN clause expanded.
public static SqliteCommand ExpandInClauseParameterMssqlite(this SqliteCommand cmd, string originalParamName, IEnumerable values)
{
if (string.IsNullOrWhiteSpace(originalParamName) || !originalParamName.StartsWith("@"))
throw new ArgumentException("Parameter name must start with '@'", nameof(originalParamName));
foreach (var p in cmd.Parameters)
if (p is IDataParameter parameter && parameter.ParameterName.Equals(originalParamName, StringComparison.OrdinalIgnoreCase))
{
cmd.Parameters.Remove(parameter);
break;
}
var inClause = string.Join(", ", values.Select((value, index) =>
{
var param_name = Library.Utility.Utility.FormatInvariantFormattable($"{originalParamName}{index}");
cmd.AddNamedParameter(param_name, value);
return param_name;
}));
if (string.IsNullOrWhiteSpace(inClause) && values.Any())
throw new ArgumentException("IN clause cannot be empty", nameof(values));
#if DEBUG
if (!cmd.CommandText.Contains(originalParamName, StringComparison.OrdinalIgnoreCase))
throw new ArgumentException($"Command text does not contain parameter '{originalParamName}'", nameof(originalParamName));
#endif
cmd.CommandText = cmd.CommandText.Replace(originalParamName, inClause, StringComparison.OrdinalIgnoreCase);
return cmd;
}
///
/// Expands an IN clause parameter in a SqliteCommand by replacing the parameter with multiple parameters for each value in the collection.
/// If a temporary table is used, it replaces the parameter with the table name.
///
/// The to expand the IN clause parameter for.
/// The name of the original parameter to replace, must start with '@'.
/// The collection of values to expand the IN clause with.
/// Cancellation token to cancel the operation.
/// A task that when awaited contains the modified with the IN clause expanded.
internal static async Task ExpandInClauseParameterMssqliteAsync(this SqliteCommand cmd, string originalParamName, TemporaryDbValueList values, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(originalParamName) || !originalParamName.StartsWith("@"))
throw new ArgumentException("Parameter name must start with '@'", nameof(originalParamName));
if (!values.IsTableCreated)
return ExpandInClauseParameterMssqlite(cmd, originalParamName, values.Values);
// We have a temporary table, so we need to replace the parameter with the table name
cmd.CommandText = cmd.CommandText.Replace(
originalParamName,
await values.GetInClauseAsync(cancellationToken).ConfigureAwait(false),
StringComparison.OrdinalIgnoreCase
);
return cmd;
}
///
/// Sets the command text and parameters for the given .
///
/// The to set the command text and parameters for.
/// The command text to set for the command, must not contain '?' as a parameter placeholder.
/// The modified with the command text and parameters set.
/// If the command text contains '?' as a parameter placeholder.
public static SqliteCommand SetCommandAndParameters(this SqliteCommand cmd, string cmdtext)
{
cmd.CommandText = cmdtext;
cmd.Parameters.Clear();
#if DEBUG
if (cmd.CommandText.Contains('?', StringComparison.OrdinalIgnoreCase))
throw new ArgumentException("Command text cannot contain '?' as a parameter placeholder, use '@' instead.", nameof(cmdtext));
#endif
var parameters = MyRegex().Matches(cmdtext);
var found = new HashSet(StringComparer.OrdinalIgnoreCase);
foreach (Match match in parameters)
{
if (found.Contains(match.Value))
continue;
found.Add(match.Value);
cmd.AddNamedParameter(match.Value);
}
return cmd;
}
///
/// Sets the value of a parameter in the command.
///
/// The to set the parameter value for.
/// The name of the parameter to set the value for.
/// The value to set for the parameter, or null to set it to DBNull.Value.
/// The with the parameter value set.
public static SqliteCommand SetParameterValue(this SqliteCommand self, string name, object? value)
{
#if DEBUG
if (value is not null && value is System.Collections.IEnumerable && value is not string)
throw new ArgumentException($"Cannot set parameter '{name}' to an array or enumerable type, as the SQLite bindings does not support it.", nameof(value));
#endif
self.Parameters[name].Value = value ?? DBNull.Value;
return self;
}
// Special case for DateTime, as we need to convert it to a long
///
/// Sets the value of a DateTime parameter in the command.
///
/// The to set the parameter value for.
/// The name of the parameter to set the value for.
/// The DateTime value to set for the parameter.
/// The with the parameter value set.
public static SqliteCommand SetParameterValue(this SqliteCommand self, string name, DateTime value)
{
self.Parameters[name].Value = Library.Utility.Utility.NormalizeDateTimeToEpochSeconds(value);
return self;
}
///
/// Sets the parameter values for the command, the parameters must already be added.
///
/// The to set the parameter values for.
/// The values to set the parameters to, where the key is the parameter name.
/// The with the parameter values set.
public static SqliteCommand SetParameterValues(this SqliteCommand self, Dictionary values)
{
foreach (var kvp in values)
self.Parameters[kvp.Key].Value = kvp.Value ?? DBNull.Value;
return self;
}
///
/// Sets the transaction for the command.
///
/// The to set the transaction for.
/// The to set for the command.
/// The with the transaction set.
public static SqliteCommand SetTransaction(this SqliteCommand self, SqliteTransaction transaction)
{
self.Transaction = transaction;
return self;
}
///
/// Sets the transaction for the command using a .
///
/// The to set the transaction for.
/// The to set for the command.
/// The with the transaction set.
internal static SqliteCommand SetTransaction(this SqliteCommand self, ReusableTransaction rtr)
{
self.Transaction = rtr.Transaction;
return self;
}
///
/// The tag used for logging
///
private static readonly string LOGTAG = Logging.Log.LogTagFromType(typeof(ExtensionMethods));
// This regex matches named parameters in the form of @paramName
[GeneratedRegex(@"@\w+")]
private static partial Regex MyRegex();
///
/// Adds a parameter to the command with the given value.
///
/// The type of the command
/// The command to add the parameter to
/// The name of the parameter
/// The optional value of the parameter
/// The command with the parameter added
public static SqliteCommand AddNamedParameter(this SqliteCommand self, string name, object? value = null)
{
var p = self.CreateParameter();
p.ParameterName = name;
if (value != null)
p.Value = value;
self.Parameters.Add(p);
return self;
}
// TODO At some point, when the entire codebase is migrated to
// Microsoft.Data.Sqlite, the extension methods using IDb* should be
// removed. Currently, they're kept for compatibility.
///
/// Adds a named parameter to the command with the given value.
///
/// The command to add the parameter to
/// The name of the parameter
/// The optional value of the parameter
/// The command with the parameter added
public static IDbCommand AddNamedParameter(this IDbCommand self, string name, object? value = null)
{
var p = self.CreateParameter();
p.ParameterName = name;
if (value != null)
p.Value = value;
self.Parameters.Add(p);
return self;
}
///
/// Sets the parameter values for the command, the parameters must already be added.
///
/// The type of the command
/// The command to set the parameter values for
/// The values to set the parameters to
/// The command with the parameter values set
public static T SetParameterValues(this T self, Dictionary values)
where T : IDbCommand
{
foreach (var kvp in values)
((IDataParameter)self.Parameters[kvp.Key]!).Value = kvp.Value ?? DBNull.Value;
return self;
}
///
/// Sets the parameter value for the command at the given index.
///
/// The type of the command
/// The command to set the parameter value for
/// The name of the parameter to set the value for
/// The value to set the parameter to
/// The command with the parameter value set
public static T SetParameterValue(this T self, string name, object? value)
where T : IDbCommand
{
#if DEBUG
if (value is not null && value is System.Collections.IEnumerable && value is not string)
throw new ArgumentException($"Cannot set parameter '{name}' to an array or enumerable type, as the SQLite bindings does not support it.", nameof(value));
#endif
((IDataParameter)self.Parameters[name]!).Value = value ?? DBNull.Value;
return self;
}
///
/// Gets the printable command text for the given command.
/// The command to get the printable command text for
/// The printable command text
public static string GetPrintableCommandText(this IDbCommand self)
{
var txt = self.CommandText;
// Replace each named parameter with its value
foreach (IDataParameter p in self.Parameters)
{
var paramName = p.ParameterName;
if (string.IsNullOrEmpty(paramName))
continue;
string v;
if (p.Value == null || p.Value == DBNull.Value)
v = "NULL";
else if (p.Value is string)
v = Library.Utility.Utility.FormatInvariantFormattable($"\"{p.Value}\"");
else if (p.Value is DateTime dt)
v = Library.Utility.Utility.FormatInvariantFormattable($"\"{dt:O}\"");
else if (p.Value is byte[] bytes)
v = Library.Utility.Utility.FormatInvariantFormattable($"X'{BitConverter.ToString(bytes).Replace("-", "")}'");
else
v = Library.Utility.Utility.FormatInvariantValue(p.Value);
paramName = Regex.Escape(paramName);
v = v.Replace("$", "$$");
// Replace all occurrences of the parameter (with word boundary)
txt = Regex.Replace(txt, $@"\B{paramName}\b", v, RegexOptions.IgnoreCase);
}
return txt;
}
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, bool writeLog)
{
return ExecuteNonQuery(self, writeLog, null);
}
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// The command string to execute
/// The values to use as parameters. The parameters must already be added.
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, string cmd)
=> ExecuteNonQuery(self, true, cmd);
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// The command string to execute
/// The values to use as parameters. The parameters must already be added.
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, string cmd, Dictionary values)
=> ExecuteNonQuery(self, true, cmd, values);
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// The values to use as parameters. The parameters must already be added.
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, bool writeLog, string? cmd, Dictionary values)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteNonQuery"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteNonQuery", string.Format("ExecuteNonQuery: {0}", self.GetPrintableCommandText())) : null)
return self.ExecuteNonQuery();
}
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, bool writeLog, string? cmd)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
using (SlowQueryMonitor.StartQuery(self, "ExecuteNonQuery"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteNonQuery", string.Format("ExecuteNonQuery: {0}", self.GetPrintableCommandText())) : null)
return self.ExecuteNonQuery();
}
///
/// Executes the command and returns the number of rows affected.
///
/// The command instance to execute on
/// The transaction to use for the command
/// The number of rows affected
public static int ExecuteNonQuery(this IDbCommand self, IDbTransaction? transaction)
{
using var _ = SlowQueryMonitor.StartQuery(self, "ExecuteNonQuery");
self.Transaction = transaction;
return self.ExecuteNonQuery();
}
///
/// Executes the command and returns the scalar value of the first row.
///
/// The command instance to execute on
/// The command string to execute
/// The scalar value of the first row
public static object? ExecuteScalar(this IDbCommand self, string cmd)
=> ExecuteScalar(self, true, cmd);
///
/// Executes the command and returns the scalar value of the first row.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// The scalar value of the first row
public static object? ExecuteScalar(this IDbCommand self, bool writeLog, string? cmd)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
using (SlowQueryMonitor.StartQuery(self, "ExecuteScalar"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteScalar", string.Format("ExecuteScalar: {0}", self.GetPrintableCommandText())) : null)
return self.ExecuteScalar();
}
///
/// Executes the command and returns the scalar int64 value of the first row as a string.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The default value to return if no value is found
/// The scalar int64 value of the first row as a string
public static long ExecuteScalarInt64(this IDbCommand self, bool writeLog, long defaultvalue = -1)
=> ExecuteScalarInt64(self, writeLog, null, defaultvalue);
///
/// Executes the command and returns the scalar int64 value of the first row as a string.
///
/// The command instance to execute on
/// The default value to return if no value is found
/// The scalar int64 value of the first row as a string
public static long ExecuteScalarInt64(this IDbCommand self, long defaultvalue = -1)
=> ExecuteScalarInt64(self, true, null, defaultvalue);
///
/// Executes the command and returns the scalar int64 value of the first row as a string.
///
/// The command instance to execute on
/// The transaction to use for the command
/// The default value to return if no value is found
/// The scalar int64 value of the first row as a string
public static long ExecuteScalarInt64(this IDbCommand self, IDbTransaction? transaction, long defaultvalue = -1)
{
self.Transaction = transaction;
return ExecuteScalarInt64(self, true, null, defaultvalue);
}
///
/// Executes the command and returns the scalar int64 value of the first row as a string.
///
/// The command instance to execute on
/// The command string to execute
/// The default value to return if no value is found
/// The scalar int64 value of the first row as a string
public static long ExecuteScalarInt64(this IDbCommand self, string? cmd, long defaultvalue = -1)
=> ExecuteScalarInt64(self, true, cmd, defaultvalue);
///
/// Executes the command and returns the scalar int64 value of the first row as a string.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// The default value to return if no value is found
/// The scalar int64 value of the first row as a string
public static long ExecuteScalarInt64(this IDbCommand self, bool writeLog, string? cmd, long defaultvalue)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
using (SlowQueryMonitor.StartQuery(self, "ExecuteScalarInt64"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteScalarInt64", string.Format("ExecuteScalarInt64: {0}", self.GetPrintableCommandText())) : null)
using (var rd = self.ExecuteReader())
if (rd.Read())
return ConvertValueToInt64(rd, 0, defaultvalue);
return defaultvalue;
}
///
/// Executes the command and returns a data reader.
///
/// The command instance to execute on
/// The command string to execute
/// The values to use as parameters. The parameters must already be added.
/// A instance
public static IDataReader ExecuteReader(this IDbCommand self, string cmd, Dictionary? values)
=> ExecuteReader(self, true, cmd, values);
///
/// Executes the command and returns a data reader.
///
/// The command instance to execute on
/// The command string to execute
/// A instance
public static IDataReader ExecuteReader(this IDbCommand self, string cmd)
=> ExecuteReader(self, true, cmd);
///
/// Executes the command and returns a data reader.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// A instance
public static IDataReader ExecuteReader(this IDbCommand self, bool writeLog, string? cmd)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
using (SlowQueryMonitor.StartQuery(self, "ExecuteReader"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteReader", string.Format("ExecuteReader: {0}", self.GetPrintableCommandText())) : null)
return self.ExecuteReader();
}
///
/// Executes the command and returns a data reader.
///
/// The command instance to execute on
/// Whether to write a log entry
/// The command string to execute
/// The values to use as parameters. The parameters must already be added.
/// A instance
public static IDataReader ExecuteReader(this IDbCommand self, bool writeLog, string? cmd, Dictionary? values)
{
if (cmd != null)
self.SetCommandAndParameters(cmd);
if (values != null && values.Count > 0)
self.SetParameterValues(values);
using (SlowQueryMonitor.StartQuery(self, "ExecuteReader"))
using (writeLog ? new Logging.Timer(LOGTAG, "ExecuteReader", string.Format("ExecuteReader: {0}", self.GetPrintableCommandText())) : null)
return self.ExecuteReader();
}
///
/// Executes the given command string `cmd` on the given database command `self` with the given values `values` and returns an enumerable of data readers.
///
/// The database command to execute on.
/// Whether to write a log entry.
/// The command string to execute.
/// An enumerable of data readers.
public static IEnumerable ExecuteReaderEnumerable(this IDbCommand self, bool writeLog, string? cmd)
{
using (var rd = ExecuteReader(self, writeLog, cmd))
while (rd.Read())
yield return rd;
}
///
/// Executes the given command string `cmd` on the given database command `self` and returns an enumerable of data readers.
///
/// The database command to execute on.
/// The command string to execute.
/// An enumerable of data readers.
public static IEnumerable ExecuteReaderEnumerable(this IDbCommand self, string cmd)
=> ExecuteReaderEnumerable(self, true, cmd);
///
/// Executes the current command string on the given database command `self` and returns an enumerable of data readers.
///
/// The database command to execute on.
/// An enumerable of data readers.
public static IEnumerable ExecuteReaderEnumerable(this IDbCommand self)
=> ExecuteReaderEnumerable(self, true, null);
///
/// Converts the value at the given index of the given data reader to a string.
///
/// The data reader to convert the value from.
/// The index of the value to convert.
/// The value at the given index as a string.
public static string? ConvertValueToString(this IDataReader reader, int index)
{
var v = reader.GetValue(index);
if (v == null || v == DBNull.Value)
return null;
return v.ToString();
}
///
/// Converts the value at the given index of the given data reader to a long.
///
/// The data reader to convert the value from.
/// The index of the value to convert.
/// The default value to return if the value is null or cannot be converted.
/// The value at the given index as a long.
public static long ConvertValueToInt64(this IDataReader reader, int index, long defaultvalue = -1)
{
try
{
if (!reader.IsDBNull(index))
return reader.GetInt64(index);
}
catch
{
}
return defaultvalue;
}
///
/// Creates a command with the given transaction.
///
/// The connection to create the command on.
/// The transaction to use for the command.
/// The command string to create the command with.
/// A new command with the given transaction.
public static IDbCommand CreateCommand(this IDbConnection self, IDbTransaction? transaction, string? cmdtext = null)
{
var cmd = self.CreateCommand();
cmd.Transaction = transaction;
if (!string.IsNullOrEmpty(cmdtext))
cmd.SetCommandAndParameters(cmdtext);
return cmd;
}
///
/// Sets the command text and adds parameters to the command.
///
/// The command to set the command text and add parameters to.
/// The transaction to use for the command.
/// The command text to set.
/// The command with the command text set and parameters added.
public static IDbCommand SetCommandAndParameters(this IDbCommand cmd, IDbTransaction transaction, string cmdtext)
{
cmd.Transaction = transaction;
return cmd.SetCommandAndParameters(cmdtext);
}
///
/// Sets the command text and adds parameters to the command.
///
/// The command to set the command text and add parameters to.
/// The command text to set.
/// The command with the command text set and parameters added.
public static IDbCommand SetCommandAndParameters(this IDbCommand cmd, string cmdtext)
{
cmd.CommandText = cmdtext;
cmd.Parameters.Clear();
#if DEBUG
if (cmd.CommandText.Contains("?", StringComparison.OrdinalIgnoreCase))
throw new ArgumentException("Command text cannot contain '?' as a parameter placeholder, use '@' instead.", nameof(cmdtext));
#endif
var parameters = Regex.Matches(cmdtext, @"@\w+");
var found = new HashSet(StringComparer.OrdinalIgnoreCase);
foreach (Match match in parameters)
{
if (found.Contains(match.Value))
continue;
found.Add(match.Value);
cmd.AddNamedParameter(match.Value);
}
return cmd;
}
///
/// Creates a command with the given command string, and adds parameters to fit the input
///
/// The connection to create the command on
/// The command string to create the command with
/// The command with the parameters added
public static IDbCommand CreateCommand(this IDbConnection self, string cmdtext)
=> CreateCommand(self, null, cmdtext);
///
/// Expands the given parameter name to a list of parameters for an IN clause.
///
/// The type of the command
/// The type of the values
/// The command to expand the parameter for
/// The original parameter name to expand
/// The values to expand the parameter for
public static IDbCommand ExpandInClauseParameter(this IDbCommand cmd, string originalParamName, IEnumerable values)
{
if (string.IsNullOrWhiteSpace(originalParamName) || !originalParamName.StartsWith("@"))
throw new ArgumentException("Parameter name must start with '@'", nameof(originalParamName));
foreach (var p in cmd.Parameters)
if (p is IDataParameter parameter && parameter.ParameterName.Equals(originalParamName, StringComparison.OrdinalIgnoreCase))
{
cmd.Parameters.Remove(parameter);
break;
}
var inClause = string.Join(", ", values.Select((value, index) =>
{
var param_name = Library.Utility.Utility.FormatInvariantFormattable($"{originalParamName}{index}");
cmd.AddNamedParameter(param_name, value);
return param_name;
}));
if (string.IsNullOrWhiteSpace(inClause) && values.Any())
throw new ArgumentException("IN clause cannot be empty", nameof(values));
#if DEBUG
if (!cmd.CommandText.Contains(originalParamName, StringComparison.OrdinalIgnoreCase))
throw new ArgumentException($"Command text does not contain parameter '{originalParamName}'", nameof(originalParamName));
#endif
cmd.CommandText = cmd.CommandText.Replace(originalParamName, inClause, StringComparison.OrdinalIgnoreCase);
return cmd;
}
///
/// Expands the given parameter name to a list of parameters for an IN clause.
///
/// The type of the command
/// The command to expand the parameter for
/// The original parameter name to expand
/// The values to expand the parameter for
internal static IDbCommand ExpandInClauseParameter(this IDbCommand cmd, string originalParamName, TemporaryDbValueList values)
{
if (string.IsNullOrWhiteSpace(originalParamName) || !originalParamName.StartsWith("@"))
throw new ArgumentException("Parameter name must start with '@'", nameof(originalParamName));
if (!values.IsTableCreated)
return ExpandInClauseParameter(cmd, originalParamName, values.Values);
// We have a temporary table, so we need to replace the parameter with the table name
cmd.CommandText = cmd.CommandText.Replace(originalParamName, values.GetInClauseAsync(default).Await(), StringComparison.OrdinalIgnoreCase);
return cmd;
}
}