SortedTable.java
/*
*
* The DbUnit Database Testing Framework
* Copyright (C)2002-2004, DbUnit.org
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
package org.dbunit.dataset;
import java.util.Arrays;
import java.util.Comparator;
import org.dbunit.DatabaseUnitRuntimeException;
import org.dbunit.dataset.datatype.DataType;
import org.dbunit.dataset.datatype.TypeCastException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* This is a ITable decorator that provide a sorted view of the decorated table.
* This implementation does not keep a separate copy of the decorated table
* data.
*
* @author Manuel Laflamme
* @author Last changed by: $Author$
* @version $Revision$ $Date: 2009-05-01 02:56:07 -0500 (Fri, 01 May 2009) $
* @since Feb 19, 2003
*/
public class SortedTable extends AbstractTable
{
private static final Logger logger =
LoggerFactory.getLogger(SortedTable.class);
private final ITable _table;
private final Column[] _columns;
private Integer[] _indexes;
/**
* The row comparator which is used for sorting
*/
private Comparator rowComparator;
/**
* Sort the decorated table by specified columns order. Resulting table uses
* column definitions from the specified table's metadata, not the specified
* columns.
*
* @param table
* decorated table
* @param columns
* columns to be used for sorting
* @throws DataSetException
*/
public SortedTable(final ITable table, final Column[] columns)
throws DataSetException
{
this(table, columns, false);
}
/**
* Sort the decorated table by specified columns order. Resulting table uses
* column definitions from the specified columns, not the ones from the
* specified table's metadata.
*
* @param table
* decorated table
* @param columns
* columns to be used for sorting
* @param useSpecifiedColumns
* true to use the column definitions specified by the columns
* parameter, false to use the column definitions from the
* specified table's metadata.
* @throws DataSetException
*/
public SortedTable(final ITable table, final Column[] columns,
final boolean useSpecifiedColumns) throws DataSetException
{
_table = table;
final Column[] validatedColumns = validateAndResolveColumns(columns);
if (useSpecifiedColumns)
{
_columns = columns;
} else
{
_columns = validatedColumns;
}
initialize();
}
/**
* Sort the decorated table by specified columns order. Resulting table uses
* column definitions from the specified table's metadata.
*
* @param table
* decorated table
* @param columnNames
* names of columns to be used for sorting
* @throws DataSetException
*/
public SortedTable(final ITable table, final String[] columnNames)
throws DataSetException
{
_table = table;
_columns = validateAndResolveColumns(columnNames);
initialize();
}
/**
* Sort the decorated table by specified metadata columns order. All
* metadata columns will be used.
*
* @param table
* The decorated table
* @param metaData
* The metadata used to retrieve all columns which in turn are
* used for sorting the table
* @throws DataSetException
*/
public SortedTable(final ITable table, final ITableMetaData metaData)
throws DataSetException
{
this(table, metaData.getColumns());
}
/**
* Sort the decorated table by its own columns order which is defined by
* {@link ITable#getTableMetaData()}. All table columns will be used.
*
* @param table
* The decorated table
* @throws DataSetException
*/
public SortedTable(final ITable table) throws DataSetException
{
this(table, table.getTableMetaData());
}
/**
* Verifies that all given columns really exist in the current table and
* returns the physical {@link Column} objects from the table.
*
* @param columns
* @return
* @throws DataSetException
*/
private Column[] validateAndResolveColumns(final Column[] columns)
throws DataSetException
{
final ITableMetaData tableMetaData = _table.getTableMetaData();
final Column[] resultColumns =
Columns.findColumnsByName(columns, tableMetaData);
return resultColumns;
}
/**
* Verifies that all given columns really exist in the current table and
* returns the physical {@link Column} objects from the table.
*
* @param columnNames
* @return
* @throws DataSetException
*/
private Column[] validateAndResolveColumns(final String[] columnNames)
throws DataSetException
{
final ITableMetaData tableMetaData = _table.getTableMetaData();
final Column[] resultColumns =
Columns.findColumnsByName(columnNames, tableMetaData);
return resultColumns;
}
private void initialize()
{
logger.debug("initialize() - start");
// The default comparator is the one that sorts by string - for
// backwards compatibility
this.rowComparator =
new RowComparatorByString(this._table, this._columns);
}
/**
* @return The columns that are used for sorting the table
*/
public Column[] getSortColumns()
{
return this._columns;
}
private int getOriginalRowIndex(final int row) throws DataSetException
{
if (logger.isDebugEnabled())
{
logger.debug("getOriginalRowIndex(row={}) - start",
Integer.toString(row));
}
if (_indexes == null)
{
final Integer[] indexes = new Integer[getRowCount()];
for (int i = 0; i < indexes.length; i++)
{
indexes[i] = i;
}
try
{
Arrays.sort(indexes, rowComparator);
} catch (final DatabaseUnitRuntimeException e)
{
throw (DataSetException) e.getCause();
}
_indexes = indexes;
}
return _indexes[row].intValue();
}
/**
* Whether or not the comparable interface should be used of the compared
* columns instead of the plain strings Default value is <code>false</code>
* for backwards compatibility Set whether or not to use the Comparable
* implementation of the corresponding column DataType for comparing values
* or not. Default value is <code>false</code> which means that the old
* string comparison is used. <br>
*
* @param useComparable
* @since 2.3.0
*/
public void setUseComparable(final boolean useComparable)
{
if (logger.isDebugEnabled())
{
logger.debug("setUseComparable(useComparable={}) - start",
Boolean.valueOf(useComparable));
}
if (useComparable)
{
setRowComparator(new RowComparator(this._table, this._columns));
} else
{
setRowComparator(
new RowComparatorByString(this._table, this._columns));
}
}
/**
* Sets the comparator to be used for sorting the table rows.
*
* @param comparator
* that sorts the table rows
* @since 2.4.2
*/
public void setRowComparator(final Comparator comparator)
{
if (logger.isDebugEnabled())
{
logger.debug("setRowComparator(comparator={}) - start", comparator);
}
if (_indexes != null)
{
// TODO this is an ugly design to avoid increasing the number of
// constructors from 4 to 8. To be discussed how to implement it the
// best way.
throw new IllegalStateException(
"Do not use this method after the table has been used (i.e. #getValue() has been called). "
+ "Please invoke this method immediately after the intialization of this object.");
}
this.rowComparator = comparator;
}
// //////////////////////////////////////////////////////////////////////////
// ITable interface
@Override
public ITableMetaData getTableMetaData()
{
logger.debug("getTableMetaData() - start");
return _table.getTableMetaData();
}
@Override
public int getRowCount()
{
logger.debug("getRowCount() - start");
return _table.getRowCount();
}
@Override
public Object getValue(final int row, final String columnName)
throws DataSetException
{
if (logger.isDebugEnabled())
{
logger.debug("getValue(row={}, columnName={}) - start",
Integer.toString(row), columnName);
}
assertValidRowIndex(row);
return _table.getValue(getOriginalRowIndex(row), columnName);
}
// //////////////////////////////////////////////////////////////////////////
// Comparator interface
/**
* Abstract class for sorting the table rows of a given table in a specific
* order
*/
public static abstract class AbstractRowComparator implements Comparator
{
/**
* Logger for this class
*/
private final Logger logger =
LoggerFactory.getLogger(AbstractRowComparator.class);
private final ITable _table;
private final Column[] _sortColumns;
/**
* @param table
* The wrapped table to be sorted
* @param sortColumns
* The columns to be used for sorting in the given order
*/
public AbstractRowComparator(final ITable table,
final Column[] sortColumns)
{
this._table = table;
this._sortColumns = sortColumns;
}
@Override
public int compare(final Object o1, final Object o2)
{
logger.debug("compare(o1={}, o2={}) - start", o1, o2);
final Integer i1 = (Integer) o1;
final Integer i2 = (Integer) o2;
try
{
for (int i = 0; i < _sortColumns.length; i++)
{
final String columnName = _sortColumns[i].getColumnName();
final Object value1 =
_table.getValue(i1.intValue(), columnName);
final Object value2 =
_table.getValue(i2.intValue(), columnName);
if (value1 == null && value2 == null)
{
continue;
}
if (value1 == null && value2 != null)
{
return -1;
}
if (value1 != null && value2 == null)
{
return 1;
}
// Compare the two values with each other for sorting
final int result = compare(_sortColumns[i], value1, value2);
if (result != 0)
{
return result;
}
}
} catch (final DataSetException e)
{
throw new DatabaseUnitRuntimeException(e);
}
return 0;
}
/**
* @param column
* The column to be compared
* @param value1
* The first value of the given column
* @param value2
* The second value of the given column
* @return 0 if both values are considered equal.
* @throws TypeCastException
*/
protected abstract int compare(Column column, Object value1,
Object value2) throws TypeCastException;
}
/**
* Compares the rows with each other in order to sort them in the correct
* order using the data type and the Comparable implementation the current
* column has.
*/
protected static class RowComparator extends AbstractRowComparator
{
/**
* Logger for this class
*/
private final Logger logger =
LoggerFactory.getLogger(RowComparator.class);
public RowComparator(final ITable table, final Column[] sortColumns)
{
super(table, sortColumns);
}
@Override
protected int compare(final Column column, final Object value1,
final Object value2) throws TypeCastException
{
if (logger.isDebugEnabled())
{
logger.debug("compare(column={}, value1={}, value2={}) - start",
new Object[] {column, value1, value2});
}
final DataType dataType = column.getDataType();
final int result = dataType.compare(value1, value2);
return result;
}
}
/**
* Compares the rows with each other in order to sort them in the correct
* order using the string value of both values for the comparison.
*/
protected static class RowComparatorByString extends AbstractRowComparator
{
/**
* Logger for this class
*/
private final Logger logger =
LoggerFactory.getLogger(RowComparatorByString.class);
public RowComparatorByString(final ITable table,
final Column[] sortColumns)
{
super(table, sortColumns);
}
@Override
protected int compare(final Column column, final Object value1,
final Object value2) throws TypeCastException
{
if (logger.isDebugEnabled())
{
logger.debug("compare(column={}, value1={}, value2={}) - start",
new Object[] {column, value1, value2});
}
// Default behavior since ever
final String stringValue1 = DataType.asString(value1);
final String stringValue2 = DataType.asString(value2);
final int result = stringValue1.compareTo(stringValue2);
return result;
}
}
/**
* {@inheritDoc}
*/
@Override
public String toString()
{
final StringBuilder sb = new StringBuilder(2000);
sb.append(getClass().getName()).append("[");
sb.append("_columns=[").append(Arrays.toString(_columns)).append("], ");
sb.append("_indexes=[").append(_indexes).append("], ");
sb.append("_table=[").append(_table).append("]");
sb.append("]");
return sb.toString();
}
}