Test Improvements & Benchmarks for SqlKata Compiler

QueryBuilder.Benchmarks/Infrastructure/TestCompiler.cs

@@ -0,0 +1,9 @@
+using SqlKata.Compilers;
+
+namespace QueryBuilder.Benchmarks.Infrastructure;
+
+public class TestCompiler
+    : Compiler
+{
+    public override string EngineCode { get; } = "generic";
+}

QueryBuilder.Benchmarks/Infrastructure/TestSupport.cs

@@ -0,0 +1,49 @@
+using SqlKata;
+using SqlKata.Compilers;
+
+namespace QueryBuilder.Benchmarks.Infrastructure;
+
+public class TestSupport
+{
+
+    public static SqlResult CompileFor(string engine, Query query, Func<Compiler, Compiler> configuration = null)
+    {
+        var compiler = CreateCompiler(engine);
+        if (configuration != null)
+        {
+            compiler = configuration(compiler);
+        }
+
+        return compiler.Compile(query);
+    }
+
+    public static SqlResult CompileFor(string engine, Query query, Action<Compiler> configuration)
+    {
+        return CompileFor(engine, query, compiler =>
+        {
+            configuration(compiler);
+            return compiler;
+        });
+    }
+
+    public static Compiler CreateCompiler(string engine)
+    {
+        return engine switch
+        {
+            EngineCodes.Firebird => new FirebirdCompiler(),
+            EngineCodes.MySql => new MySqlCompiler(),
+            EngineCodes.Oracle => new OracleCompiler
+            {
+                UseLegacyPagination = false
+            },
+            EngineCodes.PostgreSql => new PostgresCompiler(),
+            EngineCodes.Sqlite => new SqliteCompiler(),
+            EngineCodes.SqlServer => new SqlServerCompiler
+            {
+                UseLegacyPagination = false
+            },
+            EngineCodes.Generic => new TestCompiler(),
+            _ => throw new ArgumentException($"Unsupported engine type: {engine}", nameof(engine)),
+        };
+    }
+}

QueryBuilder.Benchmarks/Program.cs

@@ -0,0 +1,8 @@
+// See https://aka.ms/new-console-template for more information
+
+using BenchmarkDotNet.Running;
+using QueryBuilder.Benchmarks;
+
+SelectsBenchmarkTests.TestAll();
+
+BenchmarkRunner.Run<SelectsBenchmark>();

QueryBuilder.Benchmarks/QueryBuilder.Benchmarks.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\QueryBuilder\QueryBuilder.csproj" />
+  </ItemGroup>
+
+</Project>

QueryBuilder.Benchmarks/SelectsBenchmark.cs

@@ -0,0 +1,82 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.RegularExpressions;
+using BenchmarkDotNet.Attributes;
+using QueryBuilder.Benchmarks.Infrastructure;
+using SqlKata;
+using SqlKata.Compilers;
+
+namespace QueryBuilder.Benchmarks;
+
+[MemoryDiagnoser]
+public class SelectsBenchmark
+{
+    private Query selectSimple;
+    private Query selectGroupBy;
+    private Query selectWith;
+
+    public Compiler compiler;
+
+    [Params(
+        EngineCodes.SqlServer)]
+    public string EngineCode { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        selectSimple = new Query("Products")
+            .Select("ProductID", "ProductName", "SupplierID", "CategoryID", "UnitPrice", "UnitsInStock", "UnitsOnOrder",
+                "ReorderLevel", "Discontinued")
+            .WhereIn("CategoryID", [1, 2, 3])
+            .Where("SupplierID", 5)
+            .Where("UnitPrice", ">=", 10)
+            .Where("UnitPrice", "<=", 100)
+            .Take(10)
+            .Skip(20)
+            .OrderBy("UnitPrice", "ProductName");
+
+
+        selectGroupBy = new Query("Products")
+            .Select("SupplierID", "CategoryID")
+            .SelectAvg("UnitPrice")
+            .SelectMin("UnitPrice")
+            .SelectMax("UnitPrice")
+            .Where("CategoryID", 123)
+            .GroupBy("SupplierID", "CategoryID")
+            .HavingRaw("MIN(UnitPrice) >= ?", 10)
+            .Take(10)
+            .Skip(20)
+            .OrderBy("SupplierID", "CategoryID");
+
+        var activePosts = new Query("Comments")
+            .Select("PostId")
+            .SelectRaw("count(1) as Count")
+            .GroupBy("PostId")
+            .HavingRaw("count(1) > 100");
+
+        selectWith = new Query("Posts")
+            .With("ActivePosts", activePosts)
+            .Join("ActivePosts", "ActivePosts.PostId", "Posts.Id")
+            .Select("Posts.*", "ActivePosts.Count");
+
+        compiler = TestSupport.CreateCompiler(EngineCode);
+    }
+
+    [Benchmark]
+    public SqlResult SelectSimple()
+    {
+        return compiler.Compile(selectSimple);
+    }
+
+    [Benchmark]
+    public SqlResult SelectGroupBy()
+    {
+        return compiler.Compile(selectGroupBy);
+    }
+
+    [Benchmark]
+    public SqlResult SelectWith()
+    {
+        return compiler.Compile(selectWith);
+    }
+
+}

QueryBuilder.Benchmarks/SelectsBenchmarkTests.cs

@@ -0,0 +1,95 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.RegularExpressions;
+using SqlKata;
+using SqlKata.Compilers;
+
+namespace QueryBuilder.Benchmarks;
+
+public static partial class SelectsBenchmarkTests
+{
+    public static void TestAll()
+    {
+        TestSelectSimple();
+        TestSelectGroupBy();
+        TestSelectWith();
+    }
+
+    public static void TestSelectSimple()
+    {
+        var benchmark = CreateBenchmark();
+
+        var result = benchmark.SelectSimple();
+
+        // language=SQL
+        ValidateResult(
+            """
+            SELECT [ProductID], [ProductName], [SupplierID], [CategoryID], [UnitPrice],
+                [UnitsInStock], [UnitsOnOrder], [ReorderLevel], [Discontinued]
+            FROM [Products]
+            WHERE [CategoryID] IN (1, 2, 3)
+              AND [SupplierID] = 5
+              AND [UnitPrice] >= 10
+              AND [UnitPrice] <= 100
+            ORDER BY [UnitPrice], [ProductName]
+            OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY
+            """, result);
+    }
+
+    public static void TestSelectGroupBy()
+    {
+        var benchmark = CreateBenchmark();
+
+        var result = benchmark.SelectGroupBy();
+
+        // language=SQL
+        ValidateResult(
+            """
+            SELECT [SupplierID], [CategoryID],
+                AVG([UnitPrice]), MIN([UnitPrice]), MAX([UnitPrice])
+            FROM [Products]
+            WHERE [CategoryID] = 123
+            GROUP BY [SupplierID], [CategoryID]
+            HAVING MIN(UnitPrice) >= 10
+            ORDER BY [SupplierID], [CategoryID]
+            OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY
+            """, result);
+    }
+
+    public static void TestSelectWith()
+    {
+        var benchmark = CreateBenchmark();
+
+        var result = benchmark.SelectWith();
+
+        // language=SQL
+        ValidateResult(
+            """
+            WITH [ActivePosts] AS (SELECT [PostId], count(1) as Count FROM [Comments] GROUP BY [PostId] HAVING count(1) > 100)
+            SELECT [Posts].*, [ActivePosts].[Count]
+            FROM [Posts]
+            INNER JOIN [ActivePosts] ON [ActivePosts].[PostId] = [Posts].[Id]
+            """, result);
+    }
+
+    private static SelectsBenchmark CreateBenchmark()
+    {
+        var benchmark = new SelectsBenchmark
+        {
+            EngineCode = EngineCodes.SqlServer
+        };
+        benchmark.Setup();
+        return benchmark;
+    }
+
+    private static void ValidateResult(string expected, SqlResult result)
+    {
+        var actual = result.ToString();
+        if (WhiteSpaces().Replace(actual, " ") != WhiteSpaces().Replace(expected, " "))
+        {
+            throw new ValidationException($"Invalid result: {actual}");
+        }
+    }
+
+    [GeneratedRegex(@"\s+")]
+    private static partial Regex WhiteSpaces();
+}