protected int getTotalRows( List<RowSet> rowSets ) { int total = 0; for ( RowSet rowSet : rowSets ) { total += rowSet.size(); } return total; }
@Override public int rowsetOutputSize() { int size = 0; outputRowSetsLock.readLock().lock(); try { for ( RowSet outputRowSet : outputRowSets ) { size += outputRowSet.size(); } } finally { outputRowSetsLock.readLock().unlock(); } return size; }
@Override public int rowsetInputSize() { int size = 0; inputRowSetsLock.readLock().lock(); try { for ( RowSet inputRowSet : inputRowSets ) { size += inputRowSet.size(); } } finally { inputRowSetsLock.readLock().unlock(); } return size; }
@Override public boolean canProcessOneRow() { inputRowSetsLock.readLock().lock(); try { switch ( inputRowSets.size() ) { case 0: return false; case 1: RowSet set = inputRowSets.get( 0 ); if ( set.isDone() ) { return false; } return set.size() > 0; default: boolean allDone = true; for ( RowSet rowSet : inputRowSets ) { if ( !rowSet.isDone() ) { allDone = false; } if ( rowSet.size() > 0 ) { return true; } } return !allDone; } } finally { inputRowSetsLock.readLock().unlock(); } }
RowSet inputEmpty = null; for ( RowSet rowSet : getInputRowSets() ) { if ( rowSet.size() == transMeta.getSizeRowset() ) { inputFull = rowSet; } else if ( rowSet.size() == 0 ) { inputEmpty = rowSet; int totalSize = combiInputRowSets.size() * transMeta.getSizeRowset(); for ( RowSet rowSet : combiInputRowSets ) { inputSize += rowSet.size(); RowSet outputEmpty = null; for ( RowSet rowSet : combiOutputRowSets ) { if ( rowSet.size() == transMeta.getSizeRowset() ) { outputFull = rowSet; } else if ( rowSet.size() == 0 ) { outputEmpty = rowSet;
private boolean isRowSetContainsValue( RowSet rowSet, Object[] allowed, Object[] illegal ) { boolean ok = true; Set<Object> yes = new HashSet<Object>(); yes.addAll( Arrays.asList( allowed ) ); Set<Object> no = new HashSet<Object>(); no.addAll( Arrays.asList( illegal ) ); for ( int i = 0; i < rowSet.size(); i++ ) { Object[] row = rowSet.getRow(); Object val = row[0]; ok = yes.contains( val ) && !no.contains( val ); if ( !ok ) { // this is not ok now return false; } } return ok; }
@Override public int rowsetInputSize() { int size = 0; for ( MappingInput input : getData().getMappingTrans().findMappingInput() ) { for ( RowSet rowSet : input.getInputRowSets() ) { size += rowSet.size(); } } return size; }
@Override public int rowsetOutputSize() { int size = 0; for ( MappingOutput output : getData().getMappingTrans().findMappingOutput() ) { for ( RowSet rowSet : output.getOutputRowSets() ) { size += rowSet.size(); } } return size; }
@Override public void batchComplete() throws KettleException { RowSet rowSet = getFirstInputRowSet(); int repeats = 0; for ( int i = 0; i < data.cache.length; i++ ) { if ( repeats == 0 ) { repeats = 1; } if ( data.cache[i] != null ) { repeats *= data.cache[i].size(); } } while ( rowSet.size() > 0 && !isStopped() ) { processRow( meta, data ); } // The last row needs to be written too to the account of the number of input rows. // for ( int i = 0; i < repeats; i++ ) { processRow( meta, data ); } } }
&& !rowSet.isDone() && rowSet.size() <= lowerBufferBoundary && !isStopped() ) { try { Thread.sleep( 0, 1 );
&& !inputRowSet.isDone() && inputRowSet.size() <= lowerBufferBoundary && !isStopped() ) { try { Thread.sleep( 0, 1 );
private boolean verifyOutput( Object[][] expectedRows, RowSet outputRowSet ) throws KettleValueException { if ( expectedRows.length == outputRowSet.size() ) { for ( Object[] expectedRow : expectedRows ) { Object[] row = outputRowSet.getRow(); if ( expectedRow.length == outputRowSet.getRowMeta().size() ) { for ( int j = 0; j < expectedRow.length; j++ ) { if ( !expectedRow[j].equals( outputRowSet.getRowMeta().getString( row, j ) ) ) { return false; } } return true; } } } return false; }
@Test public void processRow_NullsArePutIntoDefaultWhenNotSpecified() throws Exception { SwitchCaseCustom step = new SwitchCaseCustom( mockHelper ); step.meta.loadXML( loadStepXmlMetadata( "SwitchCaseTest_PDI-12671.xml" ), Collections.<DatabaseMeta>emptyList(), mock( IMetaStore.class ) ); List<RowSet> outputRowSets = new LinkedList<RowSet>(); for ( SwitchCaseTarget item : step.meta.getCaseTargets() ) { StepMetaInterface smInt = new DummyTransMeta(); item.caseTargetStep = new StepMeta( item.caseTargetStepname, smInt ); RowSet rw = new QueueRowSet(); step.map.put( item.caseTargetStepname, rw ); outputRowSets.add( rw ); } // create a default step StepMetaInterface smInt = new DummyTransMeta(); StepMeta stepMeta = new StepMeta( step.meta.getDefaultTargetStepname(), smInt ); step.meta.setDefaultTargetStep( stepMeta ); RowSet defaultRowSet = new QueueRowSet(); step.map.put( step.meta.getDefaultTargetStepname(), defaultRowSet ); step.input.add( new Object[] { null } ); step.processRow(); assertEquals( 1, defaultRowSet.size() ); for ( RowSet rowSet : outputRowSets ) { assertEquals( 0, rowSet.size() ); } assertNull( defaultRowSet.getRow()[0] ); }
assertEquals( "First row set collects 2 rows", 2, rowSetOne.size() ); assertEquals( "Second row set collects 2 rows", 2, rowSetTwo.size() ); assertEquals( "First null row set collects 5 rows", 6, rowSetNullOne.size() ); assertEquals( "Second null row set collects 5 rows", 6, rowSetNullTwo.size() ); assertEquals( "Default row set collects the rest of rows", 8, def.size() );
log.logDebug( "# of input buffers: " + mappingInputRowSets.size() ); if ( mappingInputRowSets.size() > 0 ) { log.logDebug( "Input buffer 0 size: " + mappingInputRowSets.get( 0 ).size() );