feat(odbc): add dbms_name method to retrieve database management system name

Author: lovasoa

sqlx-core/src/any/connection/mod.rs

@@ -87,6 +87,34 @@ impl AnyConnection {
     pub fn private_get_mut(&mut self) -> &mut AnyConnectionKind {
         &mut self.0
     }
+
+    /// Returns the runtime DBMS name for this connection.
+    ///
+    /// For most built-in drivers this returns a well-known constant string:
+    /// - Postgres -> "PostgreSQL"
+    /// - MySQL -> "MySQL"
+    /// - SQLite -> "SQLite"
+    /// - MSSQL -> "Microsoft SQL Server"
+    ///
+    /// For ODBC, this queries the driver at runtime via `SQL_DBMS_NAME`.
+    pub async fn dbms_name(&mut self) -> Result<String, Error> {
+        match &mut self.0 {
+            #[cfg(feature = "postgres")]
+            AnyConnectionKind::Postgres(_) => Ok("PostgreSQL".to_string()),
+
+            #[cfg(feature = "mysql")]
+            AnyConnectionKind::MySql(_) => Ok("MySQL".to_string()),
+
+            #[cfg(feature = "sqlite")]
+            AnyConnectionKind::Sqlite(_) => Ok("SQLite".to_string()),
+
+            #[cfg(feature = "mssql")]
+            AnyConnectionKind::Mssql(_) => Ok("Microsoft SQL Server".to_string()),
+
+            #[cfg(feature = "odbc")]
+            AnyConnectionKind::Odbc(conn) => conn.dbms_name().await,
+        }
+    }
 }
 
 macro_rules! delegate_to {

sqlx-core/src/odbc/connection/mod.rs

@@ -28,6 +28,17 @@ impl OdbcConnection {
             log_settings: LogSettings::default(),
         })
     }
+
+    /// Returns the name of the actual Database Management System (DBMS) this
+    /// connection is talking to as reported by the ODBC driver.
+    ///
+    /// This calls the underlying ODBC API `SQL_DBMS_NAME` via
+    /// `odbc_api::Connection::database_management_system_name`.
+    ///
+    /// See: https://docs.rs/odbc-api/19.0.1/odbc_api/struct.Connection.html#method.database_management_system_name
+    pub async fn dbms_name(&mut self) -> Result<String, Error> {
+        self.worker.get_dbms_name().await
+    }
 }
 
 impl Connection for OdbcConnection {

sqlx-core/src/odbc/connection/worker.rs

@@ -53,6 +53,9 @@ enum Command {
         sql: Box<str>,
         tx: PrepareSender,
     },
+    GetDbmsName {
+        tx: oneshot::Sender<Result<String, Error>>,
+    },
 }
 
 impl Drop for ConnectionWorker {
@@ -156,6 +159,11 @@ impl ConnectionWorker {
         )
         .await?
     }
+
+    pub(crate) async fn get_dbms_name(&mut self) -> Result<String, Error> {
+        let (tx, rx) = oneshot::channel();
+        send_command_and_await(&self.command_tx, Command::GetDbmsName { tx }, rx).await?
+    }
 }
 
 // Worker thread implementation
@@ -254,6 +262,7 @@ fn process_command(cmd: Command, conn: &OdbcConnection) -> Option<oneshot::Sende
         Command::Shutdown { tx } => return Some(tx),
         Command::Execute { sql, args, tx } => handle_execute(conn, sql, args, tx),
         Command::Prepare { sql, tx } => handle_prepare(conn, sql, tx),
+        Command::GetDbmsName { tx } => handle_get_dbms_name(conn, tx),
     }
     None
 }
@@ -309,6 +318,13 @@ fn handle_prepare(conn: &OdbcConnection, sql: Box<str>, tx: PrepareSender) {
     send_result(tx, result);
 }
 
+fn handle_get_dbms_name(conn: &OdbcConnection, tx: oneshot::Sender<Result<String, Error>>) {
+    let result = conn
+        .database_management_system_name()
+        .map_err(|e| Error::Protocol(format!("Failed to get DBMS name: {}", e)));
+    send_result(tx, result);
+}
+
 // Helper functions
 fn execute_simple(conn: &OdbcConnection, sql: &str) -> Result<(), Error> {
     match conn.execute(sql, (), None) {

tests/any/odbc.rs

@@ -25,6 +25,10 @@ async fn it_connects_via_any_odbc() -> anyhow::Result<()> {
     // Simple ping test
     conn.ping().await?;
 
+    // DBMS name can be retrieved at runtime
+    let dbms = conn.dbms_name().await?;
+    assert!(!dbms.is_empty());
+
     // Close the connection
     conn.close().await?;
 
@@ -338,7 +342,9 @@ async fn it_matches_any_kind_odbc() -> anyhow::Result<()> {
     // Check that the connection kind is ODBC
     assert_eq!(conn.kind(), AnyKind::Odbc);
 
-    conn.close().await?;
+    // Ensure dbms_name works on owned connection too by dropping after fetch
+    let _ = conn;
+
     Ok(())
 }