fix(quaint): add url decode for MSSQL database name

Author: dimsssss

quaint/src/connector/connection_info.rs

@@ -125,7 +125,7 @@ impl ConnectionInfo {
                 #[cfg(feature = "mysql-native")]
                 NativeConnectionInfo::Mysql(url) => url.dbname().map(Cow::Borrowed),
                 #[cfg(feature = "mssql-native")]
-                NativeConnectionInfo::Mssql(url) => Some(Cow::Borrowed(url.dbname())),
+                NativeConnectionInfo::Mssql(url) => Some(url.dbname()),
                 #[cfg(feature = "sqlite-native")]
                 NativeConnectionInfo::Sqlite { .. } | NativeConnectionInfo::InMemorySqlite { .. } => None,
             },

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

@@ -66,7 +66,8 @@ pub struct Mssql {
 impl Mssql {
     /// Creates a new connection to SQL Server.
     pub async fn new(url: MssqlUrl) -> crate::Result<Self> {
-        let config = Config::from_jdbc_string(&url.connection_string)?;
+        let mut config = Config::from_jdbc_string(&url.connection_string)?;
+        config.database(url.dbname());
         let tcp = TcpStream::connect_named(&config).await?;
         let socket_timeout = url.socket_timeout();
 
@@ -75,6 +76,7 @@ impl Mssql {
                 Ok(client) => Ok(client),
                 Err(tiberius::error::Error::Routing { host, port }) => {
                     let mut config = Config::from_jdbc_string(&url.connection_string)?;
+                    config.database(url.dbname());
                     config.host(host);
                     config.port(port);
 

quaint/src/connector/mssql/url.rs

@@ -5,7 +5,8 @@ use crate::{
     error::{Error, ErrorKind},
 };
 use connection_string::JdbcString;
-use std::{fmt, str::FromStr, time::Duration};
+use percent_encoding::percent_decode;
+use std::{borrow::Cow, fmt, str::FromStr, time::Duration};
 
 /// Wraps a connection url and exposes the parsing logic used by Quaint,
 /// including default values.
@@ -97,9 +98,16 @@ impl MssqlUrl {
         self.query_params.transaction_isolation_level
     }
 
-    /// Name of the database.
-    pub fn dbname(&self) -> &str {
-        self.query_params.database()
+    /// Decoded database name. Defaults to `master`.
+    pub fn dbname(&self) -> Cow<'_, str> {
+        let db = self.query_params.database();
+        match percent_decode(db.as_bytes()).decode_utf8() {
+            Ok(decoded) => decoded,
+            Err(_) => {
+                tracing::warn!("Couldn't decode dbname to UTF-8, using the non-decoded version.");
+                Cow::Borrowed(db)
+            }
+        }
     }
 
     /// The prefix which to use when querying database.
@@ -368,6 +376,7 @@ impl MssqlUrl {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::tests::test_api::mssql::CONN_STR;
     use crate::{error::*, single::Quaint};
 
@@ -381,4 +390,42 @@ mod tests {
         let err = res.unwrap_err();
         assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
     }
+
+    #[test]
+    fn should_decode_percent_encoded_dbname() {
+        // Chinese characters: 测试库 (test database)
+        let url = MssqlUrl::new("sqlserver://localhost:1433;database=%E6%B5%8B%E8%AF%95%E5%BA%93;user=SA;password=pass;trustServerCertificate=true").unwrap();
+        assert_eq!("测试库", url.dbname());
+    }
+
+    #[test]
+    fn should_decode_dbname_with_spaces() {
+        let url = MssqlUrl::new("sqlserver://localhost:1433;database=my%20database;user=SA;password=pass;trustServerCertificate=true").unwrap();
+        assert_eq!("my database", url.dbname());
+    }
+
+    #[test]
+    fn should_decode_dbname_with_special_characters() {
+        // test-db_name
+        let url = MssqlUrl::new("sqlserver://localhost:1433;database=test%2Ddb%5Fname;user=SA;password=pass;trustServerCertificate=true").unwrap();
+        assert_eq!("test-db_name", url.dbname());
+    }
+
+    #[test]
+    fn should_return_master_as_default_dbname() {
+        let url = MssqlUrl::new("sqlserver://localhost:1433;user=SA;password=pass;trustServerCertificate=true").unwrap();
+        assert_eq!("master", url.dbname());
+    }
+
+    #[tokio::test]
+    async fn should_connect_to_percent_encoded_chinese_dbname() {
+        // 测试库 = %E6%B5%8B%E8%AF%95%E5%BA%93
+        let url = CONN_STR.replace("database=master", "database=%E6%B5%8B%E8%AF%95%E5%BA%93");
+        let conn = Quaint::new(&url).await.unwrap();
+
+        use crate::prelude::Queryable;
+        let result = conn.query_raw("SELECT DB_NAME() AS db_name", &[]).await.unwrap();
+        let db_name = result.first().unwrap().get("db_name").unwrap().to_string().unwrap();
+        assert_eq!("测试库", db_name);
+    }
 }

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

@@ -153,11 +153,13 @@ impl MssqlConnector {
 
     /// Get the url as a JDBC string, extract the database name, and re-encode the string.
     fn master_url(input: &str) -> ConnectorResult<(String, String)> {
+        let url = MssqlUrl::new(input).map_err(ConnectorError::url_parse_error)?;
+        let db_name = url.dbname().into_owned();
+
         let mut conn = JdbcString::from_str(&format!("jdbc:{input}"))
             .map_err(|e| ConnectorError::from_source(e, "JDBC string parse error"))?;
-        let params = conn.properties_mut();
+        conn.properties_mut().remove("database");
 
-        let db_name = params.remove("database").unwrap_or_else(|| String::from("master"));
         Ok((db_name, conn.to_string()))
     }
 }
@@ -255,22 +257,8 @@ impl SqlConnector for MssqlConnector {
     fn drop_database(&mut self) -> BoxFuture<'_, ConnectorResult<()>> {
         Box::pin(async {
             let params = self.state.get_unwrapped_params();
-            let connection_string = &params.connector_params.connection_string;
-            {
-                let conn_str: JdbcString = format!("jdbc:{connection_string}")
-                    .parse()
-                    .map_err(ConnectorError::url_parse_error)?;
-
-                let db_name = conn_str
-                    .properties()
-                    .get("database")
-                    .map(|s| s.to_owned())
-                    .unwrap_or_else(|| "master".to_owned());
-
-                assert!(db_name != "master", "Cannot drop the `master` database.");
-            }
-
             let (db_name, master_uri) = Self::master_url(&params.connector_params.connection_string)?;
+            assert!(db_name != "master", "Cannot drop the `master` database.");
             let mut conn = Connection::new(&master_uri.to_string()).await?;
 
             let query = format!("DROP DATABASE IF EXISTS [{db_name}]");