Add different benchmarks and tests

Author: faddiv

QueryBuilder.Benchmarks/Program.cs

@@ -3,6 +3,6 @@
 using BenchmarkDotNet.Running;
 using QueryBuilder.Benchmarks;
 
-SelectsBenchmark.Test();
+SelectsBenchmarkTests.TestAll();
 
 BenchmarkRunner.Run<SelectsBenchmark>();

QueryBuilder.Benchmarks/SelectsBenchmark.cs

@@ -10,58 +10,73 @@ namespace QueryBuilder.Benchmarks;
 [MemoryDiagnoser]
 public class SelectsBenchmark
 {
-    private Query query;
+    private Query selectSimple;
+    private Query selectGroupBy;
+    private Query selectWith;
 
     public Compiler compiler;
 
     [Params(
-        EngineCodes.Firebird,
-        EngineCodes.MySql,
-        EngineCodes.Oracle,
-        EngineCodes.PostgreSql,
-        EngineCodes.Sqlite,
         EngineCodes.SqlServer)]
     public string EngineCode { get; set; }
 
     [GlobalSetup]
     public void Setup()
     {
-        query = new Query("Products")
+        selectSimple = new Query("Products")
             .Select("ProductID", "ProductName", "SupplierID", "CategoryID", "UnitPrice", "UnitsInStock", "UnitsOnOrder",
                 "ReorderLevel", "Discontinued")
-            .WhereContains("ProductName", "Mascarpone")
+            .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 Select()
+    public SqlResult SelectSimple()
     {
-        return compiler.Compile(query);
+        return compiler.Compile(selectSimple);
     }
 
-    public static void Test()
+    [Benchmark]
+    public SqlResult SelectGroupBy()
+    {
+        return compiler.Compile(selectGroupBy);
+    }
+
+    [Benchmark]
+    public SqlResult SelectWith()
     {
-        var benchmark = new SelectsBenchmark();
-        benchmark.EngineCode = EngineCodes.SqlServer;
-        benchmark.Setup();
-        var result = benchmark.Select().ToString();
-        if (result !=
-            Regex.Replace("""
-            SELECT [ProductID], [ProductName], [SupplierID], [CategoryID], [UnitPrice], [UnitsInStock],
-                [UnitsOnOrder], [ReorderLevel], [Discontinued]
-            FROM [Products]
-            WHERE LOWER([ProductName]) like '%mascarpone%'
-                AND [UnitPrice] >= 10
-                AND [UnitPrice] <= 100
-            ORDER BY [UnitPrice], [ProductName] OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY
-            """, @"\s+", " "))
-        {
-            throw new ValidationException($"Invalid result: {result}");
-        }
+        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();
+}