Feat/62 (#9)

* feat: + Remove dbTypes attribute parametrs. DbType added with DbTypeMapAttribute.

* feat: + Update benchmark

Author: SoftStoneDevelop

Gedaq.Npgsql.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 18
-VisualStudioVersion = 18.1.11312.151 d18.0
+VisualStudioVersion = 18.1.11312.151
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Gedaq.Npgsql", "Src\Gedaq.Npgsql\Gedaq.Npgsql.csproj", "{9C9B875A-9C0A-49CB-A7C8-F1D5BD8CA615}"
 EndProject

Src/Gedaq.Npgsql/Attributes/BinaryExportAttribute.cs

@@ -1,6 +1,5 @@
 using Gedaq.Common.Enums;
 using Gedaq.Npgsql.Enums;
-using NpgsqlTypes;
 using System;
 
 namespace Gedaq.Npgsql.Attributes
@@ -19,7 +18,6 @@ public sealed class BinaryExportAttribute : Attribute
         /// <param name="methodName">Name of the generated method</param>
         /// <param name="queryMapTypes">The types into which the Row received from the database will be converted</param>
         /// <param name="query">Sql query</param>
-        /// <param name="dbTypes">The database types, in the order they appear in the query, that will be read in that order from the Row.</param>
         /// <param name="methodType">Type of generated method see <see cref="MethodType"/></param>
         /// <param name="sourceType">The type of database connection source for which the method will be generated see <see cref="SourceType"/></param>
         /// <param name="accessModifier">Access Modifier of Generated Methods see <see cref="AccessModifier"/></param>
@@ -29,7 +27,6 @@ public BinaryExportAttribute(
             string methodName,
             Type[] queryMapTypes,
             string? query = null,
-            NpgsqlDbType[]? dbTypes = null,
             MethodType methodType = MethodType.Sync,
             SourceType sourceType = SourceType.Connection,
             AccessModifier accessModifier = AccessModifier.AsContainingClass,

Src/Gedaq.Npgsql/Gedaq.Npgsql.csproj

@@ -10,7 +10,7 @@
 	</ItemGroup>
 	<PropertyGroup>
 		<PackageId>Gedaq.Npgsql</PackageId>
-		<PackageVersion>10.0.0.2</PackageVersion>
+		<PackageVersion>10.0.0.3</PackageVersion>
 		<Authors>Brevnov Vyacheslav Sergeevich</Authors>
 		<RepositoryUrl>https://github.com/SoftStoneDevelop/Gedaq.Npgsql</RepositoryUrl>
 		<PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>

Src/NpgsqlBenchmark/Benchmarks/BinaryExportMap.cs

@@ -53,7 +53,7 @@ public void IterationCleanup()
         }
 
         [Gedaq.Npgsql.Attributes.Query(
-            @"
+            query: @"
 SELECT 
     p.id,
     p.firstname,
@@ -66,19 +66,19 @@ public void IterationCleanup()
 FROM person p
 LEFT JOIN identification i ON i.id = p.identification_id
 ",
-            "NpgsqlQuery",
-            typeof(Person))]
+            methodName: "NpgsqlQuery",
+            queryMapTypes: [typeof(Person)])]
         [Benchmark(Description = $"NpgsqlQuery")]
         public async Task NpgsqlQuery()
         {
             for (int i = 0; i < Size; i++)
             {
-                var persons = _connection.NpgsqlQuery().ToList();
+                var persons = _connection.NpgsqlQuery();
             }
         }
 
         [Gedaq.Npgsql.Attributes.BinaryExport(
-            @"
+            query: @"
 COPY 
 (
 SELECT 
@@ -94,8 +94,8 @@ FROM person p
 LEFT JOIN identification i ON i.id = p.identification_id
 ) TO STDOUT (FORMAT BINARY)
 ",
-            "NpgsqlBinaryExport",
-            typeof(Person))]
+            methodName: "NpgsqlBinaryExport",
+            queryMapTypes: [typeof(Person)])]
         [Benchmark(Baseline = true, Description = "NpgsqlBinaryExport")]
         public async Task NpgsqlBinaryExport()
         {

Src/NpgsqlBenchmark/Benchmarks/CompareDapper.cs

@@ -1,24 +1,37 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using Dapper;
+using Gedaq.Common.Enums;
 using Npgsql;
 using NpgsqlBenchmark.Model;
 using System.Collections.Generic;
 using System.Data.Common;
-using System.Linq;
 using System.Threading.Tasks;
 
 namespace NpgsqlBenchmark.Benchmarks
 {
+    public class PersonFlat
+    {
+        public int Id { get; set; }
+
+        public string FirstName { get; set; }
+
+        public string MiddleName { get; set; }
+
+        public string LastName { get; set; }
+
+        [Gedaq.Common.Attributes.IgnoreProperty()]
+        public Identification Identification { get; set; }
+    }
+
     [MemoryDiagnoser]
     [SimpleJob(RuntimeMoniker.Net10_0)]
-    [HideColumns("Error", "StdDev", "Median", "RatioSD", "Gen0", "Gen1", "Gen2")]
     public partial class CompareDapper : PostgresBenchmark
     {
         private NpgsqlConnection _connection;
 
-        [Params(0)]
-        public int Size;
+        [Params(10, 20, 30)]
+        public int Iterations;
 
         [GlobalSetup]
         public async Task GlobalSetup()
@@ -55,35 +68,37 @@ public void IterationCleanup()
             }
         }
 
-        [Gedaq.Npgsql.Attributes.Query(
-            @"
+        [Benchmark(Baseline = true, Description = "Dapper")]
+        public void Dapper()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = _connection.Query<Person, Identification, Person>(@"
 SELECT 
     p.id,
     p.firstname,
-~StartInner::Identification:id~
-    i.id,
-    i.typename,
-~EndInner::Identification~
     p.middlename,
-    p.lastname
+    p.lastname,
+    p.identification_id,
+    i.typename
 FROM person p
 LEFT JOIN identification i ON i.id = p.identification_id
-WHERE p.id >= $1
 ",
-            "GetAllPerson",
-            typeof(Person)),
-            Gedaq.Npgsql.Attributes.Parametr(parametrType: typeof(int), position: 1)
-            ]
-        [Benchmark(Baseline = true, Description = $"Gedaq.Npgsql", OperationsPerInvoke = 1_000)]
-        public void Npgsql()
-        {
-            var persons = GetAllPerson(_connection, 50_000).ToList();
+(person, ident) =>
+{
+    person.Identification = ident;
+    return person;
+},
+splitOn: "identification_id").AsList();
+            }
         }
 
-        [Benchmark(Description = "Dapper", OperationsPerInvoke = 1_000)]
-        public void Dapper()
+        [Benchmark(Description = "Dapper Async")]
+        public async Task DapperAsync()
         {
-            var persons = _connection.Query<Person, Identification, Person>(@"
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = (await _connection.QueryAsync<Person, Identification, Person>(@"
 SELECT 
     p.id,
     p.firstname,
@@ -93,21 +108,18 @@ public void Dapper()
     i.typename
 FROM person p
 LEFT JOIN identification i ON i.id = p.identification_id
-WHERE p.id >= @id
 ",
 (person, ident) =>
 {
     person.Identification = ident;
     return person;
 },
-new { id = 50_000 },
-splitOn: "identification_id"
-)
-                    .ToList();
+splitOn: "identification_id")).AsList();
+            }
         }
 
         [DapperAot]
-        public static IEnumerable<Person> DapperAOTGetAllPerson(DbConnection connection, int id) => connection.Query<Person, Identification, Person>(
+        public static IEnumerable<Person> DapperAOTGetAllPerson(DbConnection connection) => connection.Query<Person, Identification, Person>(
         @"SELECT 
     p.id,
     p.firstname,
@@ -117,21 +129,136 @@ public static IEnumerable<Person> DapperAOTGetAllPerson(DbConnection connection,
     i.typename
 FROM person p
 LEFT JOIN identification i ON i.id = p.identification_id
-WHERE p.id >= @id
 ",
 (person, ident) =>
 {
     person.Identification = ident;
     return person;
 },
-new { id },
-splitOn: "identification_id"
-                );
+splitOn: "identification_id");
 
-        [Benchmark(Description = "DapperAOT", OperationsPerInvoke = 1_000)]
+        [Benchmark(Description = "DapperAOT")]
         public void DapperAOT()
         {
-            var persons = DapperAOTGetAllPerson(_connection, 50_000).ToList();
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = DapperAOTGetAllPerson(_connection).AsList();
+            }
+        }
+
+        [DapperAot]
+        public static Task<IEnumerable<Person>> DapperAOTGetAllPersonAsync(DbConnection connection) => connection.QueryAsync<Person, Identification, Person>(
+        @"SELECT 
+    p.id,
+    p.firstname,
+    p.middlename,
+    p.lastname,
+    p.identification_id,
+    i.typename
+FROM person p
+LEFT JOIN identification i ON i.id = p.identification_id
+",
+(person, ident) =>
+{
+    person.Identification = ident;
+    return person;
+},
+splitOn: "identification_id");
+
+        [Benchmark(Description = "DapperAOT Async")]
+        public async Task DapperAOTAsync()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = (await DapperAOTGetAllPersonAsync(_connection)).AsList();
+            }
+        }
+
+        [Gedaq.Npgsql.Attributes.Query(
+            query: @"
+SELECT 
+    p.id,
+    p.firstname,
+~StartInner::Identification:id~
+    i.id,
+    i.typename,
+~EndInner::Identification~
+    p.middlename,
+    p.lastname
+FROM person p
+LEFT JOIN identification i ON i.id = p.identification_id
+",
+            methodName: "GetAllPerson",
+            queryMapTypes: [typeof(Person)],
+            methodType: MethodType.Sync | MethodType.Async,
+            asyncResultType: AsyncResult.ValueTask)]
+        [Benchmark(Description = $"Gedaq Static Sync")]
+        public void GedaqStatic()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = GetAllPerson(_connection);
+            }
+        }
+
+        [Benchmark(Description = $"Gedaq Static Async")]
+        public async Task GedaqStaticAsync()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = await GetAllPersonAsync(_connection);
+            }
+        }
+
+        [Gedaq.Npgsql.Attributes.Query(
+            query: null,
+            methodName: "GetAllPersonDyn",
+            queryMapTypes: [typeof(PersonFlat), typeof(Identification)],
+            overrideAliasPrefixs: ["person_", "identity_"],
+            methodType: MethodType.Sync | MethodType.Async,
+            asyncResultType: AsyncResult.ValueTask)]
+        [Benchmark(Description = $"Gedaq Dynamic Sync")]
+        public void GedaqDynamic()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = new List<PersonFlat>();
+
+                GetAllPersonDyn(_connection, @"
+        SELECT 
+            p.id as person_id,
+            p.firstname as person_firstname,
+            p.middlename as person_middlename,
+            p.lastname as person_lastname,
+            i.id as identity_id,
+            i.typename as identity_typename
+        FROM person p
+        LEFT JOIN identification i ON i.id = p.identification_id
+        ",
+    (person, indetity) => { person.Identification = indetity; persons.Add(person); });
+            }
+        }
+
+        [Benchmark(Description = $"Gedaq Dynamic Async")]
+        public async Task GedaqDynamicAsync()
+        {
+            for (int i = 0; i < Iterations; i++)
+            {
+                var persons = new List<PersonFlat>();
+
+                await GetAllPersonDynAsync(_connection, @"
+        SELECT 
+            p.id as person_id,
+            p.firstname as person_firstname,
+            p.middlename as person_middlename,
+            p.lastname as person_lastname,
+            i.id as identity_id,
+            i.typename as identity_typename
+        FROM person p
+        LEFT JOIN identification i ON i.id = p.identification_id
+        ",
+    (person, indetity) => { person.Identification = indetity; persons.Add(person); });
+            }
         }
     }
 }