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(); } }