feat(c/driver_manager,rust/driver_manager): handle virtual environments in driver manager

c/driver_manager/adbc_driver_manager.cc

@@ -273,6 +273,31 @@ AdbcStatusCode LoadDriverManifest(const std::filesystem::path& driver_manifest,
   return ADBC_STATUS_OK;
 }
 
+std::filesystem::path GetEnvAsPath(const char* env_var) {
+#ifdef _WIN32
+  size_t required_size;
+
+  _wgetenv_s(&required_size, NULL, 0, env_var);
+  if (required_size == 0) {
+    return {};
+  }
+
+  std::wstring path_var;
+  path_var.resize(required_size);
+  _wgetenv_s(&required_size, path_var.data(), required_size, env_var);
+  return std::filesystem::path(path_var);
+#else
+  const char* path = std::getenv(env_var);
+  if (path) {
+    std::string_view venv(path);
+    if (!venv.empty()) {
+      return std::filesystem::path(venv);
+    }
+  }
+  return {};
+#endif
+}
+
 std::vector<std::filesystem::path> GetSearchPaths(const AdbcLoadFlags levels) {
   std::vector<std::filesystem::path> paths;
   if (levels & ADBC_LOAD_FLAG_SEARCH_ENV) {
@@ -281,6 +306,16 @@ std::vector<std::filesystem::path> GetSearchPaths(const AdbcLoadFlags levels) {
     if (env_path) {
       paths = InternalAdbcParsePath(env_path);
     }
+
+    std::filesystem::path venv = GetEnvAsPath("VIRTUAL_ENV");
+    if (!venv.empty()) {
+      paths.push_back(venv / "etc" / "adbc");
+    }
+
+    venv = GetEnvAsPath("CONDA_PREFIX");
+    if (!venv.empty()) {
+      paths.push_back(venv / "etc" / "adbc");
+    }
   }
 
   if (levels & ADBC_LOAD_FLAG_SEARCH_USER) {

docs/source/format/driver_manifests.rst

@@ -431,9 +431,14 @@ Unix-like Platforms
 For Unix-like platforms, (e.g. Linux, macOS), the driver manager will search the following directories based on the options provided, in
 the given order:
 
-#. If the ``LOAD_FLAG_SEARCH_ENV`` load option is set, then the environment variable ``ADBC_CONFIG_PATH`` will be searched
+#. If the ``LOAD_FLAG_SEARCH_ENV`` load option is set, then environment variables will be searched in this order
 
    * ``ADBC_CONFIG_PATH`` is a colon-separated list of directories to search for ``${name}.toml``
+   * ``VIRTUAL_ENV`` is used by `venv <https://docs.python.org/3/library/venv.html>`__ and if set
+     ``$VIRTUAL_ENV/etc/adbc`` will be searched for ``${name}.toml``
+   * ``CONDA_PREFIX`` is used by `conda <https://anaconda.org/anaconda/conda>`__ when using a ``conda``
+     environment (by using ``conda activate env-name``), and if set then ``$CONDA_PREFIX/etc/adbc``
+     will be searched for ``${name}.toml``
 
 #. If the ``LOAD_FLAG_SEARCH_USER`` load option is set, then a user-level configuration directory will be searched
 
@@ -452,9 +457,15 @@ Windows
 Things are slightly different on Windows, where the driver manager will also search for driver information in the registry just as
 would happen for ODBC drivers. The search for a manifest on Windows would be the following:
 
-#. If the ``LOAD_FLAG_SEARCH_ENV`` load option is set, then the environment variable ``ADBC_CONFIG_PATH`` will be searched
+#. If the ``LOAD_FLAG_SEARCH_ENV`` load option is set, then the environment variables will be searched in this order
 
    * ``ADBC_CONFIG_PATH`` is a semicolon-separated list of directories to search for ``${name}.toml``
+   * ``VIRTUAL_ENV`` is used by `venv <https://docs.python.org/3/library/venv.html>`__ and if set
+     ``$VIRTUAL_ENV/etc/adbc`` will be searched for ``${name}.toml``
+   * ``CONDA_PREFIX`` is used by `conda <https://anaconda.org/anaconda/conda>`__ when using a ``conda``
+     environment (by using ``conda activate env-name``), and if set then ``$CONDA_PREFIX/etc/adbc``
+     will be searched for ``${name}.toml``
+
 
 #. If the ``LOAD_FLAG_SEARCH_USER`` load option is set, then a user-level configuration is searched for
 

rust/driver_manager/src/lib.rs

@@ -1778,6 +1778,14 @@ fn get_search_paths(lvls: LoadFlags) -> Vec<PathBuf> {
                 result.push(p);
             }
         }
+
+        if let Some(path) = env::var_os("VIRTUAL_ENV") {
+            result.push(PathBuf::from(path).join("etc").join("adbc"));
+        }
+
+        if let Some(path) = env::var_os("CONDA_PREFIX") {
+            result.push(PathBuf::from(path).join("etc").join("adbc"));
+        }
     }
 
     if lvls & LOAD_FLAG_SEARCH_USER != 0 {
@@ -2224,4 +2232,44 @@ mod tests {
             assert_eq!(search_paths, Vec::<PathBuf>::new());
         }
     }
+
+    #[test]
+    fn test_get_search_paths_env() {
+        let path_list = vec![
+            Path::new("/foo/bar/baz"),
+            Path::new("/majestik/møøse"),
+            Path::new("/super/duper"),
+        ];
+        unsafe {
+            std::env::set_var(
+                "ADBC_CONFIG_PATH",
+                std::env::join_paths(&path_list).unwrap().as_os_str(),
+            );
+            std::env::set_var("VIRTUAL_ENV", Path::new("/home/foo/.venv").as_os_str());
+            std::env::set_var(
+                "CONDA_PREFIX",
+                Path::new("/home/foo/.conda/envs/hi").as_os_str(),
+            );
+        }
+
+        let search_paths = get_search_paths(LOAD_FLAG_SEARCH_ENV);
+        assert_eq!(
+            search_paths,
+            [
+                path_list,
+                [
+                    Path::new("/home/foo/.venv/etc/adbc"),
+                    Path::new("/home/foo/.conda/envs/hi/etc/adbc")
+                ]
+                .to_vec()
+            ]
+            .concat()
+        );
+
+        unsafe {
+            std::env::remove_var("ADBC_CONFIG_PATH");
+            std::env::remove_var("VIRTUAL_ENV");
+            std::env::remove_var("CONDA_PREFIX");
+        }
+    }
 }