public static String getValueMetaName(int type) {
for (PluginInterface plugin : pluginRegistry.getPlugins(ValueMetaPluginType.class)) {
if (Integer.toString(type).equals(plugin.getIds()[0])) {
return plugin.getName();
}
}
return "-";
}
public static int getIdForValueMeta(String valueMetaName) {
for (PluginInterface plugin : pluginRegistry.getPlugins(ValueMetaPluginType.class)) {
if (valueMetaName != null && valueMetaName.equalsIgnoreCase(plugin.getName())) {
return Integer.valueOf(plugin.getIds()[0]);
}
}
return ValueMetaInterface.TYPE_NONE;
}
public static String[] getAllValueMetaNames() {
List<String> strings = new ArrayList<String>();
List<PluginInterface> plugins = pluginRegistry.getPlugins(ValueMetaPluginType.class);
for (PluginInterface plugin : plugins) {
String id = plugin.getIds()[0];
if (!("0".equals(id))) {
strings.add(plugin.getName());
}
}
return strings.toArray(new String[strings.size()]);
}
public static String[] getValueMetaNames() {
List<String> strings = new ArrayList<String>();
List<PluginInterface> plugins = pluginRegistry.getPlugins(ValueMetaPluginType.class);
for (PluginInterface plugin : plugins) {
int id = Integer.valueOf(plugin.getIds()[0]);
if (id > 0 && id != ValueMetaInterface.TYPE_SERIALIZABLE) {
strings.add(plugin.getName());
}
}
return strings.toArray(new String[strings.size()]);
}
@BeforeClass
public static void setUpBeforeClass() throws Exception {
KettleClientEnvironment.init();
dbMap.put(DatabaseInterface.class, DBMockIface.class.getName());
dbMap.put(InfobrightDatabaseMeta.class, InfobrightDatabaseMeta.class.getName());
PluginRegistry preg = PluginRegistry.getInstance();
PluginInterface mockDbPlugin = mock(PluginInterface.class);
when(mockDbPlugin.matches(anyString())).thenReturn(true);
when(mockDbPlugin.isNativePlugin()).thenReturn(true);
when(mockDbPlugin.getMainType())
.thenAnswer(
new Answer<Class<?>>() {
@Override
public Class<?> answer(InvocationOnMock invocation) throws Throwable {
return DatabaseInterface.class;
}
});
when(mockDbPlugin.getPluginType())
.thenAnswer(
new Answer<Class<? extends PluginTypeInterface>>() {
@Override
public Class<? extends PluginTypeInterface> answer(InvocationOnMock invocation)
throws Throwable {
return DatabasePluginType.class;
}
});
when(mockDbPlugin.getIds()).thenReturn(new String[] {"Oracle", "mock-db-id"});
when(mockDbPlugin.getName()).thenReturn("mock-db-name");
when(mockDbPlugin.getClassMap()).thenReturn(dbMap);
preg.registerPlugin(DatabasePluginType.class, mockDbPlugin);
}
@Override
protected Button createHelpButton(Shell shell, StepMeta stepMeta, PluginInterface plugin) {
plugin.setDocumentationUrl(
"https://github.com/graphiq-data/pdi-uniquelist-plugin/blob/master/help.md");
return super.createHelpButton(shell, stepMeta, plugin);
}
public void dataNodeToElement(final DataNode rootNode, final RepositoryElementInterface element)
throws KettleException {
TransMeta transMeta = (TransMeta) element;
List<String> privateTransformationDatabases = null;
// read the private databases
DataNode privateDatabases = rootNode.getNode(NODE_TRANS_PRIVATE_DATABASES);
// if we have node than we use new format we could remove unexpected node
if (privateDatabases != null) {
privateTransformationDatabases = new ArrayList<String>();
for (DataNode privateDatabase : privateDatabases.getNodes()) {
privateTransformationDatabases.add(privateDatabase.getName());
}
}
transMeta.setPrivateTransformationDatabases(privateTransformationDatabases);
// read the steps...
//
DataNode stepsNode = rootNode.getNode(NODE_STEPS);
for (DataNode stepNode : stepsNode.getNodes()) {
StepMeta stepMeta = new StepMeta(new StringObjectId(stepNode.getId().toString()));
stepMeta.setParentTransMeta(transMeta); // for tracing, retain hierarchy
// Read the basics
//
stepMeta.setName(getString(stepNode, PROP_NAME));
if (stepNode.hasProperty(PROP_DESCRIPTION)) {
stepMeta.setDescription(getString(stepNode, PROP_DESCRIPTION));
}
stepMeta.setDistributes(stepNode.getProperty(PROP_STEP_DISTRIBUTE).getBoolean());
DataProperty rowDistributionProperty = stepNode.getProperty(PROP_STEP_ROW_DISTRIBUTION);
String rowDistributionCode =
rowDistributionProperty == null ? null : rowDistributionProperty.getString();
RowDistributionInterface rowDistribution =
PluginRegistry.getInstance()
.loadClass(
RowDistributionPluginType.class,
rowDistributionCode,
RowDistributionInterface.class);
stepMeta.setRowDistribution(rowDistribution);
stepMeta.setDraw(stepNode.getProperty(PROP_STEP_GUI_DRAW).getBoolean());
int copies = (int) stepNode.getProperty(PROP_STEP_COPIES).getLong();
String copiesString =
stepNode.getProperty(PROP_STEP_COPIES_STRING) != null
? stepNode.getProperty(PROP_STEP_COPIES_STRING).getString()
: StringUtils.EMPTY;
if (!Const.isEmpty(copiesString)) {
stepMeta.setCopiesString(copiesString);
} else {
stepMeta.setCopies(copies); // for backward compatibility
}
int x = (int) stepNode.getProperty(PROP_STEP_GUI_LOCATION_X).getLong();
int y = (int) stepNode.getProperty(PROP_STEP_GUI_LOCATION_Y).getLong();
stepMeta.setLocation(x, y);
// Load the group attributes map
//
AttributesMapUtil.loadAttributesMap(stepNode, stepMeta);
String stepType = getString(stepNode, PROP_STEP_TYPE);
// Create a new StepMetaInterface object...
//
PluginRegistry registry = PluginRegistry.getInstance();
PluginInterface stepPlugin = registry.findPluginWithId(StepPluginType.class, stepType);
StepMetaInterface stepMetaInterface = null;
if (stepPlugin != null) {
stepMetaInterface = (StepMetaInterface) registry.loadClass(stepPlugin);
stepType =
stepPlugin.getIds()[0]; // revert to the default in case we loaded an alternate version
} else {
stepMeta.setStepMetaInterface(
(StepMetaInterface) new MissingTrans(stepMeta.getName(), stepType));
transMeta.addMissingTrans((MissingTrans) stepMeta.getStepMetaInterface());
}
stepMeta.setStepID(stepType);
// Read the metadata from the repository too...
//
RepositoryProxy proxy = new RepositoryProxy(stepNode.getNode(NODE_STEP_CUSTOM));
if (!stepMeta.isMissing()) {
readRepCompatibleStepMeta(stepMetaInterface, proxy, null, transMeta.getDatabases());
stepMetaInterface.readRep(proxy, transMeta.getMetaStore(), null, transMeta.getDatabases());
stepMeta.setStepMetaInterface(stepMetaInterface);
}
// Get the partitioning as well...
StepPartitioningMeta stepPartitioningMeta = new StepPartitioningMeta();
if (stepNode.hasProperty(PROP_PARTITIONING_SCHEMA)) {
String partSchemaId =
stepNode.getProperty(PROP_PARTITIONING_SCHEMA).getRef().getId().toString();
String schemaName =
repo.loadPartitionSchema(new StringObjectId(partSchemaId), null).getName();
stepPartitioningMeta.setPartitionSchemaName(schemaName);
String methodCode = getString(stepNode, PROP_PARTITIONING_METHOD);
stepPartitioningMeta.setMethod(StepPartitioningMeta.getMethod(methodCode));
if (stepPartitioningMeta.getPartitioner() != null) {
proxy = new RepositoryProxy(stepNode.getNode(NODE_PARTITIONER_CUSTOM));
stepPartitioningMeta.getPartitioner().loadRep(proxy, null);
}
stepPartitioningMeta.hasChanged(true);
}
stepMeta.setStepPartitioningMeta(stepPartitioningMeta);
stepMeta
.getStepPartitioningMeta()
.setPartitionSchemaAfterLoading(transMeta.getPartitionSchemas());
// Get the cluster schema name
String clusterSchemaName = getString(stepNode, PROP_CLUSTER_SCHEMA);
stepMeta.setClusterSchemaName(clusterSchemaName);
if (clusterSchemaName != null && transMeta.getClusterSchemas() != null) {
// Get the cluster schema from the given name
for (ClusterSchema clusterSchema : transMeta.getClusterSchemas()) {
if (clusterSchema.getName().equals(clusterSchemaName)) {
stepMeta.setClusterSchema(clusterSchema);
break;
}
}
}
transMeta.addStep(stepMeta);
}
for (DataNode stepNode : stepsNode.getNodes()) {
ObjectId stepObjectId = new StringObjectId(stepNode.getId().toString());
StepMeta stepMeta = StepMeta.findStep(transMeta.getSteps(), stepObjectId);
// Also load the step error handling metadata
//
if (stepNode.hasProperty(PROP_STEP_ERROR_HANDLING_SOURCE_STEP)) {
StepErrorMeta meta = new StepErrorMeta(transMeta, stepMeta);
meta.setTargetStep(
StepMeta.findStep(
transMeta.getSteps(),
stepNode.getProperty(PROP_STEP_ERROR_HANDLING_TARGET_STEP).getString()));
meta.setEnabled(stepNode.getProperty(PROP_STEP_ERROR_HANDLING_IS_ENABLED).getBoolean());
meta.setNrErrorsValuename(getString(stepNode, PROP_STEP_ERROR_HANDLING_NR_VALUENAME));
meta.setErrorDescriptionsValuename(
getString(stepNode, PROP_STEP_ERROR_HANDLING_DESCRIPTIONS_VALUENAME));
meta.setErrorFieldsValuename(
getString(stepNode, PROP_STEP_ERROR_HANDLING_FIELDS_VALUENAME));
meta.setErrorCodesValuename(getString(stepNode, PROP_STEP_ERROR_HANDLING_CODES_VALUENAME));
meta.setMaxErrors(getString(stepNode, PROP_STEP_ERROR_HANDLING_MAX_ERRORS));
meta.setMaxPercentErrors(getString(stepNode, PROP_STEP_ERROR_HANDLING_MAX_PCT_ERRORS));
meta.setMinPercentRows(getString(stepNode, PROP_STEP_ERROR_HANDLING_MIN_PCT_ROWS));
meta.getSourceStep().setStepErrorMeta(meta); // a bit of a trick, I know.
}
}
// Have all StreamValueLookups, etc. reference the correct source steps...
//
for (int i = 0; i < transMeta.nrSteps(); i++) {
StepMeta stepMeta = transMeta.getStep(i);
StepMetaInterface sii = stepMeta.getStepMetaInterface();
if (sii != null) {
sii.searchInfoAndTargetSteps(transMeta.getSteps());
}
}
// Read the notes...
//
DataNode notesNode = rootNode.getNode(NODE_NOTES);
int nrNotes = (int) notesNode.getProperty(PROP_NR_NOTES).getLong();
for (DataNode noteNode : notesNode.getNodes()) {
String xml = getString(noteNode, PROP_XML);
transMeta.addNote(
new NotePadMeta(
XMLHandler.getSubNode(XMLHandler.loadXMLString(xml), NotePadMeta.XML_TAG)));
}
if (transMeta.nrNotes() != nrNotes) {
throw new KettleException(
"The number of notes read ["
+ transMeta.nrNotes()
+ "] was not the number we expected ["
+ nrNotes
+ "]");
}
// Read the hops...
//
DataNode hopsNode = rootNode.getNode(NODE_HOPS);
int nrHops = (int) hopsNode.getProperty(PROP_NR_HOPS).getLong();
for (DataNode hopNode : hopsNode.getNodes()) {
String stepFromName = getString(hopNode, TRANS_HOP_FROM);
String stepToName = getString(hopNode, TRANS_HOP_TO);
boolean enabled = true;
if (hopNode.hasProperty(TRANS_HOP_ENABLED)) {
enabled = hopNode.getProperty(TRANS_HOP_ENABLED).getBoolean();
}
StepMeta stepFrom = StepMeta.findStep(transMeta.getSteps(), stepFromName);
StepMeta stepTo = StepMeta.findStep(transMeta.getSteps(), stepToName);
// Make sure to only accept valid hops PDI-5519
//
if (stepFrom != null && stepTo != null) {
transMeta.addTransHop(new TransHopMeta(stepFrom, stepTo, enabled));
}
}
if (transMeta.nrTransHops() != nrHops) {
throw new KettleException(
"The number of hops read ["
+ transMeta.nrTransHops()
+ "] was not the number we expected ["
+ nrHops
+ "]");
}
// Load the details at the end, to make sure we reference the databases correctly, etc.
//
loadTransformationDetails(rootNode, transMeta);
transMeta.eraseParameters();
DataNode paramsNode = rootNode.getNode(NODE_PARAMETERS);
int count = (int) paramsNode.getProperty(PROP_NR_PARAMETERS).getLong();
for (int idx = 0; idx < count; idx++) {
DataNode paramNode = paramsNode.getNode(TRANS_PARAM_PREFIX + idx);
String key = getString(paramNode, PARAM_KEY);
String def = getString(paramNode, PARAM_DEFAULT);
String desc = getString(paramNode, PARAM_DESC);
transMeta.addParameterDefinition(key, def, desc);
}
transMeta.activateParameters();
}