pentaho/pentaho-kettle · error · KettleStepException

Could not create ValueMetaInterface

Error message

Could not create ValueMetaInterface: {0}

What it means

TransExecutorMeta wraps a sub-transformation and can copy fields from the sub-transformation's execution results into the main stream. When building the output row metadata it calls ValueMetaFactory.createValueMeta for each configured result field; if the value metadata plugin for the requested type cannot be instantiated (KettlePluginException), it rethrows as KettleStepException with this message naming the offending field.

Solutions

  1. Check the full stack trace's cause (KettlePluginException) to identify the value type/plugin that failed to load
  2. Upgrade or reinstall Pentaho Kettle/engine so the ValueMeta plugin for the field type is present
  3. Re-open the TransExecutor step in Spoon, re-select each result field and its type, and re-save the transformation
  4. If a custom ValueMeta plugin is involved, verify it is on the classpath and registered

Example fix

// before (broken plugin resolution)
ValueMetaInterface value = ValueMetaFactory.createValueMeta( fieldName, type, length, precision );
// after: guard with a known-good type before building metadata
int safeType = ValueMetaFactory.getIdForValueMeta( "String" );
ValueMetaInterface value = ValueMetaFactory.createValueMeta( fieldName, type > 0 ? type : safeType, length, precision );
Defensive patterns

Strategy: try-catch

Validate before calling

// Java: verify the value type can be instantiated before running the trans
try {
  ValueMetaFactory.createValueMeta( fieldName, type, length, precision );
} catch ( KettlePluginException e ) {
  throw new IllegalStateException( "Unusable value type " + type + " for field " + fieldName, e );
}

Type guard

boolean isKnownValueType(int type) {
  try { ValueMetaFactory.createValueMeta( "check", type, -1, -1 ); return true; }
  catch ( KettlePluginException e ) { return false; }
}

Try / catch

try {
  transExecutorMeta.prepareExecutionResultsFields( rowMeta, nextStepMeta, subTransMeta );
} catch ( KettleStepException e ) {
  if ( e.getMessage().contains( "ValueMetaInterface" ) ) {
    // inspect cause KettlePluginException, fix field type config or install missing plugin
  }
  throw e;
}

Prevention

When it happens

Trigger: addFieldToRow is called during output-row metadata preparation (via prepareExecutionResultsFields, prepareResultsRowsFields, or recursively via addFieldToRow) with a non-empty fieldName whose type/length/precision combination cannot be resolved to a ValueMetaInterface plugin — e.g. an unknown or unregistered value type.

Common situations: Running a Pentaho/Kettle version where a value meta plugin was renamed or removed; a transformation saved by a newer version references a value type the current installation cannot instantiate; corrupt step configuration in the .ktr producing an invalid type id.

Understand the failure class

Background: "not installed", "pip install", "required for": how missing-dependency errors surface across open-source libraries — this error's family across 34 libraries.

Related errors

AI-assisted analysis of pentaho/pentaho-kettle@f3058517a1 (2026-09-13). Data as JSON: /api/errors/f5182e8cbd6f7cf7. Report an issue: GitHub.

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/trans/steps/transexecutor/TransExecutorMeta.java:548

      addFieldToRow( row, executionLogTextField, ValueMetaInterface.TYPE_STRING );
      addFieldToRow( row, executionLogChannelIdField, ValueMetaInterface.TYPE_STRING, 50, 0 );

    }
  }

  protected void addFieldToRow( RowMetaInterface row, String fieldName, int type ) throws KettleStepException {
    addFieldToRow( row, fieldName, type, -1, -1 );
  }

  protected void addFieldToRow( RowMetaInterface row, String fieldName, int type, int length, int precision )
    throws KettleStepException {
    if ( !Utils.isEmpty( fieldName ) ) {
      try {
        ValueMetaInterface value = ValueMetaFactory.createValueMeta( fieldName, type, length, precision );
        value.setOrigin( getParentStepMeta().getName() );
        row.addValueMeta( value );
      } catch ( KettlePluginException e ) {
        throw new KettleStepException( BaseMessages.getString( PKG, "TransExecutorMeta.ValueMetaInterfaceCreation",
          fieldName ), e );
      }
    }
  }

  void prepareExecutionResultsFileFields( RowMetaInterface row, StepMeta nextStep ) throws KettleStepException {
    if ( nextStep != null && resultFilesTargetStepMeta != null && nextStep.equals( resultFilesTargetStepMeta ) ) {
      addFieldToRow( row, resultFilesFileNameField, ValueMetaInterface.TYPE_STRING );
    }
  }

  void prepareResultsRowsFields( RowMetaInterface row ) throws KettleStepException {
    for ( int i = 0; i < outputRowsField.length; i++ ) {
      addFieldToRow( row, outputRowsField[ i ], outputRowsType[ i ], outputRowsLength[ i ], outputRowsPrecision[ i ] );
    }
  }

  @Override

View on GitHub (pinned to f3058517a1)