Synch with H2.0.3 - main thing is the addition of a basic connection pool

to DriverManager so you can get back the same IDbConnection (same by
reference - not just an already established connection by the data providers
built in connection pool).  This defaults to not being on.


SVN: trunk@584

Author: Mike Doerfler

src/NHibernate/Connection/ConnectionProvider.cs

@@ -10,10 +10,11 @@ namespace NHibernate.Connection
 	/// <summary>
 	/// The base class for the ConnectionProvider.
 	/// </summary>
-	public abstract class ConnectionProvider : IConnectionProvider
+	public abstract class ConnectionProvider : IConnectionProvider, IDisposable
 	{
 		private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof(ConnectionProvider));
 		private string connString = null;
+		private int poolSize;
 		protected IDriver driver = null;
 
 		public virtual void CloseConnection(IDbConnection conn) 
@@ -37,6 +38,14 @@ public virtual void CloseConnection(IDbConnection conn)
 		public virtual void Configure(IDictionary settings) 
 		{
 			log.Info("Configuring ConnectionProvider");
+			
+			// default the poolSize to 0 if no setting was made because most of the .net DataProvider
+			// do their own connection pooling.  This would be useful to change to some higher number
+			// if the .net DataProvider did not provide their own connection pooling.  I don't know of
+			// any instances of this yet.
+			poolSize = PropertiesHelper.GetInt(Cfg.Environment.PoolSize, Cfg.Environment.Properties, 0);
+			log.Info("NHibernate connection pool size: " + poolSize);
+
 			connString = Cfg.Environment.Properties[ Cfg.Environment.ConnectionString ] as string;
 			if (connString==null) throw new HibernateException("Could not find connection string setting");
 
@@ -74,6 +83,11 @@ protected virtual string ConnectionString
 			get { return connString;}
 		}
 
+		protected virtual int PoolSize 
+		{
+			get { return poolSize; }
+		}
+
 		public IDriver Driver 
 		{
 			get {return driver;}
@@ -87,5 +101,16 @@ public IDriver Driver
 
 		public abstract bool IsStatementCache {get;}
 
+		public abstract void Close();
+
+		#region IDisposable Members
+
+		// equiv to java's object.finalize()
+		public void Dispose()
+		{
+			Close();
+		}
+
+		#endregion
 	}
 }

src/NHibernate/Connection/DriverConnectionProvider.cs

@@ -1,16 +1,24 @@
 using System;
+using System.Collections;
 using System.Data;
 
 using NHibernate.Driver;
 
 namespace NHibernate.Connection
 {
 	/// <summary>
-	/// Summary description for DriverConnectionProvider.
+	/// A ConnectionProvider that uses an IDriver to create connections.
 	/// </summary>
+	/// <remarks>
+	/// This IConnectionProvider implements a rudimentary connection pool.
+	/// </remarks>
 	public class DriverConnectionProvider : ConnectionProvider
 	{
 		private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof(DriverConnectionProvider));
+		private static object poolLock = new object();
+		private readonly ArrayList pool = new ArrayList();
+		
+		private int checkedOut = 0;
 
 		public DriverConnectionProvider()
 		{
@@ -19,6 +27,25 @@ public DriverConnectionProvider()
 
 		public override IDbConnection GetConnection() 
 		{
+			if(log.IsDebugEnabled) log.Debug("total checked-out connections: " + checkedOut);
+
+			lock(poolLock) 
+			{
+				if( pool.Count > 0 ) 
+				{
+					int last = pool.Count - 1;
+					if(log.IsDebugEnabled) 
+					{
+						log.Debug("using pooled connection, pool size: " + last);
+						checkedOut++;
+					}
+
+					IDbConnection conn = (IDbConnection)pool[last];
+					pool.RemoveAt(last);
+					return conn;
+				}
+			}
+
 			log.Debug("Obtaining IDbConnection from Driver");
 			try 
 			{
@@ -38,5 +65,44 @@ public override bool IsStatementCache
 			get { return false; }
 		}
 
+		public override void Close()
+		{
+			log.Info("cleaning up connection pool");
+
+			for(int i = 0; i < pool.Count; i++) 
+			{
+				try 
+				{
+					((IDbConnection)pool[i]).Close();
+				}
+				catch(Exception e) 
+				{
+					log.Warn("problem closing pooled connection", e);
+				}
+			}
+
+			pool.Clear();
+		}
+
+		public override void CloseConnection(IDbConnection conn)
+		{
+			if(log.IsDebugEnabled) checkedOut--;
+
+			lock(poolLock) 
+			{
+				int currentSize = pool.Count;
+				if( currentSize < PoolSize ) 
+				{
+					if(log.IsDebugEnabled) log.Debug("returning connection to pool, pool size: " + (currentSize + 1) );
+					pool.Add(conn);
+					return;
+				}
+			}
+
+			base.CloseConnection(conn);
+		}
+
+
+
 	}
 }

src/NHibernate/Connection/IConnectionProvider.cs

@@ -50,5 +50,10 @@ public interface IConnectionProvider
 		/// </remarks>
 		bool IsStatementCache { get; }
 
+		/// <summary>
+		/// Release all resources held by this ConnectionProvider.
+		/// </summary>
+		void Close();
+
 	}
 }

src/NHibernate/Connection/UserSuppliedConnectionProvider.cs

@@ -47,5 +47,12 @@ public override bool IsStatementCache
 			get { return false; }
 		}
 
+		public override void Close()
+		{
+			// do nothing - don't need to throw an error because this is something
+			// that NHibernate will call.
+		}
+
+
 	}
 }