pentaho/pentaho-kettle · error · KettleValueException

: Unknown storage type specified.

Error message

 : Unknown storage type  specified.

What it means

getInternetAddress() converts a stored value object into a java.net.InetAddress based on the value meta's type and storage type. When the storageType field holds a value that is not STORAGE_TYPE_NORMAL, STORAGE_TYPE_BINARY_STRING, or STORAGE_TYPE_INDEXED, the inner switch falls through to default and throws this KettleValueException. It indicates the value metadata has been corrupted or built with an out-of-range storage type code.

Solutions

  1. Inspect the ValueMeta's storageType value (getStorageType()) before the call; fix whatever set it to an invalid code
  2. Reset storage to STORAGE_TYPE_NORMAL (valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL)) if indexed/binary-string storage is not actually needed
  3. Rebuild the row metadata via ValueMetaFactory instead of deserializing legacy metadata
  4. Upgrade/align Pentaho Kettle (PDI) versions on all nodes so storage type constants match

Example fix

// before
InetAddress addr = valueMetaInternetAddress.getInternetAddress(object); // storageType garbage
// after
if (valueMetaInternetAddress.getStorageType() < ValueMetaInterface.STORAGE_TYPE_NORMAL
    || valueMetaInternetAddress.getStorageType() > ValueMetaInterface.STORAGE_TYPE_INDEXED) {
  valueMetaInternetAddress.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
}
InetAddress addr = valueMetaInternetAddress.getInternetAddress(object);
Defensive patterns

Strategy: type-guard

Validate before calling

// Java
public static boolean hasValidStorageType(ValueMetaInterface meta) {
  int st = meta.getStorageType();
  return st == ValueMetaInterface.STORAGE_TYPE_NORMAL
      || st == ValueMetaInterface.STORAGE_TYPE_BINARY_STRING
      || st == ValueMetaInterface.STORAGE_TYPE_INDEXED;
}

Type guard

if (!hasValidStorageType(meta)) { meta.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL); }

Try / catch

try {
  InetAddress addr = meta.getInternetAddress(object);
} catch (KettleValueException e) {
  if (e.getMessage().contains("Unknown storage type")) {
    meta.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
    // retry conversion
  } else { throw e; }
}

Prevention

When it happens

Trigger: Calling getInternetAddress(object) (directly or via getString/inetAddress/getNativeDataType on this ValueMetaInternetAddress) while storageType is set to an integer other than 0/1/2, e.g. after deserializing row metadata from a stream/file with a newer or corrupted storage type code.

Common situations: Row metadata deserialized from an old Kettle repository or exported XML where storage type codes changed; a plugin or custom code calling setStorageType() with an unvalidated constant; byte-level corruption when cloning row metadata between nodes in a cluster.

Related errors

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

Appendix: source

Thrown at core/src/main/java/org/pentaho/di/core/row/value/ValueMetaInternetAddress.java:86

    super( name, ValueMetaInterface.TYPE_INET );
  }

  public InetAddress getInternetAddress( Object object ) throws KettleValueException {
    if ( object == null ) {
      return null;
    }

    switch ( type ) {
      case TYPE_INET:
        switch ( storageType ) {
          case STORAGE_TYPE_NORMAL:
            return (InetAddress) object;
          case STORAGE_TYPE_BINARY_STRING:
            return (InetAddress) convertBinaryStringToNativeType( (byte[]) object );
          case STORAGE_TYPE_INDEXED:
            return (InetAddress) index[( (Integer) object )];
          default:
            throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." );
        }
      case TYPE_STRING:
        switch ( storageType ) {
          case STORAGE_TYPE_NORMAL:
            return convertStringToInternetAddress( (String) object );
          case STORAGE_TYPE_BINARY_STRING:
            return convertStringToInternetAddress( (String) convertBinaryStringToNativeType( (byte[]) object ) );
          case STORAGE_TYPE_INDEXED:
            return convertStringToInternetAddress( (String) index[( (Integer) object ).intValue()] );
          default:
            throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." );
        }
      case TYPE_NUMBER:
        switch ( storageType ) {
          case STORAGE_TYPE_NORMAL:
            return convertNumberToInternetAddress( (Double) object );
          case STORAGE_TYPE_BINARY_STRING:
            return convertNumberToInternetAddress( (Double) convertBinaryStringToNativeType( (byte[]) object ) );

View on GitHub (pinned to f3058517a1)