public void readRep(
Repository rep, ObjectId id_step, List<DatabaseMeta> databases, Map<String, Counter> counters)
throws KettleException {
String method = rep.getStepAttributeString(id_step, "specification_method");
specificationMethod = ObjectLocationSpecificationMethod.getSpecificationMethodByCode(method);
String transId = rep.getStepAttributeString(id_step, "trans_object_id");
transObjectId = Const.isEmpty(transId) ? null : new StringObjectId(transId);
transName = rep.getStepAttributeString(id_step, "trans_name"); // $NON-NLS-1$
fileName = rep.getStepAttributeString(id_step, "filename"); // $NON-NLS-1$
directoryPath = rep.getStepAttributeString(id_step, "directory_path"); // $NON-NLS-1$
// Backward compatibility check for object specification
//
checkObjectLocationSpecificationMethod();
inputMappings.clear();
outputMappings.clear();
int nrInput = rep.countNrStepAttributes(id_step, "input_field"); // $NON-NLS-1$
int nrOutput = rep.countNrStepAttributes(id_step, "output_field"); // $NON-NLS-1$
// Backward compatibility...
//
if (nrInput > 0 || nrOutput > 0) {
MappingIODefinition inputMappingDefinition = new MappingIODefinition();
inputMappingDefinition.setMainDataPath(true);
for (int i = 0; i < nrInput; i++) {
String inputField = rep.getStepAttributeString(id_step, i, "input_field"); // $NON-NLS-1$
String inputMapping =
rep.getStepAttributeString(id_step, i, "input_mapping"); // $NON-NLS-1$
inputMappingDefinition
.getValueRenames()
.add(new MappingValueRename(inputField, inputMapping));
}
MappingIODefinition outputMappingDefinition = new MappingIODefinition();
outputMappingDefinition.setMainDataPath(true);
for (int i = 0; i < nrOutput; i++) {
String outputField = rep.getStepAttributeString(id_step, i, "output_field"); // $NON-NLS-1$
String outputMapping =
rep.getStepAttributeString(id_step, i, "output_mapping"); // $NON-NLS-1$
outputMappingDefinition
.getValueRenames()
.add(new MappingValueRename(outputMapping, outputField));
}
// Don't forget to add these to the input and output mapping
// definitions...
//
inputMappings.add(inputMappingDefinition);
outputMappings.add(outputMappingDefinition);
// The default is to have no mapping parameters: the concept didn't exist
// before.
mappingParameters = new MappingParameters();
} else {
nrInput = rep.countNrStepAttributes(id_step, "input_main_path"); // $NON-NLS-1$
nrOutput = rep.countNrStepAttributes(id_step, "output_main_path"); // $NON-NLS-1$
for (int i = 0; i < nrInput; i++) {
inputMappings.add(new MappingIODefinition(rep, id_step, "input_", i));
}
for (int i = 0; i < nrOutput; i++) {
outputMappings.add(new MappingIODefinition(rep, id_step, "output_", i));
}
mappingParameters = new MappingParameters(rep, id_step);
}
allowingMultipleInputs =
rep.getStepAttributeBoolean(id_step, 0, "allow_multiple_input", inputMappings.size() > 1);
allowingMultipleOutputs =
rep.getStepAttributeBoolean(id_step, 0, "allow_multiple_output", outputMappings.size() > 1);
}
public void loadXML(Node stepnode, List<DatabaseMeta> databases, Map<String, Counter> counters)
throws KettleXMLException {
try {
String method = XMLHandler.getTagValue(stepnode, "specification_method");
specificationMethod = ObjectLocationSpecificationMethod.getSpecificationMethodByCode(method);
String transId = XMLHandler.getTagValue(stepnode, "trans_object_id");
transObjectId = Const.isEmpty(transId) ? null : new StringObjectId(transId);
transName = XMLHandler.getTagValue(stepnode, "trans_name"); // $NON-NLS-1$
fileName = XMLHandler.getTagValue(stepnode, "filename"); // $NON-NLS-1$
directoryPath = XMLHandler.getTagValue(stepnode, "directory_path"); // $NON-NLS-1$
// Backward compatibility check for object specification
//
checkObjectLocationSpecificationMethod();
Node mappingsNode = XMLHandler.getSubNode(stepnode, "mappings"); // $NON-NLS-1$
inputMappings.clear();
outputMappings.clear();
if (mappingsNode != null) {
// Read all the input mapping definitions...
//
Node inputNode = XMLHandler.getSubNode(mappingsNode, "input"); // $NON-NLS-1$
int nrInputMappings =
XMLHandler.countNodes(inputNode, MappingIODefinition.XML_TAG); // $NON-NLS-1$
for (int i = 0; i < nrInputMappings; i++) {
Node mappingNode = XMLHandler.getSubNodeByNr(inputNode, MappingIODefinition.XML_TAG, i);
MappingIODefinition inputMappingDefinition = new MappingIODefinition(mappingNode);
inputMappings.add(inputMappingDefinition);
}
Node outputNode = XMLHandler.getSubNode(mappingsNode, "output"); // $NON-NLS-1$
int nrOutputMappings =
XMLHandler.countNodes(outputNode, MappingIODefinition.XML_TAG); // $NON-NLS-1$
for (int i = 0; i < nrOutputMappings; i++) {
Node mappingNode = XMLHandler.getSubNodeByNr(outputNode, MappingIODefinition.XML_TAG, i);
MappingIODefinition outputMappingDefinition = new MappingIODefinition(mappingNode);
outputMappings.add(outputMappingDefinition);
}
// Load the mapping parameters too..
//
Node mappingParametersNode = XMLHandler.getSubNode(mappingsNode, MappingParameters.XML_TAG);
mappingParameters = new MappingParameters(mappingParametersNode);
} else {
// backward compatibility...
//
Node inputNode = XMLHandler.getSubNode(stepnode, "input"); // $NON-NLS-1$
Node outputNode = XMLHandler.getSubNode(stepnode, "output"); // $NON-NLS-1$
int nrInput = XMLHandler.countNodes(inputNode, "connector"); // $NON-NLS-1$
int nrOutput = XMLHandler.countNodes(outputNode, "connector"); // $NON-NLS-1$
// null means: auto-detect
//
MappingIODefinition inputMappingDefinition = new MappingIODefinition();
inputMappingDefinition.setMainDataPath(true);
for (int i = 0; i < nrInput; i++) {
Node inputConnector = XMLHandler.getSubNodeByNr(inputNode, "connector", i); // $NON-NLS-1$
String inputField = XMLHandler.getTagValue(inputConnector, "field"); // $NON-NLS-1$
String inputMapping = XMLHandler.getTagValue(inputConnector, "mapping"); // $NON-NLS-1$
inputMappingDefinition
.getValueRenames()
.add(new MappingValueRename(inputField, inputMapping));
}
// null means: auto-detect
//
MappingIODefinition outputMappingDefinition = new MappingIODefinition();
outputMappingDefinition.setMainDataPath(true);
for (int i = 0; i < nrOutput; i++) {
Node outputConnector =
XMLHandler.getSubNodeByNr(outputNode, "connector", i); // $NON-NLS-1$
String outputField = XMLHandler.getTagValue(outputConnector, "field"); // $NON-NLS-1$
String outputMapping = XMLHandler.getTagValue(outputConnector, "mapping"); // $NON-NLS-1$
outputMappingDefinition
.getValueRenames()
.add(new MappingValueRename(outputMapping, outputField));
}
// Don't forget to add these to the input and output mapping
// definitions...
//
inputMappings.add(inputMappingDefinition);
outputMappings.add(outputMappingDefinition);
// The default is to have no mapping parameters: the concept didn't
// exist before.
//
mappingParameters = new MappingParameters();
}
String multiInput = XMLHandler.getTagValue(stepnode, "allow_multiple_input");
allowingMultipleInputs =
Const.isEmpty(multiInput) ? inputMappings.size() > 1 : "Y".equalsIgnoreCase(multiInput);
String multiOutput = XMLHandler.getTagValue(stepnode, "allow_multiple_output");
allowingMultipleOutputs =
Const.isEmpty(multiOutput)
? outputMappings.size() > 1
: "Y".equalsIgnoreCase(multiOutput);
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(
PKG, "MappingMeta.Exception.ErrorLoadingTransformationStepFromXML"),
e); //$NON-NLS-1$
}
}
