private Object convertDataToTargetValueMeta( int i, Object formulaResult ) throws KettleException { if ( formulaResult == null ) { return formulaResult; } ValueMetaInterface target = data.outputRowMeta.getValueMeta( i ); ValueMetaInterface actual = ValueMetaFactory.guessValueMetaInterface( formulaResult ); Object value = target.convertData( actual, formulaResult ); return value; }
when( data.valueMeta.convertData( any( ValueMetaInterface.class ), any() ) ).thenAnswer( new Answer<Object>() { @Override
public static Object sum( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { if ( dataA == null && dataB == null ) { return null; } if ( dataA == null && dataB != null ) { Object value = metaA.convertData( metaB, dataB ); metaA.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL ); return value; } if ( dataA != null && dataB == null ) { return dataA; } return plus( metaA, dataA, metaB, dataB ); }
protected void convertData( RowMetaInterface source, Object[] sourceData, RowMetaInterface target ) throws KettleException { int targetIndex = getInputRowMeta().size(); for ( int i = 0; i < data.fieldIndexes.size(); i++ ) { int fieldIndex = data.fieldIndexes.get( i ); ValueMetaInterface sourceValueMeta = source.getValueMeta( fieldIndex ); ValueMetaInterface targetValueMeta = target.getValueMeta( targetIndex ); sourceData[targetIndex] = targetValueMeta.convertData( sourceValueMeta, sourceData[targetIndex] ); targetIndex++; } }
public void replaceNull( Object[] row, ValueMetaInterface sourceValueMeta, int i, String realReplaceByValue, String realconversionMask, boolean setEmptystring ) throws Exception { if ( setEmptystring ) { row[i] = StringUtil.EMPTY_STRING; } else { // DO CONVERSION OF THE DEFAULT VALUE ... // Entered by user ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta( i ); if ( !Utils.isEmpty( realconversionMask ) ) { sourceValueMeta.setConversionMask( realconversionMask ); } row[i] = targetValueMeta.convertData( sourceValueMeta, realReplaceByValue ); } }
void doConversions( Object[] outputRowData, int i, String value ) throws KettleValueException { ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta( i ); ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta( i ); if ( ValueMetaInterface.TYPE_BINARY != targetValueMeta.getType() ) { outputRowData[i] = targetValueMeta.convertData( sourceValueMeta, value ); } else { // binary type of salesforce requires specific conversion if ( value != null ) { outputRowData[ i ] = Base64.decode( value ); } else { outputRowData[ i ] = null; } } }
private Object convert( Object obj, AccessInputField field, int index ) throws Exception { // Get column Column c = data.t.getColumn( field.getColumn() ); // Find out field type ValueMetaAndData sourceValueMetaAndData = AccessInputMeta.getValueMetaAndData( c, field.getName(), obj ); // DO CONVERSIONS... // ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta( data.totalpreviousfields + index ); return targetValueMeta.convertData( sourceValueMetaAndData.getValueMeta(), sourceValueMetaAndData .getValueData() ); } }
@Test public void testSumConvertingStorageTypeToNormal() throws Exception { ValueMetaInterface metaA = mock( ValueMetaInteger.class ); metaA.setStorageType( ValueMetaInterface.STORAGE_TYPE_BINARY_STRING ); ValueMetaInterface metaB = new ValueMetaInteger(); metaB.setStorageType( ValueMetaInterface.STORAGE_TYPE_BINARY_STRING ); Object valueB = "2"; when( metaA.convertData( metaB, valueB ) ).thenAnswer( new Answer<Long>() { @Override public Long answer( InvocationOnMock invocation ) throws Throwable { return new Long( 2 ); } } ); Object returnValue = ValueDataUtil.sum( metaA, null, metaB, valueB ); verify( metaA ).convertData( metaB, valueB ); assertEquals( 2L, returnValue ); assertEquals( metaA.getStorageType(), ValueMetaInterface.STORAGE_TYPE_NORMAL ); }
return targetValueMeta.convertData( sourceValueMeta, retval );
data.outputRowMeta.getValueMeta( outputIndex ).convertData( new ValueMetaInteger( "num_values_aggregation" ), resultValue );
private void initNullIf() throws KettleException { final String[] returnFields = meta.getReturnValueField(); data.nullif = new Object[ returnFields.length ]; for ( int i = 0; i < returnFields.length; i++ ) { if ( !Utils.isEmpty( meta.getReturnValueDefault()[ i ] ) ) { ValueMetaInterface stringMeta = new ValueMetaString( "string" ); ValueMetaInterface returnMeta = data.outputRowMeta.getValueMeta( i + getInputRowMeta().size() ); data.nullif[ i ] = returnMeta.convertData( stringMeta, meta.getReturnValueDefault()[ i ] ); } else { data.nullif[ i ] = null; } } }
ValueMetaInterface binaryValueMeta = new ValueMetaBinary( "binary_data" ); return ( !Utils.isEmpty( string_value ) ? binaryValueMeta.convertData( parameterValueMeta, string_value ) : null ); } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_BOOLEAN ) { if ( !Utils.isEmpty( string_value ) ) {
private void updateField( Object[] r ) throws Exception { // Loop through fields for ( int i = 0; i < data.getFieldnr(); i++ ) { // DO CONVERSION OF THE DEFAULT VALUE ... // Entered by user ValueMetaInterface targetValueMeta = data.getOutputRowMeta().getValueMeta( data.getFieldnrs()[i] ); ValueMetaInterface sourceValueMeta = data.getConvertRowMeta().getValueMeta( data.getFieldnrs()[i] ); if ( !Utils.isEmpty( meta.getField( i ).getReplaceMask() ) ) { sourceValueMeta.setConversionMask( meta.getField( i ).getReplaceMask() ); } sourceValueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL ); r[data.getFieldnrs()[i]] = targetValueMeta.convertData( sourceValueMeta, data.getRealReplaceByValues()[i] ); targetValueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL ); } }
Object lookupData = data.valueMeta.convertData( data.inputValueMeta, r[data.fieldIndex] );
outputRow[ i ] = data.outputRowMeta.getValueMeta( i ).convertData( data.conversionMeta[ i ], dataObject );
valueData = valueMeta.convertData( originMeta, valueData );
@Override public void readRep( Repository rep, ObjectId id_step, List<DatabaseMeta> databases, Map<String, Counter> counters ) throws KettleException { try { String name = rep.getStepAttributeString( id_step, 0, "value_name" ); String typedesc = rep.getStepAttributeString( id_step, 0, "value_type" ); String text = rep.getStepAttributeString( id_step, 0, "value_text" ); boolean isnull = rep.getStepAttributeBoolean( id_step, 0, "value_null" ); int length = (int) rep.getStepAttributeInteger( id_step, 0, "value_length" ); int precision = (int) rep.getStepAttributeInteger( id_step, 0, "value_precision" ); int type = ValueMetaFactory.getIdForValueMeta( typedesc ); value = new ValueMetaAndData( new ValueMeta( name, type ), null ); value.getValueMeta().setLength( length ); value.getValueMeta().setPrecision( precision ); if ( isnull ) { value.setValueData( null ); } else { ValueMetaInterface stringMeta = new ValueMetaString( name ); if ( type != ValueMetaInterface.TYPE_STRING ) { text = Const.trim( text ); } value.setValueData( value.getValueMeta().convertData( stringMeta, text ) ); } } catch ( KettleDatabaseException dbe ) { throw new KettleException( "error reading step with id_step=" + id_step + " from the repository", dbe ); } catch ( Exception e ) { throw new KettleException( "Unexpected error reading step with id_step=" + id_step + " from the repository", e ); } }
vms.setConversionMask( data.nullValueMeta[i].getConversionMask() ); data.nullValue[i] = data.nullValueMeta[i].convertData( vms, meta.getFields()[i].getFieldValue() );
data.extraData[i] = targetMeta.convertData( sourceMeta, newValue );
return -meta2.compare( data2, meta2.convertData( this, data1 ) );