chore(rust): bump dep versions, crate edition and msrv

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>

Author: if0ne

rust/Cargo.lock

@@ -22,8 +22,8 @@ resolver = "2"
 [workspace.package]
 version = "0.23.0"
 description = "Rust implementation of Arrow Database Connectivity (ADBC)"
-edition = "2021"
-rust-version = "1.81"
+edition = "2024"
+rust-version = "1.88"
 authors = ["Apache Arrow <dev@arrow.apache.org>"]
 license = "Apache-2.0"
 documentation = "https://docs.rs/adbc_core/"
@@ -37,9 +37,9 @@ categories = ["database"]
 adbc_core = { path = "./core", version = "0.23.0" }
 adbc_driver_manager = { path = "./driver_manager", version = "0.23.0" }
 adbc_ffi = { path = "./ffi", version = "0.23.0" }
-arrow-array = { version = ">=53.1.0, <59", default-features = false, features = [
+arrow-array = { version = ">=58, <59", default-features = false, features = [
     "ffi",
 ] }
-arrow-buffer = { version = ">=53.1.0, <59", default-features = false }
-arrow-schema = { version = ">=53.1.0, <59", default-features = false }
-arrow-select = { version = ">=53.1.0, <59", default-features = false }
+arrow-buffer = { version = ">=58, <59", default-features = false }
+arrow-schema = { version = ">=58, <59", default-features = false }
+arrow-select = { version = ">=58, <59", default-features = false }

rust/Cargo.toml

@@ -33,16 +33,16 @@ categories.workspace = true
 [dependencies]
 adbc_core.workspace = true
 adbc_ffi = { workspace = true, optional = true }
-arrow-array = "57.3.0"
-arrow-buffer = "57.3.0"
-arrow-schema = "57.3.0"
-datafusion = { version = "52.1.0", default-features = false }
-datafusion-substrait = { version = "52.1.0", default-features = false }
+arrow-array = "58"
+arrow-buffer = "58"
+arrow-schema = "58"
+datafusion = { git = "https://github.com/apache/arrow-datafusion", default-features = false, features = ["sql"] }
+datafusion-substrait = { git = "https://github.com/apache/arrow-datafusion", default-features = false }
 tokio = { version = "1.50", features = ["rt-multi-thread"] }
 prost = "0.14.3"
 
 [dev-dependencies]
-arrow-select = "57.3.0"
+arrow-select = "58"
 
 [lib]
 crate-type = ["lib", "cdylib"]

rust/driver/datafusion/Cargo.toml

@@ -41,11 +41,12 @@ use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{ArrowError, DataType, Field, SchemaRef};
 
 use adbc_core::{
+    Connection, Database, Driver, Optionable, Statement,
     error::{Error, Result, Status},
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas, Connection, Database, Driver, Optionable, Statement,
+    schemas,
 };
 
 pub enum Runtime {

rust/driver/datafusion/src/lib.rs

@@ -29,12 +29,12 @@ use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{ArrowError, DataType, Field, Schema, SchemaRef, UnionFields};
 
 use adbc_core::{
-    constants,
+    Connection, Database, Driver, Optionable, PartitionedResult, Statement, constants,
     error::{Error, Result, Status},
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas, Connection, Database, Driver, Optionable, PartitionedResult, Statement,
+    schemas,
 };
 
 #[derive(Debug)]
@@ -177,13 +177,12 @@ where
 
 fn maybe_panic(fnname: impl AsRef<str>) {
     if let Some(func) = std::env::var_os("PANICDUMMY_FUNC").map(|x| x.to_string_lossy().to_string())
+        && fnname.as_ref() == func
     {
-        if fnname.as_ref() == func {
-            let message = std::env::var_os("PANICDUMMY_MESSAGE")
-                .map(|x| x.to_string_lossy().to_string())
-                .unwrap_or_else(|| format!("We panicked in {}!", fnname.as_ref()));
-            panic!("{}", message);
-        }
+        let message = std::env::var_os("PANICDUMMY_MESSAGE")
+            .map(|x| x.to_string_lossy().to_string())
+            .unwrap_or_else(|| format!("We panicked in {}!", fnname.as_ref()));
+        panic!("{}", message);
     }
 }
 

rust/driver/dummy/src/lib.rs

@@ -25,13 +25,13 @@ use std::env;
 use std::{fmt, path::PathBuf, str::FromStr, time::Duration};
 
 use adbc_core::{
+    Driver as _,
     error::{Error, Result, Status},
     options::{OptionDatabase, OptionValue},
-    Driver as _,
 };
 use url::{Host, Url};
 
-use crate::{builder::BuilderIter, Database, Driver};
+use crate::{Database, Driver, builder::BuilderIter};
 #[cfg(feature = "env")]
 use crate::{
     builder::{env_parse, env_parse_map_err},
@@ -1097,7 +1097,9 @@ mod tests {
     #[test]
     fn from_env_parse_error() {
         // Set a value that fails to parse to a LogLevel
-        env::set_var(Builder::LOG_TRACING_ENV, "warning");
+        unsafe {
+            env::set_var(Builder::LOG_TRACING_ENV, "warning");
+        }
         let result = Builder::from_env();
         assert!(result.is_err());
         assert_eq!(
@@ -1108,15 +1110,19 @@ mod tests {
             )
         );
         // Fix it to move on
-        env::set_var(Builder::LOG_TRACING_ENV, "warn");
+
+        unsafe { env::set_var(Builder::LOG_TRACING_ENV, "warn") };
 
         // Set a value that fails to parse to a duration
-        env::set_var(Builder::LOGIN_TIMEOUT_ENV, "forever");
+        unsafe { env::set_var(Builder::LOGIN_TIMEOUT_ENV, "forever") };
         let result = Builder::from_env();
         assert!(result.is_err());
         assert_eq!(
             result.unwrap_err(),
-            Error::with_message_and_status("invalid duration (valid durations are a sequence of decimal numbers, each with optional fraction and a unit suffix, such as 300ms, 1.5h, 2h45m, valid time units are ns, us, ms, s, m, h)", Status::InvalidArguments)
+            Error::with_message_and_status(
+                "invalid duration (valid durations are a sequence of decimal numbers, each with optional fraction and a unit suffix, such as 300ms, 1.5h, 2h45m, valid time units are ns, us, ms, s, m, h)",
+                Status::InvalidArguments
+            )
         );
     }
 }

rust/driver/snowflake/src/database/builder.rs

@@ -64,7 +64,7 @@ impl fmt::Debug for Driver {
 }
 
 #[cfg(any(feature = "bundled", feature = "linked"))]
-extern "C" {
+unsafe extern "C" {
     #[link_name = "AdbcDriverSnowflakeInit"]
     fn init(version: c_int, raw_driver: *mut c_void, err: *mut FFI_AdbcError) -> AdbcStatusCode;
 }

rust/driver/snowflake/src/driver.rs

@@ -24,9 +24,9 @@ use adbc_core::{
     options::AdbcVersion,
 };
 
+use crate::Driver;
 #[cfg(feature = "env")]
 use crate::builder::env_parse;
-use crate::Driver;
 
 /// A builder for [`Driver`].
 ///
@@ -94,7 +94,9 @@ mod tests {
     #[test]
     fn from_env_parse_error() {
         // Set a value that fails to parse to an AdbcVersion
-        env::set_var(Builder::ADBC_VERSION_ENV, "?");
+        unsafe {
+            env::set_var(Builder::ADBC_VERSION_ENV, "?");
+        }
         let result = Builder::from_env();
         assert!(result.is_err());
         assert_eq!(

rust/driver/snowflake/src/driver/builder.rs

@@ -17,7 +17,7 @@
 
 use path_slash::PathBufExt;
 use std::borrow::Cow;
-use std::ffi::{c_void, OsStr};
+use std::ffi::{OsStr, c_void};
 use std::fmt::Write;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -27,10 +27,10 @@ use libloading::Symbol;
 use toml::de::{DeTable, DeValue};
 
 use adbc_core::{
+    LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV, LOAD_FLAG_SEARCH_SYSTEM,
+    LOAD_FLAG_SEARCH_USER, LoadFlags,
     error::{Error, Result, Status},
     options::AdbcVersion,
-    LoadFlags, LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV, LOAD_FLAG_SEARCH_SYSTEM,
-    LOAD_FLAG_SEARCH_USER,
 };
 use adbc_ffi::{
     options::check_status,
@@ -695,8 +695,8 @@ const fn arch_triplet() -> (&'static str, &'static str, &'static str) {
 mod target_windows {
     use windows_sys as windows;
 
-    use std::ffi::c_void;
     use std::ffi::OsString;
+    use std::ffi::c_void;
     use std::os::windows::ffi::OsStringExt;
     use std::path::PathBuf;
     use std::slice;
@@ -788,30 +788,28 @@ fn system_config_dir() -> Option<PathBuf> {
 
 fn get_search_paths(lvls: LoadFlags) -> Vec<PathBuf> {
     let mut result = Vec::new();
-    if lvls & LOAD_FLAG_SEARCH_ENV != 0 {
-        if let Some(paths) = env::var_os("ADBC_DRIVER_PATH") {
-            for p in env::split_paths(&paths) {
-                result.push(p);
-            }
+    if lvls & LOAD_FLAG_SEARCH_ENV != 0
+        && let Some(paths) = env::var_os("ADBC_DRIVER_PATH")
+    {
+        for p in env::split_paths(&paths) {
+            result.push(p);
         }
     }
 
-    if lvls & LOAD_FLAG_SEARCH_USER != 0 {
-        if let Some(path) = user_config_dir() {
-            if path.exists() {
-                result.push(path);
-            }
-        }
+    if lvls & LOAD_FLAG_SEARCH_USER != 0
+        && let Some(path) = user_config_dir()
+        && path.exists()
+    {
+        result.push(path);
     }
 
     // system level for windows is to search the registry keys
     #[cfg(not(windows))]
-    if lvls & LOAD_FLAG_SEARCH_SYSTEM != 0 {
-        if let Some(path) = system_config_dir() {
-            if path.exists() {
-                result.push(path);
-            }
-        }
+    if lvls & LOAD_FLAG_SEARCH_SYSTEM != 0
+        && let Some(path) = system_config_dir()
+        && path.exists()
+    {
+        result.push(path);
     }
 
     result
@@ -1017,7 +1015,7 @@ pub(crate) fn parse_driver_uri<'a>(uri: &'a str) -> Result<DriverLocator<'a>> {
 mod tests {
     use std::env;
 
-    use adbc_core::{options::AdbcVersion, LOAD_FLAG_ALLOW_RELATIVE_PATHS};
+    use adbc_core::{LOAD_FLAG_ALLOW_RELATIVE_PATHS, options::AdbcVersion};
     use temp_env::{with_var, with_var_unset};
 
     use crate::ManagedDriver;

rust/driver_manager/src/search.rs

@@ -18,11 +18,11 @@
 use std::path::PathBuf;
 
 use adbc_core::options::{AdbcVersion, OptionDatabase, OptionValue};
-use adbc_core::{error::Status, LOAD_FLAG_DEFAULT};
+use adbc_core::{LOAD_FLAG_DEFAULT, error::Status};
+use adbc_driver_manager::ManagedDatabase;
 use adbc_driver_manager::profile::{
     ConnectionProfile, ConnectionProfileProvider, FilesystemProfileProvider,
 };
-use adbc_driver_manager::ManagedDatabase;
 use serial_test::serial;
 
 mod common;
@@ -460,7 +460,9 @@ fn test_profile_hierarchical_path_via_env_var() {
 
     // Set ADBC_PROFILE_PATH to the parent directory
     let prev_value = env::var_os("ADBC_PROFILE_PATH");
-    env::set_var("ADBC_PROFILE_PATH", tmp_dir.path());
+    unsafe {
+        env::set_var("ADBC_PROFILE_PATH", tmp_dir.path());
+    }
 
     // Verify the environment variable is set correctly
     assert_eq!(
@@ -473,9 +475,11 @@ fn test_profile_hierarchical_path_via_env_var() {
     let result = provider.get_profile("databases/postgres/production", None);
 
     // Restore the original environment variable
-    match prev_value {
-        Some(val) => env::set_var("ADBC_PROFILE_PATH", val),
-        None => env::remove_var("ADBC_PROFILE_PATH"),
+    unsafe {
+        match prev_value {
+            Some(val) => env::set_var("ADBC_PROFILE_PATH", val),
+            None => env::remove_var("ADBC_PROFILE_PATH"),
+        }
     }
 
     // Verify the profile was loaded successfully
@@ -518,16 +522,20 @@ fn test_profile_hierarchical_path_with_extension_via_env_var() {
 
     // Set ADBC_PROFILE_PATH to the parent directory
     let prev_value = env::var_os("ADBC_PROFILE_PATH");
-    env::set_var("ADBC_PROFILE_PATH", tmp_dir.path());
+    unsafe {
+        env::set_var("ADBC_PROFILE_PATH", tmp_dir.path());
+    }
 
     // Try to load the profile using hierarchical relative path with .toml extension
     let provider = FilesystemProfileProvider;
     let result = provider.get_profile("configs/dev/database.toml", None);
 
     // Restore the original environment variable
-    match prev_value {
-        Some(val) => env::set_var("ADBC_PROFILE_PATH", val),
-        None => env::remove_var("ADBC_PROFILE_PATH"),
+    unsafe {
+        match prev_value {
+            Some(val) => env::set_var("ADBC_PROFILE_PATH", val),
+            None => env::remove_var("ADBC_PROFILE_PATH"),
+        }
     }
 
     // Verify the profile was loaded successfully