pentaho/pentaho-kettle · error · KettleDatabaseException

database type with plugin id [] couldn't be found!

Error message

database type with plugin id [] couldn't be found!

What it means

DatabaseInterfaceFactory.createDatabaseMeta(...) resolves a database plugin by id or name from the PluginRegistry and throws KettleDatabaseException when neither lookup matches a registered DatabasePluginType plugin. It means the requested database type has no plugin loaded in this Kettle instance.

Solutions

1. Confirm the exact plugin id in plugins/<database-type>/plugin.xml and use that string.
2. Install the missing database plugin jar under the plugins directory (or add it to the classpath) and restart.
3. List available plugins via PluginRegistry (PluginRegistry.getInstance().getPlugins(DatabasePluginType.class)) to see valid ids.
4. Check plugin.xml registration — ids and names must match what your code passes.

Example fix

// before
DatabaseMeta meta = DatabaseInterfaceFactory.createDatabaseMeta(logChannel, "Orcadb");
// after
List<PluginInterface> plugins = PluginRegistry.getInstance().getPlugins(DatabasePluginType.class);
PluginInterface p = plugins.stream().filter(x -> "Oracle".equals(x.getName())).findFirst()
  .orElseThrow(() -> new IllegalStateException("Install/load the Oracle database plugin"));
DatabaseMeta meta = DatabaseInterfaceFactory.createDatabaseMeta(logChannel, p.getIds()[0]);

List<PluginInterface> dbPlugins = PluginRegistry.getInstance().getPlugins(DatabasePluginType.class);
boolean known = dbPlugins.stream().anyMatch(p -> type.equals(p.getIds()[0]) || type.equals(p.getName()));
if (!known) throw new IllegalArgumentException("Unknown database type/plugin: " + type);

boolean isRegisteredDatabaseType(String type) {
  PluginInterface p = PluginRegistry.getInstance().getPlugin(DatabasePluginType.class, type);
  return p != null || PluginRegistry.getInstance().findPluginWithName(DatabasePluginType.class, type) != null;
}

try {
  return DatabaseInterfaceFactory.createDatabaseMeta(logChannel, type, null);
} catch (KettleDatabaseException e) {
  log.error("DB plugin not registered: " + type + "; available=" + pluginIds(), e);
  throw new ConfigurationException("Install database plugin for type " + type, e);
}

When it happens

Trigger: Calling DatabaseInterfaceFactory.createDatabaseMeta(logChannel, "someType", ...) with a plugin id/name that is absent from the registry — misspelled type, plugin jar not on the classpath, or plugin not yet registered at call time.

Common situations: Third-party database plugin (e.g. a vendor JDBC plugin) not installed on the server; type string changed between Pentaho/Kettle versions (renamed plugin ids); running in a minimal/embedded setup where the standard database plugin directory isn't scanned.

Understand the failure class

Background: "not installed", "pip install", "required for": how missing-dependency errors surface across open-source libraries — this error's family across 34 libraries.

Related errors

• database type with plugin id [] couldn't be found!
• Database connection not found:
• Database type [] not found!
• Database.UnableToCheckIfConnectionPoolExists.Exception
• DatabaseMeta.Error.DatabaseInterfaceNotFound

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

Appendix: source

Thrown at core/src/main/java/org/pentaho/di/core/database/DatabaseInterfaceFactory.java:65

   * @param databaseTypeDesc the database type to instantiate (a plugin id or description), or blank for a Connection
   *                        Management
   *                         Service connection
   * @return the {@link DatabaseInterface} matching the requested type
   * @throws KettleDatabaseException when the type could not be found or referenced
   */
  public static DatabaseInterface create( String databaseTypeDesc ) throws KettleDatabaseException {
    if ( isConnectionManagementServiceType( databaseTypeDesc ) ) {
      return new ConnectionManagementServiceMeta();
    }

    PluginRegistry registry = PluginRegistry.getInstance();
    PluginInterface plugin = registry.getPlugin( DatabasePluginType.class, databaseTypeDesc );
    if ( plugin == null ) {
      plugin = registry.findPluginWithName( DatabasePluginType.class, databaseTypeDesc );
    }

    if ( plugin == null ) {
      throw new KettleDatabaseException( "database type with plugin id ["
        + databaseTypeDesc + "] couldn't be found!" );
    }

    return DatabaseMeta.getDatabaseInterfacesMap().get( plugin.getIds()[ 0 ] );
  }

  /**
   * Tells whether the given database type denotes a Connection Management Service connection. This is the single point
   * of truth for that decision so callers do not need to perform their own {@code instanceof} or string checks.
   *
   * @param databaseTypeDesc the database type to inspect
   * @return {@code true} when the type identifies a Connection Management Service connection
   */
  public static boolean isConnectionManagementServiceType( String databaseTypeDesc ) {
    return StringUtils.isBlank( databaseTypeDesc );
  }
}

View on GitHub (pinned to f3058517a1)