// Listen to the Variable... button
public static final String getVariableName(Shell shell, VariableSpace space) {
String keys[] = space.listVariables();
Arrays.sort(keys);
int size = keys.length;
String key[] = new String[size];
String val[] = new String[size];
String str[] = new String[size];
for (int i = 0; i < keys.length; i++) {
key[i] = keys[i];
val[i] = space.getVariable(key[i]);
str[i] = key[i] + " [" + val[i] + "]";
}
EnterSelectionDialog esd =
new EnterSelectionDialog(
shell,
str,
Messages.getString("System.Dialog.SelectEnvironmentVar.Title"),
Messages.getString("System.Dialog.SelectEnvironmentVar.Message"));
esd.clearModal();
if (esd.open() != null) {
int nr = esd.getSelectionNr();
String var = key[nr];
return var;
} else {
return null;
}
}
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();
}
public RowMetaInterface getRequiredFields(VariableSpace space) throws KettleException {
String realTableName = space.environmentSubstitute(tableName);
String realSchemaName = space.environmentSubstitute(schemaName);
if (databaseMeta != null) {
Database db = new Database(loggingObject, databaseMeta);
try {
db.connect();
if (!Const.isEmpty(realTableName)) {
String schemaTable =
databaseMeta.getQuotedSchemaTableCombination(realSchemaName, realTableName);
// Check if this table exists...
if (db.checkTableExists(schemaTable)) {
return db.getTableFields(schemaTable);
} else {
throw new KettleException(
BaseMessages.getString(PKG, "GPBulkLoaderMeta.Exception.TableNotFound"));
}
} else {
throw new KettleException(
BaseMessages.getString(PKG, "GPBulkLoaderMeta.Exception.TableNotSpecified"));
}
} catch (Exception e) {
throw new KettleException(
BaseMessages.getString(PKG, "GPBulkLoaderMeta.Exception.ErrorGettingFields"), e);
} finally {
db.disconnect();
}
} else {
throw new KettleException(
BaseMessages.getString(PKG, "GPBulkLoaderMeta.Exception.ConnectionNotDefined"));
}
}
public void setVariables(VariableSpace space) {
this.variables = new HashMap<String, String>();
for (String name : space.listVariables()) {
String value = space.getVariable(name);
this.variables.put(name, value);
}
}
/** @return the connectionName */
public String getActualConnectionName() {
String name = space.environmentSubstitute(connectionName);
if (Const.isEmpty(name)) {
name = space.getVariable(getConnectionNameVariable());
}
if (Const.isEmpty(name)) return null;
else return name;
}
/** @return the tableName */
public String getActualTableName() {
if (!Const.isEmpty(tableName)) return space.environmentSubstitute(tableName);
String name = space.getVariable(getTableNameVariable());
if (Const.isEmpty(name)) {
return null;
} else {
return name;
}
}
/** @return the schemaName */
public String getActualSchemaName() {
if (!Const.isEmpty(schemaName)) {
return space.environmentSubstitute(schemaName);
}
String name = space.getVariable(getSchemaNameVariable());
if (Const.isEmpty(name)) {
return null;
} else {
return name;
}
}
public void open(VariableSpace space, Process sqlldrProcess) throws KettleException {
String loadMethod = meta.getLoadMethod();
try {
OutputStream os = null;
if (OraBulkLoaderMeta.METHOD_AUTO_CONCURRENT.equals(loadMethod)) {
os = sqlldrProcess.getOutputStream();
} else {
// Else open the data file filled in.
String dataFile = meta.getDataFile();
dataFile = space.environmentSubstitute(dataFile);
os = new FileOutputStream(dataFile, false);
}
String encoding = meta.getEncoding();
if (Const.isEmpty(encoding)) {
// Use the default encoding.
output = new BufferedWriter(new OutputStreamWriter(os));
} else {
// Use the specified encoding
output = new BufferedWriter(new OutputStreamWriter(os, encoding));
}
} catch (IOException e) {
throw new KettleException("IO exception occured: " + e.getMessage(), e);
}
}
/**
* Since the exported transformation that runs this will reside in a ZIP file, we can't reference
* files relatively. So what this does is turn the name of the base path into an absolute path.
*
* @param space the variable space to use
* @param definitions
* @param resourceNamingInterface
* @param repository The repository to optionally load other resources from (to be converted to
* XML)
* @param metaStore the metaStore in which non-kettle metadata could reside.
* @return the filename of the exported resource
*/
public String exportResources(
VariableSpace space,
Map<String, ResourceDefinition> definitions,
ResourceNamingInterface resourceNamingInterface,
Repository repository,
IMetaStore metaStore)
throws KettleException {
try {
// The object that we're modifying here is a copy of the original!
// So let's change the filename from relative to absolute by grabbing the file object...
// In case the name of the file comes from previous steps, forget about this!
//
if (!fileNameInField) {
if (!Const.isEmpty(fileName)) {
FileObject fileObject =
KettleVFS.getFileObject(space.environmentSubstitute(fileName), space);
fileName = resourceNamingInterface.nameResource(fileObject, space, true);
}
}
return null;
} catch (Exception e) {
throw new KettleException(e);
}
}
public void getFields(
RowMetaInterface r,
String name,
RowMetaInterface info[],
StepMeta nextStep,
VariableSpace space,
Repository repository,
IMetaStore metaStore)
throws KettleStepException {
int i;
for (i = 0; i < inputFields.length; i++) {
RssInputField field = inputFields[i];
int type = field.getType();
if (type == ValueMeta.TYPE_NONE) type = ValueMeta.TYPE_STRING;
try {
ValueMetaInterface v =
ValueMetaFactory.createValueMeta(space.environmentSubstitute(field.getName()), type);
v.setLength(field.getLength(), field.getPrecision());
v.setOrigin(name);
r.addValueMeta(v);
} catch (Exception e) {
throw new KettleStepException(e);
}
}
if (includeUrl) {
ValueMetaInterface v =
new ValueMeta(space.environmentSubstitute(urlField), ValueMeta.TYPE_STRING);
v.setLength(100, -1);
v.setOrigin(name);
r.addValueMeta(v);
}
if (includeRowNumber) {
ValueMetaInterface v =
new ValueMeta(space.environmentSubstitute(rowNumberField), ValueMeta.TYPE_INTEGER);
v.setLength(ValueMetaInterface.DEFAULT_INTEGER_LENGTH, 0);
v.setOrigin(name);
r.addValueMeta(v);
}
}
/**
* Reset this field. Should be called prior to processing a new field value from the avro file
*
* @param space environment variables (values that environment variables resolve to cannot contain
* "."s)
*/
public void reset(VariableSpace space) {
m_tempParts.clear();
for (String part : m_pathParts) {
m_tempParts.add(space.environmentSubstitute(part));
}
// reset sub fields
for (MongoField f : m_subFields) {
f.reset(space);
}
}
public void getUsedVariables(JobMeta jobMeta) {
Properties sp = new Properties();
VariableSpace space = Variables.getADefaultVariableSpace();
String[] keys = space.listVariables();
for (int i = 0; i < keys.length; i++) {
sp.put(keys[i], space.getVariable(keys[i]));
}
List<String> vars = jobMeta.getUsedVariables();
if (vars != null && vars.size() > 0) {
HashMap<String, String> newVariables = new HashMap<String, String>();
for (int i = 0; i < vars.size(); i++) {
String varname = vars.get(i);
if (!varname.startsWith(Const.INTERNAL_VARIABLE_PREFIX)) {
newVariables.put(varname, Const.NVL(variables.get(varname), sp.getProperty(varname, "")));
}
}
// variables.clear();
variables.putAll(newVariables);
}
}
/**
* Since the exported transformation that runs this will reside in a ZIP file, we can't reference
* files relatively. So what this does is turn the name of files into absolute paths OR it simply
* includes the resource in the ZIP file. For now, we'll simply turn it into an absolute path and
* pray that the file is on a shared drive or something like that.
*
* <p>TODO: create options to configure this behavior
*/
public String exportResources(
VariableSpace space,
Map<String, ResourceDefinition> definitions,
ResourceNamingInterface resourceNamingInterface,
Repository repository)
throws KettleException {
try {
// The object that we're modifying here is a copy of the original!
// So let's change the filename from relative to absolute by grabbing the file object...
// In case the name of the file comes from previous steps, forget about this!
//
if (Const.isEmpty(filenameField)) {
// From : ${Internal.Transformation.Filename.Directory}/../foo/bar.csv
// To : /home/matt/test/files/foo/bar.csv
//
FileObject fileObject = KettleVFS.getFileObject(space.environmentSubstitute(filename));
// If the file doesn't exist, forget about this effort too!
//
if (fileObject.exists()) {
// Convert to an absolute path...
//
filename =
resourceNamingInterface.nameResource(
fileObject.getName().getBaseName(),
fileObject.getParent().getName().getPath(),
space.toString(),
FileNamingType.DATA_FILE);
return filename;
}
}
return null;
} catch (Exception e) {
throw new KettleException(e); // $NON-NLS-1$
}
}
public RowMetaInterface getRequiredFields(VariableSpace space) throws KettleException {
String realFilename = space.environmentSubstitute(filename);
File file = new File(realFilename);
Database db = null;
try {
if (!file.exists() || !file.isFile()) {
throw new KettleException(
BaseMessages.getString(
PKG, "AccessOutputMeta.Exception.FileDoesNotExist", realFilename));
}
// open the database and get the table
db = Database.open(file);
String realTablename = space.environmentSubstitute(tablename);
Table table = db.getTable(realTablename);
if (table == null) {
throw new KettleException(
BaseMessages.getString(
PKG, "AccessOutputMeta.Exception.TableDoesNotExist", realTablename));
}
RowMetaInterface layout = getLayout(table);
return layout;
} catch (Exception e) {
throw new KettleException(
BaseMessages.getString(PKG, "AccessOutputMeta.Exception.ErrorGettingFields"), e);
} finally {
try {
if (db != null) {
db.close();
}
} catch (IOException e) {
throw new KettleException(
BaseMessages.getString(PKG, "AccessOutputMeta.Exception.ErrorClosingDatabase"), e);
}
}
}
/* This function adds meta data to the rows being pushed out */
public void getFields(
RowMetaInterface r,
String name,
RowMetaInterface[] info,
StepMeta nextStep,
VariableSpace space,
Repository repository,
IMetaStore metaStore)
throws KettleStepException {
String realfieldname = space.environmentSubstitute(getSalesforceIDFieldName());
if (!Const.isEmpty(realfieldname)) {
ValueMetaInterface v = new ValueMetaString(realfieldname);
v.setLength(18);
v.setOrigin(name);
r.addValueMeta(v);
}
}
public void getFields(
RowMetaInterface inputRowMeta,
String name,
RowMetaInterface info[],
StepMeta nextStep,
VariableSpace space)
throws KettleStepException {
for (int i = 0; i < fieldOutStream.length; i++) {
if (!Const.isEmpty(fieldOutStream[i])) {
ValueMetaInterface v =
new ValueMeta(space.environmentSubstitute(fieldOutStream[i]), ValueMeta.TYPE_STRING);
v.setLength(100, -1);
v.setOrigin(name);
inputRowMeta.addValueMeta(v);
}
}
}
/* This function adds meta data to the rows being pushed out */
public void getFields(
RowMetaInterface r,
String name,
RowMetaInterface[] info,
StepMeta nextStep,
VariableSpace space,
Repository repository,
IMetaStore metaStore)
throws KettleStepException {
if (StringUtils.isNotBlank(this.getIdOutField())) {
ValueMetaInterface valueMeta =
new ValueMeta(
space.environmentSubstitute(this.getIdOutField()), ValueMetaInterface.TYPE_STRING);
valueMeta.setOrigin(name);
// add if doesn't exist
if (!r.exists(valueMeta)) {
r.addValueMeta(valueMeta);
}
}
}
public void getFields(
RowMetaInterface row,
String name,
RowMetaInterface[] info,
StepMeta nextStep,
VariableSpace space,
Repository repository,
IMetaStore metaStore)
throws KettleStepException {
ValueMetaInterface v = new ValueMetaString(newFieldname);
v.setOrigin(name);
row.addValueMeta(v);
// include row number
if (includeRowNumber) {
v = new ValueMetaInteger(space.environmentSubstitute(rowNumberField));
v.setLength(ValueMetaInterface.DEFAULT_INTEGER_LENGTH, 0);
v.setOrigin(name);
row.addValueMeta(v);
}
}
/**
* This factory returns a FileSystemConfigBuilder. Custom FileSystemConfigBuilders can be created
* by implementing the {@link IKettleFileSystemConfigBuilder} or overriding the {@link
* KettleGenericFileSystemConfigBuilder}
*
* @see FileSystemConfigBuilder
* @param varSpace A Kettle variable space for resolving VFS config parameters
* @param scheme The VFS scheme (FILE, HTTP, SFTP, etc...)
* @return A FileSystemConfigBuilder that can translate Kettle variables into VFS config
* parameters
* @throws IOException
*/
public static IKettleFileSystemConfigBuilder getConfigBuilder(
VariableSpace varSpace, String scheme) throws IOException {
IKettleFileSystemConfigBuilder result = null;
// Attempt to load the Config Builder from a variable: vfs.config.parser = class
String parserClass =
varSpace.getVariable("vfs." + scheme + ".config.parser"); // $NON-NLS-1$ //$NON-NLS-2$
if (parserClass != null) {
try {
Class<?> configBuilderClass =
KettleFileSystemConfigBuilderFactory.class.getClassLoader().loadClass(parserClass);
Method mGetInstance = configBuilderClass.getMethod("getInstance"); // $NON-NLS-1$
if ((mGetInstance != null)
&& (IKettleFileSystemConfigBuilder.class.isAssignableFrom(
mGetInstance.getReturnType()))) {
result = (IKettleFileSystemConfigBuilder) mGetInstance.invoke(null);
} else {
result = (IKettleFileSystemConfigBuilder) configBuilderClass.newInstance();
}
} catch (Exception e) {
// Failed to load custom parser. Throw exception.
throw new IOException(
BaseMessages.getString(PKG, "CustomVfsSettingsParser.Log.FailedToLoad")); // $NON-NLS-1$
}
} else {
// No custom parser requested, load default
if (scheme.equalsIgnoreCase("sftp")) { // $NON-NLS-1$
result = KettleSftpFileSystemConfigBuilder.getInstance();
} else {
result = KettleGenericFileSystemConfigBuilder.getInstance();
}
}
return result;
}
public String buildFilename(
String filename,
String extension,
VariableSpace space,
int stepnr,
String partnr,
int splitnr,
boolean ziparchive,
TextFileOutputMeta meta) {
SimpleDateFormat daf = new SimpleDateFormat();
// Replace possible environment variables...
String retval = space.environmentSubstitute(filename);
String realextension = space.environmentSubstitute(extension);
if (meta.isFileAsCommand()) {
return retval;
}
Date now = new Date();
if (meta.isSpecifyingFormat() && !Const.isEmpty(meta.getDateTimeFormat())) {
daf.applyPattern(meta.getDateTimeFormat());
String dt = daf.format(now);
retval += dt;
} else {
if (meta.isDateInFilename()) {
daf.applyPattern("yyyMMdd");
String d = daf.format(now);
retval += "_" + d;
}
if (meta.isTimeInFilename()) {
daf.applyPattern("HHmmss");
String t = daf.format(now);
retval += "_" + t;
}
}
if (meta.isStepNrInFilename()) {
retval += "_" + stepnr;
}
if (meta.isPartNrInFilename()) {
retval += "_" + partnr;
}
if (meta.getSplitEvery() > 0) {
retval += "_" + splitnr;
}
if (meta.getFileCompression().equals("Zip")) {
if (ziparchive) {
retval += ".zip";
} else {
if (realextension != null && realextension.length() != 0) {
retval += "." + realextension;
}
}
} else {
if (realextension != null && realextension.length() != 0) {
retval += "." + realextension;
}
if (meta.getFileCompression().equals("GZip")) {
retval += ".gz";
}
}
return retval;
}
public static final synchronized TransMeta loadMappingMeta(
MappingMeta mappingMeta, Repository rep, VariableSpace space) throws KettleException {
TransMeta mappingTransMeta = null;
switch (mappingMeta.getSpecificationMethod()) {
case FILENAME:
String realFilename = space.environmentSubstitute(mappingMeta.getFileName());
try {
// OK, load the meta-data from file...
//
// Don't set internal variables: they belong to the parent thread!
//
mappingTransMeta = new TransMeta(realFilename, space);
mappingTransMeta
.getLogChannel()
.logDetailed(
"Loading Mapping from repository",
"Mapping transformation was loaded from XML file [" + realFilename + "]");
} catch (Exception e) {
throw new KettleException(
BaseMessages.getString(PKG, "MappingMeta.Exception.UnableToLoadMapping"), e);
}
break;
case REPOSITORY_BY_NAME:
String realTransname = space.environmentSubstitute(mappingMeta.getTransName());
String realDirectory = space.environmentSubstitute(mappingMeta.getDirectoryPath());
if (!Const.isEmpty(realTransname) && !Const.isEmpty(realDirectory) && rep != null) {
RepositoryDirectoryInterface repdir = rep.findDirectory(realDirectory);
if (repdir != null) {
try {
// reads the last revision in the repository...
//
mappingTransMeta = rep.loadTransformation(realTransname, repdir, null, true, null);
mappingTransMeta
.getLogChannel()
.logDetailed(
"Loading Mapping from repository",
"Mapping transformation ["
+ realTransname
+ "] was loaded from the repository");
} catch (Exception e) {
throw new KettleException("Unable to load transformation [" + realTransname + "]", e);
}
} else {
throw new KettleException(
BaseMessages.getString(
PKG, "MappingMeta.Exception.UnableToLoadTransformation", realTransname)
+ realDirectory); //$NON-NLS-1$ //$NON-NLS-2$
}
}
break;
case REPOSITORY_BY_REFERENCE:
// Read the last revision by reference...
mappingTransMeta = rep.loadTransformation(mappingMeta.getTransObjectId(), null);
break;
}
// Pass some important information to the mapping transformation metadata:
//
mappingTransMeta.copyVariablesFrom(space);
mappingTransMeta.setRepository(rep);
mappingTransMeta.setFilename(mappingTransMeta.getFilename());
return mappingTransMeta;
}
public void getFields(
RowMetaInterface row,
String origin,
RowMetaInterface info[],
StepMeta nextStep,
VariableSpace space)
throws KettleStepException {
// First load some interesting data...
// Then see which fields get added to the row.
//
TransMeta mappingTransMeta = null;
try {
mappingTransMeta = loadMappingMeta(this, repository, space);
} catch (KettleException e) {
throw new KettleStepException(
BaseMessages.getString(PKG, "MappingMeta.Exception.UnableToLoadMappingTransformation"),
e);
}
// The field structure may depend on the input parameters as well (think of parameter
// replacements in MDX queries for instance)
if (mappingParameters != null) {
// See if we need to pass all variables from the parent or not...
//
if (mappingParameters.isInheritingAllVariables()) {
mappingTransMeta.copyVariablesFrom(space);
}
// Just set the variables in the transformation statically.
// This just means: set a number of variables or parameter values:
//
List<String> subParams = Arrays.asList(mappingTransMeta.listParameters());
for (int i = 0; i < mappingParameters.getVariable().length; i++) {
String name = mappingParameters.getVariable()[i];
String value = space.environmentSubstitute(mappingParameters.getInputField()[i]);
if (!Const.isEmpty(name) && !Const.isEmpty(value)) {
if (subParams.contains(name)) {
try {
mappingTransMeta.setParameterValue(name, value);
} catch (UnknownParamException e) {
// this is explicitly checked for up front
}
}
mappingTransMeta.setVariable(name, value);
}
}
}
// Keep track of all the fields that need renaming...
//
List<MappingValueRename> inputRenameList = new ArrayList<MappingValueRename>();
/*
* Before we ask the mapping outputs anything, we should teach the mapping
* input steps in the sub-transformation about the data coming in...
*/
for (MappingIODefinition definition : inputMappings) {
RowMetaInterface inputRowMeta;
if (definition.isMainDataPath() || Const.isEmpty(definition.getInputStepname())) {
// The row metadata, what we pass to the mapping input step
// definition.getOutputStep(), is "row"
// However, we do need to re-map some fields...
//
inputRowMeta = row.clone();
if (!inputRowMeta.isEmpty()) {
for (MappingValueRename valueRename : definition.getValueRenames()) {
ValueMetaInterface valueMeta =
inputRowMeta.searchValueMeta(valueRename.getSourceValueName());
if (valueMeta == null) {
throw new KettleStepException(
BaseMessages.getString(
PKG,
"MappingMeta.Exception.UnableToFindField",
valueRename.getSourceValueName()));
}
valueMeta.setName(valueRename.getTargetValueName());
}
}
} else {
// The row metadata that goes to the info mapping input comes from the
// specified step
// In fact, it's one of the info steps that is going to contain this
// information...
//
String[] infoSteps = getInfoSteps();
int infoStepIndex = Const.indexOfString(definition.getInputStepname(), infoSteps);
if (infoStepIndex < 0) {
throw new KettleStepException(
BaseMessages.getString(
PKG,
"MappingMeta.Exception.UnableToFindMetadataInfo",
definition.getInputStepname()));
}
if (info[infoStepIndex] != null) {
inputRowMeta = info[infoStepIndex].clone();
} else {
inputRowMeta = null;
}
}
// What is this mapping input step?
//
StepMeta mappingInputStep =
mappingTransMeta.findMappingInputStep(definition.getOutputStepname());
// We're certain it's a MappingInput step...
//
MappingInputMeta mappingInputMeta =
(MappingInputMeta) mappingInputStep.getStepMetaInterface();
// Inform the mapping input step about what it's going to receive...
//
mappingInputMeta.setInputRowMeta(inputRowMeta);
// What values are we changing names for?
//
mappingInputMeta.setValueRenames(definition.getValueRenames());
// Keep a list of the input rename values that need to be changed back at
// the output
//
if (definition.isRenamingOnOutput())
Mapping.addInputRenames(inputRenameList, definition.getValueRenames());
}
// All the mapping steps now know what they will be receiving.
// That also means that the sub-transformation / mapping has everything it
// needs.
// So that means that the MappingOutput steps know exactly what the output
// is going to be.
// That could basically be anything.
// It also could have absolutely no resemblance to what came in on the
// input.
// The relative old approach is therefore no longer suited.
//
// OK, but what we *can* do is have the MappingOutput step rename the
// appropriate fields.
// The mapping step will tell this step how it's done.
//
// Let's look for the mapping output step that is relevant for this actual
// call...
//
MappingIODefinition mappingOutputDefinition = null;
if (nextStep == null) {
// This is the main step we read from...
// Look up the main step to write to.
// This is the output mapping definition with "main path" enabled.
//
for (MappingIODefinition definition : outputMappings) {
if (definition.isMainDataPath() || Const.isEmpty(definition.getOutputStepname())) {
// This is the definition to use...
//
mappingOutputDefinition = definition;
}
}
} else {
// Is there an output mapping definition for this step?
// If so, we can look up the Mapping output step to see what has changed.
//
for (MappingIODefinition definition : outputMappings) {
if (nextStep.getName().equals(definition.getOutputStepname())
|| definition.isMainDataPath()
|| Const.isEmpty(definition.getOutputStepname())) {
mappingOutputDefinition = definition;
}
}
}
if (mappingOutputDefinition == null) {
throw new KettleStepException(
BaseMessages.getString(PKG, "MappingMeta.Exception.UnableToFindMappingDefinition"));
}
// OK, now find the mapping output step in the mapping...
// This method in TransMeta takes into account a number of things, such as
// the step not specified, etc.
// The method never returns null but throws an exception.
//
StepMeta mappingOutputStep =
mappingTransMeta.findMappingOutputStep(mappingOutputDefinition.getInputStepname());
// We know it's a mapping output step...
MappingOutputMeta mappingOutputMeta =
(MappingOutputMeta) mappingOutputStep.getStepMetaInterface();
// Change a few columns.
mappingOutputMeta.setOutputValueRenames(mappingOutputDefinition.getValueRenames());
// Perhaps we need to change a few input columns back to the original?
//
mappingOutputMeta.setInputValueRenames(inputRenameList);
// Now we know wat's going to come out of there...
// This is going to be the full row, including all the remapping, etc.
//
RowMetaInterface mappingOutputRowMeta = mappingTransMeta.getStepFields(mappingOutputStep);
row.clear();
row.addRowMeta(mappingOutputRowMeta);
}
public int getBatchSizeInt(VariableSpace vars) {
return Const.toInt(vars.environmentSubstitute(this.batchSize), DEFAULT_BATCH_SIZE);
}
public String[] getFilePaths(VariableSpace space) {
return new String[] {
space.environmentSubstitute(filename),
};
}
public String fieldSubstitute(String aString, RowMetaInterface rowMeta, Object[] rowData)
throws KettleValueException {
return variables.fieldSubstitute(aString, rowMeta, rowData);
}
public void getFields(
RowMetaInterface rowMeta,
String origin,
RowMetaInterface[] info,
StepMeta nextStep,
VariableSpace space)
throws KettleStepException {
rowMeta.clear(); // Start with a clean slate, eats the input
for (int i = 0; i < inputFields.length; i++) {
TextFileInputField field = inputFields[i];
ValueMetaInterface valueMeta = new ValueMeta(field.getName(), field.getType());
valueMeta.setConversionMask(field.getFormat());
valueMeta.setLength(field.getLength());
valueMeta.setPrecision(field.getPrecision());
valueMeta.setConversionMask(field.getFormat());
valueMeta.setDecimalSymbol(field.getDecimalSymbol());
valueMeta.setGroupingSymbol(field.getGroupSymbol());
valueMeta.setCurrencySymbol(field.getCurrencySymbol());
valueMeta.setTrimType(field.getTrimType());
if (lazyConversionActive)
valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
valueMeta.setStringEncoding(space.environmentSubstitute(encoding));
// In case we want to convert Strings...
// Using a copy of the valueMeta object means that the inner and outer representation format
// is the same.
// Preview will show the data the same way as we read it.
// This layout is then taken further down the road by the metadata through the transformation.
//
ValueMetaInterface storageMetadata = valueMeta.clone();
storageMetadata.setType(ValueMetaInterface.TYPE_STRING);
storageMetadata.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
storageMetadata.setLength(
-1, -1); // we don't really know the lengths of the strings read in advance.
valueMeta.setStorageMetadata(storageMetadata);
valueMeta.setOrigin(origin);
rowMeta.addValueMeta(valueMeta);
}
if (!Const.isEmpty(filenameField) && includingFilename) {
ValueMetaInterface filenameMeta =
new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING);
filenameMeta.setOrigin(origin);
if (lazyConversionActive) {
filenameMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
filenameMeta.setStorageMetadata(
new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING));
}
rowMeta.addValueMeta(filenameMeta);
}
if (!Const.isEmpty(rowNumField)) {
ValueMetaInterface rowNumMeta = new ValueMeta(rowNumField, ValueMetaInterface.TYPE_INTEGER);
rowNumMeta.setLength(10);
rowNumMeta.setOrigin(origin);
rowMeta.addValueMeta(rowNumMeta);
}
}
/**
* @param vs - variable space to be used for searching variable value usually "this" for a calling
* step
* @return Returns the commitSize.
*/
public int getCommitSize(VariableSpace vs) {
return Integer.parseInt(vs.environmentSubstitute(commitSize));
}
/**
* @param vs - variable space to be used for searching variable value usually "this" for a calling
* step
* @return Returns the commitSize.
*/
public int getCommitSize(VariableSpace vs) {
// this happens when the step is created via API and no setDefaults was called
commitSize = (commitSize == null) ? "0" : commitSize;
return Integer.parseInt(vs.environmentSubstitute(commitSize));
}
public String[] environmentSubstitute(String[] aString) {
return variables.environmentSubstitute(aString);
}
public void copyVariablesFrom(VariableSpace space) {
variables.copyVariablesFrom(space);
}