feat: Enhance ODBC connection string support

This commit adds support for standard ODBC connection strings in the `AnyKind` implementation, allowing for automatic detection of connection strings without the `odbc:` prefix. Additionally, comprehensive tests have been introduced to validate the parsing of various ODBC connection string formats.

Author: lovasoa

sqlx-core/src/any/kind.rs

@@ -65,16 +65,26 @@ impl FromStr for AnyKind {
             }
 
             #[cfg(feature = "odbc")]
-            _ if url.starts_with("odbc:") => {
+            _ if url.starts_with("odbc:") || Self::is_odbc_connection_string(url) => {
                 Ok(AnyKind::Odbc)
             }
 
             #[cfg(not(feature = "odbc"))]
-            _ if url.starts_with("odbc:") => {
+            _ if url.starts_with("odbc:") || Self::is_odbc_connection_string(url) => {
                 Err(Error::Configuration("database URL has the scheme of an ODBC database but the `odbc` feature is not enabled".into()))
             }
 
             _ => Err(Error::Configuration(format!("unrecognized database url: {:?}", url).into()))
         }
     }
 }
+
+impl AnyKind {
+    fn is_odbc_connection_string(s: &str) -> bool {
+        let s_upper = s.to_uppercase();
+        s_upper.starts_with("DSN=")
+            || s_upper.starts_with("DRIVER=")
+            || s_upper.starts_with("FILEDSN=")
+            || (s_upper.contains("DRIVER=") && s_upper.contains(';'))
+    }
+}

sqlx-core/src/odbc/mod.rs

@@ -1,4 +1,25 @@
 //! ODBC database driver (via `odbc-api`).
+//!
+//! ## Connection Strings
+//!
+//! When using the `Any` connection type, SQLx accepts standard ODBC connection strings:
+//!
+//! ```text
+//! // DSN-based connection
+//! DSN=MyDataSource;UID=myuser;PWD=mypassword
+//!
+//! // Driver-based connection
+//! Driver={ODBC Driver 17 for SQL Server};Server=localhost;Database=test
+//!
+//! // File DSN
+//! FILEDSN=/path/to/myfile.dsn
+//! ```
+//!
+//! The `odbc:` URL scheme prefix is optional but still supported for backward compatibility:
+//!
+//! ```text
+//! odbc:DSN=MyDataSource
+//! ```
 
 use crate::executor::Executor;
 

tests/any/odbc.rs

@@ -6,7 +6,8 @@ use sqlx_oldapi::{Column, Connection, Executor, Row, Statement};
 async fn odbc_conn() -> anyhow::Result<AnyConnection> {
     let url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set for ODBC tests");
 
-    // Ensure the URL starts with "odbc:"
+    // The "odbc:" prefix is now optional - standard ODBC connection strings
+    // like "DSN=mydsn" or "Driver={SQL Server};..." are automatically detected
     let url = if !url.starts_with("odbc:") {
         format!("odbc:{}", url)
     } else {
@@ -340,3 +341,59 @@ async fn it_matches_any_kind_odbc() -> anyhow::Result<()> {
     conn.close().await?;
     Ok(())
 }
+
+#[cfg(feature = "odbc")]
+#[sqlx_macros::test]
+async fn it_accepts_standard_odbc_connection_strings() -> anyhow::Result<()> {
+    use sqlx_oldapi::any::AnyKind;
+    use std::str::FromStr;
+
+    // Test various standard ODBC connection string formats
+    let test_cases = vec![
+        "DSN=mydsn",
+        "DSN=mydsn;UID=user;PWD=pass",
+        "Driver={SQL Server};Server=localhost;Database=test",
+        "Driver={ODBC Driver 17 for SQL Server};Server=localhost;Database=test",
+        "FILEDSN=myfile.dsn",
+        "odbc:DSN=mydsn", // Still support the odbc: prefix
+        "odbc:Driver={SQL Server};Server=localhost",
+    ];
+
+    for conn_str in test_cases {
+        let kind_result = AnyKind::from_str(conn_str);
+
+        // If ODBC feature is enabled, these should parse as ODBC
+        match kind_result {
+            Ok(kind) => assert_eq!(
+                kind,
+                AnyKind::Odbc,
+                "Failed to identify '{}' as ODBC",
+                conn_str
+            ),
+            Err(e) => panic!("Failed to parse '{}' as ODBC: {}", conn_str, e),
+        }
+    }
+
+    // Test non-ODBC connection strings don't match
+    let non_odbc_cases = vec![
+        "postgres://localhost/db",
+        "mysql://localhost/db",
+        "sqlite:memory:",
+        "random string without equals",
+    ];
+
+    for conn_str in non_odbc_cases {
+        let kind_result = AnyKind::from_str(conn_str);
+        match kind_result {
+            Ok(kind) => assert_ne!(
+                kind,
+                AnyKind::Odbc,
+                "Incorrectly identified '{}' as ODBC",
+                conn_str
+            ),
+            Err(_) => {} // Expected for unrecognized formats
+        }
+    }
+
+    Ok(())
+}