ScriptDummy (PDI Engine 8.3.0.0-0.2.3 API)

java.lang.Object
- org.pentaho.di.trans.steps.script.ScriptDummy

所有已实现的接口:

HasLogChannelInterface, org.pentaho.di.core.variables.VariableSpace, StepInterface
```
public class ScriptDummy
extends Object
implements StepInterface
```
Dummy class used for test().

构造器概要

构造器
构造器和说明

ScriptDummy(org.pentaho.di.core.row.RowMetaInterface inputRowMeta, org.pentaho.di.core.row.RowMetaInterface outputRowMeta)

构造器
构造器和说明
`ScriptDummy(org.pentaho.di.core.row.RowMetaInterface inputRowMeta, org.pentaho.di.core.row.RowMetaInterface outputRowMeta)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`void`	`addRowListener(RowListener rowListener)` Add a rowlistener to the step allowing you to inspect (or manipulate, be careful) the rows coming in or exiting the step.
`void`	`addStepListener(StepListener stepListener)` Attach a step listener to be notified when a step arrives in a certain state.
`void`	`batchComplete()` Calling this method will alert the step that we finished passing a batch of records to the step.
`boolean`	`canProcessOneRow()` This method checks if the step is capable of processing at least one row.
`void`	`cleanup()` Call this method typically, after ALL the slave transformations in a clustered run have finished.
`void`	`copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)`
`void`	`dispose(StepMetaInterface sii, StepDataInterface sdi)` Dispose of this step: close files, empty logs, etc.
`String`	`environmentSubstitute(String aString)`
`String[]`	`environmentSubstitute(String[] string)`
`String`	`fieldSubstitute(String aString, org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] rowData)`
`boolean`	`getBooleanValueOfVariable(String variableName, boolean defaultValue)`
`int`	`getCopy()`
`int`	`getCurrentInputRowSetNr()`
`int`	`getCurrentOutputRowSetNr()`
`long`	`getErrors()` Get the number of errors
`org.pentaho.di.core.row.RowMetaInterface`	`getInputRowMeta()`
`List<org.pentaho.di.core.RowSet>`	`getInputRowSets()`
`long`	`getLinesInput()`
`long`	`getLinesOutput()`
`long`	`getLinesRead()`
`long`	`getLinesRejected()`
`long`	`getLinesUpdated()`
`long`	`getLinesWritten()`
`org.pentaho.di.core.logging.LogChannelInterface`	`getLogChannel()`
`org.pentaho.metastore.api.IMetaStore`	`getMetaStore()`
`org.pentaho.di.core.row.RowMetaInterface`	`getOutputRowMeta()`
`List<org.pentaho.di.core.RowSet>`	`getOutputRowSets()`
`org.pentaho.di.core.variables.VariableSpace`	`getParentVariableSpace()`
`String`	`getPartitionID()`
`long`	`getProcessed()`
`Repository`	`getRepository()`
`Map<String,org.pentaho.di.core.ResultFile>`	`getResultFiles()`
`Object[]`	`getRow()`
`List<RowListener>`	`getRowListeners()`
`long`	`getRuntime()`
`BaseStepData.StepExecutionStatus`	`getStatus()`
`String`	`getStepID()`
`StepMeta`	`getStepMeta()`
`String`	`getStepname()` Get the name of the step.
`Trans`	`getTrans()`
`String`	`getVariable(String variableName)`
`String`	`getVariable(String variableName, String defaultValue)`
`void`	`identifyErrorOutput()` To be used to flag an error output channel of a step prior to execution for performance reasons.
`boolean`	`init(StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface)` Initialize and do work where other steps need to wait for...
`void`	`initBeforeStart()` This method is executed by Trans right before the threads start and right after initialization.
`void`	`initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)`
`void`	`injectVariables(Map<String,String> prop)`
`boolean`	`isAlive()`
`boolean`	`isIdle()`
`boolean`	`isMapping()`
`boolean`	`isPartitioned()`
`boolean`	`isPassingData()`
`boolean`	`isPaused()`
`boolean`	`isRunning()`
`boolean`	`isStopped()`
`boolean`	`isUsingThreadPriorityManagment()`
`boolean`	`isWaitingForData()`
`String[]`	`listVariables()`
`void`	`markStart()` Mark the start time of the step.
`void`	`markStop()` Mark the end time of the step.
`void`	`pauseRunning()` Pause a running step
`boolean`	`processRow(StepMetaInterface smi, StepDataInterface sdi)` Perform the equivalent of processing one row.
`void`	`putRow(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row)` Put a row on the destination rowsets.
`void`	`removeRowListener(RowListener rowListener)` Remove a rowlistener from this step.
`void`	`resumeRunning()` Resume a running step
`int`	`rowsetInputSize()`
`int`	`rowsetOutputSize()`
`void`	`run()`
`void`	`setCurrentInputRowSetNr(int index)`
`void`	`setCurrentOutputRowSetNr(int index)`
`void`	`setErrors(long errors)` Sets the number of errors
`void`	`setLinesRejected(long linesRejected)`
`void`	`setMetaStore(org.pentaho.metastore.api.IMetaStore metaStore)` Pass along the metastore to use when loading external elements at runtime.
`void`	`setOutputDone()` Signal output done to destination steps
`void`	`setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)`
`void`	`setPartitioned(boolean partitioned)`
`void`	`setPartitionID(String partitionID)`
`void`	`setPassingData(boolean passingData)`
`void`	`setRepartitioning(int partitioningMethod)`
`void`	`setRepository(Repository repository)`
`void`	`setRunning(boolean running)` Flag the step as running or not
`void`	`setSafeStopped(boolean stopped)`
`void`	`setStopped(boolean stopped)`
`void`	`setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)`
`void`	`setVariable(String variableName, String variableValue)`
`void`	`setWaitingForData(boolean waitingForData)`
`void`	`shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)`
`void`	`start()`
`void`	`stopAll()` Flags all rowsets as stopped/completed/finished.
`void`	`stopRunning(StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface)` Stop running operations...

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.pentaho.di.trans.step.StepInterface
addRowSetToInputRowSets, addRowSetToOutputRowSets, isSafeStopped, subStatuses

- 构造器详细资料
  - ScriptDummy
```
public ScriptDummy(org.pentaho.di.core.row.RowMetaInterface inputRowMeta,
                   org.pentaho.di.core.row.RowMetaInterface outputRowMeta)
```
- 方法详细资料
  - processRow
```
public boolean processRow(StepMetaInterface smi,
                          StepDataInterface sdi)
                   throws org.pentaho.di.core.exception.KettleException
```
    从接口复制的说明: StepInterface
    
    Perform the equivalent of processing one row. Typically this means reading a row from input (getRow()) and passing a row to output (putRow)).
    
    指定者:
    
    processRow 在接口中 StepInterface
    
    参数:
    
    smi - The steps metadata to work with
    
    sdi - The steps temporary working data to work with (database connections, result sets, caches, temporary variables, etc.)
    
    返回:
    
    false if no more rows can be processed or an error occurred.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException
  - addRowListener
```
public void addRowListener(RowListener rowListener)
```
    从接口复制的说明: StepInterface
    
    Add a rowlistener to the step allowing you to inspect (or manipulate, be careful) the rows coming in or exiting the step.
    
    指定者:
    
    addRowListener 在接口中 StepInterface
    
    参数:
    
    rowListener - the rowlistener to add
  - dispose
```
public void dispose(StepMetaInterface sii,
                    StepDataInterface sdi)
```
    从接口复制的说明: StepInterface
    
    Dispose of this step: close files, empty logs, etc.
    
    指定者:
    
    dispose 在接口中 StepInterface
    
    参数:
    
    sii - The metadata to work with
    
    sdi - The data to dispose of
  - getErrors
```
public long getErrors()
```
    从接口复制的说明: StepInterface
    
    Get the number of errors
    
    指定者:
    
    getErrors 在接口中 StepInterface
    
    返回:
    
    the number of errors
  - getInputRowSets
```
public List<org.pentaho.di.core.RowSet> getInputRowSets()
```
    指定者:
    
    getInputRowSets 在接口中 StepInterface
    
    返回:
    
    The list of active input rowsets for the step
  - getLinesInput
```
public long getLinesInput()
```
    指定者:
    
    getLinesInput 在接口中 StepInterface
    
    返回:
    
    Returns the linesInput.
  - getLinesOutput
```
public long getLinesOutput()
```
    指定者:
    
    getLinesOutput 在接口中 StepInterface
    
    返回:
    
    Returns the linesOutput.
  - getLinesRead
```
public long getLinesRead()
```
    指定者:
    
    getLinesRead 在接口中 StepInterface
    
    返回:
    
    Returns the linesRead.
  - getLinesUpdated
```
public long getLinesUpdated()
```
    指定者:
    
    getLinesUpdated 在接口中 StepInterface
    
    返回:
    
    Returns the linesUpdated.
  - getLinesWritten
```
public long getLinesWritten()
```
    指定者:
    
    getLinesWritten 在接口中 StepInterface
    
    返回:
    
    Returns the linesWritten.
  - getLinesRejected
```
public long getLinesRejected()
```
    指定者:
    
    getLinesRejected 在接口中 StepInterface
    
    返回:
    
    Returns the lines rejected by error handling.
  - getOutputRowSets
```
public List<org.pentaho.di.core.RowSet> getOutputRowSets()
```
    指定者:
    
    getOutputRowSets 在接口中 StepInterface
    
    返回:
    
    The list of active output rowsets for the step
  - getPartitionID
```
public String getPartitionID()
```
    指定者:
    
    getPartitionID 在接口中 StepInterface
    
    返回:
    
    the steps partition ID
  - getRow
```
public Object[] getRow()
                throws org.pentaho.di.core.exception.KettleException
```
    指定者:
    
    getRow 在接口中 StepInterface
    
    返回:
    
    a row from the source step(s).
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException
  - getRowListeners
```
public List<RowListener> getRowListeners()
```
    指定者:
    
    getRowListeners 在接口中 StepInterface
    
    返回:
    
    a list of the installed RowListeners
  - getStepID
```
public String getStepID()
```
    指定者:
    
    getStepID 在接口中 StepInterface
    
    返回:
    
    the type ID of the step...
  - getStepname
```
public String getStepname()
```
    从接口复制的说明: StepInterface
    
    Get the name of the step.
    
    指定者:
    
    getStepname 在接口中 StepInterface
    
    返回:
    
    the name of the step
  - init
```
public boolean init(StepMetaInterface stepMetaInterface,
                    StepDataInterface stepDataInterface)
```
    从接口复制的说明: StepInterface
    
    Initialize and do work where other steps need to wait for...
    
    指定者:
    
    init 在接口中 StepInterface
    
    参数:
    
    stepMetaInterface - The metadata to work with
    
    stepDataInterface - The data to initialize
  - isAlive
```
public boolean isAlive()
```
  - isPartitioned
```
public boolean isPartitioned()
```
    指定者:
    
    isPartitioned 在接口中 StepInterface
    
    返回:
    
    true if the step is running partitioned
  - isStopped
```
public boolean isStopped()
```
    指定者:
    
    isStopped 在接口中 StepInterface
    
    返回:
    
    True if the step is marked as stopped. Execution should stop immediate.
  - markStart
```
public void markStart()
```
    从接口复制的说明: StepInterface
    
    Mark the start time of the step.
    
    指定者:
    
    markStart 在接口中 StepInterface
  - markStop
```
public void markStop()
```
    从接口复制的说明: StepInterface
    
    Mark the end time of the step.
    
    指定者:
    
    markStop 在接口中 StepInterface
  - putRow
```
public void putRow(org.pentaho.di.core.row.RowMetaInterface rowMeta,
                   Object[] row)
            throws org.pentaho.di.core.exception.KettleException
```
    从接口复制的说明: StepInterface
    
    Put a row on the destination rowsets.
    
    指定者:
    
    putRow 在接口中 StepInterface
    
    参数:
    
    rowMeta - The row to send to the destinations steps
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException
  - removeRowListener
```
public void removeRowListener(RowListener rowListener)
```
    从接口复制的说明: StepInterface
    
    Remove a rowlistener from this step.
    
    指定者:
    
    removeRowListener 在接口中 StepInterface
    
    参数:
    
    rowListener - the rowlistener to remove
  - run
```
public void run()
```
  - setErrors
```
public void setErrors(long errors)
```
    从接口复制的说明: StepInterface
    
    Sets the number of errors
    
    指定者:
    
    setErrors 在接口中 StepInterface
    
    参数:
    
    errors - the number of errors to set
  - setOutputDone
```
public void setOutputDone()
```
    从接口复制的说明: StepInterface
    
    Signal output done to destination steps
    
    指定者:
    
    setOutputDone 在接口中 StepInterface
  - setPartitionID
```
public void setPartitionID(String partitionID)
```
    指定者:
    
    setPartitionID 在接口中 StepInterface
    
    参数:
    
    partitionID - the partitionID to set
  - start
```
public void start()
```
  - stopAll
```
public void stopAll()
```
    从接口复制的说明: StepInterface
    
    Flags all rowsets as stopped/completed/finished.
    
    指定者:
    
    stopAll 在接口中 StepInterface
  - stopRunning
```
public void stopRunning(StepMetaInterface stepMetaInterface,
                        StepDataInterface stepDataInterface)
                 throws org.pentaho.di.core.exception.KettleException
```
    从接口复制的说明: StepInterface
    
    Stop running operations...
    
    指定者:
    
    stopRunning 在接口中 StepInterface
    
    参数:
    
    stepMetaInterface - The metadata that might be needed by the step to stop running.
    
    stepDataInterface - The interface to the step data containing the connections, resultsets, open files, etc.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException
  - cleanup
```
public void cleanup()
```
    从接口复制的说明: StepInterface
    
    Call this method typically, after ALL the slave transformations in a clustered run have finished.
    
    指定者:
    
    cleanup 在接口中 StepInterface
  - pauseRunning
```
public void pauseRunning()
```
    从接口复制的说明: StepInterface
    
    Pause a running step
    
    指定者:
    
    pauseRunning 在接口中 StepInterface
  - resumeRunning
```
public void resumeRunning()
```
    从接口复制的说明: StepInterface
    
    Resume a running step
    
    指定者:
    
    resumeRunning 在接口中 StepInterface
  - copyVariablesFrom
```
public void copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)
```
    指定者:
    
    copyVariablesFrom 在接口中 org.pentaho.di.core.variables.VariableSpace
  - environmentSubstitute
```
public String environmentSubstitute(String aString)
```
    指定者:
    
    environmentSubstitute 在接口中 org.pentaho.di.core.variables.VariableSpace
  - environmentSubstitute
```
public String[] environmentSubstitute(String[] string)
```
    指定者:
    
    environmentSubstitute 在接口中 org.pentaho.di.core.variables.VariableSpace
  - fieldSubstitute
```
public String fieldSubstitute(String aString,
                              org.pentaho.di.core.row.RowMetaInterface rowMeta,
                              Object[] rowData)
                       throws org.pentaho.di.core.exception.KettleValueException
```
    指定者:
    
    fieldSubstitute 在接口中 org.pentaho.di.core.variables.VariableSpace
    
    抛出:
    
    org.pentaho.di.core.exception.KettleValueException
  - getBooleanValueOfVariable
```
public boolean getBooleanValueOfVariable(String variableName,
                                         boolean defaultValue)
```
    指定者:
    
    getBooleanValueOfVariable 在接口中 org.pentaho.di.core.variables.VariableSpace
  - getParentVariableSpace
```
public org.pentaho.di.core.variables.VariableSpace getParentVariableSpace()
```
    指定者:
    
    getParentVariableSpace 在接口中 org.pentaho.di.core.variables.VariableSpace
  - setParentVariableSpace
```
public void setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)
```
    指定者:
    
    setParentVariableSpace 在接口中 org.pentaho.di.core.variables.VariableSpace
  - getVariable
```
public String getVariable(String variableName,
                          String defaultValue)
```
    指定者:
    
    getVariable 在接口中 org.pentaho.di.core.variables.VariableSpace
  - getVariable
```
public String getVariable(String variableName)
```
    指定者:
    
    getVariable 在接口中 org.pentaho.di.core.variables.VariableSpace
  - initializeVariablesFrom
```
public void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)
```
    指定者:
    
    initializeVariablesFrom 在接口中 org.pentaho.di.core.variables.VariableSpace
  - injectVariables
```
public void injectVariables(Map<String,String> prop)
```
    指定者:
    
    injectVariables 在接口中 org.pentaho.di.core.variables.VariableSpace
  - listVariables
```
public String[] listVariables()
```
    指定者:
    
    listVariables 在接口中 org.pentaho.di.core.variables.VariableSpace
  - setVariable
```
public void setVariable(String variableName,
                        String variableValue)
```
    指定者:
    
    setVariable 在接口中 org.pentaho.di.core.variables.VariableSpace
  - shareVariablesWith
```
public void shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)
```
    指定者:
    
    shareVariablesWith 在接口中 org.pentaho.di.core.variables.VariableSpace
  - getInputRowMeta
```
public org.pentaho.di.core.row.RowMetaInterface getInputRowMeta()
```
  - getOutputRowMeta
```
public org.pentaho.di.core.row.RowMetaInterface getOutputRowMeta()
```
  - initBeforeStart
```
public void initBeforeStart()
                     throws org.pentaho.di.core.exception.KettleStepException
```
    从接口复制的说明: StepInterface
    
    This method is executed by Trans right before the threads start and right after initialization.
    
    !!! A plugin implementing this method should make sure to also call super.initBeforeStart(); !!!
    
    指定者:
    
    initBeforeStart 在接口中 StepInterface
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - In case there is an error
  - setLinesRejected
```
public void setLinesRejected(long linesRejected)
```
    指定者:
    
    setLinesRejected 在接口中 StepInterface
    
    参数:
    
    linesRejected - steps the lines rejected by error handling.
  - getCopy
```
public int getCopy()
```
    指定者:
    
    getCopy 在接口中 StepInterface
    
    返回:
    
    The steps copy number (default 0)
  - addStepListener
```
public void addStepListener(StepListener stepListener)
```
    从接口复制的说明: StepInterface
    
    Attach a step listener to be notified when a step arrives in a certain state. (finished)
    
    指定者:
    
    addStepListener 在接口中 StepInterface
    
    参数:
    
    stepListener - The listener to add to the step
  - isMapping
```
public boolean isMapping()
```
    指定者:
    
    isMapping 在接口中 StepInterface
    
    返回:
    
    true if the thread is a special mapping step
  - getStepMeta
```
public StepMeta getStepMeta()
```
    指定者:
    
    getStepMeta 在接口中 StepInterface
    
    返回:
    
    The metadata for this step
  - getTrans
```
public Trans getTrans()
```
    指定者:
    
    getTrans 在接口中 StepInterface
    
    返回:
    
    the transformation that is executing this step
  - getLogChannel
```
public org.pentaho.di.core.logging.LogChannelInterface getLogChannel()
```
    指定者:
    
    getLogChannel 在接口中 HasLogChannelInterface
    
    指定者:
    
    getLogChannel 在接口中 StepInterface
    
    返回:
    
    the logging channel for this step
  - isUsingThreadPriorityManagment
```
public boolean isUsingThreadPriorityManagment()
```
    指定者:
    
    isUsingThreadPriorityManagment 在接口中 StepInterface
    
    返回:
    
    true if we are actively managing priorities of step threads
  - setUsingThreadPriorityManagment
```
public void setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)
```
    指定者:
    
    setUsingThreadPriorityManagment 在接口中 StepInterface
    
    参数:
    
    usingThreadPriorityManagment - set to true to actively manage priorities of step threads
  - isRunning
```
public boolean isRunning()
```
    指定者:
    
    isRunning 在接口中 StepInterface
    
    返回:
    
    true if the step is running after having been initialized
  - setRunning
```
public void setRunning(boolean running)
```
    从接口复制的说明: StepInterface
    
    Flag the step as running or not
    
    指定者:
    
    setRunning 在接口中 StepInterface
    
    参数:
    
    running - the running flag to set
  - setStopped
```
public void setStopped(boolean stopped)
```
    指定者:
    
    setStopped 在接口中 StepInterface
    
    参数:
    
    stopped - true if the step needs to be stopped
  - setSafeStopped
```
public void setSafeStopped(boolean stopped)
```
    指定者:
    
    setSafeStopped 在接口中 StepInterface
    
    参数:
    
    stopped - true if the step needs to be safe stopped
  - rowsetInputSize
```
public int rowsetInputSize()
```
    指定者:
    
    rowsetInputSize 在接口中 StepInterface
    
    返回:
    
    The total amount of rows in the input buffers
  - rowsetOutputSize
```
public int rowsetOutputSize()
```
    指定者:
    
    rowsetOutputSize 在接口中 StepInterface
    
    返回:
    
    The total amount of rows in the output buffers
  - getProcessed
```
public long getProcessed()
```
    指定者:
    
    getProcessed 在接口中 StepInterface
    
    返回:
    
    The number of "processed" lines of a step. Well, a representable metric for that anyway.
  - getResultFiles
```
public Map<String,org.pentaho.di.core.ResultFile> getResultFiles()
```
    指定者:
    
    getResultFiles 在接口中 StepInterface
    
    返回:
    
    The result files for this step
  - getRuntime
```
public long getRuntime()
```
    指定者:
    
    getRuntime 在接口中 StepInterface
    
    返回:
    
    The number of ms that this step has been running
  - getStatus
```
public BaseStepData.StepExecutionStatus getStatus()
```
    指定者:
    
    getStatus 在接口中 StepInterface
    
    返回:
    
    the description as in StepDataInterface
  - isPaused
```
public boolean isPaused()
```
    指定者:
    
    isPaused 在接口中 StepInterface
    
    返回:
    
    True if the step is paused
  - identifyErrorOutput
```
public void identifyErrorOutput()
```
    从接口复制的说明: StepInterface
    
    To be used to flag an error output channel of a step prior to execution for performance reasons.
    
    指定者:
    
    identifyErrorOutput 在接口中 StepInterface
  - setPartitioned
```
public void setPartitioned(boolean partitioned)
```
    指定者:
    
    setPartitioned 在接口中 StepInterface
    
    参数:
    
    partitioned - true if this step is partitioned
  - setRepartitioning
```
public void setRepartitioning(int partitioningMethod)
```
    指定者:
    
    setRepartitioning 在接口中 StepInterface
    
    参数:
    
    partitioningMethod - The repartitioning method
  - canProcessOneRow
```
public boolean canProcessOneRow()
```
    从接口复制的说明: StepInterface
    
    This method checks if the step is capable of processing at least one row.
    For example, if a step has no input records but needs at least one to function, it will return false.
    
    指定者:
    
    canProcessOneRow 在接口中 StepInterface
    
    返回:
    
    true if the step can process a row.
  - isWaitingForData
```
public boolean isWaitingForData()
```
  - setWaitingForData
```
public void setWaitingForData(boolean waitingForData)
```
  - isIdle
```
public boolean isIdle()
```
  - isPassingData
```
public boolean isPassingData()
```
  - setPassingData
```
public void setPassingData(boolean passingData)
```
  - batchComplete
```
public void batchComplete()
                   throws org.pentaho.di.core.exception.KettleException
```
    从接口复制的说明: StepInterface
    
    Calling this method will alert the step that we finished passing a batch of records to the step. Specifically for steps like "Sort Rows" it means that the buffered rows can be sorted and passed on.
    
    指定者:
    
    batchComplete 在接口中 StepInterface
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException - In case an error occurs during the processing of the batch of rows.
  - setMetaStore
```
public void setMetaStore(org.pentaho.metastore.api.IMetaStore metaStore)
```
    从接口复制的说明: StepInterface
    
    Pass along the metastore to use when loading external elements at runtime.
    
    指定者:
    
    setMetaStore 在接口中 StepInterface
    
    参数:
    
    metaStore - The metastore to use
  - getMetaStore
```
public org.pentaho.metastore.api.IMetaStore getMetaStore()
```
    指定者:
    
    getMetaStore 在接口中 StepInterface
    
    返回:
    
    The metastore that the step uses to load external elements from.
  - setRepository
```
public void setRepository(Repository repository)
```
    指定者:
    
    setRepository 在接口中 StepInterface
    
    参数:
    
    repository - The repository used by the step to load and reference Kettle objects with at runtime
  - getRepository
```
public Repository getRepository()
```
    指定者:
    
    getRepository 在接口中 StepInterface
    
    返回:
    
    The repository used by the step to load and reference Kettle objects with at runtime
  - getCurrentInputRowSetNr
```
public int getCurrentInputRowSetNr()
```
    指定者:
    
    getCurrentInputRowSetNr 在接口中 StepInterface
    
    返回:
    
    the index of the active (current) input row set
  - setCurrentOutputRowSetNr
```
public void setCurrentOutputRowSetNr(int index)
```
    指定者:
    
    setCurrentOutputRowSetNr 在接口中 StepInterface
    
    参数:
    
    index - Sets the index of the active (current) output row set to use.
  - getCurrentOutputRowSetNr
```
public int getCurrentOutputRowSetNr()
```
    指定者:
    
    getCurrentOutputRowSetNr 在接口中 StepInterface
    
    返回:
    
    the index of the active (current) output row set
  - setCurrentInputRowSetNr
```
public void setCurrentInputRowSetNr(int index)
```
    指定者:
    
    setCurrentInputRowSetNr 在接口中 StepInterface
    
    参数:
    
    index - Sets the index of the active (current) input row set to use.

类 ScriptDummy

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 org.pentaho.di.trans.step.StepInterface

构造器详细资料

ScriptDummy

方法详细资料

processRow

addRowListener

dispose

getErrors

getInputRowSets

getLinesInput

getLinesOutput

getLinesRead

getLinesUpdated

getLinesWritten

getLinesRejected

getOutputRowSets

getPartitionID

getRow

getRowListeners

getStepID

getStepname

init

isAlive

isPartitioned

isStopped

markStart

markStop

putRow

removeRowListener

run

setErrors

setOutputDone

setPartitionID

start

stopAll

stopRunning

cleanup

pauseRunning

resumeRunning

copyVariablesFrom

environmentSubstitute

environmentSubstitute

fieldSubstitute

getBooleanValueOfVariable

getParentVariableSpace

setParentVariableSpace

getVariable

getVariable

initializeVariablesFrom

injectVariables

listVariables

setVariable

shareVariablesWith

getInputRowMeta

getOutputRowMeta

initBeforeStart

setLinesRejected

getCopy

addStepListener

isMapping

getStepMeta

getTrans

getLogChannel

isUsingThreadPriorityManagment

setUsingThreadPriorityManagment

isRunning

setRunning

setStopped

setSafeStopped

rowsetInputSize

rowsetOutputSize

getProcessed

getResultFiles

getRuntime

getStatus

isPaused