Merge pull request #1588 from luoianun/feat/prestosql-connector

feat: add PrestoSQL connector
This commit is contained in:
skyler authored and GitHub committed 2026-06-23 01:39:06 +08:00
commit 752a695018
41 files changed
+1347 -125

No files matched your search

+1 -1
View File
@@ -158,7 +158,7 @@ const AGENT_CATALOG: &[AgentCatalogEntry] = &[
AgentCatalogEntry {
db_type: DatabaseType::Trino,
key: "trino",
label: "Trino (Presto)",
label: "Trino",
store_visible: true,
profiles: &[],
},
+35 -6
View File
@@ -26,8 +26,8 @@ pub fn agent_connect_params(config: &ConnectionConfig, host: &str, port: u16, da
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 config.db_type == DatabaseType::Trino {
trino_agent_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::H2 {
h2_agent_jdbc_connection_string(config)
} else {
@@ -455,12 +455,17 @@ fn sap_hana_jdbc_connection_string(config: &ConnectionConfig, host: &str, port:
}
}
fn trino_agent_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
pub fn trino_like_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> 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(..11).is_some_and(|prefix| prefix.eq_ignore_ascii_case("jdbc:trino:")))
.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 {
connection_string.to_string()
@@ -471,9 +476,9 @@ fn trino_agent_jdbc_connection_string(config: &ConnectionConfig, host: &str, por
.unwrap_or_else(|| {
let database = database.trim();
if database.is_empty() {
format!("jdbc:trino://{host}:{port}")
format!("jdbc:{jdbc_scheme}://{host}:{port}")
} else {
format!("jdbc:trino://{host}:{port}/{database}")
format!("jdbc:{jdbc_scheme}://{host}:{port}/{database}")
}
});
@@ -906,6 +911,30 @@ mod tests {
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");
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");
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"));
+15
View File
@@ -164,3 +164,18 @@ async fn spawn_client_for_key(manager: &AgentManager, key: &str) -> Result<Agent
client.try_optional_handshake(manager.agent_app_version()).await;
Ok(client)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn prestosql_does_not_use_agent_driver() {
assert_eq!(runtime_agent_key_candidates(&DatabaseType::PrestoSql, None), None);
}
#[test]
fn trino_uses_only_trino_agent_driver() {
assert_eq!(runtime_agent_key_candidates(&DatabaseType::Trino, None).unwrap(), vec!["trino"]);
}
}
+9 -2
View File
@@ -186,7 +186,7 @@ pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) ->
let installed = am.is_driver_installed(key);
let requires_java_runtime = am.driver_requires_java_runtime(key);
let local = local_state.installed_drivers.get(key);
let remote = registry.and_then(|r| r.drivers.get(key));
let remote = registry.and_then(|r| agent_registry_driver(r, key));
let jre_key = remote
.map(|r| r.jre.clone())
.or_else(|| local.map(|l| l.jre.clone()))
@@ -485,7 +485,7 @@ async fn install_agent_driver_from_registry(
current: Option<u32>,
total_drivers: Option<u32>,
) -> Result<(), String> {
let Some(driver) = registry.drivers.get(db_type) else {
let Some(driver) = agent_registry_driver(registry, db_type) else {
if let Some(local_jar) = find_local_agent_jar(db_type) {
install_local_agent(am, db_type, local_jar)?;
am.stop_daemon_by_key(db_type).await;
@@ -593,6 +593,13 @@ async fn install_agent_driver_from_registry(
Ok(())
}
fn agent_registry_driver<'a>(
registry: &'a AgentRegistry,
db_type: &str,
) -> Option<&'a crate::agent_manager::DriverInfo> {
registry.drivers.get(db_type)
}
#[allow(clippy::too_many_arguments)]
async fn download_with_progress(
am: &AgentManager,
+97 -38
View File
@@ -12,7 +12,7 @@ use crate::agent_connection::{
agent_connect_params, h2_file_path_from_jdbc_url, is_h2_file_connection, mongo_legacy_error_with_auth_hint,
mongo_uses_legacy_driver, oracle_alternate_connect_config_labels, oracle_alternate_connect_configs,
oracle_auth_fallback_profiles, oracle_error_with_driver_hint, should_retry_mongo_with_legacy_driver,
should_retry_oracle_with_10g_driver,
should_retry_oracle_with_10g_driver, trino_like_jdbc_connection_string,
};
use crate::agent_manager::{JavaRuntimeMode, DEFAULT_JRE_KEY};
use crate::database_capabilities;
@@ -30,6 +30,7 @@ use crate::storage::Storage;
pub const JDBC_PLUGIN_NOT_INSTALLED: &str =
"JDBC plugin is not installed. Install the optional JDBC plugin to use this connection.";
pub const PRESTOSQL_JDBC_DRIVER_CLASS: &str = "io.prestosql.jdbc.PrestoDriver";
const DEFAULT_AGENT_CONNECT_TIMEOUT_SECS: u64 = 30;
const ACCESS_AGENT_CONNECT_TIMEOUT_SECS: u64 = 30;
const POOL_CLOSE_TIMEOUT_SECS: u64 = 5;
@@ -81,6 +82,44 @@ pub enum PoolKind {
MessageQueue,
}
macro_rules! agent_connection_pool_database_type {
() => {
DatabaseType::Dameng
| DatabaseType::Kingbase
| DatabaseType::Highgo
| DatabaseType::Vastbase
| DatabaseType::Goldendb
| DatabaseType::Databend
| DatabaseType::Yashandb
| DatabaseType::Databricks
| DatabaseType::SapHana
| DatabaseType::Teradata
| DatabaseType::Vertica
| DatabaseType::Firebird
| DatabaseType::Exasol
| DatabaseType::OceanbaseOracle
| DatabaseType::Gbase
| DatabaseType::Oracle
| DatabaseType::H2
| DatabaseType::Snowflake
| DatabaseType::Trino
| DatabaseType::Hive
| DatabaseType::Db2
| DatabaseType::Informix
| DatabaseType::Neo4j
| DatabaseType::Cassandra
| DatabaseType::Bigquery
| DatabaseType::Kylin
| DatabaseType::Sundb
| DatabaseType::Tdengine
| DatabaseType::Xugu
| DatabaseType::Iotdb
| DatabaseType::Etcd
| DatabaseType::Iris
| DatabaseType::Access
};
}
pub struct AppState {
pub connections: Arc<RwLock<HashMap<String, PoolKind>>>,
keepalive_tasks: Arc<RwLock<HashMap<String, JoinHandle<()>>>>,
@@ -151,6 +190,16 @@ pub fn database_connection_config(config: &ConnectionConfig, database: Option<&s
db_config
}
pub fn prestosql_jdbc_config_for_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> ConnectionConfig {
let mut jdbc_config = config.clone();
jdbc_config.connection_string =
Some(trino_like_jdbc_connection_string(config, host, port, config.effective_database().unwrap_or("")));
if jdbc_config.jdbc_driver_class.as_deref().is_none_or(|value| value.trim().is_empty()) {
jdbc_config.jdbc_driver_class = Some(PRESTOSQL_JDBC_DRIVER_CLASS.to_string());
}
jdbc_config
}
pub async fn connect_mysql_metadata_pool(
config: &ConnectionConfig,
db_config: &ConnectionConfig,
@@ -347,7 +396,7 @@ impl AppState {
Ok(PoolKind::ExternalDriver { driver_id: driver_id.to_string(), config: Arc::new(config.clone()), session })
}
fn external_driver_runtime_env(&self, driver_id: &str) -> Result<PluginRuntimeEnv, String> {
pub fn external_driver_runtime_env(&self, driver_id: &str) -> Result<PluginRuntimeEnv, String> {
if driver_id != "jdbc" {
return Ok(PluginRuntimeEnv::default());
}
@@ -732,39 +781,7 @@ impl AppState {
db::influxdb_driver::test_connection(&client, connect_timeout).await?;
PoolKind::InfluxDb(client)
}
DatabaseType::Dameng
| DatabaseType::Kingbase
| DatabaseType::Highgo
| DatabaseType::Vastbase
| DatabaseType::Goldendb
| DatabaseType::Databend
| DatabaseType::Yashandb
| DatabaseType::Databricks
| DatabaseType::SapHana
| DatabaseType::Teradata
| DatabaseType::Vertica
| DatabaseType::Firebird
| DatabaseType::Exasol
| DatabaseType::OceanbaseOracle
| DatabaseType::Gbase
| DatabaseType::Oracle
| DatabaseType::H2
| DatabaseType::Snowflake
| DatabaseType::Trino
| DatabaseType::Hive
| DatabaseType::Db2
| DatabaseType::Informix
| DatabaseType::Neo4j
| DatabaseType::Cassandra
| DatabaseType::Bigquery
| DatabaseType::Kylin
| DatabaseType::Sundb
| DatabaseType::Tdengine
| DatabaseType::Xugu
| DatabaseType::Iotdb
| DatabaseType::Etcd
| DatabaseType::Iris
| DatabaseType::Access => {
agent_connection_pool_database_type!() => {
let connect_params =
agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or(""));
let mut client =
@@ -865,6 +882,10 @@ impl AppState {
}
PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
}
DatabaseType::PrestoSql => {
let jdbc_config = prestosql_jdbc_config_for_endpoint(&db_config, &host, port);
self.external_driver_pool("jdbc", &jdbc_config).await?
}
DatabaseType::Jdbc => {
let mut jdbc_config = db_config.clone();
if host != config.host || port != config.port {
@@ -1986,6 +2007,11 @@ fn shares_database_pool_with_connection(db_type: &DatabaseType) -> bool {
matches!(db_type, DatabaseType::Oracle)
}
#[cfg(test)]
fn uses_agent_connection_pool(db_type: &DatabaseType) -> bool {
matches!(*db_type, agent_connection_pool_database_type!())
}
#[cfg(test)]
fn uses_bare_mysql_pool(db_type: &DatabaseType) -> bool {
matches!(db_type, DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch)
@@ -2177,8 +2203,9 @@ async fn detect_ob_oracle_mode(config: &ConnectionConfig, pool: &db::mysql::MySq
mod tests {
use super::{
agent_connect_timeout, connection_remote_endpoint, connection_url_for_endpoint, database_connection_config,
metadata_connection_config, mysql_metadata_fallback_url, redacted_connection_url_for_endpoint,
uses_bare_mysql_pool, uses_tcp_probe, validate_h2_database_path, AppState, PoolKind,
metadata_connection_config, mysql_metadata_fallback_url, prestosql_jdbc_config_for_endpoint,
redacted_connection_url_for_endpoint, uses_bare_mysql_pool, uses_tcp_probe, validate_h2_database_path,
AppState, PoolKind, PRESTOSQL_JDBC_DRIVER_CLASS,
};
use crate::agent_connection::{
agent_connect_params, mongo_legacy_error_with_auth_hint, mongo_uses_legacy_driver,
@@ -2264,6 +2291,32 @@ mod tests {
assert_eq!(agent_connect_timeout(&config).as_secs(), 45);
}
#[test]
fn prestosql_jdbc_config_sets_presto_url_and_driver_class() {
let mut config = mysql_config(Some("hive/default"));
config.db_type = DatabaseType::PrestoSql;
config.host = "presto.example.com".to_string();
config.port = 9090;
let jdbc_config = prestosql_jdbc_config_for_endpoint(&config, "127.0.0.1", 19090);
assert_eq!(jdbc_config.connection_string.as_deref(), Some("jdbc:presto://127.0.0.1:19090/hive/default"));
assert_eq!(jdbc_config.jdbc_driver_class.as_deref(), Some(PRESTOSQL_JDBC_DRIVER_CLASS));
}
#[test]
fn prestosql_jdbc_config_preserves_custom_driver_class_and_paths() {
let mut config = mysql_config(Some("hive"));
config.db_type = DatabaseType::PrestoSql;
config.jdbc_driver_class = Some("custom.PrestoDriver".to_string());
config.jdbc_driver_paths = vec!["D:\\software\\jar\\presto-jdbc-350.jar".to_string()];
let jdbc_config = prestosql_jdbc_config_for_endpoint(&config, "presto.example.com", 9090);
assert_eq!(jdbc_config.jdbc_driver_class.as_deref(), Some("custom.PrestoDriver"));
assert_eq!(jdbc_config.jdbc_driver_paths, vec!["D:\\software\\jar\\presto-jdbc-350.jar"]);
}
#[test]
fn agent_connect_params_include_url_params() {
let mut config = mysql_config(Some("testdb"));
@@ -2907,7 +2960,13 @@ mod tests {
}
#[test]
fn mysql_direct_connections_skip_tcp_probe() {
fn prestosql_uses_external_driver_pool_not_agent_pool() {
assert!(!super::uses_agent_connection_pool(&DatabaseType::PrestoSql));
assert!(super::uses_agent_connection_pool(&DatabaseType::Trino));
}
#[test]
fn mysql_hostname_connections_skip_tcp_probe() {
let mut config = mysql_config(Some("app"));
config.host = "mysql.example.com".to_string();
+207
View File
@@ -1,4 +1,5 @@
use crate::agent_service::AgentProgressEvent;
use crate::plugins::PluginRuntimeEnv;
use crate::plugins::{PluginManifest, SUPPORTED_PLUGIN_PROTOCOL_VERSION};
use crate::update::{fetch_latest_release, is_newer_version, JdbcPluginLatest};
use serde::{Deserialize, Serialize};
@@ -9,6 +10,11 @@ use tokio::process::Command;
const JDBC_PLUGIN_DOWNLOAD_URL: &str =
"https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip";
const JDBC_PLUGIN_R2_PATH: &str = "releases/latest/dbx-jdbc-plugin-latest.zip";
pub const PRESTOSQL_JDBC_DRIVER_VERSION: &str = "350";
pub const PRESTOSQL_JDBC_DRIVER_COORDINATE: &str = "io.prestosql:presto-jdbc:350";
pub const PRESTOSQL_JDBC_DRIVER_REPOSITORY: &str = "https://repo.maven.apache.org/maven2/";
const PRESTOSQL_JDBC_DRIVER_URL: &str =
"https://repo.maven.apache.org/maven2/io/prestosql/presto-jdbc/350/presto-jdbc-350.jar";
#[derive(Debug, Clone, Serialize)]
pub struct JdbcDriverInfo {
@@ -124,6 +130,7 @@ pub fn delete_jdbc_maven_bundle(plugins_root: &Path, bundle_id: &str) -> Result<
pub async fn install_jdbc_driver_from_maven(
plugins_root: &Path,
request: JdbcMavenInstallRequest,
env: PluginRuntimeEnv,
) -> Result<Vec<JdbcDriverInfo>, String> {
let coordinate = request.coordinate.trim().to_string();
if coordinate.is_empty() {
@@ -147,6 +154,7 @@ pub async fn install_jdbc_driver_from_maven(
std::fs::create_dir_all(&local_repo).map_err(|err| err.to_string())?;
let mut command = Command::new(&resolver);
env.apply_to(&mut command);
command.arg("resolve").arg("--coordinate").arg(&coordinate).arg("--local-repo").arg(&local_repo);
for repo in &repositories {
command.arg("--repo").arg(repo);
@@ -166,6 +174,51 @@ pub async fn install_jdbc_driver_from_maven(
list_jdbc_drivers(plugins_root)
}
pub async fn install_prestosql_jdbc_driver(plugins_root: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
let plugin_dir = plugins_root.join("jdbc");
let temp_dir = plugin_dir.join("downloads");
std::fs::create_dir_all(&temp_dir).map_err(|err| err.to_string())?;
let temp_file = temp_dir.join("presto-jdbc-350.jar.tmp");
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(300))
.build()
.map_err(|err| err.to_string())?;
let mut resp = client
.get(PRESTOSQL_JDBC_DRIVER_URL)
.header(reqwest::header::USER_AGENT, "dbx-prestosql-driver-installer")
.send()
.await
.and_then(|resp| resp.error_for_status())
.map_err(|err| format!("Failed to download PrestoSQL JDBC driver: {err}"))?;
let mut file = std::fs::File::create(&temp_file)
.map_err(|err| format!("Failed to create PrestoSQL JDBC driver temp file: {err}"))?;
while let Some(chunk) = resp.chunk().await.map_err(|err| format!("Download stream error: {err}"))? {
std::io::Write::write_all(&mut file, &chunk).map_err(|err| format!("Failed to write chunk: {err}"))?;
}
std::io::Write::flush(&mut file).map_err(|err| format!("Failed to flush temp file: {err}"))?;
drop(file);
let root = plugins_root.to_path_buf();
let repositories = vec![PRESTOSQL_JDBC_DRIVER_REPOSITORY.to_string()];
tokio::task::spawn_blocking(move || {
install_single_jdbc_maven_artifact(
&root,
PRESTOSQL_JDBC_DRIVER_COORDINATE,
"io.prestosql",
"presto-jdbc",
PRESTOSQL_JDBC_DRIVER_VERSION,
&temp_file,
&repositories,
)?;
let _ = std::fs::remove_file(&temp_file);
Ok::<(), String>(())
})
.await
.map_err(|err| err.to_string())??;
list_jdbc_drivers(plugins_root)
}
// ---- JDBC Plugin ----
pub async fn get_jdbc_plugin_status(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
@@ -595,6 +648,63 @@ fn install_jdbc_maven_bundle(
Ok(())
}
fn install_single_jdbc_maven_artifact(
plugins_root: &Path,
coordinate: &str,
group_id: &str,
artifact_id: &str,
version: &str,
source: &Path,
repositories: &[String],
) -> Result<(), String> {
if !source.exists() {
return Err(format!("Driver JAR does not exist: {}", source.display()));
}
let bundle_id = maven_bundle_id(coordinate);
let bundle_dir = jdbc_maven_drivers_dir(plugins_root).join(&bundle_id);
let temp_dir = bundle_dir.with_extension("tmp");
if temp_dir.exists() {
std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
}
std::fs::create_dir_all(temp_dir.join("jars")).map_err(|err| err.to_string())?;
let file_name = source
.file_name()
.and_then(|name| name.to_str())
.ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
let target = temp_dir.join("jars").join(file_name);
std::fs::copy(source, &target)
.map_err(|err| format!("Failed to copy {} to {}: {err}", source.display(), target.display()))?;
let metadata = std::fs::metadata(&target).map_err(|err| err.to_string())?;
let final_path = bundle_dir.join("jars").join(file_name);
let manifest = JdbcMavenBundleInfo {
id: bundle_id.clone(),
coordinate: coordinate.to_string(),
scope: "runtime".to_string(),
repositories: repositories.to_vec(),
installed_at: chrono::Utc::now().to_rfc3339(),
path: bundle_dir.to_string_lossy().to_string(),
artifacts: vec![JdbcMavenArtifactInfo {
group_id: group_id.to_string(),
artifact_id: artifact_id.to_string(),
version: version.to_string(),
classifier: String::new(),
extension: "jar".to_string(),
file_name: file_name.to_string(),
path: final_path.to_string_lossy().to_string(),
size: metadata.len(),
sha256: file_sha256(&target)?,
}],
};
let manifest_json = serde_json::to_string_pretty(&manifest).map_err(|err| err.to_string())?;
std::fs::write(temp_dir.join("manifest.json"), manifest_json).map_err(|err| err.to_string())?;
if bundle_dir.exists() {
std::fs::remove_dir_all(&bundle_dir).map_err(|err| err.to_string())?;
}
std::fs::rename(&temp_dir, &bundle_dir).map_err(|err| err.to_string())?;
Ok(())
}
fn maven_bundle_id(coordinate: &str) -> String {
let mut id = String::with_capacity(coordinate.len());
for ch in coordinate.trim().chars() {
@@ -661,6 +771,7 @@ pub fn unique_target_path(dir: &Path, file_name: &str) -> PathBuf {
#[cfg(test)]
mod tests {
use super::*;
use crate::plugins::PluginRuntimeEnv;
#[test]
fn maven_bundle_install_lists_nested_jars() {
@@ -706,4 +817,100 @@ mod tests {
assert!(is_safe_bundle_id("org.apache.hive_hive-jdbc_4.0.1_standalone"));
assert!(!is_safe_bundle_id("../hive"));
}
#[test]
fn installs_prestosql_direct_driver_as_builtin_bundle() {
let root = std::env::temp_dir().join(format!("dbx-prestosql-direct-driver-test-{}", uuid::Uuid::new_v4()));
let source_dir = root.join("source");
std::fs::create_dir_all(&source_dir).unwrap();
let source = source_dir.join("presto-jdbc-350.jar");
std::fs::write(&source, b"presto").unwrap();
install_single_jdbc_maven_artifact(
&root,
PRESTOSQL_JDBC_DRIVER_COORDINATE,
"io.prestosql",
"presto-jdbc",
PRESTOSQL_JDBC_DRIVER_VERSION,
&source,
&[PRESTOSQL_JDBC_DRIVER_REPOSITORY.to_string()],
)
.unwrap();
let bundles = list_jdbc_maven_bundles(&root).unwrap();
assert_eq!(bundles.len(), 1);
assert_eq!(bundles[0].id, "io.prestosql_presto-jdbc_350");
assert_eq!(bundles[0].coordinate, PRESTOSQL_JDBC_DRIVER_COORDINATE);
assert_eq!(bundles[0].artifacts[0].file_name, "presto-jdbc-350.jar");
let drivers = list_jdbc_drivers(&root).unwrap();
assert_eq!(drivers.len(), 1);
assert_eq!(drivers[0].bundle_id.as_deref(), Some("io.prestosql_presto-jdbc_350"));
let _ = std::fs::remove_dir_all(root);
}
#[tokio::test]
async fn maven_resolver_receives_runtime_env() {
let root = std::env::temp_dir().join(format!("dbx-jdbc-maven-env-test-{}", uuid::Uuid::new_v4()));
let plugin_dir = root.join("jdbc");
let bin_dir = plugin_dir.join("bin");
let source_dir = root.join("source");
std::fs::create_dir_all(&bin_dir).unwrap();
std::fs::create_dir_all(&source_dir).unwrap();
let source = source_dir.join("env-driver.jar");
std::fs::write(&source, b"jar").unwrap();
let output = serde_json::json!({
"coordinate": "com.example:env-driver:1.0.0",
"scope": "runtime",
"repositories": ["https://repo.maven.apache.org/maven2/"],
"artifacts": [{
"groupId": "com.example",
"artifactId": "env-driver",
"version": "1.0.0",
"classifier": "",
"extension": "jar",
"file": source.to_string_lossy(),
}],
})
.to_string();
let resolver = jdbc_maven_resolver_executable(&plugin_dir);
if cfg!(windows) {
std::fs::write(
&resolver,
format!(
"@echo off\r\nif \"%DBX_JAVA_BIN%\"==\"\" (\r\n echo missing DBX_JAVA_BIN 1>&2\r\n exit /b 2\r\n)\r\necho {output}\r\n"
),
)
.unwrap();
} else {
std::fs::write(
&resolver,
format!(
"#!/usr/bin/env sh\nif [ -z \"${{DBX_JAVA_BIN:-}}\" ]; then\n echo missing DBX_JAVA_BIN >&2\n exit 2\nfi\necho '{}'\n",
output.replace('\'', "'\\''")
),
)
.unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&resolver, std::fs::Permissions::from_mode(0o755)).unwrap();
}
}
let drivers = install_jdbc_driver_from_maven(
&root,
JdbcMavenInstallRequest { coordinate: "com.example:env-driver:1.0.0".to_string(), repositories: vec![] },
PluginRuntimeEnv::default().with_var("DBX_JAVA_BIN", "java-from-managed-jre"),
)
.await
.unwrap();
assert_eq!(drivers.len(), 1);
assert_eq!(drivers[0].name, "env-driver.jar");
let _ = std::fs::remove_dir_all(root);
}
}
+6
View File
@@ -290,6 +290,8 @@ pub enum DatabaseType {
H2,
Snowflake,
Trino,
#[serde(rename = "prestosql")]
PrestoSql,
Hive,
#[serde(rename = "db2")]
Db2,
@@ -762,6 +764,7 @@ impl ConnectionConfig {
DatabaseType::H2 => format!("h2://{host}:{port}{db_part}"),
DatabaseType::Snowflake => format!("snowflake://{host}/{db_part}"),
DatabaseType::Trino => format!("trino://{host}:{port}{db_part}"),
DatabaseType::PrestoSql => format!("prestosql://{host}:{port}{db_part}"),
DatabaseType::Hive => format!("hive://{host}:{port}{db_part}"),
DatabaseType::Db2 => format!("db2://{host}:{port}{db_part}"),
DatabaseType::Informix => format!("informix://{host}:{port}{db_part}"),
@@ -936,6 +939,9 @@ impl ConnectionConfig {
DatabaseType::Trino => {
format!("trino://{}:{}@{host}:{port}{db_part}", username, password)
}
DatabaseType::PrestoSql => {
format!("prestosql://{}:{}@{host}:{port}{db_part}", username, password)
}
DatabaseType::Hive => {
format!("hive://{}:{}@{host}:{port}{db_part}", username, password)
}
+1 -1
View File
@@ -66,7 +66,7 @@ impl PluginRuntimeEnv {
self.vars.iter().find_map(|(name, value)| (name == key).then_some(value.as_str()))
}
fn apply_to(&self, command: &mut Command) {
pub fn apply_to(&self, command: &mut Command) {
for (key, value) in &self.vars {
command.env(key, value);
}
+166 -1
View File
@@ -527,6 +527,11 @@ async fn list_tables_once(
let config = config.clone();
let session = session.clone();
drop(connections);
if uses_presto_like_information_schema_tables(&config.db_type) {
return external_driver_presto_like_tables(session, config.as_ref(), database, schema)
.await
.map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
}
return session
.invoke::<Vec<db::TableInfo>>(
"listTables",
@@ -750,11 +755,123 @@ fn normalize_table_info_object_type(value: &str) -> String {
"TABLE".to_string()
}
fn uses_presto_like_information_schema_tables(db_type: &DatabaseType) -> bool {
matches!(db_type, DatabaseType::PrestoSql | DatabaseType::Trino)
}
async fn external_driver_presto_like_tables(
session: Arc<crate::plugins::PluginDriverSession>,
config: &ConnectionConfig,
database: &str,
schema: &str,
) -> Result<Vec<db::TableInfo>, String> {
let result: db::QueryResult = session
.invoke(
"executeQuery",
serde_json::json!({
"connection": config,
"database": database,
"schema": schema,
"sql": presto_like_information_schema_tables_sql(database, schema),
"maxRows": 100000,
"fetchSize": 1000,
"timeoutSecs": 60
}),
)
.await?;
Ok(presto_like_tables_from_query_result(&result))
}
async fn external_driver_presto_like_objects(
session: Arc<crate::plugins::PluginDriverSession>,
config: &ConnectionConfig,
database: &str,
schema: &str,
) -> Result<Vec<db::ObjectInfo>, String> {
let tables = external_driver_presto_like_tables(session, config, database, schema).await?;
Ok(tables
.into_iter()
.map(|table| db::ObjectInfo {
name: table.name,
object_type: table.table_type,
schema: Some(schema.to_string()),
comment: table.comment,
created_at: None,
updated_at: None,
parent_schema: table.parent_schema,
parent_name: table.parent_name,
})
.collect())
}
fn presto_like_information_schema_tables_sql(database: &str, schema: &str) -> String {
let source = if database.trim().is_empty() {
"information_schema.tables".to_string()
} else {
format!("{}.information_schema.tables", quote_presto_like_identifier(database))
};
format!(
"SELECT table_name, CASE table_type WHEN 'BASE TABLE' THEN 'TABLE' ELSE table_type END AS table_type \
FROM {source} \
WHERE table_schema = {} AND table_type IN ('BASE TABLE', 'VIEW') \
ORDER BY table_type, table_name",
sql_string_literal(schema)
)
}
fn presto_like_tables_from_query_result(result: &db::QueryResult) -> Vec<db::TableInfo> {
result
.rows
.iter()
.filter_map(|row| {
let name = query_result_cell_string(row, 0)?;
if name.trim().is_empty() {
return None;
}
Some(db::TableInfo {
name,
table_type: normalize_information_schema_table_type(
query_result_cell_string(row, 1).as_deref().unwrap_or("TABLE"),
),
comment: None,
parent_schema: None,
parent_name: None,
})
})
.collect()
}
fn query_result_cell_string(row: &[serde_json::Value], index: usize) -> Option<String> {
let value = row.get(index)?;
if value.is_null() {
return None;
}
value.as_str().map(ToString::to_string).or_else(|| Some(value.to_string()))
}
fn normalize_information_schema_table_type(table_type: &str) -> String {
match table_type.trim().to_ascii_uppercase().replace(' ', "_").as_str() {
"BASE_TABLE" => "TABLE".to_string(),
"VIEW" => "VIEW".to_string(),
"MATERIALIZED_VIEW" => "MATERIALIZED_VIEW".to_string(),
_ => table_type.to_string(),
}
}
fn quote_presto_like_identifier(identifier: &str) -> String {
format!("\"{}\"", identifier.replace('"', "\"\""))
}
fn sql_string_literal(value: &str) -> String {
format!("'{}'", value.replace('\'', "''"))
}
#[cfg(test)]
mod tests {
use super::{
clickhouse_metadata_database, deduplicate_column_infos, filter_mysql_system_databases_for_config,
filter_table_infos, is_agent_postgres_metadata_fallback_config,
filter_table_infos, is_agent_postgres_metadata_fallback_config, normalize_information_schema_table_type,
presto_like_information_schema_tables_sql, presto_like_tables_from_query_result,
};
#[cfg(feature = "duckdb-bundled")]
use super::{duckdb_attach_database, duckdb_list_databases, duckdb_query_tables_in_database};
@@ -922,6 +1039,51 @@ mod tests {
assert_eq!(filtered[0].name, "active_users");
}
#[test]
fn presto_like_information_schema_sql_uses_catalog_and_schema_without_system_jdbc() {
let sql = presto_like_information_schema_tables_sql("hive", "sales_analytics");
assert_eq!(
sql,
"SELECT table_name, CASE table_type WHEN 'BASE TABLE' THEN 'TABLE' ELSE table_type END AS table_type FROM \"hive\".information_schema.tables WHERE table_schema = 'sales_analytics' AND table_type IN ('BASE TABLE', 'VIEW') ORDER BY table_type, table_name"
);
assert!(!sql.contains("system.jdbc.tables"));
}
#[test]
fn presto_like_information_schema_sql_escapes_identifiers_and_literals() {
let sql = presto_like_information_schema_tables_sql("hi\"ve", "sales'analytics");
assert!(sql.contains("\"hi\"\"ve\".information_schema.tables"));
assert!(sql.contains("table_schema = 'sales''analytics'"));
}
#[test]
fn presto_like_tables_from_query_result_normalizes_base_table_type() {
let result = super::db::QueryResult {
columns: vec!["table_name".to_string(), "table_type".to_string()],
column_types: vec![],
column_sortables: vec![],
rows: vec![
vec![serde_json::json!("daily_revenue"), serde_json::json!("BASE TABLE")],
vec![serde_json::json!("revenue_view"), serde_json::json!("VIEW")],
],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
session_id: None,
has_more: false,
};
let tables = presto_like_tables_from_query_result(&result);
assert_eq!(tables[0].name, "daily_revenue");
assert_eq!(tables[0].table_type, "TABLE");
assert_eq!(tables[1].name, "revenue_view");
assert_eq!(tables[1].table_type, "VIEW");
assert_eq!(normalize_information_schema_table_type("MATERIALIZED VIEW"), "MATERIALIZED_VIEW");
}
#[cfg(feature = "duckdb-bundled")]
#[test]
fn duckdb_list_databases_includes_attached_database() {
@@ -1109,6 +1271,9 @@ async fn list_objects_once(
let config = config.clone();
let session = session.clone();
drop(connections);
if uses_presto_like_information_schema_tables(&config.db_type) {
return external_driver_presto_like_objects(session, config.as_ref(), database, schema).await;
}
return session
.invoke::<Vec<db::ObjectInfo>>(
"listObjects",
@@ -48,6 +48,7 @@ pub fn is_schema_aware(database_type: DatabaseType) -> bool {
| DatabaseType::H2
| DatabaseType::Snowflake
| DatabaseType::Trino
| DatabaseType::PrestoSql
| DatabaseType::Hive
| DatabaseType::Db2
| DatabaseType::Tdengine