feat(rust/driver_manager): implement connection profiles (#3973)

Implementing connection profiles for the Rust driver manager including
the default FilesystemProfileProvider and updating the objects and tests
accordingly.

Author: zeroshade

rust/Cargo.lock

@@ -40,6 +40,8 @@ adbc_ffi.workspace = true
 arrow-array.workspace = true
 arrow-schema.workspace = true
 libloading = "0.8.8"
+path-slash = "0.2.1"
+regex = "1.12.3"
 toml = { version = "1.0.3", default-features = false, features = [
     "parse",
     "display",

rust/driver_manager/Cargo.toml

@@ -101,6 +101,7 @@
 // would prevent any parallelism between driver calls, which is not desirable.
 
 pub mod error;
+pub mod profile;
 pub(crate) mod search;
 
 use std::collections::HashSet;
@@ -127,7 +128,10 @@ use adbc_core::{
 };
 use adbc_ffi::driver_method;
 
-use self::search::{parse_driver_uri, DriverLibrary};
+use self::search::{parse_driver_uri, DriverLibrary, DriverLocator};
+use crate::profile::{
+    process_profile_value, ConnectionProfile, ConnectionProfileProvider, FilesystemProfileProvider,
+};
 
 const ERR_CANCEL_UNSUPPORTED: &str =
     "Canceling connection or statement is not supported with ADBC 1.0.0";
@@ -354,6 +358,67 @@ pub struct ManagedDatabase {
 }
 
 impl ManagedDatabase {
+    /// Creates a new database connection from a URI string.
+    ///
+    /// This method supports both direct driver URIs and profile references.
+    ///
+    /// # URI Formats
+    ///
+    /// ## Direct Driver Connection
+    /// - `"driver_name:connection_string"` - Loads the specified driver and connects
+    /// - `"driver_name://host:port/database"` - Standard database URI format
+    ///
+    /// ## Profile Reference
+    /// - `"profile://name"` - Loads connection configuration from a profile file
+    /// - `"profile:///absolute/path/to/profile.toml"` - Absolute path to profile
+    /// - `"profile://relative/path/to/profile.toml"` - Relative path to profile
+    ///
+    /// # Arguments
+    ///
+    /// * `uri` - The connection URI or profile reference
+    /// * `entrypoint` - Optional driver entrypoint name (uses default if `None`)
+    /// * `version` - ADBC version to use
+    /// * `load_flags` - Flags controlling driver loading behavior
+    /// * `additional_search_paths` - Optional paths to search for drivers or profiles
+    ///
+    /// # Returns
+    ///
+    /// A configured `ManagedDatabase` ready for creating connections.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The URI format is invalid
+    /// - The driver cannot be loaded
+    /// - The profile cannot be found or parsed
+    /// - Database initialization fails
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use adbc_core::options::AdbcVersion;
+    /// use adbc_driver_manager::ManagedDatabase;
+    /// use adbc_core::LOAD_FLAG_DEFAULT;
+    ///
+    /// // Direct connection
+    /// let db = ManagedDatabase::from_uri(
+    ///     "sqlite::memory:",
+    ///     None,
+    ///     AdbcVersion::V100,
+    ///     LOAD_FLAG_DEFAULT,
+    ///     None
+    /// )?;
+    ///
+    /// // Profile connection
+    /// let db = ManagedDatabase::from_uri(
+    ///     "profile://my_database",
+    ///     None,
+    ///     AdbcVersion::V100,
+    ///     LOAD_FLAG_DEFAULT,
+    ///     None
+    /// )?;
+    /// # Ok::<(), adbc_core::error::Error>(())
+    /// ```
     pub fn from_uri(
         uri: &str,
         entrypoint: Option<&[u8]>,
@@ -371,6 +436,53 @@ impl ManagedDatabase {
         )
     }
 
+    /// Creates a new database connection from a URI with additional options.
+    ///
+    /// This is similar to [`from_uri`](Self::from_uri), but allows passing additional
+    /// database options that override any options from profiles.
+    ///
+    /// # Arguments
+    ///
+    /// * `uri` - The connection URI or profile reference
+    /// * `entrypoint` - Optional driver entrypoint name
+    /// * `version` - ADBC version to use
+    /// * `load_flags` - Flags controlling driver loading behavior
+    /// * `additional_search_paths` - Optional paths to search for drivers or profiles
+    /// * `opts` - Database options to apply (override profile options)
+    ///
+    /// # Returns
+    ///
+    /// A configured `ManagedDatabase` with the specified options applied.
+    ///
+    /// # Option Priority
+    ///
+    /// Options are applied in this order (later values override earlier ones):
+    /// 1. Profile options (if using a profile URI)
+    /// 2. Options provided via `opts` parameter
+    /// 3. URI connection string (for direct driver URIs)
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use adbc_core::options::{AdbcVersion, OptionDatabase, OptionValue};
+    /// use adbc_driver_manager::ManagedDatabase;
+    /// use adbc_core::LOAD_FLAG_DEFAULT;
+    ///
+    /// let opts = vec![
+    ///     (OptionDatabase::Username, OptionValue::String("user".to_string())),
+    ///     (OptionDatabase::Password, OptionValue::String("pass".to_string())),
+    /// ];
+    ///
+    /// let db = ManagedDatabase::from_uri_with_opts(
+    ///     "profile://my_database",
+    ///     None,
+    ///     AdbcVersion::V100,
+    ///     LOAD_FLAG_DEFAULT,
+    ///     None,
+    ///     opts,
+    /// )?;
+    /// # Ok::<(), adbc_core::error::Error>(())
+    /// ```
     pub fn from_uri_with_opts(
         uri: &str,
         entrypoint: Option<&[u8]>,
@@ -379,20 +491,121 @@ impl ManagedDatabase {
         additional_search_paths: Option<Vec<PathBuf>>,
         opts: impl IntoIterator<Item = (<Self as Optionable>::Option, OptionValue)>,
     ) -> Result<Self> {
-        let (driver, final_uri) = parse_driver_uri(uri)?;
-
-        let mut drv = ManagedDriver::load_from_name(
-            driver,
+        let profile_provider = FilesystemProfileProvider;
+        Self::from_uri_with_profile_provider(
+            uri,
             entrypoint,
             version,
             load_flags,
             additional_search_paths,
-        )?;
+            profile_provider,
+            opts,
+        )
+    }
+
+    /// Creates a new database connection from a URI with a custom profile provider.
+    ///
+    /// This advanced method allows using a custom implementation of
+    /// [`ConnectionProfileProvider`] to load profiles from alternative sources
+    /// (e.g., remote configuration services, encrypted storage, etc.).
+    ///
+    /// # Arguments
+    ///
+    /// * `uri` - The connection URI or profile reference
+    /// * `entrypoint` - Optional driver entrypoint name
+    /// * `version` - ADBC version to use
+    /// * `load_flags` - Flags controlling driver loading behavior
+    /// * `additional_search_paths` - Optional paths to search for drivers or profiles
+    /// * `profile_provider` - Custom profile provider implementation
+    /// * `opts` - Database options to apply (override profile options)
+    ///
+    /// # Returns
+    ///
+    /// A configured `ManagedDatabase` using the custom profile provider.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use adbc_core::options::{AdbcVersion, OptionDatabase, OptionValue};
+    /// use adbc_driver_manager::ManagedDatabase;
+    /// use adbc_driver_manager::profile::FilesystemProfileProvider;
+    /// use adbc_core::LOAD_FLAG_DEFAULT;
+    ///
+    /// let provider = FilesystemProfileProvider;
+    /// let opts = vec![(OptionDatabase::Username, OptionValue::String("admin".to_string()))];
+    ///
+    /// let db = ManagedDatabase::from_uri_with_profile_provider(
+    ///     "profile://my_database",
+    ///     None,
+    ///     AdbcVersion::V100,
+    ///     LOAD_FLAG_DEFAULT,
+    ///     None,
+    ///     provider,
+    ///     opts,
+    /// )?;
+    /// # Ok::<(), adbc_core::error::Error>(())
+    /// ```
+    pub fn from_uri_with_profile_provider(
+        uri: &str,
+        entrypoint: Option<&[u8]>,
+        version: AdbcVersion,
+        load_flags: LoadFlags,
+        additional_search_paths: Option<Vec<PathBuf>>,
+        profile_provider: impl ConnectionProfileProvider,
+        opts: impl IntoIterator<Item = (<Self as Optionable>::Option, OptionValue)>,
+    ) -> Result<Self> {
+        let result = parse_driver_uri(uri)?;
+        let (mut drv, default_opts) = match result {
+            DriverLocator::Uri(driver, final_uri) => {
+                let drv = ManagedDriver::load_from_name(
+                    driver,
+                    entrypoint,
+                    version,
+                    load_flags,
+                    additional_search_paths,
+                )?;
+
+                let final_opts = vec![(
+                    OptionDatabase::Uri,
+                    OptionValue::String(final_uri.to_string()),
+                )];
+                (drv, final_opts)
+            }
+            DriverLocator::Profile(profile) => {
+                let profile =
+                    profile_provider.get_profile(profile, additional_search_paths.clone())?;
+                let (driver_name, init_func) = profile.get_driver_name()?;
+
+                let drv: ManagedDriver;
+                if let Some(init_fn) = init_func {
+                    drv = ManagedDriver::load_static(init_fn, version)?;
+                } else {
+                    drv = ManagedDriver::load_from_name(
+                        driver_name,
+                        entrypoint,
+                        version,
+                        load_flags,
+                        additional_search_paths,
+                    )?;
+                }
+
+                let profile_opts: Vec<(OptionDatabase, OptionValue)> = profile
+                    .get_options()?
+                    .into_iter()
+                    .map(|(k, v)| -> Result<(OptionDatabase, OptionValue)> {
+                        if let OptionValue::String(s) = v {
+                            let result = process_profile_value(&s)?;
+                            Ok((k, result))
+                        } else {
+                            Ok((k, v))
+                        }
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                (drv, profile_opts)
+            }
+        };
 
-        drv.new_database_with_opts(opts.into_iter().chain(std::iter::once((
-            OptionDatabase::Uri,
-            OptionValue::String(final_uri.to_string()),
-        ))))
+        drv.new_database_with_opts(default_opts.into_iter().chain(opts))
     }
 
     fn ffi_driver(&self) -> &adbc_ffi::FFI_AdbcDriver {