Package org.pentaho.di.trans.step

Interface StepInterface

    • Method Detail

      • getTrans

        Trans getTrans()
        Returns:
        the transformation that is executing this step

      • processRow

        boolean processRow​(StepMetaInterface smi,
                   StepDataInterface sdi)
            throws org.pentaho.di.core.exception.KettleException
        Perform the equivalent of processing one row. Typically this means reading a row from input (getRow()) and passing a row to output (putRow)).
        Parameters:
        smi - The steps metadata to work with
        sdi - The steps temporary working data to work with (database connections, result sets, caches, temporary variables, etc.)
        Returns:
        false if no more rows can be processed or an error occurred.
        Throws:
        org.pentaho.di.core.exception.KettleException

      • beforeStartProcessing

        default boolean beforeStartProcessing​(StepMetaInterface smi,
                                      StepDataInterface sdi)
                               throws org.pentaho.di.core.exception.KettleException
        This method is executed by Trans right before starting processing rows.
        Parameters:
        smi - The steps metadata to work with
        sdi - The steps temporary working data to work with (database connections, result sets, caches, temporary variables, etc.)
        Throws:
        org.pentaho.di.core.exception.KettleException

      • afterFinishProcessing

        default boolean afterFinishProcessing​(StepMetaInterface smi,
                                      StepDataInterface sdi)
        This method is executed by Trans after finishing processing rows.
        Parameters:
        smi - The steps metadata to work with
        sdi - The steps temporary working data to work with (database connections, result sets, caches, temporary variables, etc.)
        Throws:
        org.pentaho.di.core.exception.KettleException

      • canProcessOneRow

        boolean canProcessOneRow()
        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.

        Returns:
        true if the step can process a row.

      • init

        boolean init​(StepMetaInterface stepMetaInterface,
             StepDataInterface stepDataInterface)
        Initialize and do work where other steps need to wait for...
        Parameters:
        stepMetaInterface - The metadata to work with
        stepDataInterface - The data to initialize

      • dispose

        void dispose​(StepMetaInterface sii,
             StepDataInterface sdi)
        Dispose of this step: close files, empty logs, etc.
        Parameters:
        sii - The metadata to work with
        sdi - The data to dispose of

      • markStart

        void markStart()
        Mark the start time of the step.

      • markStop

        void markStop()
        Mark the end time of the step.

      • stopRunning

        void stopRunning​(StepMetaInterface stepMetaInterface,
                 StepDataInterface stepDataInterface)
          throws org.pentaho.di.core.exception.KettleException
        Stop running operations...
        Parameters:
        stepMetaInterface - The metadata that might be needed by the step to stop running.
        stepDataInterface - The interface to the step data containing the connections, resultsets, open files, etc.
        Throws:
        org.pentaho.di.core.exception.KettleException

      • isRunning

        boolean isRunning()
        Returns:
        true if the step is running after having been initialized

      • setRunning

        void setRunning​(boolean running)
        Flag the step as running or not
        Parameters:
        running - the running flag to set

      • isStopped

        boolean isStopped()
        Returns:
        True if the step is marked as stopped. Execution should stop immediate.

      • setStopped

        void setStopped​(boolean stopped)
        Parameters:
        stopped - true if the step needs to be stopped

      • setSafeStopped

        default void setSafeStopped​(boolean stopped)
        Parameters:
        stopped - true if the step needs to be safe stopped

      • isSafeStopped

        default boolean isSafeStopped()
        Returns:
        true if step is safe stopped.

      • isPaused

        boolean isPaused()
        Returns:
        True if the step is paused

      • stopAll

        void stopAll()
        Flags all rowsets as stopped/completed/finished.

      • pauseRunning

        void pauseRunning()
        Pause a running step

      • resumeRunning

        void resumeRunning()
        Resume a running step

      • getStepname

        String getStepname()
        Get the name of the step.
        Returns:
        the name of the step

      • getCopy

        int getCopy()
        Returns:
        The steps copy number (default 0)

      • getStepID

        String getStepID()
        Returns:
        the type ID of the step...

      • getErrors

        long getErrors()
        Get the number of errors
        Returns:
        the number of errors

      • setErrors

        void setErrors​(long errors)
        Sets the number of errors
        Parameters:
        errors - the number of errors to set

      • getLinesInput

        long getLinesInput()
        Returns:
        Returns the linesInput.

      • getLinesOutput

        long getLinesOutput()
        Returns:
        Returns the linesOutput.

      • getLinesRead

        long getLinesRead()
        Returns:
        Returns the linesRead.

      • getLinesWritten

        long getLinesWritten()
        Returns:
        Returns the linesWritten.

      • getLinesUpdated

        long getLinesUpdated()
        Returns:
        Returns the linesUpdated.

      • setLinesRejected

        void setLinesRejected​(long linesRejected)
        Parameters:
        linesRejected - steps the lines rejected by error handling.

      • getLinesRejected

        long getLinesRejected()
        Returns:
        Returns the lines rejected by error handling.

      • putRow

        void putRow​(org.pentaho.di.core.row.RowMetaInterface row,
            Object[] data)
     throws org.pentaho.di.core.exception.KettleException
        Put a row on the destination rowsets.
        Parameters:
        row - The row to send to the destinations steps
        Throws:
        org.pentaho.di.core.exception.KettleException

      • getRow

        Object[] getRow()
         throws org.pentaho.di.core.exception.KettleException
        Returns:
        a row from the source step(s).
        Throws:
        org.pentaho.di.core.exception.KettleException

      • setOutputDone

        void setOutputDone()
        Signal output done to destination steps

      • addRowListener

        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.
        Parameters:
        rowListener - the rowlistener to add

      • removeRowListener

        void removeRowListener​(RowListener rowListener)
        Remove a rowlistener from this step.
        Parameters:
        rowListener - the rowlistener to remove

      • getRowListeners

        List<RowListener> getRowListeners()
        Returns:
        a list of the installed RowListeners

      • getInputRowSets

        List<org.pentaho.di.core.RowSet> getInputRowSets()
        Returns:
        The list of active input rowsets for the step

      • getOutputRowSets

        List<org.pentaho.di.core.RowSet> getOutputRowSets()
        Returns:
        The list of active output rowsets for the step

      • isPartitioned

        boolean isPartitioned()
        Returns:
        true if the step is running partitioned

      • setPartitionID

        void setPartitionID​(String partitionID)
        Parameters:
        partitionID - the partitionID to set

      • getPartitionID

        String getPartitionID()
        Returns:
        the steps partition ID

      • cleanup

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

      • initBeforeStart

        void initBeforeStart()
              throws org.pentaho.di.core.exception.KettleStepException
        This method is executed by Trans right before the threads start and right after initialization.

        !!! A plugin implementing this method should make sure to also call super.initBeforeStart(); !!!
        Throws:
        org.pentaho.di.core.exception.KettleStepException - In case there is an error

      • addStepListener

        void addStepListener​(StepListener stepListener)
        Attach a step listener to be notified when a step arrives in a certain state. (finished)
        Parameters:
        stepListener - The listener to add to the step

      • isMapping

        boolean isMapping()
        Returns:
        true if the thread is a special mapping step

      • getStepMeta

        StepMeta getStepMeta()
        Returns:
        The metadata for this step

      • getLogChannel

        org.pentaho.di.core.logging.LogChannelInterface getLogChannel()
        Specified by:
        getLogChannel in interface HasLogChannelInterface
        Returns:
        the logging channel for this step

      • setUsingThreadPriorityManagment

        void setUsingThreadPriorityManagment​(boolean usingThreadPriorityManagment)
        Parameters:
        usingThreadPriorityManagment - set to true to actively manage priorities of step threads

      • isUsingThreadPriorityManagment

        boolean isUsingThreadPriorityManagment()
        Returns:
        true if we are actively managing priorities of step threads

      • rowsetInputSize

        int rowsetInputSize()
        Returns:
        The total amount of rows in the input buffers

      • rowsetOutputSize

        int rowsetOutputSize()
        Returns:
        The total amount of rows in the output buffers

      • getProcessed

        long getProcessed()
        Returns:
        The number of "processed" lines of a step. Well, a representable metric for that anyway.

      • getResultFiles

        Map<String,​org.pentaho.di.core.ResultFile> getResultFiles()
        Returns:
        The result files for this step

      • getRuntime

        long getRuntime()
        Returns:
        The number of ms that this step has been running

      • identifyErrorOutput

        void identifyErrorOutput()
        To be used to flag an error output channel of a step prior to execution for performance reasons.

      • setPartitioned

        void setPartitioned​(boolean partitioned)
        Parameters:
        partitioned - true if this step is partitioned

      • setRepartitioning

        void setRepartitioning​(int partitioningMethod)
        Parameters:
        partitioningMethod - The repartitioning method

      • batchComplete

        void batchComplete()
            throws org.pentaho.di.core.exception.KettleException
        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.
        Throws:
        org.pentaho.di.core.exception.KettleException - In case an error occurs during the processing of the batch of rows.

      • setMetaStore

        void setMetaStore​(org.pentaho.metastore.api.IMetaStore metaStore)
        Pass along the metastore to use when loading external elements at runtime.
        Parameters:
        metaStore - The metastore to use

      • getMetaStore

        org.pentaho.metastore.api.IMetaStore getMetaStore()
        Returns:
        The metastore that the step uses to load external elements from.

      • setRepository

        void setRepository​(Repository repository)
        Parameters:
        repository - The repository used by the step to load and reference Kettle objects with at runtime

      • getRepository

        Repository getRepository()
        Returns:
        The repository used by the step to load and reference Kettle objects with at runtime

      • getCurrentOutputRowSetNr

        int getCurrentOutputRowSetNr()
        Returns:
        the index of the active (current) output row set

      • setCurrentOutputRowSetNr

        void setCurrentOutputRowSetNr​(int index)
        Parameters:
        index - Sets the index of the active (current) output row set to use.

      • getCurrentInputRowSetNr

        int getCurrentInputRowSetNr()
        Returns:
        the index of the active (current) input row set

      • setCurrentInputRowSetNr

        void setCurrentInputRowSetNr​(int index)
        Parameters:
        index - Sets the index of the active (current) input row set to use.

      • addRowSetToInputRowSets

        default void addRowSetToInputRowSets​(org.pentaho.di.core.RowSet rowSet)

      • addRowSetToOutputRowSets

        default void addRowSetToOutputRowSets​(org.pentaho.di.core.RowSet rowSet)