pentaho/pentaho-kettle · error · KettleException

Compression provider

Error message

Compression provider {compressionType} does not support output streams!

What it means

After locating a compression provider by name, TextFileOutput checks supportsOutput(). Some providers (e.g. decompression-only ones like certain input-oriented providers) cannot produce output streams; using one for a text file output target throws this KettleException. The provider exists but is not suitable for writing.

Solutions

  1. Choose a compression provider that supports output (e.g. 'None', 'Zip', 'GZip') in the Text File Output step
  2. Swap the provider for one whose supportsOutput() returns true (check with the plugin vendor)
  3. If writing is genuinely unsupported, write uncompressed and compress in a post-processing job step

Example fix

// before
meta.setFileCompression( "SomeReadonlyProvider" ); // supportsOutput() == false
// after
meta.setFileCompression( "GZip" ); // supports writing output streams
Defensive patterns

Strategy: validation

Validate before calling

CompressionProvider p = CompressionProviderFactory.getInstance()
  .getCompressionProviderByName( Const.NVL( meta.getFileCompression(), "None" ) );
if ( p != null && !p.supportsOutput() ) {
  throw new IllegalArgumentException( "Provider " + p.getName() + " cannot write output streams" );
}

Try / catch

try {
  getCompressionProvider();
} catch ( KettleException e ) {
  if ( e.getMessage().contains( "does not support output streams" ) ) {
    logError( "Falling back to uncompressed output", e );
    meta.setFileCompression( "None" );
  }
}

Prevention

When it happens

Trigger: getCompressionProvider -> compressionProvider where the resolved CompressionProvider returns false from supportsOutput(): i.e. the step is configured to write a compressed file using a provider that only supports reading/input streams.

Common situations: Selecting a decompression-only provider in the Text File Output dialog; copying a compression setting from a Text File Input step into an Output step; custom/3rd-party compression plugin implementing only input streams.

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/d73eff4a7842385d. Report an issue: GitHub.

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/trans/steps/textfileoutput/TextFileOutput.java:106

  public boolean isFileExists( String filename ) throws KettleException {
    try {
      return getFileObject( filename, getTransMeta() ).exists();
    } catch ( Exception e ) {
      throw new KettleException( "Error opening new file : " + e.toString() );
    }
  }

  private CompressionProvider getCompressionProvider() throws KettleException {
    String compressionType = Const.NVL( meta.getFileCompression(), FILE_COMPRESSION_TYPE_NONE );

    CompressionProvider compressionProvider = CompressionProviderFactory.getInstance().getCompressionProviderByName( compressionType );

    if ( compressionProvider == null ) {
      throw new KettleException( "No compression provider found with name = " + compressionType );
    }

    if ( !compressionProvider.supportsOutput() ) {
      throw new KettleException( "Compression provider " + compressionType + " does not support output streams!" );
    }
    return compressionProvider;
  }

  private void initServletStreamWriter(  ) throws KettleException {
    data.writer = null;
    try {
      Writer writer = getTrans().getServletPrintWriter();
      if ( Utils.isEmpty( meta.getEncoding( ) ) ) {
        data.writer = new WriterOutputStream( writer );
      } else {
        data.writer = new WriterOutputStream( writer, meta.getEncoding( ) );
      }
    } catch ( Exception e ) {
      throw new KettleException( "Error opening new file : " + e.toString() );
    }
  }

View on GitHub (pinned to f3058517a1)