com.j256.ormlite.support.DatabaseConnection.isAutoCommitSupported java code examples

Common ways to obtain DatabaseConnection

private void myMethod () {
 DatabaseConnection d =Dao dao;dao.startThreadConnection()
ConnectionSource connectionSource;connectionSource.getReadWriteConnection()
Smart code suggestions by Tabnine
}

@Override
public boolean isAutoCommitSupported() throws SQLException {
  if (proxy == null) {
    return false;
  } else {
    return proxy.isAutoCommitSupported();
  }
}

@Override
public boolean isAutoCommitSupported() throws SQLException {
  if (proxy == null) {
    return false;
  } else {
    return proxy.isAutoCommitSupported();
  }
}

/**
 * @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;
  }        
}

@Test
public void testIsAutoCommitSupported() throws Exception {
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  boolean supported = true;
  expect(conn.isAutoCommitSupported()).andReturn(supported);
  conn.close();
  DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn);
  replay(conn);
  assertEquals(supported, proxy.isAutoCommitSupported());
  proxy.close();
  verify(conn);
}

@Test
public void testCallBatchTasksNoAutoCommit() 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(false);
  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 testTransactionManagerSavePointNull() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  expect(conn.setSavePoint(isA(String.class))).andReturn(null);
  conn.commit(null);
  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);
  TransactionManager tm = new TransactionManager(connectionSource);
  tm.callInTransaction(new Callable<Void>() {
    @Override
    public Void call() {
      return null;
    }
  });
  verify(connectionSource, conn);
}

@Test
public void testTransactionManagerTableName() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  Savepoint savePoint = createMock(Savepoint.class);
  expect(savePoint.getSavepointName()).andReturn("name").anyTimes();
  expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint);
  conn.commit(savePoint);
  expect(connectionSource.getDatabaseType()).andReturn(databaseType);
  expect(connectionSource.getReadWriteConnection(FOO_TABLE_NAME)).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(FOO_TABLE_NAME, new Callable<Void>() {
    @Override
    public Void call() {
      return null;
    }
  });
  verify(connectionSource, conn, savePoint);
}

@Test
public void testCallBatchTasksAutoCommitFalse() 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(false);
  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 testTransactionManager() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  Savepoint savePoint = createMock(Savepoint.class);
  expect(savePoint.getSavepointName()).andReturn("name").anyTimes();
  expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint);
  conn.commit(savePoint);
  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 testTransactionManagerAutoCommitSupported() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(true);
  expect(conn.isAutoCommit()).andReturn(false);
  Savepoint savePoint = createMock(Savepoint.class);
  expect(savePoint.getSavepointName()).andReturn("name").anyTimes();
  expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint);
  conn.commit(savePoint);
  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 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 testTransactionManagerRollbackNullSavePoint() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  expect(conn.setSavePoint(isA(String.class))).andReturn(null);
  conn.rollback(null);
  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);
  TransactionManager tm = new TransactionManager(connectionSource);
  try {
    tm.callInTransaction(new Callable<Void>() {
      @Override
      public Void call() throws Exception {
        throw new SQLException("you better roll back!!");
      }
    });
    fail("expected an exception");
  } catch (SQLException e) {
    // expected
  }
  verify(connectionSource, conn);
}

@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 testTransactionManagerRollbackOtherException() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  Savepoint savePoint = createMock(Savepoint.class);
  expect(savePoint.getSavepointName()).andReturn("name").anyTimes();
  expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint);
  conn.rollback(savePoint);
  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);
  try {
    tm.callInTransaction(new Callable<Void>() {
      @Override
      public Void call() throws Exception {
        throw new Exception("you better roll back!!");
      }
    });
    fail("expected an exception");
  } catch (Exception e) {
    // expected
  }
  verify(connectionSource, conn, savePoint);
}

@Test
public void testTransactionManagerRollback() throws Exception {
  ConnectionSource connectionSource = createMock(ConnectionSource.class);
  DatabaseConnection conn = createMock(DatabaseConnection.class);
  expect(conn.isAutoCommitSupported()).andReturn(false);
  Savepoint savePoint = createMock(Savepoint.class);
  expect(savePoint.getSavepointName()).andReturn("name").anyTimes();
  expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint);
  conn.rollback(savePoint);
  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);
  try {
    tm.callInTransaction(new Callable<Void>() {
      @Override
      public Void call() throws Exception {
        throw new SQLException("you better roll back!!");
      }
    });
    fail("expected an exception");
  } catch (SQLException e) {
    // expected
  }
  verify(connectionSource, conn, savePoint);
}

@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.isAutoCommitSupported()) {
  if (connection.isAutoCommit()) {

if (connection.isAutoCommitSupported()) {
  if (connection.isAutoCommit()) {

Savepoint savePoint = null;
if (saved || databaseType.isNestedSavePointsSupported()) {
  if (connection.isAutoCommitSupported()) {
    if (connection.isAutoCommit()) {

Javadoc

Return if auto-commit is supported.

Popular methods of DatabaseConnection

executeStatement
Execute a statement directly on the connection.
isAutoCommit
Return if auto-commit is currently enabled.
setAutoCommit
Set the auto-commit to be on (true) or off (false). Setting auto-commit to true may or may-not cause
commit
Commit all changes since the savepoint was created. If savePoint is null then commit all outstanding
compileStatement
Like compileStatement(String, StatementType, FieldType[]) except the caller can specify the result f
setSavePoint
Start a save point with a certain name. It can be a noop if savepoints are not supported.
close
closeQuietly
Close the connection to the database but swallow any exceptions.
insert
Perform a SQL update while with the associated SQL statement, arguments, and types. This will possib
queryForLong
Perform a query whose result should be a single long-integer value.
rollback
Roll back all changes since the savepoint was created. If savePoint is null then roll back all outst
delete
Perform a SQL delete with the associated SQL statement, arguments, and types.

Popular in Java

Start an intent from android
runOnUiThread (Activity)
scheduleAtFixedRate (ScheduledExecutorService)
notifyDataSetChanged (ArrayAdapter)
Connection (java.sql)
A connection represents a link from a Java application to a database. All SQL statements and results
SSLHandshakeException (javax.net.ssl)
The exception that is thrown when a handshake could not be completed successfully.
BoxLayout (javax.swing)
LogFactory (org.apache.commons.logging)
Factory for creating Log instances, with discovery and configuration features similar to that employ
Project (org.apache.tools.ant)
Central representation of an Ant project. This class defines an Ant project with all of its targets,
Option (scala)
21 Best IntelliJ Plugins

How to use isAutoCommitSupportedmethodin com.j256.ormlite.support.DatabaseConnection

Best Java code snippets using com.j256.ormlite.support.DatabaseConnection.isAutoCommitSupported (Showing top 20 results out of 315)

How to use
isAutoCommitSupported
method
in
com.j256.ormlite.support.DatabaseConnection