protected static void printResult(ITable resultTable) throws DataSetException { StringBuilder sb = new StringBuilder(); int columnCount = resultTable.getTableMetaData().getColumns().length; String[] columns = new String[columnCount]; for (int i = 0; i < columnCount; i++) { sb.append(resultTable.getTableMetaData().getColumns()[i].getColumnName()); sb.append("-"); sb.append(resultTable.getTableMetaData().getColumns()[i].getDataType()); sb.append("\t"); columns[i] = resultTable.getTableMetaData().getColumns()[i].getColumnName(); } sb.append("\n"); for (int i = 0; i < resultTable.getRowCount(); i++) { for (int j = 0; j < columns.length; j++) { sb.append(resultTable.getValue(i, columns[j])); sb.append("\t"); } sb.append("\n"); } System.out.println(sb.toString()); }
protected ITable executeDynamicQuery(IDatabaseConnection dbConn, String queryName, String sql, List<String> parameters, boolean needSort) throws Exception { // change join type to match current setting sql = changeJoinType(sql, joinType); PreparedStatement prepStat = dbConn.getConnection().prepareStatement(sql); for (int j = 1; j <= parameters.size(); ++j) { prepStat.setString(j, parameters.get(j - 1).trim()); } ITable queryTable = dbConn.createTable(resultTableName + queryName, prepStat); String[] columnNames = new String[queryTable.getTableMetaData().getColumns().length]; for (int i = 0; i < columnNames.length; i++) { columnNames[i] = queryTable.getTableMetaData().getColumns()[i].getColumnName(); } if (needSort) { queryTable = new SortedTable(queryTable, columnNames); } // printResult(queryTable); return queryTable; }
protected ITable executeQuery(IDatabaseConnection dbConn, String queryName, String sql, boolean needSort) throws Exception { // change join type to match current setting sql = changeJoinType(sql, joinType); ITable queryTable = dbConn.createQueryTable(resultTableName + queryName, sql); String[] columnNames = new String[queryTable.getTableMetaData().getColumns().length]; for (int i = 0; i < columnNames.length; i++) { columnNames[i] = queryTable.getTableMetaData().getColumns()[i].getColumnName(); } if (needSort) { queryTable = new SortedTable(queryTable, columnNames); } // printResult(queryTable); return queryTable; }
/** * merges the existing columns with the potentially new ones. * * @param columnsToMerge List of extra columns found, which need to be merge back into the metadata. * @return ITableMetaData The merged metadata object containing the new columns * @throws DataSetException */ private ITableMetaData mergeTableMetaData(List<Column> columnsToMerge, ITableMetaData originalMetaData) throws DataSetException { Column[] columns = new Column[originalMetaData.getColumns().length + columnsToMerge.size()]; System.arraycopy(originalMetaData.getColumns(), 0, columns, 0, originalMetaData.getColumns().length); for (int i = 0; i < columnsToMerge.size(); i++) { Column column = columnsToMerge.get(i); columns[columns.length - columnsToMerge.size() + i] = column; } return new DefaultTableMetaData(originalMetaData.getTableName(), columns); }
private Object[] extractValues(DataRowBuilder row, ITableMetaData metaData) throws DataSetException { return row.values(metaData.getColumns()); }
public TableMetaDataBuilder with(ITableMetaData metaData) throws DataSetException { return with(metaData.getColumns()); }
public static List<String> extractColumnsNotSpecifiedInExpectedDataSet(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final Set<String> allColumns = new HashSet<String>(extractColumnNames(currentTableState.getTableMetaData().getColumns())); final Set<String> expectedColumnNames = new HashSet<String>(extractColumnNames(expectedTableState.getTableMetaData().getColumns())); return extractNonExistingColumns(allColumns, expectedColumnNames); }
public static List<String> extractColumnsNotSpecifiedInExpectedDataSet(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final Set<String> allColumns = new HashSet<String>(extractColumnNames(currentTableState.getTableMetaData().getColumns())); final Set<String> expectedColumnNames = new HashSet<String>(extractColumnNames(expectedTableState.getTableMetaData().getColumns())); return extractNonExistingColumns(allColumns, expectedColumnNames); }
public static List<String> extractColumnsNotSpecifiedInExpectedDataSet(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final Set<String> allColumns = new HashSet<String>(extractColumnNames(currentTableState.getTableMetaData().getColumns())); final Set<String> expectedColumnNames = new HashSet<String>(extractColumnNames(expectedTableState.getTableMetaData().getColumns())); return extractNonExistingColumns(allColumns, expectedColumnNames); }
public static List<String> extractColumnsNotSpecifiedInExpectedDataSet(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final Set<String> allColumns = new HashSet<String>(extractColumnNames(currentTableState.getTableMetaData().getColumns())); final Set<String> expectedColumnNames = new HashSet<String>(extractColumnNames(expectedTableState.getTableMetaData().getColumns())); return extractNonExistingColumns(allColumns, expectedColumnNames); }
private List<String> additionalColumnsForSorting(final ITable expectedTableState, final ITable currentTableState) { final List<String> columnsForSorting = new ArrayList<String>(); try { final Set<String> allColumns = new HashSet<String>(extractColumnNames(expectedTableState.getTableMetaData() .getColumns())); final Set<String> columnsToIgnore = new HashSet<String>(extractColumnsToBeIgnored(expectedTableState, currentTableState)); for (String column : allColumns) { if (!columnsToIgnore.contains(column)) { columnsForSorting.add(column); } } } catch (DataSetException e) { throw new DBUnitDataSetHandlingException("Unable to resolve columns", e); } return columnsForSorting; }
private List<String> additionalColumnsForSorting(final ITable expectedTableState, final ITable currentTableState) { final List<String> columnsForSorting = new ArrayList<String>(); try { final Set<String> allColumns = new HashSet<String>(DataSetUtils.extractColumnNames(expectedTableState.getTableMetaData() .getColumns())); final Set<String> columnsToIgnore = new HashSet<String>(extractColumnsToBeIgnored(expectedTableState, currentTableState)); for (String column : allColumns) { if (!columnsToIgnore.contains(column)) { columnsForSorting.add(column); } } } catch (DataSetException e) { throw new DBUnitDataSetHandlingException("Unable to resolve columns", e); } return columnsForSorting; }
private List<String> extractColumnsToBeIgnored(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final List<String> columnsToIgnore = extractColumnsNotSpecifiedInExpectedDataSet(expectedTableState, currentTableState); final String tableName = expectedTableState.getTableMetaData().getTableName(); final List<String> tableColumns = toExclude.columnsPerTable.get(tableName); columnsToIgnore.addAll(toExclude.global); if (tableColumns != null) { columnsToIgnore.addAll(tableColumns); } final List<String> nonExistingColumns = extractNonExistingColumns(columnsToIgnore, extractColumnNames(currentTableState.getTableMetaData().getColumns())); if (!nonExistingColumns.isEmpty()) { log.warning("Columns which are specified to be filtered out " + Arrays.toString(nonExistingColumns.toArray()) + " are not existing in the table " + tableName); } return columnsToIgnore; }
private List<String> extractColumnsToBeIgnored(final ITable expectedTableState, final ITable currentTableState) throws DataSetException { final List<String> columnsToIgnore = DataSetUtils.extractColumnsNotSpecifiedInExpectedDataSet(expectedTableState, currentTableState); final String tableName = expectedTableState.getTableMetaData().getTableName(); final List<String> tableColumns = toExclude.columnsPerTable.get(tableName); columnsToIgnore.addAll(toExclude.global); if (tableColumns != null) { columnsToIgnore.addAll(tableColumns); } final List<String> nonExistingColumns = DataSetUtils.extractNonExistingColumns(columnsToIgnore, DataSetUtils.extractColumnNames(currentTableState.getTableMetaData().getColumns())); if (!nonExistingColumns.isEmpty()) { log.warning("Columns which are specified to be filtered out " + Arrays.toString(nonExistingColumns.toArray()) + " are not existing in the table " + tableName); } return columnsToIgnore; }
@Override public void assertEquals(ITable expectedSortedTable, ITable actualSortedTable, List<IColumnFilter> columnFilters) throws DatabaseUnitException { Column[] expectedColumns = expectedSortedTable.getTableMetaData().getColumns(); expectedSortedTable = new SortedTable(expectedSortedTable, expectedColumns); actualSortedTable = new SortedTable(actualSortedTable, expectedColumns); super.assertEquals(expectedSortedTable, actualSortedTable, columnFilters); }
@Override public void assertEquals(ITable expectedSortedTable, ITable actualSortedTable, List<IColumnFilter> columnFilters) throws DatabaseUnitException { Column[] expectedColumns = expectedSortedTable.getTableMetaData().getColumns(); expectedSortedTable = new SortedTable(expectedSortedTable, expectedColumns); actualSortedTable = new SortedTable(actualSortedTable, expectedColumns); super.assertEquals(expectedSortedTable, actualSortedTable, columnFilters); }
public ITableMetaData getTableMetaData() { ITableMetaData meta = delegate.getTableMetaData(); try { return new DefaultTableMetaData(tableName, meta.getColumns(), meta.getPrimaryKeys()); } catch (DataSetException e) { throw new QtafException("Don't get the meta info from " + meta, e); } }
@Override public void produce() throws DataSetException { consumer.startDataSet(); Map<String, List<Map<String, String>>> dataset = loadDataSet(); final List<Table> tables = createTables(dataset); for (Table table : tables) { ITableMetaData tableMetaData = createTableMetaData(table); consumer.startTable(tableMetaData); for (Row row : table.getRows()) { List<String> values = new ArrayList<String>(); for (Column column : tableMetaData.getColumns()) { values.add(row.valueOf(column.getColumnName())); } consumer.row(values.toArray()); } consumer.endTable(); } consumer.endDataSet(); }
private ITableMetaData updateTableMetaData(DataRowBuilder row) throws DataSetException { TableMetaDataBuilder builder = metaDataBuilderFor(row.tableName()); int previousNumberOfColumns = builder.numberOfColumns(); ITableMetaData metaData = builder.with(row.toMetaData()).build(); int newNumberOfColumns = metaData.getColumns().length; boolean addedNewColumn = newNumberOfColumns > previousNumberOfColumns; handleTable(metaData, addedNewColumn); return metaData; }
private void compare(IDataSet actualDataSet, IDataSet expectedDataSet) throws Throwable { String[] expectedTableNames = expectedDataSet.getTableNames(); if (expectedTableNames.length == 0) return; String[] actualTableNames = actualDataSet.getTableNames(); compareTableSize(actualTableNames, expectedTableNames); for (int i = 0; i < expectedTableNames.length; i++) { String tableName = expectedTableNames[i]; ITable expectedTable = expectedDataSet.getTable(tableName); String[] ignoreColumns = getIgnoreColumns(tableName); if ((ignoreColumns != null) && (ignoreColumns.length != 0)) { expectedTable = DefaultColumnFilter.excludedColumnsTable(expectedTable, ignoreColumns); } ITable actualTable = actualDataSet.getTable(tableName); Column[] expectedColumns = expectedTable.getTableMetaData().getColumns(); actualTable = DefaultColumnFilter.includedColumnsTable(actualTable, expectedColumns); Assertion.assertEquals(expectedTable, actualTable); } }