[CLEANUP] Remove ValueMeta

core/src/org/pentaho/di/core/RowMetaAndData.java

@@ -25,13 +25,15 @@
 import java.math.BigDecimal;
 import java.util.Date;
 
+import org.pentaho.di.core.exception.KettlePluginException;
 import org.pentaho.di.core.exception.KettleValueException;
 import org.pentaho.di.core.injection.InjectionTypeConverter;
 import org.pentaho.di.core.row.RowDataUtil;
 import org.pentaho.di.core.row.RowMeta;
 import org.pentaho.di.core.row.RowMetaInterface;
-import org.pentaho.di.core.row.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaInterface;
+import org.pentaho.di.core.row.value.ValueMetaFactory;
+import org.pentaho.di.core.row.value.ValueMetaNone;
 import org.pentaho.di.repository.LongObjectId;
 import org.pentaho.di.repository.ObjectId;
 
@@ -134,7 +136,13 @@ public void addValue( ValueMetaInterface valueMeta, Object valueData ) {
   }
 
   public void addValue( String valueName, int valueType, Object valueData ) {
-    addValue( new ValueMeta( valueName, valueType ), valueData );
+    ValueMetaInterface v;
+    try {
+      v = ValueMetaFactory.createValueMeta( valueName, valueType );
+    } catch ( KettlePluginException e ) {
+      v = new ValueMetaNone( valueName );
+    }
+    addValue( v, valueData );
   }
 
   public void clear() {

core/test-src/org/pentaho/di/core/database/DatabaseMetaTest.java

@@ -41,6 +41,7 @@
 import org.pentaho.di.core.row.RowMetaInterface;
 import org.pentaho.di.core.row.ValueMetaInterface;
 import org.pentaho.di.core.row.value.ValueMetaNone;
+import org.pentaho.di.core.row.value.ValueMetaPluginType;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -60,17 +61,14 @@ public class DatabaseMetaTest {
   private static final String DROP_STATEMENT = "dropStatement";
   private static final String DROP_STATEMENT_FALLBACK = "DROP TABLE IF EXISTS " + TABLE_NAME;
 
-  private static final String CONNECTION_TYPE_ID_MSSQL = "MSSQL";
-  private static final String CONNECTION_TYPE_ID_MSSQL_NATIVE = "MSSQLNATIVE";
-  private static final String CONNECTION_TYPE_ID_ORACLE = "ORACLE";
-
   private DatabaseMeta databaseMeta;
   private DatabaseInterface databaseInterface;
 
   @BeforeClass
   public static void setUpOnce() throws KettlePluginException {
     // Register Natives to create a default DatabaseMeta
     DatabasePluginType.getInstance().searchPlugins();
+    ValueMetaPluginType.getInstance().searchPlugins();
   }
 
   @Before

engine/src/org/pentaho/di/repository/kdr/delegates/KettleDatabaseRepositoryValueDelegate.java

@@ -24,7 +24,6 @@
 
 import org.pentaho.di.core.RowMetaAndData;
 import org.pentaho.di.core.exception.KettleException;
-import org.pentaho.di.core.row.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaAndData;
 import org.pentaho.di.core.row.ValueMetaInterface;
 import org.pentaho.di.core.row.value.ValueMetaFactory;
@@ -55,7 +54,8 @@ public ValueMetaAndData loadValueMetaAndData( ObjectId id_value ) throws KettleE
         int valtype = ValueMetaFactory.getIdForValueMeta(
           r.getString( KettleDatabaseRepository.FIELD_VALUE_VALUE_TYPE, null ) );
         boolean isNull = r.getBoolean( KettleDatabaseRepository.FIELD_VALUE_IS_NULL, false );
-        valueMetaAndData.setValueMeta( new ValueMeta( name, valtype ) );
+        ValueMetaInterface v = ValueMetaFactory.createValueMeta( name, valtype );
+        valueMetaAndData.setValueMeta( v );
 
         if ( isNull ) {
           valueMetaAndData.setValueData( null );
@@ -84,7 +84,7 @@ public ValueMetaAndData loadValueMetaAndData( ObjectId id_value ) throws KettleE
           // OK, now comes the dirty part...
           // We want the defaults back on there...
           //
-          valueMeta = new ValueMeta( name, valueMeta.getType() );
+          valueMeta = ValueMetaFactory.createValueMeta( name, valueMeta.getType() );
         }
       }
 

engine/src/org/pentaho/di/trans/steps/accessinput/AccessInputMeta.java

@@ -34,17 +34,18 @@
 import org.pentaho.di.core.util.Utils;
 import org.pentaho.di.core.database.DatabaseMeta;
 import org.pentaho.di.core.exception.KettleException;
+import org.pentaho.di.core.exception.KettlePluginException;
 import org.pentaho.di.core.exception.KettleStepException;
 import org.pentaho.di.core.exception.KettleXMLException;
 import org.pentaho.di.core.fileinput.FileInputList;
 import org.pentaho.di.core.row.RowMetaInterface;
-import org.pentaho.di.core.row.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaAndData;
 import org.pentaho.di.core.row.ValueMetaInterface;
 import org.pentaho.di.core.row.value.ValueMetaBoolean;
 import org.pentaho.di.core.row.value.ValueMetaDate;
 import org.pentaho.di.core.row.value.ValueMetaFactory;
 import org.pentaho.di.core.row.value.ValueMetaInteger;
+import org.pentaho.di.core.row.value.ValueMetaNone;
 import org.pentaho.di.core.row.value.ValueMetaString;
 import org.pentaho.di.core.variables.VariableSpace;
 import org.pentaho.di.core.vfs.KettleVFS;
@@ -855,7 +856,12 @@ public void getFields( RowMetaInterface r, String name, RowMetaInterface[] info,
       if ( type == ValueMetaInterface.TYPE_NONE ) {
         type = ValueMetaInterface.TYPE_STRING;
       }
-      ValueMetaInterface v = new ValueMeta( space.environmentSubstitute( field.getName() ), type );
+      ValueMetaInterface v;
+      try {
+        v = ValueMetaFactory.createValueMeta( space.environmentSubstitute( field.getName() ), type );
+      } catch ( KettlePluginException e ) {
+        v = new ValueMetaNone( space.environmentSubstitute( field.getName() ) );
+      }
       v.setLength( field.getLength() );
       v.setPrecision( field.getPrecision() );
       v.setOrigin( name );
@@ -1317,7 +1323,12 @@ public static ValueMetaAndData getValueMetaAndData( Column c, String name, Objec
         break;
     }
 
-    ValueMetaInterface sourceValueMeta = new ValueMeta( name == null ? c.getName() : name, sourceValueType );
+    ValueMetaInterface sourceValueMeta;
+    try {
+      sourceValueMeta = ValueMetaFactory.createValueMeta( name == null ? c.getName() : name, sourceValueType );
+    } catch ( KettlePluginException e ) {
+      sourceValueMeta = new ValueMetaNone( name == null ? c.getName() : name );
+    }
     sourceValueMeta.setLength( c.getLength(), c.getPrecision() );
 
     // set value meta data and return it

engine/src/org/pentaho/di/trans/steps/databasejoin/DatabaseJoinMeta.java

@@ -31,13 +31,14 @@
 import org.pentaho.di.core.database.DatabaseMeta;
 import org.pentaho.di.core.exception.KettleDatabaseException;
 import org.pentaho.di.core.exception.KettleException;
+import org.pentaho.di.core.exception.KettlePluginException;
 import org.pentaho.di.core.exception.KettleStepException;
 import org.pentaho.di.core.exception.KettleXMLException;
 import org.pentaho.di.core.row.RowMeta;
 import org.pentaho.di.core.row.RowMetaInterface;
-import org.pentaho.di.core.row.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaInterface;
 import org.pentaho.di.core.row.value.ValueMetaFactory;
+import org.pentaho.di.core.row.value.ValueMetaNone;
 import org.pentaho.di.core.variables.VariableSpace;
 import org.pentaho.di.core.xml.XMLHandler;
 import org.pentaho.di.i18n.BaseMessages;
@@ -528,7 +529,13 @@ public RowMetaInterface getTableFields() {
     //
     RowMetaInterface param = new RowMeta();
     for ( int i = 0; i < parameterField.length; i++ ) {
-      param.addValueMeta( new ValueMeta( parameterField[i], parameterType[i] ) );
+      ValueMetaInterface v;
+      try {
+        v = ValueMetaFactory.createValueMeta( parameterField[i], parameterType[i] );
+      } catch ( KettlePluginException e ) {
+        v = new ValueMetaNone( parameterField[i] );
+      }
+      param.addValueMeta( v );
     }
 
     RowMetaInterface fields = null;

engine/src/org/pentaho/di/trans/steps/dbproc/DBProcMeta.java

@@ -31,11 +31,13 @@
 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.KettlePluginException;
 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.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaInterface;
+import org.pentaho.di.core.row.value.ValueMetaBase;
+import org.pentaho.di.core.row.value.ValueMetaFactory;
 import org.pentaho.di.core.variables.VariableSpace;
 import org.pentaho.di.core.xml.XMLHandler;
 import org.pentaho.di.i18n.BaseMessages;
@@ -257,16 +259,26 @@ public void getFields( RowMetaInterface r, String name, RowMetaInterface[] info,
     VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException {
 
     if ( !Utils.isEmpty( resultName ) ) {
-      ValueMetaInterface v = new ValueMeta( resultName, resultType );
-      v.setOrigin( name );
-      r.addValueMeta( v );
+      ValueMetaInterface v;
+      try {
+        v = ValueMetaFactory.createValueMeta( resultName, resultType );
+        v.setOrigin( name );
+        r.addValueMeta( v );
+      } catch ( KettlePluginException e ) {
+        throw new KettleStepException( e );
+      }
     }
 
     for ( int i = 0; i < argument.length; i++ ) {
       if ( argumentDirection[i].equalsIgnoreCase( "OUT" ) ) {
-        ValueMetaInterface v = new ValueMeta( argument[i], argumentType[i] );
-        v.setOrigin( name );
-        r.addValueMeta( v );
+        ValueMetaInterface v;
+        try {
+          v = ValueMetaFactory.createValueMeta( argument[i], argumentType[i] );
+          v.setOrigin( name );
+          r.addValueMeta( v );
+        } catch ( KettlePluginException e ) {
+          throw new KettleStepException( e );
+        }
       }
     }
 
@@ -286,15 +298,16 @@ public String getXML() {
       retval.append( "        " ).append( XMLHandler.addTagValue( "name", argument[i] ) );
       retval.append( "        " ).append( XMLHandler.addTagValue( "direction", argumentDirection[i] ) );
       retval.append( "        " ).append(
-        XMLHandler.addTagValue( "type", ValueMeta.getTypeDesc( argumentType[i] ) ) );
+        XMLHandler.addTagValue( "type", ValueMetaFactory.getValueMetaName( argumentType[i] ) ) );
       retval.append( "      </arg>" ).append( Const.CR );
     }
 
     retval.append( "    </lookup>" ).append( Const.CR );
 
     retval.append( "    <result>" ).append( Const.CR );
     retval.append( "      " ).append( XMLHandler.addTagValue( "name", resultName ) );
-    retval.append( "      " ).append( XMLHandler.addTagValue( "type", ValueMeta.getTypeDesc( resultType ) ) );
+    retval.append( "      " ).append( XMLHandler.addTagValue( "type",
+      ValueMetaFactory.getValueMetaName( resultType ) ) );
     retval.append( "    </result>" ).append( Const.CR );
 
     retval.append( "    " ).append( XMLHandler.addTagValue( "auto_commit", autoCommit ) );
@@ -321,12 +334,12 @@ private void readData( Node stepnode, List<? extends SharedObjectInterface> data
 
         argument[i] = XMLHandler.getTagValue( anode, "name" );
         argumentDirection[i] = XMLHandler.getTagValue( anode, "direction" );
-        argumentType[i] = ValueMeta.getType( XMLHandler.getTagValue( anode, "type" ) );
+        argumentType[i] = ValueMetaFactory.getIdForValueMeta( XMLHandler.getTagValue( anode, "type" ) );
       }
 
       resultName = XMLHandler.getTagValue( stepnode, "result", "name" ); // Optional, can be null
                                                                          //
-      resultType = ValueMeta.getType( XMLHandler.getTagValue( stepnode, "result", "type" ) );
+      resultType = ValueMetaFactory.getIdForValueMeta( XMLHandler.getTagValue( stepnode, "result", "type" ) );
       autoCommit = !"N".equalsIgnoreCase( XMLHandler.getTagValue( stepnode, "auto_commit" ) );
     } catch ( Exception e ) {
       throw new KettleXMLException( BaseMessages.getString( PKG, "DBProcMeta.Exception.UnableToReadStepInfo" ), e );
@@ -344,11 +357,11 @@ public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, Lis
       for ( int i = 0; i < nrargs; i++ ) {
         argument[i] = rep.getStepAttributeString( id_step, i, "arg_name" );
         argumentDirection[i] = rep.getStepAttributeString( id_step, i, "arg_direction" );
-        argumentType[i] = ValueMeta.getType( rep.getStepAttributeString( id_step, i, "arg_type" ) );
+        argumentType[i] = ValueMetaFactory.getIdForValueMeta( rep.getStepAttributeString( id_step, i, "arg_type" ) );
       }
 
       resultName = rep.getStepAttributeString( id_step, "result_name" );
-      resultType = ValueMeta.getType( rep.getStepAttributeString( id_step, "result_type" ) );
+      resultType = ValueMetaFactory.getIdForValueMeta( rep.getStepAttributeString( id_step, "result_type" ) );
       autoCommit = rep.getStepAttributeBoolean( id_step, 0, "auto_commit", true );
     } catch ( Exception e ) {
       throw new KettleException( BaseMessages.getString(
@@ -364,12 +377,13 @@ public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transform
       for ( int i = 0; i < argument.length; i++ ) {
         rep.saveStepAttribute( id_transformation, id_step, i, "arg_name", argument[i] );
         rep.saveStepAttribute( id_transformation, id_step, i, "arg_direction", argumentDirection[i] );
-        rep
-          .saveStepAttribute( id_transformation, id_step, i, "arg_type", ValueMeta.getTypeDesc( argumentType[i] ) );
+        rep.saveStepAttribute( id_transformation, id_step, i, "arg_type",
+          ValueMetaFactory.getValueMetaName( argumentType[i] ) );
       }
 
       rep.saveStepAttribute( id_transformation, id_step, "result_name", resultName );
-      rep.saveStepAttribute( id_transformation, id_step, "result_type", ValueMeta.getTypeDesc( resultType ) );
+      rep.saveStepAttribute( id_transformation, id_step, "result_type",
+        ValueMetaFactory.getValueMetaName( resultType ) );
       rep.saveStepAttribute( id_transformation, id_step, "auto_commit", autoCommit );
 
       // Also, save the step-database relationship!
@@ -412,14 +426,14 @@ public void check( List<CheckResultInterface> remarks, TransMeta transMeta, Step
             } else {
               // Argument exists in input stream: same type?
 
-              if ( v.getType() != argumentType[i] && !( v.isNumeric() && ValueMeta.isNumeric( argumentType[i] ) ) ) {
+              if ( v.getType() != argumentType[i] && !( v.isNumeric() && ValueMetaBase.isNumeric( argumentType[i] ) ) ) {
                 error_found = true;
                 error_message +=
                   "\t\t"
                     + argument[i]
                     + BaseMessages.getString(
-                      PKG, "DBProcMeta.CheckResult.WrongTypeArguments", v.getTypeDesc(), ValueMeta
-                        .getTypeDesc( argumentType[i] ) ) + Const.CR;
+                      PKG, "DBProcMeta.CheckResult.WrongTypeArguments", v.getTypeDesc(),
+                      ValueMetaFactory.getValueMetaName( argumentType[i] ) ) + Const.CR;
               }
             }
           }

engine/src/org/pentaho/di/trans/steps/excelinput/ExcelInputMeta.java

@@ -33,6 +33,7 @@
 import org.pentaho.di.core.util.Utils;
 import org.pentaho.di.core.database.DatabaseMeta;
 import org.pentaho.di.core.exception.KettleException;
+import org.pentaho.di.core.exception.KettlePluginException;
 import org.pentaho.di.core.exception.KettleStepException;
 import org.pentaho.di.core.exception.KettleXMLException;
 import org.pentaho.di.core.fileinput.FileInputList;
@@ -41,12 +42,12 @@
 import org.pentaho.di.core.injection.InjectionSupported;
 import org.pentaho.di.core.row.RowMeta;
 import org.pentaho.di.core.row.RowMetaInterface;
-import org.pentaho.di.core.row.ValueMeta;
 import org.pentaho.di.core.row.ValueMetaInterface;
 import org.pentaho.di.core.row.value.ValueMetaBoolean;
 import org.pentaho.di.core.row.value.ValueMetaDate;
 import org.pentaho.di.core.row.value.ValueMetaFactory;
 import org.pentaho.di.core.row.value.ValueMetaInteger;
+import org.pentaho.di.core.row.value.ValueMetaNone;
 import org.pentaho.di.core.row.value.ValueMetaString;
 import org.pentaho.di.core.variables.VariableSpace;
 import org.pentaho.di.core.vfs.KettleVFS;
@@ -1344,7 +1345,12 @@ public void check( List<CheckResultInterface> remarks, TransMeta transMeta, Step
   public RowMetaInterface getEmptyFields() {
     RowMetaInterface row = new RowMeta();
     for ( int i = 0; i < field.length; i++ ) {
-      ValueMetaInterface v = new ValueMeta( field[i].getName(), field[i].getType() );
+      ValueMetaInterface v;
+      try {
+        v = ValueMetaFactory.createValueMeta( field[i].getName(), field[i].getType() );
+      } catch ( KettlePluginException e ) {
+        v = new ValueMetaNone( field[i].getName() );
+      }
       row.addValueMeta( v );
     }