BaseStep (PDI Engine 8.3.0.0-0.2.3 API)

java.lang.Object
- org.pentaho.di.trans.step.BaseStep

所有已实现的接口:

org.pentaho.di.core.ExtensionDataInterface, HasLogChannelInterface, org.pentaho.di.core.logging.LoggingObjectInterface, org.pentaho.di.core.variables.VariableSpace, StepInterface

直接已知子类:

AbstractStep, AddSequence, BaseFileInputStep, BaseStreamStep, BlockUntilStepsFinish, Calculator, Constant, CreditCardValidator, CsvInput, CubeInput, CubeOutput, DatabaseJoin, DatabaseLookup, DataGrid, DBProc, Delay, Delete, Denormaliser, DetectEmptyStream, DetectLastRow, DimensionLookup, DummyTrans, DynamicSQLRow, EasyExpand, Edi2Xml, ExcelInput, ExcelOutput, ExcelWriterStep, ExecProcess, ExecSQL, ExecSQLRow, FieldsChangeSequence, FieldSplitter, FileExists, FileLocked, FilesFromResult, FilesToResult, FilterRows, FixedInput, Flattener, Formula, FuzzyMatch, GetFileNames, GetFilesRowsCount, GetRepositoryNames, GetSlaveSequence, GetSubFolders, GetTableNames, GetVariable, GroupBy, HTTP, HTTPPOST, IfNull, InfobrightLoader, IngresVectorwiseLoader, Injector, InsertUpdate, Janino, JavaFilter, JobExecutor, JoinRows, LDAPInput, LDAPOutput, LDIFInput, LoadFileInput, Mail, MailInput, MailValidator, Mapping, MappingInput, MappingOutput, MemoryGroupBy, MergeJoin, MergeRows, MondrianInput, MonetDBBulkLoader, MultiMergeJoin, MySQLBulkLoader, Normaliser, NullIf, NumberRange, OlapInput, OraBulkLoader, ParGzipCsvInput, PentahoReportingOutput, PGBulkLoader, PGPDecryptStream, PGPEncryptStream, PrioritizeStreams, ProcessFiles, PropertyInput, PropertyOutput, RandomCCNumberGenerator, RandomValue, RegexEval, ReplaceString, ReservoirSampling, Rest, RowGenerator, RowsFromResult, RowsToResult, RssInput, RssOutput, SampleRows, SasInput, Script, ScriptValuesMod, SecretKeyGenerator, SelectValues, SetValueConstant, SetValueField, SetVariable, SFTPPut, SimpleMapping, SingleThreader, SocketReader, SocketWriter, SortedMerge, SortRows, SplitFieldToRows, SQLFileOutput, SSH, StepInterfaceWebSocketEngineAdapter, StepMetastructure, StepsMetrics, StreamLookup, StringCut, StringOperations, SwitchCase, SymmetricCryptoTrans, SynchronizeAfterMerge, SyslogMessage, SystemData, TableCompare, TableExists, TableInput, TableOutput, TextFileInput, TextFileOutput, TransExecutor, UniqueRows, UniqueRowsByHashSet, UnivariateStats, Update, UserDefinedJavaClass, Validator, ValueMapper, WebService, WebServiceAvailable, WriteToLog, XBaseInput, YamlInput, ZipFile
```
public class BaseStep
extends Object
implements org.pentaho.di.core.variables.VariableSpace, StepInterface, org.pentaho.di.core.logging.LoggingObjectInterface, org.pentaho.di.core.ExtensionDataInterface
```
This class can be extended for the actual row processing of the implemented step.
The implementing class can rely mostly on the base class, and has only three important methods it implements itself. The three methods implement the step lifecycle during transformation execution: initialization, row processing, and clean-up.
- Step Initialization
  The init() method is called when a transformation is preparing to start execution.
```
 public boolean init(...)
 
```
  Every step is given the opportunity to do one-time initialization tasks like opening files or establishing database connections. For any steps derived from BaseStep it is mandatory that super.init() is called to ensure correct behavior. The method must return true in case the step initialized correctly, it must returned false if there was an initialization error. PDI will abort the execution of a transformation in case any step returns false upon initialization.
- Row Processing
  Once the transformation starts execution it enters a tight loop calling processRow() on each step until the method returns false. Each step typically reads a single row from the input stream, alters the row structure and fields and passes the row on to next steps.
```
 public boolean processRow(...)
 
```
  A typical implementation queries for incoming input rows by calling getRow(), which blocks and returns a row object or null in case there is no more input. If there was an input row, the step does the necessary row processing and calls putRow() to pass the row on to the next step. If there are no more rows, the step must call setOutputDone() and return false.
  Formally the method must conform to the following rules:
  - If the step is done processing all rows, the method must call setOutputDone() and return false
  - If the step is not done processing all rows, the method must return true. PDI will call processRow() again in this case.
- Step Clean-Up
  Once the transformation is complete, PDI calls dispose() on all steps.
```
 public void dispose(...)
 
```
  Steps are required to deallocate resources allocated during init() or subsequent row processing. This typically means to clear all fields of the StepDataInterface object, and to ensure that all open files or connections are properly closed. For any steps derived from BaseStep it is mandatory that super.dispose() is called to ensure correct deallocation.

字段概要

字段
限定符和类型	字段和说明
`protected long`	`deadLockCounter` Keeps track of the number of rows read for input deadlock verification.
`protected Map<String,Object>`	`extensionDataMap`
`boolean`	`first` if true then the row being processed is the first row
`long`	`linesInput` 已过时。 use `getLinesInput()` or `incrementLinesInput()`
`long`	`linesOutput` 已过时。 use `getLinesOutput()` or `incrementLinesOutput()`
`long`	`linesRead` 已过时。 use `getLinesRead()`, `incrementLinesRead()`, or `decrementLinesRead()`
`long`	`linesRejected` 已过时。 use `getLinesRejected()` or `incrementLinesRejected()`
`long`	`linesSkipped` 已过时。 use `getLinesSkipped()` or `incrementLinesSkipped()`
`long`	`linesUpdated` 已过时。 use `getLinesUpdated()` or `incrementLinesUpdated()`
`long`	`linesWritten` 已过时。 use `getLinesWritten()`, `incrementLinesWritten()`, or `decrementLinesWritten()`
`protected org.pentaho.di.core.logging.LogChannelInterface`	`log`
`protected org.pentaho.metastore.api.IMetaStore`	`metaStore` The metastore that the step uses to load external elements from
`protected Repository`	`repository` The repository used by the step to load and reference Kettle objects with at runtime
`protected List<RowListener>`	`rowListeners` The list of RowListener interfaces
`protected AtomicBoolean`	`safeStopped`
`boolean`	`terminator`
`List<Object[]>`	`terminator_rows`
`protected org.pentaho.di.core.variables.VariableSpace`	`variables`

构造器概要

构造器
构造器和说明
`BaseStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans)` This is the base step that forms that basis for all steps.

方法概要

所有方法静态方法实例方法具体方法已过时的方法
限定符和类型	方法和说明
`void`	`addResultFile(org.pentaho.di.core.ResultFile resultFile)` Adds the result file.
`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`	`addRowSetToInputRowSets(org.pentaho.di.core.RowSet rowSet)`
`void`	`addRowSetToOutputRowSets(org.pentaho.di.core.RowSet rowSet)`
`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.
`org.pentaho.di.core.RowMetaAndData`	`buildLog(String sname, int copynr, long lines_read, long lines_written, long lines_updated, long lines_skipped, long errors, Date start_date, Date end_date)` Builds the log.
`boolean`	`canProcessOneRow()` This method checks if the step is capable of processing at least one row.
`protected boolean`	`checkFeedback(long lines)` Check feedback.
`void`	`cleanup()` Call this method typically, after ALL the slave transformations in a clustered run have finished.
`protected void`	`clearInputRowSets()`
`protected void`	`clearOutputRowSets()`
`static void`	`closeQuietly(Closeable cl)` Close quietly.
`void`	`copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)`
`long`	`decrementLinesRead()` Decrements the number of lines read from previous steps by one
`long`	`decrementLinesWritten()` Decrements the number of lines written to next steps by one
`void`	`dispatch()` This method finds the surrounding steps and rowsets for this base step.
`void`	`dispose(StepMetaInterface smi, StepDataInterface sdi)` Dispose of this step: close files, empty logs, etc.
`String`	`environmentSubstitute(String aString)`
`String[]`	`environmentSubstitute(String[] aString)`
`String`	`fieldSubstitute(String aString, org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] rowData)`
`org.pentaho.di.core.RowSet`	`findInputRowSet(String sourceStep)` Find input row set.
`org.pentaho.di.core.RowSet`	`findInputRowSet(String from, int fromcopy, String to, int tocopy)` Find input row set.
`org.pentaho.di.core.RowSet`	`findOutputRowSet(String targetStep)` Find output row set.
`org.pentaho.di.core.RowSet`	`findOutputRowSet(String from, int fromcopy, String to, int tocopy)` Find an output rowset in a running transformation.
`boolean`	`getBooleanValueOfVariable(String variableName, boolean defaultValue)`
`int`	`getClusterSize()` Returns the cluster size.
`String`	`getContainerObjectId()` Returns the container object ID.
`int`	`getCopy()`
`int`	`getCurrentInputRowSetNr()`
`int`	`getCurrentOutputRowSetNr()`
`Trans`	`getDispatcher()` Gets the dispatcher.
`org.pentaho.di.core.row.RowMetaInterface`	`getErrorRowMeta()`
`long`	`getErrors()` Get the number of errors
`Map<String,Object>`	`getExtensionDataMap()`
`String`	`getFilename()`
`protected org.pentaho.di.core.RowSet`	`getFirstInputRowSet()`
`org.pentaho.di.core.row.RowMetaInterface`	`getInputRowMeta()`
`List<org.pentaho.di.core.RowSet>`	`getInputRowSets()`
`long`	`getLinesInput()`
`long`	`getLinesOutput()`
`long`	`getLinesRead()`
`long`	`getLinesRejected()`
`long`	`getLinesSkipped()`
`long`	`getLinesUpdated()`
`long`	`getLinesWritten()`
`org.pentaho.di.core.logging.LogChannelInterface`	`getLogChannel()`
`String`	`getLogChannelId()`
`static org.pentaho.di.core.row.RowMetaInterface`	`getLogFields(String comm)` Gets the log fields.
`org.pentaho.di.core.logging.LogLevel`	`getLogLevel()`
`org.pentaho.metastore.api.IMetaStore`	`getMetaStore()`
`int`	`getNextClassNr()` Gets the next class nr.
`String`	`getObjectCopy()`
`org.pentaho.di.repository.ObjectId`	`getObjectId()`
`String`	`getObjectName()`
`org.pentaho.di.repository.ObjectRevision`	`getObjectRevision()`
`org.pentaho.di.core.logging.LoggingObjectType`	`getObjectType()`
`List<org.pentaho.di.core.RowSet>`	`getOutputRowSets()`
`org.pentaho.di.core.logging.LoggingObjectInterface`	`getParent()`
`org.pentaho.di.core.variables.VariableSpace`	`getParentVariableSpace()`
`String`	`getPartitionID()`
`Map<String,org.pentaho.di.core.BlockingRowSet>`	`getPartitionTargets()`
`org.pentaho.di.core.row.RowMetaInterface`	`getPreviewRowMeta()`
`long`	`getProcessed()`
`Date`	`getRegistrationDate()` Returns the registration date
`List<RemoteStep>`	`getRemoteInputSteps()` Gets the remote input steps.
`List<RemoteStep>`	`getRemoteOutputSteps()` Gets the remote output steps.
`int`	`getRepartitioning()`
`Repository`	`getRepository()`
`org.pentaho.di.repository.RepositoryDirectory`	`getRepositoryDirectory()`
`Map<String,org.pentaho.di.core.ResultFile>`	`getResultFiles()`
`Object[]`	`getRow()` In case of getRow, we receive data from previous steps through the input rowset.
`Object[]`	`getRowFrom(org.pentaho.di.core.RowSet rowSet)` Gets the row from.
`RowHandler`	`getRowHandler()`
`List<RowListener>`	`getRowListeners()`
`long`	`getRuntime()`
`List<ServerSocket>`	`getServerSockets()` Returns the serverSockets.
`int`	`getSlaveNr()` Returns the unique slave number in the cluster.
`SocketRepository`	`getSocketRepository()` Retutns the socket repository.
`BaseStepData.StepExecutionStatus`	`getStatus()`
`String`	`getStatusDescription()` Gets the status description.
`StepDataInterface`	`getStepDataInterface()`
`String`	`getStepID()`
`List<StepListener>`	`getStepListeners()` Returns the step listeners.
`StepMeta`	`getStepMeta()`
`StepMetaInterface`	`getStepMetaInterface()`
`String`	`getStepname()` Get the name of the step.
`Trans`	`getTrans()`
`TransMeta`	`getTransMeta()`
`String`	`getTypeId()` Returns the step ID via the getStepID() method call.
`int`	`getUniqueStepCountAcrossSlaves()` Returns the number of unique steps across all slave servers.
`int`	`getUniqueStepNrAcrossSlaves()` Returns a unique step number across all slave servers: slaveNr * nrCopies + copyNr.
`String`	`getVariable(String variableName)`
`String`	`getVariable(String variableName, String defaultValue)`
`Object[]`	`handleGetRowFrom(org.pentaho.di.core.RowSet rowSet)`
`void`	`handlePutRowTo(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row, org.pentaho.di.core.RowSet rowSet)`
`void`	`identifyErrorOutput()` To be used to flag an error output channel of a step prior to execution for performance reasons.
`long`	`incrementLinesInput()` Increments the number of lines read from an input source: database, file, socket, etc.
`long`	`incrementLinesOutput()` Increments the number of lines written to an output target: database, file, socket, etc.
`long`	`incrementLinesRead()` Increments the number of lines read from previous steps by one
`long`	`incrementLinesRejected()` Increments the number of lines rejected to an error handling step
`long`	`incrementLinesSkipped()` Increments the number of lines skipped
`long`	`incrementLinesUpdated()` Increments the number of lines updated in an output target: database, file, socket, etc.
`long`	`incrementLinesWritten()` Increments the number of lines written to next steps by one
`boolean`	`init(StepMetaInterface smi, StepDataInterface sdi)` 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`	`isBasic()` Checks if is basic.
`boolean`	`isDebug()` Checks if is debug.
`boolean`	`isDetailed()` Checks if is detailed.
`boolean`	`isDistributed()`
`boolean`	`isForcingSeparateLogging()`
`boolean`	`isGatheringMetrics()`
`boolean`	`isInitialising()` Checks if is initialising.
`boolean`	`isMapping()`
`boolean`	`isPartitioned()`
`boolean`	`isPaused()`
`boolean`	`isRowLevel()` Checks if is row level.
`boolean`	`isRunning()`
`boolean`	`isSafeStopped()`
`boolean`	`isStopped()`
`boolean`	`isUsingThreadPriorityManagment()` Retusn true if we are actively managing priorities of step threads.
`String[]`	`listVariables()`
`void`	`logBasic(String message)` Log basic.
`void`	`logBasic(String message, Object... arguments)` Log basic.
`void`	`logDebug(String message)` Log debug.
`void`	`logDebug(String message, Object... arguments)` Log debug.
`void`	`logDetailed(String message)` Log detailed.
`void`	`logDetailed(String message, Object... arguments)` Log detailed.
`void`	`logError(String message)` Log error.
`void`	`logError(String message, Object... arguments)` Log error.
`void`	`logError(String message, Throwable e)` Log error.
`void`	`logMinimal(String message)` Log minimal.
`void`	`logMinimal(String message, Object... arguments)` Log minimal.
`void`	`logRowlevel(String message)` Log rowlevel.
`void`	`logRowlevel(String message, Object... arguments)` Log rowlevel.
`void`	`logSummary()` Log summary.
`void`	`markStart()` Mark the start time of the step.
`void`	`markStop()` Mark the end time of the step.
`protected void`	`openRemoteInputStepSocketsOnce()` Opens socket connections to the remote input steps of this step.
`protected void`	`openRemoteOutputStepSocketsOnce()` Opens socket connections to the remote output steps of this step.
`boolean`	`outputIsDone()` Output is done.
`void`	`pauseRunning()` Pause a running step
`boolean`	`processRow(StepMetaInterface smi, StepDataInterface sdi)` Perform the equivalent of processing one row.
`void`	`putError(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row, long nrErrors, String errorDescriptions, String fieldNames, String errorCodes)` Put error.
`void`	`putRow(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row)` putRow is used to copy a row, to the alternate rowset(s) This should get priority over everything else!
`void`	`putRowTo(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row, org.pentaho.di.core.RowSet rowSet)` putRowTo is used to put a row in a certain specific RowSet.
`void`	`removeRowListener(RowListener rowListener)` Remove a rowlistener from this step.
`void`	`resumeRunning()` Resume a running step
`int`	`rowsetInputSize()`
`int`	`rowsetOutputSize()`
`protected void`	`safeModeChecking(org.pentaho.di.core.row.RowMetaInterface row)` Safe mode checking.
`static void`	`safeModeChecking(org.pentaho.di.core.row.RowMetaInterface referenceRowMeta, org.pentaho.di.core.row.RowMetaInterface rowMeta)` Safe mode checking.
`void`	`setCarteObjectId(String containerObjectId)` Sets the container object ID.
`void`	`setCopy(int cop)` Sets the copy.
`void`	`setCurrentInputRowSetNr(int index)`
`void`	`setCurrentOutputRowSetNr(int index)`
`void`	`setDistributed(boolean distributed)`
`void`	`setErrorRowMeta(org.pentaho.di.core.row.RowMetaInterface errorRowMeta)`
`void`	`setErrors(long e)` Sets the number of errors
`void`	`setForcingSeparateLogging(boolean forcingSeparateLogging)`
`void`	`setGatheringMetrics(boolean gatheringMetrics)`
`void`	`setInputRowMeta(org.pentaho.di.core.row.RowMetaInterface rowMeta)`
`void`	`setInputRowSets(List<org.pentaho.di.core.RowSet> inputRowSets)`
`void`	`setInternalVariables()` Sets the internal variables.
`void`	`setLinesInput(long newLinesInputValue)`
`void`	`setLinesOutput(long newLinesOutputValue)`
`void`	`setLinesRead(long newLinesReadValue)`
`void`	`setLinesRejected(long newLinesRejectedValue)`
`void`	`setLinesSkipped(long newLinesSkippedValue)`
`void`	`setLinesUpdated(long newLinesUpdatedValue)`
`void`	`setLinesWritten(long newLinesWrittenValue)`
`void`	`setLogLevel(org.pentaho.di.core.logging.LogLevel logLevel)` Sets the log level.
`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`	`setOutputRowSets(List<org.pentaho.di.core.RowSet> outputRowSets)`
`void`	`setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)`
`void`	`setPartitioned(boolean partitioned)`
`void`	`setPartitionID(String partitionID)`
`void`	`setPartitionTargets(Map<String,org.pentaho.di.core.BlockingRowSet> partitionTargets)`
`void`	`setPaused(AtomicBoolean paused)` Sets the paused.
`void`	`setPaused(boolean paused)` Sets the paused.
`void`	`setPreviewRowMeta(org.pentaho.di.core.row.RowMetaInterface previewRowMeta)`
`void`	`setRepartitioning(int repartitioning)`
`void`	`setRepository(Repository repository)`
`void`	`setRowHandler(RowHandler rowHandler)` RowHandler controls how getRow/putRow are handled.
`void`	`setRunning(boolean running)` Flag the step as running or not
`void`	`setSafeStopped(boolean stopped)`
`void`	`setServerSockets(List<ServerSocket> serverSockets)`
`void`	`setSocketRepository(SocketRepository socketRepository)` Sets the socket repository.
`void`	`setStepDataInterface(StepDataInterface stepDataInterface)`
`void`	`setStepListeners(List<StepListener> stepListeners)` Sets the step listeners.
`void`	`setStepMeta(StepMeta stepMeta)`
`void`	`setStepMetaInterface(StepMetaInterface stepMetaInterface)`
`void`	`setStepname(String stepname)` Sets the stepname.
`void`	`setStopped(boolean stopped)`
`void`	`setTransMeta(TransMeta transMeta)`
`void`	`setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)` Set to true to actively manage priorities of step threads.
`void`	`setVariable(String variableName, String variableValue)`
`void`	`shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)`
`void`	`stopAll()` Flags all rowsets as stopped/completed/finished.
`void`	`stopRunning()` 已过时。 use `stopRunning(StepMetaInterface, StepDataInterface)`
`void`	`stopRunning(StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface)` Perform actions to stop a running step.
`protected void`	`swapFirstInputRowSetIfExists(String stepName)`
`String`	`toString()`
`protected void`	`verifyInputDeadLock()` - A step sees that it can't get a new row from input in the step. - Then it verifies that there is more than one input row set and that at least one is full and at least one is empty. - Then it finds a step in the transformation (situated before the reader step) which has at least one full and one empty output row set. - If this situation presents itself and if it happens twice with the same rows read count (meaning: stalled reading step) we throw an exception.
`protected void`	`waitUntilTransformationIsStarted()` Wait until the transformation is completely running and all threads have been started.

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

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

- 字段详细资料
  - variables
```
protected org.pentaho.di.core.variables.VariableSpace variables
```
  - log
```
protected org.pentaho.di.core.logging.LogChannelInterface log
```
  - linesRead
```
@Deprecated
public long linesRead
```
    已过时。 use getLinesRead(), incrementLinesRead(), or decrementLinesRead()
    
    nr of lines read from previous step(s)
  - linesWritten
```
@Deprecated
public long linesWritten
```
    已过时。 use getLinesWritten(), incrementLinesWritten(), or decrementLinesWritten()
    
    nr of lines written to next step(s)
  - linesInput
```
@Deprecated
public long linesInput
```
    已过时。 use getLinesInput() or incrementLinesInput()
    
    nr of lines read from file or database
  - linesOutput
```
@Deprecated
public long linesOutput
```
    已过时。 use getLinesOutput() or incrementLinesOutput()
    
    nr of lines written to file or database
  - linesUpdated
```
@Deprecated
public long linesUpdated
```
    已过时。 use getLinesUpdated() or incrementLinesUpdated()
    
    nr of updates in a database table or file
  - linesSkipped
```
@Deprecated
public long linesSkipped
```
    已过时。 use getLinesSkipped() or incrementLinesSkipped()
    
    nr of lines skipped
  - linesRejected
```
@Deprecated
public long linesRejected
```
    已过时。 use getLinesRejected() or incrementLinesRejected()
    
    total sleep time in ns caused by an empty input buffer (previous step is slow)
  - safeStopped
```
protected AtomicBoolean safeStopped
```
  - first
```
public boolean first
```
    if true then the row being processed is the first row
  - terminator
```
public boolean terminator
```
  - terminator_rows
```
public List<Object[]> terminator_rows
```
  - rowListeners
```
protected List<RowListener> rowListeners
```
    The list of RowListener interfaces
  - deadLockCounter
```
protected long deadLockCounter
```
    Keeps track of the number of rows read for input deadlock verification.
  - repository
```
protected Repository repository
```
    The repository used by the step to load and reference Kettle objects with at runtime
  - metaStore
```
protected org.pentaho.metastore.api.IMetaStore metaStore
```
    The metastore that the step uses to load external elements from
  - extensionDataMap
```
protected Map<String,Object> extensionDataMap
```
- 构造器详细资料
  - BaseStep
```
public BaseStep(StepMeta stepMeta,
                StepDataInterface stepDataInterface,
                int copyNr,
                TransMeta transMeta,
                Trans trans)
```
    This is the base step that forms that basis for all steps. You can derive from this class to implement your own steps.
    
    参数:
    
    stepMeta - The StepMeta object to run.
    
    stepDataInterface - the data object to store temporary data, database connections, caches, result sets, hashtables etc.
    
    copyNr - The copynumber for this step.
    
    transMeta - The TransInfo of which the step stepMeta is part of.
    
    trans - The (running) transformation to obtain information shared among the steps.
- 方法详细资料
  - init
```
public boolean init(StepMetaInterface smi,
                    StepDataInterface sdi)
```
    从接口复制的说明: StepInterface
    
    Initialize and do work where other steps need to wait for...
    
    指定者:
    
    init 在接口中 StepInterface
    
    参数:
    
    smi - The metadata to work with
    
    sdi - The data to initialize
  - dispose
```
public void dispose(StepMetaInterface smi,
                    StepDataInterface sdi)
```
    从接口复制的说明: StepInterface
    
    Dispose of this step: close files, empty logs, etc.
    
    指定者:
    
    dispose 在接口中 StepInterface
    
    参数:
    
    smi - The metadata to work with
    
    sdi - The data to dispose of
  - cleanup
```
public void cleanup()
```
    从接口复制的说明: StepInterface
    
    Call this method typically, after ALL the slave transformations in a clustered run have finished.
    
    指定者:
    
    cleanup 在接口中 StepInterface
  - getProcessed
```
public long getProcessed()
```
    指定者:
    
    getProcessed 在接口中 StepInterface
    
    返回:
    
    The number of "processed" lines of a step. Well, a representable metric for that anyway.
  - setCopy
```
public void setCopy(int cop)
```
    Sets the copy.
    
    参数:
    
    cop - the new copy
  - getCopy
```
public int getCopy()
```
    指定者:
    
    getCopy 在接口中 StepInterface
    
    返回:
    
    The steps copy number (default 0)
  - getErrors
```
public long getErrors()
```
    从接口复制的说明: StepInterface
    
    Get the number of errors
    
    指定者:
    
    getErrors 在接口中 StepInterface
    
    返回:
    
    the number of errors
  - setErrors
```
public void setErrors(long e)
```
    从接口复制的说明: StepInterface
    
    Sets the number of errors
    
    指定者:
    
    setErrors 在接口中 StepInterface
    
    参数:
    
    e - the number of errors to set
  - getLinesRead
```
public long getLinesRead()
```
    指定者:
    
    getLinesRead 在接口中 StepInterface
    
    返回:
    
    Returns the number of lines read from previous steps
  - incrementLinesRead
```
public long incrementLinesRead()
```
    Increments the number of lines read from previous steps by one
    
    返回:
    
    Returns the new value
  - decrementLinesRead
```
public long decrementLinesRead()
```
    Decrements the number of lines read from previous steps by one
    
    返回:
    
    Returns the new value
  - setLinesRead
```
public void setLinesRead(long newLinesReadValue)
```
    参数:
    
    newLinesReadValue - the new number of lines read from previous steps
  - getLinesInput
```
public long getLinesInput()
```
    指定者:
    
    getLinesInput 在接口中 StepInterface
    
    返回:
    
    Returns the number of lines read from an input source: database, file, socket, etc.
  - incrementLinesInput
```
public long incrementLinesInput()
```
    Increments the number of lines read from an input source: database, file, socket, etc.
    
    返回:
    
    the new incremented value
  - setLinesInput
```
public void setLinesInput(long newLinesInputValue)
```
    参数:
    
    newLinesInputValue - the new number of lines read from an input source: database, file, socket, etc.
  - getLinesOutput
```
public long getLinesOutput()
```
    指定者:
    
    getLinesOutput 在接口中 StepInterface
    
    返回:
    
    Returns the number of lines written to an output target: database, file, socket, etc.
  - incrementLinesOutput
```
public long incrementLinesOutput()
```
    Increments the number of lines written to an output target: database, file, socket, etc.
    
    返回:
    
    the new incremented value
  - setLinesOutput
```
public void setLinesOutput(long newLinesOutputValue)
```
    参数:
    
    newLinesOutputValue - the new number of lines written to an output target: database, file, socket, etc.
  - getLinesWritten
```
public long getLinesWritten()
```
    指定者:
    
    getLinesWritten 在接口中 StepInterface
    
    返回:
    
    Returns the linesWritten.
  - incrementLinesWritten
```
public long incrementLinesWritten()
```
    Increments the number of lines written to next steps by one
    
    返回:
    
    Returns the new value
  - decrementLinesWritten
```
public long decrementLinesWritten()
```
    Decrements the number of lines written to next steps by one
    
    返回:
    
    Returns the new value
  - setLinesWritten
```
public void setLinesWritten(long newLinesWrittenValue)
```
    参数:
    
    newLinesWrittenValue - the new number of lines written to next steps
  - getLinesUpdated
```
public long getLinesUpdated()
```
    指定者:
    
    getLinesUpdated 在接口中 StepInterface
    
    返回:
    
    Returns the number of lines updated in an output target: database, file, socket, etc.
  - incrementLinesUpdated
```
public long incrementLinesUpdated()
```
    Increments the number of lines updated in an output target: database, file, socket, etc.
    
    返回:
    
    the new incremented value
  - setLinesUpdated
```
public void setLinesUpdated(long newLinesUpdatedValue)
```
    参数:
    
    newLinesUpdatedValue - the new number of lines updated in an output target: database, file, socket, etc.
  - getLinesRejected
```
public long getLinesRejected()
```
    指定者:
    
    getLinesRejected 在接口中 StepInterface
    
    返回:
    
    the number of lines rejected to an error handling step
  - incrementLinesRejected
```
public long incrementLinesRejected()
```
    Increments the number of lines rejected to an error handling step
    
    返回:
    
    the new incremented value
  - setLinesRejected
```
public void setLinesRejected(long newLinesRejectedValue)
```
    指定者:
    
    setLinesRejected 在接口中 StepInterface
    
    参数:
    
    newLinesRejectedValue - lines number of lines rejected to an error handling step
  - getLinesSkipped
```
public long getLinesSkipped()
```
    返回:
    
    the number of lines skipped
  - incrementLinesSkipped
```
public long incrementLinesSkipped()
```
    Increments the number of lines skipped
    
    返回:
    
    the new incremented value
  - setLinesSkipped
```
public void setLinesSkipped(long newLinesSkippedValue)
```
    参数:
    
    newLinesSkippedValue - lines number of lines skipped
  - getStepname
```
public String getStepname()
```
    从接口复制的说明: StepInterface
    
    Get the name of the step.
    
    指定者:
    
    getStepname 在接口中 StepInterface
    
    返回:
    
    the name of the step
  - setStepname
```
public void setStepname(String stepname)
```
    Sets the stepname.
    
    参数:
    
    stepname - the new stepname
  - getDispatcher
```
public Trans getDispatcher()
```
    Gets the dispatcher.
    
    返回:
    
    the dispatcher
  - getStatusDescription
```
public String getStatusDescription()
```
    Gets the status description.
    
    返回:
    
    the status description
  - getStepMetaInterface
```
public StepMetaInterface getStepMetaInterface()
```
    返回:
    
    Returns the stepMetaInterface.
  - setStepMetaInterface
```
public void setStepMetaInterface(StepMetaInterface stepMetaInterface)
```
    参数:
    
    stepMetaInterface - The stepMetaInterface to set.
  - getStepDataInterface
```
public StepDataInterface getStepDataInterface()
```
    返回:
    
    Returns the stepDataInterface.
  - setStepDataInterface
```
public void setStepDataInterface(StepDataInterface stepDataInterface)
```
    参数:
    
    stepDataInterface - The stepDataInterface to set.
  - getStepMeta
```
public StepMeta getStepMeta()
```
    指定者:
    
    getStepMeta 在接口中 StepInterface
    
    返回:
    
    Returns the stepMeta.
  - setStepMeta
```
public void setStepMeta(StepMeta stepMeta)
```
    参数:
    
    stepMeta - The stepMeta to set.
  - getTransMeta
```
public TransMeta getTransMeta()
```
    返回:
    
    Returns the transMeta.
  - setTransMeta
```
public void setTransMeta(TransMeta transMeta)
```
    参数:
    
    transMeta - The transMeta to set.
  - getTrans
```
public Trans getTrans()
```
    指定者:
    
    getTrans 在接口中 StepInterface
    
    返回:
    
    Returns the trans.
  - putRow
```
public void putRow(org.pentaho.di.core.row.RowMetaInterface rowMeta,
                   Object[] row)
            throws org.pentaho.di.core.exception.KettleStepException
```
    putRow is used to copy a row, to the alternate rowset(s) This should get priority over everything else! (synchronized) If distribute is true, a row is copied only once to the output rowsets, otherwise copies are sent to each rowset!
    
    指定者:
    
    putRow 在接口中 StepInterface
    
    参数:
    
    row - The row to put to the destination rowset(s).
    
    rowMeta - The row to send to the destinations steps
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - putRowTo
```
public void putRowTo(org.pentaho.di.core.row.RowMetaInterface rowMeta,
                     Object[] row,
                     org.pentaho.di.core.RowSet rowSet)
              throws org.pentaho.di.core.exception.KettleStepException
```
    putRowTo is used to put a row in a certain specific RowSet.
    
    参数:
    
    rowMeta - The row meta-data to put to the destination RowSet.
    
    row - the data to put in the RowSet
    
    rowSet - the RoWset to put the row into.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - In case something unexpected goes wrong
  - handlePutRowTo
```
public void handlePutRowTo(org.pentaho.di.core.row.RowMetaInterface rowMeta,
                           Object[] row,
                           org.pentaho.di.core.RowSet rowSet)
                    throws org.pentaho.di.core.exception.KettleStepException
```
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - putError
```
public void putError(org.pentaho.di.core.row.RowMetaInterface rowMeta,
                     Object[] row,
                     long nrErrors,
                     String errorDescriptions,
                     String fieldNames,
                     String errorCodes)
              throws org.pentaho.di.core.exception.KettleStepException
```
    Put error.
    
    参数:
    
    rowMeta - the row meta
    
    row - the row
    
    nrErrors - the nr errors
    
    errorDescriptions - the error descriptions
    
    fieldNames - the field names
    
    errorCodes - the error codes
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - the kettle step exception
  - waitUntilTransformationIsStarted
```
protected void waitUntilTransformationIsStarted()
```
    Wait until the transformation is completely running and all threads have been started.
  - getRow
```
public Object[] getRow()
                throws org.pentaho.di.core.exception.KettleException
```
    In case of getRow, we receive data from previous steps through the input rowset. In case we split the stream, we have to copy the data to the alternate splits: rowsets 1 through n.
    
    指定者:
    
    getRow 在接口中 StepInterface
    
    返回:
    
    a row from the source step(s).
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException
  - setRowHandler
```
public void setRowHandler(RowHandler rowHandler)
```
    RowHandler controls how getRow/putRow are handled. The default RowHandler will simply call handleGetRow() and handlePutRow(RowMetaInterface, Object[])
  - getRowHandler
```
public RowHandler getRowHandler()
```
  - openRemoteInputStepSocketsOnce
```
protected void openRemoteInputStepSocketsOnce()
                                       throws org.pentaho.di.core.exception.KettleStepException
```
    Opens socket connections to the remote input steps of this step.
    This method should be used by steps that don't call getRow() first in which it is executed automatically.
    This method should be called before any data is read from previous steps.
    This action is executed only once.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - openRemoteOutputStepSocketsOnce
```
protected void openRemoteOutputStepSocketsOnce()
                                        throws org.pentaho.di.core.exception.KettleStepException
```
    Opens socket connections to the remote output steps of this step.
    This method is called in method initBeforeStart() because it needs to connect to the server sockets (remote steps) as soon as possible to avoid time-out situations.
    This action is executed only once.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - safeModeChecking
```
protected void safeModeChecking(org.pentaho.di.core.row.RowMetaInterface row)
                         throws org.pentaho.di.core.exception.KettleRowException
```
    Safe mode checking.
    
    参数:
    
    row - the row
    
    抛出:
    
    org.pentaho.di.core.exception.KettleRowException - the kettle row exception
  - 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
  - safeModeChecking
```
public static void safeModeChecking(org.pentaho.di.core.row.RowMetaInterface referenceRowMeta,
                                    org.pentaho.di.core.row.RowMetaInterface rowMeta)
                             throws org.pentaho.di.core.exception.KettleRowException
```
    Safe mode checking.
    
    参数:
    
    referenceRowMeta - the reference row meta
    
    rowMeta - the row meta
    
    抛出:
    
    org.pentaho.di.core.exception.KettleRowException - the kettle row exception
  - getRowFrom
```
public Object[] getRowFrom(org.pentaho.di.core.RowSet rowSet)
                    throws org.pentaho.di.core.exception.KettleStepException
```
    Gets the row from.
    
    参数:
    
    rowSet - the row set
    
    返回:
    
    the row from
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - the kettle step exception
  - handleGetRowFrom
```
public Object[] handleGetRowFrom(org.pentaho.di.core.RowSet rowSet)
                          throws org.pentaho.di.core.exception.KettleStepException
```
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - verifyInputDeadLock
```
protected void verifyInputDeadLock()
                            throws org.pentaho.di.core.exception.KettleStepException
```
    - A step sees that it can't get a new row from input in the step. - Then it verifies that there is more than one input row set and that at least one is full and at least one is empty. - Then it finds a step in the transformation (situated before the reader step) which has at least one full and one empty output row set. - If this situation presents itself and if it happens twice with the same rows read count (meaning: stalled reading step) we throw an exception. For the attached example that exception is:
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException
  - findInputRowSet
```
public org.pentaho.di.core.RowSet findInputRowSet(String sourceStep)
                                           throws org.pentaho.di.core.exception.KettleStepException
```
    Find input row set.
    
    参数:
    
    sourceStep - the source step
    
    返回:
    
    the row set
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - the kettle step exception
  - findInputRowSet
```
public org.pentaho.di.core.RowSet findInputRowSet(String from,
                                                  int fromcopy,
                                                  String to,
                                                  int tocopy)
```
    Find input row set.
    
    参数:
    
    from - the from
    
    fromcopy - the fromcopy
    
    to - the to
    
    tocopy - the tocopy
    
    返回:
    
    the row set
  - findOutputRowSet
```
public org.pentaho.di.core.RowSet findOutputRowSet(String targetStep)
                                            throws org.pentaho.di.core.exception.KettleStepException
```
    Find output row set.
    
    参数:
    
    targetStep - the target step
    
    返回:
    
    the row set
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - the kettle step exception
  - findOutputRowSet
```
public org.pentaho.di.core.RowSet findOutputRowSet(String from,
                                                   int fromcopy,
                                                   String to,
                                                   int tocopy)
```
    Find an output rowset in a running transformation. It will also look at the "to" step to see if this is a mapping. If it is, it will find the appropriate rowset in that transformation.
    
    参数:
    
    from -
    
    fromcopy -
    
    to -
    
    tocopy -
    
    返回:
    
    The rowset or null if none is found.
  - setOutputDone
```
public void setOutputDone()
```
    从接口复制的说明: StepInterface
    
    Signal output done to destination steps
    
    指定者:
    
    setOutputDone 在接口中 StepInterface
  - dispatch
```
public void dispatch()
```
    This method finds the surrounding steps and rowsets for this base step. This steps keeps it's own list of rowsets (etc.) to prevent it from having to search every time.
    Note that all rowsets input and output is already created by transformation itself. So in this place we will look and choose which rowsets will be used by this particular step.
    We will collect all input rowsets and output rowsets so step will be able to read input data, and write to the output.
    Steps can run in multiple copies, on in partitioned fashion. For this case we should take in account that in different cases we should take in account one to one, one to many and other cases properly.
  - isBasic
```
public boolean isBasic()
```
    Checks if is basic.
    
    返回:
    
    true, if is basic
  - isDetailed
```
public boolean isDetailed()
```
    Checks if is detailed.
    
    返回:
    
    true, if is detailed
  - isDebug
```
public boolean isDebug()
```
    Checks if is debug.
    
    返回:
    
    true, if is debug
  - isRowLevel
```
public boolean isRowLevel()
```
    Checks if is row level.
    
    返回:
    
    true, if is row level
  - logMinimal
```
public void logMinimal(String message)
```
    Log minimal.
    
    参数:
    
    message - the message
  - logMinimal
```
public void logMinimal(String message,
                       Object... arguments)
```
    Log minimal.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - logBasic
```
public void logBasic(String message)
```
    Log basic.
    
    参数:
    
    message - the message
  - logBasic
```
public void logBasic(String message,
                     Object... arguments)
```
    Log basic.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - logDetailed
```
public void logDetailed(String message)
```
    Log detailed.
    
    参数:
    
    message - the message
  - logDetailed
```
public void logDetailed(String message,
                        Object... arguments)
```
    Log detailed.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - logDebug
```
public void logDebug(String message)
```
    Log debug.
    
    参数:
    
    message - the message
  - logDebug
```
public void logDebug(String message,
                     Object... arguments)
```
    Log debug.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - logRowlevel
```
public void logRowlevel(String message)
```
    Log rowlevel.
    
    参数:
    
    message - the message
  - logRowlevel
```
public void logRowlevel(String message,
                        Object... arguments)
```
    Log rowlevel.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - logError
```
public void logError(String message)
```
    Log error.
    
    参数:
    
    message - the message
  - logError
```
public void logError(String message,
                     Throwable e)
```
    Log error.
    
    参数:
    
    message - the message
    
    e - the e
  - logError
```
public void logError(String message,
                     Object... arguments)
```
    Log error.
    
    参数:
    
    message - the message
    
    arguments - the arguments
  - getNextClassNr
```
public int getNextClassNr()
```
    Gets the next class nr.
    
    返回:
    
    the next class nr
  - outputIsDone
```
public boolean outputIsDone()
```
    Output is done.
    
    返回:
    
    true, if successful
  - stopAll
```
public void stopAll()
```
    从接口复制的说明: StepInterface
    
    Flags all rowsets as stopped/completed/finished.
    
    指定者:
    
    stopAll 在接口中 StepInterface
  - isStopped
```
public boolean isStopped()
```
    指定者:
    
    isStopped 在接口中 StepInterface
    
    返回:
    
    True if the step is marked as stopped. Execution should stop immediate.
  - isRunning
```
public boolean isRunning()
```
    指定者:
    
    isRunning 在接口中 StepInterface
    
    返回:
    
    true if the step is running after having been initialized
  - isPaused
```
public boolean isPaused()
```
    指定者:
    
    isPaused 在接口中 StepInterface
    
    返回:
    
    True if the step is paused
  - 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
  - isSafeStopped
```
public boolean isSafeStopped()
```
    指定者:
    
    isSafeStopped 在接口中 StepInterface
    
    返回:
    
    true if step is safe stopped.
  - setRunning
```
public void setRunning(boolean running)
```
    从接口复制的说明: StepInterface
    
    Flag the step as running or not
    
    指定者:
    
    setRunning 在接口中 StepInterface
    
    参数:
    
    running - the running flag to set
  - pauseRunning
```
public void pauseRunning()
```
    从接口复制的说明: StepInterface
    
    Pause a running step
    
    指定者:
    
    pauseRunning 在接口中 StepInterface
  - resumeRunning
```
public void resumeRunning()
```
    从接口复制的说明: StepInterface
    
    Resume a running step
    
    指定者:
    
    resumeRunning 在接口中 StepInterface
  - setPaused
```
public void setPaused(boolean paused)
```
    Sets the paused.
    
    参数:
    
    paused - the new paused
  - setPaused
```
public void setPaused(AtomicBoolean paused)
```
    Sets the paused.
    
    参数:
    
    paused - the new paused
  - isInitialising
```
public boolean isInitialising()
```
    Checks if is initialising.
    
    返回:
    
    true, if is initialising
  - markStart
```
public void markStart()
```
    从接口复制的说明: StepInterface
    
    Mark the start time of the step.
    
    指定者:
    
    markStart 在接口中 StepInterface
  - setInternalVariables
```
public void setInternalVariables()
```
    Sets the internal variables.
  - markStop
```
public void markStop()
```
    从接口复制的说明: StepInterface
    
    Mark the end time of the step.
    
    指定者:
    
    markStop 在接口中 StepInterface
  - getRuntime
```
public long getRuntime()
```
    指定者:
    
    getRuntime 在接口中 StepInterface
    
    返回:
    
    The number of ms that this step has been running
  - buildLog
```
public org.pentaho.di.core.RowMetaAndData buildLog(String sname,
                                                   int copynr,
                                                   long lines_read,
                                                   long lines_written,
                                                   long lines_updated,
                                                   long lines_skipped,
                                                   long errors,
                                                   Date start_date,
                                                   Date end_date)
```
    Builds the log.
    
    参数:
    
    sname - the sname
    
    copynr - the copynr
    
    lines_read - the lines_read
    
    lines_written - the lines_written
    
    lines_updated - the lines_updated
    
    lines_skipped - the lines_skipped
    
    errors - the errors
    
    start_date - the start_date
    
    end_date - the end_date
    
    返回:
    
    the row meta and data
  - getLogFields
```
public static final org.pentaho.di.core.row.RowMetaInterface getLogFields(String comm)
```
    Gets the log fields.
    
    参数:
    
    comm - the comm
    
    返回:
    
    the log fields
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - rowsetOutputSize
```
public int rowsetOutputSize()
```
    指定者:
    
    rowsetOutputSize 在接口中 StepInterface
    
    返回:
    
    The total amount of rows in the output buffers
  - rowsetInputSize
```
public int rowsetInputSize()
```
    指定者:
    
    rowsetInputSize 在接口中 StepInterface
    
    返回:
    
    The total amount of rows in the input buffers
  - stopRunning
```
public void stopRunning(StepMetaInterface stepMetaInterface,
                        StepDataInterface stepDataInterface)
                 throws org.pentaho.di.core.exception.KettleException
```
    Perform actions to stop a running step. This can be stopping running SQL queries (cancel), etc. Default it doesn't do anything.
    
    指定者:
    
    stopRunning 在接口中 StepInterface
    
    参数:
    
    stepDataInterface - The interface to the step data containing the connections, resultsets, open files, etc.
    
    stepMetaInterface - The metadata that might be needed by the step to stop running.
    
    抛出:
    
    org.pentaho.di.core.exception.KettleException - in case something goes wrong
  - stopRunning
```
@Deprecated
public void stopRunning()
```
    已过时。 use stopRunning(StepMetaInterface, StepDataInterface)
    
    Stops running operations This method is deprecated, please use the method specifying the metadata and data interfaces.
  - logSummary
```
public void logSummary()
```
    Log summary.
  - getStepID
```
public String getStepID()
```
    指定者:
    
    getStepID 在接口中 StepInterface
    
    返回:
    
    the type ID of the step...
  - getInputRowSets
```
public List<org.pentaho.di.core.RowSet> getInputRowSets()
```
    指定者:
    
    getInputRowSets 在接口中 StepInterface
    
    返回:
    
    Returns the inputRowSets.
  - addRowSetToInputRowSets
```
public void addRowSetToInputRowSets(org.pentaho.di.core.RowSet rowSet)
```
    指定者:
    
    addRowSetToInputRowSets 在接口中 StepInterface
  - getFirstInputRowSet
```
protected org.pentaho.di.core.RowSet getFirstInputRowSet()
```
  - clearInputRowSets
```
protected void clearInputRowSets()
```
  - swapFirstInputRowSetIfExists
```
protected void swapFirstInputRowSetIfExists(String stepName)
```
  - setInputRowSets
```
public void setInputRowSets(List<org.pentaho.di.core.RowSet> inputRowSets)
```
    参数:
    
    inputRowSets - The inputRowSets to set.
  - getOutputRowSets
```
public List<org.pentaho.di.core.RowSet> getOutputRowSets()
```
    指定者:
    
    getOutputRowSets 在接口中 StepInterface
    
    返回:
    
    Returns the outputRowSets.
  - addRowSetToOutputRowSets
```
public void addRowSetToOutputRowSets(org.pentaho.di.core.RowSet rowSet)
```
    指定者:
    
    addRowSetToOutputRowSets 在接口中 StepInterface
  - clearOutputRowSets
```
protected void clearOutputRowSets()
```
  - setOutputRowSets
```
public void setOutputRowSets(List<org.pentaho.di.core.RowSet> outputRowSets)
```
    参数:
    
    outputRowSets - The outputRowSets to set.
  - isDistributed
```
public boolean isDistributed()
```
    返回:
    
    Returns the distributed.
  - setDistributed
```
public void setDistributed(boolean distributed)
```
    参数:
    
    distributed - The distributed to set.
  - 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
  - removeRowListener
```
public void removeRowListener(RowListener rowListener)
```
    从接口复制的说明: StepInterface
    
    Remove a rowlistener from this step.
    
    指定者:
    
    removeRowListener 在接口中 StepInterface
    
    参数:
    
    rowListener - the rowlistener to remove
  - getRowListeners
```
public List<RowListener> getRowListeners()
```
    指定者:
    
    getRowListeners 在接口中 StepInterface
    
    返回:
    
    a list of the installed RowListeners
  - addResultFile
```
public void addResultFile(org.pentaho.di.core.ResultFile resultFile)
```
    Adds the result file.
    
    参数:
    
    resultFile - the result file
  - getResultFiles
```
public Map<String,org.pentaho.di.core.ResultFile> getResultFiles()
```
    指定者:
    
    getResultFiles 在接口中 StepInterface
    
    返回:
    
    The result files for this step
  - getStatus
```
public BaseStepData.StepExecutionStatus getStatus()
```
    指定者:
    
    getStatus 在接口中 StepInterface
    
    返回:
    
    the description as in StepDataInterface
  - getPartitionID
```
public String getPartitionID()
```
    指定者:
    
    getPartitionID 在接口中 StepInterface
    
    返回:
    
    the partitionID
  - setPartitionID
```
public void setPartitionID(String partitionID)
```
    指定者:
    
    setPartitionID 在接口中 StepInterface
    
    参数:
    
    partitionID - the partitionID to set
  - getPartitionTargets
```
public Map<String,org.pentaho.di.core.BlockingRowSet> getPartitionTargets()
```
    返回:
    
    the partitionTargets
  - setPartitionTargets
```
public void setPartitionTargets(Map<String,org.pentaho.di.core.BlockingRowSet> partitionTargets)
```
    参数:
    
    partitionTargets - the partitionTargets to set
  - getRepartitioning
```
public int getRepartitioning()
```
    返回:
    
    the repartitioning type
  - setRepartitioning
```
public void setRepartitioning(int repartitioning)
```
    指定者:
    
    setRepartitioning 在接口中 StepInterface
    
    参数:
    
    repartitioning - the repartitioning type to set
  - isPartitioned
```
public boolean isPartitioned()
```
    指定者:
    
    isPartitioned 在接口中 StepInterface
    
    返回:
    
    the partitioned
  - setPartitioned
```
public void setPartitioned(boolean partitioned)
```
    指定者:
    
    setPartitioned 在接口中 StepInterface
    
    参数:
    
    partitioned - the partitioned to set
  - checkFeedback
```
protected boolean checkFeedback(long lines)
```
    Check feedback.
    
    参数:
    
    lines - the lines
    
    返回:
    
    true, if successful
  - getInputRowMeta
```
public org.pentaho.di.core.row.RowMetaInterface getInputRowMeta()
```
    返回:
    
    the rowMeta
  - setInputRowMeta
```
public void setInputRowMeta(org.pentaho.di.core.row.RowMetaInterface rowMeta)
```
    参数:
    
    rowMeta - the rowMeta to set
  - getErrorRowMeta
```
public org.pentaho.di.core.row.RowMetaInterface getErrorRowMeta()
```
    返回:
    
    the errorRowMeta
  - setErrorRowMeta
```
public void setErrorRowMeta(org.pentaho.di.core.row.RowMetaInterface errorRowMeta)
```
    参数:
    
    errorRowMeta - the errorRowMeta to set
  - getPreviewRowMeta
```
public org.pentaho.di.core.row.RowMetaInterface getPreviewRowMeta()
```
    返回:
    
    the previewRowMeta
  - setPreviewRowMeta
```
public void setPreviewRowMeta(org.pentaho.di.core.row.RowMetaInterface previewRowMeta)
```
    参数:
    
    previewRowMeta - the previewRowMeta to set
  - 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[] aString)
```
    指定者:
    
    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
  - 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
  - getBooleanValueOfVariable
```
public boolean getBooleanValueOfVariable(String variableName,
                                         boolean defaultValue)
```
    指定者:
    
    getBooleanValueOfVariable 在接口中 org.pentaho.di.core.variables.VariableSpace
  - initializeVariablesFrom
```
public void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)
```
    指定者:
    
    initializeVariablesFrom 在接口中 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
  - injectVariables
```
public void injectVariables(Map<String,String> prop)
```
    指定者:
    
    injectVariables 在接口中 org.pentaho.di.core.variables.VariableSpace
  - getTypeId
```
public String getTypeId()
```
    Returns the step ID via the getStepID() method call. Support for CheckResultSourceInterface.
    
    返回:
    
    getStepID()
  - getSlaveNr
```
public int getSlaveNr()
```
    Returns the unique slave number in the cluster.
    
    返回:
    
    the unique slave number in the cluster
  - getClusterSize
```
public int getClusterSize()
```
    Returns the cluster size.
    
    返回:
    
    the cluster size
  - getUniqueStepNrAcrossSlaves
```
public int getUniqueStepNrAcrossSlaves()
```
    Returns a unique step number across all slave servers: slaveNr * nrCopies + copyNr.
    
    返回:
    
    a unique step number across all slave servers: slaveNr * nrCopies + copyNr
  - getUniqueStepCountAcrossSlaves
```
public int getUniqueStepCountAcrossSlaves()
```
    Returns the number of unique steps across all slave servers.
    
    返回:
    
    the number of unique steps across all slave servers
  - getServerSockets
```
public List<ServerSocket> getServerSockets()
```
    Returns the serverSockets.
    
    返回:
    
    the serverSockets
  - setServerSockets
```
public void setServerSockets(List<ServerSocket> serverSockets)
```
    参数:
    
    serverSockets - the serverSockets to set
  - setUsingThreadPriorityManagment
```
public void setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)
```
    Set to true to actively manage priorities of step threads.
    
    指定者:
    
    setUsingThreadPriorityManagment 在接口中 StepInterface
    
    参数:
    
    usingThreadPriorityManagment - set to true to actively manage priorities of step threads
  - isUsingThreadPriorityManagment
```
public boolean isUsingThreadPriorityManagment()
```
    Retusn true if we are actively managing priorities of step threads.
    
    指定者:
    
    isUsingThreadPriorityManagment 在接口中 StepInterface
    
    返回:
    
    true if we are actively managing priorities of step threads
  - initBeforeStart
```
public void initBeforeStart()
                     throws org.pentaho.di.core.exception.KettleStepException
```
    This method is executed by Trans right before the threads start and right after initialization.
    More to the point: here we open remote output step sockets.
    
    指定者:
    
    initBeforeStart 在接口中 StepInterface
    
    抛出:
    
    org.pentaho.di.core.exception.KettleStepException - In case there is an error
  - getStepListeners
```
public List<StepListener> getStepListeners()
```
    Returns the step listeners.
    
    返回:
    
    the stepListeners
  - setStepListeners
```
public void setStepListeners(List<StepListener> stepListeners)
```
    Sets the step listeners.
    
    参数:
    
    stepListeners - the stepListeners to set
  - 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
  - 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.
  - 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
  - getSocketRepository
```
public SocketRepository getSocketRepository()
```
    Retutns the socket repository.
    
    返回:
    
    the socketRepository
  - setSocketRepository
```
public void setSocketRepository(SocketRepository socketRepository)
```
    Sets the socket repository.
    
    参数:
    
    socketRepository - the socketRepository to set
  - getObjectName
```
public String getObjectName()
```
    指定者:
    
    getObjectName 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getLogChannel
```
public org.pentaho.di.core.logging.LogChannelInterface getLogChannel()
```
    指定者:
    
    getLogChannel 在接口中 HasLogChannelInterface
    
    指定者:
    
    getLogChannel 在接口中 StepInterface
    
    返回:
    
    the logging channel for this step
  - getFilename
```
public String getFilename()
```
    指定者:
    
    getFilename 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getLogChannelId
```
public String getLogChannelId()
```
    指定者:
    
    getLogChannelId 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getObjectId
```
public org.pentaho.di.repository.ObjectId getObjectId()
```
    指定者:
    
    getObjectId 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getObjectRevision
```
public org.pentaho.di.repository.ObjectRevision getObjectRevision()
```
    指定者:
    
    getObjectRevision 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getObjectType
```
public org.pentaho.di.core.logging.LoggingObjectType getObjectType()
```
    指定者:
    
    getObjectType 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getParent
```
public org.pentaho.di.core.logging.LoggingObjectInterface getParent()
```
    指定者:
    
    getParent 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getRepositoryDirectory
```
public org.pentaho.di.repository.RepositoryDirectory getRepositoryDirectory()
```
    指定者:
    
    getRepositoryDirectory 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getObjectCopy
```
public String getObjectCopy()
```
    指定者:
    
    getObjectCopy 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getLogLevel
```
public org.pentaho.di.core.logging.LogLevel getLogLevel()
```
    指定者:
    
    getLogLevel 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - setLogLevel
```
public void setLogLevel(org.pentaho.di.core.logging.LogLevel logLevel)
```
    Sets the log level.
    
    参数:
    
    logLevel - the new log level
  - closeQuietly
```
public static void closeQuietly(Closeable cl)
```
    Close quietly.
    
    参数:
    
    cl - the object that can be closed.
  - getContainerObjectId
```
public String getContainerObjectId()
```
    Returns the container object ID.
    
    指定者:
    
    getContainerObjectId 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
    
    返回:
    
    the containerObjectId
  - setCarteObjectId
```
public void setCarteObjectId(String containerObjectId)
```
    Sets the container object ID.
    
    参数:
    
    containerObjectId - the containerObjectId to set
  - 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.
  - getRemoteInputSteps
```
public List<RemoteStep> getRemoteInputSteps()
```
    Gets the remote input steps.
    
    返回:
    
    the remote input steps
  - getRemoteOutputSteps
```
public List<RemoteStep> getRemoteOutputSteps()
```
    Gets the remote output steps.
    
    返回:
    
    the remote output steps
  - getRegistrationDate
```
public Date getRegistrationDate()
```
    Returns the registration date
    
    指定者:
    
    getRegistrationDate 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - isGatheringMetrics
```
public boolean isGatheringMetrics()
```
    指定者:
    
    isGatheringMetrics 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - setGatheringMetrics
```
public void setGatheringMetrics(boolean gatheringMetrics)
```
    指定者:
    
    setGatheringMetrics 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - isForcingSeparateLogging
```
public boolean isForcingSeparateLogging()
```
    指定者:
    
    isForcingSeparateLogging 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - setForcingSeparateLogging
```
public void setForcingSeparateLogging(boolean forcingSeparateLogging)
```
    指定者:
    
    setForcingSeparateLogging 在接口中 org.pentaho.di.core.logging.LoggingObjectInterface
  - getRepository
```
public Repository getRepository()
```
    指定者:
    
    getRepository 在接口中 StepInterface
    
    返回:
    
    The repository used by the step to load and reference Kettle objects with at runtime
  - setRepository
```
public void setRepository(Repository repository)
```
    指定者:
    
    setRepository 在接口中 StepInterface
    
    参数:
    
    repository - The repository used by the step to load and reference Kettle objects with at runtime
  - getMetaStore
```
public org.pentaho.metastore.api.IMetaStore getMetaStore()
```
    指定者:
    
    getMetaStore 在接口中 StepInterface
    
    返回:
    
    The metastore that the step uses to load external elements from.
  - 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
  - getCurrentOutputRowSetNr
```
public int getCurrentOutputRowSetNr()
```
    指定者:
    
    getCurrentOutputRowSetNr 在接口中 StepInterface
    
    返回:
    
    the index of the active (current) output row set
  - setCurrentOutputRowSetNr
```
public void setCurrentOutputRowSetNr(int index)
```
    指定者:
    
    setCurrentOutputRowSetNr 在接口中 StepInterface
    
    参数:
    
    index - Sets the index of the active (current) output row set to use.
  - getCurrentInputRowSetNr
```
public int getCurrentInputRowSetNr()
```
    指定者:
    
    getCurrentInputRowSetNr 在接口中 StepInterface
    
    返回:
    
    the index of the active (current) input row set
  - setCurrentInputRowSetNr
```
public void setCurrentInputRowSetNr(int index)
```
    指定者:
    
    setCurrentInputRowSetNr 在接口中 StepInterface
    
    参数:
    
    index - Sets the index of the active (current) input row set to use.
  - getExtensionDataMap
```
public Map<String,Object> getExtensionDataMap()
```
    指定者:
    
    getExtensionDataMap 在接口中 org.pentaho.di.core.ExtensionDataInterface

类 BaseStep

字段概要

构造器概要

方法概要

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

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

字段详细资料

variables

log

linesRead

linesWritten

linesInput

linesOutput

linesUpdated

linesSkipped

linesRejected

safeStopped

first

terminator

terminator_rows

rowListeners

deadLockCounter

repository

metaStore

extensionDataMap

构造器详细资料

BaseStep

方法详细资料

init

dispose

cleanup

getProcessed

setCopy

getCopy

getErrors

setErrors

getLinesRead

incrementLinesRead

decrementLinesRead

setLinesRead

getLinesInput

incrementLinesInput

setLinesInput

getLinesOutput

incrementLinesOutput

setLinesOutput

getLinesWritten

incrementLinesWritten

decrementLinesWritten

setLinesWritten

getLinesUpdated

incrementLinesUpdated

setLinesUpdated

getLinesRejected

incrementLinesRejected

setLinesRejected

getLinesSkipped

incrementLinesSkipped

setLinesSkipped

getStepname

setStepname

getDispatcher

getStatusDescription

getStepMetaInterface

setStepMetaInterface

getStepDataInterface

setStepDataInterface

getStepMeta

setStepMeta

getTransMeta

setTransMeta

getTrans

putRow

putRowTo

handlePutRowTo

putError

waitUntilTransformationIsStarted

getRow

setRowHandler

getRowHandler