SQLite.ParallelExecution.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace DBAClientX;

public partial class SQLite
{
    /// <summary>
    /// Executes a collection of SQL queries concurrently using independent connections.
    /// </summary>
    public async Task<IReadOnlyList<object?>> RunQueriesInParallel(
        IEnumerable<string> queries,
        string database,
        CancellationToken cancellationToken = default,
        int? maxDegreeOfParallelism = null)
    {
        if (queries == null)
        {
            throw new ArgumentNullException(nameof(queries));
        }

        var validatedQueries = new List<string>();
        var queryIndex = 0;
        foreach (var query in queries)
        {
            if (string.IsNullOrWhiteSpace(query))
            {
                throw new ArgumentException($"Query at index {queryIndex} cannot be null or whitespace.", nameof(queries));
            }

            validatedQueries.Add(query);
            queryIndex++;
        }

        var effectiveMaxDegreeOfParallelism = maxDegreeOfParallelism.HasValue && maxDegreeOfParallelism.Value > 0
            ? maxDegreeOfParallelism.Value
            : DefaultMaxParallelQueries;
        using var throttler = new SemaphoreSlim(effectiveMaxDegreeOfParallelism);

        var tasks = validatedQueries.Select(async q =>
        {
            await throttler.WaitAsync(cancellationToken).ConfigureAwait(false);

            try
            {
                return await QueryAsync(database, q, null, false, cancellationToken).ConfigureAwait(false);
            }
            finally
            {
                throttler.Release();
            }
        });

        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
        return results;
    }
}