public boolean init(StepMetaInterface smi, StepDataInterface sdi) { meta = (RowGeneratorMeta) smi; data = (RowGeneratorData) sdi; if (super.init(smi, sdi)) { // Determine the number of rows to generate... data.rowLimit = Const.toLong(environmentSubstitute(meta.getRowLimit()), -1L); data.rowsWritten = 0L; if (data.rowLimit < 0L) // Unable to parse { logError(BaseMessages.getString(PKG, "RowGenerator.Wrong.RowLimit.Number")); return false; // fail } // Create a row (constants) with all the values in it... List<CheckResultInterface> remarks = new ArrayList<CheckResultInterface>(); // stores the errors... RowMetaAndData outputRow = buildRow(meta, remarks, getStepname()); if (!remarks.isEmpty()) { for (int i = 0; i < remarks.size(); i++) { CheckResult cr = (CheckResult) remarks.get(i); logError(cr.getText()); } return false; } data.outputRowData = outputRow.getData(); data.outputRowMeta = outputRow.getRowMeta(); return true; } return false; }
public Object clone() { RowGeneratorMeta retval = (RowGeneratorMeta) super.clone(); int nrfields = fieldName.length; retval.allocate(nrfields); for (int i = 0; i < nrfields; i++) { retval.fieldName[i] = fieldName[i]; retval.fieldType[i] = fieldType[i]; retval.fieldFormat[i] = fieldFormat[i]; retval.currency[i] = currency[i]; retval.decimal[i] = decimal[i]; retval.group[i] = group[i]; retval.value[i] = value[i]; retval.fieldLength[i] = fieldLength[i]; retval.fieldPrecision[i] = fieldPrecision[i]; retval.setEmptyString[i] = setEmptyString[i]; } return retval; }
public static final RowMetaAndData buildRow( RowGeneratorMeta meta, List<CheckResultInterface> remarks, String origin) { RowMetaInterface rowMeta = new RowMeta(); Object[] rowData = RowDataUtil.allocateRowData(meta.getFieldName().length); for (int i = 0; i < meta.getFieldName().length; i++) { int valtype = ValueMeta.getType(meta.getFieldType()[i]); if (meta.getFieldName()[i] != null) { ValueMetaInterface valueMeta = new ValueMeta(meta.getFieldName()[i], valtype); // build a value! valueMeta.setLength(meta.getFieldLength()[i]); valueMeta.setPrecision(meta.getFieldPrecision()[i]); valueMeta.setConversionMask(meta.getFieldFormat()[i]); valueMeta.setGroupingSymbol(meta.getGroup()[i]); valueMeta.setDecimalSymbol(meta.getDecimal()[i]); valueMeta.setOrigin(origin); ValueMetaInterface stringMeta = valueMeta.clone(); stringMeta.setType(ValueMetaInterface.TYPE_STRING); String stringValue = meta.getValue()[i]; // If the value is empty: consider it to be NULL. if (Const.isEmpty(stringValue)) { rowData[i] = null; if (valueMeta.getType() == ValueMetaInterface.TYPE_NONE) { String message = BaseMessages.getString( PKG, "RowGenerator.CheckResult.SpecifyTypeError", valueMeta.getName(), stringValue); remarks.add(new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } } else { // Convert the data from String to the specified type ... // try { rowData[i] = valueMeta.convertData(stringMeta, stringValue); } catch (KettleValueException e) { switch (valueMeta.getType()) { case ValueMetaInterface.TYPE_NUMBER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Number", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_DATE: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Date", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_INTEGER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Integer", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_BIGNUMBER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.BigNumber", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; default: // Boolean and binary don't throw errors normally, so it's probably an unspecified // error problem... { String message = BaseMessages.getString( PKG, "RowGenerator.CheckResult.SpecifyTypeError", valueMeta.getName(), stringValue); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; } } } // Now add value to the row! // This is in fact a copy from the fields row, but now with data. rowMeta.addValueMeta(valueMeta); } } return new RowMetaAndData(rowMeta, rowData); }
/** Test case for Constant step. Row generator attached to a constant step. */ public void testConstant1() throws Exception { KettleEnvironment.init(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("constanttest1"); PluginRegistry registry = PluginRegistry.getInstance(); // // create a row generator step... // String rowGeneratorStepname = "row generator step"; RowGeneratorMeta rm = new RowGeneratorMeta(); // Set the information of the row generator. String rowGeneratorPid = registry.getPluginId(StepPluginType.class, rm); StepMeta rowGeneratorStep = new StepMeta(rowGeneratorPid, rowGeneratorStepname, (StepMetaInterface) rm); transMeta.addStep(rowGeneratorStep); // // Generate 1 empty row // String fieldName[] = {}; String type[] = {}; String value[] = {}; String fieldFormat[] = {}; String group[] = {}; String decimal[] = {}; int intDummies[] = {}; rm.setDefault(); rm.setFieldName(fieldName); rm.setFieldType(type); rm.setValue(value); rm.setFieldLength(intDummies); rm.setFieldPrecision(intDummies); rm.setRowLimit("1"); rm.setFieldFormat(fieldFormat); rm.setGroup(group); rm.setDecimal(decimal); // // Add constant step. // String constStepname1 = "constant 1"; ConstantMeta cnst1 = new ConstantMeta(); String fieldName1[] = { "boolean1", "boolean2", "boolean3", "boolean4", "boolean5", "boolean6", "boolean7", "string1", "string2", "string3", "integer1", "integer2", "integer3", "integer4", "number1", "number2", "number3", "number4", }; String type1[] = { "boolean", "Boolean", "bOOLEAN", "BOOLEAN", "boolean", "boolean", "boolean", "string", "string", "String", "integer", "integer", "integer", "integer", "number", "number", "number", "number" }; String value1[] = { "Y", "T", "a", "TRUE", "0", "9", "", "AAAAAAAAAAAAAA", " ", "", "-100", "0", "212", "", "-100.2", "0.0", "212.23", "" }; String fieldFormat1[] = { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" }; String group1[] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", ",", ",", ",", ","}; String decimal1[] = { "", "", "", "", "", "", "", "", "", "", "", "", "", "", ".", ".", ".", "." }; String currency[] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""}; int intDummies1[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; cnst1.setFieldName(fieldName1); cnst1.setFieldType(type1); cnst1.setValue(value1); cnst1.setFieldLength(intDummies1); cnst1.setFieldPrecision(intDummies1); cnst1.setFieldFormat(fieldFormat1); cnst1.setGroup(group1); cnst1.setDecimal(decimal1); cnst1.setCurrency(currency); String addSeqPid1 = registry.getPluginId(StepPluginType.class, cnst1); StepMeta addSeqStep1 = new StepMeta(addSeqPid1, constStepname1, (StepMetaInterface) cnst1); transMeta.addStep(addSeqStep1); TransHopMeta hi1 = new TransHopMeta(rowGeneratorStep, addSeqStep1); transMeta.addTransHop(hi1); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(constStepname1, 0); RowStepCollector endRc = new RowStepCollector(); si.addRowListener(endRc); trans.startThreads(); trans.waitUntilFinished(); // Now check whether the output is still as we expect. List<RowMetaAndData> goldenImageRows = createResultData1(); List<RowMetaAndData> resultRows1 = endRc.getRowsWritten(); checkRows(resultRows1, goldenImageRows); }
public void testCalculator1() throws Exception { KettleEnvironment.init(); PluginRegistry registry = PluginRegistry.getInstance(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("calculatortest1"); // // create a row generator step... // String rowGeneratorStepname = "row generator step"; RowGeneratorMeta rm = new RowGeneratorMeta(); // Set the information of the row generator. String rowGeneratorPid = registry.getPluginId(StepPluginType.class, rm); StepMeta rowGeneratorStep = new StepMeta(rowGeneratorPid, rowGeneratorStepname, rm); transMeta.addStep(rowGeneratorStep); // // Generate 1 empty row // String[] strDummies = {}; int[] intDummies = {}; rm.setDefault(); rm.setFieldName(strDummies); rm.setFieldType(strDummies); rm.setValue(strDummies); rm.setFieldLength(intDummies); rm.setFieldPrecision(intDummies); rm.setRowLimit("1"); rm.setFieldFormat(strDummies); rm.setGroup(strDummies); rm.setDecimal(strDummies); // // Add calculator step. // String calculatorStepname1 = "calculator 1"; CalculatorMeta calc1 = new CalculatorMeta(); CalculatorMetaFunction[] calculations = new CalculatorMetaFunction[] { new CalculatorMetaFunction( "timestamp1", // fieldName CalculatorMetaFunction.CALC_CONSTANT, // calctype "1970-01-01 00:00:00.100100", // fieldA "", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_TIMESTAMP, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ), new CalculatorMetaFunction( "int1", // fieldName CalculatorMetaFunction.CALC_CONSTANT, // calctype "1", // fieldA "", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_INTEGER, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ), new CalculatorMetaFunction( "timestamp plus 1 day", // fieldName CalculatorMetaFunction.CALC_ADD_DAYS, // calctype "timestamp1", // fieldA "int1", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_DATE, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ) }; calc1.setCalculation(calculations); // String calculatorPid1 = registry.getPluginId(StepPluginType.class, calc1); StepMeta calcualtorStep1 = new StepMeta(calculatorPid1, calculatorStepname1, calc1); transMeta.addStep(calcualtorStep1); // TransHopMeta hi1 = new TransHopMeta(rowGeneratorStep, calcualtorStep1); transMeta.addTransHop(hi1); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(calculatorStepname1, 0); RowStepCollector endRc = new RowStepCollector(); si.addRowListener(endRc); trans.startThreads(); trans.waitUntilFinished(); // Now check whether the output is still as we expect. List<RowMetaAndData> goldenImageRows = createResultData1(); List<RowMetaAndData> resultRows1 = endRc.getRowsWritten(); checkRows(resultRows1, goldenImageRows); }