*/
public class DatabaseUtils {
+ /**
+ * Represents a set of tables.
+ *
+ * @author Erik Brakkee
+ */
public static interface TableSet {
boolean contains(String aTableName);
}
+ /**
+ * Represents a unit of work (transaction).
+ *
+ * @author Erik Brakkee
+ *
+ * @param <T> Type of return value.
+ */
public static interface JdbcUnitOfWork<T> {
+ /**
+ * Executes statement within a transaction.
+ * @param aConnection Connection.
+ * @return Result of the work.
+ * @throws Exception
+ */
T execute(Connection aConnection) throws Exception;
}
+ /**
+ * Operation to be executed on a set of tables for each table
+ * individually.
+ *
+ * @author Erik Brakkee
+ */
public static interface TableSetOperation {
+ /**
+ * Executes on a table.
+ * @param aTable Table name.
+ * @throws Exception
+ */
void execute(String aTable) throws Exception;
}
*/
private static final String SCHEMA_PATTERN = "%";
private DataSource dataSource;
- private ITableFilterSimple tables;
private IDatabaseTester dbtester;
/**
/**
* Constructs the database utils.
* Before use, {@link #start()} must be called.
- * @param aDataSource Datasource.
- * @param aTables Tables to work with.
+ * @param aDataSource Datasource.
*/
- public DatabaseUtils(DataSource aDataSource, ITableFilterSimple aTables) {
+ public DatabaseUtils(DataSource aDataSource) {
dataSource = aDataSource;
- tables = aTables;
dbtester = new DataSourceDatabaseTester(dataSource);
connections = new ArrayList<IDatabaseConnection>();
}
LOG.log(Level.WARNING, "Could not close connection", e);
}
}
+ connections.clear();
}
- public IDatabaseTester createDbTester() throws Exception {
- return createDbTester(getTableNames(tables));
+ /**
+ * Creates database tester.
+ * @param aTables Tables to create the tester for.
+ * @return Database tester.
+ * @throws Exception
+ */
+ public IDatabaseTester createDbTester(ITableFilterSimple aTables) throws Exception {
+ return createDbTester(getTableNames(aTables));
}
-
+
+ /**
+ * Creates database tester.
+ * @param aTables Tables to create the tester for.
+ * @return Database tester.
+ * @throws Exception
+ */
public IDatabaseTester createDbTester(String[] aTables) throws Exception {
IDatabaseConnection connection = dbtester.getConnection();
connections.add(connection);
return dbtester;
}
- public void cleanDatabase() throws Exception {
- cleanDatabase(tables);
- }
-
+ /**
+ * Executes an operation on a set of tables.
+ * @param aTables Tables.
+ * @param aOperation Operation.
+ * @throws Exception
+ */
public void executeOnTables(ITableFilterSimple aTables,
final TableSetOperation aOperation) throws Exception {
- final String[] tables = getTableNames(aTables);
+ final String[] tableNames = getTableNames(aTables);
executeInTransaction(new JdbcUnitOfWork<Void>() {
public Void execute(Connection aConnection) throws Exception {
- for (int i = tables.length - 1; i >= 0; i--) {
- aOperation.execute(tables[i]);
+ for (int i = tableNames.length - 1; i >= 0; i--) {
+ aOperation.execute(tableNames[i]);
}
return null;
}
});
}
+ /**
+ * Cleans a number of database tables. This means deleting the content not dropping the tables.
+ * This may fail in case of cyclic dependencies between the tables (current limitation).
+ * @param aSelection Tables.
+ * @throws Exception
+ */
public void cleanDatabase(ITableFilterSimple aSelection) throws Exception {
- final String[] tables = getTableNames(aSelection);
+ final String[] tableNames = getTableNames(aSelection);
executeInTransaction(new JdbcUnitOfWork<Void>() {
public Void execute(Connection aConnection) throws Exception {
IDatabaseConnection connection = new DatabaseConnection(
aConnection);
ITableFilter filter = new DatabaseSequenceFilter(connection,
- tables);
+ tableNames);
IDataSet dataset = new FilteredDataSet(filter, connection
- .createDataSet(tables));
+ .createDataSet(tableNames));
DatabaseOperation.DELETE_ALL.execute(connection, dataset);
return null;
}
}
- public <T> T executeInTransaction(JdbcUnitOfWork<T> aCallback)
+ /**
+ * Executes a unit of work within a transaction.
+ * @param <T> Result type of th ework.
+ * @param aWork Unit of work.
+ * @return
+ * @throws Exception
+ */
+ public <T> T executeInTransaction(JdbcUnitOfWork<T> aWork)
throws Exception {
Connection connection = dataSource.getConnection();
connection.setAutoCommit(false);
try {
- T value = aCallback.execute(connection);
+ T value = aWork.execute(connection);
connection.commit();
return value;
} finally {
connection.close();
}
}
-
- public String[] getTableNames() throws Exception {
- return getTableNames(tables);
- }
-
+
/**
- * @throws SQLException
+ * Returns table names based on a table filter.
+ * @param aSelection Table filter.
+ * @return Table names.
+ * @throws Exception
*/
public String[] getTableNames(ITableFilterSimple aSelection)
throws Exception {
Connection connection = dataSource.getConnection();
try {
- ResultSet tables = connection.getMetaData().getTables(null,
+ ResultSet tableNames = connection.getMetaData().getTables(null,
SCHEMA_PATTERN, "%", new String[] { "TABLE" });
- while (tables.next()) {
- String table = tables.getString("TABLE_NAME");
+ while (tableNames.next()) {
+ String table = tableNames.getString("TABLE_NAME");
if (aSelection.accept(table)) {
result.add(table);
}
}
}
- public void emptyTables() throws Exception {
- executeOnTables(tables, new TableSetOperation() {
- public void execute(String aTable) throws Exception {
- emptyTable(aTable);
- }
- });
- }
-
/**
- * @return
- * @throws SQLException
+ * Use {@link #cleanDatabase(ITableFilterSimple)} instead.
*/
+ @Deprecated
public void emptyTables(final ITableFilterSimple aSelection)
throws Exception {
executeOnTables(aSelection, new TableSetOperation() {
}
/**
- * @return
- * @throws SQLException
+ * User {@link #cleanDatabase(ITableFilterSimple)} instead.
*/
+ @Deprecated
public void emptyTable(String aTable) throws Exception {
executeSql("delete from " + aTable);
}
- public void dropTables() throws Exception {
- dropTables(tables);
- }
-
+ /**
+ * Drops tables. This only works if there are no cyclic dependencies between the tables.
+ * @param aTables Tables to drop.
+ * @throws Exception
+ */
public void dropTables(ITableFilterSimple aTables) throws Exception {
- final String[] tables = getTableNames(aTables);
+ final String[] tableNames = getTableNames(aTables);
String[] sortedTables = executeInTransaction(new JdbcUnitOfWork<String[]>() {
public String[] execute(Connection aConnection) throws Exception {
IDatabaseConnection connection = new DatabaseConnection(
aConnection);
ITableFilter filter = new DatabaseSequenceFilter(connection,
- tables);
+ tableNames);
IDataSet dataset = new FilteredDataSet(filter, connection
- .createDataSet(tables));
+ .createDataSet(tableNames));
return dataset.getTableNames();
}
});
}
/**
- * @return
- * @throws SQLException
+ * Drops a table.
+ * @param aTable Table to drop.
+ * @throws Exception
*/
public void dropTable(final String aTable) throws Exception {
executeInTransaction(new JdbcUnitOfWork<Void>() {
}
}
+ /**
+ * Executes an update.
+ * @param aConnection Connection to use.
+ * @param aSql SQL update to use.
+ * @param aArgs Arguments to the update.
+ * @return Number of rows updated.
+ */
public int executeUpdate(Connection aConnection, final String aSql,
final Object... aArgs) {
try {
}
/**
- * @return
+ * Gets the table size.
+ * @param aTable Table.
+ * @return Table size.
* @throws SQLException
*/
public int getTableSize(final String aTable) throws Exception {
}
+ /**
+ * Counts the results in a result set.
+ * @param aResultSet Resultset.
+ * @return Number of rows in the set.
+ * @throws SQLException
+ */
public int countResultSet(ResultSet aResultSet) throws SQLException {
int count = 0;
git://wamblee.org / utils / blobdiff