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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
use crate::models::connection::{ConnectionConfig, DatabaseType};
use crate::path_utils::expand_tilde;
const OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY: &str = "compatibleOjdbcVersion";
const OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM: &str = "compatibleOjdbcVersion=8";
const ZOOKEEPER_MIN_CONNECTION_TIMEOUT_MS: u64 = 15_000;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum AgentSessionRole {
#[default]
Workload,
Metadata,
}
impl AgentSessionRole {
fn as_str(self) -> &'static str {
match self {
Self::Workload => "workload",
Self::Metadata => "metadata",
}
}
}
fn agent_jdbc_driver_class(config: &ConnectionConfig) -> &str {
let driver_class = config.jdbc_driver_class.as_deref().unwrap_or("");
if (config.db_type == DatabaseType::H2 && !h2_uses_custom_driver(config))
|| (config.db_type == DatabaseType::SapHana && matches!(driver_class, "sap_hana" | "saphana"))
|| (config.db_type == DatabaseType::Db2 && !looks_like_jdbc_driver_class_name(driver_class))
{
""
} else {
driver_class
}
}
/// DBeaver and other importers store their own driver-registry id (for example
/// `db2` or `mysql8`) in `jdbc_driver_class`. DB2 bundles its driver in the
/// agent, so such an id can only fail as `Class.forName("db2")`; forward the
/// value only when it is a package-qualified class name.
fn looks_like_jdbc_driver_class_name(value: &str) -> bool {
let mut segments = 0;
for segment in value.trim().split('.') {
let mut chars = segment.chars();
let Some(first) = chars.next() else {
return false;
};
if !(first.is_ascii_alphabetic() || first == '_' || first == '$') {
return false;
}
if !chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$') {
return false;
}
segments += 1;
}
segments >= 2
}
fn agent_jdbc_driver_paths(config: &ConnectionConfig) -> &[String] {
if config.db_type == DatabaseType::H2 && !h2_uses_custom_driver(config) {
&[]
} else {
&config.jdbc_driver_paths
}
}
fn h2_uses_custom_driver(config: &ConnectionConfig) -> bool {
config.db_type == DatabaseType::H2
&& config.driver_profile.as_deref().is_some_and(|profile| profile.eq_ignore_ascii_case("h2-custom"))
}
fn cassandra_tls_field<'a>(config: &'a ConnectionConfig, field: &str) -> &'a str {
if config.db_type != DatabaseType::Cassandra {
return "";
}
config
.external_config
.as_ref()
.and_then(|value| value.get("tls"))
.and_then(|value| value.get(field))
.and_then(serde_json::Value::as_str)
.unwrap_or("")
}
pub fn agent_connect_params(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
) -> Result<serde_json::Value, String> {
agent_connect_params_with_role(config, host, port, database, AgentSessionRole::Workload)
}
pub fn agent_connect_params_with_role(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
session_role: AgentSessionRole,
) -> Result<serde_json::Value, String> {
let agent_database = if config.db_type == DatabaseType::MongoDb {
mongo_agent_database(config, database)
} else if matches!(config.db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle) {
oracle_agent_database(config, database)
} else if matches!(
config.db_type,
DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Uxdb | DatabaseType::Vastbase
) {
postgres_like_agent_database(config, database).to_string()
} else if is_h2_file_connection(config) {
h2_agent_database(config)
} else {
database.to_string()
};
let connection_string = if config.db_type == DatabaseType::MongoDb {
config.connection_url_with_host(host, port)
} else if config.db_type == DatabaseType::Oracle {
oracle_jdbc_connection_string(config, host, port, database)?
} else if config.db_type == DatabaseType::OceanbaseOracle {
oceanbase_oracle_jdbc_connection_string(config, host, port, database)?
} else if matches!(
config.db_type,
DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Uxdb | DatabaseType::Vastbase
) {
postgres_like_agent_jdbc_connection_string(config, host, port, database)
} else if config.db_type == DatabaseType::SapHana {
sap_hana_jdbc_connection_string(config, host, port, database)
} else if matches!(config.db_type, DatabaseType::Trino | DatabaseType::PrestoSql) {
trino_like_jdbc_connection_string(config, host, port, database)?
} else if config.db_type == DatabaseType::Transwarp {
match config.connection_string.as_deref().filter(|value| !value.trim().is_empty()) {
Some(url) if host != config.host || port != config.port => {
crate::models::connection::rewrite_jdbc_url_host(url, host, port)?
}
Some(url) => url.to_string(),
None => String::new(),
}
} else if config.db_type == DatabaseType::H2 {
h2_agent_jdbc_connection_string(config)
} else {
config.connection_string.as_deref().unwrap_or("").to_string()
};
let etcd_endpoints =
if config.db_type == DatabaseType::Etcd { normalize_etcd_endpoints(config, host, port) } else { String::new() };
let zookeeper_connect_string = if config.db_type == DatabaseType::ZooKeeper {
normalize_zookeeper_connect_string(config, host, port)
} else {
String::new()
};
let (agent_host, agent_port) = if is_h2_file_connection(config) { ("", 0) } else { (host, port) };
let mut params = serde_json::json!({
"host": agent_host,
"port": agent_port,
"port_explicit": config.sqlserver_port_explicit(),
"database": agent_database,
"username": config.username,
"password": config.password,
"sysdba": oracle_uses_sysdba(config),
"url_params": config.url_params.as_deref().unwrap_or(""),
"connection_string": connection_string,
"ssl": config.ssl,
"ca_cert_path": config.ca_cert_path,
"client_cert_path": config.client_cert_path,
"client_key_path": config.client_key_path,
"truststore_path": cassandra_tls_field(config, "truststore_path"),
"truststore_password": cassandra_tls_field(config, "truststore_password"),
"keystore_path": cassandra_tls_field(config, "keystore_path"),
"keystore_password": cassandra_tls_field(config, "keystore_password"),
"connect_timeout_secs": config.effective_connect_timeout_secs(),
"etcd_endpoints": etcd_endpoints,
"zookeeper_connect_string": zookeeper_connect_string,
"gbase_server": config.gbase_server,
"informix_server": config.informix_server,
"jdbc_driver_class": agent_jdbc_driver_class(config),
"jdbc_driver_paths": agent_jdbc_driver_paths(config),
"driver_profile": config.driver_profile.as_deref().unwrap_or(""),
"sessionRole": session_role.as_str(),
"database_type": config.db_type,
});
if config.db_type == DatabaseType::ZooKeeper {
params["connection_timeout_ms"] = serde_json::json!(
(config.effective_connect_timeout_secs() * 1000).max(ZOOKEEPER_MIN_CONNECTION_TIMEOUT_MS)
);
}
Ok(params)
}
fn oracle_uses_sysdba(config: &ConnectionConfig) -> bool {
config.sysdba || (config.db_type == DatabaseType::Oracle && config.username.trim().eq_ignore_ascii_case("sys"))
}
fn oracle_agent_database(config: &ConnectionConfig, database: &str) -> String {
let database = database.trim();
if database.is_empty() || !oracle_uses_sysdba(config) || database.to_uppercase().starts_with("SYSDBA:") {
return database.to_string();
}
format!("SYSDBA:{database}")
}
fn mongo_agent_database(config: &ConnectionConfig, database: &str) -> String {
if let Some(database) = non_empty_database(database) {
return database.to_string();
}
if let Some(database) = config.database.as_deref().and_then(non_empty_database) {
return database.to_string();
}
if let Some(database) = config.connection_string.as_deref().and_then(mongo_uri_database) {
return database;
}
"admin".to_string()
}
fn non_empty_database(database: &str) -> Option<&str> {
let database = database.trim();
(!database.is_empty()).then_some(database)
}
pub fn is_h2_file_connection(config: &ConnectionConfig) -> bool {
config.db_type == DatabaseType::H2
&& (config.connection_string.as_deref().is_some_and(is_h2_file_jdbc_url)
|| (config.port == 0 && !config.host.trim().is_empty()))
}
pub fn h2_agent_jdbc_connection_string(config: &ConnectionConfig) -> String {
if let Some(connection_string) =
config.connection_string.as_deref().map(str::trim).filter(|value| !value.is_empty())
{
if is_h2_file_jdbc_url(connection_string) {
return normalize_h2_file_jdbc_url(connection_string).unwrap_or_else(|| connection_string.to_string());
}
return connection_string.to_string();
}
if is_h2_file_connection(config) {
return h2_file_jdbc_url(&config.host);
}
String::new()
}
fn h2_agent_database(config: &ConnectionConfig) -> String {
let jdbc_url = h2_agent_jdbc_connection_string(config);
jdbc_url.strip_prefix("jdbc:h2:").unwrap_or(&jdbc_url).to_string()
}
pub fn h2_file_jdbc_url(path: &str) -> String {
let url = h2_file_jdbc_url_base(path);
format!("{url};AUTO_SERVER=TRUE")
}
fn h2_file_jdbc_url_base(path: &str) -> String {
let path = h2_jdbc_file_base_path(path);
format!("jdbc:h2:file:{path}")
}
pub fn h2_jdbc_file_base_path(path: &str) -> String {
let path = expand_tilde(path.trim());
let lower = path.to_ascii_lowercase();
for suffix in [".mv.db", ".h2.db"] {
if lower.ends_with(suffix) {
return path[..path.len() - suffix.len()].to_string();
}
}
path
}
pub fn h2_file_path_from_jdbc_url(connection_string: &str) -> Option<String> {
let connection_string = connection_string.trim();
h2_file_jdbc_url_prefix(connection_string).map(|prefix| {
let raw_path = connection_string[prefix.len()..].split(';').next().unwrap_or("");
if prefix.eq_ignore_ascii_case("jdbc:h2:split:") {
raw_path
.split_once(':')
.and_then(|(block_size, path)| block_size.chars().all(|ch| ch.is_ascii_digit()).then_some(path))
.unwrap_or(raw_path)
.to_string()
} else {
raw_path.to_string()
}
})
}
fn h2_file_jdbc_url_prefix(connection_string: &str) -> Option<&'static str> {
["jdbc:h2:file:", "jdbc:h2:split:"]
.into_iter()
.find(|prefix| connection_string.get(..prefix.len()).is_some_and(|value| value.eq_ignore_ascii_case(prefix)))
}
fn normalize_h2_file_jdbc_url(connection_string: &str) -> Option<String> {
let connection_string = connection_string.trim();
let prefix = "jdbc:h2:file:";
if !connection_string.get(..prefix.len())?.eq_ignore_ascii_case(prefix) {
return None;
}
let rest = &connection_string[prefix.len()..];
let (path, options) = rest.split_once(';').map(|(path, options)| (path, Some(options))).unwrap_or((rest, None));
let mut url = if options.is_some() { h2_file_jdbc_url_base(path) } else { h2_file_jdbc_url(path) };
if let Some(options) = options {
url.push(';');
url.push_str(options);
}
Some(url)
}
fn is_h2_file_jdbc_url(connection_string: &str) -> bool {
h2_file_jdbc_url_prefix(connection_string.trim()).is_some()
}
fn mongo_uri_database(uri: &str) -> Option<String> {
let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?;
let (_, after_hosts) = rest.split_once('/')?;
let database = after_hosts.split(['?', '#']).next()?.trim();
if database.is_empty() {
return None;
}
Some(percent_decode_str(database).decode_utf8_lossy().into_owned())
}
pub fn mongo_legacy_error_with_auth_hint(err: &str) -> String {
let Some(source_start) = err.find("source='") else {
return err.to_string();
};
if !err.contains("Exception authenticating MongoCredential") || err.contains("Current authentication database:") {
return err.to_string();
}
let source = &err[source_start + "source='".len()..];
let Some(source_end) = source.find('\'') else {
return err.to_string();
};
let source = &source[..source_end];
let verification_hint = format!(
"Current authentication database: {source}. The server rejected these credentials. Verify the username and password, and confirm that the user was created in {source}."
);
if source.eq_ignore_ascii_case("admin") {
return format!("{err}\n\n{verification_hint}");
}
format!("{err}\n\n{verification_hint} If the user was created in admin, set Authentication database to admin or add authSource=admin to URL params.")
}
pub fn mongo_uses_legacy_driver(config: &ConnectionConfig) -> bool {
config.driver_profile.as_deref().is_some_and(|profile| {
profile.eq_ignore_ascii_case("mongodb-legacy")
|| profile.eq_ignore_ascii_case("mongodb_legacy")
|| profile.eq_ignore_ascii_case("legacy")
})
}
pub fn should_retry_mongo_with_legacy_driver(err: &str) -> bool {
let normalized = err.to_lowercase();
if normalized.contains("wire version") {
return true;
}
let looks_like_handshake_io_error = normalized.contains("unexpected end of file")
|| normalized.contains("connection reset by peer")
|| normalized.contains("broken pipe");
looks_like_handshake_io_error
&& (normalized.contains("server selection timeout")
|| normalized.contains("no available servers")
|| normalized.contains("topology:")
|| normalized.contains("i/o error"))
}
pub fn oracle_error_with_driver_hint(config: &ConnectionConfig, err: &str) -> String {
if config.db_type != DatabaseType::Oracle {
return err.to_string();
}
let normalized = err.to_lowercase();
if !normalized.contains("ora-12541") && !err.contains("没有监听程序") {
return err.to_string();
}
format!("{err}\n\nOracle listener was not reachable. If the host and port are correct, try switching between Service Name and SID.")
}
pub fn oracle_alternate_connect_configs(config: &ConnectionConfig, err: &str) -> Vec<ConnectionConfig> {
if config.db_type != DatabaseType::Oracle {
return Vec::new();
}
if config.oracle_connection_type.as_deref() == Some("tns") {
// TNS owns its complete address/failover descriptor; host-based retries would
// replace the configured alias with unrelated Service Name/SID URLs.
return Vec::new();
}
if config.connection_string.as_deref().is_some_and(|value| !value.trim().is_empty()) {
return Vec::new();
}
if !oracle_listener_error_can_retry(err) {
return Vec::new();
}
let database = config.effective_database().unwrap_or("").trim();
if database.is_empty() {
return Vec::new();
}
let host = config.host.trim();
let port = config.port;
let current_url = oracle_jdbc_connection_string(config, host, port, database).unwrap_or_default();
let service_url = oracle_service_jdbc_url(host, port, database);
let sid_url = oracle_sid_jdbc_url(host, port, database);
let legacy_service_url = oracle_legacy_service_jdbc_url(host, port, database);
let descriptor_service_url = oracle_descriptor_jdbc_url(host, port, database, "SERVICE_NAME");
let descriptor_sid_url = oracle_descriptor_jdbc_url(host, port, database, "SID");
let normalized = err.to_lowercase();
let candidates = if normalized.contains("ora-12505") {
vec![service_url, descriptor_service_url, legacy_service_url]
} else {
// ORA-12514: the listener answered but does not know the service name, so a
// SID/legacy/descriptor spelling is the only thing that can help.
vec![sid_url, descriptor_sid_url, legacy_service_url]
};
// The retries travel through `oracle_jdbc_connection_string` as a stored
// connection string, so they must already carry the profile's protocol.
let candidates: Vec<String> = candidates.into_iter().map(|url| oracle_url_for_profile(config, url)).collect();
let mut urls = Vec::new();
for url in candidates {
if url == current_url || urls.iter().any(|seen| seen == &url) {
continue;
}
urls.push(url);
}
urls.into_iter()
.map(|url| {
let mut retry = config.clone();
retry.oracle_connection_type = None;
retry.connection_string = Some(url);
retry
})
.collect()
}
/// Applies the OCI (thick) protocol to an Oracle JDBC URL when the connection
/// selects the OCI driver profile. Thin connections keep the URL unchanged.
///
/// OCI reaches the same targets as thin; the TNS form additionally moves its
/// `TNS_ADMIN` query into the agent-process environment
/// (`crate::oracle_oci::oracle_oci_launch_env`).
fn oracle_url_for_profile(config: &ConnectionConfig, url: String) -> String {
if !crate::oracle_oci::uses_oracle_oci_profile(config) {
return url;
}
let rewritten = crate::oracle_oci::rewrite_oracle_url_protocol(&url, true);
crate::oracle_oci::strip_oracle_tns_admin_query(&rewritten)
}
fn oracle_jdbc_connection_string(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
) -> Result<String, String> {
if let Some(connection_string) = config.connection_string.as_deref().filter(|value| !value.trim().is_empty()) {
let connection_string = connection_string.trim();
if host == config.host && port == config.port {
return Ok(oracle_url_for_profile(config, connection_string.to_string()));
}
return Ok(oracle_url_for_profile(
config,
crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port)?,
));
}
let database = database.trim();
if database.is_empty() {
return Ok(String::new());
}
let url = if config.oracle_connection_type.as_deref() == Some("sid") {
oracle_sid_jdbc_url(host, port, database)
} else {
oracle_service_jdbc_url(host, port, database)
};
Ok(oracle_url_for_profile(config, url))
}
/// Whether Oracle's alternate connection descriptors can plausibly fix this error.
///
/// The alternates only rewrite how the *connect descriptor* names the service/SID
/// (`//host:port/service`, `host:port:SID`, `(DESCRIPTION=...)`); they never change
/// host, port or route. ORA-12505/ORA-12514 are answered by a listener that is
/// reachable on host:port, so a wrong service/SID spelling is exactly what they
/// diagnose. ORA-12541 ("no listener"), timeouts and resets mean the listener was
/// never reached, so retrying three more descriptor spellings only opens three
/// more TCP connections that cannot succeed.
///
/// That matters beyond wasted time: enterprise zero-trust/security clients in
/// front of the database run an authorization check for every new connection and
/// pop a native warning per failed check, so one failed connect used to stack up
/// to five dialogs (1 initial + 4 alternates) per attempt. Keep the failure to one
/// connection; ORA-12541 keeps the "try Service Name/SID" hint
/// (`oracle_error_with_driver_hint`), it just no longer auto-retries.
fn oracle_listener_error_can_retry(err: &str) -> bool {
let normalized = err.to_lowercase();
normalized.contains("ora-12505") || normalized.contains("ora-12514")
}
fn oracle_service_jdbc_url(host: &str, port: u16, database: &str) -> String {
format!("jdbc:oracle:thin:@//{host}:{port}/{database}")
}
fn oracle_sid_jdbc_url(host: &str, port: u16, database: &str) -> String {
format!("jdbc:oracle:thin:@{host}:{port}:{database}")
}
fn oracle_legacy_service_jdbc_url(host: &str, port: u16, database: &str) -> String {
format!("jdbc:oracle:thin:@{host}:{port}/{database}")
}
fn oracle_descriptor_jdbc_url(host: &str, port: u16, database: &str, key: &str) -> String {
format!("jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST={host})(PORT={port}))(CONNECT_DATA=({key}={database})))")
}
fn oceanbase_oracle_jdbc_connection_string(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
) -> Result<String, String> {
if let Some(connection_string) = config.connection_string.as_deref().filter(|value| !value.trim().is_empty()) {
let connection_string = connection_string.trim();
let url = if host == config.host && port == config.port {
connection_string.to_string()
} else {
crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port)?
};
if url_has_query_key(&url, OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY) {
return Ok(url);
}
return Ok(append_agent_url_params(url, Some(OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM)));
}
let database = database.trim();
if database.is_empty() {
return Ok(String::new());
}
let base = format!("jdbc:oceanbase://{host}:{port}/{database}");
Ok(append_agent_url_params(base, Some(&oceanbase_oracle_jdbc_params(config))))
}
fn oceanbase_oracle_jdbc_params(config: &ConnectionConfig) -> String {
let user_params = normalize_agent_url_params(config.url_params.as_deref());
let mut params = Vec::new();
if !user_params.is_empty() {
params.push(user_params.to_string());
}
if !url_params_has_key(user_params, OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY) {
params.push(OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM.to_string());
}
params.join("&")
}
fn postgres_like_agent_jdbc_connection_string(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
) -> String {
let scheme = match config.db_type {
DatabaseType::Kingbase => "kingbase8",
DatabaseType::Highgo => "highgo",
DatabaseType::Uxdb => "uxdb",
DatabaseType::Vastbase => "vastbase",
_ => unreachable!("postgres-like agent JDBC URL requested for {:?}", config.db_type),
};
let database = postgres_like_agent_database(config, database);
let base = format!("jdbc:{scheme}://{host}:{port}/{database}");
append_agent_url_params(base, config.url_params.as_deref())
}
fn postgres_like_agent_database<'a>(config: &'a ConnectionConfig, database: &'a str) -> &'a str {
let database = database.trim();
if !database.is_empty() {
return database;
}
// Vastbase/PostgreSQL-compatible JDBC drivers can reject an empty catalog path.
config.effective_database().unwrap_or("")
}
/// Picks the database to open for a legacy KingbaseES/Vastbase connection that was
/// saved without an explicit database. Both vendor servers may lack the `postgres`
/// database that `ConnectionConfig::default_database()` falls back to, so the caller
/// probes the always-present `template1` catalog and hands the found databases here.
/// The historical `postgres` default still wins when it exists so upgraded
/// connections keep their previous behavior.
pub fn pick_legacy_postgres_like_database(databases: &[String]) -> Option<String> {
let names: Vec<&str> = databases.iter().map(|name| name.trim()).filter(|name| !name.is_empty()).collect();
let preferred =
|wanted: &str| names.iter().find(|name| name.eq_ignore_ascii_case(wanted)).map(|name| (*name).to_string());
if let Some(database) = preferred("postgres").or_else(|| preferred("kingbase")).or_else(|| preferred("test")) {
return Some(database);
}
names.iter().find(|name| !is_template_database(name)).or_else(|| names.first()).map(|name| (*name).to_string())
}
fn is_template_database(name: &str) -> bool {
name.eq_ignore_ascii_case("template0") || name.eq_ignore_ascii_case("template1")
}
pub fn oracle_alternate_connect_config(config: &ConnectionConfig, err: &str) -> Option<ConnectionConfig> {
oracle_alternate_connect_configs(config, err).into_iter().next()
}
pub fn oracle_alternate_connect_config_labels(configs: &[ConnectionConfig]) -> Vec<String> {
configs
.iter()
.map(|config| {
config
.connection_string
.as_deref()
.map(oracle_connection_string_label)
.unwrap_or_else(|| config.oracle_connection_type.as_deref().unwrap_or("service_name").to_string())
})
.collect()
}
fn oracle_connection_string_label(connection_string: &str) -> String {
let upper = connection_string.to_ascii_uppercase();
if upper.contains("(SERVICE_NAME=") {
"descriptor service name".to_string()
} else if upper.contains("(SID=") {
"descriptor SID".to_string()
} else if connection_string.starts_with("jdbc:oracle:thin:@//") {
"service name".to_string()
} else if connection_string.contains(':') && !connection_string.contains('/') {
"SID".to_string()
} else {
"legacy service name".to_string()
}
}
fn sap_hana_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
let database = database.trim();
let params = config.url_params.as_deref().unwrap_or("").trim().trim_start_matches('?');
let has_database_name = params
.split(['&', ';'])
.any(|part| part.split_once('=').map(|(key, _)| key.eq_ignore_ascii_case("databaseName")).unwrap_or(false));
let mut query_parts = Vec::new();
if !database.is_empty() && !has_database_name {
query_parts.push(format!("databaseName={}", utf8_percent_encode(database, NON_ALPHANUMERIC)));
}
if !params.is_empty() {
query_parts.push(params.to_string());
}
if query_parts.is_empty() {
format!("jdbc:sap://{host}:{port}")
} else {
format!("jdbc:sap://{host}:{port}/?{}", query_parts.join("&"))
}
}
pub fn trino_like_jdbc_connection_string(
config: &ConnectionConfig,
host: &str,
port: u16,
database: &str,
) -> Result<String, String> {
let jdbc_scheme = match config.db_type {
DatabaseType::PrestoSql => "presto",
_ => "trino",
};
let jdbc_prefix = format!("jdbc:{jdbc_scheme}:");
let base = config
.connection_string
.as_deref()
.map(str::trim)
.filter(|value| value.get(..jdbc_prefix.len()).is_some_and(|prefix| prefix.eq_ignore_ascii_case(&jdbc_prefix)))
.map(|connection_string| {
if host == config.host && port == config.port {
Ok(connection_string.to_string())
} else {
crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port)
}
})
.transpose()?
.unwrap_or_else(|| {
let database = database.trim();
if database.is_empty() {
format!("jdbc:{jdbc_scheme}://{host}:{port}")
} else {
format!("jdbc:{jdbc_scheme}://{host}:{port}/{database}")
}
});
let params = trino_agent_jdbc_params(config, &base);
Ok(if params.is_empty() { base } else { append_agent_url_params(base, Some(¶ms)) })
}
fn trino_agent_jdbc_params(config: &ConnectionConfig, base: &str) -> String {
let user_params = normalize_agent_url_params(config.url_params.as_deref());
let mut params = Vec::new();
if !user_params.is_empty() {
params.push(user_params.to_string());
}
if config.ssl && !url_params_has_key(user_params, "SSL") && !url_has_query_key(base, "SSL") {
params.push("SSL=true".to_string());
}
params.join("&")
}
fn normalize_etcd_endpoints(config: &ConnectionConfig, host: &str, port: u16) -> String {
let endpoints = config.etcd_endpoints.trim();
if !endpoints.is_empty() {
return endpoints.to_string();
}
let scheme = if config.ssl { "https" } else { "http" };
format!("{scheme}://{host}:{port}")
}
fn normalize_zookeeper_connect_string(config: &ConnectionConfig, host: &str, port: u16) -> String {
config
.connection_string
.as_deref()
.map(str::trim)
.filter(|value| !value.is_empty())
.map(str::to_string)
.unwrap_or_else(|| format!("{host}:{port}"))
}
fn normalize_agent_url_params(params: Option<&str>) -> &str {
params.unwrap_or("").trim().trim_start_matches(['?', '&'])
}
fn url_has_query_key(url: &str, key: &str) -> bool {
let Some((_, query)) = url.split_once('?') else {
return false;
};
let query = query.split('#').next().unwrap_or(query);
url_params_has_key(query, key)
}
fn url_params_has_key(params: &str, key: &str) -> bool {
params
.split(['&', ';'])
.filter_map(|part| {
let part = part.trim();
if part.is_empty() {
return None;
}
Some(part.split_once('=').map(|(param_key, _)| param_key).unwrap_or(part).trim())
})
.any(|param_key| param_key.eq_ignore_ascii_case(key))
}
fn append_agent_url_params(base: String, params: Option<&str>) -> String {
let params = normalize_agent_url_params(params);
if params.is_empty() {
return base;
}
let separator = if base.contains('?') { '&' } else { '?' };
format!("{base}{separator}{params}")
}
pub fn hive_uses_zookeeper_discovery(config: &ConnectionConfig) -> bool {
if !matches!(config.db_type, DatabaseType::Hive | DatabaseType::Kyuubi | DatabaseType::Impala | DatabaseType::Argo)
{
return false;
}
if config.url_params.as_deref().is_some_and(hive_parameters_use_zookeeper_discovery) {
return true;
}
config.host.trim().is_empty()
&& config.connection_string.as_deref().is_some_and(hive_parameters_use_zookeeper_discovery)
}
fn hive_parameters_use_zookeeper_discovery(source: &str) -> bool {
source.split([';', '?', '#', '&']).any(|part| {
let Some((key, value)) = part.split_once('=') else {
return false;
};
let key = percent_decode_str(key.trim()).decode_utf8_lossy();
let value = percent_decode_str(value.trim()).decode_utf8_lossy();
key.eq_ignore_ascii_case("serviceDiscoveryMode")
&& (value.eq_ignore_ascii_case("zookeeper") || value.eq_ignore_ascii_case("zookeeperha"))
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::connection::{
default_connect_timeout_secs, default_idle_disconnect_secs, default_idle_timeout_secs,
default_keepalive_interval_secs, default_manual_transaction_timeout_secs, default_query_timeout_secs,
default_redis_key_separator,
};
fn config(db_type: DatabaseType, database: Option<&str>) -> ConnectionConfig {
ConnectionConfig {
oracle_oci_nls_lang: None,
oracle_oci_tns_admin: None,
docs_notes_path: None,
id: "conn".to_string(),
name: "Connection".to_string(),
note: String::new(),
db_type,
driver_profile: None,
driver_label: None,
url_params: None,
agent_java_options: Vec::new(),
host: "127.0.0.1".to_string(),
port: 3306,
username: "user".to_string(),
password: "secret".to_string(),
database: database.map(str::to_string),
default_schema: None,
visible_databases: None,
visible_database_patterns: None,
visible_schemas: None,
show_system_schemas: false,
sidebar_auto_load_all_tables: false,
show_database_links: None,
show_native_jobs: None,
show_user_admin: None,
attached_databases: Vec::new(),
init_script: None,
color: None,
transport_layers: Vec::new(),
connect_timeout_secs: default_connect_timeout_secs(),
query_timeout_secs: default_query_timeout_secs(),
idle_timeout_secs: default_idle_timeout_secs(),
manual_transaction_timeout_secs: default_manual_transaction_timeout_secs(),
idle_disconnect_secs: default_idle_disconnect_secs(),
keepalive_interval_secs: default_keepalive_interval_secs(),
ssl: false,
ca_cert_path: String::new(),
client_cert_path: String::new(),
client_key_path: String::new(),
sysdba: false,
oracle_connection_type: None,
connection_string: None,
redis_connection_mode: None,
redis_sentinel_master: String::new(),
redis_sentinel_nodes: String::new(),
redis_sentinel_username: String::new(),
redis_sentinel_password: String::new(),
redis_sentinel_tls: false,
redis_cluster_nodes: String::new(),
redis_key_separator: default_redis_key_separator(),
redis_scan_page_size: None,
redis_database_aliases: Default::default(),
redis_key_templates: Vec::new(),
redis_key_filter: None,
redis_key_grouping: None,
etcd_endpoints: String::new(),
gbase_server: String::new(),
informix_server: String::new(),
external_config: None,
plugin_id: None,
plugin_connection_provider: None,
plugin_connection_type: None,
connection_secrets: Default::default(),
jdbc_driver_class: None,
jdbc_driver_paths: Vec::new(),
one_time: false,
save_password: true,
read_only: false,
is_production: false,
production_databases: vec![],
production_badge_scope: None,
database_info: None,
}
}
#[test]
fn agent_connect_params_default_to_workload_session_role() {
let params = agent_connect_params(&config(DatabaseType::H2, Some("test")), "127.0.0.1", 9092, "test").unwrap();
assert_eq!(params["sessionRole"], "workload");
assert_eq!(params["database_type"], "h2");
}
#[test]
fn metadata_agent_connect_params_include_metadata_session_role() {
let params = agent_connect_params_with_role(
&config(DatabaseType::H2, Some("test")),
"127.0.0.1",
9092,
"test",
AgentSessionRole::Metadata,
)
.unwrap();
assert_eq!(params["sessionRole"], "metadata");
}
#[test]
fn cassandra_agent_connect_params_include_tls_stores() {
let mut cfg = config(DatabaseType::Cassandra, Some("app"));
cfg.ssl = true;
cfg.external_config = Some(serde_json::json!({
"tls": {
"truststore_path": "/certs/client.truststore",
"truststore_password": "trust-secret",
"keystore_path": "/certs/client.keystore",
"keystore_password": "key-secret"
}
}));
let params = agent_connect_params(&cfg, "cassandra.example.com", 9042, "app").unwrap();
assert_eq!(params["truststore_path"], "/certs/client.truststore");
assert_eq!(params["truststore_password"], "trust-secret");
assert_eq!(params["keystore_path"], "/certs/client.keystore");
assert_eq!(params["keystore_password"], "key-secret");
}
#[test]
fn oracle_form_connections_use_orcl_when_database_is_omitted() {
for (mode, expected_url) in [
("service_name", "jdbc:oracle:thin:@//oracle.example.com:1521/ORCL"),
("sid", "jdbc:oracle:thin:@oracle.example.com:1521:ORCL"),
] {
let mut cfg = config(DatabaseType::Oracle, None);
cfg.oracle_connection_type = Some(mode.to_string());
let database = cfg.effective_database().unwrap_or("");
let params = agent_connect_params(&cfg, "oracle.example.com", 1521, database).unwrap();
assert_eq!(params["database"], "ORCL");
assert_eq!(params["connection_string"], expected_url);
}
}
#[test]
fn oracle_oci_profile_builds_oci8_urls_for_service_and_sid() {
for (mode, expected_url) in [
("service_name", "jdbc:oracle:oci8:@//oracle.example.com:1521/ORCLPDB1"),
("sid", "jdbc:oracle:oci8:@oracle.example.com:1521:ORCLPDB1"),
] {
let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
cfg.driver_profile = Some(crate::oracle_oci::ORACLE_OCI_DRIVER_PROFILE.to_string());
cfg.oracle_connection_type = Some(mode.to_string());
let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1").unwrap();
assert_eq!(params["connection_string"], expected_url);
}
}
#[test]
fn oracle_oci_profile_rewrites_tns_urls_and_strips_the_admin_query() {
let mut cfg = config(DatabaseType::Oracle, None);
cfg.driver_profile = Some(crate::oracle_oci::ORACLE_OCI_DRIVER_PROFILE.to_string());
cfg.connection_string = Some("jdbc:oracle:oci8:@ORCLPDB1?TNS_ADMIN=C%3A%5Coracle%5Cwallets".to_string());
// 主机与端口沿用连接自身:TNS 别名 URL 不参与主机改写(别名没有 host)。
let params = agent_connect_params(&cfg, &cfg.host.clone(), cfg.port, "").unwrap();
assert_eq!(params["connection_string"], "jdbc:oracle:oci8:@ORCLPDB1");
}
#[test]
fn oracle_thin_profile_keeps_the_thin_protocol() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
cfg.oracle_connection_type = Some("service_name".to_string());
let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1").unwrap();
assert_eq!(params["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCLPDB1");
}
#[test]
fn oracle_oci_alternate_connect_configs_stay_on_the_oci_protocol() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
cfg.driver_profile = Some(crate::oracle_oci::ORACLE_OCI_DRIVER_PROFILE.to_string());
cfg.oracle_connection_type = Some("service_name".to_string());
let alternates =
oracle_alternate_connect_configs(&cfg, "ORA-12514: listener does not currently know of service");
assert!(!alternates.is_empty());
for alternate in &alternates {
let url = alternate.connection_string.as_deref().expect("alternate url");
assert!(url.starts_with("jdbc:oracle:oci8:@"), "alternate url must keep the oci8 protocol: {url}");
}
}
#[test]
fn structured_hive_uses_current_url_params_for_zookeeper_detection() {
let mut cfg = config(DatabaseType::Hive, Some("default"));
cfg.connection_string = Some(
"jdbc:hive2://zk1.example.com:2181,zk2.example.com:2181/default;serviceDiscoveryMode=zooKeeper".to_string(),
);
assert!(!hive_uses_zookeeper_discovery(&cfg));
cfg.url_params = Some("serviceDiscoveryMode=zooKeeperHA;zooKeeperNamespace=hs2".to_string());
assert!(hive_uses_zookeeper_discovery(&cfg));
cfg.url_params = Some("note=serviceDiscoveryMode=zooKeeper".to_string());
assert!(!hive_uses_zookeeper_discovery(&cfg));
cfg.host.clear();
cfg.url_params = None;
assert!(hive_uses_zookeeper_discovery(&cfg));
}
#[test]
fn mongodb_database_falls_back_to_uri_database() {
let mut cfg = config(DatabaseType::MongoDb, None);
cfg.connection_string = Some("mongodb://user:[email protected]:27017/app_db?authSource=admin".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 27017, "").unwrap();
assert_eq!(params["database"], "app_db");
}
#[test]
fn h2_file_path_builds_jdbc_file_url_and_strips_database_suffix() {
assert_eq!(h2_file_jdbc_url("/tmp/app.mv.db"), "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
assert_eq!(h2_file_jdbc_url("/tmp/App.MV.DB"), "jdbc:h2:file:/tmp/App;AUTO_SERVER=TRUE");
assert_eq!(h2_file_jdbc_url("/tmp/legacy.h2.db"), "jdbc:h2:file:/tmp/legacy;AUTO_SERVER=TRUE");
assert_eq!(h2_file_jdbc_url("/tmp/app"), "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
}
#[test]
fn h2_file_connection_passes_jdbc_file_url_to_agent() {
let mut cfg = config(DatabaseType::H2, None);
cfg.host = "/tmp/app.mv.db".to_string();
cfg.port = 0;
let params = agent_connect_params(&cfg, "/tmp/app.mv.db", 0, "").unwrap();
assert_eq!(params["host"], "");
assert_eq!(params["port"], 0);
assert_eq!(params["database"], "file:/tmp/app;AUTO_SERVER=TRUE");
assert_eq!(params["connection_string"], "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
}
#[test]
fn h2_file_connection_normalizes_existing_jdbc_file_url_and_preserves_options() {
let mut cfg = config(DatabaseType::H2, None);
cfg.connection_string = Some("jdbc:h2:file:/tmp/app.mv.db;AUTO_SERVER=TRUE".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test").unwrap();
assert_eq!(params["host"], "");
assert_eq!(params["port"], 0);
assert_eq!(params["database"], "file:/tmp/app;AUTO_SERVER=TRUE");
assert_eq!(params["connection_string"], "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
}
#[test]
fn h2_split_connection_string_is_treated_as_file_mode() {
let mut cfg = config(DatabaseType::H2, None);
cfg.connection_string = Some("jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test").unwrap();
assert_eq!(
h2_file_path_from_jdbc_url(cfg.connection_string.as_deref().unwrap()).as_deref(),
Some("C:/dbx-test/h2/sample-db")
);
assert_eq!(params["host"], "");
assert_eq!(params["port"], 0);
assert_eq!(params["database"], "split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE");
assert_eq!(params["connection_string"], "jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE");
}
#[test]
fn h2_tcp_connection_keeps_empty_agent_connection_string() {
let mut cfg = config(DatabaseType::H2, Some("test"));
cfg.host = "127.0.0.1".to_string();
cfg.port = 9092;
let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test").unwrap();
assert_eq!(params["host"], "127.0.0.1");
assert_eq!(params["port"], 9092);
assert_eq!(params["database"], "test");
assert_eq!(params["connection_string"], "");
}
#[test]
fn h2_bundled_agent_connect_params_ignore_stale_custom_driver_config() {
for driver_profile in
[None, Some("h2"), Some("h2-auto"), Some("h2-legacy"), Some("h2-v1"), Some("h2-v2"), Some("h2-v3")]
{
let mut cfg = config(DatabaseType::H2, Some("test"));
cfg.driver_profile = driver_profile.map(str::to_string);
cfg.jdbc_driver_class = Some("h2_embedded".to_string());
cfg.jdbc_driver_paths = vec!["/tmp/stale-h2.jar".to_string()];
let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test").unwrap();
assert_eq!(params["jdbc_driver_class"], "");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!([]));
}
}
#[test]
fn h2_custom_agent_connect_params_preserve_external_driver_config() {
let mut cfg = config(DatabaseType::H2, Some("test"));
cfg.driver_profile = Some("h2-custom".to_string());
cfg.jdbc_driver_class = Some("org.h2.Driver".to_string());
cfg.jdbc_driver_paths = vec!["/tmp/h2-custom.jar".to_string(), "/tmp/h2-helper.jar".to_string()];
let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test").unwrap();
assert_eq!(params["driver_profile"], "h2-custom");
assert_eq!(params["jdbc_driver_class"], "org.h2.Driver");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!(["/tmp/h2-custom.jar", "/tmp/h2-helper.jar"]));
}
#[test]
fn vastbase_agent_url_defaults_to_postgres_database_when_empty() {
let cfg = config(DatabaseType::Vastbase, Some(""));
let params = agent_connect_params(&cfg, "vastbase.example.com", 5432, "").unwrap();
assert_eq!(params["database"], "postgres");
assert_eq!(params["connection_string"], "jdbc:vastbase://vastbase.example.com:5432/postgres");
}
#[test]
fn kingbase_agent_params_keep_legacy_postgres_default_when_database_is_empty() {
let cfg = config(DatabaseType::Kingbase, None);
let params = agent_connect_params(&cfg, "kingbase.example.com", 54321, "").unwrap();
assert_eq!(params["database"], "postgres");
assert_eq!(params["connection_string"], "jdbc:kingbase8://kingbase.example.com:54321/postgres");
}
#[test]
fn kingbase_agent_params_preserve_explicit_database() {
let cfg = config(DatabaseType::Kingbase, Some("application"));
let params = agent_connect_params(&cfg, "kingbase.example.com", 54321, "application").unwrap();
assert_eq!(params["database"], "application");
assert_eq!(params["connection_string"], "jdbc:kingbase8://kingbase.example.com:54321/application");
}
#[test]
fn legacy_postgres_like_database_prefers_postgres_then_kingbase() {
let databases = vec!["SAMPLES".to_string(), "kingbase".to_string(), "postgres".to_string()];
assert_eq!(pick_legacy_postgres_like_database(&databases).as_deref(), Some("postgres"));
let databases = vec!["SAMPLES".to_string(), "KingBase".to_string()];
assert_eq!(pick_legacy_postgres_like_database(&databases).as_deref(), Some("KingBase"));
let databases = vec!["security".to_string(), "test".to_string()];
assert_eq!(pick_legacy_postgres_like_database(&databases).as_deref(), Some("test"));
}
#[test]
fn legacy_postgres_like_database_skips_templates_and_blank_names() {
let databases =
vec![" ".to_string(), "TEMPLATE0".to_string(), "template1".to_string(), "dbx_demo".to_string()];
assert_eq!(pick_legacy_postgres_like_database(&databases).as_deref(), Some("dbx_demo"));
}
#[test]
fn legacy_postgres_like_database_falls_back_to_templates_then_none() {
let databases = vec!["template1".to_string(), "TEMPLATE0".to_string()];
assert_eq!(pick_legacy_postgres_like_database(&databases).as_deref(), Some("template1"));
assert_eq!(pick_legacy_postgres_like_database(&[]), None);
assert_eq!(pick_legacy_postgres_like_database(&["".to_string()]), None);
}
#[test]
fn uxdb_agent_params_use_vendor_jdbc_url() {
let cfg = config(DatabaseType::Uxdb, Some("uxdb"));
let params = agent_connect_params(&cfg, "uxdb.example.com", 52025, "uxdb").unwrap();
assert_eq!(params["database"], "uxdb");
assert_eq!(params["connection_string"], "jdbc:uxdb://uxdb.example.com:52025/uxdb");
}
#[test]
fn zookeeper_agent_params_preserve_configured_connect_string() {
let mut cfg = config(DatabaseType::ZooKeeper, None);
cfg.connection_string = Some("zk-1:2181,zk-2:2181/app".to_string());
cfg.connect_timeout_secs = 20;
let params = agent_connect_params(&cfg, "127.0.0.1", 2181, "").unwrap();
assert_eq!(params["connection_string"], "zk-1:2181,zk-2:2181/app");
assert_eq!(params["zookeeper_connect_string"], "zk-1:2181,zk-2:2181/app");
assert_eq!(params["connection_timeout_ms"], 20_000);
}
#[test]
fn agent_params_include_effective_connect_timeout_seconds() {
let mut cfg = config(DatabaseType::Mysql, Some("app"));
cfg.connect_timeout_secs = 45;
let params = agent_connect_params(&cfg, "mysql.example.com", 3306, "app").unwrap();
assert_eq!(params["connect_timeout_secs"], 45);
}
#[test]
fn zookeeper_agent_params_fall_back_to_host_port_connect_string() {
let cfg = config(DatabaseType::ZooKeeper, None);
let params = agent_connect_params(&cfg, "zk.local", 2281, "").unwrap();
assert_eq!(params["connection_string"], "");
assert_eq!(params["zookeeper_connect_string"], "zk.local:2281");
assert_eq!(params["connection_timeout_ms"], ZOOKEEPER_MIN_CONNECTION_TIMEOUT_MS);
}
#[test]
fn mongo_auth_hint_preserves_original_error() {
let err = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='admin'}";
let hinted = mongo_legacy_error_with_auth_hint(err);
assert!(hinted.starts_with(err));
assert!(hinted.contains("Current authentication database: admin"));
assert!(hinted.contains("The server rejected these credentials"));
assert!(!hinted.contains("add authSource=admin"));
}
#[test]
fn oracle_listener_error_adds_driver_version_hint_for_default_profile() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.driver_profile = Some("oracle".to_string());
let err = "Agent RPC error (-1): ORA-12541: TNS:no listener";
let hinted = oracle_error_with_driver_hint(&cfg, err);
assert!(hinted.starts_with(err));
assert!(hinted.contains("Service Name"));
assert!(hinted.contains("SID"));
}
#[test]
fn oracle_listener_error_hint_skips_non_oracle_databases() {
let err = "Agent RPC error (-1): ORA-12541: TNS:no listener";
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
assert!(oracle_error_with_driver_hint(&cfg, err).contains("Service Name"));
cfg.db_type = DatabaseType::OceanbaseOracle;
cfg.driver_profile = None;
assert_eq!(oracle_error_with_driver_hint(&cfg, err), err);
}
#[test]
fn oracle_url_uses_sid_or_service_name() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.oracle_connection_type = Some("sid".to_string());
let sid = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL").unwrap();
assert_eq!(sid["connection_string"], "jdbc:oracle:thin:@oracle.example.com:1521:ORCL");
cfg.oracle_connection_type = Some("service_name".to_string());
let service = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL").unwrap();
assert_eq!(service["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCL");
}
#[test]
fn oracle_tns_does_not_retry_with_host_based_descriptors() {
let mut cfg = config(DatabaseType::Oracle, Some("DBX_FAILOVER"));
cfg.oracle_connection_type = Some("tns".to_string());
cfg.connection_string =
Some("jdbc:oracle:thin:@DBX_FAILOVER?TNS_ADMIN=%2Fopt%2Foracle%2Fnetwork%2Fadmin".to_string());
assert!(oracle_alternate_connect_configs(
&cfg,
"ORA-12514: listener does not currently know of service requested"
)
.is_empty());
}
#[test]
fn oracle_sys_user_connects_as_sysdba_for_agent_protocol() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
cfg.username = "SYS".to_string();
cfg.oracle_connection_type = Some("service_name".to_string());
let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1").unwrap();
assert_eq!(params["database"], "SYSDBA:ORCLPDB1");
assert_eq!(params["sysdba"], true);
assert_eq!(params["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCLPDB1");
}
#[test]
fn oracle_sysdba_checkbox_connects_as_sysdba_for_agent_protocol() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
cfg.username = "system".to_string();
cfg.sysdba = true;
let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1").unwrap();
assert_eq!(params["database"], "SYSDBA:ORCLPDB1");
assert_eq!(params["sysdba"], true);
}
#[test]
fn oceanbase_oracle_uses_oceanbase_jdbc_connection_string_for_agent_protocol() {
let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
cfg.host = "oceanbase.example.com".to_string();
cfg.port = 2881;
let params = agent_connect_params(&cfg, "oceanbase.example.com", 2881, "sys").unwrap();
assert_eq!(params["database"], "sys");
assert_eq!(params["sysdba"], false);
assert_eq!(
params["connection_string"],
"jdbc:oceanbase://oceanbase.example.com:2881/sys?compatibleOjdbcVersion=8"
);
}
#[test]
fn oceanbase_oracle_jdbc_url_appends_params_and_rewrites_forwarded_host() {
let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
cfg.host = "oceanbase.example.com".to_string();
cfg.port = 2881;
cfg.url_params = Some("useSSL=false".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:oceanbase://127.0.0.1:12881/sys?useSSL=false&compatibleOjdbcVersion=8"
);
}
#[test]
fn oceanbase_oracle_jdbc_url_keeps_explicit_compatible_ojdbc_version() {
let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
cfg.host = "oceanbase.example.com".to_string();
cfg.port = 2881;
cfg.url_params = Some("compatibleOjdbcVersion=6&useSSL=false".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:oceanbase://127.0.0.1:12881/sys?compatibleOjdbcVersion=6&useSSL=false"
);
}
#[test]
fn oceanbase_oracle_custom_jdbc_url_gets_compatible_ojdbc_version_and_forwarded_host() {
let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
cfg.host = "oceanbase.example.com".to_string();
cfg.port = 2881;
cfg.connection_string = Some("jdbc:oceanbase://oceanbase.example.com:2881/sys?useSSL=false".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:oceanbase://127.0.0.1:12881/sys?useSSL=false&compatibleOjdbcVersion=8"
);
}
#[test]
fn oracle_url_preserves_custom_jdbc_descriptor_and_rewrites_host_port() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.host = "oracle.example.com".to_string();
cfg.port = 1521;
cfg.connection_string = Some(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=oracle.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
.to_string(),
);
let params = agent_connect_params(&cfg, "127.0.0.1", 11521, "ORCL").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=11521))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
);
}
#[test]
fn oracle_url_preserves_custom_jdbc_descriptor_without_forwarding() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.host = "form-host.example.com".to_string();
cfg.port = 1521;
cfg.connection_string = Some(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=descriptor-host.example.com)(PORT=1522))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
.to_string(),
);
let params = agent_connect_params(&cfg, "form-host.example.com", 1521, "ORCL").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=descriptor-host.example.com)(PORT=1522))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
);
}
#[test]
fn oracle_multi_address_descriptor_fails_closed_for_transport_endpoint() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.host = "oracle.example.com".to_string();
cfg.port = 1521;
cfg.connection_string = Some(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=db1.example.com)(PORT=1521))(ADDRESS=(PROTOCOL=TCP)(HOST=db2.example.com)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
.to_string(),
);
let err = agent_connect_params(&cfg, "127.0.0.1", 11521, "ORCL").unwrap_err();
assert!(err.contains("single ADDRESS entry"), "{err}");
}
#[test]
fn oracle_listener_errors_can_switch_descriptor() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.driver_profile = Some("oracle".to_string());
cfg.oracle_connection_type = Some("service_name".to_string());
let retry = oracle_alternate_connect_config(&cfg, "ORA-12514: listener does not know service").unwrap();
assert_eq!(retry.connection_string.as_deref(), Some("jdbc:oracle:thin:@127.0.0.1:3306:ORCL"));
assert!(oracle_alternate_connect_config(&retry, "ORA-01017: invalid username/password").is_none());
// ORA-12541 is TCP-level: the listener was never reached, so a descriptor
// spelling change cannot help and only opens more connections/dialogs.
assert!(oracle_alternate_connect_config(&cfg, "ORA-12541: TNS:no listener").is_none());
}
#[test]
fn oracle_custom_connection_string_skips_alternate_descriptor_retry() {
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.driver_profile = Some("oracle".to_string());
cfg.oracle_connection_type = Some("service_name".to_string());
cfg.connection_string = Some("jdbc:oracle:thin:@//oracle.example.com:1521/ORCL".to_string());
assert!(oracle_alternate_connect_config(&cfg, "ORA-12514: listener does not know service").is_none());
}
#[test]
fn oracle_no_listener_errors_do_not_fan_out_into_extra_connections() {
// ORA-12541 / "no listener" means host:port was never reached. Rewriting only
// the CONNECT_DATA spelling cannot fix reachability, and every alternate is a
// brand-new TCP connection — i.e. another authorization popup in front of an
// enterprise zero-trust/security client. One failure must stay one connection.
let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
cfg.host = "oracle.example.com".to_string();
cfg.port = 1521;
cfg.driver_profile = Some("oracle".to_string());
cfg.oracle_connection_type = Some("service_name".to_string());
assert!(oracle_alternate_connect_configs(&cfg, "ORA-12541: TNS:no listener").is_empty());
assert!(oracle_alternate_connect_configs(&cfg, "ORA-12541: TNS:no listener\n没有监听程序").is_empty());
assert!(oracle_alternate_connect_config(&cfg, "ORA-12541: TNS:no listener").is_none());
// The actionable hint survives, it just no longer auto-retries.
assert!(oracle_error_with_driver_hint(&cfg, "ORA-12541: TNS:no listener").contains("Service Name"));
// Listener-answered errors keep their single-purpose alternates: those arrive
// after a successful TCP handshake, so the descriptor really can be the fix.
let listener_answered = oracle_alternate_connect_configs(&cfg, "ORA-12514: no service");
assert_eq!(listener_answered.len(), 3);
}
#[test]
fn sap_hana_url_includes_selected_database_and_params() {
let mut cfg = config(DatabaseType::SapHana, Some("TENANT1"));
cfg.url_params = Some("encrypt=true".to_string());
let params = agent_connect_params(&cfg, "hana.example.com", 30013, "TENANT1").unwrap();
assert_eq!(params["connection_string"], "jdbc:sap://hana.example.com:30013/?databaseName=TENANT1&encrypt=true");
}
#[test]
fn sap_hana_agent_connect_params_normalizes_legacy_driver_class_aliases() {
for alias in ["sap_hana", "saphana"] {
let mut cfg = config(DatabaseType::SapHana, Some("TENANT1"));
cfg.jdbc_driver_class = Some(alias.to_string());
cfg.jdbc_driver_paths = vec!["/tmp/ngdbc.jar".to_string()];
let params = agent_connect_params(&cfg, "hana.example.com", 30013, "TENANT1").unwrap();
assert_eq!(params["jdbc_driver_class"], "");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!(["/tmp/ngdbc.jar"]));
}
}
#[test]
fn sap_hana_agent_connect_params_preserves_custom_driver_class() {
let mut cfg = config(DatabaseType::SapHana, Some("TENANT1"));
cfg.jdbc_driver_class = Some("com.example.CustomSapHanaDriver".to_string());
let params = agent_connect_params(&cfg, "hana.example.com", 30013, "TENANT1").unwrap();
assert_eq!(params["jdbc_driver_class"], "com.example.CustomSapHanaDriver");
}
#[test]
fn other_agent_connect_params_preserve_sap_hana_driver_alias() {
let mut cfg = config(DatabaseType::Mysql, Some("test"));
cfg.jdbc_driver_class = Some("sap_hana".to_string());
cfg.jdbc_driver_paths = vec!["/tmp/custom-driver.jar".to_string()];
let params = agent_connect_params(&cfg, "mysql.example.com", 3306, "test").unwrap();
assert_eq!(params["jdbc_driver_class"], "sap_hana");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!(["/tmp/custom-driver.jar"]));
}
#[test]
fn generic_jdbc_agent_connect_params_preserve_custom_driver_class() {
let mut cfg = config(DatabaseType::Jdbc, Some("test"));
cfg.jdbc_driver_class = Some("com.example.CustomDriver".to_string());
let params = agent_connect_params(&cfg, "jdbc.example.com", 1234, "test").unwrap();
assert_eq!(params["jdbc_driver_class"], "com.example.CustomDriver");
}
#[test]
fn transwarp_jdbc_url_follows_resolved_tunnel_endpoint() {
let mut cfg = config(DatabaseType::Transwarp, Some("analytics"));
cfg.host = "quark.example.com".to_string();
cfg.port = 10000;
cfg.connection_string = Some("jdbc:inceptor2://quark.example.com:10000/analytics;fetchSize=500".to_string());
cfg.jdbc_driver_class = Some("org.apache.hive.jdbc.HiveDriver".to_string());
cfg.jdbc_driver_paths = vec!["C:/drivers/inceptor-sdk.jar".to_string()];
let params = agent_connect_params(&cfg, "127.0.0.1", 18431, "analytics").unwrap();
assert_eq!(params["connection_string"], "jdbc:inceptor2://127.0.0.1:18431/analytics;fetchSize=500");
assert_eq!(params["jdbc_driver_class"], "org.apache.hive.jdbc.HiveDriver");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!(["C:/drivers/inceptor-sdk.jar"]));
}
#[test]
fn db2_agent_connect_params_ignore_driver_registry_ids() {
for registry_id in ["db2", "DB2", " db2 ", "db2_zos", "db2i"] {
let mut cfg = config(DatabaseType::Db2, Some("geofuy"));
cfg.jdbc_driver_class = Some(registry_id.to_string());
let params = agent_connect_params(&cfg, "db2.example.com", 50000, "geofuy").unwrap();
assert_eq!(params["jdbc_driver_class"], "", "registry id {registry_id:?} must be dropped");
}
}
#[test]
fn db2_agent_connect_params_preserve_custom_driver_class() {
let mut cfg = config(DatabaseType::Db2, Some("geofuy"));
cfg.jdbc_driver_class = Some("com.ibm.db2.jcc.DB2Driver".to_string());
let params = agent_connect_params(&cfg, "db2.example.com", 50000, "geofuy").unwrap();
assert_eq!(params["jdbc_driver_class"], "com.ibm.db2.jcc.DB2Driver");
}
#[test]
fn other_agent_connect_params_preserve_db2_driver_alias() {
let mut cfg = config(DatabaseType::Mysql, Some("test"));
cfg.jdbc_driver_class = Some("db2".to_string());
cfg.jdbc_driver_paths = vec!["/tmp/custom-driver.jar".to_string()];
let params = agent_connect_params(&cfg, "mysql.example.com", 3306, "test").unwrap();
assert_eq!(params["jdbc_driver_class"], "db2");
assert_eq!(params["jdbc_driver_paths"], serde_json::json!(["/tmp/custom-driver.jar"]));
}
#[test]
fn trino_agent_url_uses_jdbc_scheme_without_ssl_by_default() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.host = "trino.example.com".to_string();
cfg.port = 8080;
let params = agent_connect_params(&cfg, "trino.example.com", 8080, "hive").unwrap();
assert_eq!(params["connection_string"], "jdbc:trino://trino.example.com:8080/hive");
assert_eq!(params["ssl"], false);
}
#[test]
fn prestosql_jdbc_url_uses_presto_jdbc_scheme() {
let mut cfg = config(DatabaseType::PrestoSql, Some("hive/default"));
cfg.host = "presto.example.com".to_string();
cfg.port = 9090;
let params = agent_connect_params(&cfg, "presto.example.com", 9090, "hive/default").unwrap();
assert_eq!(params["connection_string"], "jdbc:presto://presto.example.com:9090/hive/default");
assert_eq!(params["ssl"], false);
}
#[test]
fn prestosql_custom_jdbc_url_rewrites_forwarded_host() {
let mut cfg = config(DatabaseType::PrestoSql, Some("hive/default"));
cfg.host = "presto.internal".to_string();
cfg.port = 9090;
cfg.connection_string = Some("jdbc:presto://presto.internal:9090/hive/default?source=dbx".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 19090, "hive/default").unwrap();
assert_eq!(params["connection_string"], "jdbc:presto://127.0.0.1:19090/hive/default?source=dbx");
}
#[test]
fn trino_agent_url_appends_ssl_when_enabled() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.ssl = true;
let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive").unwrap();
assert_eq!(params["connection_string"], "jdbc:trino://trino.example.com:8443/hive?SSL=true");
}
#[test]
fn trino_agent_url_preserves_ssl_verification_and_avoids_duplicate_ssl() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.ssl = true;
cfg.url_params = Some("ssl=true&SSLVerification=NONE".to_string());
let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:trino://trino.example.com:8443/hive?ssl=true&SSLVerification=NONE"
);
}
#[test]
fn trino_agent_url_preserves_tls_store_params() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.ssl = true;
cfg.url_params = Some(
"SSLTrustStorePath=C:\\certs\\trino.jks&SSLTrustStorePassword=secret&SSLKeyStorePath=C:\\certs\\client.jks"
.to_string(),
);
let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:trino://trino.example.com:8443/hive?SSLTrustStorePath=C:\\certs\\trino.jks&SSLTrustStorePassword=secret&SSLKeyStorePath=C:\\certs\\client.jks&SSL=true"
);
}
#[test]
fn trino_agent_url_uses_forwarded_host_and_port_with_params() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.host = "trino.internal".to_string();
cfg.port = 8443;
cfg.ssl = true;
cfg.url_params = Some("SSLVerification=NONE".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 15443, "hive").unwrap();
assert_eq!(params["connection_string"], "jdbc:trino://127.0.0.1:15443/hive?SSLVerification=NONE&SSL=true");
}
#[test]
fn trino_agent_custom_jdbc_url_rewrites_forwarded_host_and_preserves_query_ssl() {
let mut cfg = config(DatabaseType::Trino, Some("hive"));
cfg.host = "trino.internal".to_string();
cfg.port = 8443;
cfg.ssl = true;
cfg.connection_string = Some("jdbc:trino://trino.internal:8443/hive?SSL=true&source=dbx".to_string());
cfg.url_params = Some("SSLVerification=NONE".to_string());
let params = agent_connect_params(&cfg, "127.0.0.1", 15443, "hive").unwrap();
assert_eq!(
params["connection_string"],
"jdbc:trino://127.0.0.1:15443/hive?SSL=true&source=dbx&SSLVerification=NONE"
);
}
}