How to use org.pentaho.commons.connection.memory

IPentahoMetaData meta = resultSet.getMetaData();
Object[][] columnHeaders = meta.getColumnHeaders();
MemoryMetaData cachedMetaData = new MemoryMetaData( columnHeaders, null );
String[] colTypesAsString;
  colTypesAsString[ i ] = Integer.toString( colTypes[ i ] );
 cachedMetaData.setColumnTypes( colTypesAsString );
cachedResultSet = new MemoryResultSet( cachedMetaData );
Object[] rowObjects = resultSet.next();
while ( rowObjects != null ) {
 cachedResultSet.addRow( rowObjects );
 rowObjects = resultSet.next();

 @Override
 protected IPentahoResultSet getResultSet( final Map parameterProviders ) {
  List headers = node.selectNodes( "static-lov/headers/header" ); //$NON-NLS-1$
  List colHeaders = new LinkedList();
  for ( Iterator it = headers.iterator(); it.hasNext(); ) {
   Element header = (Element) it.next();
   String value = header.getStringValue();
   colHeaders.add( value );
  }

  List rows = node.selectNodes( "static-lov/rows/row" ); //$NON-NLS-1$
  List data = new LinkedList();
  for ( Iterator it = rows.iterator(); it.hasNext(); ) {
   Element rowItem = (Element) it.next();
   List items = rowItem.selectNodes( "item" );
   List row = new LinkedList();
   for ( Iterator itt = items.iterator(); itt.hasNext(); ) {
    Element item = (Element) itt.next();
    String value = item.getStringValue();
    row.add( value );
   }
   data.add( row );
  }

  IPentahoResultSet resultSet = MemoryResultSet.createFromLists( colHeaders, data );

  return resultSet;
 }
}

 Object[] pentahoRow = new Object[memResults.getColumnCount()];
 for ( int columnNo = 0; columnNo < memResults.getColumnCount(); columnNo++ ) {
  ValueMetaInterface valueMeta = rowMeta.getValueMeta( columnNo );
 memResults.addRow( pentahoRow );
} catch ( KettleValueException e ) {
 throw new KettleStepException( e );

MemoryResultSet set = new MemoryResultSet();
if ( ( min == -1 ) && ( max == -1 ) ) {
 set.addRow( new Object[] { new Double( val ) } );
} else {
 set.addRow( new Object[] { new Double( val ), new Double( min ), new Double( max ) } );

private boolean registerAsStepListener( Trans trans, Query query, Map fieldMap ) throws Exception {
 boolean success = false;
 if ( trans != null ) {
  List<StepMetaDataCombi> stepList = trans.getSteps();
  // assume the last step
  for ( StepMetaDataCombi step : stepList ) {
   if ( !"Unique rows".equals( step.stepname ) ) { //$NON-NLS-1$
    continue;
   }
   if ( logger.isDebugEnabled() ) {
    logger.debug( "STEP NAME: " + step.stepname ); //$NON-NLS-1$
   }
   RowMetaInterface row = trans.getTransMeta().getStepFields( step.stepMeta ); // step.stepname?
   // create the metadata that the Pentaho result sets need
   String[] fieldNames = row.getFieldNames();
   String[][] columns = new String[1][fieldNames.length];
   for ( int column = 0; column < fieldNames.length; column++ ) {
    columns[0][column] = fieldNames[column];
   }
   // build valid metadata
   QueryModelMetaData metadata = new QueryModelMetaData( fieldMap, columns, null, query.getSelections() );
   results = new MemoryResultSet( metadata );
   errorResults = new MemoryResultSet( metadata );
   // add ourself as a row listener
   step.step.addRowListener( this );
   success = true;
  }
 }
 return success;
}

} else if ( "result-set".equals( dataType ) ) { //$NON-NLS-1$
 return ( MemoryResultSet.createFromActionSequenceInputsNode( parameterNode ) );
} else { // Assume String
 return ( rootNode.getText() );

} else if ( ipmd instanceof MemoryMetaData ) {
 MemoryMetaData mmd = (MemoryMetaData) ipmd;
 String[] columnTypesAsString = mmd.getColumnTypes();
 columnTypes = new int[ columnTypesAsString.length ];
 for ( int i = 0; i < columnTypesAsString.length; i++ ) {

public void testResultSet() {
 MemoryResultSet data = new MemoryResultSet();
 SimpleParameterProvider params = new SimpleParameterProvider();
 params.setParameter( "data", data );
 assertTrue( params.hasParameter( "data" ) );
 assertEquals( "param value is wrong", data, params.getListParameter( "data" ) );
}