fix: adjust benchmark parameters

Author: SockworkOrange

Drivers/SqliteDriver.cs

@@ -273,7 +273,7 @@ public override CommandGenCommands CreateSqlCommand(string sqlTextConstant)
                 $"var {commandVar} = new SqliteCommand({sqlTextConstant}, {Variable.Connection.AsVarName()})",
                 true),
             SetCommandText: string.Empty,
-            PrepareCommand: $"{commandVar}.Prepare()"
+            PrepareCommand: string.Empty
         );
     }
 

benchmark/BenchmarkRunner/Benchmarks/BaseReadBenchmark.cs

@@ -3,11 +3,7 @@
 
 public abstract class BaseReadBenchmark
 {
-    [Params(1000)]
-    public int QueriesToRun { get; set; }
-
-    [Params(500)]
-    public int CustomerCount { get; set; }
+    protected const int CustomerCount = 500;
 
     [Params(100, 500)]
     public int Limit { get; set; }

benchmark/BenchmarkRunner/Benchmarks/BaseWriteBenchmark.cs

@@ -4,6 +4,9 @@ public abstract class BaseWriteBenchmark
 {
     [Params(2000000)]
     public int TotalRecords { get; set; }
+
+    [Params(500)]
+    public int EFCoreBatchSize { get; set; }
     public abstract Task Sqlc_AddOrderItems();
     public abstract Task EFCore_AddOrderItems();
 }

benchmark/BenchmarkRunner/Benchmarks/MysqlReadBenchmark.cs

@@ -17,7 +17,10 @@ public class MysqlReadBenchmark : BaseReadBenchmark
     private static readonly string _connectionString = Config.GetMysqlConnectionString();
     private readonly QuerySql _sqlcImpl = new(_connectionString);
 
-    [Params(25, 100, 200)]
+    [Params(3000)]
+    public int QueriesToRun { get; set; }
+
+    [Params(200, 500)]
     public int ConcurrentQueries { get; set; }
 
     [BenchmarkCategory("Read")]

benchmark/BenchmarkRunner/Benchmarks/MysqlWriteBenchmark.cs

@@ -22,16 +22,16 @@ public class MysqlWriteBenchmark : BaseWriteBenchmark
 
     /// <summary>
     /// MySQL batch size can be very large yet very performant in SQLC implementation due to 
-    /// CSV load usage, so we wish to examine exceptionally large batches as well.
+    /// CSV load usage, so we wish to examine exceptionally large batches.
     /// </summary>
-    [Params(500, 1000, 2000)]
-    public int BatchSize { get; set; }
+    [Params(1000, 5000, 20000)]
+    public int SqlcBatchSize { get; set; }
 
     [BenchmarkCategory("Write")]
     [Benchmark(Baseline = true, Description = "SQLC - AddOrderItems")]
     public override async Task Sqlc_AddOrderItems()
     {
-        await Helpers.InsertInBatchesAsync(_testOrderItems, BatchSize, _sqlcImpl.AddOrderItemsAsync);
+        await Helpers.InsertInBatchesAsync(_testOrderItems, SqlcBatchSize, _sqlcImpl.AddOrderItemsAsync);
     }
 
     [BenchmarkCategory("Write")]
@@ -41,7 +41,7 @@ public override async Task EFCore_AddOrderItems()
         var args = _testOrderItems.Select(i => new Queries.AddOrderItemsArgs(
             i.OrderId, i.ProductId, i.Quantity, i.UnitPrice
         )).ToList();
-        await Helpers.InsertInBatchesAsync(args, BatchSize, _efCoreImpl.AddOrderItems);
+        await Helpers.InsertInBatchesAsync(args, EFCoreBatchSize, _efCoreImpl.AddOrderItems);
     }
 
     public static Func<Task> GetSeedMethod()

benchmark/BenchmarkRunner/Benchmarks/PostgresqlReadBenchmark.cs

@@ -17,7 +17,10 @@ public class PostgresqlReadBenchmark : BaseReadBenchmark
     private static readonly string _connectionString = Config.GetPostgresConnectionString();
     private readonly QuerySql _sqlcImpl = new(_connectionString);
 
-    [Params(10, 20, 50)]
+    [Params(1000)]
+    public int QueriesToRun { get; set; }
+    
+    [Params(20, 50)]
     public int ConcurrentQueries { get; set; }
 
     [BenchmarkCategory("Read")]

benchmark/BenchmarkRunner/Benchmarks/PostgresqlWriteBenchmark.cs

@@ -20,16 +20,16 @@ public class PostgresqlWriteBenchmark : BaseWriteBenchmark
     private List<QuerySql.AddOrderItemsArgs> _testOrderItems = null!;
 
     /// <summary>
-    /// PostgreSQL batch size can be larger in SQLC implementation due to using binary import.
+    /// PostgreSQL batch size can be larger in SQLC implementation due to using COPY FROM syntax.
     /// </summary>
-    [Params(200, 500, 1000)]
-    public int BatchSize { get; set; }
+    [Params(500, 1000)]
+    public int SqlcBatchSize { get; set; }
 
     [BenchmarkCategory("Write")]
     [Benchmark(Baseline = true, Description = "SQLC - AddOrderItems")]
     public override async Task Sqlc_AddOrderItems()
     {
-        await Helpers.InsertInBatchesAsync(_testOrderItems, BatchSize, _sqlcImpl.AddOrderItemsAsync);
+        await Helpers.InsertInBatchesAsync(_testOrderItems, SqlcBatchSize, _sqlcImpl.AddOrderItemsAsync);
     }
 
     [BenchmarkCategory("Write")]
@@ -39,7 +39,7 @@ public override async Task EFCore_AddOrderItems()
         var args = _testOrderItems.Select(i => new Queries.AddOrderItemsArgs(
             i.OrderId, i.ProductId, i.Quantity, i.UnitPrice
         )).ToList();
-        await Helpers.InsertInBatchesAsync(args, BatchSize, _efCoreImpl.AddOrderItems);
+        await Helpers.InsertInBatchesAsync(args, EFCoreBatchSize, _efCoreImpl.AddOrderItems);
     }
 
     public static Func<Task> GetSeedMethod()

benchmark/BenchmarkRunner/Benchmarks/SqliteReadBenchmark.cs

@@ -3,7 +3,6 @@
 using BenchmarkDotNet.Jobs;
 using BenchmarkRunner.Utils;
 using EndToEndTests;
-using Microsoft.Data.Sqlite;
 using SqliteEFCoreImpl;
 using SqliteSqlcImpl;
 
@@ -19,10 +18,10 @@ public class SqliteReadBenchmark : BaseReadBenchmark
     private static readonly string _connectionString = Config.GetSqliteConnectionString();
     private readonly QuerySql _sqlcImpl = new(_connectionString);
 
-    /// <summary>
-    /// SQLite supports read concurrency, but less so then other relational databases.
-    /// </summary>
-    [Params(5, 10, 25)]
+    [Params(800)]
+    public int QueriesToRun { get; set; }
+    
+    [Params(10, 25)]
     public int ConcurrentQueries { get; set; }
 
     [BenchmarkCategory("Read")]
@@ -45,20 +44,13 @@ public override async Task EFCore_NoTracking_GetCustomerOrders()
     {
         await ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
-            try
-            {
-                await using var dbContext = new SalesDbContext(_connectionString);
-                var queries = new Queries(dbContext, useTracking: false);
-                return await queries.GetCustomerOrders(new Queries.GetCustomerOrdersArgs(
-                    CustomerId: Random.Shared.Next(1, CustomerCount),
-                    Offset: 0,
-                    Limit: Limit
-                ));
-            }
-            catch (SqliteException e)
-            {
-                throw new Exception($"Sqlite connection string: {_connectionString}, error: {e.Message}", e);
-            }
+            await using var dbContext = new SalesDbContext(_connectionString);
+            var queries = new Queries(dbContext, useTracking: false);
+            return await queries.GetCustomerOrders(new Queries.GetCustomerOrdersArgs(
+                CustomerId: Random.Shared.Next(1, CustomerCount),
+                Offset: 0,
+                Limit: Limit
+            ));
         });
     }
 
@@ -68,20 +60,13 @@ public override async Task EFCore_WithTracking_GetCustomerOrders()
     {
         await ExecuteConcurrentlyAsync(QueriesToRun, ConcurrentQueries, async _ =>
         {
-            try
-            {
-                await using var dbContext = new SalesDbContext(_connectionString);
-                var queries = new Queries(dbContext, useTracking: true);
-                return await queries.GetCustomerOrders(new Queries.GetCustomerOrdersArgs(
-                    CustomerId: Random.Shared.Next(1, CustomerCount),
-                    Offset: 0,
-                    Limit: Limit
-                ));
-            }
-            catch (SqliteException e)
-            {
-                throw new Exception($"Sqlite connection string: {_connectionString}, error: {e.Message}", e);
-            }
+            await using var dbContext = new SalesDbContext(_connectionString);
+            var queries = new Queries(dbContext, useTracking: true);
+            return await queries.GetCustomerOrders(new Queries.GetCustomerOrdersArgs(
+                CustomerId: Random.Shared.Next(1, CustomerCount),
+                Offset: 0,
+                Limit: Limit
+            ));
         });
     }
 

benchmark/BenchmarkRunner/Benchmarks/SqliteWriteBenchmark.cs

@@ -21,18 +21,17 @@ public class SqliteWriteBenchmark : BaseWriteBenchmark
     private List<QuerySql.AddOrderItemsArgs> _testOrderItems = null!;
 
     /// <summary>
-    /// SQLite batch size for SQLC can be large but due to the plugin implementation of batch inserts 
-    /// for SQLite, there is a limitation of 1000 bind variables in the resulting SQL.
+    /// SQLite batch size for SQLC there is a limitation of 1000 bind variables in the resulting SQL.
     /// e.g. If we insert to a table with 10 columns, the maximum batch size is 1000 / 10 = 100.
     /// </summary>
-    [Params(50, 100, 200)]
-    public int BatchSize { get; set; }
+    [Params(50, 100)]
+    public int SqlcBatchSize { get; set; }
 
     [BenchmarkCategory("Write")]
     [Benchmark(Baseline = true, Description = "SQLC - AddOrderItems")]
     public override async Task Sqlc_AddOrderItems()
     {
-        await Helpers.InsertInBatchesAsync(_testOrderItems, BatchSize, _sqlcImpl.AddOrderItemsAsync);
+        await Helpers.InsertInBatchesAsync(_testOrderItems, SqlcBatchSize, _sqlcImpl.AddOrderItemsAsync);
     }
 
     [BenchmarkCategory("Write")]
@@ -42,7 +41,7 @@ public override async Task EFCore_AddOrderItems()
         var args = _testOrderItems.Select(i => new Queries.AddOrderItemsArgs(
             i.OrderId, i.ProductId, i.Quantity, i.UnitPrice
         )).ToList();
-        await Helpers.InsertInBatchesAsync(args, BatchSize, _efCoreImpl.AddOrderItems);
+        await Helpers.InsertInBatchesAsync(args, EFCoreBatchSize, _efCoreImpl.AddOrderItems);
     }
 
     public static Func<Task> GetSeedMethod()

benchmark/BenchmarkRunner/Program.cs

@@ -1,4 +1,4 @@
-using System.CommandLine;
+using System.CommandLine;
 
 public class Program
 {