diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 86da91f0e..4e9c4c0fb 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -3,9 +3,9 @@ name: DotNet Build and Test
 # Triggers the workflow on push or pull request events but only for the master branch
 on:
   push:
-    branches: [ master ]
+    branches: [ master, pool/SNOW-860872-connection-pool ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, pool/SNOW-860872-connection-pool ]
   workflow_dispatch:
     inputs:
       logLevel:
diff --git a/CodingConventions.md b/CodingConventions.md
index 19ca8fc75..0242f583e 100644
--- a/CodingConventions.md
+++ b/CodingConventions.md
@@ -85,6 +85,18 @@ public class ExampleClass
 }
 ```
 
+#### Property
+
+Use PascalCase, eg. `SomeProperty`.
+
+```csharp
+public ExampleProperty
+{
+    get;
+    set;
+}
+```
+
 ### Local variables
 
 Use camelCase, eg. `someVariable`.
diff --git a/Snowflake.Data.Tests/IntegrationTests/ConnectingThreads.cs b/Snowflake.Data.Tests/IntegrationTests/ConnectingThreads.cs
new file mode 100644
index 000000000..be33f1ce5
--- /dev/null
+++ b/Snowflake.Data.Tests/IntegrationTests/ConnectingThreads.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using Snowflake.Data.Client;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    class ConnectingThreads
+    {
+        private string _connectionString; 
+
+        private ConcurrentQueue<ThreadEvent> _events = new ConcurrentQueue<ThreadEvent>();
+
+        private List<Thread> threads = new List<Thread>();
+
+        public ConnectingThreads(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        public ConnectingThreads NewThread(string name,
+            long waitBeforeConnectMillis,
+            long waitAfterConnectMillis,
+            bool closeOnExit)
+        {
+            var thread = new ConnectingThread(
+                name,
+                _events,
+                _connectionString,
+                waitBeforeConnectMillis,
+                waitAfterConnectMillis,
+                closeOnExit).Build();
+            threads.Add(thread);
+            return this;
+        }
+
+        public ConnectingThreads StartAll()
+        {
+            threads.ForEach(thread => thread.Start());
+            return this;
+        }
+
+        public ConnectingThreads JoinAll()
+        {
+            threads.ForEach(thread => thread.Join());
+            return this;
+        }
+
+        public IEnumerable<ThreadEvent> Events() => _events.ToArray().OfType<ThreadEvent>();
+    }
+    
+    class ConnectingThread
+    {
+        private string _name;
+        
+        private ConcurrentQueue<ThreadEvent> _events;
+
+        private string _connectionString;
+
+        private long _waitBeforeConnectMillis;
+
+        private long _waitAfterConnectMillis;
+
+        private bool _closeOnExit;
+        
+        public ConnectingThread(
+            string name,
+            ConcurrentQueue<ThreadEvent> events,
+            string connectionString,
+            long waitBeforeConnectMillis,
+            long waitAfterConnectMillis,
+            bool closeOnExit)
+        {
+            _name = name;
+            _events = events;
+            _connectionString = connectionString;
+            _waitBeforeConnectMillis = waitBeforeConnectMillis;
+            _waitAfterConnectMillis = waitAfterConnectMillis;
+            _closeOnExit = closeOnExit;
+        }
+
+        public Thread Build()
+        {
+            var thread = new Thread(Execute);
+            thread.Name = "thread_" + _name;
+            return thread;
+        }
+
+        private void Execute()
+        {
+            var connection = new SnowflakeDbConnection();
+            connection.ConnectionString = _connectionString;
+            Sleep(_waitBeforeConnectMillis);
+            var watch = new Stopwatch();
+            watch.Start();
+            var connected = false;
+            try
+            {
+                connection.Open();
+                connected = true;
+            }
+            catch (Exception exception)
+            {
+                watch.Stop();
+                _events.Enqueue(ThreadEvent.EventConnectingFailed(_name, exception, watch.ElapsedMilliseconds));
+            }
+            if (connected)
+            {
+                watch.Stop();
+                _events.Enqueue(ThreadEvent.EventConnected(_name, watch.ElapsedMilliseconds));
+            }
+            Sleep(_waitAfterConnectMillis);
+            if (_closeOnExit)
+            {
+                connection.Close();
+            }
+        }
+
+        private void Sleep(long millis)
+        {
+            if (millis <= 0)
+            {
+                return;
+            }
+            System.Threading.Thread.Sleep((int) millis);
+        }
+    }
+
+    class ThreadEvent
+    {
+        public string ThreadName { get; set; }
+
+        public string EventName { get; set; }
+        
+        public Exception Error { get; set; }
+
+        public long Timestamp { get; set; }
+
+        public long Duration { get; set; }
+
+        public ThreadEvent(string threadName, string eventName, Exception error, long duration)
+        {
+            ThreadName = threadName;
+            EventName = eventName;
+            Error = error;
+            Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            Duration = duration;
+        }
+        
+        public static ThreadEvent EventConnected(string threadName, long duration) =>
+            new ThreadEvent(threadName, "CONNECTED", null, duration);
+
+        public static ThreadEvent EventConnectingFailed(string threadName, Exception exception, long duration) =>
+            new ThreadEvent(threadName, "FAILED_TO_CONNECT", exception, duration);
+    }
+}
diff --git a/Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs b/Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs
new file mode 100644
index 000000000..ffd97b781
--- /dev/null
+++ b/Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs
@@ -0,0 +1,266 @@
+using System;
+using System.Data;
+using System.Diagnostics;
+using System.Linq;
+using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    [TestFixture]
+    [NonParallelizable]
+    public class ConnectionMultiplePoolsIT: SFBaseTest
+    {
+        private readonly PoolConfig _previousPoolConfig = new PoolConfig();
+        
+        [SetUp]
+        public new void BeforeTest()
+        {
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.MultipleConnectionPool);
+            SnowflakeDbConnectionPool.ClearAllPools();
+            SnowflakeDbConnectionPool.SetPooling(true);
+        }
+        
+        [TearDown]
+        public new void AfterTest()
+        {
+            _previousPoolConfig.Reset();
+        }
+        
+        [OneTimeTearDown]
+        public static void AfterAllTests()
+        {
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
+
+        [Test]
+        public void TestReuseSessionInConnectionPool() // old name: TestConnectionPool
+        {
+            var conn1 = new SnowflakeDbConnection(ConnectionString);
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            conn1.Close();
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+
+            var conn2 = new SnowflakeDbConnection();
+            conn2.ConnectionString = ConnectionString;
+            conn2.Open();
+            Assert.AreEqual(ConnectionState.Open, conn2.State);
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+
+            conn2.Close();
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(ConnectionState.Closed, conn2.State);
+        }
+        
+        [Test]
+        public void TestReuseSessionInConnectionPoolReachingMaxConnections() // old name: TestConnectionPoolFull
+        {
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetMaxPoolSize(2);
+
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = ConnectionString;
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+
+            var conn2 = new SnowflakeDbConnection();
+            conn2.ConnectionString = ConnectionString;
+            conn2.Open();
+            Assert.AreEqual(ConnectionState.Open, conn2.State);
+            
+            Assert.AreEqual(2, pool.GetCurrentPoolSize());
+            conn1.Close();
+            conn2.Close();
+            Assert.AreEqual(2, pool.GetCurrentPoolSize());
+            
+            var conn3 = new SnowflakeDbConnection();
+            conn3.ConnectionString = ConnectionString;
+            conn3.Open();
+            Assert.AreEqual(ConnectionState.Open, conn3.State);
+
+            var conn4 = new SnowflakeDbConnection();
+            conn4.ConnectionString = ConnectionString;
+            conn4.Open();
+            Assert.AreEqual(ConnectionState.Open, conn4.State);
+
+            conn3.Close();
+            Assert.AreEqual(2, pool.GetCurrentPoolSize());
+            conn4.Close();
+            Assert.AreEqual(2, pool.GetCurrentPoolSize());
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(ConnectionState.Closed, conn2.State);
+            Assert.AreEqual(ConnectionState.Closed, conn3.State);
+            Assert.AreEqual(ConnectionState.Closed, conn4.State);
+        }
+
+        [Test]
+        public void TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimit()
+        {
+            // arrange
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetMaxPoolSize(2);
+            pool.SetWaitingTimeout(1000);
+            var conn1 = OpenedConnection();
+            var conn2 = OpenedConnection();
+            var watch = new Stopwatch();
+            
+            // act
+            watch.Start();
+            var thrown = Assert.Throws<SnowflakeDbException>(() => OpenedConnection());
+            watch.Stop();
+
+            // assert
+            Assert.That(thrown.Message, Does.Contain("Unable to connect. Could not obtain a connection from the pool within a given timeout"));
+            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 1000);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 1500);
+            Assert.AreEqual(pool.GetCurrentPoolSize(), 2);
+
+            // cleanup
+            conn1.Close();
+            conn2.Close();
+        }
+
+        [Test]
+        public void TestWaitInAQueueForAnIdleSession()
+        {
+            // arrange
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetMaxPoolSize(2);
+            pool.SetWaitingTimeout(3000);
+            var threads = new ConnectingThreads(ConnectionString)
+                .NewThread("A", 0, 2000, true)
+                .NewThread("B", 50, 2000, true)
+                .NewThread("C", 100, 0, true)
+                .NewThread("D", 150, 0, true);
+            var watch = new Stopwatch();
+            
+            // act
+            watch.Start();
+            threads.StartAll().JoinAll();
+            watch.Stop();
+
+            // assert
+            var events = threads.Events().ToList();
+            Assert.AreEqual(4, events.Count);
+            CollectionAssert.AreEqual(
+                new[]
+                {
+                    Tuple.Create("A", "CONNECTED"),
+                    Tuple.Create("B", "CONNECTED"),
+                    Tuple.Create("C", "CONNECTED"),
+                    Tuple.Create("D", "CONNECTED")
+                },
+                events.Select(e => Tuple.Create(e.ThreadName, e.EventName)));
+            Assert.LessOrEqual(events[0].Duration, 1000);
+            Assert.LessOrEqual(events[1].Duration, 1000);
+            Assert.GreaterOrEqual(events[2].Duration, 2000);
+            Assert.LessOrEqual(events[2].Duration, 3100);
+            Assert.GreaterOrEqual(events[3].Duration, 2000);
+            Assert.LessOrEqual(events[3].Duration, 3100);
+        }
+        
+        [Test]
+        public void TestBusyAndIdleConnectionsCountedInPoolSize()
+        {
+            // arrange
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetMaxPoolSize(2);
+            var connection = new SnowflakeDbConnection();
+            connection.ConnectionString = ConnectionString;
+            
+            // act
+            connection.Open();
+            
+            // assert
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+            
+            // act
+            connection.Close();
+            
+            // assert
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        [Ignore("Enable when disabling pooling in connection string enabled - SNOW-902632")]
+        public void TestConnectionPoolNotPossibleToDisableForAllPools()
+        {
+            // act
+            var thrown = Assert.Throws<Exception>(() => SnowflakeDbConnectionPool.SetPooling(false));
+            
+            // assert
+            Assert.IsNotNull(thrown);
+        }
+        
+        [Test]
+        public void TestConnectionPoolDisable() 
+        {
+            // arrange
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetPooling(false);
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = ConnectionString;
+            
+            // act
+            conn1.Open();
+            
+            // assert
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+            
+            // act
+            conn1.Close();
+
+            // assert
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestNewConnectionPoolClean()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = ConnectionString;
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+
+            var conn2 = new SnowflakeDbConnection();
+            conn2.ConnectionString = ConnectionString + " retryCount=1";
+            conn2.Open();
+            Assert.AreEqual(ConnectionState.Open, conn2.State);
+
+            var conn3 = new SnowflakeDbConnection();
+            conn3.ConnectionString = ConnectionString + "  retryCount=2";
+            conn3.Open();
+            Assert.AreEqual(ConnectionState.Open, conn3.State);
+
+            conn1.Close();
+            conn2.Close();
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(conn2.ConnectionString).GetCurrentPoolSize());
+            SnowflakeDbConnectionPool.ClearAllPools();
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(conn2.ConnectionString).GetCurrentPoolSize());
+            conn3.Close();
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(conn3.ConnectionString).GetCurrentPoolSize());
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(ConnectionState.Closed, conn2.State);
+            Assert.AreEqual(ConnectionState.Closed, conn3.State);
+        }
+
+        private SnowflakeDbConnection OpenedConnection()
+        {
+            var connection = new SnowflakeDbConnection();
+            connection.ConnectionString = ConnectionString;
+            connection.Open();
+            return connection;
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/IntegrationTests/ConnectionPoolCommonIT.cs b/Snowflake.Data.Tests/IntegrationTests/ConnectionPoolCommonIT.cs
new file mode 100644
index 000000000..a75c19790
--- /dev/null
+++ b/Snowflake.Data.Tests/IntegrationTests/ConnectionPoolCommonIT.cs
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+ */
+
+using System.Data;
+using System.Threading;
+using NUnit.Framework;
+using Snowflake.Data.Core;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Log;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    [TestFixture(ConnectionPoolType.SingleConnectionCache)]
+    [TestFixture(ConnectionPoolType.MultipleConnectionPool)]
+    [NonParallelizable]
+    class ConnectionPoolCommonIT : SFBaseTest
+    {
+        private readonly ConnectionPoolType _connectionPoolTypeUnderTest;
+        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<ConnectionPoolManager>();
+        private readonly PoolConfig _previousPoolConfig;
+
+        public ConnectionPoolCommonIT(ConnectionPoolType connectionPoolTypeUnderTest)
+        {
+            _connectionPoolTypeUnderTest = connectionPoolTypeUnderTest;
+            _previousPoolConfig = new PoolConfig();
+        }
+
+        [SetUp]
+        public new void BeforeTest()
+        {
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(_connectionPoolTypeUnderTest);
+            SnowflakeDbConnectionPool.ClearAllPools();
+            SnowflakeDbConnectionPool.SetPooling(true);
+            s_logger.Debug($"---------------- BeforeTest ---------------------");
+            s_logger.Debug($"Testing Pool Type: {SnowflakeDbConnectionPool.GetConnectionPoolVersion()}");
+        }
+
+        [TearDown]
+        public new void AfterTest()
+        {
+            _previousPoolConfig.Reset();
+        }
+
+        [OneTimeTearDown]
+        public static void AfterAllTests()
+        {
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
+        
+        [Test]
+        public void TestBasicConnectionPool()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
+
+            var conn1 = new SnowflakeDbConnection(ConnectionString);
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            conn1.Close();
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestConnectionPoolExpirationWorks()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
+            SnowflakeDbConnectionPool.SetTimeout(10);
+
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = ConnectionString;
+
+            conn1.Open();
+            conn1.Close();
+            SnowflakeDbConnectionPool.SetTimeout(-1);
+
+            var conn2 = new SnowflakeDbConnection();
+            conn2.ConnectionString = ConnectionString;
+            conn2.Open();
+            conn2.Close();
+            var conn3 = new SnowflakeDbConnection();
+            conn3.ConnectionString = ConnectionString;
+            conn3.Open();
+            conn3.Close();
+
+            // The pooling timeout should apply to all connections being pooled,
+            // not just the connections created after the new setting,
+            // so expected result should be 0
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestConnectionPoolMultiThreading()
+        {
+            Thread t1 = new Thread(() => ThreadProcess1(ConnectionString));
+            Thread t2 = new Thread(() => ThreadProcess2(ConnectionString));
+
+            t1.Start();
+            t2.Start();
+
+            t1.Join();
+            t2.Join();
+        }
+
+        void ThreadProcess1(string connstr)
+        {
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = connstr;
+            conn1.Open();
+            Thread.Sleep(1000);
+            conn1.Close();
+            Thread.Sleep(4000);
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+        }
+
+        void ThreadProcess2(string connstr)
+        {
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = connstr;
+            conn1.Open();
+
+            Thread.Sleep(5000);
+            SFStatement statement = new SFStatement(conn1.SfSession);
+            SFBaseResultSet resultSet = statement.Execute(0, "select 1", null, false);
+            Assert.AreEqual(true, resultSet.Next());
+            Assert.AreEqual("1", resultSet.GetString(0));
+            conn1.Close();
+            SnowflakeDbConnectionPool.ClearAllPools();
+            SnowflakeDbConnectionPool.SetMaxPoolSize(0);
+            SnowflakeDbConnectionPool.SetPooling(true);
+        }
+        
+        [Test]
+        public void TestConnectionPoolWithDispose()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
+            
+            var conn1 = new SnowflakeDbConnection();
+            conn1.ConnectionString = "bad connection string";
+            Assert.Throws<SnowflakeDbException>(() => conn1.Open());
+            conn1.Close();
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString).GetCurrentPoolSize());
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolIT.cs b/Snowflake.Data.Tests/IntegrationTests/ConnectionSinglePoolCacheIT.cs
similarity index 56%
rename from Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolIT.cs
rename to Snowflake.Data.Tests/IntegrationTests/ConnectionSinglePoolCacheIT.cs
index 5c4529225..42ae22b74 100644
--- a/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolIT.cs
+++ b/Snowflake.Data.Tests/IntegrationTests/ConnectionSinglePoolCacheIT.cs
@@ -1,52 +1,41 @@
-/*
- * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
- */
-
-using Snowflake.Data.Tests.Util;
 using System;
 using System.Data;
 using System.Data.Common;
-using System.Threading;
 using System.Threading.Tasks;
-using Snowflake.Data.Core;
-using Snowflake.Data.Client;
-using Snowflake.Data.Log;
 using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Tests.Util;
 
 namespace Snowflake.Data.Tests.IntegrationTests
 {
-    [TestFixture, NonParallelizable]
-    class SFConnectionPoolIT : SFBaseTest
+    [TestFixture]
+    [NonParallelizable]
+    public class ConnectionSinglePoolCacheIT: SFBaseTest
     {
-        private static PoolConfig s_previousPoolConfig;
+        private readonly PoolConfig _previousPoolConfig = new PoolConfig();
 
-        [OneTimeSetUp]
-        public static void BeforeAllTests()
-        {
-            s_previousPoolConfig = new PoolConfig();
-        }
-        
         [SetUp]
         public new void BeforeTest()
         {
-            SnowflakeDbConnectionPool.SetPooling(true);
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.SingleConnectionCache);
             SnowflakeDbConnectionPool.ClearAllPools();
+            SnowflakeDbConnectionPool.SetPooling(true);
         }
-
+        
         [TearDown]
         public new void AfterTest()
         {
-            s_previousPoolConfig.Reset();
+            _previousPoolConfig.Reset();
         }
-
+        
         [OneTimeTearDown]
         public static void AfterAllTests()
         {
             SnowflakeDbConnectionPool.ClearAllPools();
-        }
-
+        }        
+        
         [Test]
-        // test connection pooling with concurrent connection
         public void TestConcurrentConnectionPooling()
         {
             // add test case name in connection string to make in unique for each test case
@@ -74,6 +63,7 @@ static void ConcurrentPoolingHelper(string connectionString, bool closeConnectio
             const int PoolTimeout = 3;
 
             // reset to default settings in case it changed by other test cases
+            Assert.AreEqual(true, SnowflakeDbConnectionPool.GetPool(connectionString).GetPooling()); // to instantiate pool
             SnowflakeDbConnectionPool.SetMaxPoolSize(10);
             SnowflakeDbConnectionPool.SetTimeout(PoolTimeout);
 
@@ -86,10 +76,8 @@ static void ConcurrentPoolingHelper(string connectionString, bool closeConnectio
                 });
             }
             Task.WaitAll(threads);
-            // set pooling timeout back to default to avoid impact on other test cases
-            SnowflakeDbConnectionPool.SetTimeout(3600);
         }
-
+        
         // thead to execute query with new connection in a loop
         static void QueryExecutionThread(string connectionString, bool closeConnection)
         {
@@ -130,45 +118,31 @@ static void QueryExecutionThread(string connectionString, bool closeConnection)
         }
 
         [Test]
-        public void TestBasicConnectionPool()
+        public void TestPoolContainsClosedConnections() // old name: TestConnectionPool
         {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
-
             var conn1 = new SnowflakeDbConnection(ConnectionString);
             conn1.Open();
             Assert.AreEqual(ConnectionState.Open, conn1.State);
             conn1.Close();
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-        }
-
-        [Test]
-        public void TestConnectionPool()
-        {
-            var conn1 = new SnowflakeDbConnection(ConnectionString);
-            conn1.Open();
-            Assert.AreEqual(ConnectionState.Open, conn1.State);
-            conn1.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
 
             var conn2 = new SnowflakeDbConnection();
             conn2.ConnectionString = ConnectionString;
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
 
             conn2.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(ConnectionState.Closed, conn2.State);
-            SnowflakeDbConnectionPool.ClearAllPools();
         }
-
+        
         [Test]
-        public void TestConnectionPoolIsFull()
+        public void TestPoolContainsAtMostMaxPoolSizeConnections() // old name: TestConnectionPoolFull
         {
             SnowflakeDbConnectionPool.SetMaxPoolSize(2);
+
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;
             conn1.Open();
@@ -178,93 +152,83 @@ public void TestConnectionPoolIsFull()
             conn2.ConnectionString = ConnectionString + " retryCount=1";
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
-
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            conn1.Close();
+            conn2.Close();
+            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
             var conn3 = new SnowflakeDbConnection();
             conn3.ConnectionString = ConnectionString + "  retryCount=2";
             conn3.Open();
             Assert.AreEqual(ConnectionState.Open, conn3.State);
-            SnowflakeDbConnectionPool.ClearAllPools();
 
-            conn1.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            conn2.Close();
-            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            var conn4 = new SnowflakeDbConnection();
+            conn4.ConnectionString = ConnectionString + "  retryCount=3";
+            conn4.Open();
+            Assert.AreEqual(ConnectionState.Open, conn4.State);
+
             conn3.Close();
             Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            conn4.Close();
+            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
 
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(ConnectionState.Closed, conn2.State);
             Assert.AreEqual(ConnectionState.Closed, conn3.State);
+            Assert.AreEqual(ConnectionState.Closed, conn4.State);
             SnowflakeDbConnectionPool.ClearAllPools();
         }
 
         [Test]
-        public void TestConnectionPoolExpirationWorks()
+        public void TestConnectionPoolDisableFromPoolManagerLevel()
         {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
-            SnowflakeDbConnectionPool.SetTimeout(10);
-
+            // arrange
+            SnowflakeDbConnectionPool.SetPooling(false);
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;
-
+            
+            // act
             conn1.Open();
+            
+            // assert
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+            
+            // act
             conn1.Close();
-            SnowflakeDbConnectionPool.SetTimeout(-1);
-
-            var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString;
-            conn2.Open();
-            conn2.Close();
-            var conn3 = new SnowflakeDbConnection();
-            conn3.ConnectionString = ConnectionString;
-            conn3.Open();
-            conn3.Close();
 
-            // The pooling timeout should apply to all connections being pooled,
-            // not just the connections created after the new setting,
-            // so expected result should be 0
+            // assert
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            SnowflakeDbConnectionPool.SetPooling(false);
         }
-
+        
         [Test]
-        public void TestConnectionPoolClean()
+        public void TestConnectionPoolDisable()
         {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
+            // arrange
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
+            pool.SetPooling(false);
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;
+            
+            // act
             conn1.Open();
+            
+            // assert
             Assert.AreEqual(ConnectionState.Open, conn1.State);
-
-            var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString + " retryCount=1";
-            conn2.Open();
-            Assert.AreEqual(ConnectionState.Open, conn2.State);
-
-            var conn3 = new SnowflakeDbConnection();
-            conn3.ConnectionString = ConnectionString + "  retryCount=2";
-            conn3.Open();
-            Assert.AreEqual(ConnectionState.Open, conn3.State);
-
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+            
+            // act
             conn1.Close();
-            conn2.Close();
-            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            SnowflakeDbConnectionPool.ClearAllPools();
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            conn3.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
 
+            // assert
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(ConnectionState.Closed, conn2.State);
-            Assert.AreEqual(ConnectionState.Closed, conn3.State);
-            SnowflakeDbConnectionPool.ClearAllPools();
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
         }
 
         [Test]
-        public void TestConnectionPoolFull()
+        public void TestConnectionPoolClean()
         {
             SnowflakeDbConnectionPool.SetMaxPoolSize(2);
-
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;
             conn1.Open();
@@ -274,126 +238,23 @@ public void TestConnectionPoolFull()
             conn2.ConnectionString = ConnectionString + " retryCount=1";
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            conn1.Close();
-            conn2.Close();
-            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
+
             var conn3 = new SnowflakeDbConnection();
             conn3.ConnectionString = ConnectionString + "  retryCount=2";
             conn3.Open();
             Assert.AreEqual(ConnectionState.Open, conn3.State);
 
-            var conn4 = new SnowflakeDbConnection();
-            conn4.ConnectionString = ConnectionString + "  retryCount=3";
-            conn4.Open();
-            Assert.AreEqual(ConnectionState.Open, conn4.State);
-
-            conn3.Close();
-            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            conn4.Close();
-            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(ConnectionState.Closed, conn2.State);
-            Assert.AreEqual(ConnectionState.Closed, conn3.State);
-            Assert.AreEqual(ConnectionState.Closed, conn4.State);
-            SnowflakeDbConnectionPool.ClearAllPools();
-        }
-
-        [Test]
-        public void TestConnectionPoolMultiThreading()
-        {
-            Thread t1 = new Thread(() => ThreadProcess1(ConnectionString));
-            Thread t2 = new Thread(() => ThreadProcess2(ConnectionString));
-
-            t1.Start();
-            t2.Start();
-
-            t1.Join();
-            t2.Join();
-        }
-
-        void ThreadProcess1(string connstr)
-        {
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = connstr;
-            conn1.Open();
-            Thread.Sleep(1000);
             conn1.Close();
-            Thread.Sleep(4000);
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-        }
-
-        void ThreadProcess2(string connstr)
-        {
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = connstr;
-            conn1.Open();
-
-            Thread.Sleep(5000);
-            SFStatement statement = new SFStatement(conn1.SfSession);
-            SFBaseResultSet resultSet = statement.Execute(0, "select 1", null, false);
-            Assert.AreEqual(true, resultSet.Next());
-            Assert.AreEqual("1", resultSet.GetString(0));
+            conn2.Close();
+            Assert.AreEqual(2, SnowflakeDbConnectionPool.GetCurrentPoolSize());
             SnowflakeDbConnectionPool.ClearAllPools();
-            SnowflakeDbConnectionPool.SetMaxPoolSize(0);
-            SnowflakeDbConnectionPool.SetPooling(false);
-        }
-
-        [Test]
-        public void TestConnectionPoolDisable()
-        {
-            SnowflakeDbConnectionPool.SetPooling(false);
-
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString;
-            conn1.Open();
-            Assert.AreEqual(ConnectionState.Open, conn1.State);
-            conn1.Close();
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-        }
-
-        [Test]
-        public void TestConnectionPoolWithDispose()
-        {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
-
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = "";
-            try
-            {
-                conn1.Open();
-            }
-            catch (SnowflakeDbException ex)
-            {
-                conn1.Close();
-            }
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(0, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-        }
-
-        [Test]
-        public void TestConnectionPoolTurnOff()
-        {
-            SnowflakeDbConnectionPool.SetPooling(false);
-            SnowflakeDbConnectionPool.SetPooling(true);
-            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
-            SnowflakeDbConnectionPool.ClearAllPools();
-
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString;
-            conn1.Open();
-            Assert.AreEqual(ConnectionState.Open, conn1.State);
-            conn1.Close();
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            conn3.Close();
             Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
 
-            SnowflakeDbConnectionPool.SetPooling(false);
-            //Put a breakpoint at SFSession close function, after connection pool is off, it will send close session request.
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(ConnectionState.Closed, conn2.State);
+            Assert.AreEqual(ConnectionState.Closed, conn3.State);
         }
     }
 }
diff --git a/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs b/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs
deleted file mode 100644
index eea852af2..000000000
--- a/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs
+++ /dev/null
@@ -1,2018 +0,0 @@
-/*
- * Copyright (c) 2012-2021 Snowflake Computing Inc. All rights reserved.
- */
-
-using System.Data.Common;
-
-namespace Snowflake.Data.Tests.IntegrationTests
-{
-    using NUnit.Framework;
-    using Snowflake.Data.Client;
-    using System.Data;
-    using System;
-    using Snowflake.Data.Core;
-    using System.Threading.Tasks;
-    using System.Threading;
-    using Snowflake.Data.Log;
-    using System.Diagnostics;
-    using Snowflake.Data.Tests.Mock;
-    using System.Runtime.InteropServices;
-
-    [TestFixture]
-    class SFConnectionIT : SFBaseTest
-    {
-        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SFConnectionIT>();
-
-        [Test]
-        public void TestBasicConnection()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-
-                Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-                // Data source is empty string for now
-                Assert.AreEqual("", ((SnowflakeDbConnection)conn).DataSource);
-
-                string serverVersion = ((SnowflakeDbConnection)conn).ServerVersion;
-                if (!string.Equals(serverVersion, "Dev"))
-                {
-                    string[] versionElements = serverVersion.Split('.');
-                    Assert.AreEqual(3, versionElements.Length);
-                }
-
-                conn.Close();
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestApplicationName()
-        {
-            string[] validApplicationNames = { "test1234", "test_1234", "test-1234", "test.1234"};
-            string[] invalidApplicationNames = { "1234test", "test$A", "test<script>" };
-
-            // Valid names
-            foreach (string appName in validApplicationNames)
-            {
-                using (IDbConnection conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString = ConnectionString;
-                    conn.ConnectionString += $"application={appName}";
-                    conn.Open();
-                    Assert.AreEqual(ConnectionState.Open, conn.State);
-
-                    conn.Close();
-                    Assert.AreEqual(ConnectionState.Closed, conn.State);
-                }
-            }
-
-            // Invalid names
-            foreach (string appName in invalidApplicationNames)
-            {
-                using (IDbConnection conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString = ConnectionString;
-                    conn.ConnectionString += $"application={appName}";
-                    try
-                    {
-                        conn.Open();
-                        s_logger.Debug("{appName}");
-                        Assert.Fail();
-
-                    }
-                    catch (SnowflakeDbException e)
-                    {
-                        // Expected
-                        s_logger.Debug("Failed opening connection ", e);
-                        AssertIsConnectionFailure(e);
-                    }
-
-                    Assert.AreEqual(ConnectionState.Closed, conn.State);
-                }
-            }
-        }
-
-        [Test]
-        public void TestIncorrectUserOrPasswordBasicConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = String.Format("scheme={0};host={1};port={2};" +
-            "account={3};role={4};db={5};schema={6};warehouse={7};user={8};password={9};",
-                    testConfig.protocol,
-                    testConfig.host,
-                    testConfig.port,
-                    testConfig.account,
-                    testConfig.role,
-                    testConfig.database,
-                    testConfig.schema,
-                    testConfig.warehouse,
-                    "unknown",
-                    testConfig.password);
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                
-                }
-                catch (SnowflakeDbException e)
-                {
-                    // Expected
-                    s_logger.Debug("Failed opening connection ", e);
-                    AssertIsConnectionFailure(e);
-                }
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-			}
-        }
-
-        [Test]
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestConnectionIsNotMarkedAsOpenWhenWasNotCorrectlyOpenedBefore(bool explicitClose)
-        {
-            for (int i = 0; i < 2; ++i)
-            {
-                s_logger.Debug($"Running try #{i}");
-                SnowflakeDbConnection snowflakeConnection = null;
-                try
-                {
-                    snowflakeConnection = new SnowflakeDbConnection(ConnectionStringWithInvalidUserName);
-                    snowflakeConnection.Open();
-                    Assert.Fail("Connection open should fail");
-                }
-                catch (SnowflakeDbException e)
-                {
-                    AssertIsConnectionFailure(e);
-                    AssertConnectionIsNotOpen(snowflakeConnection);
-                    if (explicitClose)
-                    {
-                        snowflakeConnection.Close();
-                        AssertConnectionIsNotOpen(snowflakeConnection);
-                    }
-                }
-            }
-        }
-
-        [Test]
-        public void TestConnectionIsNotMarkedAsOpenWhenWasNotCorrectlyOpenedWithUsingClause()
-        {
-            SnowflakeDbConnectionPool.SetPooling(true);
-            for (int i = 0; i < 2; ++i)
-            {
-                s_logger.Debug($"Running try #{i}");
-                SnowflakeDbConnection snowflakeConnection = null;
-                try
-                {
-                    using (snowflakeConnection = new SnowflakeDbConnection(ConnectionStringWithInvalidUserName))
-                    {
-                        snowflakeConnection.Open();
-                    }
-                }
-                catch (SnowflakeDbException e)
-                {
-                    AssertIsConnectionFailure(e);
-                    AssertConnectionIsNotOpen(snowflakeConnection);
-                }
-            }
-        }
-
-        private static void AssertConnectionIsNotOpen(SnowflakeDbConnection snowflakeDbConnection)
-        {
-            Assert.NotNull(snowflakeDbConnection);
-            Assert.IsFalse(snowflakeDbConnection.IsOpen()); // check via public method
-            Assert.AreEqual(ConnectionState.Closed, snowflakeDbConnection.State); // ensure internal state is expected
-        }
-
-        private static void AssertIsConnectionFailure(SnowflakeDbException e)
-        {
-            Assert.AreEqual(SnowflakeDbException.CONNECTION_FAILURE_SSTATE, e.SqlState);
-        }
-
-        [Test]
-        public void TestCrlCheckSwitchConnection()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString + ";INSECUREMODE=true";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString + ";INSECUREMODE=false";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString + ";INSECUREMODE=false";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString + ";INSECUREMODE=true";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestConnectString()
-        {
-            var schemaName = "dlSchema_" + Guid.NewGuid().ToString().Replace("-", "_");
-            var conn = new SnowflakeDbConnection();
-            conn.ConnectionString = ConnectionString;
-            conn.Open();
-            using (IDbCommand cmd = conn.CreateCommand())
-            {
-                //cmd.CommandText = "create database \"dlTest\"";
-                //cmd.ExecuteNonQuery();
-                //cmd.CommandText = "use database \"dlTest\"";
-                //cmd.ExecuteNonQuery();
-                cmd.CommandText = $"create schema \"{schemaName}\"";
-                cmd.ExecuteNonQuery();
-                cmd.CommandText = $"use schema \"{schemaName}\"";
-                cmd.ExecuteNonQuery();
-                //cmd.CommandText = "create table \"dlTest\".\"dlSchema\".test1 (col1 string, col2 int)";
-                cmd.CommandText = $"create table {TableName} (col1 string, col2 int)";
-                cmd.ExecuteNonQuery();
-                //cmd.CommandText = "insert into \"dlTest\".\"dlSchema\".test1 Values ('test 1', 1);";
-                cmd.CommandText = $"insert into {TableName} Values ('test 1', 1);";
-                cmd.ExecuteNonQuery();
-            }
-           
-            using (var conn1 = new SnowflakeDbConnection())
-            {
-                conn1.ConnectionString = String.Format("scheme={0};host={1};port={2};" +
-                    "account={3};role={4};db={5};schema={6};warehouse={7};user={8};password={9};",
-                        testConfig.protocol,
-                        testConfig.host,
-                        testConfig.port,
-                        testConfig.account,
-                        testConfig.role,
-                        //"\"dlTest\"",
-                        testConfig.database,
-                        $"\"{schemaName}\"",
-                        //testConfig.schema,
-                        testConfig.warehouse,
-                        testConfig.user,
-                        testConfig.password);
-                Assert.AreEqual(conn1.State, ConnectionState.Closed);
-
-                conn1.Open();
-                using (IDbCommand cmd = conn1.CreateCommand())
-                {
-                    cmd.CommandText = $"SELECT count(*) FROM {TableName}";
-                    IDataReader reader = cmd.ExecuteReader();
-                    Assert.IsTrue(reader.Read());
-                    Assert.AreEqual(1, reader.GetInt32(0));
-                }
-                conn1.Close();
-
-                Assert.AreEqual(ConnectionState.Closed, conn1.State); 
-            }
-            
-            using (IDbCommand cmd = conn.CreateCommand())
-            {
-                //cmd.CommandText = "drop database \"dlTest\"";
-                cmd.CommandText = $"drop schema \"{schemaName}\"";
-                cmd.ExecuteNonQuery();
-                cmd.CommandText = "use database " + testConfig.database;
-                cmd.ExecuteNonQuery();
-                cmd.CommandText = "use schema " + testConfig.schema;
-                cmd.ExecuteNonQuery();
-            }
-            conn.Close();
-        }
-
-        [Test]
-        [Ignore("TestConnectStringWithUserPwd, this will popup an internet browser for external login.")]
-        public void TestConnectStringWithUserPwd()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = String.Format("scheme={0};host={1};port={2};" +
-            "account={3};role={4};db={5};schema={6};warehouse={7};user={8};password={9};authenticator={10};",
-                    testConfig.protocol,
-                    testConfig.host,
-                    testConfig.port,
-                    testConfig.account,
-                    testConfig.role,
-                    testConfig.database,
-                    testConfig.schema,
-                    testConfig.warehouse,
-                    "",
-                    "",
-                    "externalbrowser");
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                conn.Open();
-                conn.Close();
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestConnectViaSecureString()
-        {
-            String[] connEntries = ConnectionString.Split(';');
-            String connectionStringWithoutPassword = "";
-            using (var conn = new SnowflakeDbConnection())
-            {
-                var password = new System.Security.SecureString();
-                foreach (String entry in connEntries)
-                {
-                    if (!entry.StartsWith("password="))
-                    {
-                        connectionStringWithoutPassword += entry;
-                        connectionStringWithoutPassword += ';';
-                    }
-                    else
-                    {
-                        var pass = entry.Substring(9);
-                        foreach (char c in pass)
-                        {
-                            password.AppendChar(c);
-                        }
-                    }
-                }
-                conn.ConnectionString = connectionStringWithoutPassword;
-                conn.Password = password;
-                conn.Open();
-
-                Assert.AreEqual(testConfig.database.ToUpper(), conn.Database);
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-
-                conn.Close();
-            }
-        }
-
-        [Test]
-        public void TestLoginTimeout()
-        {
-            using (IDbConnection conn = new MockSnowflakeDbConnection())
-            {
-                int timeoutSec = 5;
-                string loginTimeOut5sec = String.Format(ConnectionString + "connection_timeout={0};maxHttpRetries=0",
-                    timeoutSec);
-
-                conn.ConnectionString = loginTimeOut5sec;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (AggregateException e)
-                {
-                    // Jitter can cause the request to reach max number of retries before reaching the timeout
-                    Assert.IsTrue(e.InnerException is TaskCanceledException ||
-                        SFError.REQUEST_TIMEOUT.GetAttribute<SFErrorAttr>().errorCode ==
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-                }
-                stopwatch.Stop();
-                int delta = 10; // in case server time slower.
-
-                // Should timeout before the defined timeout plus 1 (buffer time)
-                Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (timeoutSec + 1) * 1000);
-                // Should timeout after the defined timeout since retry count is infinite
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, timeoutSec * 1000 - delta);
-
-                Assert.AreEqual(timeoutSec, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        public void TestLoginWithMaxRetryReached()
-        {
-            using (IDbConnection conn = new MockSnowflakeDbConnection())
-            {
-                string maxRetryConnStr = ConnectionString + "maxHttpRetries=5";
-
-                conn.ConnectionString = maxRetryConnStr;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (Exception e)
-                {
-                    // Jitter can cause the request to reach max number of retries before reaching the timeout
-                    Assert.IsTrue(e.InnerException is TaskCanceledException ||
-                        SFError.REQUEST_TIMEOUT.GetAttribute<SFErrorAttr>().errorCode ==
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-                }
-                stopwatch.Stop();
-
-                // retry 5 times with starting backoff of 1 second
-                // but should not delay more than the max possible seconds after 5 retries
-                // and should not take less time than the minimum possible seconds after 5 retries
-                Assert.Less(stopwatch.ElapsedMilliseconds, 79 * 1000);
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, 1 * 1000);
-            }
-        }
-
-        [Test]
-        public void TestLoginTimeoutWithRetryTimeoutLesserThanConnectionTimeout()
-        {
-            using (IDbConnection conn = new MockSnowflakeDbConnection())
-            {
-                int connectionTimeout = 600;
-                int retryTimeout = 350;
-                string loginTimeOut5sec = String.Format(ConnectionString + "connection_timeout={0};retry_timeout={1};maxHttpRetries=0",
-                    connectionTimeout, retryTimeout);
-
-                conn.ConnectionString = loginTimeOut5sec;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (AggregateException e)
-                {
-                    // Jitter can cause the request to reach max number of retries before reaching the timeout
-                    Assert.IsTrue(e.InnerException is TaskCanceledException ||
-                        SFError.REQUEST_TIMEOUT.GetAttribute<SFErrorAttr>().errorCode ==
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-                }
-                stopwatch.Stop();
-                int delta = 10; // in case server time slower.
-
-                // Should timeout before the defined timeout plus 1 (buffer time)
-                Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (retryTimeout + 1) * 1000);
-                // Should timeout after the defined timeout since retry count is infinite
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, retryTimeout * 1000 - delta);
-
-                Assert.AreEqual(retryTimeout, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        [Ignore("Disable unstable test cases for now")]
-        public void TestDefaultLoginTimeout()
-        {
-            using (IDbConnection conn = new MockSnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-
-                // Default timeout is 300 sec
-                Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {                    
-                    conn.Open();                    
-                    Assert.Fail();
-                }
-                catch (AggregateException e)
-                {
-                    if (e.InnerException is SnowflakeDbException)
-                    {
-                        Assert.AreEqual(SFError.REQUEST_TIMEOUT.GetAttribute<SFErrorAttr>().errorCode,
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-
-                        stopwatch.Stop();
-                        int delta = 10; // in case server time slower.
-
-                        // Should timeout after the default timeout (300 sec)
-                        Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, conn.ConnectionTimeout * 1000 - delta);
-                        // But never more because there's no connection timeout remaining
-                        Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (conn.ConnectionTimeout + 1) * 1000);
-                    }
-                }
-            }
-        }
-
-        [Test]
-        public void TestConnectionFailFast()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                // Just a way to get a 404 on the login request and make sure there are no retry
-                string invalidConnectionString = "host=docs.microsoft.com;"
-                    + "connection_timeout=0;account=testFailFast;user=testFailFast;password=testFailFast;";
-
-                conn.ConnectionString = invalidConnectionString;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (SnowflakeDbException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        e.ErrorCode);
-                }
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestEnableRetry()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                string invalidConnectionString = "host=docs.microsoft.com;"
-                    + "connection_timeout=0;account=testFailFast;user=testFailFast;password=testFailFast;disableretry=true;forceretryon404=true";
-                conn.ConnectionString = invalidConnectionString;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (SnowflakeDbException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        e.ErrorCode);
-                }
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestValidateDefaultParameters()
-        {
-            string connectionString = String.Format("scheme={0};host={1};port={2};" +
-            "account={3};role={4};db={5};schema={6};warehouse={7};user={8};password={9};",
-                    testConfig.protocol,
-                    testConfig.host,
-                    testConfig.port,
-                    testConfig.account,
-                    testConfig.role,
-                    testConfig.database,
-                    testConfig.schema,
-                    "WAREHOUSE_NEVER_EXISTS",
-                    testConfig.user,
-                    testConfig.password);
-
-            // By default should validate parameters
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                try
-                {
-                    conn.ConnectionString = connectionString;
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (SnowflakeDbException e)
-                {
-                    Assert.AreEqual(390201, e.ErrorCode);
-                }
-            }
-
-            // This should succeed
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = connectionString + ";VALIDATE_DEFAULT_PARAMETERS=false";
-                conn.Open();
-            }
-        }
-
-        [Test]
-        public void TestInvalidConnectionString()
-        {
-            string[] invalidStrings = {
-                // missing required connection property password
-                "ACCOUNT=testaccount;user=testuser",
-                // invalid account value
-                "ACCOUNT=A=C;USER=testuser;password=123;key",
-                "complete_invalid_string",
-            };
-
-            int[] expectedErrorCode = { 270006, 270008, 270008 };
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                for (int i = 0; i < invalidStrings.Length; i++)
-                {
-                    try
-                    {
-                        conn.ConnectionString = invalidStrings[i];
-                        conn.Open();
-                        Assert.Fail();
-                    }
-                    catch (SnowflakeDbException e)
-                    {
-                        Assert.AreEqual(expectedErrorCode[i], e.ErrorCode);
-                    }
-                }
-            }
-        }
-
-        [Test]
-        public void TestUnknownConnectionProperty()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                // invalid propety will be ignored.
-                conn.ConnectionString = ConnectionString + ";invalidProperty=invalidvalue;";
-
-                conn.Open();
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-                conn.Close();
-            }
-        }
-
-        [Test]
-        [IgnoreOnEnvIs("snowflake_cloud_env",
-                       new string[] { "AZURE", "GCP" })]
-        public void TestSwitchDb()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                conn.Open();
-
-                Assert.AreEqual(testConfig.database.ToUpper(), conn.Database);
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    conn.ChangeDatabase("SNOWFLAKE_SAMPLE_DATA");
-                    Assert.AreEqual("SNOWFLAKE_SAMPLE_DATA", conn.Database);
-                }
-
-                conn.ChangeDatabase(testConfig.database);
-                conn.Close();
-            }
-
-        }
-
-        [Test]
-        public void TestConnectWithoutHost()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                string connStrFmt = "account={0};user={1};password={2}";
-                conn.ConnectionString = string.Format(connStrFmt, testConfig.account,
-                    testConfig.user, testConfig.password);
-                // Check that connection succeeds if host is not specified in test configs, i.e. default should work.
-                if (string.IsNullOrEmpty(testConfig.host))
-                {
-                    conn.Open();
-                    Assert.AreEqual(conn.State, ConnectionState.Open);
-                    conn.Close();
-                }
-            }
-        }
-
-        [Test]
-        public void TestConnectWithDifferentRole()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                var host = testConfig.host;
-                if (string.IsNullOrEmpty(host))
-                {
-                    host = $"{testConfig.account}.snowflakecomputing.com";
-                }
-
-                string connStrFmt = "scheme={0};host={1};port={2};" +
-                    "user={3};password={4};account={5};role=public;db=snowflake_sample_data;schema=information_schema;warehouse=WH_NOT_EXISTED;validate_default_parameters=false";
-
-                conn.ConnectionString = string.Format(
-                    connStrFmt,
-                    testConfig.protocol,
-                    testConfig.host,
-                    testConfig.port,
-                    testConfig.user,
-                    testConfig.password,
-                    testConfig.account
-                    );
-                conn.Open();
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-
-                using (IDbCommand command = conn.CreateCommand())
-                {
-                    command.CommandText = "select current_role()";
-                    Assert.AreEqual(command.ExecuteScalar().ToString(), "PUBLIC");
-
-                    command.CommandText = "select current_database()";
-                    CollectionAssert.Contains(new[] { "SNOWFLAKE_SAMPLE_DATA", "" }, command.ExecuteScalar().ToString());
-
-                    command.CommandText = "select current_schema()";
-                    CollectionAssert.Contains(new[] { "INFORMATION_SCHEMA", "" }, command.ExecuteScalar().ToString());
-
-                    command.CommandText = "select current_warehouse()";
-                    // Command will return empty string if the hardcoded warehouse does not exist.
-                    Assert.AreEqual("", command.ExecuteScalar().ToString());
-                }
-                conn.Close();
-            }
-        }
-
-        // Test that when a connection is disposed, a close would send out and unfinished transaction would be roll back.
-        [Test]
-        public void TestConnectionDispose()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection(ConnectionString))
-            {
-                conn.Open();
-                CreateOrReplaceTable(conn, TableName, new []{"c INT"});
-                var t1 = conn.BeginTransaction();
-                var t1c1 = conn.CreateCommand();
-                t1c1.Transaction = t1;
-                t1c1.CommandText = $"insert into {TableName} values (1)";
-                t1c1.ExecuteNonQuery();
-            }
-
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                // Previous connection would be disposed and 
-                // uncommitted txn would rollback at this point
-                conn.ConnectionString = ConnectionString;
-                conn.Open();
-                IDbCommand command = conn.CreateCommand();
-                command.CommandText = $"SELECT * FROM {TableName}";
-                IDataReader reader = command.ExecuteReader();
-                Assert.IsFalse(reader.Read());
-            }
-        }
-
-        [Test]
-        public void TestUnknownAuthenticator()
-        {
-            string[] wrongAuthenticators = new string[]
-            {
-                "http://snowflakecomputing.okta.com",
-                "https://snowflake.com",
-                "unknown",
-            };
-
-            foreach (string wrongAuthenticator in wrongAuthenticators)
-            {
-                try
-                {
-                    IDbConnection conn = new SnowflakeDbConnection();
-                    conn.ConnectionString = "scheme=http;host=test;port=8080;user=test;password=test;account=test;authenticator=" + wrongAuthenticator;
-                    conn.Open();
-                    Assert.Fail("Authentication of {0} should fail", wrongAuthenticator);
-                }
-                catch (SnowflakeDbException e)
-                {
-                    Assert.AreEqual(SFError.UNKNOWN_AUTHENTICATOR.GetAttribute<SFErrorAttr>().errorCode, e.ErrorCode);
-                }
-
-            }
-        }
-
-        [Test]
-        [Ignore("This test requires manual setup and therefore cannot be run in CI")]
-        public void TestOktaConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator={0};user={1};password={2};",
-                        testConfig.oktaUrl,
-                        testConfig.oktaUser,
-                        testConfig.oktaPassword);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("This test requires manual setup and therefore cannot be run in CI")]
-        public void TestOkta2ConnectionsFollowingEachOther()
-        {
-            // This test is here because Cookies were messing up with sequential Okta connections
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator={0};user={1};password={2};",
-                        testConfig.oktaUrl,
-                        testConfig.oktaUser,
-                        testConfig.oktaPassword);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-
-
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator={0};user={1};password={2};",
-                        testConfig.oktaUrl,
-                        testConfig.oktaUser,
-                        testConfig.oktaPassword);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("This test requires manual interaction and therefore cannot be run in CI")]
-        public void TestSSOConnectionWithUser()
-        {
-            // Use external browser to log in using proper password for qa@snowflakecomputing.com
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + ";authenticator=externalbrowser;user=qa@snowflakecomputing.com";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-                using (IDbCommand command = conn.CreateCommand())
-                {
-                    command.CommandText = "SELECT CURRENT_USER()";
-                    Assert.AreEqual("QA", command.ExecuteScalar().ToString());
-                }
-            }
-        }
-
-        [Test]
-        [Ignore("This test requires manual interaction and therefore cannot be run in CI")]
-        public void TestSSOConnectionWithUserAsync()
-        {
-            // Use external browser to log in using proper password for qa@snowflakecomputing.com
-            using (SnowflakeDbConnection conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                      + ";authenticator=externalbrowser;user=qa@snowflakecomputing.com";
-
-                Task connectTask = conn.OpenAsync(CancellationToken.None);
-                connectTask.Wait();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-                using (DbCommand command = conn.CreateCommand())
-                {
-                    command.CommandText = "SELECT CURRENT_USER()";
-                    Task<object> task = command.ExecuteScalarAsync(CancellationToken.None);
-                    task.Wait(CancellationToken.None);
-                    Assert.AreEqual("QA", task.Result);
-                }
-            }
-        }
-        
-        [Test]
-        [Ignore("This test requires manual interaction and therefore cannot be run in CI")]
-        public void TestSSOConnectionTimeoutAfter10s()
-        {
-            // Do not log in by external browser - timeout after 10s should happen 
-            int waitSeconds = 10;
-            Stopwatch stopwatch = Stopwatch.StartNew();
-            Assert.Throws<SnowflakeDbException>(() =>
-                {
-                    using (IDbConnection conn = new SnowflakeDbConnection())
-                    {
-                        conn.ConnectionString
-                            = ConnectionStringWithoutAuth
-                              + $";authenticator=externalbrowser;user=qa@snowflakecomputing.com;BROWSER_RESPONSE_TIMEOUT={waitSeconds}";
-                        conn.Open();
-                        Assert.AreEqual(ConnectionState.Open, conn.State);
-                        using (IDbCommand command = conn.CreateCommand())
-                        {
-                            command.CommandText = "SELECT CURRENT_USER()";
-                            Assert.AreEqual("QA", command.ExecuteScalar().ToString());
-                        }
-                    }
-                }
-            );
-            stopwatch.Stop();
-
-            // timeout after specified number of seconds
-            Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, waitSeconds * 1000);
-            // and not later than 5s after expected time 
-            Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (waitSeconds + 5) * 1000);
-        }
-
-        [Test]
-        [Ignore("This test requires manual interaction and therefore cannot be run in CI")]
-        public void TestSSOConnectionWithWrongUser()
-        {
-            try
-            {
-                using (IDbConnection conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + ";authenticator=externalbrowser;user=wrong@snowflakecomputing.com";
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                Assert.AreEqual(390191, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtUnencryptedPemFileConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=snowflake_jwt;user={0};private_key_file={1}",
-                        testConfig.jwtAuthUser,
-                        testConfig.pemFilePath);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtUnencryptedP8FileConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=snowflake_jwt;user={0};private_key_file={1}",
-                        testConfig.jwtAuthUser,
-                        testConfig.p8FilePath);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtEncryptedPkFileConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=snowflake_jwt;user={0};private_key_file={1};private_key_pwd={2}",
-                        testConfig.jwtAuthUser,
-                        testConfig.pwdProtectedPrivateKeyFilePath,
-                        testConfig.privateKeyFilePwd);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtUnencryptedPkConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=snowflake_jwt;user={0};private_key={1}",
-                        testConfig.jwtAuthUser,
-                        testConfig.privateKey);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtEncryptedPkConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=snowflake_jwt;user={0};private_key={1};private_key_pwd={2}",
-                        testConfig.jwtAuthUser,
-                        testConfig.pwdProtectedPrivateKey,
-                        testConfig.privateKeyFilePwd);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtMissingConnectionSettingConnection()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + String.Format(
-                            ";authenticator=snowflake_jwt;user={0};private_key_pwd={1}",
-                            testConfig.jwtAuthUser,
-                            testConfig.privateKeyFilePwd);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Missing PRIVATE_KEY_FILE connection setting required for 
-                // authenticator =snowflake_jwt
-                Assert.AreEqual(270008, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtEncryptedPkFileInvalidPwdConnection()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + String.Format(
-                            ";authenticator=snowflake_jwt;user={0};private_key_file={1};private_key_pwd=Invalid",
-                            testConfig.jwtAuthUser,
-                            testConfig.pwdProtectedPrivateKeyFilePath);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Invalid password for decrypting the private key
-                Assert.AreEqual(270052, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtEncryptedPkFileNoPwdConnection()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + String.Format(
-                            ";authenticator=snowflake_jwt;user={0};private_key_file={1}",
-                            testConfig.jwtAuthUser,
-                            testConfig.pwdProtectedPrivateKeyFilePath);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Invalid password (none provided) for decrypting the private key
-                Assert.AreEqual(270052, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtConnectionWithWrongUser()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + String.Format(
-                            ";authenticator=snowflake_jwt;user={0};private_key_file={1}",
-                            "WrongUser",
-                            testConfig.pemFilePath);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Jwt token is invalid
-                Assert.AreEqual(390144, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestJwtEncryptedPkConnectionWithWrongUser()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + String.Format(
-                            ";authenticator=snowflake_jwt;user={0};private_key_file={1};private_key_pwd={2}",
-                            "WrongUser",
-                            testConfig.pwdProtectedPrivateKeyFilePath,
-                            testConfig.privateKeyFilePwd);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Jwt token is invalid
-                Assert.AreEqual(390144, e.ErrorCode);
-            }
-        }
-
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestValidOAuthConnection()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                    = ConnectionStringWithoutAuth
-                    + String.Format(
-                        ";authenticator=oauth;token={0}",
-                        testConfig.oauthToken);
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-            }
-        }
-
-        [Test]
-        public void TestInValidOAuthTokenConnection()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                        = ConnectionStringWithoutAuth
-                        + ";authenticator=oauth;token=notAValidOAuthToken";
-                    conn.Open();
-                    Assert.AreEqual(ConnectionState.Open, conn.State);
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                // Invalid OAuth access token
-                Assert.AreEqual(390303, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestValidOAuthExpiredTokenConnection()
-        {
-            try
-            {
-                using (var conn = new SnowflakeDbConnection())
-                {
-                    conn.ConnectionString
-                   = ConnectionStringWithoutAuth
-                   + String.Format(
-                       ";authenticator=oauth;token={0}",
-                       testConfig.expOauthToken);
-                    conn.Open();
-                    Assert.Fail();
-                }
-            }
-            catch (SnowflakeDbException e)
-            {
-                Console.Write(e);
-                // Token is expired
-                Assert.AreEqual(390318, e.ErrorCode);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestCorrectProxySettingFromConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                = ConnectionString
-                + String.Format(
-                    ";useProxy=true;proxyHost={0};proxyPort={1}",
-                    testConfig.proxyHost,
-                    testConfig.proxyPort);
-
-                conn.Open();
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestCorrectProxyWithCredsSettingFromConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                = ConnectionString
-                + String.Format(
-                    ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3}",
-                    testConfig.authProxyHost,
-                    testConfig.authProxyPort,
-                    testConfig.authProxyUser,
-                    testConfig.authProxyPwd);
-
-                conn.Open();
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestCorrectProxySettingWithByPassListFromConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                = ConnectionString
-                + String.Format(
-                    ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};nonProxyHosts={4}",
-                    testConfig.authProxyHost,
-                    testConfig.authProxyPort,
-                    testConfig.authProxyUser,
-                    testConfig.authProxyPwd,
-                    "*.foo.com %7C" + testConfig.host + "|localhost");
-
-                conn.Open();
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void TestMultipleConnectionWithDifferentHttpHandlerSettings()
-        {
-            // Authenticated proxy
-            using (var conn1 = new SnowflakeDbConnection())
-            {
-                conn1.ConnectionString = ConnectionString
-                    + String.Format(
-                        ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3}",
-                        testConfig.authProxyHost,
-                        testConfig.authProxyPort,
-                        testConfig.authProxyUser,
-                        testConfig.authProxyPwd);
-                conn1.Open();
-            }
-
-            // No proxy
-            using (var conn2 = new SnowflakeDbConnection())
-            {
-                conn2.ConnectionString = ConnectionString;
-                conn2.Open();
-            }
-
-            // Non authenticated proxy
-            using (var conn3 = new SnowflakeDbConnection())
-            {
-                conn3.ConnectionString = ConnectionString
-                + String.Format(
-                    ";useProxy=true;proxyHost={0};proxyPort={1}",
-                    testConfig.proxyHost,
-                    testConfig.proxyPort);
-                conn3.Open();
-            }
-
-            // Invalid proxy
-            using (var conn4 = new SnowflakeDbConnection())
-            {
-                conn4.ConnectionString =
-                    ConnectionString + "connection_timeout=20;useProxy=true;proxyHost=Invalid;proxyPort=8080;INSECUREMODE=true";
-                try
-                {
-                    conn4.Open();
-                    Assert.Fail();
-                }
-                catch
-                {
-                    // Expected
-                }
-            }
-
-            // Another authenticated proxy connection, same proxy but insecure mode is true
-			// Will use a different httpclient
-            using (var conn5 = new SnowflakeDbConnection())
-            {
-                conn5.ConnectionString = ConnectionString
-                    + String.Format(
-                        ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};INSECUREMODE=true",
-                        testConfig.authProxyHost,
-                        testConfig.authProxyPort,
-                        testConfig.authProxyUser,
-                        testConfig.authProxyPwd);
-                conn5.Open();
-            }
-
-            // No proxy again, but insecure mode is true
-			// Will use a different httpclient
-            using (var conn6 = new SnowflakeDbConnection())
-            {
-
-                conn6.ConnectionString = ConnectionString + ";INSECUREMODE=true";
-                conn6.Open();
-            }
-
-            // Another authenticated proxy, but this will create a new httpclient because there is
-            // a bypass list
-            using (var conn7 = new SnowflakeDbConnection())
-            {
-                conn7.ConnectionString
-              = ConnectionString
-              + String.Format(
-                  ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};nonProxyHosts={4}",
-                  testConfig.authProxyHost,
-                  testConfig.authProxyPort,
-                  testConfig.authProxyUser,
-                  testConfig.authProxyPwd,
-                  "*.foo.com %7C" + testConfig.host + "|localhost");
-
-                conn7.Open();
-            }
-
-            // No proxy again, insecure mode is false
-            // Should use same httpclient than conn2
-            using (var conn8 = new SnowflakeDbConnection())
-            {
-                conn8.ConnectionString = ConnectionString + ";INSECUREMODE=false";
-                conn8.Open();
-            }
-
-            // Another authenticated proxy with bypasslist, but this will create a new httpclient because 
-            // InsecureMode=true
-            using (var conn9 = new SnowflakeDbConnection())
-            {
-                conn9.ConnectionString
-              = ConnectionString
-              + String.Format(
-                  ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};nonProxyHosts={4};INSECUREMODE=true",
-                  testConfig.authProxyHost,
-                  testConfig.authProxyPort,
-                  testConfig.authProxyUser,
-                  testConfig.authProxyPwd,
-                  "*.foo.com %7C" + testConfig.host + "|localhost");
-
-                conn9.Open();
-            }
-
-            // Another authenticated proxy with bypasslist
-            // Should use same httpclient than conn7
-            using (var conn10 = new SnowflakeDbConnection())
-            {
-                conn10.ConnectionString
-              = ConnectionString
-              + String.Format(
-                  ";useProxy=true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};nonProxyHosts={4}",
-                  testConfig.authProxyHost,
-                  testConfig.authProxyPort,
-                  testConfig.authProxyUser,
-                  testConfig.authProxyPwd,
-                  "*.foo.com %7C" + testConfig.host + "|localhost");
-
-                conn10.Open();
-            }
-
-            // No proxy, but insecuremode=true
-            // Should use same httpclient than conn6
-            using (var conn11 = new SnowflakeDbConnection())
-            {
-                conn11.ConnectionString = ConnectionString+";INSECUREMODE=true";
-                conn11.Open();
-            }
-        }
-
-        [Test]
-        public void TestInvalidProxySettingFromConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-
-                conn.ConnectionString =
-                    ConnectionString + "connection_timeout=5;useProxy=true;proxyHost=Invalid;proxyPort=8080";
-                try
-                {
-                    conn.Open();
-                    Assert.Fail();
-                }
-                catch (SnowflakeDbException e)
-                {
-                    // Expected
-                    s_logger.Debug("Failed opening connection ", e);
-                    Assert.AreEqual(270001, e.ErrorCode); //Internal error
-                    AssertIsConnectionFailure(e);
-                }
-            }
-        }
-
-        [Test]
-        public void TestUseProxyFalseWithInvalidProxyConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString =
-                    ConnectionString + ";useProxy=false;proxyHost=Invalid;proxyPort=8080";
-                conn.Open();
-                // Because useProxy=false, the proxy settings are ignored
-            }
-        }
-
-        [Test]
-        public void TestInvalidProxySettingWithByPassListFromConnectionString()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString
-                = ConnectionString
-                + String.Format(
-                    ";useProxy=true;proxyHost=Invalid;proxyPort=8080;nonProxyHosts={0}",
-                    "*.foo.com %7C" + testConfig.account + ".snowflakecomputing.com|" + testConfig.host);
-                conn.Open();
-                // Because testConfig.host is in the bypass list, the proxy should not be used
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test until configuration is setup for CI integration. Can be run manually.")]
-        public void testMulitpleConnectionInParallel()
-        {
-            string baseConnectionString = ConnectionString + $";CONNECTION_TIMEOUT=30;";
-            string authenticatedProxy = String.Format("useProxy =true;proxyHost={0};proxyPort={1};proxyUser={2};proxyPassword={3};",
-                  testConfig.authProxyHost,
-                  testConfig.authProxyPort,
-                  testConfig.authProxyUser,
-                  testConfig.authProxyPwd);
-            string byPassList = "nonProxyHosts=*.foo.com %7C" + testConfig.host + "|localhost;";
-            string insecureModeTrue = "INSECUREMODE=true;";
-            string insecureModeFalse = "INSECUREMODE=false;";
-
-            string[] connectionStrings = {
-                baseConnectionString,
-                baseConnectionString + insecureModeFalse ,
-                baseConnectionString + insecureModeTrue,
-                baseConnectionString + authenticatedProxy,
-                baseConnectionString + authenticatedProxy + insecureModeFalse,
-                baseConnectionString + authenticatedProxy + insecureModeTrue,
-                baseConnectionString + authenticatedProxy + byPassList,
-                baseConnectionString + authenticatedProxy + byPassList + insecureModeFalse,
-                baseConnectionString + authenticatedProxy + byPassList + insecureModeTrue};
-
-            bool failed = false;
-
-           Task[] tasks = new Task[450];
-            for (int i = 0; i < 450; i++)
-            {
-                string connString = connectionStrings[i % (connectionStrings.Length)];
-                tasks[i] = Task.Run(() =>
-                {
-                    using (IDbConnection conn = new SnowflakeDbConnection())
-                    {
-                        conn.ConnectionString = connString;
-                        Console.WriteLine($"{conn.ConnectionString}");
-                        try
-                        {
-                            conn.Open();
-                        }
-                        catch (Exception e)
-                        {
-                            Console.WriteLine(e);
-                            Console.WriteLine("--------------------------");
-                            Console.WriteLine(e.InnerException);
-                            failed = true;
-                        }
-
-                        using (IDbCommand command = conn.CreateCommand())
-                        {
-                            try
-                            {
-                                command.CommandText = "SELECT 1";
-                                command.ExecuteScalar();
-                            }
-                            catch (Exception e)
-                            {
-                                Console.WriteLine("ExecuteScalar error");
-                                Console.WriteLine(e);
-                                failed = true;
-                            }
-                        }
-                    }
-                });
-            }
-            try
-            {
-                Task.WaitAll(tasks);
-            }
-            catch (AggregateException ae)
-            {
-                Console.WriteLine("One or more exceptions occurred: ");
-                foreach (var ex in ae.Flatten().InnerExceptions)
-                    Console.WriteLine("   {0}", ex.Message);
-                failed = true;
-            }
-
-            if (failed)
-            {
-                Assert.Fail();
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test, please test this manual with breakpoint at SFSessionProperty::parseConnectionString() to verify")]
-        public void TestEscapeChar()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                SnowflakeDbConnectionPool.SetPooling(false);
-                conn.ConnectionString = ConnectionString + "key1=test\'password;key2=test\"password;key3=test==password";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-
-                Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-                // Data source is empty string for now
-                Assert.AreEqual("", ((SnowflakeDbConnection)conn).DataSource);
-
-                string serverVersion = ((SnowflakeDbConnection)conn).ServerVersion;
-                if (!string.Equals(serverVersion, "Dev"))
-                {
-                    string[] versionElements = serverVersion.Split('.');
-                    Assert.AreEqual(3, versionElements.Length);
-                }
-
-                conn.Close();
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-
-        [Test]
-        [Ignore("Ignore this test, please test this manual with breakpoint at SFSessionProperty::parseConnectionString() to verify")]
-        public void TestEscapeChar1()
-        {
-            using (IDbConnection conn = new SnowflakeDbConnection())
-            {
-                SnowflakeDbConnectionPool.SetPooling(false);
-                conn.ConnectionString = ConnectionString + "key==word=value; key1=\"test;password\"; key2=\"test=password\"";
-                conn.Open();
-                Assert.AreEqual(ConnectionState.Open, conn.State);
-
-                Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-                // Data source is empty string for now
-                Assert.AreEqual("", ((SnowflakeDbConnection)conn).DataSource);
-
-                string serverVersion = ((SnowflakeDbConnection)conn).ServerVersion;
-                if (!string.Equals(serverVersion, "Dev"))
-                {
-                    string[] versionElements = serverVersion.Split('.');
-                    Assert.AreEqual(3, versionElements.Length);
-                }
-
-                conn.Close();
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-            }
-        }
-        
-        [Test]
-        [Ignore("Ignore this test. Please run this manually, since it takes 4 hrs to finish.")]
-        public void TestHeartBeat()
-        {
-            SnowflakeDbConnectionPool.SetPooling(false);
-            var conn = new SnowflakeDbConnection();
-            conn.ConnectionString = ConnectionString + ";CLIENT_SESSION_KEEP_ALIVE=true";
-            conn.Open();
-
-            Thread.Sleep(TimeSpan.FromSeconds(14430)); // more than 4 hrs
-            using (IDbCommand command = conn.CreateCommand())
-            {
-                command.CommandText = $"SELECT COUNT(*) FROM DOUBLE_TABLE";
-                Assert.AreEqual(command.ExecuteScalar(), 46 );
-            }
-
-            conn.Close();
-            Assert.AreEqual(ConnectionState.Closed, conn.State);
-        }
-
-        [Test]
-        [Ignore("Ignore this test. Please run this manually, since it takes 4 hrs to finish.")]
-        public void TestHeartBeatWithConnectionPool()
-        {
-            SnowflakeDbConnectionPool.ClearAllPools();
-            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
-            SnowflakeDbConnectionPool.SetTimeout(14800);
-            SnowflakeDbConnectionPool.SetPooling(true);
-
-            var conn = new SnowflakeDbConnection();
-            conn.ConnectionString = ConnectionString + ";CLIENT_SESSION_KEEP_ALIVE=true";
-            conn.Open();
-            conn.Close();
-
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-            
-            var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString + ";CLIENT_SESSION_KEEP_ALIVE=true";
-            conn1.Open();
-            Thread.Sleep(TimeSpan.FromSeconds(14430)); // more than 4 hrs
-
-            using (IDbCommand command = conn.CreateCommand())
-            {
-                command.CommandText = $"SELECT COUNT(*) FROM DOUBLE_TABLE";
-                Assert.AreEqual(command.ExecuteScalar(), 46);
-            }
-
-            conn1.Close();
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetCurrentPoolSize());
-        }
-
-        [Test]
-        public void TestKeepAlive()
-        {
-            // create 100 connections, one per second
-            var connCount = 100;
-            // pooled connectin expire in 5 seconds so after 5 seconds,
-            // one connection per second will be closed
-            SnowflakeDbConnectionPool.SetTimeout(5);
-            SnowflakeDbConnectionPool.SetMaxPoolSize(20);
-            // heart beat interval is validity/4 so send out per 5 seconds
-            HeartBeatBackground.setValidity(20);
-            try
-            {
-                for (int i = 0; i < connCount; i++)
-                {
-                    using (var conn = new SnowflakeDbConnection())
-                    {
-                        conn.ConnectionString = ConnectionString + ";CLIENT_SESSION_KEEP_ALIVE=true";
-                        conn.Open();
-                    }
-                    Thread.Sleep(TimeSpan.FromSeconds(1));
-                    // roughly should only have 5 sessions in pool stay alive
-                    // check for 10 in case of bad timing, also much less than the
-                    // pool max size to ensure it's unpooled because of expire
-                    Assert.Less(HeartBeatBackground.getQueueLength(), 10);
-                }
-            }
-            catch
-            {
-                // fail the test case if any exception is thrown
-                Assert.Fail();
-            }
-        }
-    }
-
-    [TestFixture]
-    class SFConnectionITAsync : SFBaseTestAsync
-    {
-        private static SFLogger logger = SFLoggerFactory.GetLogger<SFConnectionITAsync>();
-
-
-        [Test]
-        public void TestCancelLoginBeforeTimeout()
-        {
-            using (var conn = new MockSnowflakeDbConnection())
-            {
-                // No timeout
-                int timeoutSec = 0;
-                string infiniteLoginTimeOut = String.Format(ConnectionString + ";connection_timeout={0};maxHttpRetries=0",
-                    timeoutSec);
-
-                conn.ConnectionString = infiniteLoginTimeOut;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                // At this point the connection string has not been parsed, it will return the 
-                // default value
-                //Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-
-                CancellationTokenSource connectionCancelToken = new CancellationTokenSource();
-                Task connectTask = conn.OpenAsync(connectionCancelToken.Token);
-
-                // Sleep for more than the default timeout to make sure there are no false positive)
-                Thread.Sleep((SFSessionHttpClientProperties.s_retryTimeoutDefault + 10) * 1000);
-
-                Assert.AreEqual(ConnectionState.Connecting, conn.State);
-
-                // Cancel the connection because it will never succeed since there is no 
-                // connection_timeout defined
-                logger.Debug("connectionCancelToken.Cancel ");
-                connectionCancelToken.Cancel();
-
-                try
-                {
-                    connectTask.Wait();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(
-                        "System.Threading.Tasks.TaskCanceledException",
-                        e.InnerException.GetType().ToString());
-                    
-                }
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-                Assert.AreEqual(timeoutSec, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        public void TestAsyncLoginTimeout()
-        {
-            using (var conn = new MockSnowflakeDbConnection())
-            {
-                int timeoutSec = 5;
-                string loginTimeOut5sec = String.Format(ConnectionString + "connection_timeout={0};maxHttpRetries=0",
-                    timeoutSec);
-                conn.ConnectionString = loginTimeOut5sec;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    Task connectTask = conn.OpenAsync(CancellationToken.None);
-                    connectTask.Wait();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-
-                }
-                stopwatch.Stop();
-                int delta = 10; // in case server time slower.
-
-                // Should timeout after the defined timeout since retry count is infinite
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, timeoutSec * 1000 - delta);
-                // But never more than 1 sec (buffer time) after the defined timeout
-                Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (timeoutSec + 1) * 1000);
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-                Assert.AreEqual(timeoutSec, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        public void TestAsyncLoginTimeoutWithRetryTimeoutLesserThanConnectionTimeout()
-        {
-            using (var conn = new MockSnowflakeDbConnection())
-            {
-                int connectionTimeout = 600;
-                int retryTimeout = 350;
-                string loginTimeOut5sec = String.Format(ConnectionString + "connection_timeout={0};retry_timeout={1};maxHttpRetries=0",
-                    connectionTimeout, retryTimeout);
-                conn.ConnectionString = loginTimeOut5sec;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    Task connectTask = conn.OpenAsync(CancellationToken.None);
-                    connectTask.Wait();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-
-                }
-                stopwatch.Stop();
-                int delta = 10; // in case server time slower.
-
-                // Should timeout after the defined timeout since retry count is infinite
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, retryTimeout * 1000 - delta);
-                // But never more than 1 sec (buffer time) after the defined timeout
-                Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (retryTimeout + 1) * 1000);
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-                Assert.AreEqual(retryTimeout, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        public void TestAsyncDefaultLoginTimeout()
-        {
-            using (var conn = new MockSnowflakeDbConnection())
-            {
-                // unlimited retry count to trigger the timeout
-                conn.ConnectionString = ConnectionString + "maxHttpRetries=0";
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                Stopwatch stopwatch = Stopwatch.StartNew();
-                try
-                {
-                    Task connectTask = conn.OpenAsync(CancellationToken.None);
-                    connectTask.Wait();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-                }
-                stopwatch.Stop();
-                int delta = 10; // in case server time slower.
-
-                // Should timeout after the default timeout (300 sec)
-                Assert.GreaterOrEqual(stopwatch.ElapsedMilliseconds, conn.ConnectionTimeout * 1000 - delta);
-                // But never more because there's no connection timeout remaining
-                Assert.LessOrEqual(stopwatch.ElapsedMilliseconds, (conn.ConnectionTimeout + 1) * 1000);
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-                Assert.AreEqual(SFSessionHttpClientProperties.s_retryTimeoutDefault, conn.ConnectionTimeout);
-            }
-        }
-
-        [Test]
-        public void TestAsyncConnectionFailFast()
-        {
-            using (var conn = new SnowflakeDbConnection())
-            {
-                // Just a way to get a 404 on the login request and make sure there are no retry
-                string invalidConnectionString = "host=docs.microsoft.com;"
-                    + "connection_timeout=0;account=testFailFast;user=testFailFast;password=testFailFast;";
-
-                conn.ConnectionString = invalidConnectionString;
-
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Task connectTask = null;
-                try
-                {
-                    connectTask = conn.OpenAsync(CancellationToken.None);
-                    connectTask.Wait();
-                    Assert.Fail();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(SFError.INTERNAL_ERROR.GetAttribute<SFErrorAttr>().errorCode,
-                        ((SnowflakeDbException)e.InnerException).ErrorCode);
-                }
-
-                Assert.AreEqual(ConnectionState.Closed, conn.State);
-                Assert.IsTrue(connectTask.IsFaulted);
-            }
-        }
-
-        [Test]
-        public void TestCloseAsyncWithCancellation()
-        {
-            // https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbconnection.close
-            // https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbconnection.closeasync
-            // An application can call Close or CloseAsync more than one time. 
-            // No exception is generated.
-            using (var conn = new SnowflakeDbConnection())
-            {
-                conn.ConnectionString = ConnectionString;
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Task task = null;
-
-                // Close the connection. It's not opened yet, but it should not have any issue
-                task = conn.CloseAsync(CancellationToken.None);
-                task.Wait();
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                // Open the connection
-                task = conn.OpenAsync(CancellationToken.None);
-                task.Wait();
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-
-                // Close the opened connection
-                task = conn.CloseAsync(CancellationToken.None);
-                task.Wait();
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-                // Close the connection again.
-                task = conn.CloseAsync(CancellationToken.None);
-                task.Wait();
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-            }
-		}
-
-#if NETCOREAPP3_0_OR_GREATER
-		[Test]
-		public void TestCloseAsync()
-		{
-			// https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbconnection.close
-			// https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbconnection.closeasync
-			// An application can call Close or CloseAsync more than one time. 
-			// No exception is generated.
-			using (var conn = new SnowflakeDbConnection())
-			{
-				conn.ConnectionString = ConnectionString;
-				Assert.AreEqual(conn.State, ConnectionState.Closed);
-				Task task = null;
-
-				// Close the connection. It's not opened yet, but it should not have any issue
-				task = conn.CloseAsync();
-				task.Wait();
-				Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-				// Open the connection
-				task = conn.OpenAsync();
-				task.Wait();
-				Assert.AreEqual(conn.State, ConnectionState.Open);
-
-				// Close the opened connection
-				task = conn.CloseAsync();
-				task.Wait();
-				Assert.AreEqual(conn.State, ConnectionState.Closed);
-
-				// Close the connection again.
-				task = conn.CloseAsync();
-				task.Wait();
-				Assert.AreEqual(conn.State, ConnectionState.Closed);
-			}
-		}
-#endif
-
-        [Test]
-        public void TestCloseAsyncFailure()
-        {
-            using (var conn = new MockSnowflakeDbConnection(new MockCloseSessionException()))
-            {
-                conn.ConnectionString = ConnectionString;
-                Assert.AreEqual(conn.State, ConnectionState.Closed);
-                Task task = null;
-
-                // Open the connection
-                task = conn.OpenAsync(CancellationToken.None);
-                task.Wait();
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-
-                // Close the opened connection
-                task =  conn.CloseAsync(CancellationToken.None);
-                try
-                {
-                    task.Wait();
-                    Assert.Fail();
-                }
-                catch (AggregateException e)
-                {
-                    Assert.AreEqual(MockCloseSessionException.SESSION_CLOSE_ERROR,
-                        ((SnowflakeDbException)(e.InnerException).InnerException).ErrorCode);
-                }
-                Assert.AreEqual(conn.State, ConnectionState.Open);
-            }
-        }
-
-        [Test]
-        public void TestExplicitTransactionOperationsTracked()
-        {
-            using (var conn = new SnowflakeDbConnection(ConnectionString))
-            {
-                conn.Open();
-                Assert.AreEqual(false, conn.HasActiveExplicitTransaction());
-
-                var trans = conn.BeginTransaction();
-                Assert.AreEqual(true, conn.HasActiveExplicitTransaction());
-                trans.Rollback();
-                Assert.AreEqual(false, conn.HasActiveExplicitTransaction());
-
-                conn.BeginTransaction().Rollback();
-                Assert.AreEqual(false, conn.HasActiveExplicitTransaction());
-                
-                conn.BeginTransaction().Commit();
-                Assert.AreEqual(false, conn.HasActiveExplicitTransaction());
-            }
-        }
-    }
-}
-
-
diff --git a/Snowflake.Data.Tests/UnitTests/ConnectionPoolManagerTest.cs b/Snowflake.Data.Tests/UnitTests/ConnectionPoolManagerTest.cs
new file mode 100644
index 000000000..ebcb85c5c
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/ConnectionPoolManagerTest.cs
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 2023 Snowflake Computing Inc. All rights reserved.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Snowflake.Data.Core;
+using Snowflake.Data.Core.Session;
+using Moq;
+using Snowflake.Data.Client;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.UnitTests
+{
+    [TestFixture, NonParallelizable]
+    class ConnectionPoolManagerTest
+    {
+        private readonly ConnectionPoolManager _connectionPoolManager = new ConnectionPoolManager();
+        private const string ConnectionString1 = "database=D1;warehouse=W1;account=A1;user=U1;password=P1;role=R1;";
+        private const string ConnectionString2 = "database=D2;warehouse=W2;account=A2;user=U2;password=P2;role=R2;";
+        private readonly SecureString _password = new SecureString();
+        private static PoolConfig s_poolConfig;
+
+        [OneTimeSetUp] 
+        public static void BeforeAllTests()
+        {
+            s_poolConfig = new PoolConfig();
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.MultipleConnectionPool);
+            SessionPool.SessionFactory = new MockSessionFactory();
+        }
+        
+        [OneTimeTearDown]
+        public void AfterAllTests()
+        {
+            s_poolConfig.Reset();
+            SessionPool.SessionFactory = new SessionFactory();
+        }
+
+        [Test]
+        public void TestPoolManagerReturnsSessionPoolForGivenConnectionString()
+        {
+            // Act
+            var sessionPool = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            
+            // Assert
+            Assert.AreEqual(ConnectionString1, sessionPool.ConnectionString);
+            Assert.AreEqual(_password, sessionPool.Password);
+        }
+        
+        [Test]
+        public void TestPoolManagerReturnsSamePoolForGivenConnectionString()
+        {
+            // Arrange
+            var anotherConnectionString = ConnectionString1;
+            
+            // Act
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(anotherConnectionString, _password);
+            
+            // Assert
+            Assert.AreEqual(sessionPool1, sessionPool2);
+        }
+        
+        [Test]
+        public void TestDifferentPoolsAreReturnedForDifferentConnectionStrings()
+        {
+            // Arrange
+            Assert.AreNotSame(ConnectionString1, ConnectionString2);
+            
+            // Act
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            
+            // Assert
+            Assert.AreNotSame(sessionPool1, sessionPool2);
+            Assert.AreEqual(ConnectionString1, sessionPool1.ConnectionString);
+            Assert.AreEqual(ConnectionString2, sessionPool2.ConnectionString);
+        }
+        
+                
+        [Test]
+        public void TestGetSessionWorksForSpecifiedConnectionString()
+        {
+            // Act
+            var sfSession = _connectionPoolManager.GetSession(ConnectionString1, _password);
+            
+            // Assert
+            Assert.AreEqual(ConnectionString1, sfSession.ConnectionString);
+            Assert.AreEqual(_password, sfSession.Password);
+        }
+
+        [Test]
+        public async Task TestGetSessionAsyncWorksForSpecifiedConnectionString()
+        {
+            // Act
+            var sfSession = await _connectionPoolManager.GetSessionAsync(ConnectionString1, _password, CancellationToken.None);
+            
+            // Assert
+            Assert.AreEqual(ConnectionString1, sfSession.ConnectionString);
+            Assert.AreEqual(_password, sfSession.Password);
+        }
+
+        [Test]
+        [Ignore("Enable after completion of SNOW-937189")] // TODO: 
+        public void TestCountingOfSessionProvidedByPool()
+        {
+            // Act
+            _connectionPoolManager.GetSession(ConnectionString1, _password);
+            
+            // Assert
+            var sessionPool = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            Assert.AreEqual(1, sessionPool.GetCurrentPoolSize());
+        }
+        
+        [Test]
+        public void TestCountingOfSessionReturnedBackToPool()
+        {
+            // Arrange
+            var sfSession = _connectionPoolManager.GetSession(ConnectionString1, _password);
+            
+            // Act
+            _connectionPoolManager.AddSession(sfSession);
+            
+            // Assert
+            var sessionPool = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            Assert.AreEqual(1, sessionPool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestSetMaxPoolSizeForAllPools()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+
+            // Act
+            _connectionPoolManager.SetMaxPoolSize(3);
+
+            // Assert
+            Assert.AreEqual(3, sessionPool1.GetMaxPoolSize());
+            Assert.AreEqual(3, sessionPool2.GetMaxPoolSize());
+        }
+         
+        [Test]
+        public void TestSetTimeoutForAllPools()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            
+            // Act
+            _connectionPoolManager.SetTimeout(3000);
+            
+            // Assert
+            Assert.AreEqual(3000, sessionPool1.GetTimeout());
+            Assert.AreEqual(3000, sessionPool2.GetTimeout());
+        }         
+        
+        [Test]
+        [Ignore("Enable when disabling pooling in connection string enabled - SNOW-902632")]
+        public void TestSetPoolingDisabledForAllPoolsNotPossible()
+        {
+            // Arrange
+            _connectionPoolManager.GetPool(ConnectionString1, _password);
+
+            // Act
+            var thrown = Assert.Throws<Exception>(() => _connectionPoolManager.SetPooling(false));
+            
+            // Assert
+            Assert.IsNotNull(thrown);
+        }
+
+        [Test]
+        public void TestGetPoolingOnManagerLevelWhenNotAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetPooling(true);
+            sessionPool2.SetPooling(false);
+            
+            // Act/Assert
+            var exception = Assert.Throws<SnowflakeDbException>(() => _connectionPoolManager.GetPooling());
+            Assert.IsNotNull(exception);
+            Assert.AreEqual(SFError.INCONSISTENT_RESULT_ERROR.GetAttribute<SFErrorAttr>().errorCode, exception.ErrorCode);
+            Assert.IsTrue(exception.Message.Contains("Multiple pools have different Pooling values"));
+        }
+
+        [Test]
+        public void TestGetPoolingOnManagerLevelWorksWhenAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetPooling(true);
+            sessionPool2.SetPooling(true);
+            
+            // Act/Assert
+            Assert.AreEqual(true,_connectionPoolManager.GetPooling());
+        }
+
+        [Test]
+        public void TestGetTimeoutOnManagerLevelWhenNotAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetTimeout(299);
+            sessionPool2.SetTimeout(1313);
+            
+            // Act/Assert
+            var exception = Assert.Throws<SnowflakeDbException>(() => _connectionPoolManager.GetTimeout());
+            Assert.IsNotNull(exception);
+            Assert.AreEqual(SFError.INCONSISTENT_RESULT_ERROR.GetAttribute<SFErrorAttr>().errorCode, exception.ErrorCode);
+            Assert.IsTrue(exception.Message.Contains("Multiple pools have different Timeout values"));
+        }
+
+        [Test]
+        public void TestGetTimeoutOnManagerLevelWhenAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetTimeout(3600);
+            sessionPool2.SetTimeout(3600);
+            
+            // Act/Assert
+            Assert.AreEqual(3600,_connectionPoolManager.GetTimeout());
+        }
+
+        [Test]
+        public void TestGetMaxPoolSizeOnManagerLevelWhenNotAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetMaxPoolSize(1);
+            sessionPool2.SetMaxPoolSize(17);
+            
+            // Act/Assert
+            var exception = Assert.Throws<SnowflakeDbException>(() => _connectionPoolManager.GetMaxPoolSize());
+            Assert.IsNotNull(exception);
+            Assert.AreEqual(SFError.INCONSISTENT_RESULT_ERROR.GetAttribute<SFErrorAttr>().errorCode, exception.ErrorCode);
+            Assert.IsTrue(exception.Message.Contains("Multiple pools have different Max Pool Size values"));
+        }
+        
+        [Test]
+        public void TestGetMaxPoolSizeOnManagerLevelWhenAllPoolsEqual()
+        {
+            // Arrange
+            var sessionPool1 = _connectionPoolManager.GetPool(ConnectionString1, _password);
+            var sessionPool2 = _connectionPoolManager.GetPool(ConnectionString2, _password);
+            sessionPool1.SetMaxPoolSize(33);
+            sessionPool2.SetMaxPoolSize(33);
+            
+            // Act/Assert
+            Assert.AreEqual(33,_connectionPoolManager.GetMaxPoolSize());
+        }
+
+        [Test]
+        public void TestGetCurrentPoolSizeThrowsExceptionWhenNotAllPoolsEqual()
+        {
+            // Arrange
+            EnsurePoolSize(ConnectionString1, 2);
+            EnsurePoolSize(ConnectionString2, 3);
+            
+            // Act/Assert
+            var exception = Assert.Throws<SnowflakeDbException>(() => _connectionPoolManager.GetCurrentPoolSize());
+            Assert.IsNotNull(exception);
+            Assert.AreEqual(SFError.INCONSISTENT_RESULT_ERROR.GetAttribute<SFErrorAttr>().errorCode, exception.ErrorCode);
+            Assert.IsTrue(exception.Message.Contains("Multiple pools have different Current Pool Size values"));
+        }
+        
+        private void EnsurePoolSize(string connectionString, int requiredCurrentSize)
+        {
+            var sessionPool = _connectionPoolManager.GetPool(connectionString, _password);
+            sessionPool.SetMaxPoolSize(requiredCurrentSize);
+            var busySessions = new List<SFSession>();
+            for (var i = 0; i < requiredCurrentSize; i++)
+            {
+                var sfSession = _connectionPoolManager.GetSession(connectionString, _password);
+                busySessions.Add(sfSession);
+            }
+
+            foreach (var session in busySessions) // TODO: remove after SNOW-937189 since sessions will be already counted by GetCurrentPool size
+            {
+                session.close();
+                _connectionPoolManager.AddSession(session);
+            }
+            
+            Assert.AreEqual(requiredCurrentSize, sessionPool.GetCurrentPoolSize());
+        }
+    }
+
+    class MockSessionFactory : ISessionFactory
+    {
+        public SFSession NewSession(string connectionString, SecureString password)
+        {
+            var mockSfSession = new Mock<SFSession>(connectionString, password);
+            mockSfSession.Setup(x => x.Open()).Verifiable();
+            mockSfSession.Setup(x => x.OpenAsync(default)).Returns(Task.FromResult(this));
+            mockSfSession.Setup(x => x.IsNotOpen()).Returns(false);
+            mockSfSession.Setup(x => x.IsExpired(It.IsAny<long>(), It.IsAny<long>())).Returns(false);
+            return mockSfSession.Object;
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokenTest.cs b/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokenTest.cs
new file mode 100644
index 000000000..17b48403d
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokenTest.cs
@@ -0,0 +1,38 @@
+using System;
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class CreateSessionTokenTest
+    {
+        private readonly long _timeout = 30000; // 30 seconds in millis
+        
+        [Test]
+        public void TestTokenIsNotExpired()
+        {
+            // arrange
+            var token = new CreateSessionToken(_timeout);
+
+            // act
+            var isExpired = token.IsExpired(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+            
+            // assert
+            Assert.IsFalse(isExpired);
+        }
+        
+        [Test]
+        public void TestTokenIsExpired()
+        {
+            // arrange
+            var token = new CreateSessionToken(_timeout);
+
+            // act
+            var isExpired = token.IsExpired(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + _timeout + 1);
+
+            // assert
+            Assert.IsTrue(isExpired);
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokensTest.cs b/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokensTest.cs
new file mode 100644
index 000000000..bc341df44
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/CreateSessionTokensTest.cs
@@ -0,0 +1,83 @@
+using System.Threading;
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class CreateSessionTokensTest
+    {
+        [Test]
+        public void TestGrantSessionCreation()
+        {
+            // arrange
+            var tokens = new CreateSessionTokens();
+            
+            // act
+            tokens.BeginCreate();
+            
+            // assert
+            Assert.AreEqual(1, tokens.Count());
+            
+            // act
+            tokens.BeginCreate();
+            
+            // assert
+            Assert.AreEqual(2, tokens.Count());
+        }
+
+        [Test]
+        public void TestCompleteSessionCreation()
+        {
+            // arrange
+            var tokens = new CreateSessionTokens();
+            var token1 = tokens.BeginCreate();
+            var token2 = tokens.BeginCreate();
+            
+            // act
+            tokens.EndCreate(token1);
+            
+            // assert
+            Assert.AreEqual(1, tokens.Count());
+            
+            // act
+            tokens.EndCreate(token2);
+            
+            // assert
+            Assert.AreEqual(0, tokens.Count());
+        }
+
+        [Test]
+        public void TestCompleteUnknownTokenDoesNotThrowExceptions()
+        {
+            // arrange
+            var tokens = new CreateSessionTokens();
+            tokens.BeginCreate();
+            var unknownToken = new CreateSessionToken(0);
+            
+            // act
+            tokens.EndCreate(unknownToken);
+
+            // assert
+            Assert.AreEqual(1, tokens.Count());
+        }
+
+        [Test]
+        public void TestCompleteCleansExpiredTokens()
+        {
+            // arrange
+            var tokens = new CreateSessionTokens();
+            tokens._timeout = 50;
+            var token = tokens.BeginCreate();
+            tokens.BeginCreate(); // this token will be cleaned because of expiration
+            Assert.AreEqual(2, tokens.Count());
+            Thread.Sleep((int) tokens._timeout);
+
+            // act
+            tokens.EndCreate(token);
+            
+            // assert
+            Assert.AreEqual(0, tokens.Count());
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/FixedZeroCounterTest.cs b/Snowflake.Data.Tests/UnitTests/Session/FixedZeroCounterTest.cs
new file mode 100644
index 000000000..79653ef63
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/FixedZeroCounterTest.cs
@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class FixedZeroCounterTest
+    {
+        [Test]
+        public void TestInitialZero()
+        {
+            // arrange
+            var counter = new FixedZeroCounter();
+            
+            // act
+            var count = counter.Count();
+            
+            // assert
+            Assert.AreEqual(0, count);
+        }
+
+        [Test]
+        public void TestZeroAfterIncrease()
+        {
+            // arrange
+            var counter = new FixedZeroCounter();
+            
+            // act
+            counter.Increase();
+
+            // assert
+            Assert.AreEqual(0, counter.Count());
+        }
+        
+        [Test]
+        public void TestZeroAfterDecrease()
+        {
+            // arrange
+            var counter = new FixedZeroCounter();
+            
+            // act
+            counter.Decrease();
+
+            // assert
+            Assert.AreEqual(0, counter.Count());
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/NoOneWaitingTest.cs b/Snowflake.Data.Tests/UnitTests/Session/NoOneWaitingTest.cs
new file mode 100644
index 000000000..b3f9e4c50
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/NoOneWaitingTest.cs
@@ -0,0 +1,55 @@
+using System.Diagnostics;
+using System.Threading;
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class NoOneWaitingTest
+    {
+        [Test]
+        public void TestWaitDoesNotHangAndReturnsFalse()
+        {
+            // arrange
+            var noOneWaiting = new NoOneWaiting();
+            var watch = new Stopwatch();
+            
+            // act
+            watch.Start();
+            var result = noOneWaiting.Wait(10000, CancellationToken.None);
+            watch.Stop();
+            
+            // assert
+            Assert.IsFalse(result);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 50);
+        }
+
+        [Test]
+        public void TestNoOneIsWaiting()
+        {
+            // arrange
+            var noOneWaiting = new NoOneWaiting();
+            noOneWaiting.Wait(10000, CancellationToken.None);
+            
+            // act
+            var isAnyoneWaiting = noOneWaiting.IsAnyoneWaiting();
+            
+            // assert
+            Assert.IsFalse(isAnyoneWaiting);
+        }
+
+        [Test]
+        public void TestWaitingDisabled()
+        {
+            // arrange
+            var noOneWaiting = new NoOneWaiting();
+
+            // act
+            var isWaitingEnabled = noOneWaiting.IsWaitingEnabled();
+            
+            // assert
+            Assert.IsFalse(isWaitingEnabled);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Snowflake.Data.Tests/UnitTests/Session/NonNegativeCounterTest.cs b/Snowflake.Data.Tests/UnitTests/Session/NonNegativeCounterTest.cs
new file mode 100644
index 000000000..7b63126f4
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/NonNegativeCounterTest.cs
@@ -0,0 +1,76 @@
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class NonNegativeCounterTest
+    {
+        [Test]
+        public void TestInitialZero()
+        {
+            // arrange
+            var counter = new NonNegativeCounter();
+
+            // act
+            var count = counter.Count();
+
+            // assert
+            Assert.AreEqual(0, count);
+        }
+
+        [Test]
+        public void TestIncrease()
+        {
+            // arrange
+            var counter = new NonNegativeCounter();
+
+            // act
+            counter.Increase();
+
+            // assert
+            Assert.AreEqual(1, counter.Count());
+
+            // act
+            counter.Increase();
+
+            // assert
+            Assert.AreEqual(2, counter.Count());
+        }
+
+
+        [Test]
+        public void TestDecrease()
+        {
+            // arrange
+            var counter = new NonNegativeCounter();
+            counter.Increase();
+            counter.Increase();
+
+            // act
+            counter.Decrease();
+
+            // assert
+            Assert.AreEqual(1, counter.Count());
+
+            // act
+            counter.Decrease();
+
+            // assert
+            Assert.AreEqual(0, counter.Count());
+        }
+
+        [Test]
+        public void TestDecreaseDoesNotGoBelowZero()
+        {
+            // arrange
+            var counter = new NonNegativeCounter();
+
+            // act
+            counter.Decrease();
+
+            // assert
+            Assert.AreEqual(0, counter.Count());
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/NotCountingCreateSessionTokensTest.cs b/Snowflake.Data.Tests/UnitTests/Session/NotCountingCreateSessionTokensTest.cs
new file mode 100644
index 000000000..7be440d23
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/NotCountingCreateSessionTokensTest.cs
@@ -0,0 +1,51 @@
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class NotCountingCreateSessionTokensTest
+    {
+        [Test]
+        public void TestGrantSessionCreation()
+        {
+            // arrange
+            var tokens = new NotCountingCreateSessionTokens();
+            
+            // act
+            tokens.BeginCreate();
+            
+            // assert
+            Assert.AreEqual(0, tokens.Count());
+        }
+        
+        [Test]
+        public void TestCompleteSessionCreation()
+        {
+            // arrange
+            var tokens = new NotCountingCreateSessionTokens();
+            var token = tokens.BeginCreate();
+            
+            // act
+            tokens.EndCreate(token);
+            
+            // assert
+            Assert.AreEqual(0, tokens.Count());
+        }
+        
+        [Test]
+        public void TestCompleteUnknownTokenDoesNotThrowExceptions()
+        {
+            // arrange
+            var tokens = new NotCountingCreateSessionTokens();
+            tokens.BeginCreate();
+            var unknownToken = new CreateSessionToken(0);
+            
+            // act
+            tokens.EndCreate(unknownToken);
+
+            // assert
+            Assert.AreEqual(0, tokens.Count());
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/Session/SemaphoreBasedQueueTest.cs b/Snowflake.Data.Tests/UnitTests/Session/SemaphoreBasedQueueTest.cs
new file mode 100644
index 000000000..9fdd2143c
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/Session/SemaphoreBasedQueueTest.cs
@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class SemaphoreBasedQueueTest
+    {
+        [Test]
+        public void TestWaitForTheResourceUntilTimeout()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            var watch = new Stopwatch();
+            
+            // act
+            watch.Start();
+            var result = queue.Wait(50, CancellationToken.None);
+            watch.Stop();
+
+            // assert
+            Assert.IsFalse(result);
+            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 50);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 100);
+        }
+
+        [Test]
+        public void TestWaitForTheResourceUntilCancellation()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            var cancellationSource = new CancellationTokenSource(50);
+            var watch = new Stopwatch();
+
+            // act
+            watch.Start();
+            var result = queue.Wait(30000, cancellationSource.Token);
+            watch.Stop();
+            
+            // assert
+            Assert.IsFalse(result);
+            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 50);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 100);
+        }
+
+        [Test]
+        public void TestWaitUntilResourceAvailable()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            var watch = new Stopwatch();
+            Task.Run(() =>
+            {
+                Thread.Sleep(50);
+                queue.OnResourceIncrease();
+            });
+            
+            // act
+            watch.Start();
+            var result = queue.Wait(30000, CancellationToken.None);
+            watch.Stop();
+
+            // assert
+            Assert.IsTrue(result);
+            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 50);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 500);
+        }
+
+        [Test]
+        public void TestWaitingEnabled()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            
+            // act
+            var isWaitingEnabled = queue.IsWaitingEnabled();
+            
+            // assert
+            Assert.IsTrue(isWaitingEnabled);
+        }
+
+        [Test]
+        public void TestNoOneIsWaiting()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            
+            // act
+            var isAnyoneWaiting = queue.IsAnyoneWaiting();
+            
+            // assert
+            Assert.IsFalse(isAnyoneWaiting);
+        }
+
+        [Test]
+        public void TestSomeoneIsWaiting()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            var syncThreadsSemaphore = new SemaphoreSlim(0, 1);
+            Task.Run(() =>
+            {
+                syncThreadsSemaphore.Release();
+                return queue.Wait(1000, CancellationToken.None);
+            });
+            syncThreadsSemaphore.Wait(10000); // make sure scheduled thread execution has started
+            Thread.Sleep(50);
+
+            // act
+            var isAnyoneWaiting = queue.IsAnyoneWaiting();
+            
+            // assert
+            Assert.IsTrue(isAnyoneWaiting);
+        }
+
+        [Test]
+        public void TestDecreaseResources()
+        {
+            // arrange
+            var queue = new SemaphoreBasedQueue();
+            queue.OnResourceIncrease();
+            var watch = new Stopwatch();
+            
+            // act
+            queue.OnResourceDecrease();
+            watch.Start();
+            var result = queue.Wait(50, CancellationToken.None);
+            watch.Stop();
+            
+            // assert
+            Assert.IsFalse(result);
+            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 50);
+            Assert.LessOrEqual(watch.ElapsedMilliseconds, 500);
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/UnitTests/SnowflakeDbConnectionPoolTest.cs b/Snowflake.Data.Tests/UnitTests/SnowflakeDbConnectionPoolTest.cs
new file mode 100644
index 000000000..82ad550d9
--- /dev/null
+++ b/Snowflake.Data.Tests/UnitTests/SnowflakeDbConnectionPoolTest.cs
@@ -0,0 +1,25 @@
+using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests
+{
+    public class SnowflakeDbConnectionPoolTest
+    {
+        private readonly string _connectionString1 = "database=D1;warehouse=W1;account=A1;user=U1;password=P1;role=R1;";
+        private readonly string _connectionString2 = "database=D2;warehouse=W2;account=A2;user=U2;password=P2;role=R2;";
+
+        [Test]
+        public void TestRevertPoolToPreviousVersion()
+        {
+            // act
+            SnowflakeDbConnectionPool.SetOldConnectionPoolVersion();
+            
+            // assert
+            var sessionPool1 = SnowflakeDbConnectionPool.GetPool(_connectionString1);
+            var sessionPool2 = SnowflakeDbConnectionPool.GetPool(_connectionString2);
+            Assert.AreEqual(ConnectionPoolType.SingleConnectionCache, SnowflakeDbConnectionPool.GetConnectionPoolVersion());
+            Assert.AreEqual(sessionPool1, sessionPool2);
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/Util/PoolConfig.cs b/Snowflake.Data.Tests/Util/PoolConfig.cs
index 4856da243..078b6e359 100644
--- a/Snowflake.Data.Tests/Util/PoolConfig.cs
+++ b/Snowflake.Data.Tests/Util/PoolConfig.cs
@@ -3,6 +3,7 @@
  */
 
 using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
 
 namespace Snowflake.Data.Tests.Util
 {
@@ -11,16 +12,19 @@ class PoolConfig
         private readonly bool _pooling;
         private readonly long _timeout;
         private readonly int _maxPoolSize;
+        private readonly ConnectionPoolType _connectionPoolType;
 
         public PoolConfig()
         {
             _maxPoolSize = SnowflakeDbConnectionPool.GetMaxPoolSize();
             _timeout = SnowflakeDbConnectionPool.GetTimeout();
             _pooling = SnowflakeDbConnectionPool.GetPooling();
+            _connectionPoolType = SnowflakeDbConnectionPool.GetConnectionPoolVersion();
         }
 
         public void Reset()
         {
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(_connectionPoolType);
             SnowflakeDbConnectionPool.SetMaxPoolSize(_maxPoolSize);
             SnowflakeDbConnectionPool.SetTimeout(_timeout);
             SnowflakeDbConnectionPool.SetPooling(_pooling);
diff --git a/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs b/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
index f643fa5c9..46348cf61 100644
--- a/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
+++ b/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
@@ -2,6 +2,7 @@
  * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
  */
 
+using System;
 using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,72 +15,127 @@ namespace Snowflake.Data.Client
     public class SnowflakeDbConnectionPool
     {
         private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SnowflakeDbConnectionPool>();
-        private static readonly IConnectionManager s_connectionManager = new ConnectionCacheManager();
+        private static readonly Object s_connectionManagerInstanceLock = new Object();
+        private static IConnectionManager s_connectionManager;
+        private const ConnectionPoolType DefaultConnectionPoolType = ConnectionPoolType.SingleConnectionCache; // TODO: set to MultipleConnectionPool once development of entire ConnectionPoolManager epic is complete
+
+        private static IConnectionManager ConnectionManager
+        {
+            get
+            {
+                if (s_connectionManager != null)
+                    return s_connectionManager;
+                SetConnectionPoolVersion(DefaultConnectionPoolType);
+                return s_connectionManager;
+            }
+        }
         
         internal static SFSession GetSession(string connectionString, SecureString password)
         {
-            s_logger.Debug("SnowflakeDbConnectionPool::GetSession");
-            return s_connectionManager.GetSession(connectionString, password);
+            s_logger.Debug($"SnowflakeDbConnectionPool::GetSession");
+            return ConnectionManager.GetSession(connectionString, password);
         }
         
         internal static Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken)
         {
-            s_logger.Debug("SnowflakeDbConnectionPool::GetSessionAsync");
-            return s_connectionManager.GetSessionAsync(connectionString, password, cancellationToken);
+            s_logger.Debug($"SnowflakeDbConnectionPool::GetSessionAsync");
+            return ConnectionManager.GetSessionAsync(connectionString, password, cancellationToken);
+        }
+
+        internal static SessionPool GetPool(string connectionString)
+        {
+            s_logger.Debug($"SnowflakeDbConnectionPool::GetPool");
+            return ConnectionManager.GetPool(connectionString);
         }
         
         internal static bool AddSession(SFSession session)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::AddSession");
-            return s_connectionManager.AddSession(session);
+            return ConnectionManager.AddSession(session);
         }
 
         public static void ClearAllPools()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::ClearAllPools");
-            s_connectionManager.ClearAllPools();
+            ConnectionManager.ClearAllPools();
         }
 
         public static void SetMaxPoolSize(int maxPoolSize)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::SetMaxPoolSize");
-            s_connectionManager.SetMaxPoolSize(maxPoolSize);
+            ConnectionManager.SetMaxPoolSize(maxPoolSize);
         }
 
         public static int GetMaxPoolSize()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::GetMaxPoolSize");
-            return s_connectionManager.GetMaxPoolSize();
+            return ConnectionManager.GetMaxPoolSize();
         }
 
         public static void SetTimeout(long connectionTimeout)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::SetTimeout");
-            s_connectionManager.SetTimeout(connectionTimeout);
+            ConnectionManager.SetTimeout(connectionTimeout);
         }
         
         public static long GetTimeout()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::GetTimeout");
-            return s_connectionManager.GetTimeout();
+            return ConnectionManager.GetTimeout();
         }
 
         public static int GetCurrentPoolSize()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::GetCurrentPoolSize");
-            return s_connectionManager.GetCurrentPoolSize();
+            return ConnectionManager.GetCurrentPoolSize();
         }
 
         public static bool SetPooling(bool isEnable)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::SetPooling");
-            return s_connectionManager.SetPooling(isEnable);
+            return ConnectionManager.SetPooling(isEnable);
         }
 
         public static bool GetPooling()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::GetPooling");
-            return s_connectionManager.GetPooling();
+            return ConnectionManager.GetPooling();
+        }
+
+        internal static void SetOldConnectionPoolVersion() // TODO: set to public once development of entire ConnectionPoolManager epic is complete
+        {
+            SetConnectionPoolVersion(ConnectionPoolType.SingleConnectionCache);   
+        }
+
+        internal static void SetConnectionPoolVersion(ConnectionPoolType requestedPoolType)
+        {
+            lock (s_connectionManagerInstanceLock)
+            {
+                s_connectionManager?.ClearAllPools();
+                if (requestedPoolType == ConnectionPoolType.MultipleConnectionPool)
+                {
+                    s_connectionManager = new ConnectionPoolManager();
+                    s_logger.Info("SnowflakeDbConnectionPool - multiple connection pools enabled");
+                }
+                if (requestedPoolType == ConnectionPoolType.SingleConnectionCache)
+                {
+                    s_connectionManager = new ConnectionCacheManager();
+                    s_logger.Warn("SnowflakeDbConnectionPool - connection cache enabled");
+                }
+            }
+        }
+
+        internal static ConnectionPoolType GetConnectionPoolVersion()
+        {
+            if (ConnectionManager != null)
+            {
+                switch (ConnectionManager)
+                {
+                    case ConnectionCacheManager _: return ConnectionPoolType.SingleConnectionCache;
+                    case ConnectionPoolManager _: return ConnectionPoolType.MultipleConnectionPool;
+                }
+            }
+            return DefaultConnectionPoolType;
         }
     }
 }
diff --git a/Snowflake.Data/Core/ErrorMessages.resx b/Snowflake.Data/Core/ErrorMessages.resx
index 7159b86a0..8c50a5b57 100755
--- a/Snowflake.Data/Core/ErrorMessages.resx
+++ b/Snowflake.Data/Core/ErrorMessages.resx
@@ -183,4 +183,7 @@
   <data name="BROWSER_RESPONSE_TIMEOUT" xml:space="preserve">
     <value>Browser response timed out after {0} seconds.</value>
   </data>
+  <data name="INCONSISTENT_RESULT_ERROR" xml:space="preserve">
+    <value>Cannot return result set as a scalar value: {0}</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Snowflake.Data/Core/SFError.cs b/Snowflake.Data/Core/SFError.cs
index 2aac72f16..3a71e95fb 100755
--- a/Snowflake.Data/Core/SFError.cs
+++ b/Snowflake.Data/Core/SFError.cs
@@ -78,6 +78,9 @@ public enum SFError
 
         [SFErrorAttr(errorCode = 270057)]
         BROWSER_RESPONSE_TIMEOUT,
+        
+        [SFErrorAttr(errorCode = 270058)]
+        INCONSISTENT_RESULT_ERROR,
     }
 
     class SFErrorAttr : Attribute
diff --git a/Snowflake.Data/Core/Session/ConnectionCacheManager.cs b/Snowflake.Data/Core/Session/ConnectionCacheManager.cs
index e10a984e3..4ab1cc3cb 100644
--- a/Snowflake.Data/Core/Session/ConnectionCacheManager.cs
+++ b/Snowflake.Data/Core/Session/ConnectionCacheManager.cs
@@ -1,3 +1,7 @@
+/*
+ * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+ */
+
 using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
@@ -6,12 +10,12 @@ namespace Snowflake.Data.Core.Session
 {
     internal sealed class ConnectionCacheManager : IConnectionManager
     {
-        private readonly SessionPool _sessionPool = new SessionPool();
+        private readonly SessionPool _sessionPool = SessionPool.CreateSessionCache();
         public SFSession GetSession(string connectionString, SecureString password) => _sessionPool.GetSession(connectionString, password);
         public Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken)
             => _sessionPool.GetSessionAsync(connectionString, password, cancellationToken);
         public bool AddSession(SFSession session) => _sessionPool.AddSession(session);
-        public void ClearAllPools() => _sessionPool.ClearAllPools();
+        public void ClearAllPools() => _sessionPool.ClearIdleSessions();
         public void SetMaxPoolSize(int maxPoolSize) => _sessionPool.SetMaxPoolSize(maxPoolSize);
         public int GetMaxPoolSize() => _sessionPool.GetMaxPoolSize();
         public void SetTimeout(long connectionTimeout) => _sessionPool.SetTimeout(connectionTimeout);
@@ -19,5 +23,6 @@ public Task<SFSession> GetSessionAsync(string connectionString, SecureString pas
         public int GetCurrentPoolSize() => _sessionPool.GetCurrentPoolSize();
         public bool SetPooling(bool poolingEnabled) => _sessionPool.SetPooling(poolingEnabled);
         public bool GetPooling() => _sessionPool.GetPooling();
+        public SessionPool GetPool(string _) => _sessionPool;
     }
 }
diff --git a/Snowflake.Data/Core/Session/ConnectionPoolManager.cs b/Snowflake.Data/Core/Session/ConnectionPoolManager.cs
new file mode 100644
index 000000000..1e5147b8a
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ConnectionPoolManager.cs
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+using Snowflake.Data.Client;
+using Snowflake.Data.Log;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal sealed class ConnectionPoolManager : IConnectionManager
+    {
+        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<ConnectionPoolManager>();
+        private static readonly Object s_poolsLock = new Object();
+        private readonly Dictionary<string, SessionPool> _pools;
+
+        internal ConnectionPoolManager()
+        {
+            lock (s_poolsLock)
+            {
+                _pools = new Dictionary<string, SessionPool>();
+            }
+        }
+        
+        public SFSession GetSession(string connectionString, SecureString password)
+        {
+            s_logger.Debug($"ConnectionPoolManager::GetSession");
+            return GetPool(connectionString, password).GetSession();
+        }
+
+        public Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken)
+        {
+            s_logger.Debug($"ConnectionPoolManager::GetSessionAsync");
+            return GetPool(connectionString, password).GetSessionAsync(cancellationToken);
+        }
+
+        public bool AddSession(SFSession session)
+        {
+            s_logger.Debug($"ConnectionPoolManager::AddSession for {session.ConnectionString}");
+            return GetPool(session.ConnectionString, session.Password).AddSession(session);
+        }
+
+        public void ClearAllPools()
+        {
+            s_logger.Debug("ConnectionPoolManager::ClearAllPools");
+            foreach (var sessionPool in _pools.Values)
+            {
+                sessionPool.ClearIdleSessions();       
+            }
+            _pools.Clear();
+        }
+        
+        public void SetMaxPoolSize(int maxPoolSize)
+        {
+            s_logger.Debug("ConnectionPoolManager::SetMaxPoolSize for all pools");
+            foreach (var pool in _pools.Values)
+            {
+                pool.SetMaxPoolSize(maxPoolSize);
+            }
+        }
+
+        public int GetMaxPoolSize()
+        {
+            s_logger.Debug("ConnectionPoolManager::GetMaxPoolSize");
+            var values = _pools.Values.Select(it => it.GetMaxPoolSize()).Distinct().ToList();
+            return values.Count == 1
+                ? values.First()
+                : throw new SnowflakeDbException(SFError.INCONSISTENT_RESULT_ERROR, "Multiple pools have different Max Pool Size values");
+        }
+
+        public void SetTimeout(long connectionTimeout)
+        {
+            s_logger.Debug("ConnectionPoolManager::SetTimeout for all pools");
+            foreach (var pool in _pools.Values)
+            {
+                pool.SetTimeout(connectionTimeout);
+            }
+        }
+
+        public long GetTimeout()
+        {
+            s_logger.Debug("ConnectionPoolManager::GetTimeout");
+            var values = _pools.Values.Select(it => it.GetTimeout()).Distinct().ToList();
+            return values.Count == 1
+                ? values.First()
+                : throw new SnowflakeDbException(SFError.INCONSISTENT_RESULT_ERROR, "Multiple pools have different Timeout values");
+        }
+
+        public int GetCurrentPoolSize()
+        {
+            s_logger.Debug("ConnectionPoolManager::GetCurrentPoolSize");
+            var values = _pools.Values.Select(it => it.GetCurrentPoolSize()).Distinct().ToList();
+            return values.Count == 1
+                ? values.First()
+                : throw new SnowflakeDbException(SFError.INCONSISTENT_RESULT_ERROR, "Multiple pools have different Current Pool Size values");
+        }
+
+        public bool SetPooling(bool poolingEnabled)
+        {
+            // if (!poolingEnabled) // TODO: enable when disabling pooling in connection string completed SNOW-902632
+            //     throw new Exception(
+            //         "Could not disable pooling for all connections. You could disable pooling by given connection string instead.");
+            s_logger.Debug("ConnectionPoolManager::SetPooling for all pools");
+            return _pools.Values
+                .Select(pool => pool.SetPooling(poolingEnabled))
+                .All(setPoolingResult => setPoolingResult);
+        }
+
+        public bool GetPooling() 
+        {
+            s_logger.Debug("ConnectionPoolManager::GetPooling");
+            var values = _pools.Values.Select(it => it.GetPooling()).Distinct().ToList();
+            return values.Count == 1
+                ? values.First()
+                : throw new SnowflakeDbException(SFError.INCONSISTENT_RESULT_ERROR, "Multiple pools have different Pooling values");
+        }
+
+        internal SessionPool GetPool(string connectionString, SecureString password)
+        {
+            s_logger.Debug($"ConnectionPoolManager::GetPool");
+            var poolKey = GetPoolKey(connectionString);
+            
+            if (_pools.TryGetValue(poolKey, out var item))
+                return item;
+            lock (s_poolsLock)
+            {
+                if (_pools.TryGetValue(poolKey, out var poolCreatedWhileWaitingOnLock))
+                    return poolCreatedWhileWaitingOnLock;
+                s_logger.Info($"Creating new pool");
+                var pool = SessionPool.CreateSessionPool(connectionString, password);
+                _pools.Add(poolKey, pool);
+                return pool;
+            }
+        }
+
+        public SessionPool GetPool(string connectionString)
+        {
+            s_logger.Debug($"ConnectionPoolManager::GetPool");
+            return GetPool(connectionString, null);
+        }
+
+        // TODO: SNOW-937188
+        private string GetPoolKey(string connectionString)
+        {
+            return connectionString;
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/ConnectionPoolType.cs b/Snowflake.Data/Core/Session/ConnectionPoolType.cs
new file mode 100644
index 000000000..5844878fc
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ConnectionPoolType.cs
@@ -0,0 +1,8 @@
+namespace Snowflake.Data.Core.Session
+{
+    internal enum ConnectionPoolType
+    {
+        SingleConnectionCache,
+        MultipleConnectionPool
+    }
+}
diff --git a/Snowflake.Data/Core/Session/CreateSessionToken.cs b/Snowflake.Data/Core/Session/CreateSessionToken.cs
new file mode 100644
index 000000000..00c5ea643
--- /dev/null
+++ b/Snowflake.Data/Core/Session/CreateSessionToken.cs
@@ -0,0 +1,20 @@
+using System;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class CreateSessionToken
+    {
+        public Guid Id { get; }
+        private readonly long _grantedAtAsEpocMillis;
+        private readonly long _timeout;
+
+        public CreateSessionToken(long timeout)
+        {
+            Id = Guid.NewGuid();
+            _grantedAtAsEpocMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            _timeout = timeout;
+        }
+
+        public bool IsExpired(long nowMillis) => nowMillis > _grantedAtAsEpocMillis + _timeout;
+    }
+}
diff --git a/Snowflake.Data/Core/Session/CreateSessionTokens.cs b/Snowflake.Data/Core/Session/CreateSessionTokens.cs
new file mode 100644
index 000000000..940025446
--- /dev/null
+++ b/Snowflake.Data/Core/Session/CreateSessionTokens.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class CreateSessionTokens: ICreateSessionTokens
+    {
+        internal long _timeout { get; set; }  = Timeout;
+        private const long Timeout = 30000; // 30 seconds as default
+        private readonly object _tokenLock = new object();
+        private readonly List<CreateSessionToken> _tokens = new List<CreateSessionToken>();
+        private int _tokenCount = 0;
+        
+        public CreateSessionToken BeginCreate()
+        {
+            lock (_tokenLock)
+            {
+                var token = new CreateSessionToken(_timeout);
+                _tokens.Add(token);
+                var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+                _tokens.RemoveAll(t => t.IsExpired(now));
+                _tokenCount = _tokens.Count;
+                return token;
+            }
+        }
+
+        public void EndCreate(CreateSessionToken token)
+        {
+            lock (_tokenLock)
+            {
+                var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+                _tokens.RemoveAll(t => token.Id == t.Id || t.IsExpired(now));
+                _tokenCount = _tokens.Count;
+            }
+        }
+
+        public int Count()
+        {
+            return _tokenCount;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Snowflake.Data/Core/Session/FixedZeroCounter.cs b/Snowflake.Data/Core/Session/FixedZeroCounter.cs
new file mode 100644
index 000000000..9f545f2f3
--- /dev/null
+++ b/Snowflake.Data/Core/Session/FixedZeroCounter.cs
@@ -0,0 +1,15 @@
+namespace Snowflake.Data.Core.Session
+{
+    internal class FixedZeroCounter: ICounter
+    {
+        public int Count() => 0;
+
+        public void Increase()
+        {
+        }
+
+        public void Decrease()
+        {
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/IConnectionManager.cs b/Snowflake.Data/Core/Session/IConnectionManager.cs
index e72ade2e7..c64699d54 100644
--- a/Snowflake.Data/Core/Session/IConnectionManager.cs
+++ b/Snowflake.Data/Core/Session/IConnectionManager.cs
@@ -21,5 +21,6 @@ internal interface IConnectionManager
         int GetCurrentPoolSize();
         bool SetPooling(bool poolingEnabled);
         bool GetPooling();
+        SessionPool GetPool(string connectionString);
     }
 }
diff --git a/Snowflake.Data/Core/Session/ICounter.cs b/Snowflake.Data/Core/Session/ICounter.cs
new file mode 100644
index 000000000..61065d73f
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ICounter.cs
@@ -0,0 +1,11 @@
+namespace Snowflake.Data.Core.Session
+{
+    internal interface ICounter
+    {
+        int Count();
+
+        void Increase();
+
+        void Decrease();
+    }
+}
diff --git a/Snowflake.Data/Core/Session/ICreateSessionTokens.cs b/Snowflake.Data/Core/Session/ICreateSessionTokens.cs
new file mode 100644
index 000000000..edba11181
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ICreateSessionTokens.cs
@@ -0,0 +1,13 @@
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal interface ICreateSessionTokens
+    {
+        CreateSessionToken BeginCreate();
+
+        void EndCreate(CreateSessionToken token);
+
+        int Count();
+    }
+}
\ No newline at end of file
diff --git a/Snowflake.Data/Core/Session/ISessionFactory.cs b/Snowflake.Data/Core/Session/ISessionFactory.cs
new file mode 100644
index 000000000..f9416de8d
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ISessionFactory.cs
@@ -0,0 +1,9 @@
+using System.Security;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal interface ISessionFactory
+    {
+        SFSession NewSession(string connectionString, SecureString password);
+    }
+}
diff --git a/Snowflake.Data/Core/Session/IWaitingQueue.cs b/Snowflake.Data/Core/Session/IWaitingQueue.cs
new file mode 100644
index 000000000..b8a6c673b
--- /dev/null
+++ b/Snowflake.Data/Core/Session/IWaitingQueue.cs
@@ -0,0 +1,21 @@
+using System.Threading;
+
+namespace Snowflake.Data.Core.Session
+{
+    public interface IWaitingQueue
+    {
+        bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
+
+        void OnResourceIncrease();
+
+        void OnResourceDecrease();
+
+        bool IsAnyoneWaiting();
+
+        bool IsWaitingEnabled();
+
+        long GetWaitingTimeoutMillis();
+        
+        void SetWaitingTimeout(long timeoutMillis);
+    }
+}
diff --git a/Snowflake.Data/Core/Session/NoOneWaiting.cs b/Snowflake.Data/Core/Session/NoOneWaiting.cs
new file mode 100644
index 000000000..ff0b4ef39
--- /dev/null
+++ b/Snowflake.Data/Core/Session/NoOneWaiting.cs
@@ -0,0 +1,37 @@
+using System.Threading;
+
+namespace Snowflake.Data.Core.Session
+{
+    public class NoOneWaiting: IWaitingQueue
+    {
+        public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
+        {
+            return false;
+        }
+
+        public void OnResourceIncrease()
+        {
+        }
+
+        public void OnResourceDecrease()
+        {
+        }
+
+        public bool IsAnyoneWaiting()
+        {
+            return false;
+        }
+
+        public bool IsWaitingEnabled()
+        {
+            return false;
+        }
+
+        public long GetWaitingTimeoutMillis() => 0;
+
+        public void SetWaitingTimeout(long timeoutMillis)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/NonNegativeCounter.cs b/Snowflake.Data/Core/Session/NonNegativeCounter.cs
new file mode 100644
index 000000000..3d755c6cb
--- /dev/null
+++ b/Snowflake.Data/Core/Session/NonNegativeCounter.cs
@@ -0,0 +1,18 @@
+using System;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class NonNegativeCounter : ICounter
+    {
+        private int _value;
+
+        public int Count() => _value;
+
+        public void Increase() => _value++;
+
+        public void Decrease()
+        {
+            _value = Math.Max(_value - 1, 0);
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/NotCountingCreateSessionTokens.cs b/Snowflake.Data/Core/Session/NotCountingCreateSessionTokens.cs
new file mode 100644
index 000000000..eae65a06e
--- /dev/null
+++ b/Snowflake.Data/Core/Session/NotCountingCreateSessionTokens.cs
@@ -0,0 +1,13 @@
+namespace Snowflake.Data.Core.Session
+{
+    internal class NotCountingCreateSessionTokens: ICreateSessionTokens
+    {
+        public CreateSessionToken BeginCreate() => new CreateSessionToken(0);
+
+        public void EndCreate(CreateSessionToken token)
+        {
+        }
+
+        public int Count() => 0;
+    }
+}
diff --git a/Snowflake.Data/Core/Session/SFSession.cs b/Snowflake.Data/Core/Session/SFSession.cs
index d153ffff4..f554263d3 100755
--- a/Snowflake.Data/Core/Session/SFSession.cs
+++ b/Snowflake.Data/Core/Session/SFSession.cs
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2021 Snowflake Computing Inc. All rights reserved.
+ * Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
  */
 
 using System;
@@ -15,7 +15,6 @@
 using System.Threading.Tasks;
 using System.Net.Http;
 using System.Text.RegularExpressions;
-using Snowflake.Data.Configuration;
 
 namespace Snowflake.Data.Core
 {
@@ -69,7 +68,8 @@ public class SFSession
         private readonly EasyLoggingStarter _easyLoggingStarter = EasyLoggingStarter.Instance;
 
         private long _startTime = 0;
-        internal string connStr = null;
+        internal string ConnectionString { get; }
+        internal SecureString Password { get; }
 
         private QueryContextCache _queryContextCache = new QueryContextCache(_defaultQueryContextCacheSize);
 
@@ -145,8 +145,9 @@ internal SFSession(
             EasyLoggingStarter easyLoggingStarter)
         {
             _easyLoggingStarter = easyLoggingStarter;
-            connStr = connectionString;
-            properties = SFSessionProperties.parseConnectionString(connectionString, password);
+            ConnectionString = connectionString;
+            Password = password;
+            properties = SFSessionProperties.parseConnectionString(ConnectionString, Password);
             _disableQueryContextCache = bool.Parse(properties[SFSessionProperty.DISABLEQUERYCONTEXTCACHE]);
             ValidateApplicationName(properties);
             try
@@ -215,7 +216,7 @@ internal Uri BuildUri(string path, Dictionary<string, string> queryParams = null
             return uriBuilder.Uri;
         }
 
-        internal void Open()
+        internal virtual void Open()
         {
             logger.Debug("Open Session");
 
@@ -227,7 +228,7 @@ internal void Open()
             authenticator.Authenticate();
         }
 
-        internal async Task OpenAsync(CancellationToken cancellationToken)
+        internal virtual async Task OpenAsync(CancellationToken cancellationToken)
         {
             logger.Debug("Open Session Async");
 
@@ -557,12 +558,12 @@ internal void heartbeat()
             }
         }
 
-        internal bool IsNotOpen()
+        internal virtual bool IsNotOpen()
         {
             return _startTime == 0;
         }
 
-        internal bool IsExpired(long timeoutInSeconds, long utcTimeInSeconds)
+        internal virtual bool IsExpired(long timeoutInSeconds, long utcTimeInSeconds)
         {
             return _startTime + timeoutInSeconds <= utcTimeInSeconds;
         }
diff --git a/Snowflake.Data/Core/Session/SemaphoreBasedQueue.cs b/Snowflake.Data/Core/Session/SemaphoreBasedQueue.cs
new file mode 100644
index 000000000..7426723a3
--- /dev/null
+++ b/Snowflake.Data/Core/Session/SemaphoreBasedQueue.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Threading;
+
+namespace Snowflake.Data.Core.Session
+{
+    public class SemaphoreBasedQueue: IWaitingQueue
+    {
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(0, 1000); // TODO: how not to set it? 
+        private readonly object _lock = new object();
+        private int _waitingCount = 0;
+        private long _waitingTimeoutMillis = 30000; // 30 seconds as default
+
+        public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
+        {
+            lock (_lock)
+            {
+                _waitingCount++;
+            }
+            try
+            {
+                return _semaphore.Wait(millisecondsTimeout, cancellationToken);
+            }
+            catch (OperationCanceledException exception)
+            {
+                return false;
+            }
+            finally
+            {
+                lock (_lock)
+                {
+                    _waitingCount--;
+                }
+            }
+        }
+
+        public void OnResourceIncrease()
+        {
+            _semaphore.Release(1);
+        }
+
+        public void OnResourceDecrease()
+        {
+            _semaphore.Wait(0, CancellationToken.None);
+        }
+
+        public bool IsAnyoneWaiting() => _waitingCount > 0;
+
+        public bool IsWaitingEnabled() => true;
+
+        public long GetWaitingTimeoutMillis() => _waitingTimeoutMillis;
+
+        public void SetWaitingTimeout(long timeoutMillis) => _waitingTimeoutMillis = timeoutMillis;
+    }
+}
diff --git a/Snowflake.Data/Core/Session/SessionFactory.cs b/Snowflake.Data/Core/Session/SessionFactory.cs
new file mode 100644
index 000000000..2eb0ba6df
--- /dev/null
+++ b/Snowflake.Data/Core/Session/SessionFactory.cs
@@ -0,0 +1,12 @@
+using System.Security;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class SessionFactory : ISessionFactory
+    {
+        public SFSession NewSession(string connectionString, SecureString password)
+        {
+            return new SFSession(connectionString, password);
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/SessionOrCreateToken.cs b/Snowflake.Data/Core/Session/SessionOrCreateToken.cs
new file mode 100644
index 000000000..1f3ffea8c
--- /dev/null
+++ b/Snowflake.Data/Core/Session/SessionOrCreateToken.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class SessionOrCreateToken
+    {
+        public SFSession Session { get; }
+        public CreateSessionToken CreateToken { get; }
+
+        public SessionOrCreateToken(SFSession session)
+        {
+            Session = session ?? throw new Exception("Internal error: missing session");
+            CreateToken = null;
+        }
+
+        public SessionOrCreateToken(CreateSessionToken createToken)
+        {
+            Session = null;
+            CreateToken = createToken ?? throw new Exception("Internal error: missing create token");
+        }
+    }
+}
diff --git a/Snowflake.Data/Core/Session/SessionPool.cs b/Snowflake.Data/Core/Session/SessionPool.cs
index a7eae7726..63a792b83 100644
--- a/Snowflake.Data/Core/Session/SessionPool.cs
+++ b/Snowflake.Data/Core/Session/SessionPool.cs
@@ -16,23 +16,49 @@ namespace Snowflake.Data.Core.Session
     sealed class SessionPool : IDisposable
     {
         private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SessionPool>();
-        private static readonly object s_sessionPoolLock = new object();
-        private readonly List<SFSession> _sessions;
+        private readonly object _sessionPoolLock = new object();
+        private static ISessionFactory s_sessionFactory = new SessionFactory();
+
+        private readonly List<SFSession> _idleSessions;
+        private readonly IWaitingQueue _waitingQueue;
+        private readonly ICreateSessionTokens _createSessionTokens;
         private int _maxPoolSize;
         private long _timeout;
         private const int MaxPoolSize = 10;
         private const long Timeout = 3600;
+        internal string ConnectionString { get; }
+        internal SecureString Password { get; }
         private bool _pooling = true;
+        private readonly ICounter _busySessionsCounter;
 
-        internal SessionPool()
+        private SessionPool()
         {
-            lock (s_sessionPoolLock)
-            {
-                _sessions = new List<SFSession>();
-                _maxPoolSize = MaxPoolSize;
-                _timeout = Timeout;
-            }
+            // acquiring a lock not needed because one is already acquired in SnowflakeDbConnectionPool
+            _idleSessions = new List<SFSession>();
+            _maxPoolSize = MaxPoolSize;
+            _timeout = Timeout;
+            _busySessionsCounter = new FixedZeroCounter();
+            _waitingQueue = new NoOneWaiting();
+            _createSessionTokens = new NotCountingCreateSessionTokens();
+        }
+
+        private SessionPool(string connectionString, SecureString password)
+        {
+            // acquiring a lock not needed because one is already acquired in ConnectionPoolManager 
+            _idleSessions = new List<SFSession>();
+            _maxPoolSize = MaxPoolSize;
+            _timeout = Timeout;
+            _busySessionsCounter = new NonNegativeCounter();
+            ConnectionString = connectionString;
+            Password = password;
+            _waitingQueue = new SemaphoreBasedQueue();
+            _createSessionTokens = new CreateSessionTokens();
         }
+
+        internal static SessionPool CreateSessionCache() => new SessionPool();
+
+        internal static SessionPool CreateSessionPool(string connectionString, SecureString password) =>
+            new SessionPool(connectionString, password);
         
         ~SessionPool()
         {
@@ -43,21 +69,27 @@ internal SessionPool()
 
         public void Dispose()
         {
-            ClearAllPools();
+            ClearIdleSessions();
+        }
+
+        internal static ISessionFactory SessionFactory
+        {
+            set => s_sessionFactory = value;
         }
 
         private void CleanExpiredSessions()
         {
             s_logger.Debug("SessionPool::CleanExpiredSessions");
-            lock (s_sessionPoolLock)
+            lock (_sessionPoolLock)
             {
                 long timeNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
 
-                foreach (var item in _sessions.ToList())
+                foreach (var item in _idleSessions.ToList())
                 {
                     if (item.IsExpired(_timeout, timeNow))
                     {
-                        _sessions.Remove(item);
+                        _idleSessions.Remove(item);
+                        _waitingQueue.OnResourceDecrease();
                         item.close();
                     }
                 }
@@ -68,60 +100,154 @@ internal SFSession GetSession(string connStr, SecureString password)
         {
             s_logger.Debug("SessionPool::GetSession");
             if (!_pooling)
-                return NewSession(connStr, password);
-            SFSession session = GetIdleSession(connStr);
-            return session ?? NewSession(connStr, password);
+                return NewSession(connStr, password, new CreateSessionToken(0));
+            var sessionOrCreateToken = GetIdleSession(connStr);
+            return sessionOrCreateToken.Session ?? NewSession(connStr, password, sessionOrCreateToken.CreateToken);
         }
         
         internal Task<SFSession> GetSessionAsync(string connStr, SecureString password, CancellationToken cancellationToken)
         {
             s_logger.Debug("SessionPool::GetSessionAsync");
             if (!_pooling)
-                return NewSessionAsync(connStr, password, cancellationToken);
-            SFSession session = GetIdleSession(connStr);
-            return session != null ? Task.FromResult(session) : NewSessionAsync(connStr, password, cancellationToken);
+                return NewSessionAsync(connStr, password, new CreateSessionToken(0), cancellationToken);
+            var sessionOrCreateToken = GetIdleSession(connStr);
+            return sessionOrCreateToken.Session != null
+                ? Task.FromResult(sessionOrCreateToken.Session)
+                : NewSessionAsync(connStr, password, sessionOrCreateToken.CreateToken, cancellationToken);
         }
 
-        private SFSession GetIdleSession(string connStr)
+        internal SFSession GetSession() => GetSession(ConnectionString, Password);
+
+        internal Task<SFSession> GetSessionAsync(CancellationToken cancellationToken) =>
+            GetSessionAsync(ConnectionString, Password, cancellationToken);
+
+        private SessionOrCreateToken GetIdleSession(string connStr)
         {
             s_logger.Debug("SessionPool::GetIdleSession");
-            lock (s_sessionPoolLock)
+            lock (_sessionPoolLock)
             {
-                for (int i = 0; i < _sessions.Count; i++)
+                if (_waitingQueue.IsAnyoneWaiting())
+                {
+                    s_logger.Debug("SessionPool::GetIdleSession - someone is already waiting for a session, request is going to be queued");
+                }
+                else
                 {
-                    if (_sessions[i].connStr.Equals(connStr))
+                    var session = ExtractIdleSession(connStr);
+                    if (session != null)
                     {
-                        SFSession session = _sessions[i];
-                        _sessions.RemoveAt(i);
-                        long timeNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
-                        if (session.IsExpired(_timeout, timeNow))
-                        {
-                            session.close();
-                            i--;
-                        }
-                        else
-                        {
-                            s_logger.Debug($"reuse pooled session with sid {session.sessionId}");
-                            return session;
-                        }
+                        s_logger.Debug("SessionPool::GetIdleSession - no one was waiting for a session, a session was extracted from idle sessions");
+                        _waitingQueue.OnResourceDecrease();
+                        return new SessionOrCreateToken(session);
+                    }
+                    s_logger.Debug("SessionPool::GetIdleSession - no one was waiting for session, but could not find any idle session available");
+                    if (IsAllowedToCreateNewSession())
+                    {
+                        // there is no need to wait for a session since we can create a new one
+                        return new SessionOrCreateToken(_createSessionTokens.BeginCreate());
+                    }
+                }
+            }
+            return new SessionOrCreateToken(WaitForSession(connStr));
+        }
+
+        private bool IsAllowedToCreateNewSession()
+        {
+            if (!_waitingQueue.IsWaitingEnabled())
+            {
+                s_logger.Debug($"SessionPool - new session creation granted");
+                return true;
+            }
+            var currentSize = GetCurrentPoolSize();
+            if (currentSize < _maxPoolSize)
+            {
+                s_logger.Debug($"SessionPool - new session creation granted because current size is {currentSize} out of {_maxPoolSize}");
+                return true;
+            }
+            s_logger.Debug($"SessionPool - could not grant new session creation because current size is {currentSize} out of {_maxPoolSize}");
+            return false;
+        }
+        
+        private SFSession WaitForSession(string connStr)
+        {
+            var timeout = _waitingQueue.GetWaitingTimeoutMillis();
+            s_logger.Debug($"SessionPool::WaitForSession for {timeout} millis timeout");
+            var beforeWaitingTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+            long nowTime = beforeWaitingTime;
+            while (nowTime < beforeWaitingTime + timeout) // we loop to handle the case if someone overtook us after being woken or session which we were promised has just expired
+            {
+                var timeoutLeft = beforeWaitingTime + timeout - nowTime;
+                var successful = _waitingQueue.Wait((int) timeoutLeft, CancellationToken.None);
+                if (!successful)
+                {
+                    s_logger.Debug($"SessionPool::WaitForSession - woken without a session granted");
+                    throw WaitingFailedException();
+                }
+                s_logger.Debug($"SessionPool::WaitForSession - woken with a session granted");
+                lock (_sessionPoolLock)
+                {
+                    var session = ExtractIdleSession(connStr);
+                    if (session != null)
+                    {
+                        s_logger.Debug($"SessionPool::WaitForSession - a session was extracted from idle sessions");
+                        return session;
+                    }
+                }
+                nowTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+            }
+            s_logger.Debug($"SessionPool::WaitForSession - could not find any idle session available withing a given timeout");
+            throw WaitingFailedException();
+        }
+
+        private static Exception WaitingFailedException() => new Exception("Could not obtain a connection from the pool within a given timeout");
+
+        private SFSession ExtractIdleSession(string connStr)
+        {
+            for (int i = 0; i < _idleSessions.Count; i++)
+            {
+                if (_idleSessions[i].ConnectionString.Equals(connStr))
+                {
+                    SFSession session = _idleSessions[i];
+                    _idleSessions.RemoveAt(i); // we don't do _waitingQueue.OnResourceDecrease() here because it happens in GetIdleSession()
+                    long timeNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+                    if (session.IsExpired(_timeout, timeNow))
+                    {
+                        session.close(); // TODO: change to session required
+                        _waitingQueue.OnResourceDecrease();
+                        i--;
+                    }
+                    else
+                    {
+                        s_logger.Debug($"reuse pooled session with sid {session.sessionId}");
+                        _busySessionsCounter.Increase();
+                        return session;
                     }
                 }
             }
             return null;
         }
 
-        private SFSession NewSession(String connectionString, SecureString password)
+        private SFSession NewSession(String connectionString, SecureString password, CreateSessionToken createSessionToken)
         {
             s_logger.Debug("SessionPool::NewSession");
             try
             {
-                var session = new SFSession(connectionString, password);
+                var session = s_sessionFactory.NewSession(connectionString, password);
                 session.Open();
+                s_logger.Debug("SessionPool::NewSession - opened");
+                if (_pooling)
+                {
+                    lock (_sessionPoolLock)
+                    {
+                        _createSessionTokens.EndCreate(createSessionToken);
+                        _busySessionsCounter.Increase();
+                    }
+                }
                 return session;
             }
             catch (Exception e)
             {
                 // Otherwise when Dispose() is called, the close request would timeout.
+                _createSessionTokens.EndCreate(createSessionToken);
                 if (e is SnowflakeDbException)
                     throw;
                 throw new SnowflakeDbException(
@@ -132,14 +258,19 @@ private SFSession NewSession(String connectionString, SecureString password)
             }
         }
 
-        private Task<SFSession> NewSessionAsync(String connectionString, SecureString password, CancellationToken cancellationToken)
+        private Task<SFSession> NewSessionAsync(String connectionString, SecureString password, CreateSessionToken createSessionToken, CancellationToken cancellationToken)
         {
             s_logger.Debug("SessionPool::NewSessionAsync");
-            var session = new SFSession(connectionString, password);
+            var session = s_sessionFactory.NewSession(connectionString, password);
             return session
                 .OpenAsync(cancellationToken)
                 .ContinueWith(previousTask =>
                 {
+                    if (previousTask.IsFaulted)
+                    {
+                        _createSessionTokens.EndCreate(createSessionToken);
+                    }
+                        
                     if (previousTask.IsFaulted && previousTask.Exception != null)
                         throw previousTask.Exception;
 
@@ -149,8 +280,17 @@ private Task<SFSession> NewSessionAsync(String connectionString, SecureString pa
                             SFError.INTERNAL_ERROR,
                             "Failure while opening session async");
 
+                    if (_pooling)
+                    {
+                        lock (_sessionPoolLock)
+                        {
+                            _createSessionTokens.EndCreate(createSessionToken);
+                            _busySessionsCounter.Increase();
+                        }
+                    }
+
                     return session;
-                }, TaskContinuationOptions.NotOnCanceled);
+                }, TaskContinuationOptions.None); // previously it was NotOnCanceled but we would like to execute it even in case of cancellation to properly update counters 
         }
 
         internal bool AddSession(SFSession session)
@@ -160,47 +300,59 @@ internal bool AddSession(SFSession session)
                 return false;
             long timeNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
             if (session.IsNotOpen() || session.IsExpired(_timeout, timeNow))
-                return false;
-
-            lock (s_sessionPoolLock)
             {
-                if (_sessions.Count >= _maxPoolSize)
+                lock (_sessionPoolLock)
                 {
-                    CleanExpiredSessions();
+                    _busySessionsCounter.Decrease();
                 }
-                if (_sessions.Count >= _maxPoolSize)
+                return false;
+            }
+
+            lock (_sessionPoolLock)
+            {
+                _busySessionsCounter.Decrease();
+                CleanExpiredSessions();
+                if (GetCurrentPoolSize() >= _maxPoolSize)
                 {
-                    // pool is full
+                    s_logger.Warn($"Pool is full - unable to add session with sid {session.sessionId}");
                     return false;
                 }
 
                 s_logger.Debug($"pool connection with sid {session.sessionId}");
-                _sessions.Add(session);
+                _idleSessions.Add(session);
+                _waitingQueue.OnResourceIncrease();
                 return true;
             }
         }
 
-        internal void ClearAllPools()
+        internal void ClearIdleSessions()
         {
-            s_logger.Debug("SessionPool::ClearAllPools");
-            lock (s_sessionPoolLock)
+            s_logger.Debug("SessionPool::ClearIdleSessions");
+            lock (_sessionPoolLock)
             {
-                foreach (SFSession session in _sessions)
+                foreach (SFSession session in _idleSessions)
                 {
                     session.close();
                 }
-                _sessions.Clear();
+                _idleSessions.ForEach(session => _waitingQueue.OnResourceDecrease());
+                _idleSessions.Clear();
             }
         }
 
         internal async void ClearAllPoolsAsync()
         {
             s_logger.Debug("SessionPool::ClearAllPoolsAsync");
-            foreach (SFSession session in _sessions)
+            IEnumerable<SFSession> idleSessionsCopy;
+            lock (_sessionPoolLock)
+            {
+                idleSessionsCopy = _idleSessions.Select(session => session);
+                _idleSessions.ForEach(session => _waitingQueue.OnResourceDecrease());
+                _idleSessions.Clear();
+            }
+            foreach (SFSession session in idleSessionsCopy)
             {
                 await session.CloseAsync(CancellationToken.None).ConfigureAwait(false);
             }
-            _sessions.Clear();
         }
 
         public void SetMaxPoolSize(int size)
@@ -225,7 +377,7 @@ public long GetTimeout()
 
         public int GetCurrentPoolSize()
         {
-            return _sessions.Count;
+            return _idleSessions.Count + _busySessionsCounter.Count() + _createSessionTokens.Count();
         }
 
         public bool SetPooling(bool isEnable)
@@ -236,7 +388,7 @@ public bool SetPooling(bool isEnable)
             _pooling = isEnable;
             if (!_pooling)
             {
-                ClearAllPools();
+                ClearIdleSessions();
             }
             return true;
         }
@@ -245,5 +397,7 @@ public bool GetPooling()
         {
             return _pooling;
         }
+
+        public void SetWaitingTimeout(long timeoutMillis) => _waitingQueue.SetWaitingTimeout(timeoutMillis);
     }
 }