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.synchronizeaftermerge
Class SynchronizeAfterMergeMeta

    java.lang.Object
      org.pentaho.di.trans.step.BaseStepMeta
          org.pentaho.di.trans.steps.synchronizeaftermerge.SynchronizeAfterMergeMeta

All Implemented Interfaces:
  Cloneable, StepMetaInterface

    public class SynchronizeAfterMergeMeta

extends BaseStepMeta
implements StepMetaInterface

Constructor Summary
`SynchronizeAfterMergeMeta()`

Method Summary
`void` | `allocate(int nrkeys, int nrvalues)`
`void` | `analyseImpact(List<DatabaseImpact> impact, TransMeta transMeta, StepMeta stepMeta, org.pentaho.di.core.row.RowMetaInterface prev, String[] input, String[] output, org.pentaho.di.core.row.RowMetaInterface info)` Each step must be able to report on the impact it has on a database, table field, etc.
`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.
`int` | `getCommitSize()`
`org.pentaho.di.core.database.DatabaseMeta` | `getDatabaseMeta()`
`String[]` | `getKeyCondition()`
`String[]` | `getKeyLookup()`
`String[]` | `getKeyStream()`
`String[]` | `getKeyStream2()`
`String` | `getOperationOrderField()`
`String` | `getOrderDelete()`
`String` | `getOrderInsert()`
`String` | `getOrderUpdate()`
`org.pentaho.di.core.row.RowMetaInterface` | `getRequiredFields(org.pentaho.di.core.variables.VariableSpace space)` The natural way of data flow in a transformation is source-to-target.
`String` | `getSchemaName()`
`org.pentaho.di.core.SQLStatement` | `getSQLStatements(TransMeta transMeta, StepMeta stepMeta, org.pentaho.di.core.row.RowMetaInterface prev)` Standard method to return one or more SQLStatement objects that the step needs in order to work correctly.
`StepInterface` | `getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans trans)` Get the executing step, needed by Trans to launch a step.
`StepDataInterface` | `getStepData()` Get a new instance of the appropriate data class.
`String` | `getTableName()`
`String` | `gettablenameField()`
`Boolean[]` | `getUpdate()`
`String[]` | `getUpdateLookup()`
`String[]` | `getUpdateStream()`
`org.pentaho.di.core.database.DatabaseMeta[]` | `getUsedDatabaseConnections()` This method returns all the database connections that are used by the step.
`String` | `getXML()` Produces the XML string that describes this step's information.
`boolean` | `isPerformLookup()`
`boolean` | `istablenameInField()`
`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` | `setCommitSize(int commitSize)`
`void` | `setDatabaseMeta(org.pentaho.di.core.database.DatabaseMeta database)`
`void` | `setDefault()` Set default values
`void` | `setKeyCondition(String[] keyCondition)`
`void` | `setKeyLookup(String[] keyLookup)`
`void` | `setKeyStream(String[] keyStream)`
`void` | `setKeyStream2(String[] keyStream2)`
`void` | `setOperationOrderField(String operationOrderField)`
`void` | `setOrderDelete(String delete)`
`void` | `setOrderInsert(String insert)`
`void` | `setOrderUpdate(String update)`
`void` | `setPerformLookup(boolean performLookup)`
`void` | `setSchemaName(String schemaName)`
`void` | `setTableName(String tableName)`
`void` | `settablenameField(String tablenamefield)`
`void` | `settablenameInField(boolean tablenamefield)`
`void` | `setUpdate(Boolean[] update)`
`void` | `setUpdateLookup(String[] updateLookup)`
`void` | `setUpdateStream(String[] updateStream)`
`void` | `setUseBatchUpdate(boolean useBatchUpdate)`
`boolean` | `supportsErrorHandling()`
`boolean` | `useBatchUpdate()`

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

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

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

Constructor Detail

### SynchronizeAfterMergeMeta

    public SynchronizeAfterMergeMeta()

Method Detail

### setUseBatchUpdate

    public void setUseBatchUpdate(boolean useBatchUpdate)

  Parameters:
    `useBatchUpdate` - The useBatchUpdate flag to set.

### useBatchUpdate

    public boolean useBatchUpdate()

  Returns:
    Returns the useBatchUpdate flag.

### setPerformLookup

    public void setPerformLookup(boolean performLookup)

  Parameters:
    `performLookup` - The performLookup flag to set.

### isPerformLookup

    public boolean isPerformLookup()

  Returns:
    Returns the performLookup flag.

### istablenameInField

    public boolean istablenameInField()

### settablenameInField

    public void settablenameInField(boolean tablenamefield)

### gettablenameField

    public String gettablenameField()

### getOperationOrderField

    public String getOperationOrderField()

### getOrderInsert

    public String getOrderInsert()

### getOrderUpdate

    public String getOrderUpdate()

### getOrderDelete

    public String getOrderDelete()

### setOrderInsert

    public void setOrderInsert(String insert)

### setOrderUpdate

    public void setOrderUpdate(String update)

### setOrderDelete

    public void setOrderDelete(String delete)

### setOperationOrderField

    public void setOperationOrderField(String operationOrderField)

### settablenameField

    public void settablenameField(String tablenamefield)

### getCommitSize

    public int getCommitSize()

  Returns:
    Returns the commitSize.

### setCommitSize

    public void setCommitSize(int commitSize)

  Parameters:
    `commitSize` - The commitSize to set.

### getDatabaseMeta

    public org.pentaho.di.core.database.DatabaseMeta getDatabaseMeta()

  Returns:
    Returns the database.

### setDatabaseMeta

    public void setDatabaseMeta(org.pentaho.di.core.database.DatabaseMeta database)

  Parameters:
    `database` - The database to set.

### getKeyCondition

    public String[] getKeyCondition()

  Returns:
    Returns the keyCondition.

### setKeyCondition

    public void setKeyCondition(String[] keyCondition)

  Parameters:
    `keyCondition` - The keyCondition to set.

### getKeyLookup

    public String[] getKeyLookup()

  Returns:
    Returns the keyLookup.

### setKeyLookup

    public void setKeyLookup(String[] keyLookup)

  Parameters:
    `keyLookup` - The keyLookup to set.

### getKeyStream

    public String[] getKeyStream()

  Returns:
    Returns the keyStream.

### setKeyStream

    public void setKeyStream(String[] keyStream)

  Parameters:
    `keyStream` - The keyStream to set.

### getKeyStream2

    public String[] getKeyStream2()

  Returns:
    Returns the keyStream2.

### setKeyStream2

    public void setKeyStream2(String[] keyStream2)

  Parameters:
    `keyStream2` - The keyStream2 to set.

### getTableName

    public String getTableName()

  Returns:
    Returns the tableName.

### setTableName

    public void setTableName(String tableName)

  Parameters:
    `tableName` - The tableName to set.

### getUpdateLookup

    public String[] getUpdateLookup()

  Returns:
    Returns the updateLookup.

### setUpdateLookup

    public void setUpdateLookup(String[] updateLookup)

  Parameters:
    `updateLookup` - The updateLookup to set.

### getUpdateStream

    public String[] getUpdateStream()

  Returns:
    Returns the updateStream.

### setUpdateStream

    public void setUpdateStream(String[] updateStream)

  Parameters:
    `updateStream` - The updateStream to set.

### getUpdate

    public Boolean[] getUpdate()

### setUpdate

    public void setUpdate(Boolean[] update)

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

### allocate

    public void allocate(int nrkeys,
                         int nrvalues)

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

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

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

### getSQLStatements

    public org.pentaho.di.core.SQLStatement getSQLStatements(TransMeta transMeta,
                                                             StepMeta stepMeta,
                                                             org.pentaho.di.core.row.RowMetaInterface prev)
                                                      throws org.pentaho.di.core.exception.KettleStepException

  Description copied from class: `BaseStepMeta`
  Standard method to return one or more SQLStatement objects that the step needs in order to work correctly. This can mean "create table", "create index" statements but also "alter table ... add/drop/modify" statements.

  Specified by:
    `getSQLStatements` in interface `StepMetaInterface`
  Overrides:
    `getSQLStatements` in class `BaseStepMeta`
  Parameters:
    `transMeta` - TransInfo object containing the complete transformation
    `stepMeta` - StepMeta object containing the complete step
    `prev` - Row containing meta-data for the input fields (no data)
  Returns:
    The SQL Statements for this step or null if an error occurred. If nothing has to be done, the SQLStatement.getSQL() == null.
  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### analyseImpact

    public void analyseImpact(List<DatabaseImpact> impact,
                              TransMeta transMeta,
                              StepMeta stepMeta,
                              org.pentaho.di.core.row.RowMetaInterface prev,
                              String[] input,
                              String[] output,
                              org.pentaho.di.core.row.RowMetaInterface info)
                       throws org.pentaho.di.core.exception.KettleStepException

  Description copied from class: `BaseStepMeta`
  Each step must be able to report on the impact it has on a database, table field, etc.

  Specified by:
    `analyseImpact` in interface `StepMetaInterface`
  Overrides:
    `analyseImpact` in class `BaseStepMeta`
  Parameters:
    `impact` - The list of impacts @see org.pentaho.di.transMeta.DatabaseImpact
    `transMeta` - The transformation information
    `stepMeta` - The step information
    `prev` - The fields entering this step
    `input` - The previous step names
    `output` - The output step names
    `info` - The fields used as information by this step
  Throws:
    `org.pentaho.di.core.exception.KettleStepException`

### getStep

    public StepInterface getStep(StepMeta stepMeta,
                                 StepDataInterface stepDataInterface,
                                 int cnr,
                                 TransMeta transMeta,
                                 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
    `transMeta` - 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.

### getUsedDatabaseConnections

    public org.pentaho.di.core.database.DatabaseMeta[] getUsedDatabaseConnections()

  Description copied from class: `BaseStepMeta`
  This method returns all the database connections that are used by the step.

  Specified by:
    `getUsedDatabaseConnections` in interface `StepMetaInterface`
  Overrides:
    `getUsedDatabaseConnections` in class `BaseStepMeta`
  Returns:
    an array of database connections meta-data. Return an empty array if no connections are used.

### getRequiredFields

    public org.pentaho.di.core.row.RowMetaInterface getRequiredFields(org.pentaho.di.core.variables.VariableSpace space)
                                                               throws org.pentaho.di.core.exception.KettleException

  Description copied from class: `BaseStepMeta`
  The natural way of data flow in a transformation is source-to-target. However, this makes mapping to target tables difficult to do. To help out here, we supply information to the transformation meta-data model about which fields are required for a step. This allows us to automate certain tasks like the mapping to pre-defined tables. The Table Output step in this case will output the fields in the target table using this method. This default implementation returns an empty row meaning that no fields are required for this step to operate.

  Specified by:
    `getRequiredFields` in interface `StepMetaInterface`
  Overrides:
    `getRequiredFields` in class `BaseStepMeta`
  Parameters:
    `space` - the variable space to use to do variable substitution.
  Returns:
    the required fields for this steps meta data.
  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case the required fields can't be determined

### getSchemaName

    public String getSchemaName()

  Returns:
    the schemaName

### setSchemaName

    public void setSchemaName(String schemaName)

  Parameters:
    `schemaName` - the schemaName to set

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

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