/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. /// If <paramref name="usePooledConnection"/> is true, than if this connection has been opened before, /// the connection from the pool will be returned rather than creating a new one. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <param name="usePooledConnection">If true, return an already created connection for this object. If /// false, always create a new one.</param> /// <returns>A new connection.</returns> public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db, bool usePooledConnection) { string connectionString = db.ConnectionStringWithoutCredentials; DatabaseConnectionWrapper connection; lock (connections) { if (!connections.TryGetValue(connectionString, out connection)) { // // We have to test this again in case another thread added a connection. // if (!connections.ContainsKey(connectionString)) { DbConnection keepAliveConnection = new SqlCeConnection(); db.SetConnectionString(keepAliveConnection); keepAliveConnection.Open(); connection = new DatabaseConnectionWrapper(keepAliveConnection); connections.Add(connectionString, connection); } } if (usePooledConnection) { connection.AddRef(); return connection; } return new DatabaseConnectionWrapper(new SqlCeConnection()); } }
public void CannotGetCommandForStoredProcedure() { TestConnectionString testConnection = new TestConnectionString(); testConnection.CopyFile(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); db.GetStoredProcCommand("CustOrdersOrders"); }
/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. /// If <paramref name="usePooledConnection"/> is true, than if this connection has been opened before, /// the connection from the pool will be returned rather than creating a new one. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <param name="usePooledConnection">If true, return an already created connection for this object. If /// false, always create a new one.</param> /// <returns>A new connection.</returns> public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db, bool usePooledConnection) { string connectionString = db.ConnectionStringWithoutCredentials; DatabaseConnectionWrapper connection; lock (connections) { if (!connections.TryGetValue(connectionString, out connection)) { // // We have to test this again in case another thread added a connection. // if (!connections.ContainsKey(connectionString)) { DbConnection keepAliveConnection = new SqlCeConnection(); db.SetConnectionString(keepAliveConnection); keepAliveConnection.Open(); connection = new DatabaseConnectionWrapper(keepAliveConnection); connections.Add(connectionString, connection); } } if (usePooledConnection) { connection.AddRef(); return(connection); } return(new DatabaseConnectionWrapper(new SqlCeConnection())); } }
public void SetUp() { testConnection = new TestConnectionString(); testConnection.CopyFile(); db = new SqlCeDatabase(testConnection.ConnectionString); DbCommand command = db.GetSqlStringCommand("Select count(*) from region"); baseFixture = new ExecuteScalarFixture(db, command); }
public void ConnectionShouldRemainInPoolAfterReturnedConnectionDisposed() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {} DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0); Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State); }
public void GetConnectionAddsConnectionToPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) { Assert.IsNotNull(connection); Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); } }
public void GetConnectionOpensConnectionInPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) { DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0); Assert.AreEqual(ConnectionState.Open, keepAlive.Connection.State); } }
public void CloseSharedConnectionsShouldClearPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) {} Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); SqlCeConnectionPool.CloseSharedConnections(); Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize); }
public static DbConnection CreateConnection(SqlCeDatabase db) { string connectionString = db.ConnectionStringWithoutCredentials; if (!connections.ContainsKey(connectionString)) { lock (connections) { if (!connections.ContainsKey(connectionString)) { DbConnection keepAliveConnection = new SqlCeConnection(); db.SetConnectionString(keepAliveConnection); keepAliveConnection.Open(); connections.Add(connectionString, keepAliveConnection); } } } return(new SqlCeConnection()); }
/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <returns>A new connection.</returns> internal static DbConnection CreateConnection(SqlCeDatabase db) { string connectionString = db.ConnectionStringWithoutCredentials; if (!connections.ContainsKey(connectionString)) { lock (connections) { // // We have to test this again in case another thread added a connection. // if (!connections.ContainsKey(connectionString)) { DbConnection keepAliveConnection = new SqlCeConnection(); db.SetConnectionString(keepAliveConnection); keepAliveConnection.Open(); connections.Add(connectionString, keepAliveConnection); } } } return new SqlCeConnection(); }
/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <returns>A new connection.</returns> internal static DbConnection CreateConnection(SqlCeDatabase db) { string connectionString = db.ConnectionStringWithoutCredentials; if (!connections.ContainsKey(connectionString)) { lock (connections) { // // We have to test this again in case another thread added a connection. // if (!connections.ContainsKey(connectionString)) { DbConnection keepAliveConnection = new SqlCeConnection(); db.SetConnectionString(keepAliveConnection); keepAliveConnection.Open(); connections.Add(connectionString, keepAliveConnection); } } } return(new SqlCeConnection()); }
/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. Always returns a new <see cref="SqlCeConnection"/> /// object, not a pooled one. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <returns>A new connection.</returns> public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db) { return(CreateConnection(db, false)); }
public void GetConnectionWithPoolingReturnsSameConnection() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db, true)) { using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db, true)) { Assert.AreSame(connection1, connection2); Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); } } }
/// <summary> /// Creates a new connection. If this is the first connection, it also creates an extra /// "Keep Alive" connection to keep the database open. Always returns a new <see cref="SqlCeConnection"/> /// object, not a pooled one. /// </summary> /// <param name="db">The database instance that will be used to create a connection.</param> /// <returns>A new connection.</returns> public static DatabaseConnectionWrapper CreateConnection(SqlCeDatabase db) { return CreateConnection(db, false); }
public void GetConnectionReturnsDifferentConnectionThanOneInPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db)) { DatabaseConnectionWrapper keepAlive = TestableSqlCeConnectionPool.GetConnection(0); Assert.AreNotSame(connection, keepAlive); } }
public void CanCreateNewDatabaseFile() { string filename = Path.Combine(Environment.CurrentDirectory, "newfile.sdf"); string connectionString = "Data Source='{0}'"; connectionString = String.Format(connectionString, filename); if (File.Exists(filename)) File.Delete(filename); Assert.IsFalse(File.Exists(filename)); SqlCeDatabase database = new SqlCeDatabase(connectionString); database.CreateFile(); Assert.IsTrue(File.Exists(filename)); File.Delete(filename); }
public void SetUp() { testConnection = new TestConnectionString(); testConnection.CopyFile(); db = new SqlCeDatabase(testConnection.ConnectionString); }
public void DatabaseShouldCloseSharedConnection() { TestConnectionString file = new TestConnectionString(); SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString); using (DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(database)) {} Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); database.CloseSharedConnection(); Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize); }
public void CreateNewDatabaseThrowsWhenFileAlreadyExists() { TestConnectionString file = new TestConnectionString(); Assert.IsTrue(File.Exists(file.Filename)); SqlCeDatabase database = new SqlCeDatabase(file.ConnectionString); database.CreateFile(); }
public void ShouldNotAddConnectionToPoolIfOpenFails() { SqlCeDatabase db = new SqlCeDatabase("Data Source='invalid.sdf'"); try { DatabaseConnectionWrapper connection = SqlCeConnectionPool.CreateConnection(db); } catch (SqlCeException) {} Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize); }
public void ExecuteSqlCreatesConnectionInPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); DbCommand command = db.GetSqlStringCommand("select count(*) from region"); Assert.AreEqual(0, TestableSqlCeConnectionPool.PoolSize); int result = (int)db.ExecuteScalar(command); Assert.AreEqual(4, result); Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); }
public void GetConnectionForTwoFilesAddsTwoConnectionsToPool() { TestConnectionString file1 = new TestConnectionString(); TestConnectionString file2 = new TestConnectionString("test2.sdf"); file2.CopyFile(); SqlCeDatabase db1 = new SqlCeDatabase(file1.ConnectionString); SqlCeDatabase db2 = new SqlCeDatabase(file2.ConnectionString); using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db1)) { using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db2)) {} } Assert.AreEqual(2, TestableSqlCeConnectionPool.PoolSize); SqlCeConnectionPool.CloseSharedConnections(); file2.DeleteFile(); }
public void CanOpenSqlCeDatabase() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase database = new SqlCeDatabase(testConnection.ConnectionString); using (DbConnection connection = database.CreateConnection()) { connection.Open(); Assert.AreEqual(ConnectionState.Open, connection.State); } }
public void GetConnectionReturnsNewConnectionButHasOnlyOneInPool() { TestConnectionString testConnection = new TestConnectionString(); SqlCeDatabase db = new SqlCeDatabase(testConnection.ConnectionString); using (DatabaseConnectionWrapper connection1 = SqlCeConnectionPool.CreateConnection(db)) { using (DatabaseConnectionWrapper connection2 = SqlCeConnectionPool.CreateConnection(db)) { Assert.AreNotSame(connection1, connection2); Assert.AreEqual(1, TestableSqlCeConnectionPool.PoolSize); } } }