pentaho/pentaho-kettle · error · KettleException

The specified object location specification method

Error message

The specified object location specification method '<specificationMethod>' is not yet supported in this <friendlyMetaType> entry.

What it means

getMetaForEntry dispatches on the entry's specificationMethod (FILENAME, REPOSITORY_BY_NAME, REPOSITORY_BY_REFERENCE). If the stored value is none of these — typically a corrupted, future-version, or invalid enum value — the switch's default branch throws a KettleException saying that object-location specification method is not yet supported in this entry. It is a defensive guard against an unknown enum state rather than a normal user error.

Solutions

Open the kjb in Spoon, re-set the transformation/job reference on the entry dialog (this resets specificationMethod to a supported value), and re-save.
Inspect the kjb XML and correct the specification-method attribute to 'FILENAME', 'REPOSITORY_BY_NAME', or 'REPOSITORY_BY_REFERENCE'.
Align PDI runtime and design-tool versions (regenerate the file with the same version that reads it).
If building entries in code, only assign values from the supported SPECIFICATION_METHOD enum; never raw integers/strings.

Example fix

// before (hand-edited kjb / legacy value)
<reference_type>99</reference_type>

// after
<reference_type>3</reference_type> <!-- REPOSITORY_BY_REFERENCE -->
// or in code:
jet.setSpecificationMethod( JobEntryInterface.SPECIFICATION_METHOD.REPOSITORY_BY_NAME );

Defensive patterns

Strategy: validation

Validate before calling

// reject unsupported specification methods before execution
Object method = jobEntry.getSpecificationMethod();
if ( method != SPECIFICATION_METHOD.FILENAME
  && method != SPECIFICATION_METHOD.REPOSITORY_BY_NAME
  && method != SPECIFICATION_METHOD.REPOSITORY_BY_REFERENCE ) {
  throw new IllegalStateException( "Unsupported specification method: " + method );
}

Type guard

boolean isSupportedSpecificationMethod( Object method ) {
  return method == SPECIFICATION_METHOD.FILENAME
    || method == SPECIFICATION_METHOD.REPOSITORY_BY_NAME
    || method == SPECIFICATION_METHOD.REPOSITORY_BY_REFERENCE;
}

Try / catch

try {
  meta = loader.getMetaForEntry( bowl, rep, metaStore, space );
} catch ( KettleException ke ) {
  if ( String.valueOf( ke.getMessage() ).contains( "not yet supported" ) ) {
    throw new JobExecutionException( "Unsupported reference type in kjb — reopen in the matching PDI version and re-save", ke );
  }
  throw ke;
}

Prevention

Keep the PDI runtime version >= the version that authored the job files.
Never hand-edit specification-method values in kjb XML.
Only assign specificationMethod from the supported enum constants in plugins/code.
Validate imported job files by loading all entries and checking their specification methods.

When it happens

Trigger: JobEntryTrans/JobEntryJob instance whose specificationMethod field holds a value outside the supported enum (e.g. deserialized from a kjb written by a newer Pentaho version, a manually edited XML value, or an uninitialized/legacy constant).

Common situations: Opening jobs exported from a newer Pentaho/PDI release into older code; hand-editing the 'reference_type'/'specification_method' attribute in a kjb; third-party tools generating job XML with unsupported values; plugins that set custom specification methods.

Related errors

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

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/base/MetaFileLoaderImpl.java:269

          if ( rep != null ) {
            theMeta = attemptCacheRead( metaObjectId.toString() ); //try to get from the cache first
            if ( theMeta == null ) {
              // Load the last revision
              if ( isTransMeta() ) {
                theMeta = (T) rep.loadTransformation( metaObjectId, null );
              } else {
                theMeta = (T) rep.loadJob( metaObjectId, null );
              }
              idContainer[ 0 ] = metaObjectId.toString();
            }
          } else {
            throw new KettleException(
              "Could not execute " + friendlyMetaType + " specified in a repository since we're not connected to one" );
          }
          break;
        default:
          throw new KettleException( "The specified object location specification method '"
            + specificationMethod + "' is not yet supported in this " + friendlyMetaType + " entry." );
      }

      cacheMeta( idContainer[ 0 ], theMeta );
      // Re-seed the internal directory variables on the returned meta from the freshly resolved tmpSpace.
      // The cache may return an instance whose internal vars were last set in a different context
      // (e.g. from a step loader using getVarSpaceOnlyWithRequiredParentVars, or with rep==null),
      // which would otherwise leak the wrong Internal.Entry.Current.Directory into the child execution.
      reseedInternalDirectoryVars( theMeta, tmpSpace );
      return theMeta;
    } catch ( final KettleException ke ) {
      // if we get a KettleException, simply re-throw it
      throw ke;
    } catch ( Exception e ) {
      throw new KettleException( BaseMessages.getString( persistentClass, "JobTrans.Exception.MetaDataLoad" ), e );
    }
  }

View on GitHub (pinned to f3058517a1)