pulling main back up

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));

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();
             }
         }

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;
                     }
                 }
 

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
+                {
+
+                }
             }
         }
 

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;

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
         {

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;
 

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;
                     }
                 }
 

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>