Approval tests

.editorconfig

@@ -2,7 +2,7 @@ root = true
 
 [*]
 charset = utf-8
-end_of_line = lf
+end_of_line = crlf
 # Note: the trim_trailing_whitespace option is br0ken in visualstudio, it
 # simply does not follow the EditorConfig specification. Therefor you are
 # strongly encouraged to not rely on this setting alone, but please install
@@ -16,13 +16,76 @@ end_of_line = lf
 trim_trailing_whitespace = true
 insert_final_newline = true
 indent_style = tab
-indent_size = 2
+indent_size = 4
 
 
 [*.cs] # To match existing style
 indent_style = space
 indent_size = 4
+csharp_indent_labels = no_change
+csharp_using_directive_placement = outside_namespace:silent
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_prefer_braces = true:silent
+csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_prefer_method_group_conversion = true:silent
+csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_style_expression_bodied_methods = false:silent
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:silent
+csharp_space_around_binary_operators = before_and_after
 
 
 [*.yml]
 indent_style = space
+
+[*.{cs,vb}]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4

.gitignore

@@ -276,3 +276,4 @@ __pycache__/
 
 # Thumbs
 Thumbs.db
+*.received.*

Program/Program.cs

@@ -1,59 +1,28 @@
 using System;
-using System.Collections.Generic;
-using SqlKata;
 using SqlKata.Compilers;
 using SqlKata.Execution;
-using System.Data.SqlClient;
-using System.Threading.Tasks;
-using System.Linq;
 using Newtonsoft.Json;
-using Npgsql;
-using System.Data;
-using Dapper;
 using System.Data.SQLite;
-using static SqlKata.Expressions;
 using System.IO;
 
 namespace Program
 {
     class Program
     {
-        private class Loan
+
+        static void Main()
         {
-            public string Id { get; set; }
-            public string Name { get; set; }
-            public List<Installment> Installments { get; set; } = new List<Installment>();
-        }
-
-        private class Installment
-        {
-            public string Id { get; set; }
-            public string LoanId { get; set; }
-            public int DaysCount { get; set; }
-        }
-
-        static void Main(string[] args)
-        {
-            using (var db = SqlLiteQueryFactory())
-            {
-                var query = db.Query("accounts")
-                    .Where("balance", ">", 0)
-                    .GroupBy("balance")
+            using var db = SqlLiteQueryFactory();
+            var query = db.Query("accounts")
+                .Where("balance", ">", 0)
+                .GroupBy("balance")
                 .Limit(10);
 
-                var accounts = query.Clone().Get();
-                Console.WriteLine(JsonConvert.SerializeObject(accounts, Formatting.Indented));
+            var accounts = query.Clone().Get();
+            Console.WriteLine(JsonConvert.SerializeObject(accounts, Formatting.Indented));
 
-                var exists = query.Clone().Exists();
-                Console.WriteLine(exists);
-            }
-        }
-
-        private static void log(Compiler compiler, Query query)
-        {
-            var compiled = compiler.Compile(query);
-            Console.WriteLine(compiled.ToString());
-            Console.WriteLine(JsonConvert.SerializeObject(compiled.Bindings));
+            var exists = query.Clone().Exists();
+            Console.WriteLine(exists);
         }
 
         private static QueryFactory SqlLiteQueryFactory()
@@ -93,22 +62,6 @@ private static QueryFactory SqlLiteQueryFactory()
 
         }
 
-        private static QueryFactory SqlServerQueryFactory()
-        {
-            var compiler = new PostgresCompiler();
-            var connection = new SqlConnection(
-               "Server=tcp:localhost,1433;Initial Catalog=Lite;User ID=sa;Password=P@ssw0rd"
-           );
-
-            var db = new QueryFactory(connection, compiler);
-
-            db.Logger = result =>
-            {
-                Console.WriteLine(result.ToString());
-            };
-
-            return db;
-        }
 
     }
 }

Program/Program.csproj

@@ -6,16 +6,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-    <PackageReference Include="Npgsql" Version="4.0.4" />
-    <PackageReference Include="System.Data.SqlClient" Version="4.5.1" />
-    <PackageReference Include="System.Data.SQLite" Version="1.0.109.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Npgsql" Version="7.0.4" />
+    <PackageReference Include="System.Data.SqlClient" Version="4.8.5" />
+    <PackageReference Include="System.Data.SQLite" Version="1.0.118" />
   </ItemGroup>
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <IsPackable>false</IsPackable>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
 </Project>

QueryBuilder.Tests/AggregateTests.cs

@@ -1,92 +1,94 @@
 using SqlKata.Compilers;
 using SqlKata.Tests.Infrastructure;
-using Xunit;
 
-namespace SqlKata.Tests
+namespace SqlKata.Tests;
+
+public class AggregateTests : TestSupport
 {
-    public class AggregateTests : TestSupport
+    [Fact]
+    public void Count()
     {
-        [Fact]
-        public void Count()
-        {
-            var query = new Query("A").AsCount();
+        var query = new Query("A").AsCount();
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM [A]", c[EngineCodes.SqlServer]);
-            Assert.Equal("SELECT COUNT(*) AS `count` FROM `A`", c[EngineCodes.MySql]);
-            Assert.Equal("SELECT COUNT(*) AS \"count\" FROM \"A\"", c[EngineCodes.PostgreSql]);
-            Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[EngineCodes.Firebird]);
-        }
+        Assert.Equal("SELECT COUNT(*) AS [count] FROM [A]", c[EngineCodes.SqlServer]);
+        Assert.Equal("SELECT COUNT(*) AS `count` FROM `A`", c[EngineCodes.MySql]);
+        Assert.Equal("SELECT COUNT(*) AS \"count\" FROM \"A\"", c[EngineCodes.PostgreSql]);
+        Assert.Equal("SELECT COUNT(*) AS \"COUNT\" FROM \"A\"", c[EngineCodes.Firebird]);
+    }
 
-        [Fact]
-        public void CountMultipleColumns()
-        {
-            var query = new Query("A").AsCount(new[] { "ColumnA", "ColumnB" });
+    [Fact]
+    public void CountMultipleColumns()
+    {
+        var query = new Query("A").AsCount(new[] { "ColumnA", "ColumnB" });
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal(
+            "SELECT COUNT(*) AS [count] FROM (SELECT 1 FROM [A] WHERE [ColumnA] IS NOT NULL AND [ColumnB] IS NOT NULL) AS [countQuery]",
+            c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void DistinctCount()
-        {
-            var query = new Query("A").Distinct().AsCount();
+    [Fact]
+    public void DistinctCount()
+    {
+        var query = new Query("A").Distinct().AsCount();
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT * FROM [A]) AS [countQuery]",
+            c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void DistinctCountMultipleColumns()
-        {
-            var query = new Query("A").Distinct().AsCount(new[] { "ColumnA", "ColumnB" });
+    [Fact]
+    public void DistinctCountMultipleColumns()
+    {
+        var query = new Query("A").Distinct().AsCount(new[] { "ColumnA", "ColumnB" });
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT COUNT(*) AS [count] FROM (SELECT DISTINCT [ColumnA], [ColumnB] FROM [A]) AS [countQuery]",
+            c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void Average()
-        {
-            var query = new Query("A").AsAverage("TTL");
+    [Fact]
+    public void Average()
+    {
+        var query = new Query("A").AsAverage("TTL");
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT AVG([TTL]) AS [avg] FROM [A]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT AVG([TTL]) AS [avg] FROM [A]", c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void Sum()
-        {
-            var query = new Query("A").AsSum("PacketsDropped");
+    [Fact]
+    public void Sum()
+    {
+        var query = new Query("A").AsSum("PacketsDropped");
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT SUM([PacketsDropped]) AS [sum] FROM [A]", c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void Max()
-        {
-            var query = new Query("A").AsMax("LatencyMs");
+    [Fact]
+    public void Max()
+    {
+        var query = new Query("A").AsMax("LatencyMs");
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT MAX([LatencyMs]) AS [max] FROM [A]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT MAX([LatencyMs]) AS [max] FROM [A]", c[EngineCodes.SqlServer]);
+    }
 
-        [Fact]
-        public void Min()
-        {
-            var query = new Query("A").AsMin("LatencyMs");
+    [Fact]
+    public void Min()
+    {
+        var query = new Query("A").AsMin("LatencyMs");
 
-            var c = Compile(query);
+        var c = Compile(query);
 
-            Assert.Equal("SELECT MIN([LatencyMs]) AS [min] FROM [A]", c[EngineCodes.SqlServer]);
-        }
+        Assert.Equal("SELECT MIN([LatencyMs]) AS [min] FROM [A]", c[EngineCodes.SqlServer]);
     }
 }