@Override public void setDefault() { value = new ValueMetaAndData( new ValueMetaNumber( "valuename" ), new Double( 123.456 ) ); value.getValueMeta().setLength( 12 ); value.getValueMeta().setPrecision( 4 ); }
public ExcelInputData() { super(); workbook = null; filenr = 0; sheetnr = 0; rownr = -1; colnr = -1; valueMetaString = new ValueMetaString( "v" ); valueMetaNumber = new ValueMetaNumber( "v" ); valueMetaDate = new ValueMetaDate( "v" ); valueMetaBoolean = new ValueMetaBoolean( "v" ); } }
private static void populateMetaAndData( int i, Object[] rowString10, RowMetaInterface metaString10, Object[] rowMixed10, RowMetaInterface metaMixed10 ) { rowString10[i] = StringUtil.generateRandomString( 20, "", "", false ); ValueMetaInterface meta = new ValueMetaString( "String" + ( i + 1 ), 20, 0 ); metaString10.addValueMeta( meta ); rowMixed10[i * 5 + 0] = StringUtil.generateRandomString( 20, "", "", false ); ValueMetaInterface meta0 = new ValueMetaString( "String" + ( i * 5 + 1 ), 20, 0 ); metaMixed10.addValueMeta( meta0 ); rowMixed10[i * 5 + 1] = new Date(); ValueMetaInterface meta1 = new ValueMetaDate( "String" + ( i * 5 + 1 ) ); metaMixed10.addValueMeta( meta1 ); rowMixed10[i * 5 + 2] = new Double( Math.random() * 1000000 ); ValueMetaInterface meta2 = new ValueMetaNumber( "String" + ( i * 5 + 1 ), 12, 4 ); metaMixed10.addValueMeta( meta2 ); rowMixed10[i * 5 + 3] = new Long( (long) ( Math.random() * 1000000 ) ); ValueMetaInterface meta3 = new ValueMetaInteger( "String" + ( i * 5 + 1 ), 8, 0 ); metaMixed10.addValueMeta( meta3 ); rowMixed10[i * 5 + 4] = Boolean.valueOf( Math.random() > 0.5 ? true : false ); ValueMetaInterface meta4 = new ValueMetaBoolean( "String" + ( i * 5 + 1 ) ); metaMixed10.addValueMeta( meta4 ); }
@Test public void assertNumeric_Number() throws Exception { assertNumericForNumberMeta( new ValueMetaNumber( "number" ), 1D ); }
/** * Create meta information for rows that are passed to Excel Writer step * * @return * @throws KettleException */ private RowMetaInterface createRowMeta() throws KettleException { RowMetaInterface rm = new RowMeta(); try { ValueMetaInterface[] valuesMeta = { new ValueMetaInteger( "col 1" ), new ValueMetaNumber( "col 2" ), new ValueMetaBigNumber( "col 3" ), new ValueMetaNumber( "col 4" ) }; for ( int i = 0; i < valuesMeta.length; i++ ) { rm.addValueMeta( valuesMeta[i] ); } } catch ( Exception ex ) { return null; } return rm; } }
r.addValueMeta( sname ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.Copy" ) ) ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.LinesReaded" ) ) ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.LinesWritten" ) ) ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.LinesUpdated" ) ) ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.LinesSkipped" ) ) ); r.addValueMeta( new ValueMetaNumber( BaseMessages.getString( PKG, "BaseStep.ColumnName.Errors" ) ) ); r.addValueMeta( new ValueMetaDate(
public RowMetaInterface getParameterMetaData( String sql, RowMetaInterface inform, Object[] data ) { // The database couldn't handle it: try manually! int q = countParameters( sql ); RowMetaInterface par = new RowMeta(); if ( inform != null && q == inform.size() ) { for ( int i = 0; i < q; i++ ) { ValueMetaInterface inf = inform.getValueMeta( i ); ValueMetaInterface v = inf.clone(); par.addValueMeta( v ); } } else { for ( int i = 0; i < q; i++ ) { ValueMetaInterface v = new ValueMetaNumber( "name" + i ); par.addValueMeta( v ); } } return par; }
public ValueMetaAndData( String valueName, Object valueData ) throws KettleValueException { this.valueData = valueData; if ( valueData instanceof String ) { this.valueMeta = new ValueMetaString( valueName ); } else if ( valueData instanceof Double ) { this.valueMeta = new ValueMetaNumber( valueName ); } else if ( valueData instanceof Long ) { this.valueMeta = new ValueMetaInteger( valueName ); } else if ( valueData instanceof Date ) { this.valueMeta = new ValueMetaDate( valueName, ValueMetaInterface.TYPE_DATE ); } else if ( valueData instanceof BigDecimal ) { this.valueMeta = new ValueMetaBigNumber( valueName ); } else if ( valueData instanceof Boolean ) { this.valueMeta = new ValueMetaBoolean( valueName ); } else if ( valueData instanceof byte[] ) { this.valueMeta = new ValueMetaBinary( valueName ); } else { this.valueMeta = new ValueMetaSerializable( valueName ); } }
@Test public void getGetSignature_Number() { ValueMetaNumber v = new ValueMetaNumber( "Value" ); String accessor = FieldHelper.getAccessor( true, "Value" ); assertEquals( "Double Value = get(Fields.In, \"Value\").getDouble(r);", FieldHelper.getGetSignature( accessor, v ) ); assertNotNull( getMethod( FieldHelper.class, "getDouble", Object[].class ) ); }
public synchronized ObjectId insertJobEntryAttribute( ObjectId id_job, ObjectId id_jobentry, long nr, String code, double value_num, String value_str ) throws KettleException { ObjectId id = getNextJobEntryAttributeID(); RowMetaAndData table = new RowMetaAndData(); //CHECKSTYLE:LineLength:OFF table .addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_ID_JOBENTRY_ATTRIBUTE ), id ); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_ID_JOB ), id_job ); table .addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_ID_JOBENTRY ), id_jobentry ); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_NR ), new Long( nr ) ); table.addValue( new ValueMetaString( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_CODE ), code ); table.addValue( new ValueMetaNumber( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_VALUE_NUM ), new Double( value_num ) ); table.addValue( new ValueMetaString( KettleDatabaseRepository.FIELD_JOBENTRY_ATTRIBUTE_VALUE_STR ), value_str ); database.prepareInsert( table.getRowMeta(), KettleDatabaseRepository.TABLE_R_JOBENTRY_ATTRIBUTE ); database.setValuesInsert( table ); database.insertRow(); database.closeInsert(); return id; }
v = new ValueMetaNumber( fieldName[i], 10, 5 ); break; case TYPE_RANDOM_INTEGER:
data.bulkDateMeta.setStringEncoding( realEncoding ); data.bulkNumberMeta = new ValueMetaNumber( "numberMeta" ); data.bulkNumberMeta.setConversionMask( "#.#" ); data.bulkNumberMeta.setGroupingSymbol( "," );
public synchronized ObjectId insertStepAttribute( ObjectId id_transformation, ObjectId id_step, long nr, String code, double value_num, String value_str ) throws KettleException { ObjectId id = getNextStepAttributeID(); RowMetaAndData table = new RowMetaAndData(); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_STEP_ATTRIBUTE ), id ); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_TRANSFORMATION ), id_transformation ); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_STEP ), id_step ); table.addValue( new ValueMetaInteger( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_NR ), new Long( nr ) ); table.addValue( new ValueMetaString( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_CODE ), code ); table.addValue( new ValueMetaNumber( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_VALUE_NUM ), new Double( value_num ) ); table.addValue( new ValueMetaString( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_VALUE_STR ), value_str ); /* * If we have prepared the insert, we don't do it again. We assume that all the step insert statements come one * after the other. */ if ( psStepAttributesInsert == null ) { String sql = database.getInsertStatement( KettleDatabaseRepository.TABLE_R_STEP_ATTRIBUTE, table.getRowMeta() ); psStepAttributesInsert = database.prepareSQL( sql ); } database.setValues( table, psStepAttributesInsert ); database.insertRow( psStepAttributesInsert, useBatchProcessing ); if ( log.isDebug() ) { log.logDebug( "saved attribute [" + code + "]" ); } return id; }
@Test public void testNullsAreZeroDefault() throws Exception { variables.setVariable( Const.KETTLE_AGGREGATION_ALL_NULLS_ARE_ZERO, "Y" ); addColumn( new ValueMetaInteger( "nul" ) ); addColumn( new ValueMetaInteger( "both" ), -2L, 0L, null, 10L ); addColumn( new ValueMetaNumber( "both_num" ), -2.0, 0.0, null, 10.0 ); RowMetaAndData output = runStep(); assertThat( output.getInteger( "nul_min" ), is( 0L ) ); assertThat( output.getInteger( "nul_max" ), is( 0L ) ); assertThat( output.getInteger( "nul_sum" ), is( 0L ) ); assertThat( output.getInteger( "nul_ave" ), is( 0L ) ); assertThat( output.getInteger( "nul_count" ), is( 0L ) ); assertThat( output.getInteger( "nul_count_any" ), is( 4L ) ); assertThat( output.getInteger( "nul_count_distinct" ), is( 0L ) ); assertThat( output.getInteger( "both_max" ), is( 10L ) ); assertThat( output.getInteger( "both_min" ), is( -2L ) ); assertThat( output.getInteger( "both_sum" ), is( 8L ) ); assertThat( output.getInteger( "both_ave" ), is( 2L ) ); assertThat( output.getInteger( "both_count" ), is( 3L ) ); assertThat( output.getInteger( "both_count_any" ), is( 4L ) ); assertThat( output.getInteger( "both_count_distinct" ), is( 3L ) ); assertThat( output.getNumber( "both_num_max", Double.NaN ), is( 10.0 ) ); assertThat( output.getNumber( "both_num_min", Double.NaN ), is( -2.0 ) ); assertThat( output.getNumber( "both_num_sum", Double.NaN ), is( 8.0 ) ); assertEquals( 2.666666, output.getNumber( "both_num_ave", Double.NaN ), 0.000001 /* delta */ ); assertThat( output.getInteger( "both_num_count" ), is( 3L ) ); assertThat( output.getInteger( "both_num_count_any" ), is( 4L ) ); assertThat( output.getInteger( "both_num_count_distinct" ), is( 3L ) ); }
data.monetTimeMeta.setStringEncoding( encoding ); data.monetNumberMeta = new ValueMetaNumber( "numberMeta" ); data.monetNumberMeta.setConversionMask( "#.#" ); data.monetNumberMeta.setGroupingSymbol( "," );
public void assertRound( final double expectedResult, final double value ) throws KettleException { RowMeta inputRowMeta = new RowMeta(); ValueMetaNumber valueMeta = new ValueMetaNumber( "Value" ); inputRowMeta.addValueMeta( valueMeta ); RowSet inputRowSet = smh.getMockInputRowSet( new Object[] { value } ); inputRowSet.setRowMeta( inputRowMeta ); Calculator calculator = new Calculator( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); calculator.addRowSetToInputRowSets( inputRowSet ); calculator.setInputRowMeta( inputRowMeta ); calculator.init( smh.initStepMetaInterface, smh.initStepDataInterface ); CalculatorMeta meta = new CalculatorMeta(); meta.setCalculation( new CalculatorMetaFunction[] { new CalculatorMetaFunction( "test", CalculatorMetaFunction.CALC_ROUND_1, "Value", null, null, ValueMetaInterface.TYPE_NUMBER, 2, 0, false, "", "", "", "" ) } ); // Verify output try { calculator.addRowListener( new RowAdapter() { @Override public void rowWrittenEvent( RowMetaInterface rowMeta, Object[] row ) throws KettleStepException { assertEquals( expectedResult, row[1] ); } } ); calculator.processRow( meta, new CalculatorData() ); } catch ( KettleException ke ) { ke.printStackTrace(); fail(); } }
public void assertRoundStd( final double expectedResult, final double value ) throws KettleException { RowMeta inputRowMeta = new RowMeta(); ValueMetaNumber valueMeta = new ValueMetaNumber( "Value" ); inputRowMeta.addValueMeta( valueMeta ); RowSet inputRowSet = smh.getMockInputRowSet( new Object[] { value } ); inputRowSet.setRowMeta( inputRowMeta ); Calculator calculator = new Calculator( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); calculator.addRowSetToInputRowSets( inputRowSet ); calculator.setInputRowMeta( inputRowMeta ); calculator.init( smh.initStepMetaInterface, smh.initStepDataInterface ); CalculatorMeta meta = new CalculatorMeta(); meta.setCalculation( new CalculatorMetaFunction[] { new CalculatorMetaFunction( "test", CalculatorMetaFunction.CALC_ROUND_STD_1, "Value", null, null, ValueMetaInterface.TYPE_NUMBER, 2, 0, false, "", "", "", "" ) } ); // Verify output try { calculator.addRowListener( new RowAdapter() { @Override public void rowWrittenEvent( RowMetaInterface rowMeta, Object[] row ) throws KettleStepException { assertEquals( expectedResult, row[1] ); } } ); calculator.processRow( meta, new CalculatorData() ); } catch ( KettleException ke ) { ke.printStackTrace(); fail(); } }
private RowMetaInterface getInputRowMeta() { RowMetaInterface rm = new RowMeta(); rm.addValueMeta( new ValueMetaString( "myGroupField2" ) ); rm.addValueMeta( new ValueMetaString( "myGroupField1" ) ); rm.addValueMeta( new ValueMetaString( "myString" ) ); rm.addValueMeta( new ValueMetaInteger( "myInteger" ) ); rm.addValueMeta( new ValueMetaNumber( "myNumber" ) ); rm.addValueMeta( new ValueMetaBigNumber( "myBigNumber" ) ); rm.addValueMeta( new ValueMetaBinary( "myBinary" ) ); rm.addValueMeta( new ValueMetaBoolean( "myBoolean" ) ); rm.addValueMeta( new ValueMetaDate( "myDate" ) ); rm.addValueMeta( new ValueMetaTimestamp( "myTimestamp" ) ); rm.addValueMeta( new ValueMetaInternetAddress( "myInternetAddress" ) ); return rm; } @Test
public void assertRoundStd2( final double expectedResult, final double value, final long precision ) throws KettleException { RowMeta inputRowMeta = new RowMeta(); ValueMetaNumber valueMeta = new ValueMetaNumber( "Value" ); ValueMetaInteger precisionMeta = new ValueMetaInteger( "Precision" ); inputRowMeta.addValueMeta( valueMeta );
public void assertRound2( final double expectedResult, final double value, final long precision ) throws KettleException { RowMeta inputRowMeta = new RowMeta(); ValueMetaNumber valueMeta = new ValueMetaNumber( "Value" ); ValueMetaInteger precisionMeta = new ValueMetaInteger( "Precision" ); inputRowMeta.addValueMeta( valueMeta );