#35 enhanced the shared db connection to track threads and the number of connections defined per thread.

kccarter76 · kccarter76 · commit 9feb5ca5b4a7 · 2020-07-09T23:53:14.000-06:00
diff --git a/SubSonic/Extensions/Internal/Objects.cs b/SubSonic/Extensions/Internal/Objects.cs
@@ -14,6 +14,18 @@ namespace SubSonic
     /// </remarks>
     internal static partial class InternalExtensions
     {
+        public static bool IsIntGreaterThan(this object left, object right)
+        {
+            if (left is int _left)
+            {
+                if (right is int _right)
+                {
+                   return _left > _right;
+                }
+            }
+
+            return false;
+        }
         public static bool IsOfType<TType>(this object source)
         {
             return IsOfType(source, typeof(TType));
diff --git a/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderAsyncQueryProvider.cs b/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderAsyncQueryProvider.cs
@@ -80,10 +80,7 @@ await Scope.Connection.OpenAsync(cancellationToken)
                     {
                         dbQuery.CleanUpParameters();
 
-                        if (!(Scope.Connection is null))
-                        {
-                            Scope.Connection.Close();
-                        }
+                        Scope.Connection.Close();
                     }
                 }
             }
@@ -217,7 +214,7 @@ public async IAsyncEnumerable<TResult> ExecuteAsync<TResult>([NotNull] Expressio
                 throw Error.ArgumentNull(nameof(query));
             }
 
-            using SharedDbConnectionScope Scope = DbContext.ServiceProvider.GetService<SharedDbConnectionScope>();
+            using SharedDbConnectionScope Scope = DbContext.Current.UseSharedDbConnection();
             IDbQuery dbQuery = ToQuery(query);
 
             Type elementType = query.Type.GetQualifiedType();
@@ -226,8 +223,6 @@ public async IAsyncEnumerable<TResult> ExecuteAsync<TResult>([NotNull] Expressio
 
             try
             {
-                await Scope.Connection.OpenAsync(cancellationToken)
-                            .ConfigureAwait(false);
                 if (isEntityModel)
                 {
                     using (DbDataReader reader = await Scope.Database
@@ -259,13 +254,11 @@ await Scope.Connection.OpenAsync(cancellationToken)
             }
             finally
             {
-                if (Scope.Connection != null)
-                {
-                    await Scope.Connection
-                        .CloseAsync()
-                        .ConfigureAwait(false);
-                }
-
+#if NETSTANDARD2_1
+                await Scope.Connection.CloseAsync().ConfigureAwait(true);
+#else
+                Scope.Connection.Close();
+#endif
                 dbQuery.CleanUpParameters();
             }
         }
diff --git a/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderQueryProvider.cs b/SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderQueryProvider.cs
@@ -13,6 +13,7 @@ namespace SubSonic.Infrastructure.Builders
     using Linq;
     using Linq.Expressions;
     using Logging;
+    using System.Globalization;
 
     public partial class DbSqlQueryBuilder
     {
@@ -146,10 +147,20 @@ public TResult Execute<TResult>(Expression expression)
                 {
                     if (BuildSelect(dbSelect, where) is DbSelectExpression select)
                     {
-                        return Execute<TResult>(DbExpression.DbSelectAggregate(select, new[]
+                        TResult result = Execute<TResult>(DbExpression.DbSelectAggregate(select, new[]
                         {
                             DbExpression.DbAggregate(typeof(TResult), AggregateType.Count, select.Columns.First(x => x.Property.IsPrimaryKey).Expression)
                         }));
+
+                        if (select.Take is ConstantExpression take)
+                        {
+                            if (result.IsIntGreaterThan(take.Value))
+                            {
+                                return (TResult)Convert.ChangeType(take.Value, typeof(TResult), CultureInfo.InvariantCulture);
+                            }
+                        }
+
+                        return result;
                     }
                 }
                 
diff --git a/SubSonic/Infrastructure/Database/DbDatabase.cs b/SubSonic/Infrastructure/Database/DbDatabase.cs
@@ -63,6 +63,7 @@ internal DbConnection CurrentSharedConnection
 
         private static void DBSharedConnection_Disposed(object sender, EventArgs e)
         {
+            dBSharedConnection?.Close();
             dBSharedConnection = null;
         }
 
@@ -270,6 +271,11 @@ public async Task<DbDataReader> ExecuteReaderAsync(IDbQuery dbQuery, Cancellatio
 
                 try
                 {
+                    if (Scope.Connection.State != ConnectionState.Open)
+                    {
+                        Scope.Connection.Open();
+                    }
+
                     return await cmd
                         .ExecuteReaderAsync(dbQuery.Behavior, cancellationToken)
                         .ConfigureAwait(false);
@@ -280,6 +286,10 @@ public async Task<DbDataReader> ExecuteReaderAsync(IDbQuery dbQuery, Cancellatio
 
                     throw;
                 }
+                finally
+                {
+
+                }
             }
         }
 
diff --git a/SubSonic/Infrastructure/Providers/Connections/SharedDbConnectionScope.cs b/SubSonic/Infrastructure/Providers/Connections/SharedDbConnectionScope.cs
@@ -1,7 +1,9 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Data.Common;
+using System.Diagnostics;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace SubSonic.Infrastructure
@@ -10,23 +12,32 @@ public class SharedDbConnectionScope
         : IConnectionScope
         , IDisposable
     {
-        [ThreadStatic]
-        private static Stack<SharedDbConnectionScope> __instances;
+        //[ThreadStatic]
+        private static Dictionary<int, Stack<SharedDbConnectionScope>> __db_instances;
 
         private readonly DbDatabase dbDatabase;
 
         public SharedDbConnectionScope(DbDatabase dbDatabase)
         {
             this.dbDatabase = dbDatabase ?? throw new ArgumentNullException(nameof(dbDatabase));
             this.dbDatabase.InitializeSharedConnection();
+            this.threadId = Thread.CurrentThread.ManagedThreadId;
 
-            if (__instances == null)
+            if (__db_instances == null)
             {
-                __instances = new Stack<SharedDbConnectionScope>();
+                __db_instances = new Dictionary<int, Stack<SharedDbConnectionScope>>();
             }
-            __instances.Push(this);
+
+            if (!__db_instances.ContainsKey(threadId))
+            {
+                __db_instances[threadId] = new Stack<SharedDbConnectionScope>();
+            }
+
+            __db_instances[threadId].Push(this);
         }
 
+        private readonly int threadId;
+
         public DbConnection Connection => dbDatabase.CurrentSharedConnection;
 
         public DbDatabase Database => dbDatabase;
@@ -41,11 +52,18 @@ protected virtual void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    __instances?.Pop();
+                    SharedDbConnectionScope scope = __db_instances[threadId].Pop();
+
+                    Debug.Assert(scope.dbDatabase.CurrentSharedConnection.State == System.Data.ConnectionState.Closed, "open connection is being disposed.");
+
+                    if (__db_instances[threadId]?.Count == 0)
+                    {
+                        __db_instances.Remove(threadId);
+                    }
 
-                    if(__instances?.Count == 0)
+                    if (__db_instances.Count == 0)
                     {
-                        this.dbDatabase.ResetSharedConnection();
+                        scope.dbDatabase.ResetSharedConnection();
                     }
 
                     disposedValue = true;
diff --git a/SubSonic/Linq/Expressions/DbSelectAggregateExpression.cs b/SubSonic/Linq/Expressions/DbSelectAggregateExpression.cs
@@ -11,7 +11,6 @@ namespace SubSonic.Linq.Expressions
     public class DbSelectAggregateExpression
         : DbConstantExpression
     {
-        private readonly DbSelectExpression select;
         protected internal DbSelectAggregateExpression(DbSelectExpression select, IEnumerable<DbExpression> columns)
             : base(
                   select.IsNullThrowArgumentNull(nameof(select)).QueryObject,
@@ -25,18 +24,20 @@ protected internal DbSelectAggregateExpression(DbSelectExpression select, IEnume
 
             Columns = new ReadOnlyCollection<DbExpression>(columns.ToList());
 
-            this.select = select;
+            Select = select;
         }
 
+        public DbSelectExpression Select { get; }
+
         public ReadOnlyCollection<DbExpression> Columns { get; }
 
-        public bool IsCte => select.IsCte;
+        public bool IsCte => Select.IsCte;
 
-        public DbTableExpression From => select.From;
+        public DbTableExpression From => Select.From;
 
-        public Expression Where => select.Where;
+        public Expression Where => Select.Where;
 
-        public ReadOnlyCollection<Expression> GroupBy => select.GroupBy;
+        public ReadOnlyCollection<Expression> GroupBy => Select.GroupBy;
 
         public string QueryText
         {
diff --git a/SubSonic/Linq/Expressions/Structure/SqlFormatter/TSqlFormatter.cs b/SubSonic/Linq/Expressions/Structure/SqlFormatter/TSqlFormatter.cs
@@ -22,7 +22,7 @@ public partial class TSqlFormatter
         : DbExpressionVisitor
     {
         [ThreadStatic]
-        private static Stack<TSqlFormatter> __instances;
+        private static Stack<TSqlFormatter> __formatter_instances;
         private int depth = 0;
         private readonly TextWriter writer;
         private readonly ISqlContext context;
@@ -49,15 +49,15 @@ protected TSqlFormatter(TextWriter writer, ISqlContext context)
             this.context = context ?? throw new ArgumentNullException(nameof(context));
             this.provider = context.Provider ?? throw new InvalidOperationException();
 
-            if (__instances is null)
+            if (__formatter_instances is null)
             {
-                __instances = new Stack<TSqlFormatter>();
+                __formatter_instances = new Stack<TSqlFormatter>();
             }
 
-            __instances.Push(this);
+            __formatter_instances.Push(this);
         }
 
-        protected static int IndentationWidth => __instances.Count;
+        protected static int IndentationWidth => __formatter_instances.Count;
 
         protected bool IsNested { get; set; } = false;
 
diff --git a/SubSonic/Linq/Expressions/Structure/SqlFormatter/TSqlFormatterDisposable.cs b/SubSonic/Linq/Expressions/Structure/SqlFormatter/TSqlFormatterDisposable.cs
@@ -20,11 +20,11 @@ protected virtual void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    __instances.Pop();
+                    __formatter_instances.Pop();
 
-                    if(__instances.Count == 0)
+                    if(__formatter_instances.Count == 0)
                     {
-                        __instances = null;
+                        __formatter_instances = null;
                     }
                 }
 
diff --git a/SubSonic/SubSonic.Core.DataAccessLayer.csproj b/SubSonic/SubSonic.Core.DataAccessLayer.csproj
@@ -9,7 +9,7 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <PackageTags>DAL;SqlServer;C#;.NetFramework;.NetCore;</PackageTags>
-    <Version>4.1.0-alpha.5</Version>
+    <Version>4.1.0-alpha.6</Version>
     <PackageId>SubSonic.Core.DAL</PackageId>
     <Company>SubSonic-Core</Company>
     <PackageProjectUrl>https://github.com/SubSonic-Core/SubSonic/wiki</PackageProjectUrl>

Original file line number	Diff line number	Diff line change
`@@ -80,10 +80,7 @@ await Scope.Connection.OpenAsync(cancellationToken)`
`80`	`80`	`{`
`81`	`81`	`dbQuery.CleanUpParameters();`
`82`	`82`
`83`		`- if (!(Scope.Connection is null))`
`84`		`- {`
`85`		`- Scope.Connection.Close();`
`86`		`- }`
	`83`	`+ Scope.Connection.Close();`
`87`	`84`	`}`
`88`	`85`	`}`
`89`	`86`	`}`
`@@ -217,7 +214,7 @@ public async IAsyncEnumerable<TResult> ExecuteAsync<TResult>([NotNull] Expressio`
`217`	`214`	`throw Error.ArgumentNull(nameof(query));`
`218`	`215`	`}`
`219`	`216`
`220`		`- using SharedDbConnectionScope Scope = DbContext.ServiceProvider.GetService<SharedDbConnectionScope>();`
	`217`	`+ using SharedDbConnectionScope Scope = DbContext.Current.UseSharedDbConnection();`
`221`	`218`	`IDbQuery dbQuery = ToQuery(query);`
`222`	`219`
`223`	`220`	`Type elementType = query.Type.GetQualifiedType();`
`@@ -226,8 +223,6 @@ public async IAsyncEnumerable<TResult> ExecuteAsync<TResult>([NotNull] Expressio`
`226`	`223`
`227`	`224`	`try`
`228`	`225`	`{`
`229`		`- await Scope.Connection.OpenAsync(cancellationToken)`
`230`		`- .ConfigureAwait(false);`
`231`	`226`	`if (isEntityModel)`
`232`	`227`	`{`
`233`	`228`	`using (DbDataReader reader = await Scope.Database`
`@@ -259,13 +254,11 @@ await Scope.Connection.OpenAsync(cancellationToken)`
`259`	`254`	`}`
`260`	`255`	`finally`
`261`	`256`	`{`
`262`		`- if (Scope.Connection != null)`
`263`		`- {`
`264`		`- await Scope.Connection`
`265`		`- .CloseAsync()`
`266`		`- .ConfigureAwait(false);`
`267`		`- }`
`268`		`-`
	`257`	`+#if NETSTANDARD2_1`
	`258`	`+ await Scope.Connection.CloseAsync().ConfigureAwait(true);`
	`259`	`+#else`
	`260`	`+ Scope.Connection.Close();`
	`261`	`+#endif`
`269`	`262`	`dbQuery.CleanUpParameters();`
`270`	`263`	`}`
`271`	`264`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ namespace SubSonic.Infrastructure.Builders`
`13`	`13`	`using Linq;`
`14`	`14`	`using Linq.Expressions;`
`15`	`15`	`using Logging;`
	`16`	`+ using System.Globalization;`
`16`	`17`
`17`	`18`	`public partial class DbSqlQueryBuilder`
`18`	`19`	`{`
`@@ -146,10 +147,20 @@ public TResult Execute<TResult>(Expression expression)`
`146`	`147`	`{`
`147`	`148`	`if (BuildSelect(dbSelect, where) is DbSelectExpression select)`
`148`	`149`	`{`
`149`		`- return Execute<TResult>(DbExpression.DbSelectAggregate(select, new[]`
	`150`	`+ TResult result = Execute<TResult>(DbExpression.DbSelectAggregate(select, new[]`
`150`	`151`	`{`
`151`	`152`	`DbExpression.DbAggregate(typeof(TResult), AggregateType.Count, select.Columns.First(x => x.Property.IsPrimaryKey).Expression)`
`152`	`153`	`}));`
	`154`	`+`
	`155`	`+ if (select.Take is ConstantExpression take)`
	`156`	`+ {`
	`157`	`+ if (result.IsIntGreaterThan(take.Value))`
	`158`	`+ {`
	`159`	`+ return (TResult)Convert.ChangeType(take.Value, typeof(TResult), CultureInfo.InvariantCulture);`
	`160`	`+ }`
	`161`	`+ }`
	`162`	`+`
	`163`	`+ return result;`
`153`	`164`	`}`
`154`	`165`	`}`
`155`	`166`
Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,7 @@ internal DbConnection CurrentSharedConnection`
`63`	`63`
`64`	`64`	`private static void DBSharedConnection_Disposed(object sender, EventArgs e)`
`65`	`65`	`{`
	`66`	`+ dBSharedConnection?.Close();`
`66`	`67`	`dBSharedConnection = null;`
`67`	`68`	`}`
`68`	`69`
`@@ -270,6 +271,11 @@ public async Task<DbDataReader> ExecuteReaderAsync(IDbQuery dbQuery, Cancellatio`
`270`	`271`
`271`	`272`	`try`
`272`	`273`	`{`
	`274`	`+ if (Scope.Connection.State != ConnectionState.Open)`
	`275`	`+ {`
	`276`	`+ Scope.Connection.Open();`
	`277`	`+ }`
	`278`	`+`
`273`	`279`	`return await cmd`
`274`	`280`	`.ExecuteReaderAsync(dbQuery.Behavior, cancellationToken)`
`275`	`281`	`.ConfigureAwait(false);`
`@@ -280,6 +286,10 @@ public async Task<DbDataReader> ExecuteReaderAsync(IDbQuery dbQuery, Cancellatio`
`280`	`286`
`281`	`287`	`throw;`
`282`	`288`	`}`
	`289`	`+ finally`
	`290`	`+ {`
	`291`	`+`
	`292`	`+ }`
`283`	`293`	`}`
`284`	`294`	`}`
`285`	`295`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public partial class TSqlFormatter`
`22`	`22`	`: DbExpressionVisitor`
`23`	`23`	`{`
`24`	`24`	`[ThreadStatic]`
`25`		`- private static Stack<TSqlFormatter> __instances;`
	`25`	`+ private static Stack<TSqlFormatter> __formatter_instances;`
`26`	`26`	`private int depth = 0;`
`27`	`27`	`private readonly TextWriter writer;`
`28`	`28`	`private readonly ISqlContext context;`
`@@ -49,15 +49,15 @@ protected TSqlFormatter(TextWriter writer, ISqlContext context)`
`49`	`49`	`this.context = context ?? throw new ArgumentNullException(nameof(context));`
`50`	`50`	`this.provider = context.Provider ?? throw new InvalidOperationException();`
`51`	`51`
`52`		`- if (__instances is null)`
	`52`	`+ if (__formatter_instances is null)`
`53`	`53`	`{`
`54`		`- __instances = new Stack<TSqlFormatter>();`
	`54`	`+ __formatter_instances = new Stack<TSqlFormatter>();`
`55`	`55`	`}`
`56`	`56`
`57`		`- __instances.Push(this);`
	`57`	`+ __formatter_instances.Push(this);`
`58`	`58`	`}`
`59`	`59`
`60`		`- protected static int IndentationWidth => __instances.Count;`
	`60`	`+ protected static int IndentationWidth => __formatter_instances.Count;`
`61`	`61`
`62`	`62`	`protected bool IsNested { get; set; } = false;`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ protected virtual void Dispose(bool disposing)`
`20`	`20`	`{`
`21`	`21`	`if (disposing)`
`22`	`22`	`{`
`23`		`- __instances.Pop();`
	`23`	`+ __formatter_instances.Pop();`
`24`	`24`
`25`		`- if(__instances.Count == 0)`
	`25`	`+ if(__formatter_instances.Count == 0)`
`26`	`26`	`{`
`27`		`- __instances = null;`
	`27`	`+ __formatter_instances = null;`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`