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 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()); }
public static int getTableIndexFor(ITable table, String columnName, Object value) throws Exception { for (int i = 0; i < table.getRowCount(); i++) { if (value.equals(table.getValue(i, columnName))) { return i; } } return -1; }
@Override public Object getValue(int row, String column) throws DataSetException { return table.getValue(row, column); } }
protected void verifyResultRowCount(String queryFolder) throws Exception { printInfo("---------- verify result count in folder: " + queryFolder); List<File> sqlFiles = getFilesFromFolder(new File(queryFolder), ".sql"); for (File sqlFile : sqlFiles) { String queryName = StringUtils.split(sqlFile.getName(), '.')[0]; String sql = getTextFromFile(sqlFile); File expectResultFile = new File(sqlFile.getParent(), sqlFile.getName() + ".expected"); int expectRowCount = Integer.parseInt(Files.readFirstLine(expectResultFile, Charset.defaultCharset())); // execute Kylin printInfo("Query Result from Kylin - " + queryName + " (" + queryFolder + ")"); IDatabaseConnection kylinConn = new DatabaseConnection(cubeConnection); ITable kylinTable = executeQuery(kylinConn, queryName, sql, false); // compare the result Assert.assertEquals(expectRowCount, kylinTable.getRowCount()); // Assertion.assertEquals(expectRowCount, kylinTable.getRowCount()); } }
public static List<TableRow> getTableRowsFor(ITable table, String columnName, Object value) throws Exception { List<TableRow> rows = new ArrayList<TableRow>(); for (int i = 0; i < table.getRowCount(); i++) { if (value.equals(table.getValue(i, columnName))) { rows.add(new TableRow(table, i)); } } return rows; }
@Override public Object getValue(int row, String column) throws DataSetException { return table.getValue(row, column); } }
@Override public int getRowCount() { return table.getRowCount(); }
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; }
private ITable filterTableByPrimaryKey(ITable expectedDataSet, ITable actualDataSet) throws DataSetException { //PrimaryKeyFilteredTableWrapper uses Set.contains to check PK values, so types should be the same in both datasets DataType dataType = actualDataSet.getTableMetaData().getPrimaryKeys()[0].getDataType(); String pkName = actualDataSet.getTableMetaData().getPrimaryKeys()[0].getColumnName(); Set<Object> pkSet = new HashSet<>(); for (int i = 0; i < expectedDataSet.getRowCount(); i++) { pkSet.add(dataType.typeCast(expectedDataSet.getValue(i, pkName))); } return new PrimaryKeyFilteredTableWrapper(actualDataSet, pkSet); }
for (int i = 0; i < expectedTable.getRowCount(); i++) { DataType dataType = compareColumn.getDataType(); Object expectedValue = expectedTable.getValue(i, columnName); Object actualValue = actualTable.getValue(i, columnName);
@Override public Object getValue(int row, String column) throws DataSetException { return table.getValue(row, column); } }
@Override public int getRowCount() { return delegate.getRowCount(); }
@Override public ITableMetaData getTableMetaData() { return delegate.getTableMetaData(); }
/** * Adds the rows of the DbUnit table to the given table. * * @param dbUnitTable The DbUnit table containing the rows, not null * @param table The table to add the rows to, not null * @param primaryKeyColumnNames The names of the pk columns, empty if there are none */ protected void addRows(ITable dbUnitTable, Table table, List<String> primaryKeyColumnNames) throws DataSetException { org.dbunit.dataset.Column[] columns = dbUnitTable.getTableMetaData().getColumns(); int rowCount = dbUnitTable.getRowCount(); for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) { Row row = new Row(); table.addRow(row); for (org.dbunit.dataset.Column dbUnitColumn : columns) { String columnName = dbUnitColumn.getColumnName(); DataType columnType = dbUnitColumn.getDataType(); Object value = dbUnitTable.getValue(rowIndex, columnName); Column column = new Column(columnName, columnType, value); if (primaryKeyColumnNames.contains(columnName)) { row.addPrimaryKeyColumn(column); } else { row.addColumn(column); } } } }
public Object getValue(String columnName) throws Exception { return table.getValue(index, columnName); }
@Override public int getRowCount() { return table.getRowCount(); }
public ITableMetaData getTableMetaData() { return this.target.getTableMetaData(); }
for (int i=0; i<expectedTable.getRowCount(); i++) { for (String orderColumn : orderBy) { if (expectedTable.getValue(i, orderColumn).toString().startsWith("regex:")) { throw new IllegalArgumentException("The orderBy columns cannot use regex matching"); expectedTable.getTableMetaData().getColumns());
public Object getValue(int row, String column) throws DataSetException { Object delta = delegate.getValue(row, column); if (delta instanceof String) { if (StringUtils.isEmpty((String) delta)) { return null; } } return delta; }