fix(quaint): add url decode for non-ascii db names (#5750)

Description
## Summary
Fix connection failure when using databases with non-ASCII names (e.g.,
Chinese characters like `测试库`).
## Problem
When connecting to a PostgreSQL database with a non-ASCII name, the URL
must be percent-encoded:
postgresql://user:pass@localhost:5432/%E6%B5%8B%E8%AF%95%E5%BA%93
Previously, `dbname()` returned the encoded string
`%E6%B5%8B%E8%AF%95%E5%BA%93` as-is, causing:
  Error: Database does not exist: %E6%B5%8B%E8%AF%95%E5%BA%93
  
  for Example
  my database

![2026-01-18_15-23-24](https://github.com/user-attachments/assets/78b2a7f1-83e4-46d3-a47b-f581735eed7e)

  
<img width="1765" height="452" alt="스크린샷 2026-01-25 20-24-00"
src="https://github.com/user-attachments/assets/9b049e61-b223-49f8-9c6a-cd23e1cbddf3"
/>
                                                                  
## Solution
- Decode percent-encoded path segment in `PostgresNativeUrl::dbname()`
using `percent_decode`
- Change return type from `&str` to `Cow<'_, str>` to handle decoded
strings
- Update dependent code in connection_info, schema-engine, and qe-setup
## Test Plan
- [x] Unit tests for percent-decoding logic (Chinese, spaces, special
characters)
- [x] Integration test connecting to real PostgreSQL with Chinese
database name
## Before/After
**Before (bug exists):**
Connecting to: postgresql://.../%E6%B5%8B%E8%AF%95%E5%BA%93
❌ Connection FAILED
Error: Database does not exist: %E6%B5%8B%E8%AF%95%E5%BA%93
**After (fixed):**
Connecting to: postgresql://.../%E6%B5%8B%E8%AF%95%E5%BA%93
  ✅ Connection SUCCESS  


**Relation**
prisma/prisma#26886

Author: dimsssss

quaint/src/connector/connection_info.rs

@@ -111,7 +111,7 @@ impl ConnectionInfo {
     }
 
     /// The provided database name. This will be `None` on SQLite.
-    pub fn dbname(&self) -> Option<&str> {
+    pub fn dbname(&self) -> Option<Cow<'_, str>> {
         match self {
             #[cfg(any(
                 feature = "sqlite-native",
@@ -123,9 +123,9 @@ impl ConnectionInfo {
                 #[cfg(feature = "postgresql-native")]
                 NativeConnectionInfo::Postgres(url) => Some(url.dbname()),
                 #[cfg(feature = "mysql-native")]
-                NativeConnectionInfo::Mysql(url) => url.dbname(),
+                NativeConnectionInfo::Mysql(url) => url.dbname().map(Cow::Borrowed),
                 #[cfg(feature = "mssql-native")]
-                NativeConnectionInfo::Mssql(url) => Some(url.dbname()),
+                NativeConnectionInfo::Mssql(url) => Some(Cow::Borrowed(url.dbname())),
                 #[cfg(feature = "sqlite-native")]
                 NativeConnectionInfo::Sqlite { .. } | NativeConnectionInfo::InMemorySqlite { .. } => None,
             },

quaint/src/connector/postgres/native/mod.rs

@@ -207,7 +207,7 @@ impl PostgresNativeUrl {
         config.password(self.password().as_ref());
         config.host(self.host());
         config.port(self.port());
-        config.dbname(self.dbname());
+        config.dbname(self.dbname().as_ref());
         config.pgbouncer_mode(self.query_params.pg_bouncer);
 
         if let Some(options) = self.options() {

quaint/src/connector/postgres/url.rs

@@ -78,10 +78,10 @@ impl PostgresUrl {
         Ok(Self::WebSocket(PostgresWebSocketUrl::new(url, api_key)))
     }
 
-    pub fn dbname(&self) -> &str {
+    pub fn dbname(&self) -> Cow<'_, str> {
         match self {
             Self::Native(url) => url.dbname(),
-            Self::WebSocket(url) => url.dbname(),
+            Self::WebSocket(url) => Cow::Borrowed(url.dbname()),
         }
     }
 
@@ -193,11 +193,20 @@ impl PostgresNativeUrl {
         is_url_localhost(&self.url)
     }
 
-    /// Name of the database connected. Defaults to `postgres`.
-    pub fn dbname(&self) -> &str {
+    /// decoded database name. Defaults to `postgres`.
+    pub fn dbname(&self) -> Cow<'_, str> {
         match self.url.path_segments() {
-            Some(mut segments) => segments.next().unwrap_or("postgres"),
-            None => "postgres",
+            Some(mut segments) => {
+                let segment = segments.next().unwrap_or("postgres");
+                match percent_decode(segment.as_bytes()).decode_utf8() {
+                    Ok(dbname) => dbname,
+                    Err(_) => {
+                        tracing::warn!("Couldn't decode dbname to UTF-8, using the non-decoded version.");
+                        segment.into()
+                    }
+                }
+            }
+            None => Cow::Borrowed("postgres"),
         }
     }
 
@@ -595,6 +604,31 @@ mod tests {
         assert_eq!("/var/run/postgresql", url.host());
     }
 
+    #[test]
+    fn should_decode_percent_encoded_dbname() {
+        // Chinese characters: 测试库 (test database)
+        let url = PostgresNativeUrl::new(
+            Url::parse("postgresql://user:pass@localhost:5432/%E6%B5%8B%E8%AF%95%E5%BA%93").unwrap(),
+        )
+        .unwrap();
+        assert_eq!("测试库", url.dbname());
+    }
+
+    #[test]
+    fn should_decode_dbname_with_spaces() {
+        let url =
+            PostgresNativeUrl::new(Url::parse("postgresql://user:pass@localhost:5432/my%20database").unwrap()).unwrap();
+        assert_eq!("my database", url.dbname());
+    }
+
+    #[test]
+    fn should_decode_dbname_with_special_characters() {
+        // test-db_name
+        let url = PostgresNativeUrl::new(Url::parse("postgresql://user:pass@localhost:5432/test%2Ddb%5Fname").unwrap())
+            .unwrap();
+        assert_eq!("test-db_name", url.dbname());
+    }
+
     #[test]
     fn should_allow_changing_of_cache_size() {
         let url =
@@ -815,4 +849,48 @@ mod tests {
         // CRDB does NOT support setting the search_path via a connection parameter if the identifier is unsafe.
         assert_eq!(config.get_search_path(), None);
     }
+
+    /// Tests that connecting to a database with a percent-encoded name works correctly.
+    ///
+    /// This test verifies:
+    /// 1. A database with Chinese characters (测试库) can be created
+    /// 2. The percent-encoded URL correctly connects to the database
+    /// 3. The `dbname()` function returns the decoded database name
+    #[tokio::test]
+    async fn should_connect_to_db_with_percent_encoded_name() {
+        use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
+
+        let base_url = Url::parse(&CONN_STR).unwrap();
+        let conn = Quaint::new(base_url.as_str()).await.unwrap();
+
+        // Create a database with Chinese characters: 测试库 (meaning "test database")
+        let test_db_name = "测试库";
+        let _ = conn
+            .raw_cmd(&format!(r#"DROP DATABASE IF EXISTS "{test_db_name}""#))
+            .await;
+        conn.raw_cmd(&format!(r#"CREATE DATABASE "{test_db_name}""#))
+            .await
+            .unwrap();
+
+        // Build URL with percent-encoded database name
+        // 测试库 -> %E6%B5%8B%E8%AF%95%E5%BA%93
+        let encoded_db_name = utf8_percent_encode(test_db_name, NON_ALPHANUMERIC).to_string();
+        let mut test_url = base_url.clone();
+        test_url.set_path(&format!("/{encoded_db_name}"));
+
+        // Connect using percent-encoded URL and verify dbname() returns decoded value
+        let test_conn = Quaint::new(test_url.as_str()).await.unwrap();
+        let pg_url = PostgresNativeUrl::new(test_url).unwrap();
+        assert_eq!(test_db_name, pg_url.dbname());
+
+        // Verify the connection actually works by executing a simple query
+        let result = test_conn.query_raw("SELECT 1 as test", &[]).await.unwrap();
+        assert_eq!(1, result.len());
+
+        // Cleanup: drop the test database
+        drop(test_conn);
+        conn.raw_cmd(&format!(r#"DROP DATABASE IF EXISTS "{test_db_name}""#))
+            .await
+            .unwrap();
+    }
 }

query-engine/connector-test-kit-rs/qe-setup/src/cockroachdb.rs

@@ -21,7 +21,7 @@ pub(crate) async fn cockroach_setup(url: String, prisma_schema: &str) -> Connect
 
     conn.raw_cmd(&query).await.unwrap();
 
-    drop_db_when_thread_exits(parsed_url, db_name);
+    drop_db_when_thread_exits(parsed_url, &db_name);
     let params = ConnectorParams::new(url, Default::default(), None);
     let mut connector = sql_schema_connector::SqlSchemaConnector::new_cockroach(params)?;
     crate::diff_and_apply(prisma_schema, &mut connector).await

schema-engine/connectors/sql-schema-connector/src/flavour/postgres.rs

@@ -166,7 +166,7 @@ impl MigratePostgresUrl {
         Ok(Self(postgres_url))
     }
 
-    pub(super) fn dbname(&self) -> &str {
+    pub(super) fn dbname(&self) -> Cow<'_, str> {
         self.0.dbname()
     }
 

schema-engine/connectors/sql-schema-connector/src/flavour/postgres/connector/native/mod.rs

@@ -260,7 +260,7 @@ pub async fn create_database(state: &State) -> ConnectorResult<String> {
 
     conn.close().await;
 
-    Ok(db_name.to_owned())
+    Ok(db_name.into_owned())
 }
 
 pub async fn drop_database(state: &State) -> ConnectorResult<()> {