/// <summary>
 /// Creates a simple profiled connection instance.
 /// </summary>
 /// <param name="connection">The database connection to wrap</param>
 /// <param name="profiler">The profiler to use</param>
 public SimpleProfiledConnection(IDbConnection connection, IDbProfiler profiler)
 {
     _connection = connection;
     if (profiler != null)
     {
         _profiler = profiler;
     }
 }

        public ProfiledDbCommand(DbCommand command, DbConnection connection, IDbProfiler profiler)
        {
            if (command == null) throw new ArgumentNullException("command");

            InternalCommand = command;
            _connection = connection;

            _profiler = profiler;
        }

        /// <summary>
        /// Initialises a new instance of the <see cref="ProfiledDbDataReader"/> class.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="connection">The connection.</param>
        /// <param name="profiler">The profiler.</param>
        public ProfiledDbDataReader(DbDataReader reader, DbConnection connection, IDbProfiler profiler)
        {
            _reader = reader;

            if (profiler != null)
            {
                _profiler = profiler;
            }
        }

        /// <summary>
        /// Initialises a new instance of the <see cref="ProfiledDbDataAdapter"/> class.
        /// </summary>
        /// <param name="wrappedAdapter">The wrapped adapter.</param>
        /// <param name="profiler">The profiler.</param>
        public ProfiledDbDataAdapter(IDbDataAdapter wrappedAdapter, IDbProfiler profiler = null)
        {
            if (wrappedAdapter == null)
            {
                throw new ArgumentNullException("wrappedAdapter");
            }

            _adapter = wrappedAdapter;
            _profiler = profiler ?? MiniProfiler.Current;
        }

 public ProfiledDbTransaction(DbTransaction transaction, ProfiledDbConnection connection, IDbProfiler profiler)
 {
     if (transaction == null) throw new ArgumentNullException("transaction");
     if (connection == null) throw new ArgumentNullException("connection");
     InnerTransaction = transaction;
     _connection = connection;
     _profiler = profiler;
     _connectionId = UniqueIdExtensions<DbConnection>.GetUniqueId(connection.InnerConnection).ToInt();
     _profiler.TransactionBegan(connection.InnerConnection, NHProfilerContextProvider.GetLoggedDbConnection(this, _connectionId));
 }

        public ProfiledDbDataReader(DbDataReader reader, DbConnection connection, IDbProfiler profiler)
        {
            this.reader = reader;
            db = connection;

            if (profiler != null)
            {
                this.profiler = profiler;
            }
        }

        public ProfiledDbConnection(IDbConnection connection, IDbProfiler profiler, bool autoDisposeConnection=true)
        {
    		var hasConn = connection as IHasDbConnection;
			if (hasConn != null) connection = hasConn.DbConnection;
    		var dbConn = connection as DbConnection;

			if (dbConn == null)
				throw new ArgumentException(connection.GetType().GetOperationName() + " does not inherit DbConnection");
			
			Init(dbConn, profiler, autoDisposeConnection);
        }

        /// <summary>
        /// Initialises a new instance of the <see cref="SimpleProfiledDataReader"/> class.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="profiler">The profiler.</param>
        public SimpleProfiledDataReader(IDataReader reader, IDbProfiler profiler)
        {
            if (reader == null) throw new ArgumentNullException("reader");

            _reader = reader;

            if (profiler != null)
            {
                _profiler = profiler;
            }
        }

    	public ProfiledDbConnection(IDbConnection connection, IDbProfiler profiler)
    	{
    		var hasConn = connection as IHasDbConnection;
			if (hasConn != null) connection = hasConn.DbConnection;
    		var dbConn = connection as DbConnection;

			if (dbConn == null)
				throw new ArgumentException(connection.GetType().Name + " does not inherit DbConnection");
			
			Init(dbConn, profiler);
        }

        /// <summary>
        /// Returns a new <see cref="ProfiledDbConnection"/> that wraps <paramref name="connection"/>, 
        /// providing query execution profiling.  If profiler is null, no profiling will occur.
        /// </summary>
        /// <param name="connection">Your provider-specific flavor of connection, e.g. SqlConnection, OracleConnection</param>
        /// <param name="profiler">The currently started <see cref="MiniProfiler"/> or null.</param>
        public ProfiledDbConnection(DbConnection connection, IDbProfiler profiler)
        {
            if (connection == null) throw new ArgumentNullException("connection");

            _conn = connection;
            _conn.StateChange += StateChangeHandler;

            if (profiler != null)
            {
                _profiler = profiler;
            }
        }

        public ProfiledDbCommand(DbCommand cmd, DbConnection conn, IDbProfiler profiler)
        {
            if (cmd == null) throw new ArgumentNullException("cmd");

            _cmd = cmd;
            _conn = conn;

            if (profiler != null)
            {
                _profiler = profiler;
            }
        }

        private void Init(DbConnection connection, IDbProfiler profiler, bool autoDisposeConnection)
    	{
    		if (connection == null) throw new ArgumentNullException("connection");

    	    this.autoDisposeConnection = autoDisposeConnection;
    		_conn = connection;
    		_conn.StateChange += StateChangeHandler;

    		if (profiler != null)
    		{
    			_profiler = profiler;
    		}
    	}

        public ProfiledSqlClientBatchingBatcher(ConnectionManager connectionManager, IInterceptor interceptor)
            : base(connectionManager, interceptor)
        {
            this.batchSize = Factory.Settings.AdoBatchSize;
            this.defaultTimeout = PropertiesHelper.GetInt32(global::NHibernate.Cfg.Environment.CommandTimeout, global::NHibernate.Cfg.Environment.Properties, -1);

            this.currentBatch = this.CreateConfiguredBatch();

            // we always create this, because we need to deal with a scenario in which
            // the user change the logging configuration at runtime. Trying to put this
            // behind an if(log.IsDebugEnabled) will cause a null reference exception 
            // at that point.
            this.currentBatchCommandsLog = new StringBuilder().AppendLine("Batch commands:");
            this.profiler = StackExchange.Profiling.MiniProfiler.Current as IDbProfiler;
        }

        /// <summary>
        /// Initializes a <see cref="ProfiledDbProviderFactory"/>.
        /// </summary>
        /// <param name="dbProviderFactory">The <see cref="DbProviderFactory"/> to be profiled.</param>
        /// <param name="dbProfiler">The <see cref="IDbProfiler"/>.</param>
        public ProfiledDbProviderFactory(DbProviderFactory dbProviderFactory, IDbProfiler dbProfiler)
        {
            if (dbProviderFactory == null)
            {
                throw new ArgumentNullException("dbProviderFactory");
            }

            if (dbProfiler == null)
            {
                throw new ArgumentNullException("dbProfiler");
            }

            _dbProviderFactory = dbProviderFactory;
            _dbProfiler = dbProfiler;
        }

        /// <summary>
        /// Initializes a <see cref="ProfiledDbDataReader"/>.
        /// </summary>
        /// <param name="dataReader">The <see cref="IDataReader"/> to be profiled.</param>
        /// <param name="dbProfiler">
        ///     The <see cref="IDbProfiler"/> which profiles the <see cref="IDataReader"/>
        /// </param>
        public ProfiledDbDataReader(IDataReader dataReader, IDbProfiler dbProfiler)
        {
            if (dataReader == null)
            {
                throw new ArgumentNullException("dataReader");
            }

            if (dbProfiler == null)
            {
                throw new ArgumentNullException("dbProfiler");
            }

            _dataReader = dataReader;
            _dbDataReader = dataReader as DbDataReader;
            _dbProfiler = dbProfiler;
        }

        /// <summary>
        /// Initializes a <see cref="ProfiledDbConnection"/>.
        /// </summary>
        /// <param name="connection">The <see cref="IDbConnection"/> to be profiled.</param>
        /// <param name="dbProfiler">The <see cref="IDbProfiler"/>.</param>
        public ProfiledDbConnection(IDbConnection connection, IDbProfiler dbProfiler)
        {
            if (connection == null)
            {
                throw new ArgumentNullException("connection");
            }

            if (dbProfiler == null)
            {
                throw new ArgumentNullException("dbProfiler");
            }

            _connection = connection;
            _dbConnection = connection as DbConnection;
            if (_dbConnection != null)
            {
                _dbConnection.StateChange += StateChangeHandler;
            }
            _dbProfiler = dbProfiler;
        }

        /// <summary>
        /// Initializes a <see cref="ProfiledDbCommand"/>.
        /// </summary>
        /// <param name="command">The <see cref="IDbCommand"/> to be profiled.</param>
        /// <param name="dbProfiler">The <see cref="IDbProfiler"/>.</param>
        /// <param name="tags">The tags of the <see cref="DbTiming"/> which will be created internally.</param>
        public ProfiledDbCommand(IDbCommand command, IDbProfiler dbProfiler, IEnumerable<string> tags = null)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            if (dbProfiler == null)
            {
                throw new ArgumentNullException("dbProfiler");
            }

            _command = command;
            _dbCommand = command as DbCommand;
            _dbProfiler = dbProfiler;

            if (tags != null)
            {
                _tags = new List<string>(tags);
            }
        }

 /// <summary>
 /// proxy
 /// </summary>
 /// <param name="profiler"></param>
 /// <param name="tail"></param>
 public ProfiledDbProviderFactory(IDbProfiler profiler, DbProviderFactory tail)
 {
     this.profiler = profiler;
     this.tail = tail;
 }

 /// <summary>
 /// Initialises a new instance of the <see cref="CountingConnection"/> class. 
 /// </summary>
 /// <param name="connection">
 /// The connection.
 /// </param>
 /// <param name="profiler">
 /// The profiler.
 /// </param>
 public CountingConnection(DbConnection connection, IDbProfiler profiler)
     : base(connection, profiler)
 {
     CountingProfiler = (CountingDbProfiler)profiler;
 }

 public ProfiledSqlCommand(DbCommand command, IDbProfiler profiler)
     : base(command, null, profiler)
 {
     _sqlCommand = (SqlCommand)command;
 }