public static void logDb(IDatabaseConnection connection) { try { ITableFilter filter = new DatabaseSequenceFilter(connection); IDataSet dataset = new FilteredDataSet(filter, connection.createDataSet()); StringWriter out = new StringWriter(); FlatXmlDataSet.write(dataset, out); log.info(out.getBuffer().toString()); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } }
public void compareContent(IDataSet currentDataSet, IDataSet expectedDataSet, AssertionErrorCollector errorCollector) throws DatabaseUnitException { final String[] tableNames = expectedDataSet.getTableNames(); final FilteredDataSet filteredCurrentDataSet = new FilteredDataSet(new IncludeTableFilter(tableNames), currentDataSet); for (String tableName : tableNames) { final List<String> columnsForSorting = defineColumnsForSorting(filteredCurrentDataSet, expectedDataSet, tableName); final ITable expectedTable = sort(new TableWrapper(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName).getTableMetaData()), columnsForSorting); final ITable currentTable = sort(filteredCurrentDataSet.getTable(tableName), columnsForSorting); final List<String> columnsToIgnore = extractColumnsToBeIgnored(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName)); final DiffCollectingFailureHandler diffCollector = new DiffCollectingFailureHandler(); final ITable expectedTableWithFilteredColumns = filter(expectedTable, toStringArray(columnsToIgnore)); final ITable actualTableWithFilteredColumns = filter(currentTable, toStringArray(columnsToIgnore)); Assertion.assertEquals(expectedTableWithFilteredColumns, actualTableWithFilteredColumns, diffCollector); @SuppressWarnings("unchecked") final List<Difference> diffs = diffCollector.getDiffList(); collectErrors(errorCollector, diffs); } }
public void compareContent(IDataSet currentDataSet, IDataSet expectedDataSet, AssertionErrorCollector errorCollector) throws DatabaseUnitException { final String[] tableNames = expectedDataSet.getTableNames(); final FilteredDataSet filteredCurrentDataSet = new FilteredDataSet(new IncludeTableFilter(tableNames), currentDataSet); for (String tableName : tableNames) { final List<String> columnsForSorting = defineColumnsForSorting(filteredCurrentDataSet, expectedDataSet, tableName); final ITable expectedTable = sort(new TableWrapper(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName).getTableMetaData()), columnsForSorting); final ITable currentTable = sort(filteredCurrentDataSet.getTable(tableName), columnsForSorting); final List<String> columnsToIgnore = extractColumnsToBeIgnored(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName)); final DiffCollectingFailureHandler diffCollector = new DiffCollectingFailureHandler(); final ITable expectedTableWithFilteredColumns = filter(expectedTable, toStringArray(columnsToIgnore)); final ITable actualTableWithFilteredColumns = filter(currentTable, toStringArray(columnsToIgnore)); try { Assertion.assertEquals(expectedTableWithFilteredColumns, actualTableWithFilteredColumns, diffCollector); } catch (Throwable e) { e.printStackTrace(); errorCollector.collect(e); } @SuppressWarnings("unchecked") final List<Difference> diffs = diffCollector.getDiffList(); collectErrors(errorCollector, diffs); } }
@Override public void doInDbUnit(IDatabaseConnection connection) throws Exception { IDataSet dataSet = new FilteredDataSet(new DatabaseSequenceFilter(connection), connection.createDataSet()); File parent = new File(dir); if (!parent.exists()) { parent.mkdirs(); } Writer out = new OutputStreamWriter(new FileOutputStream(new File(dir, fileName))); FlatDtdDataSet.write(new SortedDataSet(dataSet), out); } });
public void compareContent(IDataSet currentDataSet, IDataSet expectedDataSet, AssertionErrorCollector errorCollector) throws DatabaseUnitException { final String[] tableNames = expectedDataSet.getTableNames(); final FilteredDataSet filteredCurrentDataSet = new FilteredDataSet(new IncludeTableFilter(tableNames), currentDataSet); for (String tableName : tableNames) { final List<String> columnsForSorting = defineColumnsForSorting(filteredCurrentDataSet, expectedDataSet, tableName); final ITable expectedTable = sort(new TableWrapper(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName).getTableMetaData()), columnsForSorting); final ITable currentTable = sort(filteredCurrentDataSet.getTable(tableName), columnsForSorting); final List<String> columnsToIgnore = extractColumnsToBeIgnored(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName)); final DiffCollectingFailureHandler diffCollector = new DiffCollectingFailureHandler(); final ITable expectedTableWithFilteredColumns = filter(expectedTable, toStringArray(columnsToIgnore)); final ITable actualTableWithFilteredColumns = filter(currentTable, toStringArray(columnsToIgnore)); try { Assertion.assertEquals(expectedTableWithFilteredColumns, actualTableWithFilteredColumns, diffCollector); } catch (Throwable e) { e.printStackTrace(); errorCollector.collect(e); } @SuppressWarnings("unchecked") final List<Difference> diffs = diffCollector.getDiffList(); collectErrors(errorCollector, diffs); } }
private IDataSet getDataSet(IDatabaseConnection conn) throws Exception { IDataSet ds = flatXmlDataSet; // If automated table order is enabled, decorate the table set with a database sequence filter if (this.automatedTableOrder) { ds = new FilteredDataSet(new DatabaseSequenceFilter(conn), flatXmlDataSet); } return ds; }
public void compareContent(IDataSet currentDataSet, IDataSet expectedDataSet, AssertionErrorCollector errorCollector) throws DataSetException, DatabaseUnitException { final String[] tableNames = expectedDataSet.getTableNames(); final FilteredDataSet filteredCurrentDataSet = new FilteredDataSet(new IncludeTableFilter(tableNames), currentDataSet); for (String tableName : tableNames) { final List<String> columnsForSorting = defineColumnsForSorting(filteredCurrentDataSet, expectedDataSet, tableName); final ITable expectedTable = sort(expectedDataSet, tableName, columnsForSorting); final ITable currentTable = sort(filteredCurrentDataSet, tableName, columnsForSorting); final List<String> columnsToIgnore = extractColumnsToBeIgnored(expectedDataSet.getTable(tableName), filteredCurrentDataSet.getTable(tableName)); final DiffCollectingFailureHandler diffCollector = new DiffCollectingFailureHandler(); Assertion.assertEquals(filter(expectedTable, toArray(columnsToIgnore)), filter(currentTable, toArray(columnsToIgnore)), diffCollector); @SuppressWarnings("unchecked") final List<Difference> diffs = diffCollector.getDiffList(); collectErrors(errorCollector, diffs); } }
/** * Creates a data set schema for the given DbUnit dataset. * * @param schemaName The schema name that this data set is for, not null * @param dbUnitDataSet The DbUnit data set, not null * @param tablesToInclude Only tables with these names will be returned the rest will be ignored, null for all tables * @return The data set schema, not null */ public Schema createSchemaForDbUnitDataSet(String schemaName, IDataSet dbUnitDataSet, List<String> tablesToInclude) { IDataSet filteredDataSet = new FilteredDataSet(new IncludeTableFilter(tablesToInclude.toArray(new String[tablesToInclude.size()])), dbUnitDataSet); return createSchemaForDbUnitDataSet(schemaName, filteredDataSet); }
public static IDataSet excludeTables(IDataSet dataSet, String ... tablesToExclude) { return new FilteredDataSet(new ExcludeTableFilter(tablesToExclude), dataSet); }
public static IDataSet excludeTables(IDataSet dataSet, String ... tablesToExclude) { return new FilteredDataSet(new ExcludeTableFilter(tablesToExclude), dataSet); }
@Override public void doInDbUnit(IDatabaseConnection connection) throws Exception { FilteredDataSet dataSet = new FilteredDataSet( new DatabaseSequenceFilter(connection), connection.createDataSet()); File parent = new File(dir); if (!parent.exists()) { parent.mkdirs(); } Writer out = new FileWriter(new File(dir, fileName)); //OutputStream out = new FileOutputStream(new File(dir, fileName)); FlatXmlDataSet.write(new SortedDataSet(dataSet), out, "UTF-8"); } });
public static IDataSet excludeTables(IDataSet dataSet, String... tablesToExclude) { return new FilteredDataSet(new ExcludeTableFilter(tablesToExclude), dataSet); }
public void writeXmlDataSet(OutputStream outputStream, String[] tables) { try { IDataSet dataSet = getIDatabaseConnection().createDataSet(); if (tables != null) { dataSet = new FilteredDataSet(tables, dataSet); } XmlDataSet.write(dataSet, outputStream); } catch (IOException e) { throw new RuntimeException(e); } catch (DataSetException e) { throw new RuntimeException(e); } catch (SQLException e) { throw new RuntimeException(e); } }
/** * Export the schema of a database as a DTD. * * @return the schema of a database as a DTD. */ public String exportDtd() { try { ITableFilter tableFilter = new DatabaseSequenceFilter(connection); IDataSet dataSet = new FilteredDataSet(tableFilter, connection.createDataSet()); StringWriter buffer = new StringWriter(); FlatDtdDataSet.write(dataSet, buffer); return buffer.toString(); } catch (DataSetException | IOException | SQLException e) { throw new RuntimeException("Error while exporting schema", e); } }
public static IDataSet excludeTables(IDataSet dataSet, String... tablesToExclude) { return new FilteredDataSet(new ExcludeTableFilter(tablesToExclude), dataSet); }
public void execute(IDatabaseConnection connection, IDataSet dataSet) throws DatabaseUnitException, SQLException { ITableFilter filter = new DatabaseSequenceFilter(connection); IDataSet dataset = new FilteredDataSet(filter, connection.createDataSet()); String[] tableNames = dataset.getTableNames(); List<String> reversedTableNames = new ArrayList<String>(); reversedTableNames.addAll(Arrays.asList(tableNames)); Collections.reverse(reversedTableNames); Statement stmt = null; try { stmt = connection.getConnection().createStatement(); for (String table : reversedTableNames) { stmt.addBatch("DROP TABLE " + table + " IF EXISTS CASCADE"); } stmt.executeBatch(); } finally { if (stmt != null) { try { stmt.close(); } catch (SQLException ignore) { } } } }
public void execute(IDatabaseConnection connection, IDataSet dataSet) throws DatabaseUnitException, SQLException { ITableFilter filter = new DatabaseSequenceFilter(connection); IDataSet dataset = new FilteredDataSet(filter, connection.createDataSet()); String[] tableNames = dataset.getTableNames(); List<String> reversedTableNames = new ArrayList<String>(); reversedTableNames.addAll(Arrays.asList(tableNames)); Collections.reverse(reversedTableNames); Statement stmt = null; try { stmt = connection.getConnection().createStatement(); for (String table : reversedTableNames) { // don't delete sequence table, eclipselink will not add new sequences if (!table.equalsIgnoreCase("SEQUENCE")) { stmt.addBatch("DELETE from " + table); } } stmt.executeBatch(); } finally { if (stmt != null) { try { stmt.close(); } catch (SQLException ignore) { } } } }
public void writeXmlDataSet(OutputStream outputStream, String[] tables) { IDatabaseConnection databaseConnection = null; try { databaseConnection = getIDatabaseConnection(); ITableFilter sequenceFilter = new DatabaseSequenceFilter(databaseConnection); IDataSet dataSet = new FilteredDataSet(sequenceFilter, databaseConnection.createDataSet()); if (tables != null) { dataSet = new FilteredDataSet(tables, dataSet); } XmlDataSet.write(dataSet, outputStream); } catch (IOException e) { throw new RuntimeException(e); } catch (DataSetException e) { throw new RuntimeException(e); } catch (SQLException e) { throw new RuntimeException(e); } finally { if (databaseConnection != null) { try { databaseConnection.close(); } catch (SQLException ignore) { } } } }
/** * Exports a full db saving a dataset for each table. * @param connection dbunit connection * @param directory export directory * @param datasetType dbunit dataset type * @param tableFilter optional table filter * @throws SQLException sql exception * @throws DataSetException dbunit exception * @throws IOException IO exception */ public void exportTablesToDir(IDatabaseConnection connection, File directory, DatasetType datasetType, ITableFilter tableFilter) throws SQLException, DataSetException, IOException { directory.mkdirs(); IDataSet dataset = connection.createDataSet(); if (tableFilter != null) { dataset = new FilteredDataSet(tableFilter, dataset); } String[] tablenames = dataset.getTableNames(); for (String table : tablenames) { File exportFile = new File(directory, table + (datasetType == DatasetType.EXCEL ? ".xls" : ".xml")); log.info("Exporting {}", table); DbUnitUtils.exportDataset(connection, new String[]{table }, exportFile, datasetType); } }
fullDataSet = new FilteredDataSet(tableNames, fullDataSet);