chore: remove lazy_static and once_cell dependencies

crates/aws/Cargo.toml

@@ -19,7 +19,6 @@ aws-credential-types = { version="1.2", features = ["hardcoded-credentials"]}
 aws-config = { version = "1.5", default-features = false, features = ["behavior-version-latest","rt-tokio", "credentials-process", "sso"] }
 aws-sdk-dynamodb = {version = "1.45", default-features = false, features = ["behavior-version-latest", "rt-tokio"] }
 aws-sdk-sts = {version = "1.42", default-features = false, features = ["behavior-version-latest", "rt-tokio"] }
-lazy_static = "1"
 maplit = "1"
 
 # workspace dependencies

crates/aws/src/constants.rs

@@ -2,7 +2,7 @@
 //! delta-rs
 //!
 
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
 use std::time::Duration;
 
 /// Custom S3 endpoint.
@@ -150,15 +150,15 @@ pub const STRING_TYPE: &str = "S";
 pub const KEY_TYPE_HASH: &str = "HASH";
 pub const KEY_TYPE_RANGE: &str = "RANGE";
 
-lazy_static! {
-    pub static ref CONDITION_EXPR_CREATE: String = format!(
-        "attribute_not_exists({ATTR_TABLE_PATH}) and attribute_not_exists({ATTR_FILE_NAME})"
-    );
+pub static CONDITION_EXPR_CREATE: LazyLock<String> = LazyLock::new(|| {
+    format!("attribute_not_exists({ATTR_TABLE_PATH}) and attribute_not_exists({ATTR_FILE_NAME})")
+});
 
-    pub static ref CONDITION_DELETE_INCOMPLETE: String = format!(
-        "(complete = :f) or (attribute_not_exists({ATTR_TABLE_PATH}) and attribute_not_exists({ATTR_FILE_NAME}))"
-    );
-}
+pub static CONDITION_DELETE_INCOMPLETE: LazyLock<String> = LazyLock::new(|| {
+    format!(
+    "(complete = :f) or (attribute_not_exists({ATTR_TABLE_PATH}) and attribute_not_exists({ATTR_FILE_NAME}))"
+)
+});
 
 pub const CONDITION_UPDATE_INCOMPLETE: &str = "complete = :f";
 pub const DEFAULT_COMMIT_ENTRY_EXPIRATION_DELAY: Duration = Duration::from_secs(86_400);

crates/aws/src/lib.rs

@@ -30,12 +30,11 @@ use deltalake_core::storage::object_store::aws::AmazonS3ConfigKey;
 use deltalake_core::storage::{factories, url_prefix_handler, ObjectStoreRef, StorageOptions};
 use deltalake_core::{DeltaResult, Path};
 use errors::{DynamoDbConfigError, LockClientError};
-use lazy_static::lazy_static;
 use regex::Regex;
 use std::{
     collections::HashMap,
     str::FromStr,
-    sync::Arc,
+    sync::{Arc, LazyLock},
     time::{Duration, SystemTime},
 };
 use storage::S3StorageOptionsConversion;
@@ -703,10 +702,9 @@ fn num_attr<T: ToString>(n: T) -> AttributeValue {
     AttributeValue::N(n.to_string())
 }
 
-lazy_static! {
-    static ref DELTA_LOG_PATH: Path = Path::from("_delta_log");
-    static ref DELTA_LOG_REGEX: Regex = Regex::new(r"(\d{20})\.(json|checkpoint).*$").unwrap();
-}
+static DELTA_LOG_PATH: LazyLock<Path> = LazyLock::new(|| Path::from("_delta_log"));
+static DELTA_LOG_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"(\d{20})\.(json|checkpoint).*$").unwrap());
 
 /// Extract version from a file name in the delta log
 fn extract_version_from_filename(name: &str) -> Option<i64> {

crates/aws/tests/integration_s3_dynamodb.rs

@@ -3,6 +3,7 @@
 #![cfg(feature = "integration_test")]
 
 use std::collections::HashMap;
+use std::sync::LazyLock;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use aws_sdk_dynamodb::types::BillingMode;
@@ -19,7 +20,6 @@ use deltalake_core::storage::StorageOptions;
 use deltalake_core::table::builder::ensure_table_uri;
 use deltalake_core::{DeltaOps, DeltaTable, DeltaTableBuilder, ObjectStoreError};
 use deltalake_test::utils::*;
-use lazy_static::lazy_static;
 use object_store::path::Path;
 use serde_json::Value;
 use serial_test::serial;
@@ -35,12 +35,13 @@ use common::*;
 
 pub type TestResult<T> = Result<T, Box<dyn std::error::Error + 'static>>;
 
-lazy_static! {
-    static ref OPTIONS: HashMap<String, String> = maplit::hashmap! {
+static OPTIONS: LazyLock<HashMap<String, String>> = LazyLock::new(|| {
+    hashmap! {
         "allow_http".to_owned() => "true".to_owned(),
-    };
-    static ref S3_OPTIONS: S3StorageOptions = S3StorageOptions::from_map(&OPTIONS).unwrap();
-}
+    }
+});
+static S3_OPTIONS: LazyLock<S3StorageOptions> =
+    LazyLock::new(|| S3StorageOptions::from_map(&OPTIONS).unwrap());
 
 fn make_client() -> TestResult<DynamoDbLockClient> {
     let options: S3StorageOptions = S3StorageOptions::try_default().unwrap();

crates/azure/Cargo.toml

@@ -15,7 +15,6 @@ rust-version.workspace = true
 deltalake-core = { version = "0.24.0", path = "../core", features = [
     "datafusion",
 ]}
-lazy_static = "1"
 
 # workspace depenndecies
 async-trait = { workspace = true }

crates/azure/src/config.rs

@@ -6,14 +6,14 @@
 //! way how we discover valid credentials and some heuristics on how they are prioritized.
 use std::collections::{hash_map::Entry, HashMap};
 use std::str::FromStr;
+use std::sync::LazyLock;
 
 use object_store::azure::AzureConfigKey;
 use object_store::Error as ObjectStoreError;
 
 use crate::error::Result;
 
-lazy_static::lazy_static! {
-    static ref CREDENTIAL_KEYS: Vec<AzureConfigKey> =
+static CREDENTIAL_KEYS: LazyLock<Vec<AzureConfigKey>> = LazyLock::new(|| {
     Vec::from_iter([
         AzureConfigKey::ClientId,
         AzureConfigKey::ClientSecret,
@@ -23,8 +23,8 @@ lazy_static::lazy_static! {
         AzureConfigKey::MsiEndpoint,
         AzureConfigKey::ObjectId,
         AzureConfigKey::MsiResourceId,
-    ]);
-}
+    ])
+});
 
 /// Credential
 enum AzureCredential {

crates/core/Cargo.toml

@@ -84,12 +84,10 @@ either = "1.8"
 fix-hidden-lifetime-bug = "0.2"
 indexmap = "2.2.1"
 itertools = "0.14"
-lazy_static = "1"
 libc = ">=0.2.90, <1"
 num-bigint = "0.4"
 num-traits = "0.2.15"
 object_store = { workspace = true }
-once_cell = "1.16.0"
 parking_lot = "0.12"
 percent-encoding = "2"
 roaring = "0.10.1"

crates/core/src/delta_datafusion/cdf/mod.rs

@@ -1,8 +1,8 @@
 //! Logical operators and physical executions for CDF
 use std::collections::HashMap;
+use std::sync::LazyLock;
 
 use arrow_schema::{DataType, Field, TimeUnit};
-use lazy_static::lazy_static;
 
 pub(crate) use self::scan::*;
 pub(crate) use self::scan_utils::*;
@@ -19,25 +19,27 @@ pub const COMMIT_VERSION_COL: &str = "_commit_version";
 /// Commit Timestamp column name
 pub const COMMIT_TIMESTAMP_COL: &str = "_commit_timestamp";
 
-lazy_static! {
-    pub(crate) static ref CDC_PARTITION_SCHEMA: Vec<Field> = vec![
+pub(crate) static CDC_PARTITION_SCHEMA: LazyLock<Vec<Field>> = LazyLock::new(|| {
+    vec![
         Field::new(COMMIT_VERSION_COL, DataType::Int64, true),
         Field::new(
             COMMIT_TIMESTAMP_COL,
             DataType::Timestamp(TimeUnit::Millisecond, None),
-            true
-        )
-    ];
-    pub(crate) static ref ADD_PARTITION_SCHEMA: Vec<Field> = vec![
+            true,
+        ),
+    ]
+});
+pub(crate) static ADD_PARTITION_SCHEMA: LazyLock<Vec<Field>> = LazyLock::new(|| {
+    vec![
         Field::new(CHANGE_TYPE_COL, DataType::Utf8, true),
         Field::new(COMMIT_VERSION_COL, DataType::Int64, true),
         Field::new(
             COMMIT_TIMESTAMP_COL,
             DataType::Timestamp(TimeUnit::Millisecond, None),
-            true
+            true,
         ),
-    ];
-}
+    ]
+});
 
 #[derive(Debug)]
 pub(crate) struct CdcDataSpec<F: FileAction> {

crates/core/src/kernel/arrow/mod.rs

@@ -1,12 +1,11 @@
 //! Conversions between Delta and Arrow data types
 
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
 use arrow_schema::{
     DataType as ArrowDataType, Field as ArrowField, FieldRef as ArrowFieldRef,
     Schema as ArrowSchema, SchemaRef as ArrowSchemaRef,
 };
-use lazy_static::lazy_static;
 
 pub(crate) mod extract;
 pub(crate) mod json;
@@ -184,8 +183,8 @@ pub(crate) fn delta_log_schema_for_table(
     partition_columns: &[String],
     use_extended_remove_schema: bool,
 ) -> ArrowSchemaRef {
-    lazy_static! {
-        static ref SCHEMA_FIELDS: Vec<ArrowField> = arrow_defs![
+    static SCHEMA_FIELDS: LazyLock<Vec<ArrowField>> = LazyLock::new(|| {
+        arrow_defs![
                 metaData[
                     id:Utf8,
                     name:Utf8,
@@ -206,8 +205,10 @@ pub(crate) fn delta_log_schema_for_table(
                     appId:Utf8,
                     version:Int64
                 ]
-        ];
-        static ref ADD_FIELDS: Vec<ArrowField> = arrow_defs![
+        ]
+    });
+    static ADD_FIELDS: LazyLock<Vec<ArrowField>> = LazyLock::new(|| {
+        arrow_defs![
             path:Utf8,
             size:Int64,
             modificationTime:Int64,
@@ -222,16 +223,18 @@ pub(crate) fn delta_log_schema_for_table(
                 sizeInBytes:Int32 not_null,
                 cardinality:Int64 not_null
             ]
-        ];
-        static ref REMOVE_FIELDS: Vec<ArrowField> = arrow_defs![
+        ]
+    });
+    static REMOVE_FIELDS: LazyLock<Vec<ArrowField>> = LazyLock::new(|| {
+        arrow_defs![
             path: Utf8,
             deletionTimestamp: Int64,
             dataChange: Boolean,
             extendedFileMetadata: Boolean
-        ];
-        static ref REMOVE_EXTENDED_FILE_METADATA_FIELDS: Vec<ArrowField> =
-            arrow_defs![size: Int64, partitionValues, tags];
-    };
+        ]
+    });
+    static REMOVE_EXTENDED_FILE_METADATA_FIELDS: LazyLock<Vec<ArrowField>> =
+        LazyLock::new(|| arrow_defs![size: Int64, partitionValues, tags]);
 
     // create add fields according to the specific data table schema
     let (partition_fields, non_partition_fields): (Vec<ArrowFieldRef>, Vec<ArrowFieldRef>) =

crates/core/src/kernel/mod.rs

@@ -1,7 +1,9 @@
 //! Delta Kernel module
 //!
 //! The Kernel module contains all the logic for reading and processing the Delta Lake transaction log.
+
 use delta_kernel::engine::arrow_expression::ArrowExpressionHandler;
+use std::sync::LazyLock;
 
 pub mod arrow;
 pub mod error;
@@ -21,6 +23,5 @@ pub trait DataCheck {
     fn get_expression(&self) -> &str;
 }
 
-lazy_static::lazy_static! {
-    static ref ARROW_HANDLER: ArrowExpressionHandler = ArrowExpressionHandler {};
-}
+static ARROW_HANDLER: LazyLock<ArrowExpressionHandler> =
+    LazyLock::new(|| ArrowExpressionHandler {});