calcData[index] = ValueDataUtil.plus( metaA, dataA, metaB, dataB ); if ( metaA.isString() || metaB.isString() ) { resultType = ValueMetaInterface.TYPE_STRING; calcData[index] = ValueDataUtil.minus( metaA, dataA, metaB, dataB ); if ( metaA.isDate() ) { resultType = ValueMetaInterface.TYPE_INTEGER; calcData[index] = ValueDataUtil.multiply( metaA, dataA, metaB, dataB ); if ( metaA.isString() || metaB.isString() ) { resultType = ValueMetaInterface.TYPE_STRING; calcData[index] = ValueDataUtil.divide( metaA, dataA, metaB, dataB ); break; case CalculatorMetaFunction.CALC_SQUARE: // A * A calcData[index] = ValueDataUtil.multiply( metaA, dataA, metaA, dataA ); break; case CalculatorMetaFunction.CALC_SQUARE_ROOT: // SQRT( A ) calcData[index] = ValueDataUtil.sqrt( metaA, dataA ); break; case CalculatorMetaFunction.CALC_PERCENT_1: // 100 * A / B calcData[index] = ValueDataUtil.percent1( metaA, dataA, metaB, dataB ); break; case CalculatorMetaFunction.CALC_PERCENT_2: // A - ( A * B / 100 ) calcData[index] = ValueDataUtil.percent2( metaA, dataA, metaB, dataB ); break; case CalculatorMetaFunction.CALC_PERCENT_3: // A + ( A * B / 100 ) calcData[index] = ValueDataUtil.percent3( metaA, dataA, metaB, dataB ); break;
} else { if ( sourceMeta.isInteger() ) { sum = ValueDataUtil.plus( data.valueMetaInteger, data.previousAvgSum[ i ], sourceMeta, row[ sourceIndex ] ); } else { sum = ValueDataUtil.plus( targetMeta, data.previousAvgSum[ i ], sourceMeta, row[ sourceIndex ] ); row[ targetIndex ] = ValueDataUtil.divide( targetMeta, sum, data.valueMetaInteger, data.previousAvgCount[ i ] );
return ValueDataUtil.plus( valueMetaA, dataA, valueMetaB, dataB ); return ValueDataUtil.plus3( valueMetaA, dataA, valueMetaB, dataB, valueMetaC, dataC ); return ValueDataUtil.minus( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DIVIDE ) { return ValueDataUtil.divide( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_1 ) { return ValueDataUtil.percent1( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_2 ) { return ValueDataUtil.percent2( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_3 ) { return ValueDataUtil.percent3( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_COMBINATION_1 ) { return ValueDataUtil.combination1( valueMetaA, dataA, valueMetaB, dataB, valueMetaC, dataC ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_COMBINATION_2 ) { return ValueDataUtil.combination2( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ROUND_1 ) { return ValueDataUtil.round( valueMetaA, dataA ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ROUND_2 ) { return ValueDataUtil.round( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_NVL ) { return ValueDataUtil.nvl( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DATE_DIFF ) { return ValueDataUtil.DateDiff( valueMetaA, dataA, valueMetaB, dataB, "" ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DATE_WORKING_DIFF ) { return ValueDataUtil.DateWorkingDiff( valueMetaA, dataA, valueMetaB, dataB ); } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_REMAINDER ) { return ValueDataUtil.remainder( valueMetaA, dataA, valueMetaB, dataB );
/** * Checks an xml file is well formed. * * @param metaA * The ValueMetaInterface * @param dataA * The value (filename) * @return true if the file is well formed. * @deprecated Use {@link ValueDataUtil#isXMLFileWellFormed(ValueMetaInterface, Object, boolean)} instead */ @Deprecated public static boolean isXMLFileWellFormed( ValueMetaInterface metaA, Object dataA ) { boolean xmlWellFormed = false; try { xmlWellFormed = isXMLFileWellFormed( metaA, dataA, false ); } catch ( KettleFileNotFoundException e ) { // Ignore } return xmlWellFormed; }
/** * Get file encoding. * * @param metaA * The ValueMetaInterface * @param dataA * The value (filename) * @return file encoding. * @deprecated Use {@link ValueDataUtil#getFileEncoding(ValueMetaInterface, Object, boolean)} instead */ @Deprecated public static String getFileEncoding( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { String encoding = null; try { encoding = getFileEncoding( metaA, dataA, true ); } catch ( KettleFileNotFoundException e ) { throw new KettleValueException(); } return encoding; }
/** * @deprecated Use {@link ValueDataUtil#createChecksum(ValueMetaInterface, Object, String, boolean)} instead */ @Deprecated public static String createChecksum( ValueMetaInterface metaA, Object dataA, String type ) { String checksum = null; try { checksum = createChecksum( metaA, dataA, type, false ); } catch ( KettleFileNotFoundException e ) { // Ignore } return checksum; }
/** * @deprecated Use {@link ValueDataUtil#checksumAdler32(ValueMetaInterface, Object, boolean)} instead */ @Deprecated public static Long ChecksumAdler32( ValueMetaInterface metaA, Object dataA ) { long checksum = 0; try { checksum = checksumAdler32( metaA, dataA, false ); } catch ( KettleFileNotFoundException e ) { // Ignore } return checksum; }
/** * @deprecated Use {@link ValueDataUtil#checksumCRC32(ValueMetaInterface, Object, boolean)} instead */ @Deprecated public static Long ChecksumCRC32( ValueMetaInterface metaA, Object dataA ) { long checksum = 0; try { checksum = checksumCRC32( metaA, dataA, false ); } catch ( KettleFileNotFoundException e ) { // Ignore } return checksum; }
/** * @deprecated Use {@link ValueDataUtil#loadFileContentInBinary(ValueMetaInterface, Object, boolean)} instead */ @Deprecated public static Object loadFileContentInBinary( ValueMetaInterface metaA, Object dataA ) throws KettleValueException { Object content = null; try { content = loadFileContentInBinary( metaA, dataA, true ); } catch ( KettleFileNotFoundException e ) { throw new KettleValueException(); } return content; }
targetData = targetMeta.convertData( sourceMeta, sourceData ); if ( prevTargetData != null ) { prevTargetData = ValueDataUtil.sum( targetMeta, prevTargetData, targetMeta, targetData ); } else { prevTargetData = targetData; data.sum[idx] = targetData; } else { data.sum[idx] = ValueDataUtil.plus( targetMeta, data.sum[idx], targetMeta, targetData );
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 ); }
/** * Rounding with decimal places (using default rounding method ROUND_HALF_EVEN) * * @param metaA * Metadata of value to round * @param dataA * Value to round * @param metaB * Metadata of decimal places * @param dataB * decimal places * @return The rounded value * @throws KettleValueException */ public static Object round( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB ) throws KettleValueException { final Object r = round( metaA, dataA, metaB, dataB, ROUND_2_MODE ); return r; }
@Test public void xmlFileBadlyFormedWithFailIfNoFileTest() throws KettleFileNotFoundException { String invalidXmlFilePath = getClass().getResource( "invalid-xml-sample.xml" ).getPath(); boolean wellFormed = ValueDataUtil.isXMLFileWellFormed( new ValueMetaString(), invalidXmlFilePath, true ); assertFalse( wellFormed ); }
@Test public void getFileEncodingTest() throws Exception { String path = getClass().getResource( "txt-sample.txt" ).getPath(); String encoding = ValueDataUtil.getFileEncoding( new ValueMetaString(), path ); assertEquals( "US-ASCII", encoding ); }
@Test public void checksumWithoutFailIfNoFileTest() throws Exception { String path = getClass().getResource( "txt-sample.txt" ).getPath(); String checksum = ValueDataUtil.createChecksum( new ValueMetaString(), path, "MD5", false ); assertEquals( "098f6bcd4621d373cade4e832627b4f6", checksum ); }
@Test public void checksumAdlerWithFailIfNoFileTest() throws Exception { String path = getClass().getResource( "txt-sample.txt" ).getPath(); long checksum = ValueDataUtil.checksumAdler32( new ValueMetaString(), path, true ); assertEquals( 73204161L, checksum ); }
@Test public void checksumCRC32WithoutFailIfNoFileTest() throws Exception { String path = getClass().getResource( "txt-sample.txt" ).getPath(); long checksum = ValueDataUtil.checksumCRC32( new ValueMetaString(), path, false ); assertEquals( 3632233996l, checksum ); }
@Test public void loadFileContentInBinary() throws Exception { String path = getClass().getResource( "txt-sample.txt" ).getPath(); byte[] content = ValueDataUtil.loadFileContentInBinary( new ValueMetaString(), path, true ); assertTrue( Arrays.equals( "test".getBytes(), content ) ); }
private void addCumulativeSums( Object[] row ) throws KettleValueException { // We need to adjust this row with cumulative averages? // for ( int i = 0; i < data.cumulativeSumSourceIndexes.size(); i++ ) { int sourceIndex = data.cumulativeSumSourceIndexes.get( i ); Object previousTarget = data.previousSums[ i ]; Object sourceValue = row[ sourceIndex ]; int targetIndex = data.cumulativeSumTargetIndexes.get( i ); ValueMetaInterface sourceMeta = data.inputRowMeta.getValueMeta( sourceIndex ); ValueMetaInterface targetMeta = data.outputRowMeta.getValueMeta( targetIndex ); // If the first values where null, or this is the first time around, just take the source value... // if ( targetMeta.isNull( previousTarget ) ) { row[ targetIndex ] = sourceMeta.convertToNormalStorageType( sourceValue ); } else { // If the source value is null, just take the previous target value // if ( sourceMeta.isNull( sourceValue ) ) { row[ targetIndex ] = previousTarget; } else { row[ targetIndex ] = ValueDataUtil.plus( targetMeta, data.previousSums[ i ], sourceMeta, row[ sourceIndex ] ); } } data.previousSums[ i ] = row[ targetIndex ]; } }
/** * Rounding with decimal places with a given rounding method * * @param metaA * Metadata of value to round * @param dataA * Value to round * @param metaB * Metadata of decimal places * @param dataB * decimal places * @param metaC * Metadata of rounding mode * @param dataC * rounding mode, e.g. java.math.BigDecimal.ROUND_HALF_EVEN * @return The rounded value * @throws KettleValueException */ public static Object round( ValueMetaInterface metaA, Object dataA, ValueMetaInterface metaB, Object dataB, ValueMetaInterface metaC, Object dataC ) throws KettleValueException { if ( dataA == null || dataB == null || dataC == null ) { return null; } Long valueC = metaC.getInteger( dataC ); if ( valueC == null || valueC < Const.ROUND_HALF_CEILING || valueC > BigDecimal.ROUND_HALF_EVEN ) { throw new KettleValueException( "The 'round_custom' arg C has incorrect value: " + valueC ); } int roundingMode = valueC.intValue(); return round( metaA, dataA, metaB, dataB, roundingMode ); }