org.pentaho.di.trans
Class Trans

java.lang.Object
  extended by org.pentaho.di.trans.Trans
All Implemented Interfaces:
org.pentaho.di.core.parameters.NamedParams, org.pentaho.di.core.variables.VariableSpace

public class Trans
extends Object
implements org.pentaho.di.core.variables.VariableSpace, org.pentaho.di.core.parameters.NamedParams

This class is responsible for the execution of Transformations. It loads, instantiates, initializes, runs, monitors the execution of the transformation contained in the TransInfo object you feed it.

Since:
07-04-2003
Author:
Matt

Field Summary
 int class_nr
           
static String CONFIGURATION_IN_EXPORT_FILENAME
           
static String REPLAY_DATE_FORMAT
           
static String STRING_FINISHED
           
static String STRING_HALTING
           
static String STRING_INITIALIZING
           
static String STRING_PREPARING
           
static String STRING_RUNNING
           
static String STRING_STOPPED
           
static String STRING_WAITING
           
static int TYPE_DISP_1_1
           
static int TYPE_DISP_1_N
           
static int TYPE_DISP_N_1
           
static int TYPE_DISP_N_M
           
static int TYPE_DISP_N_N
           
 
Constructor Summary
Trans(TransMeta transMeta)
          Initialize a transformation from transformation meta-data defined in memory
Trans(org.pentaho.di.core.variables.VariableSpace parentVariableSpace, Repository rep, String name, String dirname, String filename)
           
 
Method Summary
 void activateParameters()
           
 void addParameterDefinition(String key, String defValue, String description)
           
 RowProducer addRowProducer(String stepname, int copynr)
          This adds a row producer to the transformation that just got set up.
 void addTransListener(TransListener transListener)
           
 void beginProcessing()
           
 void cleanup()
          Call this method after the transformation has finished.
 void clearParameters()
           
 void copyParametersFrom(org.pentaho.di.core.parameters.NamedParams params)
           
 void copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)
           
 boolean endProcessing(String status)
           
 String environmentSubstitute(String aString)
           
 String[] environmentSubstitute(String[] aString)
           
 void eraseParameters()
           
 void execute(String[] arguments)
          Execute this transformation.
static TransSplitter executeClustered(TransMeta transMeta, TransExecutionConfiguration executionConfiguration)
           
static void executeClustered(TransSplitter transSplitter, TransExecutionConfiguration executionConfiguration)
          executes an existing transSplitter, with transformation already split.
 List<BaseStep> findBaseSteps(String stepname)
           
 StepDataInterface findDataInterface(String name)
           
 MappingInput[] findMappingInput()
           
 MappingOutput[] findMappingOutput()
           
 org.pentaho.di.core.RowSet findRowSet(String rowsetname)
           
 org.pentaho.di.core.RowSet findRowSet(String from, int fromcopy, String to, int tocopy)
           
 BaseStep findRunThread(String stepname)
           
 long getBatchId()
           
 boolean getBooleanValueOfVariable(String variableName, boolean defaultValue)
           
static org.pentaho.di.core.Result getClusteredTransformationResult(String logSubject, TransSplitter transSplitter, Job parentJob)
           
 Date getCurrentDate()
           
 Date getDepDate()
           
 Date getEndDate()
           
 int getEnded()
           
 int getErrors()
           
 Date getJobEndDate()
           
 Date getJobStartDate()
           
 long getLastProcessed()
           
 Date getLogDate()
           
 String getMappingStepName()
           
 String getName()
           
 String getParameterDefault(String key)
           
 String getParameterDescription(String key)
           
 String getParameterValue(String key)
           
 Job getParentJob()
           
 Trans getParentTrans()
           
 org.pentaho.di.core.variables.VariableSpace getParentVariableSpace()
           
 long getPassedBatchId()
           
 Date getReplayDate()
           
 Repository getRepository()
           
 org.pentaho.di.core.Result getResult()
           
 List<org.pentaho.di.core.RowSet> getRowsets()
           
 BaseStep getRunThread(int i)
           
 BaseStep getRunThread(String name, int copy)
           
 SocketRepository getSocketRepository()
           
 Date getStartDate()
           
 String getStatus()
           
 StepDataInterface getStepDataInterface(String stepname, int stepcopy)
          Finds the StepDataInterface (currently) associated with the specified step
 StepInterface getStepInterface(String stepname, int copy)
          Find the StepInterface (thread) by looking it up using the name
 Map<String,List<StepPerformanceSnapShot>> getStepPerformanceSnapShots()
           
 List<StepMetaDataCombi> getSteps()
           
 String getThreadName()
           
 List<TransListener> getTransListeners()
           
 TransMeta getTransMeta()
           
 String getVariable(String variableName)
           
 String getVariable(String variableName, String defaultValue)
           
 boolean hasHaltedSteps()
           
 boolean hasStepStarted(String sname, int copy)
           
 void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)
           
 void injectVariables(Map<String,String> prop)
           
 boolean isFinished()
           
 boolean isInitializing()
           
 boolean isMonitored()
           
 boolean isPaused()
           
 boolean isPreparing()
           
 boolean isPreview()
           
 boolean isReadyToStart()
           
 boolean isRunning()
           
 boolean isSafeModeEnabled()
           
 boolean isStopped()
           
 void killAll()
           
 String[] listParameters()
           
 String[] listVariables()
           
 void logSummary(StepInterface si)
           
static long monitorClusteredTransformation(String logSubject, TransSplitter transSplitter, Job parentJob)
          Consider that all the transformations in a cluster schema are running now...
Now we should verify that they are all running as they should.
If a transformation has an error, we should kill them all..
This should happen in a separate thread to prevent blocking of the UI.

When the master and slave transformations have all finished, we should also run
a cleanup on those transformations to release sockets, etc.

static long monitorClusteredTransformation(String logSubject, TransSplitter transSplitter, Job parentJob, int sleepTimeSeconds)
          Consider that all the transformations in a cluster schema are running now...
Now we should verify that they are all running as they should.
If a transformation has an error, we should kill them all..
This should happen in a separate thread to prevent blocking of the UI.

When the master and slave transformations have all finished, we should also run
a cleanup on those transformations to release sockets, etc.

static void monitorRemoteTransformation(String transName, SlaveServer remoteSlaveServer)
           
static void monitorRemoteTransformation(String transName, SlaveServer remoteSlaveServer, int sleepTimeSeconds)
           
 int nrActiveSteps()
           
 int nrSteps()
           
 void pauseRunning()
          Pause the transformation (pause all steps)
 void prepareExecution(String[] arguments)
          Prepare the execution of the transformation.
 void printStats(int seconds)
           
 void resumeRunning()
          Resume running the transformation after a pause (resume all steps)
static void sendToSlaveServer(TransMeta transMeta, TransExecutionConfiguration executionConfiguration, Repository repository)
           
 void setBatchId(long batchId)
           
 void setInitializing(boolean initializing)
           
 void setInternalKettleVariables(org.pentaho.di.core.variables.VariableSpace var)
           
 void setJobEndDate(Date jobEndDate)
           
 void setJobStartDate(Date jobStartDate)
           
 void setMappingStepName(String mappingStepName)
           
 void setMonitored(boolean monitored)
           
 void setParameterValue(String key, String value)
           
 void setParentJob(Job parentJob)
           
 void setParentTrans(Trans parentTrans)
           
 void setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)
           
 void setPassedBatchId(long jobBatchId)
           
 void setPreparing(boolean preparing)
           
 void setPreview(boolean preview)
           
 void setReplayDate(Date replayDate)
           
 void setRepository(Repository repository)
           
 void setRunning(boolean running)
           
 void setSafeModeEnabled(boolean safeModeEnabled)
          Turn on safe mode during running: the transformation will run slower but with more checking enabled.
 void setSocketRepository(SocketRepository socketRepository)
           
 void setStepPerformanceSnapShots(Map<String,List<StepPerformanceSnapShot>> stepPerformanceSnapShots)
           
 void setThreadName(String threadName)
           
 void setTransListeners(List<TransListener> transListeners)
           
 void setTransMeta(TransMeta transMeta)
           
 void setVariable(String variableName, String variableValue)
           
 void shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)
           
 void startThreads()
          Start the threads prepared by prepareThreads(); Before you start the threads, you can add RowListeners to them.
 void stopAll()
           
 String toString()
           
 void waitUntilFinished()
           
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

REPLAY_DATE_FORMAT

public static final String REPLAY_DATE_FORMAT
See Also:
Constant Field Values

class_nr

public int class_nr

TYPE_DISP_1_1

public static final int TYPE_DISP_1_1
See Also:
Constant Field Values

TYPE_DISP_1_N

public static final int TYPE_DISP_1_N
See Also:
Constant Field Values

TYPE_DISP_N_1

public static final int TYPE_DISP_N_1
See Also:
Constant Field Values

TYPE_DISP_N_N

public static final int TYPE_DISP_N_N
See Also:
Constant Field Values

TYPE_DISP_N_M

public static final int TYPE_DISP_N_M
See Also:
Constant Field Values

STRING_FINISHED

public static final String STRING_FINISHED
See Also:
Constant Field Values

STRING_RUNNING

public static final String STRING_RUNNING
See Also:
Constant Field Values

STRING_PREPARING

public static final String STRING_PREPARING
See Also:
Constant Field Values

STRING_INITIALIZING

public static final String STRING_INITIALIZING
See Also:
Constant Field Values

STRING_WAITING

public static final String STRING_WAITING
See Also:
Constant Field Values

STRING_STOPPED

public static final String STRING_STOPPED
See Also:
Constant Field Values

STRING_HALTING

public static final String STRING_HALTING
See Also:
Constant Field Values

CONFIGURATION_IN_EXPORT_FILENAME

public static final String CONFIGURATION_IN_EXPORT_FILENAME
See Also:
Constant Field Values
Constructor Detail

Trans

public Trans(TransMeta transMeta)
Initialize a transformation from transformation meta-data defined in memory

Parameters:
transMeta - the transformation meta-data to use.

Trans

public Trans(org.pentaho.di.core.variables.VariableSpace parentVariableSpace,
             Repository rep,
             String name,
             String dirname,
             String filename)
      throws org.pentaho.di.core.exception.KettleException
Throws:
org.pentaho.di.core.exception.KettleException
Method Detail

getName

public String getName()

execute

public void execute(String[] arguments)
             throws org.pentaho.di.core.exception.KettleException
Execute this transformation.

Throws:
org.pentaho.di.core.exception.KettleException - in case the transformation could not be prepared (initialized)

prepareExecution

public void prepareExecution(String[] arguments)
                      throws org.pentaho.di.core.exception.KettleException
Prepare the execution of the transformation.

Parameters:
arguments - the arguments to use for this transformation
Throws:
org.pentaho.di.core.exception.KettleException - in case the transformation could not be prepared (initialized)

startThreads

public void startThreads()
                  throws org.pentaho.di.core.exception.KettleException
Start the threads prepared by prepareThreads(); Before you start the threads, you can add RowListeners to them.

Throws:
org.pentaho.di.core.exception.KettleException - in case there is a communication error with a remote output socket.

cleanup

public void cleanup()
Call this method after the transformation has finished. Typically, after ALL the slave transformations in a clustered run have finished.


logSummary

public void logSummary(StepInterface si)

waitUntilFinished

public void waitUntilFinished()

getErrors

public int getErrors()

getEnded

public int getEnded()

isFinished

public boolean isFinished()

killAll

public void killAll()

printStats

public void printStats(int seconds)

getLastProcessed

public long getLastProcessed()

findRowSet

public org.pentaho.di.core.RowSet findRowSet(String rowsetname)

findRowSet

public org.pentaho.di.core.RowSet findRowSet(String from,
                                             int fromcopy,
                                             String to,
                                             int tocopy)

hasStepStarted

public boolean hasStepStarted(String sname,
                              int copy)

stopAll

public void stopAll()

nrSteps

public int nrSteps()

nrActiveSteps

public int nrActiveSteps()

getRunThread

public BaseStep getRunThread(int i)

getRunThread

public BaseStep getRunThread(String name,
                             int copy)

beginProcessing

public void beginProcessing()
                     throws org.pentaho.di.core.exception.KettleTransException
Throws:
org.pentaho.di.core.exception.KettleTransException

getResult

public org.pentaho.di.core.Result getResult()

endProcessing

public boolean endProcessing(String status)
                      throws org.pentaho.di.core.exception.KettleException
Throws:
org.pentaho.di.core.exception.KettleException

findRunThread

public BaseStep findRunThread(String stepname)

findBaseSteps

public List<BaseStep> findBaseSteps(String stepname)

findDataInterface

public StepDataInterface findDataInterface(String name)

getStartDate

public Date getStartDate()
Returns:
Returns the startDate.

getEndDate

public Date getEndDate()
Returns:
Returns the endDate.

isMonitored

public boolean isMonitored()
Returns:
See if the running transformation is monitored.

setMonitored

public void setMonitored(boolean monitored)
Parameters:
monitored - Indicate we want to monitor the running transformation

getTransMeta

public TransMeta getTransMeta()
Returns:
Returns the transMeta.

setTransMeta

public void setTransMeta(TransMeta transMeta)
Parameters:
transMeta - The transMeta to set.

getCurrentDate

public Date getCurrentDate()
Returns:
Returns the currentDate.

getDepDate

public Date getDepDate()
Returns:
Returns the depDate.

getLogDate

public Date getLogDate()
Returns:
Returns the logDate.

getRowsets

public List<org.pentaho.di.core.RowSet> getRowsets()
Returns:
Returns the rowsets.

getSteps

public List<StepMetaDataCombi> getSteps()
Returns:
Returns the steps.

toString

public String toString()
Overrides:
toString in class Object

findMappingInput

public MappingInput[] findMappingInput()

findMappingOutput

public MappingOutput[] findMappingOutput()

getStepInterface

public StepInterface getStepInterface(String stepname,
                                      int copy)
Find the StepInterface (thread) by looking it up using the name

Parameters:
stepname - The name of the step to look for
copy - the copy number of the step to look for
Returns:
the StepInterface or null if nothing was found.

getReplayDate

public Date getReplayDate()

setReplayDate

public void setReplayDate(Date replayDate)

setSafeModeEnabled

public void setSafeModeEnabled(boolean safeModeEnabled)
Turn on safe mode during running: the transformation will run slower but with more checking enabled.

Parameters:
safeModeEnabled - true for safe mode

isSafeModeEnabled

public boolean isSafeModeEnabled()
Returns:
Returns true if the safe mode is enabled: the transformation will run slower but with more checking enabled

addRowProducer

public RowProducer addRowProducer(String stepname,
                                  int copynr)
                           throws org.pentaho.di.core.exception.KettleException
This adds a row producer to the transformation that just got set up. Preferable run this BEFORE execute() but after prepareExcution()

Parameters:
stepname - The step to produce rows for
copynr - The copynr of the step to produce row for (normally 0 unless you have multiple copies running)
Throws:
org.pentaho.di.core.exception.KettleException - in case the thread/step to produce rows for could not be found.

getParentJob

public Job getParentJob()
Returns:
Returns the parentJob.

setParentJob

public void setParentJob(Job parentJob)
Parameters:
parentJob - The parentJob to set.

getStepDataInterface

public StepDataInterface getStepDataInterface(String stepname,
                                              int stepcopy)
Finds the StepDataInterface (currently) associated with the specified step

Parameters:
stepname - The name of the step to look for
stepcopy - The copy number (0 based) of the step
Returns:
The StepDataInterface or null if non found.

hasHaltedSteps

public boolean hasHaltedSteps()
Returns:
true if one or more steps are halted

getJobStartDate

public Date getJobStartDate()

getJobEndDate

public Date getJobEndDate()

setJobEndDate

public void setJobEndDate(Date jobEndDate)
Parameters:
jobEndDate - the jobEndDate to set

setJobStartDate

public void setJobStartDate(Date jobStartDate)
Parameters:
jobStartDate - the jobStartDate to set

getPassedBatchId

public long getPassedBatchId()
Returns:
the jobBatchId

setPassedBatchId

public void setPassedBatchId(long jobBatchId)
Parameters:
jobBatchId - the jobBatchId to set

getBatchId

public long getBatchId()
Returns:
the batchId

setBatchId

public void setBatchId(long batchId)
Parameters:
batchId - the batchId to set

getThreadName

public String getThreadName()
Returns:
the threadName

setThreadName

public void setThreadName(String threadName)
Parameters:
threadName - the threadName to set

getStatus

public String getStatus()

isInitializing

public boolean isInitializing()
Returns:
the initializing

setInitializing

public void setInitializing(boolean initializing)
Parameters:
initializing - the initializing to set

isPreparing

public boolean isPreparing()
Returns:
the preparing

setPreparing

public void setPreparing(boolean preparing)
Parameters:
preparing - the preparing to set

isRunning

public boolean isRunning()
Returns:
the running

setRunning

public void setRunning(boolean running)
Parameters:
running - the running to set

executeClustered

public static final TransSplitter executeClustered(TransMeta transMeta,
                                                   TransExecutionConfiguration executionConfiguration)
                                            throws org.pentaho.di.core.exception.KettleException
Throws:
org.pentaho.di.core.exception.KettleException

executeClustered

public static final void executeClustered(TransSplitter transSplitter,
                                          TransExecutionConfiguration executionConfiguration)
                                   throws org.pentaho.di.core.exception.KettleException
executes an existing transSplitter, with transformation already split. See also : org.pentaho.di.ui.spoon.delegates.SpoonTransformationDelegate

Parameters:
transSplitter -
executionConfiguration -
Throws:
org.pentaho.di.core.exception.KettleException

monitorClusteredTransformation

public static final long monitorClusteredTransformation(String logSubject,
                                                        TransSplitter transSplitter,
                                                        Job parentJob)
Consider that all the transformations in a cluster schema are running now...
Now we should verify that they are all running as they should.
If a transformation has an error, we should kill them all..
This should happen in a separate thread to prevent blocking of the UI.

When the master and slave transformations have all finished, we should also run
a cleanup on those transformations to release sockets, etc.

Parameters:
logSubject - the subject to use for logging
transSplitter - the transformation splitter object
parentJob - the parent job when executed in a job, otherwise just set to null
sleepTimeSeconds - the sleep time in seconds in between slave transformation status polling
Returns:
the number of errors encountered

monitorClusteredTransformation

public static final long monitorClusteredTransformation(String logSubject,
                                                        TransSplitter transSplitter,
                                                        Job parentJob,
                                                        int sleepTimeSeconds)
Consider that all the transformations in a cluster schema are running now...
Now we should verify that they are all running as they should.
If a transformation has an error, we should kill them all..
This should happen in a separate thread to prevent blocking of the UI.

When the master and slave transformations have all finished, we should also run
a cleanup on those transformations to release sockets, etc.

Parameters:
logSubject - the subject to use for logging
transSplitter - the transformation splitter object
parentJob - the parent job when executed in a job, otherwise just set to null
sleepTimeSeconds - the sleep time in seconds in between slave transformation status polling
Returns:
the number of errors encountered

getClusteredTransformationResult

public static final org.pentaho.di.core.Result getClusteredTransformationResult(String logSubject,
                                                                                TransSplitter transSplitter,
                                                                                Job parentJob)

sendToSlaveServer

public static void sendToSlaveServer(TransMeta transMeta,
                                     TransExecutionConfiguration executionConfiguration,
                                     Repository repository)
                              throws org.pentaho.di.core.exception.KettleException
Throws:
org.pentaho.di.core.exception.KettleException

isReadyToStart

public boolean isReadyToStart()
Returns:
true if the transformation was prepared for execution successfully.
See Also:
prepareExecution(String[])

setInternalKettleVariables

public void setInternalKettleVariables(org.pentaho.di.core.variables.VariableSpace var)

copyVariablesFrom

public void copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)
Specified by:
copyVariablesFrom in interface org.pentaho.di.core.variables.VariableSpace

environmentSubstitute

public String environmentSubstitute(String aString)
Specified by:
environmentSubstitute in interface org.pentaho.di.core.variables.VariableSpace

environmentSubstitute

public String[] environmentSubstitute(String[] aString)
Specified by:
environmentSubstitute in interface org.pentaho.di.core.variables.VariableSpace

getParentVariableSpace

public org.pentaho.di.core.variables.VariableSpace getParentVariableSpace()
Specified by:
getParentVariableSpace in interface org.pentaho.di.core.variables.VariableSpace

setParentVariableSpace

public void setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)
Specified by:
setParentVariableSpace in interface org.pentaho.di.core.variables.VariableSpace

getVariable

public String getVariable(String variableName,
                          String defaultValue)
Specified by:
getVariable in interface org.pentaho.di.core.variables.VariableSpace

getVariable

public String getVariable(String variableName)
Specified by:
getVariable in interface org.pentaho.di.core.variables.VariableSpace

getBooleanValueOfVariable

public boolean getBooleanValueOfVariable(String variableName,
                                         boolean defaultValue)
Specified by:
getBooleanValueOfVariable in interface org.pentaho.di.core.variables.VariableSpace

initializeVariablesFrom

public void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)
Specified by:
initializeVariablesFrom in interface org.pentaho.di.core.variables.VariableSpace

listVariables

public String[] listVariables()
Specified by:
listVariables in interface org.pentaho.di.core.variables.VariableSpace

setVariable

public void setVariable(String variableName,
                        String variableValue)
Specified by:
setVariable in interface org.pentaho.di.core.variables.VariableSpace

shareVariablesWith

public void shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)
Specified by:
shareVariablesWith in interface org.pentaho.di.core.variables.VariableSpace

injectVariables

public void injectVariables(Map<String,String> prop)
Specified by:
injectVariables in interface org.pentaho.di.core.variables.VariableSpace

pauseRunning

public void pauseRunning()
Pause the transformation (pause all steps)


resumeRunning

public void resumeRunning()
Resume running the transformation after a pause (resume all steps)


isPreview

public boolean isPreview()
Returns:
the preview

setPreview

public void setPreview(boolean preview)
Parameters:
preview - the preview to set

getRepository

public Repository getRepository()
Returns:
the repository

setRepository

public void setRepository(Repository repository)
Parameters:
repository - the repository to set

getStepPerformanceSnapShots

public Map<String,List<StepPerformanceSnapShot>> getStepPerformanceSnapShots()
Returns:
the stepPerformanceSnapShots

setStepPerformanceSnapShots

public void setStepPerformanceSnapShots(Map<String,List<StepPerformanceSnapShot>> stepPerformanceSnapShots)
Parameters:
stepPerformanceSnapShots - the stepPerformanceSnapShots to set

getTransListeners

public List<TransListener> getTransListeners()
Returns:
the transListeners

setTransListeners

public void setTransListeners(List<TransListener> transListeners)
Parameters:
transListeners - the transListeners to set

addTransListener

public void addTransListener(TransListener transListener)

isPaused

public boolean isPaused()

isStopped

public boolean isStopped()

monitorRemoteTransformation

public static void monitorRemoteTransformation(String transName,
                                               SlaveServer remoteSlaveServer)

monitorRemoteTransformation

public static void monitorRemoteTransformation(String transName,
                                               SlaveServer remoteSlaveServer,
                                               int sleepTimeSeconds)

addParameterDefinition

public void addParameterDefinition(String key,
                                   String defValue,
                                   String description)
                            throws org.pentaho.di.core.parameters.DuplicateParamException
Specified by:
addParameterDefinition in interface org.pentaho.di.core.parameters.NamedParams
Throws:
org.pentaho.di.core.parameters.DuplicateParamException

getParameterDefault

public String getParameterDefault(String key)
                           throws org.pentaho.di.core.parameters.UnknownParamException
Specified by:
getParameterDefault in interface org.pentaho.di.core.parameters.NamedParams
Throws:
org.pentaho.di.core.parameters.UnknownParamException

getParameterDescription

public String getParameterDescription(String key)
                               throws org.pentaho.di.core.parameters.UnknownParamException
Specified by:
getParameterDescription in interface org.pentaho.di.core.parameters.NamedParams
Throws:
org.pentaho.di.core.parameters.UnknownParamException

getParameterValue

public String getParameterValue(String key)
                         throws org.pentaho.di.core.parameters.UnknownParamException
Specified by:
getParameterValue in interface org.pentaho.di.core.parameters.NamedParams
Throws:
org.pentaho.di.core.parameters.UnknownParamException

listParameters

public String[] listParameters()
Specified by:
listParameters in interface org.pentaho.di.core.parameters.NamedParams

setParameterValue

public void setParameterValue(String key,
                              String value)
                       throws org.pentaho.di.core.parameters.UnknownParamException
Specified by:
setParameterValue in interface org.pentaho.di.core.parameters.NamedParams
Throws:
org.pentaho.di.core.parameters.UnknownParamException

eraseParameters

public void eraseParameters()
Specified by:
eraseParameters in interface org.pentaho.di.core.parameters.NamedParams

clearParameters

public void clearParameters()
Specified by:
clearParameters in interface org.pentaho.di.core.parameters.NamedParams

activateParameters

public void activateParameters()
Specified by:
activateParameters in interface org.pentaho.di.core.parameters.NamedParams

copyParametersFrom

public void copyParametersFrom(org.pentaho.di.core.parameters.NamedParams params)
Specified by:
copyParametersFrom in interface org.pentaho.di.core.parameters.NamedParams

getParentTrans

public Trans getParentTrans()
Returns:
the parentTrans

setParentTrans

public void setParentTrans(Trans parentTrans)
Parameters:
parentTrans - the parentTrans to set

getMappingStepName

public String getMappingStepName()
Returns:
the name of the mapping step that created this transformation

setMappingStepName

public void setMappingStepName(String mappingStepName)
Parameters:
mappingStepName - the name of the mapping step that created this transformation

setSocketRepository

public void setSocketRepository(SocketRepository socketRepository)

getSocketRepository

public SocketRepository getSocketRepository()