Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

23.5 KB
Raw Blame
use dbx_core::agent_catalog;
use dbx_core::database_capabilities::{
    agent_key, is_agent_type, is_metadata_connection_scoped, is_single_connection_pool, skips_tcp_probe,
};
use dbx_core::models::connection::DatabaseType;
use serde::Deserialize;
use std::collections::HashSet;

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct DriverManifest {
    drivers: Vec<DriverManifestEntry>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct DriverManifestEntry {
    db_type: DatabaseType,
    label: String,
    runtime_mode: String,
    support_level: String,
    capabilities: DriverProductCapabilities,
    #[serde(default)]
    agent_key: Option<String>,
    #[serde(default)]
    single_connection_pool: bool,
    #[serde(default)]
    metadata_connection_scoped: bool,
    #[serde(default)]
    skip_tcp_probe: bool,
    #[serde(default)]
    specialized_surface: bool,
    #[serde(default)]
    driver_profiles: Vec<DriverProfileEntry>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct DriverProductCapabilities {
    query_execution: bool,
    metadata_browse: bool,
    object_browser: bool,
    object_source: bool,
    schema_search: bool,
    diagram: bool,
    table_data_edit: bool,
    table_structure_edit: bool,
    table_import: bool,
    data_transfer: bool,
    sql_file_execution: bool,
    database_create: bool,
    field_lineage: bool,
    sql_explain: bool,
    user_admin: bool,
    driver_management: bool,
}

impl DriverProductCapabilities {
    fn any_enabled(&self) -> bool {
        [
            self.metadata_browse,
            self.query_execution,
            self.object_browser,
            self.object_source,
            self.schema_search,
            self.diagram,
            self.table_data_edit,
            self.table_structure_edit,
            self.table_import,
            self.data_transfer,
            self.sql_file_execution,
            self.database_create,
            self.field_lineage,
            self.sql_explain,
            self.user_admin,
            self.driver_management,
        ]
        .into_iter()
        .any(|enabled| enabled)
    }
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct DriverProfileEntry {
    profile: String,
    agent_key: String,
}

fn driver_manifest() -> DriverManifest {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("assets").join("database-drivers.manifest.json");
    let json = std::fs::read_to_string(&path).unwrap_or_else(|err| {
        panic!("failed to read driver manifest {}: {err}", path.display());
    });
    serde_json::from_str(&json).expect("driver manifest should be valid JSON")
}

#[test]
fn maps_agent_database_types_to_driver_keys() {
    assert_eq!(agent_key(&DatabaseType::Trino, None), Some("trino"));
    assert_eq!(agent_key(&DatabaseType::Hive, None), Some("hive"));
    assert_eq!(agent_key(&DatabaseType::Kyuubi, None), Some("hive"));
    assert_eq!(agent_key(&DatabaseType::Impala, None), Some("hive"));
    assert_eq!(agent_key(&DatabaseType::Argo, None), Some("argo"));
    assert_eq!(agent_key(&DatabaseType::Tdengine, None), Some("tdengine"));
    assert_eq!(agent_key(&DatabaseType::Iotdb, None), Some("iotdb"));
    assert_eq!(agent_key(&DatabaseType::Yashandb, None), Some("yashandb"));
    assert_eq!(agent_key(&DatabaseType::Databricks, None), Some("databricks"));
    assert_eq!(agent_key(&DatabaseType::SapHana, None), Some("saphana"));
    assert_eq!(agent_key(&DatabaseType::Teradata, None), Some("teradata"));
    assert_eq!(agent_key(&DatabaseType::Vertica, None), Some("vertica"));
    assert_eq!(agent_key(&DatabaseType::Firebird, None), Some("firebird"));
    assert_eq!(agent_key(&DatabaseType::Exasol, None), Some("exasol"));
    assert_eq!(agent_key(&DatabaseType::OceanbaseOracle, None), Some("oceanbase-oracle"));
    assert_eq!(agent_key(&DatabaseType::Gbase, None), Some("gbase8a"));
    assert_eq!(agent_key(&DatabaseType::Gbase8s, None), Some("gbase8s"));
    assert_eq!(agent_key(&DatabaseType::Access, None), Some("access"));
    assert_eq!(agent_key(&DatabaseType::Oracle, None), Some("oracle"));
    assert_eq!(agent_key(&DatabaseType::Databend, None), Some("databend"));
    assert_eq!(agent_key(&DatabaseType::InfluxDb, None), Some("influxdb"));
    assert_eq!(agent_key(&DatabaseType::Uxdb, None), Some("uxdb"));
    assert_eq!(agent_key(&DatabaseType::Gbase8c, None), Some("gbase8c"));
    assert_eq!(agent_key(&DatabaseType::ZooKeeper, None), Some("zookeeper"));
    assert_eq!(agent_key(&DatabaseType::Spanner, None), Some("spanner"));
    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle"));
    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle"));
    assert_eq!(agent_key(&DatabaseType::SqlServer, Some("sqlserver-legacy")), Some("sqlserver-legacy"));
    assert_eq!(agent_key(&DatabaseType::SqlServer, None), None);
    assert_eq!(agent_key(&DatabaseType::Postgres, None), None);
}

#[test]
fn driver_store_entries_do_not_repeat_agent_keys() {
    let entries: Vec<_> = agent_catalog::driver_store_entries().collect();
    let mut seen = HashSet::new();
    let duplicate_keys: Vec<_> = entries.iter().map(|(key, _)| *key).filter(|key| !seen.insert(*key)).collect();

    assert!(duplicate_keys.is_empty(), "driver store agent keys should be unique: {duplicate_keys:?}");
    assert_eq!(entries.iter().filter(|(key, _)| *key == "gbase8a").count(), 1);
    assert_eq!(entries.iter().filter(|(key, _)| *key == "gbase8s").count(), 1);
    assert_eq!(entries.iter().filter(|(key, _)| *key == "sqlserver-legacy").count(), 1);
    assert_eq!(agent_catalog::label_for_key("sqlserver-legacy"), Some("SQL Server legacy compatibility component"));
}

#[test]
fn classifies_agent_database_types() {
    assert!(is_agent_type(&DatabaseType::Oracle));
    assert!(is_agent_type(&DatabaseType::Trino));
    assert!(is_agent_type(&DatabaseType::Hive));
    assert!(is_agent_type(&DatabaseType::Kyuubi));
    assert!(is_agent_type(&DatabaseType::Impala));
    assert!(is_agent_type(&DatabaseType::Argo));
    assert!(is_agent_type(&DatabaseType::Tdengine));
    assert!(is_agent_type(&DatabaseType::Iotdb));
    assert!(is_agent_type(&DatabaseType::Yashandb));
    assert!(is_agent_type(&DatabaseType::Databricks));
    assert!(is_agent_type(&DatabaseType::SapHana));
    assert!(is_agent_type(&DatabaseType::Teradata));
    assert!(is_agent_type(&DatabaseType::Vertica));
    assert!(is_agent_type(&DatabaseType::Firebird));
    assert!(is_agent_type(&DatabaseType::Exasol));
    assert!(is_agent_type(&DatabaseType::OceanbaseOracle));
    assert!(is_agent_type(&DatabaseType::Gbase));
    assert!(is_agent_type(&DatabaseType::Gbase8c));
    assert!(is_agent_type(&DatabaseType::Access));
    assert!(is_agent_type(&DatabaseType::Databend));
    assert!(is_agent_type(&DatabaseType::InfluxDb));
    assert!(is_agent_type(&DatabaseType::ZooKeeper));
    assert!(is_agent_type(&DatabaseType::Spanner));
    assert!(!is_agent_type(&DatabaseType::Mysql));
    assert!(!is_agent_type(&DatabaseType::Jdbc));
    assert!(!is_agent_type(&DatabaseType::Gaussdb));
    assert!(!is_agent_type(&DatabaseType::Kwdb));
    assert!(!is_agent_type(&DatabaseType::OpenGauss));
    assert!(!is_agent_type(&DatabaseType::Questdb));
}

#[test]
fn identifies_single_connection_pool_types() {
    assert!(is_single_connection_pool(&DatabaseType::Sqlite));
    assert!(is_single_connection_pool(&DatabaseType::DuckDb));
    assert!(is_single_connection_pool(&DatabaseType::MongoDb));
    assert!(is_single_connection_pool(&DatabaseType::Oracle));
    assert!(is_single_connection_pool(&DatabaseType::Dameng));
    assert!(is_single_connection_pool(&DatabaseType::Access));
    assert!(is_single_connection_pool(&DatabaseType::Yashandb));
    assert!(is_single_connection_pool(&DatabaseType::Firebird));
    assert!(is_single_connection_pool(&DatabaseType::OceanbaseOracle));
    assert!(is_single_connection_pool(&DatabaseType::Jdbc));
    assert!(is_single_connection_pool(&DatabaseType::VictoriaMetrics));
    assert!(!is_single_connection_pool(&DatabaseType::Trino));
    // Spanner is HikariCP-pooled in the agent; a single connection would be a regression.
    assert!(!is_single_connection_pool(&DatabaseType::Spanner));
    assert!(!is_single_connection_pool(&DatabaseType::Postgres));
    assert!(!is_single_connection_pool(&DatabaseType::Kwdb));
}

#[test]
fn identifies_metadata_connections_that_drop_database_scope() {
    assert!(is_metadata_connection_scoped(&DatabaseType::Mysql));
    assert!(is_metadata_connection_scoped(&DatabaseType::Doris));
    assert!(is_metadata_connection_scoped(&DatabaseType::StarRocks));
    assert!(is_metadata_connection_scoped(&DatabaseType::ManticoreSearch));
    assert!(!is_metadata_connection_scoped(&DatabaseType::Postgres));
    assert!(!is_metadata_connection_scoped(&DatabaseType::Kwdb));
    assert!(!is_metadata_connection_scoped(&DatabaseType::Oracle));
}

#[test]
fn skips_tcp_probe_for_local_file_plugin_and_agent_types() {
    assert!(skips_tcp_probe(&DatabaseType::Sqlite));
    assert!(skips_tcp_probe(&DatabaseType::DuckDb));
    assert!(skips_tcp_probe(&DatabaseType::Jdbc));
    assert!(skips_tcp_probe(&DatabaseType::Access));
    assert!(skips_tcp_probe(&DatabaseType::H2));
    assert!(skips_tcp_probe(&DatabaseType::Trino));
    assert!(skips_tcp_probe(&DatabaseType::Oracle));
    assert!(skips_tcp_probe(&DatabaseType::Tdengine));
    assert!(skips_tcp_probe(&DatabaseType::Iotdb));
    assert!(skips_tcp_probe(&DatabaseType::Yashandb));
    assert!(skips_tcp_probe(&DatabaseType::Databricks));
    assert!(skips_tcp_probe(&DatabaseType::OceanbaseOracle));
    assert!(skips_tcp_probe(&DatabaseType::Gbase));
    assert!(skips_tcp_probe(&DatabaseType::Databend));
    assert!(skips_tcp_probe(&DatabaseType::InfluxDb));
    assert!(skips_tcp_probe(&DatabaseType::VictoriaMetrics));
    assert!(skips_tcp_probe(&DatabaseType::MessageQueue));
    assert!(skips_tcp_probe(&DatabaseType::ZooKeeper));
    // Real Cloud Spanner connections have no host to probe.
    assert!(skips_tcp_probe(&DatabaseType::Spanner));
    assert!(!skips_tcp_probe(&DatabaseType::Postgres));
    assert!(!skips_tcp_probe(&DatabaseType::Mysql));
    assert!(!skips_tcp_probe(&DatabaseType::Gaussdb));
    assert!(!skips_tcp_probe(&DatabaseType::Kwdb));
    assert!(!skips_tcp_probe(&DatabaseType::OpenGauss));
    assert!(!skips_tcp_probe(&DatabaseType::Questdb));
}

#[test]
fn driver_manifest_matches_core_database_capabilities() {
    let manifest = driver_manifest();
    let support_levels = ["connect", "browse", "understand", "operate"];

    for driver in &manifest.drivers {
        assert!(
            support_levels.contains(&driver.support_level.as_str()),
            "invalid support level for {:?}",
            driver.db_type
        );
        assert!(
            driver.capabilities.any_enabled() || driver.specialized_surface,
            "database {:?} should declare a product capability or a specialized surface",
            driver.db_type
        );
        assert_eq!(
            is_agent_type(&driver.db_type),
            driver.runtime_mode == "agent",
            "agent classification mismatch for {:?}",
            driver.db_type
        );
        assert_eq!(
            agent_key(&driver.db_type, None),
            driver.agent_key.as_deref(),
            "agent key mismatch for {:?}",
            driver.db_type
        );
        assert_eq!(
            is_single_connection_pool(&driver.db_type),
            driver.single_connection_pool,
            "single-pool mismatch for {:?}",
            driver.db_type
        );
        assert_eq!(
            is_metadata_connection_scoped(&driver.db_type),
            driver.metadata_connection_scoped,
            "metadata scope mismatch for {:?}",
            driver.db_type
        );
        assert_eq!(
            skips_tcp_probe(&driver.db_type),
            driver.skip_tcp_probe,
            "TCP probe behavior mismatch for {:?}",
            driver.db_type
        );

        for profile in &driver.driver_profiles {
            assert_eq!(
                agent_key(&driver.db_type, Some(&profile.profile)),
                Some(profile.agent_key.as_str()),
                "profile agent key mismatch for {:?}/{}",
                driver.db_type,
                profile.profile
            );
        }
    }
}

#[test]
fn driver_manifest_declares_expected_product_capabilities() {
    let manifest = driver_manifest();
    let find_driver = |db_type: DatabaseType| {
        manifest
            .drivers
            .iter()
            .find(|driver| driver.db_type == db_type)
            .unwrap_or_else(|| panic!("{db_type:?} manifest entry"))
    };

    let mysql = find_driver(DatabaseType::Mysql);
    assert_eq!(mysql.support_level, "operate");
    assert!(mysql.capabilities.schema_search);
    assert!(mysql.capabilities.table_structure_edit);
    assert!(mysql.capabilities.sql_explain);
    assert!(!mysql.capabilities.driver_management);

    let jdbc = find_driver(DatabaseType::Jdbc);
    assert_eq!(jdbc.support_level, "browse");
    assert!(jdbc.capabilities.metadata_browse);
    assert!(jdbc.capabilities.object_browser);
    assert!(jdbc.capabilities.sql_file_execution);
    assert!(!jdbc.capabilities.table_structure_edit);
    assert!(!jdbc.capabilities.user_admin);

    let manticore = find_driver(DatabaseType::ManticoreSearch);
    assert_eq!(manticore.support_level, "operate");
    assert!(manticore.capabilities.metadata_browse);
    assert!(manticore.capabilities.sql_file_execution);
    assert!(manticore.capabilities.table_structure_edit);
    assert!(!manticore.capabilities.object_browser);
    assert!(manticore.capabilities.table_data_edit);

    let redis = find_driver(DatabaseType::Redis);
    assert_eq!(redis.support_level, "connect");
    assert!(!redis.capabilities.object_browser);
    assert!(!redis.capabilities.sql_file_execution);

    let zookeeper = find_driver(DatabaseType::ZooKeeper);
    assert_eq!(zookeeper.label, "Apache ZooKeeper");
    assert_eq!(zookeeper.runtime_mode, "agent");
    assert_eq!(zookeeper.agent_key.as_deref(), Some("zookeeper"));
    assert_eq!(zookeeper.support_level, "connect");
    // ZooKeeper has no SQL engine and its agent implements only kv_* operations;
    // claiming query execution or schema search made "new query" call
    // list-databases on an agent that does not support it (issue #8215).
    assert!(!zookeeper.capabilities.query_execution);
    assert!(!zookeeper.capabilities.schema_search);
    assert!(zookeeper.capabilities.driver_management);
    assert!(!zookeeper.capabilities.metadata_browse);

    let victoriametrics = find_driver(DatabaseType::VictoriaMetrics);
    assert_eq!(victoriametrics.runtime_mode, "native");
    assert_eq!(victoriametrics.support_level, "browse");
    assert!(victoriametrics.capabilities.query_execution);
    assert!(victoriametrics.capabilities.metadata_browse);
    assert!(victoriametrics.capabilities.object_browser);
    assert!(!victoriametrics.capabilities.table_data_edit);
    assert!(!victoriametrics.capabilities.sql_explain);

    let uxdb = find_driver(DatabaseType::Uxdb);
    assert_eq!(uxdb.label, "优炫 UXDB");
    assert_eq!(uxdb.runtime_mode, "agent");
    assert_eq!(uxdb.agent_key.as_deref(), Some("uxdb"));
    assert_eq!(uxdb.support_level, "operate");
    assert!(uxdb.capabilities.query_execution);
    assert!(uxdb.capabilities.metadata_browse);
    assert!(uxdb.capabilities.table_structure_edit);
    assert!(!uxdb.capabilities.data_transfer);
    assert!(!uxdb.capabilities.user_admin);

    let gbase8c = find_driver(DatabaseType::Gbase8c);
    assert_eq!(gbase8c.label, "南大通用 GBase 8c");
    assert_eq!(gbase8c.runtime_mode, "agent");
    assert_eq!(gbase8c.agent_key.as_deref(), Some("gbase8c"));
    assert_eq!(gbase8c.support_level, "operate");
    assert!(gbase8c.capabilities.query_execution);
    assert!(gbase8c.capabilities.metadata_browse);
    assert!(gbase8c.capabilities.table_data_edit);
    assert!(gbase8c.capabilities.driver_management);
    // Generated DDL has to follow DBCOMPATIBILITY (A/B/C/PG), which is fixed at database
    // creation and cannot be changed by SQL, so the same DDL can be right on one GBase 8c
    // instance and wrong on another. Structure editing, table import and data transfer stay
    // off until the DDL generator can honour the connected database's mode.
    assert!(!gbase8c.capabilities.table_structure_edit);
    assert!(!gbase8c.capabilities.table_import);
    assert!(!gbase8c.capabilities.data_transfer);
    // ConfiguredJdbcAgent (the base this agent uses) throws for object source.
    assert!(!gbase8c.capabilities.object_source);
    assert!(!gbase8c.capabilities.user_admin);

    let salesforce = find_driver(DatabaseType::Salesforce);
    assert_eq!(salesforce.label, "Salesforce");
    assert_eq!(salesforce.support_level, "operate");
    assert!(salesforce.capabilities.query_execution);
    assert!(salesforce.capabilities.metadata_browse);
    assert!(salesforce.capabilities.object_browser);
    assert!(salesforce.capabilities.schema_search);
    assert!(salesforce.capabilities.table_data_edit);
    assert!(!salesforce.capabilities.table_structure_edit);
    assert!(!salesforce.capabilities.object_source);
    assert!(!salesforce.capabilities.diagram);

    let spanner = find_driver(DatabaseType::Spanner);
    assert_eq!(spanner.label, "Google Cloud Spanner");
    assert_eq!(spanner.runtime_mode, "agent");
    assert_eq!(spanner.agent_key.as_deref(), Some("spanner"));
    assert_eq!(spanner.support_level, "operate");
    assert!(spanner.capabilities.query_execution);
    assert!(spanner.capabilities.metadata_browse);
    assert!(spanner.capabilities.object_browser);
    assert!(spanner.capabilities.schema_search);
    assert!(spanner.capabilities.sql_file_execution);
    assert!(spanner.capabilities.driver_management);
    // Every table in Spanner has a primary key, so grid edits can locate rows reliably.
    assert!(spanner.capabilities.table_data_edit);
    // Structure edits need per-dialect DDL descriptors; database creation needs the
    // Admin API (`CreateDatabase` gRPC), which the JDBC driver cannot reach.
    assert!(!spanner.capabilities.table_structure_edit);
    assert!(!spanner.capabilities.database_create);
    assert!(!spanner.capabilities.table_import);
    assert!(!spanner.capabilities.data_transfer);
    assert!(!spanner.capabilities.object_source);
    assert!(!spanner.capabilities.diagram);
    assert!(!spanner.capabilities.sql_explain);
    assert!(!spanner.capabilities.user_admin);

    let starrocks = find_driver(DatabaseType::StarRocks);
    assert!(starrocks.capabilities.user_admin);

    let impala = find_driver(DatabaseType::Impala);
    assert_eq!(impala.label, "Apache Impala");
    assert_eq!(impala.runtime_mode, "agent");
    assert_eq!(impala.agent_key.as_deref(), Some("hive"));
    assert_eq!(impala.support_level, "operate");
    assert!(impala.capabilities.query_execution);
    assert!(impala.capabilities.metadata_browse);
    assert!(impala.capabilities.object_browser);
    assert!(impala.capabilities.object_source);
    assert!(impala.capabilities.schema_search);
    assert!(impala.capabilities.sql_explain);
    assert!(impala.capabilities.data_transfer);
    assert!(impala.capabilities.sql_file_execution);
    assert!(!impala.capabilities.table_data_edit);
    assert!(!impala.capabilities.table_structure_edit);
    assert!(!impala.capabilities.table_import);
    assert!(!impala.capabilities.diagram);
    assert!(!impala.capabilities.user_admin);

    let kyuubi = find_driver(DatabaseType::Kyuubi);
    assert_eq!(kyuubi.label, "Apache Kyuubi");
    assert_eq!(kyuubi.runtime_mode, "agent");
    assert_eq!(kyuubi.agent_key.as_deref(), Some("hive"));
    assert_eq!(kyuubi.support_level, "operate");
    assert!(kyuubi.capabilities.query_execution);
    assert!(kyuubi.capabilities.metadata_browse);
    assert!(kyuubi.capabilities.object_browser);
    assert!(kyuubi.capabilities.object_source);
    assert!(kyuubi.capabilities.schema_search);
    assert!(kyuubi.capabilities.sql_explain);
    assert!(kyuubi.capabilities.data_transfer);
    assert!(kyuubi.capabilities.sql_file_execution);
    assert!(!kyuubi.capabilities.table_data_edit);
    assert!(!kyuubi.capabilities.table_structure_edit);
    assert!(!kyuubi.capabilities.table_import);
    assert!(!kyuubi.capabilities.diagram);
    assert!(!kyuubi.capabilities.user_admin);
}

#[test]
fn kingbase_declares_data_transfer_support() {
    let manifest = driver_manifest();
    let kingbase = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::Kingbase)
        .expect("Kingbase manifest entry");

    assert!(kingbase.capabilities.table_import);
    assert!(kingbase.capabilities.data_transfer);
}

#[test]
fn goldendb_declares_data_transfer_support() {
    let manifest = driver_manifest();
    let goldendb = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::Goldendb)
        .expect("GoldenDB manifest entry");

    assert!(goldendb.capabilities.table_import);
    assert!(goldendb.capabilities.data_transfer);
}

#[test]
fn highgo_declares_data_transfer_support() {
    let manifest = driver_manifest();
    let highgo =
        manifest.drivers.iter().find(|driver| driver.db_type == DatabaseType::Highgo).expect("HighGo manifest entry");

    assert!(highgo.capabilities.table_import);
    assert!(highgo.capabilities.data_transfer);
}

#[test]
fn vastbase_declares_data_transfer_support() {
    let manifest = driver_manifest();
    let vastbase = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::Vastbase)
        .expect("Vastbase manifest entry");

    assert!(vastbase.capabilities.table_import);
    assert!(vastbase.capabilities.data_transfer);
}

#[test]
fn yashandb_declares_data_transfer_support() {
    let manifest = driver_manifest();
    let yashandb = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::Yashandb)
        .expect("YashanDB manifest entry");

    assert!(yashandb.capabilities.table_import);
    assert!(yashandb.capabilities.data_transfer);
}

#[test]
fn xugu_declares_table_import_support() {
    let manifest = driver_manifest();
    let xugu =
        manifest.drivers.iter().find(|driver| driver.db_type == DatabaseType::Xugu).expect("Xugu manifest entry");

    assert!(xugu.capabilities.table_import);
}

#[test]
fn db2_declares_table_import_support() {
    let manifest = driver_manifest();
    let db2 = manifest.drivers.iter().find(|driver| driver.db_type == DatabaseType::Db2).expect("DB2 manifest entry");

    assert!(db2.capabilities.table_import);
}

#[test]
fn opengauss_declares_table_import_support() {
    let manifest = driver_manifest();
    let opengauss = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::OpenGauss)
        .expect("openGauss manifest entry");

    assert!(opengauss.capabilities.table_import);
    // The import wizard relies on these neighbouring capabilities; keep the
    // openGauss block coherent so the entry surfaces stay reachable.
    assert!(opengauss.capabilities.table_data_edit);
    assert!(opengauss.capabilities.sql_file_execution);
    assert!(opengauss.capabilities.data_transfer);
}

#[test]
fn saphana_declares_table_import_support() {
    let manifest = driver_manifest();
    let hana = manifest
        .drivers
        .iter()
        .find(|driver| driver.db_type == DatabaseType::SapHana)
        .expect("SAP HANA manifest entry");

    assert!(hana.capabilities.table_import);
    // Import into an existing table needs table editing and SQL execution.
    assert!(hana.capabilities.table_data_edit);
    assert!(hana.capabilities.sql_file_execution);
}