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。

17.1 KB
Raw Blame
use crate::connection::{MysqlMode, PoolKind};
use crate::db;
use crate::models::connection::{ConnectionConfig, DatabaseType};

pub(in crate::schema) async fn list_databases(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
) -> Result<Vec<db::DatabaseInfo>, String> {
    match pool {
        PoolKind::Mysql(p, _)
            if config.is_some_and(|c| db::mysql_compatible::uses_show_metadata(c) || super::super::is_mycat_config(c)) =>
        {
            db::mysql::list_databases_show(p)
                .await
                .map(|databases| filter_mysql_system_databases_for_config(databases, config))
        }
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => db::ob_oracle::list_databases(p).await,
        PoolKind::Mysql(p, _) => db::mysql::list_databases(p).await,
        PoolKind::Postgres(p) => db::postgres::list_databases(p).await,
        PoolKind::Sqlite(p) => db::sqlite::list_databases(p).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::list_databases(client).await,
        PoolKind::HBase(client) => db::hbase_driver::list_namespaces(client).await,
        PoolKind::Turso(client) => db::turso_driver::list_databases(client).await,
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_schemas(pool: &PoolKind) -> Result<Vec<String>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => db::ob_oracle::list_schemas(p).await,
        PoolKind::Postgres(p) => db::postgres::list_schemas(p).await,
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_tables(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    database: &str,
    schema: &str,
) -> Result<Vec<db::TableInfo>, String> {
    match pool {
        PoolKind::Mysql(p, _)
            if config.is_some_and(|c| db::mysql_compatible::uses_show_metadata(c) || super::super::is_mycat_config(c)) =>
        {
            db::mysql::list_tables_show(p, database).await
        }
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            let s = if schema.is_empty() { database } else { schema };
            db::ob_oracle::list_tables(p, s).await
        }
        PoolKind::Mysql(p, _) => {
            let db = if schema.is_empty() { database } else { schema };
            db::mysql::list_tables(p, db).await
        }
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => db::questdb::list_tables(p, schema).await,
        PoolKind::Postgres(p) if config.is_some_and(is_cloudberry_config) => {
            db::cloudberry::list_tables_filtered(p, schema, None, None, None).await
        }
        PoolKind::Postgres(p) => db::postgres::list_tables(p, schema).await,
        PoolKind::Sqlite(p) => db::sqlite::list_tables(p, schema).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::list_tables(client, schema).await,
        PoolKind::Turso(client) => db::turso_driver::list_tables(client, schema).await,
        PoolKind::MongoDb(client) => db::mongo_driver::list_collections(client, database)
            .await
            .map(|names| collection_names_to_tables(names, "COLLECTION")),
        PoolKind::Elasticsearch(client) => {
            db::elasticsearch_driver::list_indices(client).await.map(|names| collection_names_to_tables(names, "INDEX"))
        }
        PoolKind::Easysearch(client) => {
            db::easysearch_driver::list_indices(client).await.map(|names| collection_names_to_tables(names, "INDEX"))
        }
        PoolKind::Solr(client) => {
            db::solr_driver::list_cores(client).await.map(|names| collection_names_to_tables(names, "CORE"))
        }
        PoolKind::CouchDb(client) => {
            db::couchdb_driver::list_databases(client).await.map(|names| collection_names_to_tables(names, "DATABASE"))
        }
        PoolKind::Meilisearch(client) => {
            db::meilisearch_driver::list_indexes(client).await.map(|names| collection_names_to_tables(names, "INDEX"))
        }
        PoolKind::HBase(client) => db::hbase_driver::list_tables(client, database).await,
        PoolKind::VectorDb(client) => db::vector_driver::list_collections(client)
            .await
            .map(|infos| collection_names_to_tables(infos.into_iter().map(|i| i.name).collect(), "COLLECTION")),
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_objects(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    database: &str,
    schema: &str,
) -> Result<Option<Vec<db::ObjectInfo>>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::manticoresearch::is_config) => {
            db::manticoresearch::list_objects(p, database).await.map(Some)
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::mysql_compatible::uses_show_metadata) => {
            db::mysql::list_table_objects_show(p, database).await.map(Some)
        }
        PoolKind::Mysql(p, _) => {
            db::mysql::list_objects(p, database, None, None, None).await.map(|result| Some(result.objects))
        }
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
            db::questdb::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Postgres(p) if config.is_some_and(is_cloudberry_config) => {
            db::cloudberry::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema, true, true, false).await.map(Some),
        _ => Ok(None),
    }
}

pub(in crate::schema) async fn list_completion_objects(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    database: &str,
    schema: &str,
) -> Result<Option<Vec<db::ObjectInfo>>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode != MysqlMode::OceanBaseOracle => {
            db::mysql::list_completion_objects(p, database).await.map(Some)
        }
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
            db::questdb::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Postgres(p) if config.is_some_and(is_cloudberry_config) => {
            db::cloudberry::list_objects(p, schema).await.map(Some)
        }
        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema, true, true, false).await.map(Some),
        _ => Ok(None),
    }
}

pub(in crate::schema) async fn get_columns(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    database: &str,
    schema: &str,
    table: &str,
) -> Result<Vec<db::ColumnInfo>, String> {
    match pool {
        PoolKind::Mysql(p, _) if config.is_some_and(db::manticoresearch::is_config) => {
            let metadata_database = mysql_show_metadata_database_for_config(config, database);
            db::manticoresearch::get_columns(p, metadata_database, table).await
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::mysql_compatible::uses_show_metadata) => {
            let metadata_database = mysql_show_metadata_database_for_config(config, database);
            db::mysql::get_columns(p, metadata_database, table).await
        }
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::get_columns(p, database, table).await
        }
        PoolKind::Mysql(p, _) => db::mysql::get_columns(p, database, table).await,
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
            db::questdb::get_columns(p, schema, table).await
        }
        PoolKind::Postgres(p) => db::postgres::get_columns(p, schema, table).await,
        PoolKind::Sqlite(p) => db::sqlite::get_columns(p, schema, table).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::get_columns(client, schema, table).await,
        PoolKind::Turso(client) => db::turso_driver::get_columns(client, schema, table).await,
        PoolKind::Elasticsearch(client) => db::elasticsearch_driver::get_columns(client, table).await,
        PoolKind::Easysearch(client) => db::easysearch_driver::get_columns(client, table).await,
        PoolKind::Solr(client) => db::solr_driver::get_columns(client, table).await,
        PoolKind::CouchDb(client) => db::couchdb_driver::get_columns(client, table).await,
        PoolKind::Meilisearch(client) => db::meilisearch_driver::get_columns(client, table).await,
        PoolKind::HBase(client) => db::hbase_driver::get_columns(client, database, table).await,
        PoolKind::VectorDb(_) => Ok(vec![]),
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_indexes(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    database: &str,
    schema: &str,
    table: &str,
) -> Result<Vec<db::IndexInfo>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::list_indexes(p, schema, table).await
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::starrocks::is_config) => {
            db::starrocks::list_indexes(p, database, table).await
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::doris::is_config) => {
            db::doris::list_indexes(p, database, table).await
        }
        PoolKind::Mysql(p, _) if config.is_some_and(db::manticoresearch::is_config) => {
            db::mysql_compatible::list_indexes_with_ddl_fallback(p, database, table).await
        }
        PoolKind::Mysql(p, _) => db::mysql::list_indexes(p, schema, table).await,
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
            db::questdb::list_indexes(p, schema, table).await
        }
        PoolKind::Postgres(p) => db::postgres::list_indexes(p, schema, table).await,
        PoolKind::Sqlite(p) => db::sqlite::list_indexes(p, schema, table).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::list_indexes(client, schema, table).await,
        PoolKind::Turso(client) => db::turso_driver::list_indexes(client, schema, table).await,
        PoolKind::MongoDb(client) => db::mongo_driver::list_indexes(client, database, table).await,
        PoolKind::ClickHouse(client) => {
            db::clickhouse_driver::list_indexes(client, clickhouse_metadata_database(database, schema), table).await
        }
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_foreign_keys(
    pool: &PoolKind,
    schema: &str,
    table: &str,
) -> Result<Vec<db::ForeignKeyInfo>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::list_foreign_keys(p, schema, table).await
        }
        PoolKind::Mysql(p, _) => db::mysql::list_foreign_keys(p, schema, table).await,
        PoolKind::Postgres(p) => db::postgres::list_foreign_keys(p, schema, table).await,
        PoolKind::Sqlite(p) => db::sqlite::list_foreign_keys(p, schema, table).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::list_foreign_keys(client, schema, table).await,
        PoolKind::Turso(client) => db::turso_driver::list_foreign_keys(client, schema, table).await,
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn list_triggers(
    pool: &PoolKind,
    schema: &str,
    table: &str,
) -> Result<Vec<db::TriggerInfo>, String> {
    match pool {
        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
            db::ob_oracle::list_triggers(p, schema, table).await
        }
        PoolKind::Mysql(p, _) => db::mysql::list_triggers(p, schema, table).await,
        PoolKind::Postgres(p) => db::postgres::list_triggers(p, schema, table).await,
        PoolKind::Sqlite(p) => db::sqlite::list_triggers(p, schema, table).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::list_triggers(client, schema, table).await,
        PoolKind::Turso(client) => db::turso_driver::list_triggers(client, schema, table).await,
        _ => Ok(vec![]),
    }
}

pub(in crate::schema) async fn table_ddl(
    pool: &PoolKind,
    config: Option<&ConnectionConfig>,
    schema: &str,
    table: &str,
) -> Result<String, String> {
    match pool {
        PoolKind::Mysql(p, _) => super::super::mysql_ddl(p, schema, table).await,
        PoolKind::Postgres(p) if config.is_some_and(is_opengauss_family_config) => {
            match super::super::opengauss_table_ddl(p, schema, table).await {
                Ok(ddl) => Ok(ddl),
                Err(_) => super::super::pg_ddl(p, schema, table).await,
            }
        }
        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
            match db::questdb::questdb_table_or_view_ddl(p, table).await {
                Ok(ddl) => Ok(ddl),
                Err(_) => super::super::pg_ddl(p, schema, table).await,
            }
        }
        PoolKind::Postgres(p) if config.is_some_and(is_cloudberry_config) => {
            super::super::cloudberry_ddl(p, schema, table, false).await
        }
        PoolKind::Postgres(p) if config.is_some_and(db::opentenbase::is_config) => {
            super::super::opentenbase_ddl(p, schema, table, false).await
        }
        PoolKind::Postgres(p) => super::super::pg_ddl(p, schema, table).await,
        PoolKind::Sqlite(p) => super::super::sqlite_ddl(p, schema, table).await,
        PoolKind::Rqlite(client) => db::rqlite_driver::table_ddl(client, table).await,
        PoolKind::Turso(client) => db::turso_driver::table_ddl(client, table).await,
        _ => Err("DDL not supported for this database type".to_string()),
    }
}

pub(in crate::schema) async fn object_source(
    pool: &PoolKind,
    database: &str,
    schema: &str,
    name: &str,
    object_type: &db::ObjectSourceKind,
) -> Result<Option<String>, String> {
    match pool {
        PoolKind::Mysql(pool, mode) if *mode == MysqlMode::OceanBaseOracle => {
            super::super::db::ob_oracle::get_object_source(pool, schema, name, object_type).await.map(Some)
        }
        PoolKind::Mysql(pool, _) => super::super::mysql_object_source(
            pool,
            super::super::mysql_table_metadata_catalog(database, schema),
            name,
            object_type,
        )
        .await
        .map(Some),
        PoolKind::Postgres(pool) => {
            super::super::postgres_object_source(pool, schema, name, object_type).await.map(Some)
        }
        PoolKind::Sqlite(pool) => {
            let source = super::super::first_string_cell(
                db::sqlite::execute_query(pool, &super::super::sqlite_object_source_sql(schema, name, object_type))
                    .await?,
            )?;
            Ok(Some(source))
        }
        PoolKind::Rqlite(client) => {
            db::rqlite_driver::object_source(client, name, object_type).await.map(|source| Some(source.source))
        }
        PoolKind::Turso(client) => {
            db::turso_driver::object_source(client, name, object_type).await.map(|source| Some(source.source))
        }
        PoolKind::ClickHouse(client) if matches!(object_type, db::ObjectSourceKind::View) => {
            let result = db::clickhouse_driver::execute_query(
                client,
                database,
                &format!("SHOW CREATE TABLE {}", super::super::mysql_ident(name)),
            )
            .await?;
            super::super::first_string_cell(result).map(Some)
        }
        _ => Ok(None),
    }
}

fn collection_names_to_tables(names: Vec<String>, table_type: &str) -> Vec<db::TableInfo> {
    names
        .into_iter()
        .map(|name| db::TableInfo {
            name,
            table_type: table_type.to_string(),
            valid: None,
            comment: None,
            parent_schema: None,
            parent_name: None,
        })
        .collect()
}

fn clickhouse_metadata_database<'a>(database: &'a str, schema: &'a str) -> &'a str {
    if database.is_empty() {
        schema
    } else {
        database
    }
}

fn is_opengauss_family_config(config: &ConnectionConfig) -> bool {
    matches!(config.db_type, DatabaseType::OpenGauss | DatabaseType::Gaussdb)
        || matches!(config.driver_profile.as_deref(), Some("opengauss" | "gaussdb"))
}

fn is_cloudberry_config(config: &ConnectionConfig) -> bool {
    matches!(config.driver_profile.as_deref(), Some("cloudberry"))
}

fn mysql_show_metadata_database_for_config<'a>(config: Option<&ConnectionConfig>, database: &'a str) -> &'a str {
    if config.is_some_and(db::manticoresearch::is_config) {
        ""
    } else {
        database
    }
}

fn filter_mysql_system_databases_for_config(
    databases: Vec<db::DatabaseInfo>,
    config: Option<&ConnectionConfig>,
) -> Vec<db::DatabaseInfo> {
    if !config.is_some_and(db::manticoresearch::is_config) {
        return databases;
    }

    databases.into_iter().filter(|database| !is_mysql_system_database(&database.name)).collect()
}

fn is_mysql_system_database(name: &str) -> bool {
    matches!(name.to_ascii_lowercase().as_str(), "information_schema" | "mysql" | "performance_schema" | "sys")
}

fn is_questdb_config(config: &ConnectionConfig) -> bool {
    matches!(config.db_type, DatabaseType::Questdb) || matches!(config.driver_profile.as_deref(), Some("questdb"))
}