@Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } }
@Override public void setAutoCommit(DatabaseConnection connection, boolean autoCommit) throws SQLException { connection.setAutoCommit(autoCommit); }
@Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } }
@Override public void setAutoCommit(DatabaseConnection connection, boolean autoCommit) throws SQLException { connection.setAutoCommit(autoCommit); }
/** * Return true if the two connections seem to one one connection under the covers. */ protected boolean isSingleConnection(DatabaseConnection conn1, DatabaseConnection conn2) throws SQLException { // initialize the connections auto-commit flags conn1.setAutoCommit(true); conn2.setAutoCommit(true); try { // change conn1's auto-commit to be false conn1.setAutoCommit(false); if (conn2.isAutoCommit()) { // if the 2nd connection's auto-commit is still true then we have multiple connections return false; } else { // if the 2nd connection's auto-commit is also false then we have a single connection return true; } } finally { // restore its auto-commit conn1.setAutoCommit(true); } }
/** * Return true if the two connections seem to one one connection under the covers. */ protected boolean isSingleConnection(DatabaseConnection conn1, DatabaseConnection conn2) throws SQLException { // initialize the connections auto-commit flags conn1.setAutoCommit(true); conn2.setAutoCommit(true); try { // change conn1's auto-commit to be false conn1.setAutoCommit(false); if (conn2.isAutoCommit()) { // if the 2nd connection's auto-commit is still true then we have multiple connections return false; } else { // if the 2nd connection's auto-commit is also false then we have a single connection return true; } } finally { // restore its auto-commit conn1.setAutoCommit(true); } }
@Override public void close() throws Exception { try { if (autoCommitAtStart) { connection.setAutoCommit(true); } } finally { connectionSource.clearSpecialConnection(connection); connectionSource.releaseConnection(connection); } } }
DatabaseConnection databaseConnection = blogDao.startThreadConnection(); boolean autoCommit = databaseConnection.isAutoCommit(); databaseConnection.setAutoCommit(false); for (Blog blog : blogList) { blogDao.create(blog); databaseConnection.setAutoCommit(autoCommit);
/** * @param connectionSource {@link ConnectionSource} for transaction. * @throws SQLException Connection error. */ public OrmliteTransaction(@Nonnull ConnectionSource connectionSource) throws SQLException { Validate.notNull(connectionSource, "connectionSource"); this.connectionSource = connectionSource; this.connection = this.connectionSource.getReadWriteConnection(); final boolean saved = this.connectionSource.saveSpecialConnection(connection); if (saved || connectionSource.getDatabaseType().isNestedSavePointsSupported()) { if (connection.isAutoCommitSupported()) { autoCommitAtStart = connection.isAutoCommit(); if (autoCommitAtStart) { connection.setAutoCommit(false); } } else { autoCommitAtStart = false; } savepoint = connection.setSavePoint(SAVE_POINT_PREFIX + savepointCounter.incrementAndGet()); } else { savepoint = null; autoCommitAtStart = false; } }
if (connection.isAutoCommit()) { connection.setAutoCommit(false); resetAutoCommit = true; logger.debug("disabled auto-commit on table {} before batch tasks", tableInfo.getTableName()); connection.setAutoCommit(true); logger.debug("re-enabled auto-commit on table {} after batch tasks", tableInfo.getTableName());
if (connection.isAutoCommit()) { connection.setAutoCommit(false); resetAutoCommit = true; logger.debug("disabled auto-commit on table {} before batch tasks", tableInfo.getTableName()); connection.setAutoCommit(true); logger.debug("re-enabled auto-commit on table {} after batch tasks", tableInfo.getTableName());
@Test public void testSetAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; conn.setAutoCommit(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setAutoCommit(autoCommit); proxy.close(); verify(conn); }
@Test public void testCallBatchTasksAutoCommitTrueSynchronized() throws Exception { TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(databaseType, Foo.class); ConnectionSource connectionSource = createMock(ConnectionSource.class); DatabaseConnection connection = createMock(DatabaseConnection.class); expect(connectionSource.isSingleConnection("foo")).andReturn(true); expect(connectionSource.getReadWriteConnection("foo")).andReturn(connection); expect(connectionSource.saveSpecialConnection(connection)).andReturn(false); connectionSource.clearSpecialConnection(connection); connectionSource.releaseConnection(connection); expect(connection.isAutoCommitSupported()).andReturn(true); expect(connection.isAutoCommit()).andReturn(true); connection.setAutoCommit(false); connection.setAutoCommit(true); StatementExecutor<Foo, String> statementExec = new StatementExecutor<Foo, String>(databaseType, tableInfo, null); replay(connectionSource, connection); final AtomicBoolean called = new AtomicBoolean(false); statementExec.callBatchTasks(connectionSource, new Callable<Void>() { @Override public Void call() { called.set(true); return null; } }); assertTrue(called.get()); verify(connectionSource, connection); }
@Test public void testTransactionManagerAutoCommitOn() throws Exception { ConnectionSource connectionSource = createMock(ConnectionSource.class); DatabaseConnection conn = createMock(DatabaseConnection.class); expect(conn.isAutoCommitSupported()).andReturn(true); expect(conn.isAutoCommit()).andReturn(true); conn.setAutoCommit(false); Savepoint savePoint = createMock(Savepoint.class); expect(savePoint.getSavepointName()).andReturn("name").anyTimes(); expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint); conn.commit(savePoint); conn.setAutoCommit(true); expect(connectionSource.getDatabaseType()).andReturn(databaseType); expect(connectionSource.getReadWriteConnection(null)).andReturn(conn); expect(connectionSource.saveSpecialConnection(conn)).andReturn(true); connectionSource.clearSpecialConnection(conn); connectionSource.releaseConnection(conn); replay(connectionSource, conn, savePoint); TransactionManager tm = new TransactionManager(connectionSource); tm.callInTransaction(new Callable<Void>() { @Override public Void call() { return null; } }); verify(connectionSource, conn, savePoint); }
@Test public void testCallBatchTasksAutoCommitTrue() throws Exception { TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(databaseType, Foo.class); ConnectionSource connectionSource = createMock(ConnectionSource.class); DatabaseConnection connection = createMock(DatabaseConnection.class); expect(connectionSource.isSingleConnection("foo")).andReturn(false); expect(connectionSource.getReadWriteConnection("foo")).andReturn(connection); expect(connectionSource.saveSpecialConnection(connection)).andReturn(false); connectionSource.clearSpecialConnection(connection); connectionSource.releaseConnection(connection); expect(connection.isAutoCommitSupported()).andReturn(true); expect(connection.isAutoCommit()).andReturn(true); connection.setAutoCommit(false); connection.setAutoCommit(true); StatementExecutor<Foo, String> statementExec = new StatementExecutor<Foo, String>(databaseType, tableInfo, null); replay(connectionSource, connection); final AtomicBoolean called = new AtomicBoolean(false); statementExec.callBatchTasks(connectionSource, new Callable<Void>() { @Override public Void call() { called.set(true); return null; } }); assertTrue(called.get()); verify(connectionSource, connection); }
@Test public void testCallBatchTasksAutoCommitTrueThrow() throws Exception { TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(databaseType, Foo.class); ConnectionSource connectionSource = createMock(ConnectionSource.class); DatabaseConnection connection = createMock(DatabaseConnection.class); expect(connectionSource.isSingleConnection("foo")).andReturn(false); expect(connectionSource.getReadWriteConnection("foo")).andReturn(connection); expect(connectionSource.saveSpecialConnection(connection)).andReturn(false); connectionSource.clearSpecialConnection(connection); connectionSource.releaseConnection(connection); expect(connection.isAutoCommitSupported()).andReturn(true); expect(connection.isAutoCommit()).andReturn(true); connection.setAutoCommit(false); connection.setAutoCommit(true); StatementExecutor<Foo, String> statementExec = new StatementExecutor<Foo, String>(databaseType, tableInfo, null); replay(connectionSource, connection); try { statementExec.callBatchTasks(connectionSource, new Callable<Void>() { @Override public Void call() throws Exception { throw new Exception("expected"); } }); fail("Should have thrown"); } catch (Exception e) { // expected } verify(connectionSource, connection); }
if (connection.isAutoCommit()) { connection.setAutoCommit(false); restoreAutoCommit = true; logger.trace("had to set auto-commit to false"); if (restoreAutoCommit) { connection.setAutoCommit(true); logger.trace("restored auto-commit to true");
if (connection.isAutoCommit()) { connection.setAutoCommit(false); restoreAutoCommit = true; logger.trace("had to set auto-commit to false"); if (restoreAutoCommit) { connection.setAutoCommit(true); logger.trace("restored auto-commit to true");
@Test public void testSetAutoCommit() throws Exception { JdbcPooledConnectionSource pooled = new JdbcPooledConnectionSource(DEFAULT_DATABASE_URL); try { DatabaseConnection conn1 = pooled.getReadOnlyConnection(null); conn1.setAutoCommit(false); pooled.releaseConnection(conn1); DatabaseConnection conn2 = pooled.getReadOnlyConnection(null); assertSame(conn1, conn2); assertTrue(conn2.isAutoCommit()); } finally { pooled.close(); } }
@Test public void testConnectionMethods() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); DatabaseConnection conn = null; try { conn = dao.startThreadConnection(); assertTrue(dao.isAutoCommit(conn)); dao.setAutoCommit(conn, false); assertFalse(dao.isAutoCommit(conn)); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); assertNotNull(dao.queryForId(foo.id)); dao.rollBack(conn); assertNull(dao.queryForId(foo.id)); foo = new Foo(); assertEquals(1, dao.create(foo)); assertNotNull(dao.queryForId(foo.id)); dao.commit(conn); assertNotNull(dao.queryForId(foo.id)); dao.rollBack(conn); assertNotNull(dao.queryForId(foo.id)); } finally { if (conn != null) { conn.setAutoCommit(true); dao.endThreadConnection(conn); } } }