public void loadXML(
Node entrynode,
List<DatabaseMeta> databases,
List<SlaveServer> slaveServers,
Repository rep,
IMetaStore metaStore)
throws KettleXMLException {
try {
super.loadXML(entrynode, databases, slaveServers);
schemaname = XMLHandler.getTagValue(entrynode, "schemaname");
tablename = XMLHandler.getTagValue(entrynode, "tablename");
filename = XMLHandler.getTagValue(entrynode, "filename");
separator = XMLHandler.getTagValue(entrynode, "separator");
enclosed = XMLHandler.getTagValue(entrynode, "enclosed");
lineterminated = XMLHandler.getTagValue(entrynode, "lineterminated");
limitlines = XMLHandler.getTagValue(entrynode, "limitlines");
listcolumn = XMLHandler.getTagValue(entrynode, "listcolumn");
highpriority = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "highpriority"));
optionenclosed = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "optionenclosed"));
outdumpvalue = Const.toInt(XMLHandler.getTagValue(entrynode, "outdumpvalue"), -1);
iffileexists = Const.toInt(XMLHandler.getTagValue(entrynode, "iffileexists"), -1);
String dbname = XMLHandler.getTagValue(entrynode, "connection");
connection = DatabaseMeta.findDatabase(databases, dbname);
addfiletoresult = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "addfiletoresult"));
} catch (KettleException e) {
throw new KettleXMLException(
"Unable to load job entry of type 'table exists' from XML node", e);
}
}
private void readData(Node stepnode) throws KettleXMLException {
try {
Node fields = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
int nrfields = XMLHandler.countNodes(fields, "field"); // $NON-NLS-1$
allocate(nrfields);
for (int i = 0; i < nrfields; i++) {
Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i); // $NON-NLS-1$
fieldName[i] = XMLHandler.getTagValue(fnode, "name"); // $NON-NLS-1$
fieldType[i] = ValueMeta.getType(XMLHandler.getTagValue(fnode, "type")); // $NON-NLS-1$
String slength = XMLHandler.getTagValue(fnode, "length"); // $NON-NLS-1$
String sprecision = XMLHandler.getTagValue(fnode, "precision"); // $NON-NLS-1$
fieldLength[i] = Const.toInt(slength, -1);
fieldPrecision[i] = Const.toInt(sprecision, -1);
}
selectingAndSortingUnspecifiedFields =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(fields, "select_unspecified"));
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "MappingInputMeta.Exception.UnableToLoadStepInfoFromXML"),
e); //$NON-NLS-1$
}
}
@Override
public void loadPage(Map<String, List<String>> parameterHolder) throws KettlePageException {
try {
JSONArray fields = XMLHandler.getPageRows(parameterHolder, fid("fields"));
int nrfields = fields.size();
allocate(nrfields);
for (int i = 0; i < nrfields; i++) {
JSONObject field = (JSONObject) fields.get(i);
fieldName[i] = (String) field.get("fieldName");
fieldType[i] = (String) field.get("fieldType");
fieldFormat[i] = (String) field.get("fieldFormat");
currency[i] = (String) field.get("currency");
decimal[i] = (String) field.get("decimal");
group[i] = (String) field.get("group");
value[i] = (String) field.get("value");
fieldLength[i] = Const.toInt(String.valueOf(field.get("fieldLength")), -1);
fieldPrecision[i] = Const.toInt(String.valueOf(field.get("fieldPrecision")), -1);
setEmptyString[i] = Const.toBoolean(String.valueOf(field.get("setEmptyString")), false);
}
rowLimit = XMLHandler.getPageValue(parameterHolder, fid("limit"));
} catch (Exception e) {
throw new KettlePageException(
"Unexpected error reading step information from the repository", e);
}
}
public void getInfo(SasInputMeta meta) throws KettleStepException {
// copy info to Meta class (input)
meta.setAcceptingField(wAccField.getText());
int nrNonEmptyFields = wFields.nrNonEmpty();
meta.getOutputFields().clear();
for (int i = 0; i < nrNonEmptyFields; i++) {
TableItem item = wFields.getNonEmpty(i);
int colnr = 1;
SasInputField field = new SasInputField();
field.setName(item.getText(colnr++));
field.setRename(item.getText(colnr++));
if (Const.isEmpty(field.getRename())) {
field.setRename(field.getName());
}
field.setType(ValueMeta.getType(item.getText(colnr++)));
field.setConversionMask(item.getText(colnr++));
field.setLength(Const.toInt(item.getText(colnr++), -1));
field.setPrecision(Const.toInt(item.getText(colnr++), -1));
field.setDecimalSymbol(item.getText(colnr++));
field.setGroupingSymbol(item.getText(colnr++));
field.setTrimType(ValueMeta.getTrimTypeByDesc(item.getText(colnr++)));
meta.getOutputFields().add(field);
}
wFields.removeEmptyRows();
wFields.setRowNums();
wFields.optWidth(true);
}
public CalculatorMetaFunction(Node calcnode) {
fieldName = XMLHandler.getTagValue(calcnode, "field_name");
calcType = getCalcFunctionType(XMLHandler.getTagValue(calcnode, "calc_type"));
fieldA = XMLHandler.getTagValue(calcnode, "field_a");
fieldB = XMLHandler.getTagValue(calcnode, "field_b");
fieldC = XMLHandler.getTagValue(calcnode, "field_c");
fieldD = XMLHandler.getTagValue(calcnode, "field_d");
fieldE = XMLHandler.getTagValue(calcnode, "field_e");
valueType = ValueMeta.getType(XMLHandler.getTagValue(calcnode, "value_type"));
valueLength = Const.toInt(XMLHandler.getTagValue(calcnode, "value_length"), -1);
valuePrecision = Const.toInt(XMLHandler.getTagValue(calcnode, "value_precision"), -1);
removedFromResult = "Y".equalsIgnoreCase(XMLHandler.getTagValue(calcnode, "remove"));
conversionMask = XMLHandler.getTagValue(calcnode, "conversion_mask");
decimalSymbol = XMLHandler.getTagValue(calcnode, "decimal_symbol");
groupingSymbol = XMLHandler.getTagValue(calcnode, "grouping_symbol");
currencySymbol = XMLHandler.getTagValue(calcnode, "currency_symbol");
// Fix 2.x backward compatibility
// The conversion mask was added in a certain revision.
// Anything that we load from before then should get masks set to retain backward compatibility
//
if (XMLHandler.getSubNode(calcnode, "conversion_mask") == null) {
fixBackwardCompatibility();
}
}
private void readData(Node stepnode) throws KettleXMLException {
try {
Node fields = XMLHandler.getSubNode(stepnode, "fields");
int nrfields = XMLHandler.countNodes(fields, "field");
allocate(nrfields);
String slength, sprecision;
for (int i = 0; i < nrfields; i++) {
Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i);
fieldName[i] = XMLHandler.getTagValue(fnode, "name");
fieldType[i] = XMLHandler.getTagValue(fnode, "type");
fieldFormat[i] = XMLHandler.getTagValue(fnode, "format");
currency[i] = XMLHandler.getTagValue(fnode, "currency");
decimal[i] = XMLHandler.getTagValue(fnode, "decimal");
group[i] = XMLHandler.getTagValue(fnode, "group");
value[i] = XMLHandler.getTagValue(fnode, "nullif");
slength = XMLHandler.getTagValue(fnode, "length");
sprecision = XMLHandler.getTagValue(fnode, "precision");
fieldLength[i] = Const.toInt(slength, -1);
fieldPrecision[i] = Const.toInt(sprecision, -1);
String emptyString = XMLHandler.getTagValue(fnode, "set_empty_string");
setEmptyString[i] = !Const.isEmpty(emptyString) && "Y".equalsIgnoreCase(emptyString);
}
// Is there a limit on the number of rows we process?
rowLimit = XMLHandler.getTagValue(stepnode, "limit");
} catch (Exception e) {
throw new KettleXMLException("Unable to load step info from XML", e);
}
}
private void readData(Node stepnode, List<? extends SharedObjectInterface> databases)
throws KettleXMLException {
try {
String commit, csize;
schemaName = XMLHandler.getTagValue(stepnode, "schema"); // $NON-NLS-1$
tablename = XMLHandler.getTagValue(stepnode, "table"); // $NON-NLS-1$
String con = XMLHandler.getTagValue(stepnode, "connectionRead"); // $NON-NLS-1$
databaseReadMeta = DatabaseMeta.findDatabase(databases, con);
con = XMLHandler.getTagValue(stepnode, "connectionWrite"); // $NON-NLS-1$
databaseWriteMeta = DatabaseMeta.findDatabase(databases, con);
commit = XMLHandler.getTagValue(stepnode, "commit"); // $NON-NLS-1$
commitSize = Const.toInt(commit, 0);
csize = XMLHandler.getTagValue(stepnode, "cache_size"); // $NON-NLS-1$
cacheSize = Const.toInt(csize, 0);
replaceFields =
"Y"
.equalsIgnoreCase(
XMLHandler.getTagValue(stepnode, "replace")); // $NON-NLS-1$ //$NON-NLS-2$
useHash =
"Y"
.equalsIgnoreCase(
XMLHandler.getTagValue(stepnode, "crc")); // $NON-NLS-1$ //$NON-NLS-2$
hashField = XMLHandler.getTagValue(stepnode, "crcfield"); // $NON-NLS-1$
Node keys = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
int nrkeys = XMLHandler.countNodes(keys, "key"); // $NON-NLS-1$
allocate(nrkeys);
// Read keys to dimension
for (int i = 0; i < nrkeys; i++) {
Node knode = XMLHandler.getSubNodeByNr(keys, "key", i); // $NON-NLS-1$
keyField[i] = XMLHandler.getTagValue(knode, "name"); // $NON-NLS-1$
keyLookup[i] = XMLHandler.getTagValue(knode, "lookup"); // $NON-NLS-1$
}
// If this is empty: use auto-increment field!
sequenceFrom = XMLHandler.getTagValue(stepnode, "sequence"); // $NON-NLS-1$
Node fields = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
Node retkey = XMLHandler.getSubNode(fields, "return"); // $NON-NLS-1$
technicalKeyField = XMLHandler.getTagValue(retkey, "name"); // $NON-NLS-1$
useAutoinc =
!"N"
.equalsIgnoreCase(
XMLHandler.getTagValue(retkey, "use_autoinc")); // $NON-NLS-1$ //$NON-NLS-2$
lastUpdateField = XMLHandler.getTagValue(stepnode, "last_update_field"); // $NON-NLS-1$
setTechKeyCreation(XMLHandler.getTagValue(retkey, "creation_method")); // $NON-NLS-1$
} catch (Exception e) {
throw new KettleXMLException(
Messages.getString("ConcurrentCombinationLookupMeta.Exception.UnableToLoadStepInfo"),
e); //$NON-NLS-1$
}
}
public YamlInputField(Node fnode) throws KettleValueException {
setName(XMLHandler.getTagValue(fnode, "name"));
setPath(XMLHandler.getTagValue(fnode, "path"));
setType(ValueMeta.getType(XMLHandler.getTagValue(fnode, "type")));
setFormat(XMLHandler.getTagValue(fnode, "format"));
setCurrencySymbol(XMLHandler.getTagValue(fnode, "currency"));
setDecimalSymbol(XMLHandler.getTagValue(fnode, "decimal"));
setGroupSymbol(XMLHandler.getTagValue(fnode, "group"));
setLength(Const.toInt(XMLHandler.getTagValue(fnode, "length"), -1));
setPrecision(Const.toInt(XMLHandler.getTagValue(fnode, "precision"), -1));
setTrimType(getTrimTypeByCode(XMLHandler.getTagValue(fnode, "trim_type")));
}
private void readData(Node stepnode) throws KettleXMLException {
try {
keyField = XMLHandler.getTagValue(stepnode, "key_field"); // $NON-NLS-1$
Node groupn = XMLHandler.getSubNode(stepnode, "group"); // $NON-NLS-1$
Node fields = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
int sizegroup = XMLHandler.countNodes(groupn, "field"); // $NON-NLS-1$
int nrfields = XMLHandler.countNodes(fields, "field"); // $NON-NLS-1$
allocate(sizegroup, nrfields);
for (int i = 0; i < sizegroup; i++) {
Node fnode = XMLHandler.getSubNodeByNr(groupn, "field", i); // $NON-NLS-1$
groupField[i] = XMLHandler.getTagValue(fnode, "name"); // $NON-NLS-1$
}
for (int i = 0; i < nrfields; i++) {
Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i); // $NON-NLS-1$
denormaliserTargetField[i] = new DenormaliserTargetField();
denormaliserTargetField[i].setFieldName(
XMLHandler.getTagValue(fnode, "field_name")); // $NON-NLS-1$
denormaliserTargetField[i].setKeyValue(
XMLHandler.getTagValue(fnode, "key_value")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetName(
XMLHandler.getTagValue(fnode, "target_name")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetType(
XMLHandler.getTagValue(fnode, "target_type")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetFormat(
XMLHandler.getTagValue(fnode, "target_format")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetLength(
Const.toInt(XMLHandler.getTagValue(fnode, "target_length"), -1)); // $NON-NLS-1$
denormaliserTargetField[i].setTargetPrecision(
Const.toInt(XMLHandler.getTagValue(fnode, "target_precision"), -1)); // $NON-NLS-1$
denormaliserTargetField[i].setTargetDecimalSymbol(
XMLHandler.getTagValue(fnode, "target_decimal_symbol")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetGroupingSymbol(
XMLHandler.getTagValue(fnode, "target_grouping_symbol")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetCurrencySymbol(
XMLHandler.getTagValue(fnode, "target_currency_symbol")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetNullString(
XMLHandler.getTagValue(fnode, "target_null_string")); // $NON-NLS-1$
denormaliserTargetField[i].setTargetAggregationType(
XMLHandler.getTagValue(fnode, "target_aggregation_type")); // $NON-NLS-1$
}
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "DenormaliserMeta.Exception.UnableToLoadStepInfoFromXML"),
e); //$NON-NLS-1$
}
}
private void readData(Node stepnode) throws KettleXMLException {
try {
encoding = XMLHandler.getTagValue(stepnode, "encoding"); // $NON-NLS-1$
valueName = XMLHandler.getTagValue(stepnode, "valueName"); // $NON-NLS-1$
rootNode = XMLHandler.getTagValue(stepnode, "xml_repeat_element"); // $NON-NLS-1$
omitXMLheader =
"Y"
.equalsIgnoreCase(
XMLHandler.getTagValue(
stepnode, "file", "omitXMLheader")); // $NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
omitNullValues =
"Y"
.equalsIgnoreCase(
XMLHandler.getTagValue(
stepnode, "file", "omitNullValues")); // $NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
Node fields = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
int nrfields = XMLHandler.countNodes(fields, "field"); // $NON-NLS-1$
allocate(nrfields);
for (int i = 0; i < nrfields; i++) {
Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i); // $NON-NLS-1$
outputFields[i] = new XMLField();
outputFields[i].setFieldName(XMLHandler.getTagValue(fnode, "name")); // $NON-NLS-1$
outputFields[i].setElementName(XMLHandler.getTagValue(fnode, "element")); // $NON-NLS-1$
outputFields[i].setType(XMLHandler.getTagValue(fnode, "type")); // $NON-NLS-1$
outputFields[i].setFormat(XMLHandler.getTagValue(fnode, "format")); // $NON-NLS-1$
outputFields[i].setCurrencySymbol(XMLHandler.getTagValue(fnode, "currency")); // $NON-NLS-1$
outputFields[i].setDecimalSymbol(XMLHandler.getTagValue(fnode, "decimal")); // $NON-NLS-1$
outputFields[i].setGroupingSymbol(XMLHandler.getTagValue(fnode, "group")); // $NON-NLS-1$
outputFields[i].setNullString(XMLHandler.getTagValue(fnode, "nullif")); // $NON-NLS-1$
outputFields[i].setLength(
Const.toInt(XMLHandler.getTagValue(fnode, "length"), -1)); // $NON-NLS-1$
outputFields[i].setPrecision(
Const.toInt(XMLHandler.getTagValue(fnode, "precision"), -1)); // $NON-NLS-1$
outputFields[i].setAttribute(
"Y"
.equalsIgnoreCase(
XMLHandler.getTagValue(fnode, "attribute"))); // $NON-NLS-1$ //$NON-NLS-2$
outputFields[i].setAttributeParentName(
XMLHandler.getTagValue(fnode, "attributeParentName")); // $NON-NLS-1$
}
} catch (Exception e) {
throw new KettleXMLException("Unable to load step info from XML", e); // $NON-NLS-1$
}
}
private void readData(Node stepnode, List<? extends SharedObjectInterface> databases)
throws KettleXMLException {
try {
String csize;
int nrkeys;
String con = XMLHandler.getTagValue(stepnode, "connection"); // $NON-NLS-1$
databaseMeta = DatabaseMeta.findDatabase(databases, con);
csize = XMLHandler.getTagValue(stepnode, "commit"); // $NON-NLS-1$
commitSize = Const.toInt(csize, 0);
schemaName =
XMLHandler.getTagValue(stepnode, "lookup", "schema"); // $NON-NLS-1$ //$NON-NLS-2$
tableName = XMLHandler.getTagValue(stepnode, "lookup", "table"); // $NON-NLS-1$ //$NON-NLS-2$
Node lookup = XMLHandler.getSubNode(stepnode, "lookup"); // $NON-NLS-1$
nrkeys = XMLHandler.countNodes(lookup, "key"); // $NON-NLS-1$
allocate(nrkeys);
for (int i = 0; i < nrkeys; i++) {
Node knode = XMLHandler.getSubNodeByNr(lookup, "key", i); // $NON-NLS-1$
keyStream[i] = XMLHandler.getTagValue(knode, "name"); // $NON-NLS-1$
keyLookup[i] = XMLHandler.getTagValue(knode, "field"); // $NON-NLS-1$
keyCondition[i] = XMLHandler.getTagValue(knode, "condition"); // $NON-NLS-1$
if (keyCondition[i] == null) keyCondition[i] = "="; // $NON-NLS-1$
keyStream2[i] = XMLHandler.getTagValue(knode, "name2"); // $NON-NLS-1$
}
} catch (Exception e) {
throw new KettleXMLException(
Messages.getString("DeleteMeta.Exception.UnableToReadStepInfoFromXML"), e); // $NON-NLS-1$
}
}
private void ok() {
if (Const.isEmpty(wName.getText())) {
MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR);
mb.setText(BaseMessages.getString(PKG, "System.StepJobEntryNameMissing.Title"));
mb.setMessage(BaseMessages.getString(PKG, "System.JobEntryNameMissing.Msg"));
mb.open();
return;
}
jobEntry.setName(wName.getText());
int nritems = wFields.nrNonEmpty();
jobEntry.connections = new DatabaseMeta[nritems];
jobEntry.waitfors = new String[nritems];
jobEntry.waittimes = new int[nritems];
for (int i = 0; i < nritems; i++) {
String arg = wFields.getNonEmpty(i).getText(1);
DatabaseMeta dbMeta = jobMeta.findDatabase(arg);
if (dbMeta != null) {
jobEntry.connections[i] = dbMeta;
jobEntry.waitfors[i] = "" + Const.toInt(wFields.getNonEmpty(i).getText(2), 0);
jobEntry.waittimes[i] =
JobEntryCheckDbConnections.getWaitTimeByDesc(wFields.getNonEmpty(i).getText(3));
}
}
dispose();
}
private void ok() {
if (Const.isEmpty(wStepname.getText())) return;
input.setCommitSize(Const.toInt(wCommit.getText(), 0));
stepname = wStepname.getText(); // return value
input.setSqlFieldName(wSQLFieldName.getText());
// copy info to TextFileInputMeta class (input)
input.setDatabaseMeta(transMeta.findDatabase(wConnection.getText()));
input.setInsertField(wInsertField.getText());
input.setUpdateField(wUpdateField.getText());
input.setDeleteField(wDeleteField.getText());
input.setReadField(wReadField.getText());
input.setSqlFromfile(wSQLFromFile.getSelection());
input.SetSendOneStatement(wSendOneStatement.getSelection());
if (input.getDatabaseMeta() == null) {
MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR);
mb.setMessage(
BaseMessages.getString(
PKG, "ExecSQLRowDialog.InvalidConnection.DialogMessage")); // $NON-NLS-1$
mb.setText(
BaseMessages.getString(
PKG, "ExecSQLRowDialog.InvalidConnection.DialogTitle")); // $NON-NLS-1$
mb.open();
return;
}
dispose();
}
private void getInfo(LucidDBBulkLoaderMeta inf) {
int nrfields = wReturn.nrNonEmpty();
inf.allocate(nrfields);
inf.setMaxErrors(Const.toInt(wMaxErrors.getText(), 0));
logDebug(
BaseMessages.getString(
PKG,
"LucidDBBulkLoaderDialog.Log.FoundFields",
"" + nrfields)); // $NON-NLS-1$ //$NON-NLS-2$
for (int i = 0; i < nrfields; i++) {
TableItem item = wReturn.getNonEmpty(i);
inf.getFieldTable()[i] = item.getText(1);
inf.getFieldStream()[i] = item.getText(2);
inf.getFieldFormatOk()[i] = "Y".equalsIgnoreCase(item.getText(3));
}
inf.setSchemaName(wSchema.getText());
inf.setTableName(wTable.getText());
inf.setDatabaseMeta(transMeta.findDatabase(wConnection.getText()));
inf.setFifoDirectory(wFifoPath.getText());
inf.setFifoServerName(wFifoServer.getText());
stepname = wStepname.getText(); // return value
}
private void getInfo(StepsMetricsMeta in) {
stepname = wStepname.getText(); // return value
int nrsteps = wFields.nrNonEmpty();
in.allocate(nrsteps);
for (int i = 0; i < nrsteps; i++) {
TableItem ti = wFields.getNonEmpty(i);
StepMeta tm = transMeta.findStep(ti.getText(1));
// CHECKSTYLE:Indentation:OFF
if (tm != null) {
in.getStepName()[i] = tm.getName();
in.getStepCopyNr()[i] = "" + Const.toInt(ti.getText(2), 0);
in.getStepRequired()[i] = in.getRequiredStepsCode(ti.getText(3));
}
}
in.setStepNameFieldName(wStepnameField.getText());
in.setStepIdFieldName(wStepidField.getText());
in.setStepLinesInputFieldName(wLinesinputField.getText());
in.setStepLinesOutputFieldName(wLinesoutputField.getText());
in.setStepLinesReadFieldName(wLinesreadField.getText());
in.setStepLinesWrittenFieldName(wLineswrittenField.getText());
in.setStepLinesUpdatedFieldName(wLinesupdatedField.getText());
in.setStepLinesErrorsFieldName(wLineserrorsField.getText());
in.setStepSecondsFieldName(wSecondsField.getText());
}
protected String getLogBuffer(
VariableSpace space, String logChannelId, LogStatus status, String limit) {
StringBuffer buffer = KettleLogStore.getAppender().getBuffer(logChannelId, true);
if (Const.isEmpty(limit)) {
String defaultLimit = space.getVariable(Const.KETTLE_LOG_SIZE_LIMIT, null);
if (!Const.isEmpty(defaultLimit)) {
limit = defaultLimit;
}
}
// See if we need to limit the amount of rows
//
int nrLines = Const.isEmpty(limit) ? -1 : Const.toInt(space.environmentSubstitute(limit), -1);
if (nrLines > 0) {
int start = buffer.length() - 1;
for (int i = 0; i < nrLines && start > 0; i++) {
start = buffer.lastIndexOf(Const.CR, start - 1);
}
if (start > 0) {
buffer.delete(0, start + Const.CR.length());
}
}
return buffer.append(Const.CR + status.getStatus().toUpperCase() + Const.CR).toString();
}
private void readData(Node stepnode, List<? extends SharedObjectInterface> databases)
throws KettleXMLException {
try {
String csize;
String con = XMLHandler.getTagValue(stepnode, "connection");
databaseMeta = DatabaseMeta.findDatabase(databases, con);
csize = XMLHandler.getTagValue(stepnode, "commit");
commitSize = Const.toInt(csize, 0);
sqlField = XMLHandler.getTagValue(stepnode, "sql_field");
insertField = XMLHandler.getTagValue(stepnode, "insert_field");
updateField = XMLHandler.getTagValue(stepnode, "update_field");
deleteField = XMLHandler.getTagValue(stepnode, "delete_field");
readField = XMLHandler.getTagValue(stepnode, "read_field");
sqlFromfile = "Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "sqlFromfile"));
sendOneStatement =
"Y"
.equalsIgnoreCase(
Const.NVL(XMLHandler.getTagValue(stepnode, "sendOneStatement"), "Y"));
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "ExecSQLRowMeta.Exception.UnableToLoadStepInfoFromXML"), e);
}
}
public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
meta = (IngresVectorwiseLoaderMeta) smi;
data = (IngresVectorwiseLoaderData) sdi;
if (super.init(smi, sdi)) {
if (Const.isEmpty(meta.getDelimiter())) {
data.separator = data.getBytes("|");
} else {
data.separator = data.getBytes(meta.getDelimiter());
}
data.newline = data.getBytes("\n");
data.semicolon = data.getBytes(";");
data.doubleQuote = data.getBytes("\"");
// Schema-table combination...
data.schemaTable =
meta.getDatabaseMeta()
.getQuotedSchemaTableCombination(null, environmentSubstitute(meta.getTablename()));
data.encoding = environmentSubstitute(meta.getEncoding());
data.isEncoding = !Const.isEmpty(environmentSubstitute(meta.getEncoding()));
data.byteBuffer = null;
String bufferSizeString = environmentSubstitute(meta.getBufferSize());
data.bufferSize =
Const.isEmpty(bufferSizeString) ? 5000 : Const.toInt(bufferSizeString, 5000);
if (meta.isTruncatingTable() && meta.getDatabaseMeta() != null) {
// Connect to Vectorwise over standard JDBC and truncate the table
//
Database db = new Database(this, meta.getDatabaseMeta());
try {
db.connect();
db.execStatement(
"CALL VECTORWISE( COMBINE '" + data.schemaTable + " - " + data.schemaTable + "' )");
// Just to make sure VW gets the message
//
db.execStatement(
"CALL VECTORWISE( COMBINE '" + data.schemaTable + " - " + data.schemaTable + "' )");
log.logDetailed(
"Table " + data.schemaTable + " was truncated using a 'combine' statement.");
} catch (Exception e) {
log.logError("Error truncating table", e);
return false;
} finally {
db.disconnect();
}
}
return true;
}
return false;
}
private void readData(Node stepnode) throws KettleXMLException {
try {
filename = XMLHandler.getTagValue(stepnode, "filename");
filenameField = XMLHandler.getTagValue(stepnode, "filename_field");
rowNumField = XMLHandler.getTagValue(stepnode, "rownum_field");
includingFilename =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "include_filename"));
delimiter = XMLHandler.getTagValue(stepnode, "separator");
enclosure = XMLHandler.getTagValue(stepnode, "enclosure");
bufferSize = XMLHandler.getTagValue(stepnode, "buffer_size");
headerPresent = "Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "header"));
lazyConversionActive =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "lazy_conversion"));
isaddresult = "Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "add_filename_result"));
runningInParallel = "Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "parallel"));
encoding = XMLHandler.getTagValue(stepnode, "encoding");
Node fields = XMLHandler.getSubNode(stepnode, "fields");
int nrfields = XMLHandler.countNodes(fields, "field");
allocate(nrfields);
for (int i = 0; i < nrfields; i++) {
inputFields[i] = new TextFileInputField();
Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i);
inputFields[i].setName(XMLHandler.getTagValue(fnode, "name"));
inputFields[i].setType(ValueMeta.getType(XMLHandler.getTagValue(fnode, "type")));
inputFields[i].setFormat(XMLHandler.getTagValue(fnode, "format"));
inputFields[i].setCurrencySymbol(XMLHandler.getTagValue(fnode, "currency"));
inputFields[i].setDecimalSymbol(XMLHandler.getTagValue(fnode, "decimal"));
inputFields[i].setGroupSymbol(XMLHandler.getTagValue(fnode, "group"));
inputFields[i].setLength(Const.toInt(XMLHandler.getTagValue(fnode, "length"), -1));
inputFields[i].setPrecision(Const.toInt(XMLHandler.getTagValue(fnode, "precision"), -1));
inputFields[i].setTrimType(
ValueMeta.getTrimTypeByCode(XMLHandler.getTagValue(fnode, "trim_type")));
}
} catch (Exception e) {
throw new KettleXMLException("Unable to load step info from XML", e);
}
}
private void getInfo(FixedInputMeta fixedInputMeta) {
fixedInputMeta.setFilename(wFilename.getText());
fixedInputMeta.setLineWidth(wLineWidth.getText());
fixedInputMeta.setBufferSize(wBufferSize.getText());
fixedInputMeta.setLazyConversionActive(wLazyConversion.getSelection());
fixedInputMeta.setHeaderPresent(wHeaderPresent.getSelection());
fixedInputMeta.setLineFeedPresent(wLineFeedPresent.getSelection());
fixedInputMeta.setRunningInParallel(wRunningInParallel.getSelection());
fixedInputMeta.setFileType(FixedInputMeta.getFileType(wFileType.getText()));
fixedInputMeta.setEncoding(wEncoding.getText());
fixedInputMeta.setAddResultFile(wAddResult.getSelection());
int nrNonEmptyFields = wFields.nrNonEmpty();
fixedInputMeta.allocate(nrNonEmptyFields);
for (int i = 0; i < nrNonEmptyFields; i++) {
TableItem item = wFields.getNonEmpty(i);
int colnr = 1;
FixedFileInputField field = new FixedFileInputField();
field.setName(item.getText(colnr++));
field.setType(ValueMetaFactory.getIdForValueMeta(item.getText(colnr++)));
field.setFormat(item.getText(colnr++));
field.setWidth(Const.toInt(item.getText(colnr++), -1));
field.setLength(Const.toInt(item.getText(colnr++), -1));
field.setPrecision(Const.toInt(item.getText(colnr++), -1));
field.setCurrency(item.getText(colnr++));
field.setDecimal(item.getText(colnr++));
field.setGrouping(item.getText(colnr++));
field.setTrimType(ValueMetaString.getTrimTypeByDesc(item.getText(colnr++)));
// CHECKSTYLE:Indentation:OFF
fixedInputMeta.getFieldDefinition()[i] = field;
}
wFields.removeEmptyRows();
wFields.setRowNums();
wFields.optWidth(true);
fixedInputMeta.setChanged();
}
private void getModulesList() {
if (!gotModule) {
SalesforceConnection connection = null;
try {
SalesforceDeleteMeta meta = new SalesforceDeleteMeta();
getInfo(meta);
String url = transMeta.environmentSubstitute(meta.getTargetURL());
String selectedField = wModule.getText();
wModule.removeAll();
// Define a new Salesforce connection
connection =
new SalesforceConnection(
log,
url,
transMeta.environmentSubstitute(meta.getUsername()),
Utils.resolvePassword(transMeta, meta.getPassword()));
int realTimeOut = Const.toInt(transMeta.environmentSubstitute(meta.getTimeout()), 0);
connection.setTimeOut(realTimeOut);
// connect to Salesforce
connection.connect();
// return
wModule.setItems(connection.getAllAvailableObjects(false));
if (!Utils.isEmpty(selectedField)) {
wModule.setText(selectedField);
}
gotModule = true;
getModulesListError = false;
} catch (Exception e) {
new ErrorDialog(
shell,
BaseMessages.getString(PKG, "SalesforceDeleteDialog.ErrorRetrieveModules.DialogTitle"),
BaseMessages.getString(
PKG, "SalesforceDeleteDialog.ErrorRetrieveData.ErrorRetrieveModules"),
e);
getModulesListError = true;
} finally {
if (connection != null) {
try {
connection.close();
} catch (Exception e) {
/* Ignore */
}
}
}
}
}
private void readData(Node stepnode) throws KettleXMLException {
try {
splitField = XMLHandler.getTagValue(stepnode, "splitfield"); // $NON-NLS-1$
delimiter = XMLHandler.getTagValue(stepnode, "delimiter"); // $NON-NLS-1$
final Node fields = XMLHandler.getSubNode(stepnode, "fields"); // $NON-NLS-1$
final int nrfields = XMLHandler.countNodes(fields, "field"); // $NON-NLS-1$
allocate(nrfields);
for (int i = 0; i < nrfields; i++) {
final Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i); // $NON-NLS-1$
fieldName[i] = XMLHandler.getTagValue(fnode, "name"); // $NON-NLS-1$
fieldID[i] = XMLHandler.getTagValue(fnode, "id"); // $NON-NLS-1$
final String sidrem = XMLHandler.getTagValue(fnode, "idrem"); // $NON-NLS-1$
final String stype = XMLHandler.getTagValue(fnode, "type"); // $NON-NLS-1$
fieldFormat[i] = XMLHandler.getTagValue(fnode, "format"); // $NON-NLS-1$
fieldGroup[i] = XMLHandler.getTagValue(fnode, "group"); // $NON-NLS-1$
fieldDecimal[i] = XMLHandler.getTagValue(fnode, "decimal"); // $NON-NLS-1$
fieldCurrency[i] = XMLHandler.getTagValue(fnode, "currency"); // $NON-NLS-1$
final String slen = XMLHandler.getTagValue(fnode, "length"); // $NON-NLS-1$
final String sprc = XMLHandler.getTagValue(fnode, "precision"); // $NON-NLS-1$
fieldNullIf[i] = XMLHandler.getTagValue(fnode, "nullif"); // $NON-NLS-1$
fieldIfNull[i] = XMLHandler.getTagValue(fnode, "ifnull"); // $NON-NLS-1$
final String trim = XMLHandler.getTagValue(fnode, "trimtype"); // $NON-NLS-1$
fieldRemoveID[i] = "Y".equalsIgnoreCase(sidrem); // $NON-NLS-1$
fieldType[i] = ValueMeta.getType(stype);
fieldLength[i] = Const.toInt(slen, -1);
fieldPrecision[i] = Const.toInt(sprc, -1);
fieldTrimType[i] = ValueMeta.getTrimTypeByCode(trim);
}
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "FieldSplitterMeta.Exception.UnableToLoadStepInfoFromXML"),
e); //$NON-NLS-1$
}
}
public XMLInputSaxField(Node fnode) throws KettleValueException {
setName(XMLHandler.getTagValue(fnode, "name"));
setType(ValueMeta.getType(XMLHandler.getTagValue(fnode, "type")));
setFormat(XMLHandler.getTagValue(fnode, "format"));
setCurrencySymbol(XMLHandler.getTagValue(fnode, "currency"));
setDecimalSymbol(XMLHandler.getTagValue(fnode, "decimal"));
setGroupSymbol(XMLHandler.getTagValue(fnode, "group"));
setLength(Const.toInt(XMLHandler.getTagValue(fnode, "length"), -1));
setPrecision(Const.toInt(XMLHandler.getTagValue(fnode, "precision"), -1));
setTrimType(getTrimType(XMLHandler.getTagValue(fnode, "trim_type")));
setRepeated(!"N".equalsIgnoreCase(XMLHandler.getTagValue(fnode, "repeat")));
Node positions = XMLHandler.getSubNode(fnode, "positions");
int nrPositions = XMLHandler.countNodes(positions, "position");
fieldPosition = new XMLInputSaxFieldPosition[nrPositions];
for (int i = 0; i < nrPositions; i++) {
Node positionnode = XMLHandler.getSubNodeByNr(positions, "position", i);
String encoded = XMLHandler.getNodeValue(positionnode);
fieldPosition[i] = new XMLInputSaxFieldPosition(encoded);
}
}
/** Copy information from the meta-data input to the dialog fields. */
public void getData() {
Table table = wFields.table;
if (input.getStepName().length > 0) {
table.removeAll();
}
for (int i = 0; i < input.getStepName().length; i++) {
TableItem ti = new TableItem(table, SWT.NONE);
ti.setText(0, "" + (i + 1));
if (input.getStepName()[i] != null) {
ti.setText(1, input.getStepName()[i]);
ti.setText(2, String.valueOf(Const.toInt(input.getStepCopyNr()[i], 0)));
ti.setText(3, input.getRequiredStepsDesc(input.getStepRequired()[i]));
}
}
wFields.removeEmptyRows();
wFields.setRowNums();
wFields.optWidth(true);
if (input.getStepNameFieldName() != null) {
wStepnameField.setText(input.getStepNameFieldName());
}
if (input.getStepIdFieldName() != null) {
wStepidField.setText(input.getStepIdFieldName());
}
if (input.getStepLinesInputFieldName() != null) {
wLinesinputField.setText(input.getStepLinesInputFieldName());
}
if (input.getStepLinesOutputFieldName() != null) {
wLinesoutputField.setText(input.getStepLinesOutputFieldName());
}
if (input.getStepLinesReadFieldName() != null) {
wLinesreadField.setText(input.getStepLinesReadFieldName());
}
if (input.getStepLinesWrittenFieldName() != null) {
wLineswrittenField.setText(input.getStepLinesWrittenFieldName());
}
if (input.getStepLinesUpdatedFieldName() != null) {
wLinesupdatedField.setText(input.getStepLinesUpdatedFieldName());
}
if (input.getStepLinesErrorsFieldName() != null) {
wLineserrorsField.setText(input.getStepLinesErrorsFieldName());
}
if (input.getStepSecondsFieldName() != null) {
wSecondsField.setText(input.getStepSecondsFieldName());
}
wStepname.selectAll();
wStepname.setFocus();
}
private void readData(Node stepnode, List<? extends SharedObjectInterface> databases)
throws KettleXMLException {
try {
String con = XMLHandler.getTagValue(stepnode, "connection"); // $NON-NLS-1$
databaseMeta = DatabaseMeta.findDatabase(databases, con);
String serror = XMLHandler.getTagValue(stepnode, "errors"); // $NON-NLS-1$
maxErrors = Const.toInt(serror, 50); // default to 50.
schemaName = XMLHandler.getTagValue(stepnode, "schema"); // $NON-NLS-1$
tableName = XMLHandler.getTagValue(stepnode, "table"); // $NON-NLS-1$
loadMethod = XMLHandler.getTagValue(stepnode, "load_method"); // $NON-NLS-1$
loadAction = XMLHandler.getTagValue(stepnode, "load_action"); // $NON-NLS-1$
PsqlPath = XMLHandler.getTagValue(stepnode, "PsqlPath"); // $NON-NLS-1$
controlFile = XMLHandler.getTagValue(stepnode, "control_file"); // $NON-NLS-1$
dataFile = XMLHandler.getTagValue(stepnode, "data_file"); // $NON-NLS-1$
logFile = XMLHandler.getTagValue(stepnode, "log_file"); // $NON-NLS-1$
eraseFiles =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(stepnode, "erase_files")); // $NON-NLS-1$
encoding = XMLHandler.getTagValue(stepnode, "encoding"); // $NON-NLS-1$
dbNameOverride = XMLHandler.getTagValue(stepnode, "dbname_override"); // $NON-NLS-1$
int nrvalues = XMLHandler.countNodes(stepnode, "mapping"); // $NON-NLS-1$
allocate(nrvalues);
for (int i = 0; i < nrvalues; i++) {
Node vnode = XMLHandler.getSubNodeByNr(stepnode, "mapping", i); // $NON-NLS-1$
fieldTable[i] = XMLHandler.getTagValue(vnode, "stream_name"); // $NON-NLS-1$
fieldStream[i] = XMLHandler.getTagValue(vnode, "field_name"); // $NON-NLS-1$
if (fieldStream[i] == null) fieldStream[i] = fieldTable[i]; // default: the same name!
String locDateMask = XMLHandler.getTagValue(vnode, "date_mask"); // $NON-NLS-1$
if (locDateMask == null) {
dateMask[i] = "";
} else {
if (GPBulkLoaderMeta.DATE_MASK_DATE.equals(locDateMask)
|| GPBulkLoaderMeta.DATE_MASK_DATETIME.equals(locDateMask)) {
dateMask[i] = locDateMask;
} else {
dateMask[i] = "";
}
}
}
} catch (Exception e) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "GPBulkLoaderMeta.Exception.UnableToReadStepInfoFromXML"),
e); //$NON-NLS-1$
}
}
public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
meta = (SalesforceDeleteMeta) smi;
data = (SalesforceDeleteData) sdi;
if (super.init(smi, sdi)) {
try {
data.realModule = environmentSubstitute(meta.getModule());
// Check if module is specified
if (Const.isEmpty(data.realModule)) {
log.logError(
BaseMessages.getString(PKG, "SalesforceDeleteDialog.ModuleMissing.DialogMessage"));
return false;
}
String realUser = environmentSubstitute(meta.getUserName());
// Check if username is specified
if (Const.isEmpty(realUser)) {
log.logError(
BaseMessages.getString(PKG, "SalesforceDeleteDialog.UsernameMissing.DialogMessage"));
return false;
}
// initialize variables
data.realURL = environmentSubstitute(meta.getTargetURL());
// create a Salesforce connection
data.connection =
new SalesforceConnection(
log, data.realURL, realUser, environmentSubstitute(meta.getPassword()));
// set timeout
data.connection.setTimeOut(Const.toInt(environmentSubstitute(meta.getTimeOut()), 0));
// Do we use compression?
data.connection.setUsingCompression(meta.isUsingCompression());
// Do we rollback all changes on error
data.connection.rollbackAllChangesOnError(meta.isRollbackAllChangesOnError());
// Now connect ...
data.connection.connect();
return true;
} catch (KettleException ke) {
logError(
BaseMessages.getString(PKG, "SalesforceDelete.Log.ErrorOccurredDuringStepInitialize")
+ ke.getMessage()); // $NON-NLS-1$
}
return true;
}
return false;
}
public void loadXML(
Node entrynode,
List<DatabaseMeta> databases,
List<SlaveServer> slaveServers,
Repository rep,
IMetaStore metaStore)
throws KettleXMLException {
try {
super.loadXML(entrynode, databases, slaveServers);
serverName = XMLHandler.getTagValue(entrynode, "servername");
userName = XMLHandler.getTagValue(entrynode, "username");
password =
Encr.decryptPasswordOptionallyEncrypted(XMLHandler.getTagValue(entrynode, "password"));
serverPort = XMLHandler.getTagValue(entrynode, "serverport");
ftpDirectory = XMLHandler.getTagValue(entrynode, "ftpdirectory");
localDirectory = XMLHandler.getTagValue(entrynode, "localdirectory");
wildcard = XMLHandler.getTagValue(entrynode, "wildcard");
onlyGettingNewFiles = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "only_new"));
usehttpproxy = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "usehttpproxy"));
httpProxyHost = XMLHandler.getTagValue(entrynode, "httpproxyhost");
httpproxyport = XMLHandler.getTagValue(entrynode, "httpproxyport");
httpproxyusername = XMLHandler.getTagValue(entrynode, "httpproxyusername");
httpProxyPassword = XMLHandler.getTagValue(entrynode, "httpproxypassword");
publicpublickey = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "publicpublickey"));
keyFilename = XMLHandler.getTagValue(entrynode, "keyfilename");
keyFilePass = XMLHandler.getTagValue(entrynode, "keyfilepass");
useBasicAuthentication =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "usebasicauthentication"));
afterFtpPut = XMLHandler.getTagValue(entrynode, "afterftpput");
destinationfolder = XMLHandler.getTagValue(entrynode, "destinationfolder");
createdestinationfolder =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "createdestinationfolder"));
cachehostkey = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "cachehostkey"));
timeout = Const.toInt(XMLHandler.getTagValue(entrynode, "timeout"), 0);
createtargetfolder =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "createtargetfolder"));
includeSubFolders =
"Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "includeSubFolders"));
} catch (KettleXMLException xe) {
throw new KettleXMLException(
BaseMessages.getString(PKG, "JobSSH2GET.Log.UnableLoadXML", xe.getMessage()));
}
}
public boolean init(StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface) {
if (super.init(stepMetaInterface, stepDataInterface)) {
m_meta = (MongoDbOutputMeta) stepMetaInterface;
m_data = (MongoDbOutputData) stepDataInterface;
String hostname = environmentSubstitute(m_meta.getHostname());
int port = Const.toInt(environmentSubstitute(m_meta.getPort()), 27017);
String db = environmentSubstitute(m_meta.getDBName());
String collection = environmentSubstitute(m_meta.getCollection());
try {
m_data.connect(hostname, port);
m_data.setDB(m_data.getConnection().getDB(db));
String realUser = environmentSubstitute(m_meta.getUsername());
String realPass =
Encr.decryptPasswordOptionallyEncrypted(environmentSubstitute(m_meta.getPassword()));
if (!Const.isEmpty(realUser) || !Const.isEmpty(realPass)) {
if (!m_data.getDB().authenticate(realUser, realPass.toCharArray())) {
throw new KettleException(
BaseMessages.getString(PKG, "MongoDbOutput.Messages.Error.UnableToAuthenticate"));
}
}
if (Const.isEmpty(collection)) {
throw new KettleException(
BaseMessages.getString(PKG, "MongoDbOutput.Messages.Error.NoCollectionSpecified"));
}
m_data.createCollection(collection);
m_data.setCollection(m_data.getDB().getCollection(collection));
return true;
} catch (UnknownHostException ex) {
logError(
BaseMessages.getString(PKG, "MongoDbOutput.Messages.Error.UnknownHost", hostname), ex);
return false;
} catch (Exception e) {
logError(
BaseMessages.getString(
PKG, "MongoDbOutput.Messages.Error.ProblemConnecting", hostname, "" + port),
e);
return false;
}
}
return false;
}
/** Copy information from the meta-data input to the dialog fields. */
public void getData() {
if (jobEntry.getName() != null) wName.setText(jobEntry.getName());
if (jobEntry.connections != null) {
for (int i = 0; i < jobEntry.connections.length; i++) {
TableItem ti = wFields.table.getItem(i);
if (jobEntry.connections[i] != null) {
ti.setText(1, jobEntry.connections[i].getName());
ti.setText(2, "" + Const.toInt(jobEntry.waitfors[i], 0));
ti.setText(3, JobEntryCheckDbConnections.getWaitTimeDesc(jobEntry.waittimes[i]));
}
}
wFields.setRowNums();
wFields.optWidth(true);
}
wName.selectAll();
wName.setFocus();
}
private void ok() {
if (Const.isEmpty(wStepname.getText())) {
return;
}
if (wCondition.getLevel() > 0) {
wCondition.goUp();
} else {
stepname = wStepname.getText(); // return value
input.setPrefix(wPrefix.getText());
input.setDirectory(wSortDir.getText());
input.setCacheSize(Const.toInt(wCache.getText(), -1));
input.setMainStep(transMeta.findStep(wMainStep.getText()));
dispose();
}
}
