Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.pentaho.di.trans.step
Class BaseStep

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

All Implemented Interfaces:
  Runnable, org.pentaho.di.core.variables.VariableSpace, StepInterface

Direct Known Subclasses:
  Abort, AccessInput, AccessOutput, AddSequence, AddXML, AggregateRows, AnalyticQuery, Append, BlockingStep, Calculator, CheckSum, CloneRow, ClosureGenerator, ColumnExists, CombinationLookup, Constant, CreditCardValidator, CsvInput, CubeInput, CubeOutput, DatabaseJoin, DatabaseLookup, DBProc, Delay, Delete, Denormaliser, DetectEmptyStream, DetectLastRow, DimensionLookup, DummyTrans, DynamicSQLRow, ExcelInput, ExcelOutput, ExecProcess, ExecSQL, ExecSQLRow, FieldSplitter, FileExists, FilesFromResult, FilesToResult, FilterRows, FixedInput, Flattener, Formula, GetFileNames, GetFilesRowsCount, GetPreviousRowField, GetSubFolders, GetVariable, GetXMLData, GPBulkLoader, GroupBy, HTTP, HTTPPOST, IfNull, InfobrightLoader, Injector, InsertUpdate, Janino, JoinRows, LDAPInput, LDIFInput, LucidDBBulkLoader, Mail, MailValidator, Mapping, MappingInput, MappingOutput, MergeJoin, MergeRows, MondrianInput, MonetDBBulkLoader, MySQLBulkLoader, Normaliser, NullIf, NumberRange, OraBulkLoader, ParGzipCsvInput, PGBulkLoader, ProcessFiles, PropertyInput, PropertyOutput, RandomValue, RegexEval, ReplaceString, ReservoirSampling, RowGenerator, RowsFromResult, RowsToResult, RssInput, RssOutput, SalesforceInput, SampleRows, ScriptValuesMod, SelectValues, SetValueConstant, SetValueField, SetVariable, SocketReader, SocketWriter, SortedMerge, SortRows, SplitFieldToRows, SQLFileOutput, StepMetastructure, StreamLookup, StringCut, SwitchCase, SynchronizeAfterMerge, SystemData, TableExists, TableInput, TableOutput, TextFileInput, TextFileOutput, UniqueRows, UniqueRowsByHashSet, UnivariateStats, Update, Validator, ValueMapper, WebService, WriteToLog, XBaseInput, XMLInput, XMLInputSax, XMLJoin, XMLOutput, XsdValidator, Xslt

    public class BaseStep

extends Thread
implements org.pentaho.di.core.variables.VariableSpace, StepInterface

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread
`Thread.State, Thread.UncaughtExceptionHandler`

Field Summary
`static String[]` | `category_order` Deprecated. Please use StepCategory.STANDARD_CATEGORIES to get the natural order
`org.pentaho.di.core.RowSet` | `errorRowSet` the rowset for the error rows
`boolean` | `first`
`boolean` | `init`
`ArrayList<org.pentaho.di.core.RowSet>` | `inputRowSets` The rowsets on the input, size() == nr of source steps
`long` | `linesInput` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesOutput` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesRead` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesRejected` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesSkipped` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesUpdated` Deprecated. please use the supplied getters, setters and increment/decrement methods
`long` | `linesWritten` Deprecated. please use the supplied getters, setters and increment/decrement methods
`ArrayList<org.pentaho.di.core.RowSet>` | `outputRowSets` the rowsets on the output, size() == nr of target steps
`AtomicBoolean` | `paused`
`List<RemoteStep>` | `remoteInputSteps` The remote input steps.
`List<RemoteStep>` | `remoteOutputSteps` The remote output steps.
`static String[]` | `statusDesc`
`static StepPluginMeta[]` | `steps`
`AtomicBoolean` | `stopped`
`boolean` | `terminator`
`List<Object[]>` | `terminator_rows`
`List<BaseStep>` | `thr`
`boolean` | `waiting`

Fields inherited from class java.lang.Thread
`MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY`

Constructor Summary
`BaseStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans)` This is the base step that forms that basis for all steps.

Method Summary
`void` | `addResultFile(org.pentaho.di.core.ResultFile resultFile)`
`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.
`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)`
`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)`
`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)`
`org.pentaho.di.core.RowSet` | `findInputRowSet(String sourceStep)`
`org.pentaho.di.core.RowSet` | `findInputRowSet(String from, int fromcopy, String to, int tocopy)`
`org.pentaho.di.core.RowSet` | `findOutputRowSet(String targetStep)`
`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()`
`int` | `getCopy()`
`Trans` | `getDispatcher()`
`org.pentaho.di.core.row.RowMetaInterface` | `getErrorRowMeta()`
`long` | `getErrors()` Get the number of errors
`static String` | `getIconFilename(int steptype)`
`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()`
`static org.pentaho.di.core.row.RowMetaInterface` | `getLogFields(String comm)`
`int` | `getNextClassNr()`
`List<org.pentaho.di.core.RowSet>` | `getOutputRowSets()`
`org.pentaho.di.core.variables.VariableSpace` | `getParentVariableSpace()`
`String` | `getPartitionID()`
`Map<String,org.pentaho.di.core.RowSet>` | `getPartitionTargets()`
`org.pentaho.di.core.row.RowMetaInterface` | `getPreviewRowMeta()`
`long` | `getProcessed()`
`int` | `getRepartitioning()`
`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)`
`List<RowListener>` | `getRowListeners()`
`long` | `getRuntime()`
`List<ServerSocket>` | `getServerSockets()`
`int` | `getSlaveNr()`
`SocketRepository` | `getSocketRepository()`
`int` | `getStatus()`
`String` | `getStatusDescription()`
`StepDataInterface` | `getStepDataInterface()`
`String` | `getStepID()`
`static StepMetaInterface` | `getStepInfo(StepPlugin stepplugin, StepLoader steploader)` Create a new empty StepMeta class from the steploader
`List<StepListener>` | `getStepListeners()`
`StepMeta` | `getStepMeta()`
`StepMetaInterface` | `getStepMetaInterface()`
`String` | `getStepname()` Get the name of the step.
`Thread` | `getThread()`
`Trans` | `getTrans()`
`TransMeta` | `getTransMeta()`
`String` | `getTypeId()` Support for CheckResultSourceInterface
`int` | `getUniqueStepCountAcrossSlaves()`
`int` | `getUniqueStepNrAcrossSlaves()`
`String` | `getVariable(String variableName)`
`String` | `getVariable(String variableName, String defaultValue)`
`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)` Initialise 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` | `isDistributed()`
`boolean` | `isInitialising()`
`boolean` | `isMapping()`
`boolean` | `isPartitioned()`
`boolean` | `isPaused()`
`boolean` | `isSafeModeEnabled()`
`boolean` | `isStopped()`
`boolean` | `isUsingThreadPriorityManagment()`
`String[]` | `listVariables()`
`void` | `logBasic(String s)`
`void` | `logDebug(String s)`
`void` | `logDetailed(String s)`
`void` | `logError(String s)`
`void` | `logError(String s, Throwable e)`
`void` | `logMinimal(String s)`
`void` | `logRowlevel(String s)`
`void` | `logSummary()`
`void` | `markStart()` Mark the start time of the step.
`void` | `markStop()` Mark the end time of the step.
`boolean` | `outputIsDone()`
`void` | `pauseRunning()` Pause a running step
`boolean` | `processRow(StepMetaInterface smi, StepDataInterface sdi)` Process one row.
`void` | `putError(org.pentaho.di.core.row.RowMetaInterface rowMeta, Object[] row, long nrErrors, String errorDescriptions, String fieldNames, String errorCodes)`
`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! (synchronized) If distribute is true, a row is copied only once to the output rowsets, otherwise copies are sent to each rowset!
`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()`
`static void` | `runStepThread(StepInterface stepInterface, StepMetaInterface meta, StepDataInterface data)`
`static void` | `safeModeChecking(org.pentaho.di.core.row.RowMetaInterface referenceRowMeta, org.pentaho.di.core.row.RowMetaInterface rowMeta)`
`void` | `setCopy(int cop)`
`void` | `setDistributed(boolean distributed)`
`void` | `setErrorRowMeta(org.pentaho.di.core.row.RowMetaInterface errorRowMeta)`
`void` | `setErrors(long e)` Sets the number of errors
`void` | `setInputRowMeta(org.pentaho.di.core.row.RowMetaInterface rowMeta)`
`void` | `setInputRowSets(ArrayList<org.pentaho.di.core.RowSet> inputRowSets)`
`void` | `setInternalVariables()`
`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` | `setOutputDone()` Signal output done to destination steps
`void` | `setOutputRowSets(ArrayList<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.RowSet> partitionTargets)`
`void` | `setPaused(AtomicBoolean paused)`
`void` | `setPaused(boolean paused)`
`void` | `setPreviewRowMeta(org.pentaho.di.core.row.RowMetaInterface previewRowMeta)`
`void` | `setRepartitioning(int repartitioning)`
`void` | `setSafeModeEnabled(boolean safeModeEnabled)`
`void` | `setServerSockets(List<ServerSocket> serverSockets)`
`void` | `setSocketRepository(SocketRepository socketRepository)`
`void` | `setStepDataInterface(StepDataInterface stepDataInterface)`
`void` | `setStepListeners(List<StepListener> stepListeners)`
`void` | `setStepMeta(StepMeta stepMeta)`
`void` | `setStepMetaInterface(StepMetaInterface stepMetaInterface)`
`void` | `setStepname(String stepname)`
`void` | `setStopped(AtomicBoolean stopped)`
`void` | `setStopped(boolean stopped)`
`void` | `setTransMeta(TransMeta transMeta)`
`void` | `setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)`
`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()` Deprecated.
`void` | `stopRunning(StepMetaInterface stepMetaInterface, StepDataInterface stepDataInterface)` Perform actions to stop a running step.
`String` | `toString()`

Methods inherited from class java.lang.Thread
`activeCount, checkAccess, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, run, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, yield`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.pentaho.di.trans.step.StepInterface
`isAlive, run, start`

Field Detail

### steps

    public static StepPluginMeta[] steps

### category_order

    public static final String[] category_order

  Deprecated. Please use StepCategory.STANDARD_CATEGORIES to get the natural order

### statusDesc

    public static final String[] statusDesc

### linesRead

    public long linesRead

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of lines read from previous step(s)

### linesWritten

    public long linesWritten

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of lines written to next step(s)

### linesInput

    public long linesInput

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of lines read from file or database

### linesOutput

    public long linesOutput

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of lines written to file or database

### linesUpdated

    public long linesUpdated

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of updates in a database table or file

### linesSkipped

    public long linesSkipped

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  nr of lines skipped

### linesRejected

    public long linesRejected

  Deprecated. please use the supplied getters, setters and increment/decrement methods
  total sleep time in ns caused by an empty input buffer (previous step is slow)

### thr

    public List<BaseStep> thr

### inputRowSets

    public ArrayList<org.pentaho.di.core.RowSet> inputRowSets

  The rowsets on the input, size() == nr of source steps

### outputRowSets

    public ArrayList<org.pentaho.di.core.RowSet> outputRowSets

  the rowsets on the output, size() == nr of target steps

### remoteInputSteps

    public List<RemoteStep> remoteInputSteps

  The remote input steps.

### remoteOutputSteps

    public List<RemoteStep> remoteOutputSteps

  The remote output steps.

### errorRowSet

    public org.pentaho.di.core.RowSet errorRowSet

  the rowset for the error rows

### stopped

    public AtomicBoolean stopped

### paused

    public AtomicBoolean paused

### waiting

    public boolean waiting

### init

    public boolean init

### first

    public boolean first

### terminator

    public boolean terminator

### terminator_rows

    public List<Object[]> terminator_rows

Constructor Detail

### 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.

  Parameters:
    `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.

Method Detail

### init

    public boolean init(StepMetaInterface smi,
                        StepDataInterface sdi)

  Description copied from interface: `StepInterface`
  Initialise and do work where other steps need to wait for...

  Specified by:
    `init` in interface `StepInterface`
  Parameters:
    `smi` - The metadata to work with
    `sdi` - The data to initialize

### dispose

    public void dispose(StepMetaInterface smi,
                        StepDataInterface sdi)

  Description copied from interface: `StepInterface`
  Dispose of this step: close files, empty logs, etc.

  Specified by:
    `dispose` in interface `StepInterface`
  Parameters:
    `smi` - The metadata to work with
    `sdi` - The data to dispose of

### cleanup

    public void cleanup()

  Description copied from interface: `StepInterface`
  Call this method typically, after ALL the slave transformations in a clustered run have finished.

  Specified by:
    `cleanup` in interface `StepInterface`

### getProcessed

    public long getProcessed()

### setCopy

    public void setCopy(int cop)

### getCopy

    public int getCopy()

  Specified by:
    `getCopy` in interface `StepInterface`
  Returns:
    The steps copy number (default 0)

### getErrors

    public long getErrors()

  Description copied from interface: `StepInterface`
  Get the number of errors

  Specified by:
    `getErrors` in interface `StepInterface`
  Returns:
    the number of errors

### setErrors

    public void setErrors(long e)

  Description copied from interface: `StepInterface`
  Sets the number of errors

  Specified by:
    `setErrors` in interface `StepInterface`
  Parameters:
    `e` - the number of errors to set

### getLinesRead

    public long getLinesRead()

  Specified by:
    `getLinesRead` in interface `StepInterface`
  Returns:
    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:
    Returns the new value

### decrementLinesRead

    public long decrementLinesRead()

  Decrements the number of lines read from previous steps by one

  Returns:
    Returns the new value

### setLinesRead

    public void setLinesRead(long newLinesReadValue)

  Parameters:
    `newLinesReadValue` - the new number of lines read from previous steps

### getLinesInput

    public long getLinesInput()

  Specified by:
    `getLinesInput` in interface `StepInterface`
  Returns:
    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.

  Returns:
    the new incremented value

### setLinesInput

    public void setLinesInput(long newLinesInputValue)

  Parameters:
    `newLinesInputValue` - the new number of lines read from an input source: database, file, socket, etc.

### getLinesOutput

    public long getLinesOutput()

  Specified by:
    `getLinesOutput` in interface `StepInterface`
  Returns:
    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.

  Returns:
    the new incremented value

### setLinesOutput

    public void setLinesOutput(long newLinesOutputValue)

  Parameters:
    `newLinesOutputValue` - the new number of lines written to an output target: database, file, socket, etc.

### getLinesWritten

    public long getLinesWritten()

  Specified by:
    `getLinesWritten` in interface `StepInterface`
  Returns:
    Returns the linesWritten.

### incrementLinesWritten

    public long incrementLinesWritten()

  Increments the number of lines written to next steps by one

  Returns:
    Returns the new value

### decrementLinesWritten

    public long decrementLinesWritten()

  Decrements the number of lines written to next steps by one

  Returns:
    Returns the new value

### setLinesWritten

    public void setLinesWritten(long newLinesWrittenValue)

  Parameters:
    `newLinesWrittenValue` - the new number of lines written to next steps

### getLinesUpdated

    public long getLinesUpdated()

  Specified by:
    `getLinesUpdated` in interface `StepInterface`
  Returns:
    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.

  Returns:
    the new incremented value

### setLinesUpdated

    public void setLinesUpdated(long newLinesUpdatedValue)

  Parameters:
    `newLinesOutputValue` - the new number of lines updated in an output target: database, file, socket, etc.

### getLinesRejected

    public long getLinesRejected()

  Specified by:
    `getLinesRejected` in interface `StepInterface`
  Returns:
    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

  Returns:
    the new incremented value

### setLinesRejected

    public void setLinesRejected(long newLinesRejectedValue)

  Specified by:
    `setLinesRejected` in interface `StepInterface`
  Parameters:
    `newLinesRejectedValue` - lines number of lines rejected to an error handling step

### getLinesSkipped

    public long getLinesSkipped()

  Returns:
    the number of lines skipped

### incrementLinesSkipped

    public long incrementLinesSkipped()

  Increments the number of lines skipped

  Returns:
    the new incremented value

### setLinesSkipped

    public void setLinesSkipped(long newLinesSkippedValue)

  Parameters:
    `newLinesSkippedValue` - lines number of lines skipped

### getStepname

    public String getStepname()

  Description copied from interface: `StepInterface`
  Get the name of the step.

  Specified by:
    `getStepname` in interface `StepInterface`
  Returns:
    the name of the step

### setStepname

    public void setStepname(String stepname)

### getDispatcher

    public Trans getDispatcher()

### getStatusDescription

    public String getStatusDescription()

### getStepMetaInterface

    public StepMetaInterface getStepMetaInterface()

  Returns:
    Returns the stepMetaInterface.

### setStepMetaInterface

    public void setStepMetaInterface(StepMetaInterface stepMetaInterface)

  Parameters:
    `stepMetaInterface` - The stepMetaInterface to set.

### getStepDataInterface

    public StepDataInterface getStepDataInterface()

  Returns:
    Returns the stepDataInterface.

### setStepDataInterface

    public void setStepDataInterface(StepDataInterface stepDataInterface)

  Parameters:
    `stepDataInterface` - The stepDataInterface to set.

### getStepMeta

    public StepMeta getStepMeta()

  Specified by:
    `getStepMeta` in interface `StepInterface`
  Returns:
    Returns the stepMeta.

### setStepMeta

    public void setStepMeta(StepMeta stepMeta)

  Parameters:
    `stepMeta` - The stepMeta to set.

### getTransMeta

    public TransMeta getTransMeta()

  Returns:
    Returns the transMeta.

### setTransMeta

    public void setTransMeta(TransMeta transMeta)

  Parameters:
    `transMeta` - The transMeta to set.

### getTrans

    public Trans getTrans()

  Returns:
    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!

  Specified by:
    `putRow` in interface `StepInterface`
  Parameters:
    `row` - The row to put to the destination rowset(s).
    `rowMeta` - The row to send to the destinations steps
  Throws:
    `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.

  Parameters:
    `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.
  Throws:
    `org.pentaho.di.core.exception.KettleStepException` - In case something unexpected goes wrong

### 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

  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### 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.

  Specified by:
    `getRow` in interface `StepInterface`
  Returns:
    a row from the source step(s).
  Throws:
    `org.pentaho.di.core.exception.KettleException`

### 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

  Throws:
    `org.pentaho.di.core.exception.KettleRowException`

### getRowFrom

    public Object[] getRowFrom(org.pentaho.di.core.RowSet rowSet)
                        throws org.pentaho.di.core.exception.KettleStepException

  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### findInputRowSet

    public org.pentaho.di.core.RowSet findInputRowSet(String sourceStep)
                                               throws org.pentaho.di.core.exception.KettleStepException

  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### findInputRowSet

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

### findOutputRowSet

    public org.pentaho.di.core.RowSet findOutputRowSet(String targetStep)
                                                throws org.pentaho.di.core.exception.KettleStepException

  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### 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.

  Parameters:
    `from` -
    `fromcopy` -
    `to` -
    `tocopy` -
  Returns:
    The rowset or null if none is found.

### setOutputDone

    public void setOutputDone()

  Description copied from interface: `StepInterface`
  Signal output done to destination steps

  Specified by:
    `setOutputDone` in interface `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.

### logMinimal

    public void logMinimal(String s)

### logBasic

    public void logBasic(String s)

### logError

    public void logError(String s)

### logError

    public void logError(String s,
                         Throwable e)

### logDetailed

    public void logDetailed(String s)

### logDebug

    public void logDebug(String s)

### logRowlevel

    public void logRowlevel(String s)

### getNextClassNr

    public int getNextClassNr()

### outputIsDone

    public boolean outputIsDone()

### stopAll

    public void stopAll()

  Description copied from interface: `StepInterface`
  Flags all rowsets as stopped/completed/finished.

  Specified by:
    `stopAll` in interface `StepInterface`

### isStopped

    public boolean isStopped()

  Specified by:
    `isStopped` in interface `StepInterface`
  Returns:
    True if the step is marked as stopped. Execution should stop immediate.

### isPaused

    public boolean isPaused()

### setStopped

    public void setStopped(boolean stopped)

### setStopped

    public void setStopped(AtomicBoolean stopped)

### pauseRunning

    public void pauseRunning()

  Description copied from interface: `StepInterface`
  Pause a running step

  Specified by:
    `pauseRunning` in interface `StepInterface`

### resumeRunning

    public void resumeRunning()

  Description copied from interface: `StepInterface`
  Resume a running step

  Specified by:
    `resumeRunning` in interface `StepInterface`

### setPaused

    public void setPaused(boolean paused)

### setPaused

    public void setPaused(AtomicBoolean paused)

### isInitialising

    public boolean isInitialising()

### markStart

    public void markStart()

  Description copied from interface: `StepInterface`
  Mark the start time of the step.

  Specified by:
    `markStart` in interface `StepInterface`

### setInternalVariables

    public void setInternalVariables()

### markStop

    public void markStop()

  Description copied from interface: `StepInterface`
  Mark the end time of the step.

  Specified by:
    `markStop` in interface `StepInterface`

### getRuntime

    public long getRuntime()

### 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)

### getLogFields

    public static final org.pentaho.di.core.row.RowMetaInterface getLogFields(String comm)

### toString

    public String toString()

  Overrides:
    `toString` in class `Thread`

### getThread

    public Thread getThread()

### rowsetOutputSize

    public int rowsetOutputSize()

### rowsetInputSize

    public int rowsetInputSize()

### getStepInfo

    public static final StepMetaInterface getStepInfo(StepPlugin stepplugin,
                                                      StepLoader steploader)
                                               throws org.pentaho.di.core.exception.KettleStepLoaderException

  Create a new empty StepMeta class from the steploader

  Parameters:
    `stepplugin` - The step/plugin to use
    `steploader` - The StepLoader to load from
  Returns:
    The requested class.
  Throws:
    `org.pentaho.di.core.exception.KettleStepLoaderException`

### getIconFilename

    public static final String getIconFilename(int steptype)

### 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.

  Specified by:
    `stopRunning` in interface `StepInterface`
  Parameters:
    `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.
  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case something goes wrong

### stopRunning

    public void stopRunning()

  Deprecated.

  Stops running operations This method is deprecated, please use the method specifying the metadata and data interfaces.

### logSummary

    public void logSummary()

### getStepID

    public String getStepID()

  Specified by:
    `getStepID` in interface `StepInterface`
  Returns:
    the type ID of the step...

### getInputRowSets

    public List<org.pentaho.di.core.RowSet> getInputRowSets()

  Specified by:
    `getInputRowSets` in interface `StepInterface`
  Returns:
    Returns the inputRowSets.

### setInputRowSets

    public void setInputRowSets(ArrayList<org.pentaho.di.core.RowSet> inputRowSets)

  Parameters:
    `inputRowSets` - The inputRowSets to set.

### getOutputRowSets

    public List<org.pentaho.di.core.RowSet> getOutputRowSets()

  Specified by:
    `getOutputRowSets` in interface `StepInterface`
  Returns:
    Returns the outputRowSets.

### setOutputRowSets

    public void setOutputRowSets(ArrayList<org.pentaho.di.core.RowSet> outputRowSets)

  Parameters:
    `outputRowSets` - The outputRowSets to set.

### isDistributed

    public boolean isDistributed()

  Returns:
    Returns the distributed.

### setDistributed

    public void setDistributed(boolean distributed)

  Parameters:
    `distributed` - The distributed to set.

### addRowListener

    public void addRowListener(RowListener rowListener)

  Description copied from interface: `StepInterface`
  Add a rowlistener to the step allowing you to inspect (or manipulate, be careful) the rows coming in or exiting the step.

  Specified by:
    `addRowListener` in interface `StepInterface`
  Parameters:
    `rowListener` - the rowlistener to add

### removeRowListener

    public void removeRowListener(RowListener rowListener)

  Description copied from interface: `StepInterface`
  Remove a rowlistener from this step.

  Specified by:
    `removeRowListener` in interface `StepInterface`
  Parameters:
    `rowListener` - the rowlistener to remove

### getRowListeners

    public List<RowListener> getRowListeners()

  Specified by:
    `getRowListeners` in interface `StepInterface`
  Returns:
    a list of the installed RowListeners

### addResultFile

    public void addResultFile(org.pentaho.di.core.ResultFile resultFile)

### getResultFiles

    public Map<String,org.pentaho.di.core.ResultFile> getResultFiles()

### isSafeModeEnabled

    public boolean isSafeModeEnabled()

  Returns:
    Returns true is this step is running in safe mode, with extra checking enabled...

### setSafeModeEnabled

    public void setSafeModeEnabled(boolean safeModeEnabled)

  Parameters:
    `safeModeEnabled` - set to true is this step has to be running in safe mode, with extra checking enabled...

### getStatus

    public int getStatus()

### getPartitionID

    public String getPartitionID()

  Specified by:
    `getPartitionID` in interface `StepInterface`
  Returns:
    the partitionID

### setPartitionID

    public void setPartitionID(String partitionID)

  Specified by:
    `setPartitionID` in interface `StepInterface`
  Parameters:
    `partitionID` - the partitionID to set

### getPartitionTargets

    public Map<String,org.pentaho.di.core.RowSet> getPartitionTargets()

  Returns:
    the partitionTargets

### setPartitionTargets

    public void setPartitionTargets(Map<String,org.pentaho.di.core.RowSet> partitionTargets)

  Parameters:
    `partitionTargets` - the partitionTargets to set

### getRepartitioning

    public int getRepartitioning()

  Returns:
    the repartitioning type

### setRepartitioning

    public void setRepartitioning(int repartitioning)

  Parameters:
    `repartitioning` - the repartitioning type to set

### isPartitioned

    public boolean isPartitioned()

  Specified by:
    `isPartitioned` in interface `StepInterface`
  Returns:
    the partitioned

### setPartitioned

    public void setPartitioned(boolean partitioned)

  Parameters:
    `partitioned` - the partitioned to set

### getInputRowMeta

    public org.pentaho.di.core.row.RowMetaInterface getInputRowMeta()

  Returns:
    the rowMeta

### setInputRowMeta

    public void setInputRowMeta(org.pentaho.di.core.row.RowMetaInterface rowMeta)

  Parameters:
    `rowMeta` - the rowMeta to set

### getErrorRowMeta

    public org.pentaho.di.core.row.RowMetaInterface getErrorRowMeta()

  Returns:
    the errorRowMeta

### setErrorRowMeta

    public void setErrorRowMeta(org.pentaho.di.core.row.RowMetaInterface errorRowMeta)

  Parameters:
    `errorRowMeta` - the errorRowMeta to set

### getPreviewRowMeta

    public org.pentaho.di.core.row.RowMetaInterface getPreviewRowMeta()

  Returns:
    the previewRowMeta

### setPreviewRowMeta

    public void setPreviewRowMeta(org.pentaho.di.core.row.RowMetaInterface previewRowMeta)

  Parameters:
    `previewRowMeta` - the previewRowMeta to set

### copyVariablesFrom

    public void copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)

  Specified by:
    `copyVariablesFrom` in interface `org.pentaho.di.core.variables.VariableSpace`

### environmentSubstitute

    public String environmentSubstitute(String aString)

  Specified by:
    `environmentSubstitute` in interface `org.pentaho.di.core.variables.VariableSpace`

### environmentSubstitute

    public String[] environmentSubstitute(String[] aString)

  Specified by:
    `environmentSubstitute` in interface `org.pentaho.di.core.variables.VariableSpace`

### getParentVariableSpace

    public org.pentaho.di.core.variables.VariableSpace getParentVariableSpace()

  Specified by:
    `getParentVariableSpace` in interface `org.pentaho.di.core.variables.VariableSpace`

### setParentVariableSpace

    public void setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)

  Specified by:
    `setParentVariableSpace` in interface `org.pentaho.di.core.variables.VariableSpace`

### getVariable

    public String getVariable(String variableName,
                              String defaultValue)

  Specified by:
    `getVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### getVariable

    public String getVariable(String variableName)

  Specified by:
    `getVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### getBooleanValueOfVariable

    public boolean getBooleanValueOfVariable(String variableName,
                                             boolean defaultValue)

  Specified by:
    `getBooleanValueOfVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### initializeVariablesFrom

    public void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)

  Specified by:
    `initializeVariablesFrom` in interface `org.pentaho.di.core.variables.VariableSpace`

### listVariables

    public String[] listVariables()

  Specified by:
    `listVariables` in interface `org.pentaho.di.core.variables.VariableSpace`

### setVariable

    public void setVariable(String variableName,
                            String variableValue)

  Specified by:
    `setVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### shareVariablesWith

    public void shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)

  Specified by:
    `shareVariablesWith` in interface `org.pentaho.di.core.variables.VariableSpace`

### injectVariables

    public void injectVariables(Map<String,String> prop)

  Specified by:
    `injectVariables` in interface `org.pentaho.di.core.variables.VariableSpace`

### getTypeId

    public String getTypeId()

  Support for CheckResultSourceInterface

### getSlaveNr

    public int getSlaveNr()

  Returns:
    the unique slave number in the cluster

### getClusterSize

    public int getClusterSize()

  Returns:
    the cluster size

### getUniqueStepNrAcrossSlaves

    public int getUniqueStepNrAcrossSlaves()

  Returns:
    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

### getServerSockets

    public List<ServerSocket> getServerSockets()

  Returns:
    the serverSockets

### setServerSockets

    public void setServerSockets(List<ServerSocket> serverSockets)

  Parameters:
    `serverSockets` - the serverSockets to set

### setUsingThreadPriorityManagment

    public void setUsingThreadPriorityManagment(boolean usingThreadPriorityManagment)

  Parameters:
    `usingThreadPriorityManagment` - set to true to actively manage priorities of step threads

### isUsingThreadPriorityManagment

    public boolean isUsingThreadPriorityManagment()

  Returns:
    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.

  Specified by:
    `initBeforeStart` in interface `StepInterface`
  Throws:
    `org.pentaho.di.core.exception.KettleStepException` - In case there is an error

### runStepThread

    public static void runStepThread(StepInterface stepInterface,
                                     StepMetaInterface meta,
                                     StepDataInterface data)

### getStepListeners

    public List<StepListener> getStepListeners()

  Returns:
    the stepListeners

### setStepListeners

    public void setStepListeners(List<StepListener> stepListeners)

  Parameters:
    `stepListeners` - the stepListeners to set

### processRow

    public boolean processRow(StepMetaInterface smi,
                              StepDataInterface sdi)
                       throws org.pentaho.di.core.exception.KettleException

  Description copied from interface: `StepInterface`
  Process one row.

  Specified by:
    `processRow` in interface `StepInterface`
  Parameters:
    `smi` - The metadata to work with
    `sdi` - The temporary working data to work with (database connections, resultsets, caches, temporary variables, etc.)
  Returns:
    false if no more rows can be processed or an error occurred.
  Throws:
    `org.pentaho.di.core.exception.KettleException`

### addStepListener

    public void addStepListener(StepListener stepListener)

  Description copied from interface: `StepInterface`
  Attach a step listener to be notified when a step arrives in a certain state. (finished)

  Specified by:
    `addStepListener` in interface `StepInterface`
  Parameters:
    `stepListener` - The listener to add to the step

### isMapping

    public boolean isMapping()

  Specified by:
    `isMapping` in interface `StepInterface`
  Returns:
    true if the thread is a special mapping step

### getSocketRepository

    public SocketRepository getSocketRepository()

  Returns:
    the socketRepository

### setSocketRepository

    public void setSocketRepository(SocketRepository socketRepository)

  Parameters:
    `socketRepository` - the socketRepository to set

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD