pentaho/pentaho-kettle · error · KettleException

Step ' ' of type ' ' is not yet supported in a Single…

Error message

Step '${stepname}' of type '${stepID}' is not yet supported in a Single Threaded transformation engine.

What it means

The Single Threaded execution engine can only run steps explicitly marked as supporting TransformationType.SingleThreaded. During init(), every step meta's supported transformation types are scanned; if a step does not declare SingleThreaded support, this KettleException is thrown before execution starts.

Solutions

Replace the unsupported step with an equivalent step that supports the SingleThreaded transformation type
Switch the transformation's execution engine back to the standard (threaded) engine
Implement SingleThreaded support in the custom step plugin and add TransformationType.SingleThreaded to its supported types

Example fix

// before
transMeta.setTransformationType(TransformationType.SingleThreaded); // step X unsupported
// after
transMeta.setTransformationType(TransformationType.Normal); // or use a single-threaded-capable step

Defensive patterns

Strategy: validation

Validate before calling

for (StepMeta sm : transMeta.getSteps()) {
  if (!Arrays.asList(sm.getStepMetaInterface().getSupportedTransformationTypes()).contains(TransformationType.SingleThreaded)) {
    throw new IllegalStateException("Step " + sm.getName() + " unsupported in single-threaded mode");
  }
}

Try / catch

try { executor.init(); } catch (KettleException e) { log.error("Single-threaded init failed: " + e.getMessage()); }

Prevention

Audit all steps for SingleThreaded support before switching engine type
Keep single-threaded transformations minimal with known-supported steps
Test with SingleThreadedTransExecutor in CI

When it happens

Trigger: Calling SingleThreadedTransExecutor.init() on a transformation containing any step (per its stepmeta.getSupportedTransformationTypes()) that does not include SingleThreaded in its supported types list.

Common situations: Using the single-threaded engine (e.g. via transformation type setting or testSingleThreadedTrans) with plugins or standard steps that only support Normal mode; converting an existing transformation to SingleThreaded without auditing each step's support.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

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

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/trans/SingleThreadedTransExecutor.java:275

      log.logDetailed( tLogString.toString() );
    }
  }

  public boolean init() throws KettleException {

    // See if the steps support the SingleThreaded transformation type...
    //
    log.logBasic( "Single Threaded Executor initializing Trans: [" + trans.getName( ) + "]" );
    for ( StepMetaDataCombi combi : steps ) {
      TransformationType[] types = combi.stepMeta.getStepMetaInterface().getSupportedTransformationTypes();
      boolean ok = false;
      for ( TransformationType type : types ) {
        if ( type == TransformationType.SingleThreaded ) {
          ok = true;
        }
      }
      if ( !ok ) {
        throw new KettleException( "Step '"
          + combi.stepname + "' of type '" + combi.stepMeta.getStepID()
          + "' is not yet supported in a Single Threaded transformation engine." );
      }
    }
    // Initialize all the steps...
    //
    for ( StepMetaDataCombi combi : steps ) {
      boolean ok = combi.step.init( combi.meta, combi.data );
      if ( !ok ) {
        return false;
      }
    }
    return true;

  }

  /**
   * Give all steps in the transformation the chance to process all rows on input...

View on GitHub (pinned to f3058517a1)