internal void CloseFully() { if (settings.Pooling && driver.IsOpen) { // if we are in a transaction, roll it back if (driver.HasStatus(ServerStatusFlags.InTransaction)) { MySqlTransaction t = new MySqlTransaction(this, IsolationLevel.Unspecified); t.Rollback(); } MySqlPoolManager.ReleaseConnection(driver); } else { driver.Close(); } driver = null; }
/// <summary> /// Removes a connection from the in use pool. The only situations where this method /// would be called are when a connection that is in use gets some type of fatal exception /// or when the connection is being returned to the pool and it's too old to be /// returned. /// </summary> /// <param name="driver"></param> public void RemoveConnection(Driver driver) { lock ((inUsePool as ICollection).SyncRoot) { if (inUsePool.Contains(driver)) { inUsePool.Remove(driver); Interlocked.Increment(ref available); autoEvent.Set(); } } // if we are being cleared and we are out of connections then have // the manager destroy us. if (beingCleared && NumConnections == 0) { MySqlPoolManager.RemoveClearedPool(this); } }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { throw new InvalidOperationException(ResourceStrings.ConnectionAlreadyOpen); } SetState(ConnectionState.Connecting, true); try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(settings); } } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } SetState(ConnectionState.Open, false); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) { ChangeDatabase(settings.Database); } hasBeenOpen = true; SetState(ConnectionState.Open, true); }
protected virtual void Dispose(bool disposing) { // Avoid cyclic calls to Dispose. if (disposeInProgress) { return; } disposeInProgress = true; try { ResetTimeout(1000); if (disposing) { handler.Close(isOpen); } // if we are pooling, then release ourselves if (connectionString.Pooling) { MySqlPoolManager.RemoveConnection(this); } } catch (Exception) { if (disposing) { throw; } } finally { reader = null; isOpen = false; disposeInProgress = false; } }
/// <include file='docs/MySqlConnection.xml' path='docs/ClearAllPools/*'/> public static void ClearAllPools() { MySqlPoolManager.ClearAllPools(); }
/* * // Due to the DNXCore replacement for DataReader.GetSchemaTable() * // haven't implemented (refer to https://github.com/dotnet/corefx/issues/3423) * // this method should be remove till GetSchema is back. * // * * /// <summary> * /// Returns schema information for the data source of this <see cref="DbConnection"/>. * /// </summary> * /// <returns>A <see cref="DataTable"/> that contains schema information. </returns> * public override DataTable GetSchema() * { * return GetSchema(null); * } * * /// <summary> * /// Returns schema information for the data source of this * /// <see cref="DbConnection"/> using the specified string for the schema name. * /// </summary> * /// <param name="collectionName">Specifies the name of the schema to return. </param> * /// <returns>A <see cref="DataTable"/> that contains schema information. </returns> * public override DataTable GetSchema(string collectionName) * { * if (collectionName == null) * collectionName = SchemaProvider.MetaCollection; * * return GetSchema(collectionName, null); * } * * /// <summary> * /// Returns schema information for the data source of this <see cref="DbConnection"/> * /// using the specified string for the schema name and the specified string array * /// for the restriction values. * /// </summary> * /// <param name="collectionName">Specifies the name of the schema to return.</param> * /// <param name="restrictionValues">Specifies a set of restriction values for the requested schema.</param> * /// <returns>A <see cref="DataTable"/> that contains schema information.</returns> * public override DataTable GetSchema(string collectionName, string[] restrictionValues) * { * if (collectionName == null) * collectionName = SchemaProvider.MetaCollection; * * string[] restrictions = schemaProvider.CleanRestrictions(restrictionValues); * DataTable dt = schemaProvider.GetSchema(collectionName, restrictions); * return dt; * } */ /// <include file='docs/MySqlConnection.xml' path='docs/ClearPool/*'/> public static void ClearPool(MySqlConnection connection) { MySqlPoolManager.ClearPool(connection.Settings); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { throw new InvalidOperationException(Resources.ConnectionAlreadyOpen); } SetState(ConnectionState.Connecting, true); #if !CF // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { throw new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported); } } #endif try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(settings); } procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } SetState(ConnectionState.Open, false); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) { ChangeDatabase(settings.Database); } // setup our schema provider schemaProvider = new ISSchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF if (Transaction.Current != null && settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }