public Double getDouble( Object[] dataRow ) throws KettleValueException { return meta.getNumber( dataRow[index] ); }
public Double getNumber( Object object ) throws ValueConverterException { try { return meta.getNumber( object ); } catch ( KettleValueException kve ) { throw new ValueConverterException( kve ); } }
public static Object sqrt( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { case ValueMetaInterface.TYPE_NUMBER: return new Double( Math.sqrt( metaA.getNumber( dataA ).doubleValue() ) ); case ValueMetaInterface.TYPE_INTEGER: return new Long( Math.round( Math.sqrt( metaA.getNumber( dataA ).doubleValue() ) ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return BigDecimal.valueOf( Math.sqrt( metaA.getNumber( dataA ).doubleValue() ) ); default: throw new KettleValueException( "The 'sqrt' function only works on numeric data." ); } }
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" ); } }
/** * Get a Number value from a row of data. Convert data if this needed. * * @param dataRow the row of data * @param index the index * @return The number found on that position in the row * @throws KettleValueException in case there was a problem converting the data. */ @Override public Double getNumber( Object[] dataRow, int index ) throws KettleValueException { if ( dataRow == null ) { return null; } ValueMetaInterface meta = getValueMeta( index ); return meta.getNumber( dataRow[ index ] ); }
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" ); } }
/** * 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" ); } }
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() ); } }
/** * 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." ); } }
/** * Returns the remainder (modulus) of A / B. * * @param metaA * @param dataA * The dividend * @param metaB * @param dataB * The divisor * @return The remainder * @throws KettleValueException */ public static Object remainder( 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 ) % metaB.getInteger( dataB ) ); case ValueMetaInterface.TYPE_BIGNUMBER: BigDecimal aValue = metaA.getBigNumber( dataA ); BigDecimal bValue = metaA.getBigNumber( dataB ); BigDecimal result = aValue.remainder( bValue, new MathContext( getMaxPrecision( aValue, bValue ), RoundingMode.HALF_EVEN ) ); return removeTrailingZeroFractionOrScale( result, result.scale() ); default: throw new KettleValueException( "The 'remainder' function only works on numeric data" ); } }
/** * A + ( A * B / 100 ) * * @param metaA * @param dataA * @param metaB * @param dataB * @return * @throws KettleValueException */ public static Object percent3( 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() + divideDoubles( multiplyDoubles( metaA.getNumber( dataA ), metaB.getNumber( dataB ) ), 100.0D ) ); case ValueMetaInterface.TYPE_INTEGER: return new Long( metaA.getInteger( dataA ).longValue() + divideLongs( multiplyLongs( metaA.getInteger( dataA ), metaB.getInteger( dataB ) ), 100L ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return metaA.getBigNumber( dataA ).add( divideBigDecimals( multiplyBigDecimals( metaB.getBigNumber( dataB ), metaA.getBigNumber( dataA ), null ), new BigDecimal( 100 ), null ) ); default: throw new KettleValueException( "The 'A+B%' 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." ); } }
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." ); } }
/** * Rounding with no decimal places with a given rounding method * * @param metaA * Metadata of value to round * @param dataA * Value to round * @param roundingMode * The mode for rounding, e.g. java.math.BigDecimal.ROUND_HALF_EVEN * @return The rounded value * @throws KettleValueException */ public static Object round( ValueMetaInterface metaA, Object dataA, int roundingMode ) throws KettleValueException { if ( dataA == null ) { return null; } switch ( metaA.getType() ) { // Use overloaded Const.round(value, precision, mode) case ValueMetaInterface.TYPE_NUMBER: return new Double( Const.round( metaA.getNumber( dataA ), 0, roundingMode ) ); case ValueMetaInterface.TYPE_INTEGER: return new Long( Const.round( metaA.getInteger( dataA ), 0, roundingMode ) ); case ValueMetaInterface.TYPE_BIGNUMBER: return Const.round( metaA.getBigNumber( dataA ), 0, roundingMode ); default: throw new KettleValueException( "The 'round' function only works on numeric data" ); } }
/** * 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; } }
/** * Convert the specified data to the data type specified in this object. * * @param meta2 * the metadata of the object to be converted * @param data2 * the data of the object to be converted * @return the object in the data type of this value metadata object * @throws KettleValueException * in case there is a data conversion error */ @Override public Object convertData( ValueMetaInterface meta2, Object data2 ) throws KettleValueException { switch ( meta2.getType() ) { case TYPE_STRING: return convertStringToInternetAddress( meta2.getString( data2 ) ); case TYPE_INTEGER: return convertIntegerToInternetAddress( meta2.getInteger( data2 ) ); case TYPE_NUMBER: return convertNumberToInternetAddress( meta2.getNumber( data2 ) ); case TYPE_BIGNUMBER: return convertBigNumberToInternetAddress( meta2.getBigNumber( data2 ) ); default: throw new KettleValueException( meta2.toStringMeta() + " : can't be converted to an Internet Address" ); } }
/** * Convert the specified data to the data type specified in this object. * * @param meta2 * the metadata of the object to be converted * @param data2 * the data of the object to be converted * @return the object in the data type of this value metadata object * @throws KettleValueException * in case there is a data conversion error */ @Override public Object convertData( ValueMetaInterface meta2, Object data2 ) throws KettleValueException { switch ( meta2.getType() ) { case TYPE_TIMESTAMP: return ( (ValueMetaTimestamp) meta2 ).getTimestamp( data2 ); case TYPE_STRING: return convertStringToTimestamp( meta2.getString( data2 ) ); case TYPE_INTEGER: return convertIntegerToTimestamp( meta2.getInteger( data2 ) ); case TYPE_NUMBER: return convertNumberToTimestamp( meta2.getNumber( data2 ) ); case TYPE_DATE: return convertDateToTimestamp( meta2.getDate( data2 ) ); case TYPE_BIGNUMBER: return convertBigNumberToTimestamp( meta2.getBigNumber( data2 ) ); default: throw new KettleValueException( meta2.toStringMeta() + " : can't be converted to a timestamp" ); } }