Examples with KettleFileNotFoundException org.pentaho.di.core.exception.KettleFileNotFoundException used on opensource projects

Example 6 with KettleFileNotFoundException

use of org.pentaho.di.core.exception.KettleFileNotFoundException in project pentaho-kettle by pentaho.

the class Calculator method processRow.

@Override
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
    meta = (CalculatorMeta) smi;
    data = (CalculatorData) sdi;
    // get row, set busy!
    Object[] r = getRow();
    if (r == null) {
        // no more input to be expected...
        setOutputDone();
        data.clearValuesMetaMapping();
        return false;
    }
    if (first) {
        first = false;
        data.setOutputRowMeta(getInputRowMeta().clone());
        meta.getFields(data.getOutputRowMeta(), getStepname(), null, null, this, repository, metaStore);
        // get all metadata, including source rows and temporary fields.
        data.setCalcRowMeta(meta.getAllFields(getInputRowMeta()));
        data.setFieldIndexes(new FieldIndexes[meta.getCalculation().length]);
        List<Integer> tempIndexes = new ArrayList<Integer>();
        // CHECKSTYLE:Indentation:OFF
        for (int i = 0; i < meta.getCalculation().length; i++) {
            CalculatorMetaFunction function = meta.getCalculation()[i];
            data.getFieldIndexes()[i] = new FieldIndexes();
            if (!Utils.isEmpty(function.getFieldName())) {
                data.getFieldIndexes()[i].indexName = data.getCalcRowMeta().indexOfValue(function.getFieldName());
                if (data.getFieldIndexes()[i].indexName < 0) {
                    // Nope: throw an exception
                    throw new KettleStepException(BaseMessages.getString(PKG, "Calculator.Error.UnableFindField", function.getFieldName(), "" + (i + 1)));
                }
            } else {
                throw new KettleStepException(BaseMessages.getString(PKG, "Calculator.Error.NoNameField", "" + (i + 1)));
            }
            if (!Utils.isEmpty(function.getFieldA())) {
                if (function.getCalcType() != CalculatorMetaFunction.CALC_CONSTANT) {
                    data.getFieldIndexes()[i].indexA = data.getCalcRowMeta().indexOfValue(function.getFieldA());
                    if (data.getFieldIndexes()[i].indexA < 0) {
                        // Nope: throw an exception
                        throw new KettleStepException("Unable to find the first argument field '" + function.getFieldName() + " for calculation #" + (i + 1));
                    }
                } else {
                    data.getFieldIndexes()[i].indexA = -1;
                }
            } else {
                throw new KettleStepException("There is no first argument specified for calculated field #" + (i + 1));
            }
            if (!Utils.isEmpty(function.getFieldB())) {
                data.getFieldIndexes()[i].indexB = data.getCalcRowMeta().indexOfValue(function.getFieldB());
                if (data.getFieldIndexes()[i].indexB < 0) {
                    // Nope: throw an exception
                    throw new KettleStepException("Unable to find the second argument field '" + function.getFieldName() + " for calculation #" + (i + 1));
                }
            }
            data.getFieldIndexes()[i].indexC = -1;
            if (!Utils.isEmpty(function.getFieldC())) {
                data.getFieldIndexes()[i].indexC = data.getCalcRowMeta().indexOfValue(function.getFieldC());
                if (data.getFieldIndexes()[i].indexC < 0) {
                    // Nope: throw an exception
                    throw new KettleStepException("Unable to find the third argument field '" + function.getFieldName() + " for calculation #" + (i + 1));
                }
            }
            if (function.isRemovedFromResult()) {
                tempIndexes.add(getInputRowMeta().size() + i);
            }
        }
        // Convert temp indexes to int[]
        data.setTempIndexes(new int[tempIndexes.size()]);
        for (int i = 0; i < data.getTempIndexes().length; i++) {
            data.getTempIndexes()[i] = tempIndexes.get(i);
        }
    }
    if (log.isRowLevel()) {
        logRowlevel(BaseMessages.getString(PKG, "Calculator.Log.ReadRow") + getLinesRead() + " : " + getInputRowMeta().getString(r));
    }
    try {
        Object[] row = calcFields(getInputRowMeta(), r);
        // copy row to possible alternate rowset(s).
        putRow(data.getOutputRowMeta(), row);
        if (log.isRowLevel()) {
            logRowlevel("Wrote row #" + getLinesWritten() + " : " + getInputRowMeta().getString(r));
        }
        if (checkFeedback(getLinesRead())) {
            if (log.isBasic()) {
                logBasic(BaseMessages.getString(PKG, "Calculator.Log.Linenr", "" + getLinesRead()));
            }
        }
    } catch (KettleFileNotFoundException e) {
        if (meta.isFailIfNoFile()) {
            logError(BaseMessages.getString(PKG, "Calculator.Log.NoFile") + " : " + e.getFilepath());
            setErrors(getErrors() + 1);
            return false;
        }
    } catch (KettleException e) {
        logError(BaseMessages.getString(PKG, "Calculator.ErrorInStepRunning" + " : " + e.getMessage()));
        throw new KettleStepException(BaseMessages.getString(PKG, "Calculator.ErrorInStepRunning"), e);
    }
    return true;
}

Example 7 with KettleFileNotFoundException

use of org.pentaho.di.core.exception.KettleFileNotFoundException in project pentaho-kettle by pentaho.

the class Calculator method calcFields.

/**
 * @param inputRowMeta
 *          the input row metadata
 * @param r
 *          the input row (data)
 * @return A row including the calculations, excluding the temporary values
 * @throws KettleValueException
 *           in case there is a calculation error.
 */
private Object[] calcFields(RowMetaInterface inputRowMeta, Object[] r) throws KettleValueException, KettleFileNotFoundException {
    // First copy the input data to the new result...
    Object[] calcData = RowDataUtil.resizeArray(r, data.getCalcRowMeta().size());
    for (int i = 0, index = inputRowMeta.size() + i; i < meta.getCalculation().length; i++, index++) {
        CalculatorMetaFunction fn = meta.getCalculation()[i];
        if (!Utils.isEmpty(fn.getFieldName())) {
            ValueMetaInterface targetMeta = data.getCalcRowMeta().getValueMeta(index);
            // Get the metadata & the data...
            ValueMetaInterface metaA = null;
            Object dataA = null;
            if (data.getFieldIndexes()[i].indexA >= 0) {
                metaA = data.getCalcRowMeta().getValueMeta(data.getFieldIndexes()[i].indexA);
                dataA = metaA.convertToNormalStorageType(calcData[data.getFieldIndexes()[i].indexA]);
                // We changed the storage type of the data and, thus, we need meta to have that information
                // We can't change the original meta as it refers to the original data!
                // So we clone and change the new one.
                metaA = metaA.clone();
                metaA.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
            }
            ValueMetaInterface metaB = null;
            Object dataB = null;
            if (data.getFieldIndexes()[i].indexB >= 0) {
                metaB = data.getCalcRowMeta().getValueMeta(data.getFieldIndexes()[i].indexB);
                dataB = metaB.convertToNormalStorageType(calcData[data.getFieldIndexes()[i].indexB]);
                // We changed the storage type of the data and, thus, we need meta to have that information
                // We can't change the original meta as it refers to the original data!
                // So we clone and change the new one.
                metaB = metaB.clone();
                metaB.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
            }
            ValueMetaInterface metaC = null;
            Object dataC = null;
            if (data.getFieldIndexes()[i].indexC >= 0) {
                metaC = data.getCalcRowMeta().getValueMeta(data.getFieldIndexes()[i].indexC);
                dataC = calcData[data.getFieldIndexes()[i].indexC];
            }
            int calcType = fn.getCalcType();
            // The data types are those of the first argument field, convert to the target field.
            // Exceptions:
            // - multiply can be string
            // - constant is string
            // - all date functions except add days/months
            // - hex encode / decodes
            int resultType;
            if (metaA != null) {
                resultType = metaA.getType();
            } else {
                resultType = ValueMetaInterface.TYPE_NONE;
            }
            switch(calcType) {
                case CalculatorMetaFunction.CALC_NONE:
                    break;
                case // Create a copy of field A
                CalculatorMetaFunction.CALC_COPY_OF_FIELD:
                    calcData[index] = dataA;
                    break;
                case // A + B
                CalculatorMetaFunction.CALC_ADD:
                    calcData[index] = ValueDataUtil.plus(metaA, dataA, metaB, dataB);
                    if (metaA.isString() || metaB.isString()) {
                        resultType = ValueMetaInterface.TYPE_STRING;
                    }
                    break;
                case // A - B
                CalculatorMetaFunction.CALC_SUBTRACT:
                    calcData[index] = ValueDataUtil.minus(metaA, dataA, metaB, dataB);
                    if (metaA.isDate()) {
                        resultType = ValueMetaInterface.TYPE_INTEGER;
                    }
                    break;
                case // A * B
                CalculatorMetaFunction.CALC_MULTIPLY:
                    calcData[index] = ValueDataUtil.multiply(metaA, dataA, metaB, dataB);
                    if (metaA.isString() || metaB.isString()) {
                        resultType = ValueMetaInterface.TYPE_STRING;
                    }
                    break;
                case // A / B
                CalculatorMetaFunction.CALC_DIVIDE:
                    calcData[index] = ValueDataUtil.divide(metaA, dataA, metaB, dataB, this);
                    break;
                case // A * A
                CalculatorMetaFunction.CALC_SQUARE:
                    calcData[index] = ValueDataUtil.multiply(metaA, dataA, metaA, dataA);
                    break;
                case // SQRT( A )
                CalculatorMetaFunction.CALC_SQUARE_ROOT:
                    calcData[index] = ValueDataUtil.sqrt(metaA, dataA);
                    break;
                case // 100 * A / B
                CalculatorMetaFunction.CALC_PERCENT_1:
                    calcData[index] = ValueDataUtil.percent1(metaA, dataA, metaB, dataB, this);
                    break;
                case // A - ( A * B / 100 )
                CalculatorMetaFunction.CALC_PERCENT_2:
                    calcData[index] = ValueDataUtil.percent2(metaA, dataA, metaB, dataB, this);
                    break;
                case // A + ( A * B / 100 )
                CalculatorMetaFunction.CALC_PERCENT_3:
                    calcData[index] = ValueDataUtil.percent3(metaA, dataA, metaB, dataB, this);
                    break;
                case // A + B * C
                CalculatorMetaFunction.CALC_COMBINATION_1:
                    calcData[index] = ValueDataUtil.combination1(metaA, dataA, metaB, dataB, metaC, dataC);
                    break;
                case // SQRT( A*A + B*B )
                CalculatorMetaFunction.CALC_COMBINATION_2:
                    calcData[index] = ValueDataUtil.combination2(metaA, dataA, metaB, dataB);
                    break;
                case // ROUND( A )
                CalculatorMetaFunction.CALC_ROUND_1:
                    calcData[index] = ValueDataUtil.round(metaA, dataA);
                    break;
                case // ROUND( A , B )
                CalculatorMetaFunction.CALC_ROUND_2:
                    calcData[index] = ValueDataUtil.round(metaA, dataA, metaB, dataB);
                    break;
                case // ROUND( A , B )
                CalculatorMetaFunction.CALC_ROUND_CUSTOM_1:
                    calcData[index] = ValueDataUtil.round(metaA, dataA, metaB.getNumber(dataB).intValue());
                    break;
                case // ROUND( A , B, C )
                CalculatorMetaFunction.CALC_ROUND_CUSTOM_2:
                    calcData[index] = ValueDataUtil.round(metaA, dataA, metaB, dataB, metaC.getNumber(dataC).intValue());
                    break;
                case // ROUND( A )
                CalculatorMetaFunction.CALC_ROUND_STD_1:
                    calcData[index] = ValueDataUtil.round(metaA, dataA, java.math.BigDecimal.ROUND_HALF_UP);
                    break;
                case // ROUND( A , B )
                CalculatorMetaFunction.CALC_ROUND_STD_2:
                    calcData[index] = ValueDataUtil.round(metaA, dataA, metaB, dataB, java.math.BigDecimal.ROUND_HALF_UP);
                    break;
                case // CEIL( A )
                CalculatorMetaFunction.CALC_CEIL:
                    calcData[index] = ValueDataUtil.ceil(metaA, dataA);
                    break;
                case // FLOOR( A )
                CalculatorMetaFunction.CALC_FLOOR:
                    calcData[index] = ValueDataUtil.floor(metaA, dataA);
                    break;
                case // Set field to constant value...
                CalculatorMetaFunction.CALC_CONSTANT:
                    // A string
                    calcData[index] = fn.getFieldA();
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Replace null values with another value
                CalculatorMetaFunction.CALC_NVL:
                    calcData[index] = ValueDataUtil.nvl(metaA, dataA, metaB, dataB);
                    break;
                case // Add B days to date field A
                CalculatorMetaFunction.CALC_ADD_DAYS:
                    calcData[index] = ValueDataUtil.addDays(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Add B hours to date field A
                CalculatorMetaFunction.CALC_ADD_HOURS:
                    calcData[index] = ValueDataUtil.addHours(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Add B minutes to date field A
                CalculatorMetaFunction.CALC_ADD_MINUTES:
                    calcData[index] = ValueDataUtil.addMinutes(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the year (Integer) of a date?
                CalculatorMetaFunction.CALC_YEAR_OF_DATE:
                    calcData[index] = ValueDataUtil.yearOfDate(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the month (Integer) of a date?
                CalculatorMetaFunction.CALC_MONTH_OF_DATE:
                    calcData[index] = ValueDataUtil.monthOfDate(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the day of year (Integer) of a date?
                CalculatorMetaFunction.CALC_DAY_OF_YEAR:
                    calcData[index] = ValueDataUtil.dayOfYear(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the day of month (Integer) of a date?
                CalculatorMetaFunction.CALC_DAY_OF_MONTH:
                    calcData[index] = ValueDataUtil.dayOfMonth(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the day of week (Integer) of a date?
                CalculatorMetaFunction.CALC_DAY_OF_WEEK:
                    calcData[index] = ValueDataUtil.dayOfWeek(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the week of year (Integer) of a date?
                CalculatorMetaFunction.CALC_WEEK_OF_YEAR:
                    calcData[index] = ValueDataUtil.weekOfYear(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the week of year (Integer) of a date ISO8601
                CalculatorMetaFunction.CALC_WEEK_OF_YEAR_ISO8601:
                    // style?
                    calcData[index] = ValueDataUtil.weekOfYearISO8601(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the year (Integer) of a date ISO8601 style?
                CalculatorMetaFunction.CALC_YEAR_OF_DATE_ISO8601:
                    calcData[index] = ValueDataUtil.yearOfDateISO8601(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Byte to Hex encode string field A
                CalculatorMetaFunction.CALC_BYTE_TO_HEX_ENCODE:
                    calcData[index] = ValueDataUtil.byteToHexEncode(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Hex to Byte decode string field A
                CalculatorMetaFunction.CALC_HEX_TO_BYTE_DECODE:
                    calcData[index] = ValueDataUtil.hexToByteDecode(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Char to Hex encode string field A
                CalculatorMetaFunction.CALC_CHAR_TO_HEX_ENCODE:
                    calcData[index] = ValueDataUtil.charToHexEncode(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Hex to Char decode string field A
                CalculatorMetaFunction.CALC_HEX_TO_CHAR_DECODE:
                    calcData[index] = ValueDataUtil.hexToCharDecode(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // CRC32
                CalculatorMetaFunction.CALC_CRC32:
                    calcData[index] = ValueDataUtil.checksumCRC32(metaA, dataA, meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // ADLER32
                CalculatorMetaFunction.CALC_ADLER32:
                    calcData[index] = ValueDataUtil.checksumAdler32(metaA, dataA, meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // MD5
                CalculatorMetaFunction.CALC_MD5:
                    calcData[index] = ValueDataUtil.createChecksum(metaA, dataA, "MD5", meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // SHA-1
                CalculatorMetaFunction.CALC_SHA1:
                    calcData[index] = ValueDataUtil.createChecksum(metaA, dataA, "SHA-1", meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // LEVENSHTEIN DISTANCE
                CalculatorMetaFunction.CALC_LEVENSHTEIN_DISTANCE:
                    calcData[index] = ValueDataUtil.getLevenshtein_Distance(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // METAPHONE
                CalculatorMetaFunction.CALC_METAPHONE:
                    calcData[index] = ValueDataUtil.get_Metaphone(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Double METAPHONE
                CalculatorMetaFunction.CALC_DOUBLE_METAPHONE:
                    calcData[index] = ValueDataUtil.get_Double_Metaphone(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // ABS( A )
                CalculatorMetaFunction.CALC_ABS:
                    calcData[index] = ValueDataUtil.abs(metaA, dataA);
                    break;
                case // Remove Time from field A
                CalculatorMetaFunction.CALC_REMOVE_TIME_FROM_DATE:
                    calcData[index] = ValueDataUtil.removeTimeFromDate(metaA, dataA);
                    break;
                case // DateA - DateB
                CalculatorMetaFunction.CALC_DATE_DIFF:
                    calcData[index] = ValueDataUtil.DateDiff(metaA, dataA, metaB, dataB, "d");
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // A + B + C
                CalculatorMetaFunction.CALC_ADD3:
                    calcData[index] = ValueDataUtil.plus3(metaA, dataA, metaB, dataB, metaC, dataC);
                    if (metaA.isString() || metaB.isString() || metaC.isString()) {
                        resultType = ValueMetaInterface.TYPE_STRING;
                    }
                    break;
                case // InitCap( A )
                CalculatorMetaFunction.CALC_INITCAP:
                    calcData[index] = ValueDataUtil.initCap(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // UpperCase( A )
                CalculatorMetaFunction.CALC_UPPER_CASE:
                    calcData[index] = ValueDataUtil.upperCase(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // UpperCase( A )
                CalculatorMetaFunction.CALC_LOWER_CASE:
                    calcData[index] = ValueDataUtil.lowerCase(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // escapeXML( A )
                CalculatorMetaFunction.CALC_MASK_XML:
                    calcData[index] = ValueDataUtil.escapeXML(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // CDATA( A )
                CalculatorMetaFunction.CALC_USE_CDATA:
                    calcData[index] = ValueDataUtil.useCDATA(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REMOVE CR FROM A
                CalculatorMetaFunction.CALC_REMOVE_CR:
                    calcData[index] = ValueDataUtil.removeCR(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REMOVE LF FROM A
                CalculatorMetaFunction.CALC_REMOVE_LF:
                    calcData[index] = ValueDataUtil.removeLF(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REMOVE CRLF FROM A
                CalculatorMetaFunction.CALC_REMOVE_CRLF:
                    calcData[index] = ValueDataUtil.removeCRLF(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REMOVE TAB FROM A
                CalculatorMetaFunction.CALC_REMOVE_TAB:
                    calcData[index] = ValueDataUtil.removeTAB(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // GET ONLY DIGITS FROM A
                CalculatorMetaFunction.CALC_GET_ONLY_DIGITS:
                    calcData[index] = ValueDataUtil.getDigits(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REMOVE DIGITS FROM A
                CalculatorMetaFunction.CALC_REMOVE_DIGITS:
                    calcData[index] = ValueDataUtil.removeDigits(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // RETURN THE LENGTH OF A
                CalculatorMetaFunction.CALC_STRING_LEN:
                    calcData[index] = ValueDataUtil.stringLen(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // LOAD CONTENT OF A FILE A IN A BLOB
                CalculatorMetaFunction.CALC_LOAD_FILE_CONTENT_BINARY:
                    calcData[index] = ValueDataUtil.loadFileContentInBinary(metaA, dataA, meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Add time B to a date A
                CalculatorMetaFunction.CALC_ADD_TIME_TO_DATE:
                    calcData[index] = ValueDataUtil.addTimeToDate(metaA, dataA, metaB, dataB, metaC, dataC);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // What is the quarter (Integer) of a date?
                CalculatorMetaFunction.CALC_QUARTER_OF_DATE:
                    calcData[index] = ValueDataUtil.quarterOfDate(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // variable substitution in string
                CalculatorMetaFunction.CALC_SUBSTITUTE_VARIABLE:
                    calcData[index] = environmentSubstitute(dataA.toString());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // UnescapeXML( A )
                CalculatorMetaFunction.CALC_UNESCAPE_XML:
                    calcData[index] = ValueDataUtil.unEscapeXML(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // EscapeHTML( A )
                CalculatorMetaFunction.CALC_ESCAPE_HTML:
                    calcData[index] = ValueDataUtil.escapeHTML(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // UnescapeHTML( A )
                CalculatorMetaFunction.CALC_UNESCAPE_HTML:
                    calcData[index] = ValueDataUtil.unEscapeHTML(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // EscapeSQL( A )
                CalculatorMetaFunction.CALC_ESCAPE_SQL:
                    calcData[index] = ValueDataUtil.escapeSQL(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DateWorkingDiff( A , B)
                CalculatorMetaFunction.CALC_DATE_WORKING_DIFF:
                    calcData[index] = ValueDataUtil.DateWorkingDiff(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Add B months to date field A
                CalculatorMetaFunction.CALC_ADD_MONTHS:
                    calcData[index] = ValueDataUtil.addMonths(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Check if file A is well formed
                CalculatorMetaFunction.CALC_CHECK_XML_FILE_WELL_FORMED:
                    calcData[index] = ValueDataUtil.isXMLFileWellFormed(metaA, dataA, meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Check if xml A is well formed
                CalculatorMetaFunction.CALC_CHECK_XML_WELL_FORMED:
                    calcData[index] = ValueDataUtil.isXMLWellFormed(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Get file encoding from a file A
                CalculatorMetaFunction.CALC_GET_FILE_ENCODING:
                    calcData[index] = ValueDataUtil.getFileEncoding(metaA, dataA, meta.isFailIfNoFile());
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DAMERAULEVENSHTEIN DISTANCE
                CalculatorMetaFunction.CALC_DAMERAU_LEVENSHTEIN:
                    calcData[index] = ValueDataUtil.getDamerauLevenshtein_Distance(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // NEEDLEMANWUNSH DISTANCE
                CalculatorMetaFunction.CALC_NEEDLEMAN_WUNSH:
                    calcData[index] = ValueDataUtil.getNeedlemanWunsch_Distance(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Jaro DISTANCE
                CalculatorMetaFunction.CALC_JARO:
                    calcData[index] = ValueDataUtil.getJaro_Similitude(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Jaro DISTANCE
                CalculatorMetaFunction.CALC_JARO_WINKLER:
                    calcData[index] = ValueDataUtil.getJaroWinkler_Similitude(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // SOUNDEX
                CalculatorMetaFunction.CALC_SOUNDEX:
                    calcData[index] = ValueDataUtil.get_SoundEx(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // REFINEDSOUNDEX
                CalculatorMetaFunction.CALC_REFINED_SOUNDEX:
                    calcData[index] = ValueDataUtil.get_RefinedSoundEx(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DateA - DateB (ms)
                CalculatorMetaFunction.CALC_DATE_DIFF_MSEC:
                    calcData[index] = ValueDataUtil.DateDiff(metaA, dataA, metaB, dataB, "ms");
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DateA - DateB (s)
                CalculatorMetaFunction.CALC_DATE_DIFF_SEC:
                    calcData[index] = ValueDataUtil.DateDiff(metaA, dataA, metaB, dataB, "s");
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DateA - DateB (mn)
                CalculatorMetaFunction.CALC_DATE_DIFF_MN:
                    calcData[index] = ValueDataUtil.DateDiff(metaA, dataA, metaB, dataB, "mn");
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // DateA - DateB (h)
                CalculatorMetaFunction.CALC_DATE_DIFF_HR:
                    calcData[index] = ValueDataUtil.DateDiff(metaA, dataA, metaB, dataB, "h");
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case CalculatorMetaFunction.CALC_HOUR_OF_DAY:
                    calcData[index] = ValueDataUtil.hourOfDay(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case CalculatorMetaFunction.CALC_MINUTE_OF_HOUR:
                    calcData[index] = ValueDataUtil.minuteOfHour(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case CalculatorMetaFunction.CALC_SECOND_OF_MINUTE:
                    calcData[index] = ValueDataUtil.secondOfMinute(metaA, dataA);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case // Add B seconds to date field A
                CalculatorMetaFunction.CALC_ADD_SECONDS:
                    calcData[index] = ValueDataUtil.addSeconds(metaA, dataA, metaB, dataB);
                    resultType = CalculatorMetaFunction.calcDefaultResultType[calcType];
                    break;
                case CalculatorMetaFunction.CALC_REMAINDER:
                    if (targetMeta.getType() != metaA.getType() || targetMeta.getType() != metaB.getType()) {
                        dataA = targetMeta.convertData(metaA, dataA);
                        metaA = targetMeta.clone();
                        dataB = targetMeta.convertData(metaB, dataB);
                        metaB = targetMeta.clone();
                    }
                    calcData[index] = ValueDataUtil.remainder(metaA, dataA, metaB, dataB);
                    resultType = targetMeta.getType();
                    break;
                default:
                    throw new KettleValueException(BaseMessages.getString(PKG, "Calculator.Log.UnknownCalculationType") + fn.getCalcType());
            }
            // 
            if (targetMeta.getType() == ValueMetaInterface.TYPE_NONE) {
                throw new KettleValueException(BaseMessages.getString(PKG, "Calculator.Log.NoType") + (i + 1) + " : " + fn.getFieldName() + " = " + fn.getCalcTypeDesc() + " / " + fn.getCalcTypeLongDesc());
            }
            // 
            if (calcData[index] != null) {
                if (targetMeta.getType() != resultType) {
                    ValueMetaInterface resultMeta;
                    try {
                        // clone() is not necessary as one data instance belongs to one step instance and no race condition occurs
                        resultMeta = data.getValueMetaFor(resultType, "result");
                    } catch (Exception exception) {
                        throw new KettleValueException("Error creating value");
                    }
                    resultMeta.setConversionMask(fn.getConversionMask());
                    resultMeta.setGroupingSymbol(fn.getGroupingSymbol());
                    resultMeta.setDecimalSymbol(fn.getDecimalSymbol());
                    resultMeta.setCurrencySymbol(fn.getCurrencySymbol());
                    try {
                        calcData[index] = targetMeta.convertData(resultMeta, calcData[index]);
                    } catch (Exception ex) {
                        throw new KettleValueException("resultType: " + resultType + "; targetMeta: " + targetMeta.getType(), ex);
                    }
                }
            }
        }
    }
    // 
    return RowDataUtil.removeItems(calcData, data.getTempIndexes());
}

Example 8 with KettleFileNotFoundException

use of org.pentaho.di.core.exception.KettleFileNotFoundException in project pentaho-kettle by pentaho.

the class ValueDataUtil method createChecksum.

/**
 * @param metaA
 *   The ValueMetaInterface
 * @param dataA
 *   Filename
 * @param type
 *   Algorithm to be used when computing the checksum (MD5 or SHA-1)
 * @param failIfNoFile
 *   Indicates if the transformation should fail if no file is found
 * @return File's checksum
 * @throws KettleFileNotFoundException
 */
public static String createChecksum(ValueMetaInterface metaA, Object dataA, String type, boolean failIfNoFile) throws KettleFileNotFoundException {
    if (dataA == null) {
        return null;
    }
    String md5Hash = null;
    FileObject file = null;
    InputStream in = null;
    try {
        file = KettleVFS.getFileObject(dataA.toString());
        throwsErrorOnFileNotFound(file);
        in = KettleVFS.getInputStream(file);
        int bytes = in.available();
        byte[] buffer = new byte[bytes];
        in.read(buffer);
        StringBuffer md5HashBuff = new StringBuffer(32);
        byte[] b = MessageDigest.getInstance(type).digest(buffer);
        int len = b.length;
        for (int x = 0; x < len; x++) {
            md5HashBuff.append(String.format("%02x", b[x]));
        }
        md5Hash = md5HashBuff.toString();
    } catch (KettleFileNotFoundException e) {
        if (failIfNoFile) {
            throw e;
        }
        log.debug(e.getMessage());
    } catch (Exception e) {
        log.debug(e.getMessage());
    } finally {
        IOUtils.closeQuietly(file);
        IOUtils.closeQuietly(in);
    }
    return md5Hash;
}