public Long getLong( Object[] dataRow ) throws KettleValueException { return meta.getInteger( dataRow[index] ); }
public static Object addHours( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { Calendar cal = Calendar.getInstance(); cal.setTime( metaA.getDate( dataA ) ); cal.add( Calendar.HOUR_OF_DAY, metaB.getInteger( dataB ).intValue() ); return cal.getTime(); }
public static Object addMinutes( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { Calendar cal = Calendar.getInstance(); cal.setTime( metaA.getDate( dataA ) ); cal.add( Calendar.MINUTE, metaB.getInteger( dataB ).intValue() ); return cal.getTime(); }
public static Object addSeconds( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { Calendar cal = Calendar.getInstance(); cal.setTime( metaA.getDate( dataA ) ); cal.add( Calendar.SECOND, metaB.getInteger( dataB ).intValue() ); return cal.getTime(); }
public static Object addDays( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { Calendar cal = Calendar.getInstance(); cal.setTime( metaA.getDate( dataA ) ); cal.add( Calendar.DAY_OF_YEAR, metaB.getInteger( dataB ).intValue() ); return cal.getTime(); }
public Long getInteger( Object object ) throws ValueConverterException { try { return meta.getInteger( object ); } catch ( KettleValueException kve ) { throw new ValueConverterException( kve ); } }
/** * Get an Integer value from a row of data. Convert data if this needed. * * @param dataRow the row of data * @param index the index * @return The integer found on that position in the row * @throws KettleValueException in case there was a problem converting the data. */ @Override public Long getInteger( Object[] dataRow, int index ) throws KettleValueException { if ( dataRow == null ) { return null; } ValueMetaInterface meta = getValueMeta( index ); return meta.getInteger( dataRow[ index ] ); }
public static Object minus( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { if ( dataA == null || dataB == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( metaA.getNumber( dataA ).doubleValue() - metaB.getNumber( dataB ).doubleValue() ); case ValueMetaInterface.TYPE_INTEGER: return new Long( metaA.getInteger( dataA ).longValue() - metaB.getInteger( dataB ).longValue() ); case ValueMetaInterface.TYPE_BIGNUMBER: return metaA.getBigNumber( dataA ).subtract( metaB.getBigNumber( dataB ) ); default: return new Long( metaA.getInteger( dataA ).longValue() - metaB.getInteger( dataB ).longValue() ); } }
public static Object addMonths( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { if ( dataA != null && dataB != null ) { Calendar cal = Calendar.getInstance(); cal.setTime( metaA.getDate( dataA ) ); int year = cal.get( Calendar.YEAR ); int month = cal.get( Calendar.MONTH ); int day = cal.get( Calendar.DAY_OF_MONTH ); month += metaB.getInteger( dataB ).intValue(); int newyear = year + (int) Math.floor( month / 12 ); int newmonth = month % 12; cal.set( newyear, newmonth, 1 ); int newday = cal.getActualMaximum( Calendar.DAY_OF_MONTH ); if ( newday < day ) { cal.set( Calendar.DAY_OF_MONTH, newday ); } else { cal.set( Calendar.DAY_OF_MONTH, day ); } return ( cal.getTime() ); } else { throw new KettleValueException( "Unable to add months with a null value" ); } }
public static Object abs( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( Math.abs( metaA.getNumber( dataA ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return metaA.getInteger( Math.abs( metaA.getNumber( dataA ).longValue() ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return new BigDecimal( Math.abs( metaA.getNumber( dataA ).doubleValue() ) ); default: throw new KettleValueException( "The 'abs' function only works on numeric data" ); } }
public static Object ceil( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( Math.ceil( metaA.getNumber( dataA ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return metaA.getInteger( dataA ); case ValueMetaInterface.TYPE_BIGNUMBER: return new BigDecimal( Math.ceil( metaA.getNumber( dataA ).doubleValue() ) ); default: throw new KettleValueException( "The 'ceil' function only works on numeric data" ); } }
public static Object floor( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( Math.floor( metaA.getNumber( dataA ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return metaA.getInteger( dataA ); case ValueMetaInterface.TYPE_BIGNUMBER: return new BigDecimal( Math.floor( metaA.getNumber( dataA ).doubleValue() ) ); default: throw new KettleValueException( "The 'floor' function only works on numeric data" ); } }
protected static Object multiplyString( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { StringBuffer s; String append = ""; int n; if ( metaB.isString() ) { s = new StringBuffer( metaB.getString( dataB ) ); append = metaB.getString( dataB ); n = metaA.getInteger( dataA ).intValue(); } else { s = new StringBuffer( metaA.getString( dataA ) ); append = metaA.getString( dataA ); n = metaB.getInteger( dataB ).intValue(); } if ( n == 0 ) { s.setLength( 0 ); } else { for ( int i = 1; i < n; i++ ) { s.append( append ); } } return s.toString(); }
/** * Rounding with no decimal places (using default rounding method ROUND_HALF_CEILING) * * @param metaA * Metadata of value to round * @param dataA * Value to round * @return The rounded value * @throws KettleValueException */ public static Object round( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( Math.round( metaA.getNumber( dataA ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return metaA.getInteger( dataA ); case ValueMetaInterface.TYPE_BIGNUMBER: return new BigDecimal( Math.round( metaA.getNumber( dataA ).doubleValue() ) ); default: throw new KettleValueException( "The 'round' function only works on numeric data" ); } }
/** * A + B * C * * @param metaA * @param dataA * @param metaB * @param dataB * @return * @throws KettleValueException */ public static Object combination1( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB, ValueMetaInterface metaC, Object dataC ) throws KettleValueException { if ( dataA == null || dataB == null || dataC == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( metaA.getNumber( dataA ).doubleValue() + ( metaB.getNumber( dataB ).doubleValue() * metaC.getNumber( dataC ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return new Long( metaA.getInteger( dataA ).longValue() + ( metaB.getInteger( dataB ).longValue() * metaC.getInteger( dataC ).longValue() ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return metaA.getBigNumber( dataA ).add( multiplyBigDecimals( metaB.getBigNumber( dataB ), metaC.getBigNumber( dataC ), null ) ); default: throw new KettleValueException( "The 'combination1' function only works on numeric data" ); } }
public static Object plus3( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB, ValueMetaInterface metaC, Object dataC ) throws KettleValueException { if ( dataA == null || dataB == null || dataC == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_STRING: return metaA.getString( dataA ) + metaB.getString( dataB ) + metaC.getString( dataC ); case ValueMetaInterface.TYPE_NUMBER: return new Double( metaA.getNumber( dataA ).doubleValue() + metaB.getNumber( dataB ).doubleValue() + metaC.getNumber( dataC ).doubleValue() ); case ValueMetaInterface.TYPE_INTEGER: return new Long( metaA.getInteger( dataA ).longValue() + metaB.getInteger( dataB ).longValue() + metaC.getInteger( dataC ).longValue() ); case ValueMetaInterface.TYPE_BOOLEAN: return Boolean.valueOf( metaA.getBoolean( dataA ).booleanValue() || metaB.getBoolean( dataB ).booleanValue() || metaB.getBoolean( dataC ).booleanValue() ); case ValueMetaInterface.TYPE_BIGNUMBER: return metaA.getBigNumber( dataA ).add( metaB.getBigNumber( dataB ).add( metaC.getBigNumber( dataC ) ) ); default: throw new KettleValueException( "The 'plus' function only works on numeric data and Strings." ); } }
public static Object divide( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { if ( dataA == null || dataB == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return divideDoubles( metaA.getNumber( dataA ), metaB.getNumber( dataB ) ); case ValueMetaInterface.TYPE_INTEGER: return divideLongs( metaA.getInteger( dataA ), metaB.getInteger( dataB ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return divideBigDecimals( metaA.getBigNumber( dataA ), metaB.getBigNumber( dataB ), null ); default: throw new KettleValueException( "The 'divide' function only works on numeric data." ); } }
protected static Object multiplyNumeric( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return multiplyDoubles( metaA.getNumber( dataA ), metaB.getNumber( dataB ) ); case ValueMetaInterface.TYPE_INTEGER: return multiplyLongs( metaA.getInteger( dataA ), metaB.getInteger( dataB ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return multiplyBigDecimals( metaA.getBigNumber( dataA ), metaB.getBigNumber( dataB ), null ); default: throw new KettleValueException( "The 'multiply' function only works on numeric data optionally multiplying strings." ); } }
/** * 100 * A / B * * @param metaA * @param dataA * @param metaB * @param dataB * @return * @throws KettleValueException */ public static Object percent1( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { if ( dataA == null || dataB == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return divideDoubles( multiplyDoubles( 100.0D, metaA.getNumber( dataA ) ), metaB.getNumber( dataB ) ); case ValueMetaInterface.TYPE_INTEGER: return divideLongs( multiplyLongs( 100L, metaA.getInteger( dataA ) ), metaB.getInteger( dataB ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return divideBigDecimals( multiplyBigDecimals( metaA.getBigNumber( dataA ), new BigDecimal( 100 ), null ), metaB .getBigNumber( dataB ), null ); default: throw new KettleValueException( "The 'A/B in %' function only works on numeric data" ); } }
public static Object getPrimitive( ValueMetaInterface valueMeta, Object valueData ) throws KettleValueException { switch ( valueMeta.getType() ) { case ValueMetaInterface.TYPE_BIGNUMBER: return valueMeta.getBigNumber( valueData ); case ValueMetaInterface.TYPE_BINARY: return valueMeta.getBinary( valueData ); case ValueMetaInterface.TYPE_BOOLEAN: return valueMeta.getBoolean( valueData ); case ValueMetaInterface.TYPE_DATE: return valueMeta.getDate( valueData ); case ValueMetaInterface.TYPE_INTEGER: return valueMeta.getInteger( valueData ); case ValueMetaInterface.TYPE_NUMBER: return valueMeta.getNumber( valueData ); // case ValueMetaInterface.TYPE_SERIALIZABLE: return valueMeta.(valueData); case ValueMetaInterface.TYPE_STRING: return valueMeta.getString( valueData ); default: return null; } }