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.steps.validator
Class ValidatorMeta

    java.lang.Object
      org.pentaho.di.trans.step.BaseStepMeta
          org.pentaho.di.trans.steps.validator.ValidatorMeta

All Implemented Interfaces:
  Cloneable, StepMetaInterface

    public class ValidatorMeta

extends BaseStepMeta
implements StepMetaInterface

Contains the meta-data for the Validator step: calculates predefined formula's Created on 08-sep-2005

Constructor Summary
`ValidatorMeta()`

Method Summary
`void` | `allocate(int nrValidations)`
`void` | `check(List<org.pentaho.di.core.CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, org.pentaho.di.core.row.RowMetaInterface prev, String[] input, String[] output, org.pentaho.di.core.row.RowMetaInterface info)` Checks the settings of this step and puts the findings in a remarks List.
`Object` | `clone()` Make an exact copy of this step, make sure to explicitly copy Collections etc.
`boolean` | `equals(Object obj)`
`boolean` | `excludeFromRowLayoutVerification()` This method is added to exclude certain steps from layout checking.
`String` | `getConcatenationSeparator()`
`String[]` | `getInfoSteps()`
`StepInterface` | `getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta tr, Trans trans)` Get the executing step, needed by Trans to launch a step.
`StepDataInterface` | `getStepData()` Get a new instance of the appropriate data class.
`Validation[]` | `getValidations()`
`String` | `getXML()` Produces the XML string that describes this step's information.
`boolean` | `isConcatenatingErrors()`
`boolean` | `isValidatingAll()`
`void` | `loadXML(Node stepnode, List<org.pentaho.di.core.database.DatabaseMeta> databases, Map<String,org.pentaho.di.core.Counter> counters)` Load the values for this step from an XML Node
`void` | `readRep(Repository rep, long id_step, List<org.pentaho.di.core.database.DatabaseMeta> databases, Map<String,org.pentaho.di.core.Counter> counters)` Read the steps information from a Kettle repository
`void` | `saveRep(Repository rep, long id_transformation, long id_step)` Save the steps data into a Kettle repository
`void` | `searchInfoAndTargetSteps(List<StepMeta> steps)`
`void` | `setConcatenatingErrors(boolean concatenatingErrors)`
`void` | `setConcatenationSeparator(String concatenationSeparator)`
`void` | `setDefault()` Set default values
`void` | `setValidatingAll(boolean validatingAll)`
`void` | `setValidations(Validation[] validations)`
`boolean` | `supportsErrorHandling()`

Methods inherited from class org.pentaho.di.trans.step.BaseStepMeta
`analyseImpact, cancelQueries, chosesTargetSteps, exportResources, getDialogClassName, getFields, getID, getRequiredFields, getRequiredFields, getResourceDependencies, getSQLStatements, getTableFields, getTargetSteps, getUsedArguments, getUsedDatabaseConnections, getUsedLibraries, hasChanged, setChanged, setChanged, setID, setInfoSteps, setTargetSteps`

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

Methods inherited from interface org.pentaho.di.trans.step.StepMetaInterface
`analyseImpact, cancelQueries, exportResources, getDialogClassName, getFields, getRequiredFields, getRequiredFields, getResourceDependencies, getSQLStatements, getTableFields, getTargetSteps, getUsedArguments, getUsedDatabaseConnections, getUsedLibraries, setInfoSteps, setTargetSteps`

Constructor Detail

### ValidatorMeta

    public ValidatorMeta()

Method Detail

### allocate

    public void allocate(int nrValidations)

### loadXML

    public void loadXML(Node stepnode,
                        List<org.pentaho.di.core.database.DatabaseMeta> databases,
                        Map<String,org.pentaho.di.core.Counter> counters)
                 throws org.pentaho.di.core.exception.KettleXMLException

  Description copied from interface: `StepMetaInterface`
  Load the values for this step from an XML Node

  Specified by:
    `loadXML` in interface `StepMetaInterface`
  Parameters:
    `stepnode` - the Node to get the info from
    `databases` - The available list of databases to reference to
    `counters` - Counters to reference.
  Throws:
    `org.pentaho.di.core.exception.KettleXMLException` - When an unexpected XML error occurred. (malformed etc.)

### getXML

    public String getXML()

  Description copied from class: `BaseStepMeta`
  Produces the XML string that describes this step's information.

  Specified by:
    `getXML` in interface `StepMetaInterface`
  Overrides:
    `getXML` in class `BaseStepMeta`
  Returns:
    String containing the XML describing this step.

### equals

    public boolean equals(Object obj)

  Overrides:
    `equals` in class `Object`

### clone

    public Object clone()

  Description copied from interface: `StepMetaInterface`
  Make an exact copy of this step, make sure to explicitly copy Collections etc.

  Specified by:
    `clone` in interface `StepMetaInterface`
  Overrides:
    `clone` in class `BaseStepMeta`
  Returns:
    an exact copy of this step

### setDefault

    public void setDefault()

  Description copied from interface: `StepMetaInterface`
  Set default values

  Specified by:
    `setDefault` in interface `StepMetaInterface`

### readRep

    public void readRep(Repository rep,
                        long id_step,
                        List<org.pentaho.di.core.database.DatabaseMeta> databases,
                        Map<String,org.pentaho.di.core.Counter> counters)
                 throws org.pentaho.di.core.exception.KettleException

  Description copied from interface: `StepMetaInterface`
  Read the steps information from a Kettle repository

  Specified by:
    `readRep` in interface `StepMetaInterface`
  Parameters:
    `rep` - The repository to read from
    `id_step` - The step ID
    `databases` - The databases to reference
    `counters` - The counters to reference
  Throws:
    `org.pentaho.di.core.exception.KettleException` - When an unexpected error occurred (database, network, etc)

### saveRep

    public void saveRep(Repository rep,
                        long id_transformation,
                        long id_step)
                 throws org.pentaho.di.core.exception.KettleException

  Description copied from interface: `StepMetaInterface`
  Save the steps data into a Kettle repository

  Specified by:
    `saveRep` in interface `StepMetaInterface`
  Parameters:
    `rep` - The Kettle repository to save to
    `id_transformation` - The transformation ID
    `id_step` - The step ID
  Throws:
    `org.pentaho.di.core.exception.KettleException` - When an unexpected error occurred (database, network, etc)

### check

    public void check(List<org.pentaho.di.core.CheckResultInterface> remarks,
                      TransMeta transMeta,
                      StepMeta stepMeta,
                      org.pentaho.di.core.row.RowMetaInterface prev,
                      String[] input,
                      String[] output,
                      org.pentaho.di.core.row.RowMetaInterface info)

  Description copied from interface: `StepMetaInterface`
  Checks the settings of this step and puts the findings in a remarks List.

  Specified by:
    `check` in interface `StepMetaInterface`
  Parameters:
    `remarks` - The list to put the remarks in @see org.pentaho.di.core.CheckResult
    `stepMeta` - The stepMeta to help checking
    `prev` - The fields coming from the previous step
    `input` - The input step names
    `output` - The output step names
    `info` - The fields that are used as information by the step

### getStep

    public StepInterface getStep(StepMeta stepMeta,
                                 StepDataInterface stepDataInterface,
                                 int cnr,
                                 TransMeta tr,
                                 Trans trans)

  Description copied from interface: `StepMetaInterface`
  Get the executing step, needed by Trans to launch a step.

  Specified by:
    `getStep` in interface `StepMetaInterface`
  Parameters:
    `stepMeta` - The step info
    `stepDataInterface` - the step data interface linked to this step. Here the step can store temporary data, database connections, etc.
    `cnr` - The copy nr to get
    `tr` - The transformation info
    `trans` - The launching transformation

### getStepData

    public StepDataInterface getStepData()

  Description copied from interface: `StepMetaInterface`
  Get a new instance of the appropriate data class. This data class implements the StepDataInterface. It basically contains the persisting data that needs to live on, even if a worker thread is terminated.

  Specified by:
    `getStepData` in interface `StepMetaInterface`
  Returns:
    The appropriate StepDataInterface class.

### supportsErrorHandling

    public boolean supportsErrorHandling()

  Specified by:
    `supportsErrorHandling` in interface `StepMetaInterface`
  Overrides:
    `supportsErrorHandling` in class `BaseStepMeta`
  Returns:
    true if this step supports error "reporting" on rows: the ability to send rows to a certain target step.

### getValidations

    public Validation[] getValidations()

  Returns:
    the validations

### setValidations

    public void setValidations(Validation[] validations)

  Parameters:
    `validations` - the validations to set

### excludeFromRowLayoutVerification

    public boolean excludeFromRowLayoutVerification()

  Description copied from class: `BaseStepMeta`
  This method is added to exclude certain steps from layout checking.

  Specified by:
    `excludeFromRowLayoutVerification` in interface `StepMetaInterface`
  Overrides:
    `excludeFromRowLayoutVerification` in class `BaseStepMeta`

### searchInfoAndTargetSteps

    public void searchInfoAndTargetSteps(List<StepMeta> steps)

  Specified by:
    `searchInfoAndTargetSteps` in interface `StepMetaInterface`
  Overrides:
    `searchInfoAndTargetSteps` in class `BaseStepMeta`
  Parameters:
    `steps` - optionally search the info step in a list of steps

### getInfoSteps

    public String[] getInfoSteps()

  Specified by:
    `getInfoSteps` in interface `StepMetaInterface`
  Overrides:
    `getInfoSteps` in class `BaseStepMeta`
  Returns:
    the informational source steps, if any. Null is the default: none.

### isValidatingAll

    public boolean isValidatingAll()

  Returns:
    the validatingAll

### setValidatingAll

    public void setValidatingAll(boolean validatingAll)

  Parameters:
    `validatingAll` - the validatingAll to set

### isConcatenatingErrors

    public boolean isConcatenatingErrors()

  Returns:
    the concatenatingErrors

### setConcatenatingErrors

    public void setConcatenatingErrors(boolean concatenatingErrors)

  Parameters:
    `concatenatingErrors` - the concatenatingErrors to set

### getConcatenationSeparator

    public String getConcatenationSeparator()

  Returns:
    the concatenationSeparator

### setConcatenationSeparator

    public void setConcatenationSeparator(String concatenationSeparator)

  Parameters:
    `concatenationSeparator` - the concatenationSeparator 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