What causes "StreamLookup.Exception.ConversionNotImplemented" in pentaho/pentaho-kettle?

Remove the default value (leave it empty) so the step sets null instead of throwing, if a null is acceptable.

pentaho/pentaho-kettle · error · RuntimeException

StreamLookup.Exception.ConversionNotImplemented

Error message

StreamLookup.Exception.ConversionNotImplemented

What it means

In StreamLookup's handleNullIf, when a lookup value's conversion is not implemented and a non-empty default value was configured, a RuntimeException is thrown with the localized 'ConversionNotImplemented' message plus the offending value type name. It protects against silently using a default whose value type the lookup cannot convert.

Solutions

Remove the default value (leave it empty) so the step sets null instead of throwing, if a null is acceptable.
Change the value default type to a supported type (String, Integer, Number, Date, Boolean, BigNumber) that matches the lookup field.
Align the lookup field type in the source stream with the configured default type so no exotic conversion is needed.
Inspect meta.getValueDefaultType() entries in the transformation XML and fix any Binary/Serializable types.
Handle the conversion yourself in an earlier step (e.g. use a 'If field value is null' or Calculator step) instead of StreamLookup defaults.

Example fix

// before (transformation XML: unsupported default type with a default value)
<value_default>S</value_default>
<value_default_type>8</value_default_type>
// after (use a supported type or clear the default)
<value_default></value_default>
<value_default_type>2</value_default_type>

Defensive patterns

Strategy: validation

Validate before calling

// Validate default value types before running StreamLookup
for ( int i = 0; i < meta.getValueDefaultType().length; i++ ) {
  String def = meta.getValueDefault()[i];
  int type = meta.getValueDefaultType()[i];
  if ( def != null && def.trim().length() > 0
       && ( type == ValueMetaInterface.TYPE_BINARY || type == ValueMetaInterface.TYPE_SERIALIZABLE ) ) {
    throw new IllegalStateException( "Unsupported default value type for lookup index " + i );
  }
}

Type guard

boolean hasSupportedDefaultType( StreamLookupMeta meta, int i ) {
  String def = meta.getValueDefault()[i];
  int t = meta.getValueDefaultType()[i];
  return def == null || def.trim().isEmpty()
      || ( t != ValueMetaInterface.TYPE_BINARY && t != ValueMetaInterface.TYPE_SERIALIZABLE );
}

Try / catch

try {
  trans.execute( null );
} catch ( RuntimeException e ) {
  if ( e.getMessage() != null && e.getMessage().contains( "Conversion not implemented" ) ) {
    log.error( "StreamLookup default value type unsupported; fix step config", e );
  } else { throw e; }
}

Prevention

Leave the default value empty when the default type cannot represent a string.
Use only String/Integer/Number/Date/Boolean/BigNumber as default value types.
Null the lookup field explicitly upstream instead of relying on StreamLookup defaults for exotic types.
After Pentaho upgrades, review StreamLookup configs whose field types changed.

When it happens

Trigger: Configuring a StreamLookup with a value default type (meta.getValueDefaultType()[i]) that has no conversion implementation (e.g. Binary or an unsupported type) while also specifying a non-empty default value string; the step then hits the default branch during processRow.

Common situations: Selecting an exotic default value type in the StreamLookup dialog; upgrading Kettle so a formerly tolerated type is now rejected; passing default values for lookup fields where the stream type cannot be converted (e.g. defaulting a Binary or Serializable field); copy-pasting metadata between steps with different field types.

Related errors

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

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/trans/steps/streamlookup/StreamLookup.java:118

        case ValueMetaInterface.TYPE_BOOLEAN:
          if ( "TRUE".equalsIgnoreCase( meta.getValueDefault()[i] )
            || "Y".equalsIgnoreCase( meta.getValueDefault()[i] ) ) {
            data.nullIf[i] = Boolean.TRUE;
          } else {
            data.nullIf[i] = Boolean.FALSE;
          }
          break;
        case ValueMetaInterface.TYPE_BIGNUMBER:
          try {
            data.nullIf[i] = new BigDecimal( meta.getValueDefault()[i] );
          } catch ( Exception e ) {
            // Ignore errors
          }
          break;
        default:
          // if a default value is given and no conversion is implemented throw an error
          if ( meta.getValueDefault()[i] != null && meta.getValueDefault()[i].trim().length() > 0 ) {
            throw new RuntimeException( BaseMessages.getString(
              PKG, "StreamLookup.Exception.ConversionNotImplemented" )
              + " " + ValueMetaFactory.getValueMetaName( meta.getValueDefaultType()[i] ) );
          } else {
            // no default value given: just set it to null
            data.nullIf[i] = null;
            break;
          }
      }
    }
  }

  private boolean readLookupValues() throws KettleException {
    data.infoStream = meta.getStepIOMeta().getInfoStreams().get( 0 );
    if ( data.infoStream.getStepMeta() == null ) {
      logError( BaseMessages.getString( PKG, "StreamLookup.Log.NoLookupStepSpecified" ) );
      return false;
    }
    if ( log.isDetailed() ) {

View on GitHub (pinned to f3058517a1)