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
fix(jdbc): bind PostgreSQL pools to the requested database
t8y2c3522b087986
diff --git a/crates/dbx-core/src/connection/mod.rs b/crates/dbx-core/src/connection/mod.rsindex 13d805600f..1e1329f93e 100644--- a/crates/dbx-core/src/connection/mod.rs+++ b/crates/dbx-core/src/connection/mod.rs@@ -1478,14 +1478,13 @@ impl AppState {}?;let pool_database = metadata_pool_database(Some(&config), database);let mut base_pool_keys =- vec![base_pool_key_for_with_catalog(Some(config.db_type), connection_id, pool_database, None, false)];+ vec![base_pool_key_for_config(Some(&config), connection_id, pool_database, None, false)];// MongoDB document operations use a connection-level pool and send the// requested database in the command. A host connection can therefore// legitimately be registered either under the selected database or// under the connection-level key; probe both without creating either.if config.db_type == DatabaseType::MongoDb {- let connection_pool_key =- base_pool_key_for_with_catalog(Some(config.db_type), connection_id, None, None, false);+ let connection_pool_key = base_pool_key_for_config(Some(&config), connection_id, None, None, false);if !base_pool_keys.contains(&connection_pool_key) {base_pool_keys.push(connection_pool_key);}@@ -2657,11 +2656,10 @@ impl AppState {configs.get(connection_id).ok_or("Connection config not found")?.clone()};validate_connection_url_params(&config)?;- let db_type = Some(config.db_type);let validate_existing_pool = should_validate_existing_pool_before_reuse(config.db_type);let catalog = catalog.map(str::trim).filter(|value| !value.is_empty());- let base_pool_key = base_pool_key_for_with_catalog(db_type, connection_id, database, catalog, false);+ let base_pool_key = base_pool_key_for_config(Some(&config), connection_id, database, catalog, false);let pool_key = pool_key_for_session_role(Some(&config), base_pool_key.clone(), client_session_id, session_role);loop {@@ -4678,14 +4676,13 @@ impl AppState {let configs = self.configs.read().await;configs.get(connection_id).cloned()};- let db_type = config.as_ref().map(|config| config.db_type);let catalog = catalog.map(str::trim).filter(|value| !value.is_empty());let pool_database = if session_role == AgentSessionRole::Metadata {metadata_pool_database(config.as_ref(), database)} else {database};- let base_pool_key = base_pool_key_for_with_catalog(db_type, connection_id, pool_database, catalog, true);+ let base_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, pool_database, catalog, true);let pool_key = pool_key_for_session_role(config.as_ref(), base_pool_key, client_session_id, session_role);if self.uses_forwarded_transport(connection_id).await {self.remove_connection_pools(connection_id).await;@@ -4788,13 +4785,12 @@ impl AppState {let configs = self.configs.read().await;configs.get(connection_id).cloned()};- let db_type = config.as_ref().map(|config| config.db_type);let pool_database = if session_role == AgentSessionRole::Metadata {metadata_pool_database(config.as_ref(), database)} else {database};- let base_pool_key = base_pool_key_for(db_type, connection_id, pool_database, false);+ let base_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, pool_database, None, false);let pool_key =pool_key_for_session_role(config.as_ref(), base_pool_key.clone(), Some(client_session_id), session_role);if pool_key == base_pool_key {@@ -4832,9 +4828,8 @@ impl AppState {let configs = self.configs.read().await;configs.get(connection_id).cloned()};- let db_type = config.as_ref().map(|config| config.db_type);let pool_database = metadata_pool_database(config.as_ref(), database);- let base_pool_key = base_pool_key_for(db_type, connection_id, pool_database, false);+ let base_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, pool_database, None, false);let pool_key =pool_key_for_session_role(config.as_ref(), base_pool_key, client_session_id, AgentSessionRole::Metadata);self.detach_pool_by_key(&pool_key, true).await@@ -4852,9 +4847,8 @@ impl AppState {let configs = self.configs.read().await;configs.get(connection_id).cloned()};- let db_type = config.as_ref().map(|config| config.db_type);let pool_database = metadata_pool_database(config.as_ref(), database);- let base_pool_key = base_pool_key_for(db_type, connection_id, pool_database, false);+ let base_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, pool_database, None, false);let pool_key =pool_key_for_session_role(config.as_ref(), base_pool_key, client_session_id, AgentSessionRole::Metadata);if let Some(session_id) = agent_session_id {@@ -4903,8 +4897,7 @@ impl AppState {let configs = self.configs.read().await;configs.get(connection_id).cloned()};- let db_type = config.as_ref().map(|config| config.db_type);- let base_pool_key = base_pool_key_for(db_type, connection_id, database, false);+ let base_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, database, None, false);let pool_key = pool_key_for_session_role(config.as_ref(), base_pool_key.clone(), Some(&session), session_role);if pool_key == base_pool_key {return Ok(None);@@ -5059,19 +5052,24 @@ impl AppState {}pub async fn close_database_pool(&self, connection_id: &str, database: Option<&str>) -> Result<bool, String> {- let (db_type, default_database) = {+ let config = {let configs = self.configs.read().await;- configs- .get(connection_id)- .map_or((None, None), |config| (Some(config.db_type), config.effective_database().map(str::to_string)))+ configs.get(connection_id).cloned()};+ let db_type = config.as_ref().map(|config| config.db_type);+ let default_database = config.as_ref().and_then(|config| config.effective_database());if database.is_some() && db_type.is_some_and(|db_type| shares_database_pool_with_connection(&db_type)) {return Ok(false);}- let target_database = database.map(str::trim).filter(|database| !database.is_empty());- let mut base_pool_keys = vec![base_pool_key_for(db_type, connection_id, target_database, false)];- if target_database.is_some() && target_database == default_database.as_deref() {- let connection_pool_key = base_pool_key_for(db_type, connection_id, None, false);+ let target_database = if config.as_ref().is_some_and(is_postgres_jdbc) {+ database.filter(|database| !database.trim().is_empty())+ } else {+ database.map(str::trim).filter(|database| !database.is_empty())+ };+ let mut base_pool_keys =+ vec![base_pool_key_for_config(config.as_ref(), connection_id, target_database, None, false)];+ if target_database.is_some() && target_database == default_database {+ let connection_pool_key = base_pool_key_for_config(config.as_ref(), connection_id, None, None, false);if !base_pool_keys.contains(&connection_pool_key) {base_pool_keys.push(connection_pool_key);}@@ -6473,9 +6471,17 @@ fn is_embedded_h2_jdbc(config: &ConnectionConfig) -> bool {&& !location.is_empty()}+fn is_postgres_jdbc(config: &ConnectionConfig) -> bool {+ config.db_type == DatabaseType::Jdbc+ && config.connection_string.as_deref().is_some_and(|url| url.trim().starts_with("jdbc:postgresql:"))+}+#[cfg(all(test, unix))]mod h2_jdbc_tests;+#[cfg(all(test, unix))]+mod postgres_jdbc_tests;+pub fn task_client_session_id(task_kind: &str, task_id: &str) -> String {format!("{task_kind}:{task_id}")}@@ -6668,7 +6674,9 @@ fn pool_key_for_session_role(let pool_key = session_scoped_pool_key_for(config, base_pool_key, client_session_id);if session_role == AgentSessionRole::Metadata&& config.is_some_and(|config| {- database_capabilities::is_agent_type(&config.db_type) || sqlserver_uses_legacy_driver(config)+ database_capabilities::is_agent_type(&config.db_type)+ || sqlserver_uses_legacy_driver(config)+ || is_postgres_jdbc(config)}){// The legacy SQL Server Agent borrows one connection-level pool for metadata across@@ -6841,6 +6849,35 @@ fn extract_auth_token_from_params(params: &str) -> Option<String> {.map(|(_, value)| value.trim().to_string())}+fn base_pool_key_for_config(+ config: Option<&ConnectionConfig>,+ connection_id: &str,+ database: Option<&str>,+ catalog: Option<&str>,+ include_elasticsearch_single_pool: bool,+) -> String {+ if config.is_some_and(is_postgres_jdbc) {+ let key = match database.filter(|database| !database.trim().is_empty()) {+ Some(database) => format!(+ "{connection_id}:database:{}",+ percent_encoding::utf8_percent_encode(database, percent_encoding::NON_ALPHANUMERIC)+ ),+ None => connection_id.to_string(),+ };+ return match catalog.map(str::trim).filter(|catalog| !catalog.is_empty()) {+ Some(catalog) => format!("{key}:catalog:{catalog}"),+ None => key,+ };+ }+ base_pool_key_for_with_catalog(+ config.map(|config| config.db_type),+ connection_id,+ database,+ catalog,+ include_elasticsearch_single_pool,+ )+}+fn base_pool_key_for(db_type: Option<DatabaseType>,connection_id: &str,diff --git a/crates/dbx-core/src/connection/postgres_jdbc_tests.rs b/crates/dbx-core/src/connection/postgres_jdbc_tests.rsnew file mode 100644index 0000000000..a9095ad660--- /dev/null+++ b/crates/dbx-core/src/connection/postgres_jdbc_tests.rs@@ -0,0 +1,158 @@+use super::*;++fn config(url: &str) -> ConnectionConfig {+ let mut config = super::tests::mysql_config(None);+ config.db_type = DatabaseType::Jdbc;+ config.connection_string = Some(url.into());+ config.jdbc_driver_class = Some("org.postgresql.Driver".into());+ config+}++#[test]+fn postgres_jdbc_pool_keys_preserve_database_role_and_session_identity() {+ let config = config("jdbc:postgresql://localhost/a?sslmode=require");+ let key = |database, session, role| {+ pool_key_for_session_role(+ Some(&config),+ base_pool_key_for_config(Some(&config), "conn", database, None, false),+ session,+ role,+ )+ };+ let mut keys = std::collections::HashSet::new();+ for database in [None, Some("a"), Some("b"), Some(" a"), Some("a "), Some("a:session:x")] {+ for session in [None, Some("tab-a"), Some("tab-b")] {+ for role in [AgentSessionRole::Metadata, AgentSessionRole::Workload] {+ assert!(keys.insert(key(database, session, role)));+ }+ }+ }+ assert_eq!(key(Some("a:session:x"), None, AgentSessionRole::Workload), "conn:database:a%3Asession%3Ax");+ assert_eq!(key(Some(""), None, AgentSessionRole::Workload), "conn");+}++#[test]+fn postgres_jdbc_routing_scope_keeps_other_vendor_pool_defaults() {+ for url in [+ "jdbc:h2:file:./sample",+ "jdbc:h2:tcp://localhost/sample",+ "jdbc:h2:mem:sample",+ "jdbc:hive2://localhost/default",+ "jdbc:kingbase8://localhost/a",+ "jdbc:postgresqlx://localhost/a",+ ] {+ let config = config(url);+ assert!(!is_postgres_jdbc(&config));+ assert_eq!(base_pool_key_for_config(Some(&config), "conn", Some("b"), None, false), "conn");+ }+ let config = config("jdbc:postgresql://localhost/a");+ let target = database_connection_config(&config, Some(" b "));+ assert_eq!(target.database.as_deref(), Some(" b "));+ assert_eq!(target.connection_string, config.connection_string);+ assert_eq!(database_connection_config(&config, None).database, None);+}++async fn fixture() -> (AppState, std::path::PathBuf) {+ use std::os::unix::fs::PermissionsExt;+ let (mut state, directory) = super::tests::test_app_state().await;+ let plugin = directory.join("plugins/jdbc");+ std::fs::create_dir_all(&plugin).unwrap();+ let script = plugin.join("driver.py");+ std::fs::write(+ &script,+ r#"#!/usr/bin/python3+import json, os, sys+database = None+for line in sys.stdin:+ request = json.loads(line)+ method, params = request['method'], request.get('params', {})+ response = {'id': request['id']}+ result = {'pid': os.getpid(), 'database': database}+ if method == 'connect':+ database = params['connection'].get('database') or 'url_default'+ if database in ('missing', 'denied'):+ response['error'] = {'message': 'target database unavailable'}+ elif method == 'listSchemas':+ result = [database + '_only', 'public']+ response.setdefault('result', result)+ print(json.dumps(response), flush=True)+ if method == 'close':+ break+"#,+ )+ .unwrap();+ std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();+ std::fs::write(+ plugin.join("manifest.json"),+ serde_json::json!({+ "id": "jdbc", "name": "JDBC", "version": "0.1.41", "protocol_version": 1,+ "executable": "driver.py", "drivers": [{"id": "jdbc", "label": "JDBC", "kind": "external", "database_type": "jdbc"}]+ }).to_string(),+ ).unwrap();+ state.plugins = PluginRegistry::new_with_app_version(directory.join("plugins"), "0.6.30");+ state.configs.write().await.insert("conn".into(), config("jdbc:postgresql://localhost/a"));+ (state, directory)+}++async fn identity(state: &AppState, key: &str) -> serde_json::Value {+ let PoolKind::ExternalDriver { session, .. } = state.pool_handle(key).await.unwrap() else { panic!() };+ session.invoke("identity", serde_json::json!({})).await.unwrap()+}++#[tokio::test]+async fn postgres_jdbc_owning_entries_route_metadata_cache_hits_and_failures() {+ let (state, directory) = fixture().await;+ let mut owners = HashMap::new();+ for database in ["a", "b", "a"] {+ assert_eq!(+ crate::schema::list_schemas_core(&state, "conn", database).await.unwrap(),+ vec![format!("{database}_only"), "public".into()]+ );+ let key = state.get_or_create_metadata_pool_for_session("conn", Some(database), None).await.unwrap();+ let current = identity(&state, &key).await;+ assert_eq!(current["database"], database);+ if let Some(original) = owners.insert(database, current.clone()) {+ assert_eq!(original, current);+ }+ assert_eq!(state.existing_metadata_pool_key_for_session("conn", Some(database), None).await, Some(key));+ }+ assert_ne!(owners["a"]["pid"], owners["b"]["pid"]);+ for database in ["missing", "denied"] {+ assert!(state.get_or_create_metadata_pool_for_session("conn", Some(database), None).await.is_err());+ assert_eq!(state.existing_metadata_pool_key_for_session("conn", Some(database), None).await, None);+ }+ let database_a_pool = state.get_or_create_metadata_pool_for_session("conn", Some("a"), None).await.unwrap();+ assert_eq!(identity(&state, &database_a_pool).await, owners["a"]);+ assert!(state.close_database_pool("conn", Some("b")).await.unwrap());+ assert_eq!(identity(&state, &database_a_pool).await, owners["a"]);+ assert_eq!(state.existing_metadata_pool_key_for_session("conn", Some("b"), None).await, None);+ state.shutdown(Duration::from_secs(5)).await;+ std::fs::remove_dir_all(directory).unwrap();+}++#[tokio::test]+async fn postgres_jdbc_owning_entries_separate_concurrent_roles_sessions_and_cleanup() {+ let (state, directory) = fixture().await;+ let (metadata, workload, other_database, other_tab) = tokio::join!(+ state.get_or_create_metadata_pool_for_session("conn", Some("a"), Some("tab")),+ state.get_or_create_pool_for_session("conn", Some("a"), Some("tab")),+ state.get_or_create_pool_for_session("conn", Some("b"), Some("tab")),+ state.get_or_create_pool_for_session("conn", Some("a"), Some("other")),+ );+ let keys = [metadata.unwrap(), workload.unwrap(), other_database.unwrap(), other_tab.unwrap()];+ let mut pids = std::collections::HashSet::new();+ for key in &keys {+ assert!(pids.insert(identity(&state, key).await["pid"].as_i64().unwrap()));+ }+ assert!(state.close_metadata_session_pool("conn", Some("a"), "tab").await.unwrap());+ assert!(state.pool_handle(&keys[0]).await.is_none());+ assert!(state.detach_client_session_pool("conn", Some("a"), "tab").await.unwrap());+ assert!(state.pool_handle(&keys[1]).await.is_none());+ assert_eq!(identity(&state, &keys[2]).await["database"], "b");+ assert_eq!(identity(&state, &keys[3]).await["database"], "a");+ assert!(!state.detach_metadata_pool_after_recovery("conn", Some("b"), None, None, false).await);+ let default = state.get_or_create_pool("conn", None).await.unwrap();+ assert_eq!(identity(&state, &default).await["database"], "url_default");+ state.shutdown(Duration::from_secs(5)).await;+ std::fs::remove_dir_all(directory).unwrap();+}diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.javaindex 48fa2e9a47..0cd2ca1b93 100644--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java@@ -393,7 +393,8 @@ public final class DbxJdbcPlugin {registerDrivers(connection);return handle(method, params, connection);} catch (Exception | LinkageError error) {- if ("connect".equals(method)) {+ if ("connect".equals(method)+ && (state.sharedConnection == null || !isPostgresJdbcUrl(optionalText(connection, "connection_string")))) {closeSharedConnection();state.closing = true;LOGICAL_SESSIONS.remove(id, state);@@ -527,6 +528,15 @@ public final class DbxJdbcPlugin {}private static JsonNode handle(String method, JsonNode params, JsonNode connection) throws Exception {+ String database = optionalText(params, "database");+ if (isPostgresJdbcUrl(optionalText(connection, "connection_string"))) {+ database = postgresDatabase(params);+ if (database != null) {+ ObjectNode targeted = connection.deepCopy();+ targeted.put("database", database);+ connection = targeted;+ }+ }return switch (method) {case "testConnection" -> connectionTestResult(openConnection(connection));case "connect" -> {@@ -539,7 +549,7 @@ public final class DbxJdbcPlugin {case "executeQuery" -> executeQuery(connection,requireText(params, "sql"),- optionalText(params, "database"),+ database,optionalText(params, "schema"),positiveInt(params, "maxRows", MAX_ROWS),nonNegativeInt(params, "fetchSize", 0),@@ -548,13 +558,13 @@ public final class DbxJdbcPlugin {);case "beginManualTransaction", "begin_manual_transaction" -> beginManualTransaction(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"));case "executeInManualTransaction", "execute_in_manual_transaction" -> executeInManualTransaction(connection,requireText(params, "sql"),- optionalText(params, "database"),+ database,optionalText(params, "schema"),positiveInt(params, "maxRows", MAX_ROWS),nonNegativeInt(params, "fetchSize", 0),@@ -566,7 +576,7 @@ public final class DbxJdbcPlugin {case "executeQueryPage", "execute_query_page" -> executeQueryPage(connection,requireText(params, "sql"),- optionalText(params, "database"),+ database,optionalText(params, "schema"),positiveInt(params, "pageSize", 100),positiveInt(params, "maxRows", MAX_ROWS),@@ -579,10 +589,10 @@ public final class DbxJdbcPlugin {);case "closeQuerySession", "close_query_session" -> closeQuerySessionResult(requireText(params, "sessionId"));case "listDatabases" -> listDatabases(connection);- case "listSchemas" -> listSchemas(connection, optionalText(params, "database"));+ case "listSchemas" -> listSchemas(connection, database);case "listTables" -> listTables(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"),optionalText(params, "filter"),nonNegativeInt(params, "limit", 0),@@ -591,7 +601,7 @@ public final class DbxJdbcPlugin {);case "listObjects", "list_objects" -> listObjects(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"),optionalText(params, "filter"),nonNegativeInt(params, "limit", 0),@@ -600,28 +610,28 @@ public final class DbxJdbcPlugin {);case "listIndexes", "list_indexes" -> listIndexes(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"),requireText(params, "table"));- case "listDataTypes", "list_data_types" -> listDataTypes(connection, optionalText(params, "database"));+ case "listDataTypes", "list_data_types" -> listDataTypes(connection, database);case "getObjectSource", "get_object_source" -> getObjectSource(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"),requireText(params, "name"),requireText(params, "object_type"));case "getColumns" -> getColumns(connection,- optionalText(params, "database"),+ database,optionalText(params, "schema"),requireText(params, "table"));case "getExplainInfo" -> getExplainInfo(connection,requireText(params, "sql"),- optionalText(params, "database"),+ database,optionalText(params, "schema"),nonNegativeInt(params, "timeoutSecs", -1),optionalText(params, "mode")@@ -807,7 +817,12 @@ public final class DbxJdbcPlugin {configureOrdinaryAutoCommit(state.sharedConnection);return state.sharedConnection;}- closeSharedConnection();+ boolean postgres = isPostgresJdbcUrl(url);+ if (postgres && state.sharedConnection != null+ && (state.manualTransactionActive || hasActiveQuerySession(state.sharedConnection))) {+ throw new SQLException("Cannot change PostgreSQL database while a transaction or query session is active");+ }+ if (!postgres) closeSharedConnection();JdbcUrlCredentials urlCredentials = extractJdbcUrlCredentials(url);url = urlCredentials.url;@@ -835,7 +850,21 @@ public final class DbxJdbcPlugin {// Prefer the explicitly registered driver. DriverManager.getConnection only catches// SQLException; Hive/Inceptor drivers may throw UnsupportedOperationException for optional// methods, which aborts connect before the intended driver is reached.- state.sharedConnection = connectWithRegisteredDriver(url, properties);+ Connection opened = connectWithRegisteredDriver(url, properties);+ if (postgres) {+ try {+ configureOrdinaryAutoCommit(opened);+ } catch (SQLException | RuntimeException | Error error) {+ try {+ opened.close();+ } catch (SQLException closeError) {+ error.addSuppressed(closeError);+ }+ throw error;+ }+ closeSharedConnection();+ }+ state.sharedConnection = opened;state.sharedConnectionKey = key;configureOrdinaryAutoCommit(state.sharedConnection);return state.sharedConnection;@@ -3692,6 +3721,7 @@ public final class DbxJdbcPlugin {private static String connectionKey(JsonNode connection) {String connectionString = optionalText(connection, "connection_string");+ if (isPostgresJdbcUrl(connectionString)) connectionString = jdbcUrl(connection);String jdbcxSecurityKey = isJdbcxUrl(connectionString)? "|jdbcxHighPrivilegeExtensions=" + jdbcxHighPrivilegeExtensionsEnabled(connection): "";@@ -3739,9 +3769,53 @@ public final class DbxJdbcPlugin {static String jdbcUrl(JsonNode connection) {String url = appendJdbcUrlParams(optionalText(connection, "connection_string"), optionalText(connection, "url_params"));+ url = postgresDatabaseUrl(url, postgresDatabase(connection));return jdbcUrlWithPasswordKey(url, optionalText(connection, "password"));}+ private static boolean isPostgresJdbcUrl(String url) {+ return url != null && url.startsWith("jdbc:postgresql:");+ }++ private static String postgresDatabase(JsonNode node) {+ String database = node.path("database").asText(null);+ return database == null || database.isBlank() ? null : database;+ }++ private static String postgresDatabaseUrl(String url, String database) {+ if (!isPostgresJdbcUrl(url) || database == null) return url;+ String prefix = "jdbc:postgresql:";+ int queryStart = url.indexOf('?');+ String location = url.substring(prefix.length(), queryStart < 0 ? url.length() : queryStart);+ String authority = "";+ String originalDatabase = location;+ if (location.equals("//") || location.equals("///")) {+ originalDatabase = "";+ } else if (location.startsWith("//")) {+ int slash = location.indexOf('/', 2);+ if (slash < 0 || location.indexOf('/', slash + 1) >= 0) {+ throw new IllegalArgumentException("Invalid PostgreSQL JDBC URL database path");+ }+ authority = location.substring(0, slash + 1);+ originalDatabase = location.substring(slash + 1);+ } else if (location.startsWith("/")) {+ throw new IllegalArgumentException("Invalid PostgreSQL JDBC URL database path");+ }+ try {+ URLDecoder.decode(originalDatabase, StandardCharsets.UTF_8);+ } catch (IllegalArgumentException error) {+ throw new IllegalArgumentException("Invalid PostgreSQL JDBC URL database encoding");+ }+ String targeted = prefix + authority + URLEncoder.encode(database, StandardCharsets.UTF_8);+ if (queryStart < 0) return targeted;+ List<String> parameters = new ArrayList<>();+ for (String part : url.substring(queryStart + 1).split("&", -1)) {+ String name = partName(part);+ if (!name.equals("PGDBNAME") && !name.equals("dbname")) parameters.add(part);+ }+ return targeted + "?" + String.join("&", parameters);+ }+private record JdbcUrlCredentials(String url, String username, String password) {}static JdbcUrlCredentials extractJdbcUrlCredentials(String url) {diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/PostgresDatabaseRoutingTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/PostgresDatabaseRoutingTest.javanew file mode 100644index 0000000000..8d5d0a2c5a--- /dev/null+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/PostgresDatabaseRoutingTest.java@@ -0,0 +1,269 @@+package app.dbx.jdbc;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;++import java.lang.reflect.Proxy;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.sql.*;+import java.util.*;+import java.util.concurrent.CompletableFuture;+import java.util.concurrent.CopyOnWriteArrayList;+import java.util.logging.Logger;++import static org.junit.jupiter.api.Assertions.*;++final class PostgresDatabaseRoutingTest {+ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final List<Physical> PHYSICAL = new CopyOnWriteArrayList<>();+ private final List<String> sessions = new ArrayList<>();++ @AfterEach+ void cleanup() throws Exception {+ for (String session : sessions) call("closeJdbcSession", params("a", null).put("jdbcSessionId", session));+ call("close", MAPPER.createObjectNode());+ var field = DbxJdbcPlugin.class.getDeclaredField("logicalDriverKey");+ field.setAccessible(true);+ field.set(null, null);+ PHYSICAL.clear();+ }++ @Test+ void metadataBindsTheRequestedPhysicalDatabaseAcrossAToBToA() throws Exception {+ for (String database : List.of("a", "b", "a")) {+ JsonNode result = ok(call("listSchemas", params("a", database)));+ assertEquals(List.of(database + "_only", "public"), MAPPER.convertValue(result, List.class));+ }+ assertEquals(List.of("a", "b", "a"), PHYSICAL.stream().map(physical -> physical.database).toList());+ }++ @Test+ void urlBindingPreservesEndpointsOptionsAndEscapesDatabaseNames() {+ String target = " sales/季度?&+#% ";+ ObjectNode config = config("jdbc:postgresql://[::1]:5433,standby:5434/a%20b?sslmode=require&user=u%40x&password=p%26x&dbname=old");+ config.put("database", target).put("url_params", "ApplicationName=dbx&PGDBNAME=also_old&options=-c%20search_path%3Dpublic");+ String url = DbxJdbcPlugin.jdbcUrl(config);+ assertEquals(target, database(url));+ assertTrue(url.startsWith("jdbc:postgresql://[::1]:5433,standby:5434/"));+ assertTrue(url.contains("sslmode=require&user=u%40x&password=p%26x"));+ assertTrue(url.contains("ApplicationName=dbx"));+ assertTrue(url.contains("options=-c%20search_path%3Dpublic"));+ assertFalse(url.contains("old"));+ assertFalse(url.contains("季度"));+ }++ @Test+ void targetConnectionKeepsRoutedEndpointCredentialsAndOptions() throws Exception {+ ObjectNode request = MAPPER.createObjectNode().put("database", "b");+ ObjectNode connection = config("jdbc:postgresql://127.0.0.1:25432/a?sslmode=require&user=url%40user&password=p%26%2Bword");+ connection.put("url_params", "ApplicationName=dbx&options=-c%20search_path%3Dpublic");+ request.set("connection", connection);+ ok(call("connect", request));+ Physical opened = PHYSICAL.getFirst();+ assertEquals("jdbc:postgresql://127.0.0.1:25432/b?sslmode=require&ApplicationName=dbx&options=-c%20search_path%3Dpublic", opened.url);+ assertEquals("url@user", opened.properties.getProperty("user"));+ assertEquals("p&+word", opened.properties.getProperty("password"));+ connection.put("username", "form@user").put("password", "form-password");+ ok(call("connect", request));+ assertEquals("form@user", PHYSICAL.getLast().properties.getProperty("user"));+ assertEquals("form-password", PHYSICAL.getLast().properties.getProperty("password"));+ }++ @Test+ void defaultAndUnspecifiedDatabasePreserveTheOriginalUrl() throws Exception {+ for (String url : List.of("jdbc:postgresql:a", "jdbc:postgresql:", "jdbc:postgresql://host/", "jdbc:postgresql://host/a?ApplicationName=dbx")) {+ assertEquals(url, DbxJdbcPlugin.jdbcUrl(config(url)));+ ObjectNode selected = config(url).put("database", "b");+ assertEquals("b", database(DbxJdbcPlugin.jdbcUrl(selected)));+ }+ assertEquals("a_only", ok(call("listSchemas", params("a", null))).get(0).asText());+ assertEquals("b_only", ok(call("listSchemas", params("b", null))).get(0).asText());+ }++ @Test+ void otherVendorsAndMalformedPostgresUrlsKeepTheirBoundaries() {+ for (String url : List.of("jdbc:h2:file:./sample", "jdbc:h2:tcp://host/sample", "jdbc:hive2://host/default", "jdbc:kingbase8://host/a")) {+ assertEquals(url, DbxJdbcPlugin.jdbcUrl(config(url).put("database", "b")));+ }+ for (String url : List.of("jdbc:postgresql://host", "jdbc:postgresql:/a", "jdbc:postgresql://host/a/b", "jdbc:postgresql://host/%xx")) {+ assertThrows(IllegalArgumentException.class, () -> DbxJdbcPlugin.jdbcUrl(config(url).put("database", "b")));+ }+ }++ @Test+ void missingAndDeniedTargetsNeverReturnTheOriginalDatabaseOrCloseIt() throws Exception {+ ok(call("listSchemas", params("a", "a")));+ Physical original = PHYSICAL.getFirst();+ for (String target : List.of("missing", "denied")) {+ JsonNode response = call("listSchemas", params("a", target));+ assertTrue(response.has("error"), response.toString());+ assertTrue(response.path("error").path("message").asText().contains(target));+ assertFalse(original.closed);+ }+ assertEquals("a_only", ok(call("listSchemas", params("a", "a"))).get(0).asText());+ assertEquals(1, PHYSICAL.size());+ }++ @Test+ void activeTransactionsRejectDatabaseChangesWithoutLosingTheirOwner() throws Exception {+ ok(call("beginManualTransaction", params("a", "a")));+ Physical owner = PHYSICAL.getFirst();+ assertFalse(owner.autoCommit);+ assertTrue(call("listSchemas", params("a", "b")).has("error"));+ assertTrue(call("executeInManualTransaction", params("a", "b").put("sql", "SELECT 1")).has("error"));+ assertFalse(owner.closed);+ assertFalse(owner.autoCommit);+ ok(call("rollbackManualTransaction", params("a", "a")));+ assertEquals(1, owner.rollbacks);+ assertEquals("b_only", ok(call("listSchemas", params("a", "b"))).get(0).asText());+ }++ @Test+ void concurrentLogicalSessionsKeepMetadataAndTransactionOwnersSeparate() throws Exception {+ List<CompletableFuture<JsonNode>> pending = new ArrayList<>();+ for (int i = 0; i < 8; i++) {+ String session = "postgres-" + i;+ sessions.add(session);+ ObjectNode request = params("a", i % 2 == 0 ? "a" : "b").put("jdbcSessionId", session);+ ok(call("openJdbcSession", request));+ pending.add(CompletableFuture.supplyAsync(() -> {+ try { return call("listSchemas", request); }+ catch (Exception error) { throw new RuntimeException(error); }+ }));+ }+ for (int i = 0; i < pending.size(); i++) {+ assertEquals((i % 2 == 0 ? "a" : "b") + "_only", ok(pending.get(i).get()).get(0).asText());+ }+ assertEquals(8, PHYSICAL.size());+ ok(call("beginManualTransaction", params("a", "a").put("jdbcSessionId", sessions.getFirst())));+ assertEquals(1, PHYSICAL.stream().filter(physical -> !physical.autoCommit).count());+ ok(call("closeJdbcSession", params("a", null).put("jdbcSessionId", sessions.getFirst())));+ assertEquals(1, PHYSICAL.stream().filter(physical -> physical.closed).count());+ }++ @Test+ void failedReconnectKeepsTheExistingLogicalSessionAndTransaction() throws Exception {+ String session = "reconnect";+ sessions.add(session);+ ObjectNode original = params("a", "a").put("jdbcSessionId", session);+ ok(call("openJdbcSession", original));+ ok(call("connect", original));+ Physical owner = PHYSICAL.getFirst();+ assertTrue(call("connect", params("a", "missing").put("jdbcSessionId", session)).has("error"));+ assertFalse(owner.closed);+ ok(call("beginManualTransaction", original));+ assertTrue(call("connect", params("a", "b").put("jdbcSessionId", session)).has("error"));+ assertFalse(owner.closed);+ ok(call("rollbackManualTransaction", original));+ assertEquals(1, owner.rollbacks);+ assertEquals("a_only", ok(call("listSchemas", original)).get(0).asText());+ }++ private static ObjectNode config(String url) {+ ObjectNode config = MAPPER.createObjectNode().put("connection_string", url)+ .put("jdbc_driver_class", FakeDriver.class.getName());+ config.putArray("jdbc_driver_paths");+ return config;+ }++ private static ObjectNode params(String savedDatabase, String target) {+ ObjectNode params = MAPPER.createObjectNode();+ params.set("connection", config("jdbc:postgresql://localhost/" + savedDatabase));+ if (target != null) params.put("database", target);+ return params;+ }++ private static JsonNode call(String method, ObjectNode params) throws Exception {+ ObjectNode request = MAPPER.createObjectNode().put("id", 1).put("method", method);+ request.set("params", params);+ var handler = DbxJdbcPlugin.class.getDeclaredMethod("handleLine", String.class);+ handler.setAccessible(true);+ return (JsonNode) handler.invoke(null, request.toString());+ }++ private static JsonNode ok(JsonNode response) {+ assertFalse(response.has("error"), response.toString());+ return response.path("result");+ }++ private static String database(String url) {+ String location = url.substring("jdbc:postgresql:".length()).split("\\?", 2)[0];+ String value = location.startsWith("//") ? location.substring(location.indexOf('/', 2) + 1) : location;+ for (String part : url.substring(url.indexOf('?') + 1).split("&")) {+ if (part.startsWith("PGDBNAME=") || part.startsWith("dbname=")) value = part.substring(part.indexOf('=') + 1);+ }+ return URLDecoder.decode(value, StandardCharsets.UTF_8);+ }++ public static final class FakeDriver implements Driver {+ public Connection connect(String url, Properties properties) throws SQLException {+ if (!acceptsURL(url)) return null;+ String database = database(url);+ if (Set.of("missing", "denied").contains(database)) throw new SQLException(database + " database unavailable");+ Physical physical = new Physical(database, url, properties);+ PHYSICAL.add(physical);+ return physical.connection;+ }+ public boolean acceptsURL(String url) { return url.startsWith("jdbc:postgresql:"); }+ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) { return new DriverPropertyInfo[0]; }+ public int getMajorVersion() { return 1; }+ public int getMinorVersion() { return 0; }+ public boolean jdbcCompliant() { return false; }+ public Logger getParentLogger() { return Logger.getGlobal(); }+ }++ private static final class Physical {+ final String database;+ final String url;+ final Properties properties;+ final Connection connection;+ boolean closed;+ boolean autoCommit = true;+ int rollbacks;++ Physical(String database, String url, Properties properties) {+ this.database = database;+ this.url = url;+ this.properties = properties;+ DatabaseMetaData metadata = proxy(DatabaseMetaData.class, (object, method, args) -> {+ if (method.getName().equals("supportsTransactions")) return true;+ if (method.getName().equals("getSchemas")) {+ List<String> schemas = args == null || args[0] == null || database.equals(args[0])+ ? List.of(database + "_only", "public") : List.of();+ int[] row = {-1};+ return proxy(ResultSet.class, (rs, operation, values) -> switch (operation.getName()) {+ case "next" -> ++row[0] < schemas.size();+ case "getString" -> "TABLE_CATALOG".equals(values[0]) ? database : schemas.get(row[0]);+ default -> defaultValue(operation.getReturnType());+ });+ }+ return defaultValue(method.getReturnType());+ });+ connection = proxy(Connection.class, (object, method, args) -> switch (method.getName()) {+ case "getMetaData" -> metadata;+ case "getCatalog" -> database;+ case "getAutoCommit" -> autoCommit;+ case "setAutoCommit" -> { autoCommit = (boolean) args[0]; yield null; }+ case "isClosed" -> closed;+ case "close" -> { closed = true; yield null; }+ case "rollback" -> { rollbacks++; yield null; }+ default -> defaultValue(method.getReturnType());+ });+ }+ }++ private static <T> T proxy(Class<T> type, java.lang.reflect.InvocationHandler handler) {+ return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler));+ }++ private static Object defaultValue(Class<?> type) {+ if (type == boolean.class) return false;+ if (type == int.class) return 0;+ if (type == long.class) return 0L;+ return null;+ }+}