org.pentaho.di.trans.steps.addsequence.AddSequenceMeta Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of kettle-engine Show documentation
Show all versions of kettle-engine Show documentation
Container pom for Pentaho Data Integration modules
The newest version!
/*! ******************************************************************************
*
* Pentaho Data Integration
*
* Copyright (C) 2002-2017 by Hitachi Vantara : http://www.pentaho.com
*
*******************************************************************************
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
package org.pentaho.di.trans.steps.addsequence;
import java.util.List;
import org.pentaho.di.core.CheckResult;
import org.pentaho.di.core.CheckResultInterface;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.SQLStatement;
import org.pentaho.di.core.database.Database;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleStepException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.core.row.value.ValueMetaInteger;
import org.pentaho.di.core.variables.VariableSpace;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.shared.SharedObjectInterface;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.BaseStepMeta;
import org.pentaho.di.trans.step.StepDataInterface;
import org.pentaho.di.trans.step.StepInterface;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.step.StepMetaInterface;
import org.pentaho.metastore.api.IMetaStore;
import org.w3c.dom.Node;
/**
* Meta data for the Add Sequence step.
*
* Created on 13-may-2003
*/
public class AddSequenceMeta extends BaseStepMeta implements StepMetaInterface {
private static Class PKG = AddSequenceMeta.class; // for i18n purposes, needed by Translator2!!
private String valuename;
private boolean useDatabase;
private DatabaseMeta database;
private String schemaName;
private String sequenceName;
private boolean useCounter;
private String counterName;
private String startAt;
private String incrementBy;
private String maxValue;
/**
* @return Returns the connection.
*/
public DatabaseMeta getDatabase() {
return database;
}
/**
* @param connection
* The connection to set.
*/
public void setDatabase( DatabaseMeta connection ) {
this.database = connection;
}
/**
* @return Returns the incrementBy.
*/
public String getIncrementBy() {
return incrementBy;
}
/**
* @param incrementBy
* The incrementBy to set.
*/
public void setIncrementBy( String incrementBy ) {
this.incrementBy = incrementBy;
}
/**
* @return Returns the maxValue.
*/
public String getMaxValue() {
return maxValue;
}
/**
* @param maxValue
* The maxValue to set.
*/
public void setMaxValue( String maxValue ) {
this.maxValue = maxValue;
}
/**
* @return Returns the sequenceName.
*/
public String getSequenceName() {
return sequenceName;
}
/**
* @param sequenceName
* The sequenceName to set.
*/
public void setSequenceName( String sequenceName ) {
this.sequenceName = sequenceName;
}
/**
* @param maxValue
* The maxValue to set.
*/
public void setMaxValue( long maxValue ) {
this.maxValue = Long.toString( maxValue );
}
/**
* @param startAt
* The starting point of the sequence to set.
*/
public void setStartAt( long startAt ) {
this.startAt = Long.toString( startAt );
}
/**
* @param incrementBy
* The incrementBy to set.
*/
public void setIncrementBy( long incrementBy ) {
this.incrementBy = Long.toString( incrementBy );
}
/**
* @return Returns the start of the sequence.
*/
public String getStartAt() {
return startAt;
}
/**
* @param startAt
* The starting point of the sequence to set.
*/
public void setStartAt( String startAt ) {
this.startAt = startAt;
}
/**
* @return Returns the useCounter.
*/
public boolean isCounterUsed() {
return useCounter;
}
/**
* @param useCounter
* The useCounter to set.
*/
public void setUseCounter( boolean useCounter ) {
this.useCounter = useCounter;
}
/**
* @return Returns the useDatabase.
*/
public boolean isDatabaseUsed() {
return useDatabase;
}
/**
* @param useDatabase
* The useDatabase to set.
*/
public void setUseDatabase( boolean useDatabase ) {
this.useDatabase = useDatabase;
}
/**
* @return Returns the valuename.
*/
public String getValuename() {
return valuename;
}
/**
* @param valuename
* The valuename to set.
*/
public void setValuename( String valuename ) {
this.valuename = valuename;
}
@Override
public void loadXML( Node stepnode, List databases, IMetaStore metaStore ) throws KettleXMLException {
readData( stepnode, databases );
}
@Override
public Object clone() {
Object retval = super.clone();
return retval;
}
private void readData( Node stepnode, List databases ) throws KettleXMLException {
try {
valuename = XMLHandler.getTagValue( stepnode, "valuename" );
useDatabase = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "use_database" ) );
String conn = XMLHandler.getTagValue( stepnode, "connection" );
database = DatabaseMeta.findDatabase( databases, conn );
schemaName = XMLHandler.getTagValue( stepnode, "schema" );
sequenceName = XMLHandler.getTagValue( stepnode, "seqname" );
useCounter = "Y".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "use_counter" ) );
counterName = XMLHandler.getTagValue( stepnode, "counter_name" );
startAt = XMLHandler.getTagValue( stepnode, "start_at" );
incrementBy = XMLHandler.getTagValue( stepnode, "increment_by" );
maxValue = XMLHandler.getTagValue( stepnode, "max_value" );
// TODO startAt = Const.toLong(XMLHandler.getTagValue(stepnode, "start_at"), 1);
// incrementBy = Const.toLong(XMLHandler.getTagValue(stepnode, "increment_by"), 1);
// maxValue = Const.toLong(XMLHandler.getTagValue(stepnode, "max_value"), 999999999L);
} catch ( Exception e ) {
throw new KettleXMLException(
BaseMessages.getString( PKG, "AddSequenceMeta.Exception.ErrorLoadingStepInfo" ), e );
}
}
@Override
public void setDefault() {
valuename = "valuename";
useDatabase = false;
schemaName = "";
sequenceName = "SEQ_";
database = null;
useCounter = true;
counterName = null;
startAt = "1";
incrementBy = "1";
maxValue = "999999999";
}
@Override
public void getFields( RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep,
VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException {
ValueMetaInterface v = new ValueMetaInteger( valuename );
// v.setLength(ValueMetaInterface.DEFAULT_INTEGER_LENGTH, 0); Removed for 2.5.x compatibility reasons.
v.setOrigin( name );
row.addValueMeta( v );
}
@Override
public String getXML() {
StringBuilder retval = new StringBuilder( 300 );
retval.append( " " ).append( XMLHandler.addTagValue( "valuename", valuename ) );
retval.append( " " ).append( XMLHandler.addTagValue( "use_database", useDatabase ) );
retval
.append( " " ).append( XMLHandler.addTagValue( "connection", database == null ? "" : database.getName() ) );
retval.append( " " ).append( XMLHandler.addTagValue( "schema", schemaName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "seqname", sequenceName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "use_counter", useCounter ) );
retval.append( " " ).append( XMLHandler.addTagValue( "counter_name", counterName ) );
retval.append( " " ).append( XMLHandler.addTagValue( "start_at", startAt ) );
retval.append( " " ).append( XMLHandler.addTagValue( "increment_by", incrementBy ) );
retval.append( " " ).append( XMLHandler.addTagValue( "max_value", maxValue ) );
return retval.toString();
}
@Override
public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List databases ) throws KettleException {
try {
valuename = rep.getStepAttributeString( id_step, "valuename" );
useDatabase = rep.getStepAttributeBoolean( id_step, "use_database" );
database = rep.loadDatabaseMetaFromStepAttribute( id_step, "id_connection", databases );
schemaName = rep.getStepAttributeString( id_step, "schema" );
sequenceName = rep.getStepAttributeString( id_step, "seqname" );
useCounter = rep.getStepAttributeBoolean( id_step, "use_counter" );
counterName = rep.getStepAttributeString( id_step, "counter_name" );
startAt = rep.getStepAttributeString( id_step, "start_at" );
incrementBy = rep.getStepAttributeString( id_step, "increment_by" );
maxValue = rep.getStepAttributeString( id_step, "max_value" );
// Fix for backwards compatibility, only to be used from previous versions (TO DO Sven Boden: remove in later
// versions)
if ( startAt == null ) {
long start = rep.getStepAttributeInteger( id_step, "start_at" );
startAt = Long.toString( start );
}
if ( incrementBy == null ) {
long increment = rep.getStepAttributeInteger( id_step, "increment_by" );
incrementBy = Long.toString( increment );
}
if ( maxValue == null ) {
long max = rep.getStepAttributeInteger( id_step, "max_value" );
maxValue = Long.toString( max );
}
} catch ( Exception e ) {
throw new KettleException( BaseMessages.getString( PKG, "AddSequenceMeta.Exception.UnableToReadStepInfo" )
+ id_step, e );
}
}
@Override
public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ) throws KettleException {
try {
rep.saveStepAttribute( id_transformation, id_step, "valuename", valuename );
rep.saveStepAttribute( id_transformation, id_step, "use_database", useDatabase );
rep.saveDatabaseMetaStepAttribute( id_transformation, id_step, "id_connection", database );
rep.saveStepAttribute( id_transformation, id_step, "schema", schemaName );
rep.saveStepAttribute( id_transformation, id_step, "seqname", sequenceName );
rep.saveStepAttribute( id_transformation, id_step, "use_counter", useCounter );
rep.saveStepAttribute( id_transformation, id_step, "counter_name", counterName );
rep.saveStepAttribute( id_transformation, id_step, "start_at", startAt );
rep.saveStepAttribute( id_transformation, id_step, "increment_by", incrementBy );
rep.saveStepAttribute( id_transformation, id_step, "max_value", maxValue );
// Also, save the step-database relationship!
if ( database != null ) {
rep.insertStepDatabase( id_transformation, id_step, database.getObjectId() );
}
} catch ( Exception e ) {
throw new KettleException( BaseMessages.getString( PKG, "AddSequenceMeta.Exception.UnableToSaveStepInfo" )
+ id_step, e );
}
}
@Override
public void check( List remarks, TransMeta transMeta, StepMeta stepMeta,
RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space,
Repository repository, IMetaStore metaStore ) {
CheckResult cr;
if ( useDatabase ) {
Database db = new Database( loggingObject, database );
db.shareVariablesWith( transMeta );
try {
db.connect();
if ( db.checkSequenceExists( transMeta.environmentSubstitute( schemaName ), transMeta
.environmentSubstitute( sequenceName ) ) ) {
cr =
new CheckResult( CheckResultInterface.TYPE_RESULT_OK, BaseMessages.getString(
PKG, "AddSequenceMeta.CheckResult.SequenceExists.Title" ), stepMeta );
} else {
cr =
new CheckResult( CheckResultInterface.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "AddSequenceMeta.CheckResult.SequenceCouldNotBeFound.Title", sequenceName ), stepMeta );
}
} catch ( KettleException e ) {
cr =
new CheckResult( CheckResultInterface.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "AddSequenceMeta.CheckResult.UnableToConnectDB.Title" )
+ Const.CR + e.getMessage(), stepMeta );
} finally {
db.disconnect();
}
remarks.add( cr );
}
if ( input.length > 0 ) {
cr =
new CheckResult( CheckResultInterface.TYPE_RESULT_OK, BaseMessages.getString(
PKG, "AddSequenceMeta.CheckResult.StepIsReceving.Title" ), stepMeta );
remarks.add( cr );
} else {
cr =
new CheckResult( CheckResultInterface.TYPE_RESULT_ERROR, BaseMessages.getString(
PKG, "AddSequenceMeta.CheckResult.NoInputReceived.Title" ), stepMeta );
remarks.add( cr );
}
}
@Override
public SQLStatement getSQLStatements( TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev,
Repository repository, IMetaStore metaStore ) {
SQLStatement retval = new SQLStatement( stepMeta.getName(), database, null ); // default: nothing to do!
if ( useDatabase ) {
// Otherwise, don't bother!
if ( database != null ) {
Database db = new Database( loggingObject, database );
db.shareVariablesWith( transMeta );
try {
db.connect();
if ( !db.checkSequenceExists( schemaName, sequenceName ) ) {
String cr_table = db.getCreateSequenceStatement( sequenceName, startAt, incrementBy, maxValue, true );
retval.setSQL( cr_table );
} else {
retval.setSQL( null ); // Empty string means: nothing to do: set it to null...
}
} catch ( KettleException e ) {
retval.setError( BaseMessages.getString( PKG, "AddSequenceMeta.ErrorMessage.UnableToConnectDB" )
+ Const.CR + e.getMessage() );
} finally {
db.disconnect();
}
} else {
retval.setError( BaseMessages.getString( PKG, "AddSequenceMeta.ErrorMessage.NoConnectionDefined" ) );
}
}
return retval;
}
@Override
public StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr,
TransMeta transMeta, Trans trans ) {
return new AddSequence( stepMeta, stepDataInterface, cnr, transMeta, trans );
}
@Override
public StepDataInterface getStepData() {
return new AddSequenceData();
}
@Override
public DatabaseMeta[] getUsedDatabaseConnections() {
if ( database != null ) {
return new DatabaseMeta[] { database };
} else {
return super.getUsedDatabaseConnections();
}
}
/**
* @return the counterName
*/
public String getCounterName() {
return counterName;
}
/**
* @param counterName
* the counterName to set
*/
public void setCounterName( String counterName ) {
this.counterName = counterName;
}
/**
* @return the schemaName
*/
public String getSchemaName() {
return schemaName;
}
/**
* @param schemaName
* the schemaName to set
*/
public void setSchemaName( String schemaName ) {
this.schemaName = schemaName;
}
}