diff --git a/c/sedona-geoarrow-c/src/kernels.rs b/c/sedona-geoarrow-c/src/kernels.rs
index 062d1013..caab4158 100644
--- a/c/sedona-geoarrow-c/src/kernels.rs
+++ b/c/sedona-geoarrow-c/src/kernels.rs
@@ -154,14 +154,15 @@ mod tests {
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOGRAPHY, WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
 
-    use sedona_testing::{create::create_scalar_storage, testers::ScalarUdfTester};
+    use sedona_testing::{
+        create::{create_array, create_scalar_storage},
+        testers::ScalarUdfTester,
+    };
 
     use super::*;
 
     #[rstest]
     fn fromwkt(#[values(DataType::Utf8, DataType::Utf8View)] data_type: DataType) {
-        use sedona_testing::create::create_array;
-
         let udf = SedonaScalarUDF::from_kernel("st_geomfromwkt", st_geomfromwkt_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![SedonaType::Arrow(data_type)]);
         tester.assert_return_type(WKB_GEOMETRY);
diff --git a/c/sedona-geos/src/binary_predicates.rs b/c/sedona-geos/src/binary_predicates.rs
index 90ece9ba..41ea2ab1 100644
--- a/c/sedona-geos/src/binary_predicates.rs
+++ b/c/sedona-geos/src/binary_predicates.rs
@@ -104,6 +104,7 @@ impl<Op: BinaryPredicate> SedonaScalarKernel for GeosPredicate<Op> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -115,8 +116,6 @@ mod tests {
 
     #[rstest]
     fn contains_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_contains", st_contains_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -154,8 +153,6 @@ mod tests {
 
     #[rstest]
     fn covered_by_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_coveredby", st_covered_by_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -193,8 +190,6 @@ mod tests {
 
     #[rstest]
     fn covers_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_covers", st_covers_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -232,8 +227,6 @@ mod tests {
 
     #[rstest]
     fn disjoint_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_disjoint", st_disjoint_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -271,8 +264,6 @@ mod tests {
 
     #[rstest]
     fn equals_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_equals", st_equals_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -310,8 +301,6 @@ mod tests {
 
     #[rstest]
     fn intersects_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_intersects", st_intersects_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -349,8 +338,6 @@ mod tests {
 
     #[rstest]
     fn within_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_within", st_within_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -388,7 +375,6 @@ mod tests {
 
     #[rstest]
     fn crosses_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
         let udf = SedonaScalarUDF::from_kernel("st_crosses", st_crosses_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
@@ -425,7 +411,6 @@ mod tests {
 
     #[rstest]
     fn overlaps_udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
         let udf = SedonaScalarUDF::from_kernel("st_overlaps", st_overlaps_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Boolean);
diff --git a/c/sedona-geos/src/distance.rs b/c/sedona-geos/src/distance.rs
index 5af15009..c77b1374 100644
--- a/c/sedona-geos/src/distance.rs
+++ b/c/sedona-geos/src/distance.rs
@@ -77,6 +77,7 @@ fn invoke_scalar(geos_geom: &geos::Geometry, other_geos_geom: &geos::Geometry) -
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -88,8 +89,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_distance", st_distance_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type.clone(), sedona_type]);
         tester.assert_return_type(DataType::Float64);
diff --git a/c/sedona-geos/src/st_area.rs b/c/sedona-geos/src/st_area.rs
index ba4ea68a..b89cc1ed 100644
--- a/c/sedona-geos/src/st_area.rs
+++ b/c/sedona-geos/src/st_area.rs
@@ -75,6 +75,7 @@ fn invoke_scalar(geos_geom: &geos::Geometry) -> Result<f64> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -84,8 +85,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_area", st_area_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type]);
         tester.assert_return_type(DataType::Float64);
diff --git a/c/sedona-geos/src/st_dwithin.rs b/c/sedona-geos/src/st_dwithin.rs
index bc7bbd10..4ab466f8 100644
--- a/c/sedona-geos/src/st_dwithin.rs
+++ b/c/sedona-geos/src/st_dwithin.rs
@@ -82,6 +82,7 @@ fn invoke_scalar(lhs: &geos::Geometry, rhs: &geos::Geometry, distance: f64) -> R
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -93,8 +94,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_dwithin", st_dwithin_impl());
         let tester = ScalarUdfTester::new(
             udf.into(),
diff --git a/c/sedona-geos/src/st_length.rs b/c/sedona-geos/src/st_length.rs
index 3860f80c..83d5af6a 100644
--- a/c/sedona-geos/src/st_length.rs
+++ b/c/sedona-geos/src/st_length.rs
@@ -96,6 +96,7 @@ fn invoke_scalar(geos_geom: &geos::Geometry) -> GResult<f64> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -105,8 +106,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_length", st_length_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type]);
         tester.assert_return_type(DataType::Float64);
diff --git a/c/sedona-geos/src/st_perimeter.rs b/c/sedona-geos/src/st_perimeter.rs
index e4dbfb1e..f8f6a16f 100644
--- a/c/sedona-geos/src/st_perimeter.rs
+++ b/c/sedona-geos/src/st_perimeter.rs
@@ -95,6 +95,7 @@ fn invoke_scalar(geos_geom: &geos::Geometry) -> GResult<f64> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use rstest::rstest;
     use sedona_expr::scalar_udf::SedonaScalarUDF;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -104,8 +105,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf = SedonaScalarUDF::from_kernel("st_perimeter", st_perimeter_impl());
         let tester = ScalarUdfTester::new(udf.into(), vec![sedona_type]);
         tester.assert_return_type(DataType::Float64);
diff --git a/rust/sedona-functions/src/barrier.rs b/rust/sedona-functions/src/barrier.rs
index 3c67ee6f..83d7fefd 100644
--- a/rust/sedona-functions/src/barrier.rs
+++ b/rust/sedona-functions/src/barrier.rs
@@ -333,7 +333,6 @@ impl Barrier {
     /// Compare two scalar values using the given operator
     fn compare_values(left: &ScalarValue, op: &str, right: &ScalarValue) -> Result<bool> {
         use ScalarValue::*;
-
         match (left, right) {
             (Int64(Some(l)), Int64(Some(r))) => match op {
                 "=" | "==" => Ok(l == r),
@@ -386,6 +385,7 @@ mod tests {
     use super::*;
     use arrow_array::RecordBatch;
     use arrow_schema::{Field, Schema};
+    use datafusion::prelude::SessionContext;
     use datafusion_expr::ScalarUDF;
     use sedona_testing::testers::ScalarUdfTester;
 
@@ -652,8 +652,6 @@ mod tests {
         expression: &str,
         column_values: &[(&str, ScalarValue)],
     ) -> Result<bool> {
-        use datafusion::prelude::SessionContext;
-
         // Create schema from column values
         let mut fields = vec![];
         let mut arrays = vec![];
diff --git a/rust/sedona-functions/src/st_dimension.rs b/rust/sedona-functions/src/st_dimension.rs
index beb284c6..9911e8ff 100644
--- a/rust/sedona-functions/src/st_dimension.rs
+++ b/rust/sedona-functions/src/st_dimension.rs
@@ -103,6 +103,7 @@ fn invoke_scalar(item: &Wkb) -> Result<i8> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -119,8 +120,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let tester = ScalarUdfTester::new(st_dimension_udf().into(), vec![sedona_type.clone()]);
 
         tester.assert_return_type(DataType::Int8);
diff --git a/rust/sedona-functions/src/st_geometrytype.rs b/rust/sedona-functions/src/st_geometrytype.rs
index 6cccf0e0..e5cb0812 100644
--- a/rust/sedona-functions/src/st_geometrytype.rs
+++ b/rust/sedona-functions/src/st_geometrytype.rs
@@ -118,6 +118,7 @@ fn infer_geometry_type_name(buf: &[u8]) -> Result<&'static str> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -134,8 +135,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let udf: ScalarUDF = st_geometry_type_udf().into();
         let tester = ScalarUdfTester::new(udf, vec![sedona_type]);
         tester.assert_return_type(DataType::Utf8);
diff --git a/rust/sedona-functions/src/st_haszm.rs b/rust/sedona-functions/src/st_haszm.rs
index eeae58f5..a4a20fff 100644
--- a/rust/sedona-functions/src/st_haszm.rs
+++ b/rust/sedona-functions/src/st_haszm.rs
@@ -23,6 +23,7 @@ use datafusion_common::error::Result;
 use datafusion_expr::{
     scalar_doc_sections::DOC_SECTION_OTHER, ColumnarValue, Documentation, Volatility,
 };
+use geo_traits::GeometryCollectionTrait;
 use geo_traits::{Dimensions, GeometryTrait};
 use sedona_common::sedona_internal_err;
 use sedona_expr::scalar_udf::{SedonaScalarKernel, SedonaScalarUDF};
@@ -110,7 +111,6 @@ impl SedonaScalarKernel for STHasZm {
 fn invoke_scalar(item: &Wkb, dim_index: usize) -> Result<Option<bool>> {
     match item.as_type() {
         geo_traits::GeometryType::GeometryCollection(collection) => {
-            use geo_traits::GeometryCollectionTrait;
             if collection.num_geometries() == 0 {
                 Ok(Some(false))
             } else {
diff --git a/rust/sedona-functions/src/st_isclosed.rs b/rust/sedona-functions/src/st_isclosed.rs
index 0010f892..2ae6d4a7 100644
--- a/rust/sedona-functions/src/st_isclosed.rs
+++ b/rust/sedona-functions/src/st_isclosed.rs
@@ -124,6 +124,7 @@ fn is_geometry_closed(item: &Wkb) -> Result<bool> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -140,8 +141,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let tester = ScalarUdfTester::new(st_isclosed_udf().into(), vec![sedona_type.clone()]);
 
         tester.assert_return_type(DataType::Boolean);
diff --git a/rust/sedona-functions/src/st_isempty.rs b/rust/sedona-functions/src/st_isempty.rs
index cc06ed2e..eae8e7dd 100644
--- a/rust/sedona-functions/src/st_isempty.rs
+++ b/rust/sedona-functions/src/st_isempty.rs
@@ -98,6 +98,7 @@ fn invoke_scalar(item: &Wkb) -> Result<bool> {
 #[cfg(test)]
 mod tests {
     use arrow_array::{create_array as arrow_array, ArrayRef};
+    use datafusion_common::ScalarValue;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
@@ -114,8 +115,6 @@ mod tests {
 
     #[rstest]
     fn udf(#[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] sedona_type: SedonaType) {
-        use datafusion_common::ScalarValue;
-
         let tester = ScalarUdfTester::new(st_isempty_udf().into(), vec![sedona_type.clone()]);
 
         tester.assert_return_type(DataType::Boolean);
diff --git a/rust/sedona-functions/src/st_point.rs b/rust/sedona-functions/src/st_point.rs
index c944d212..42f893ae 100644
--- a/rust/sedona-functions/src/st_point.rs
+++ b/rust/sedona-functions/src/st_point.rs
@@ -155,9 +155,11 @@ fn populate_wkb_item(item: &mut [u8], x: &f64, y: &f64) {
 #[cfg(test)]
 mod tests {
     use arrow_array::create_array;
+    use arrow_array::ArrayRef;
     use arrow_schema::DataType;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
+    use sedona_testing::compare::assert_array_equal;
     use sedona_testing::{create::create_array, testers::ScalarUdfTester};
 
     use super::*;
@@ -179,9 +181,6 @@ mod tests {
     #[case(DataType::Float64, DataType::Float32)]
     #[case(DataType::Float32, DataType::Float32)]
     fn udf_invoke(#[case] lhs_type: DataType, #[case] rhs_type: DataType) {
-        use arrow_array::ArrayRef;
-        use sedona_testing::compare::assert_array_equal;
-
         let udf = st_point_udf();
 
         let lhs_scalar_null = ScalarValue::Float64(None).cast_to(&lhs_type).unwrap();
diff --git a/rust/sedona-geo/src/st_dwithin.rs b/rust/sedona-geo/src/st_dwithin.rs
index 25e8bf26..11211a81 100644
--- a/rust/sedona-geo/src/st_dwithin.rs
+++ b/rust/sedona-geo/src/st_dwithin.rs
@@ -88,6 +88,7 @@ mod tests {
     use sedona_schema::datatypes::{WKB_GEOMETRY, WKB_VIEW_GEOMETRY};
     use sedona_testing::create::create_scalar;
     use sedona_testing::testers::ScalarUdfTester;
+    use sedona_testing::{compare::assert_array_equal, create::create_array};
 
     use super::*;
 
@@ -96,8 +97,6 @@ mod tests {
         #[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] left_sedona_type: SedonaType,
         #[values(WKB_GEOMETRY, WKB_VIEW_GEOMETRY)] right_sedona_type: SedonaType,
     ) {
-        use sedona_testing::{compare::assert_array_equal, create::create_array};
-
         let udf = SedonaScalarUDF::from_kernel("st_dwithin", st_dwithin_impl());
         let tester = ScalarUdfTester::new(
             udf.into(),
diff --git a/rust/sedona-spatial-join/src/exec.rs b/rust/sedona-spatial-join/src/exec.rs
index effc8958..6dc935b7 100644
--- a/rust/sedona-spatial-join/src/exec.rs
+++ b/rust/sedona-spatial-join/src/exec.rs
@@ -19,14 +19,18 @@ use std::{fmt::Formatter, sync::Arc};
 use arrow_schema::SchemaRef;
 use datafusion_common::{project_schema, DataFusionError, JoinSide, Result};
 use datafusion_execution::{SendableRecordBatchStream, TaskContext};
-use datafusion_expr::JoinType;
-use datafusion_physical_expr::equivalence::{join_equivalence_properties, ProjectionMapping};
-use datafusion_physical_expr::PhysicalExpr;
+use datafusion_expr::{JoinType, Operator};
+use datafusion_physical_expr::{
+    equivalence::{join_equivalence_properties, ProjectionMapping},
+    expressions::{BinaryExpr, Column},
+    PhysicalExpr,
+};
 use datafusion_physical_plan::{
     execution_plan::EmissionType,
     joins::utils::{build_join_schema, check_join_is_valid, ColumnIndex, JoinFilter},
     metrics::{ExecutionPlanMetricsSet, MetricsSet},
-    DisplayAs, DisplayFormatType, ExecutionPlan, ExecutionPlanProperties, PlanProperties,
+    DisplayAs, DisplayFormatType, ExecutionPlan, ExecutionPlanProperties, Partitioning,
+    PlanProperties,
 };
 use parking_lot::Mutex;
 
@@ -48,9 +52,6 @@ type BuildProbePlans<'a> = (&'a Arc<dyn ExecutionPlan>, &'a Arc<dyn ExecutionPla
 fn extract_equality_conditions(
     filter: &JoinFilter,
 ) -> Vec<(Arc<dyn PhysicalExpr>, Arc<dyn PhysicalExpr>)> {
-    use datafusion_expr::Operator;
-    use datafusion_physical_expr::expressions::{BinaryExpr, Column};
-
     let mut equalities = Vec::new();
 
     if let Some(binary_expr) = filter.expression().as_any().downcast_ref::<BinaryExpr>() {
@@ -269,7 +270,7 @@ impl SpatialJoinExec {
             // Replicate HashJoin's symmetric partitioning logic
             // HashJoin preserves partitioning from both sides for inner joins
             // and from one side for outer joins
-            use datafusion_physical_plan::Partitioning;
+
             match join_type {
                 JoinType::Inner | JoinType::Left | JoinType::LeftSemi | JoinType::LeftAnti => {
                     left.output_partitioning().clone()
diff --git a/rust/sedona-spatial-join/src/index.rs b/rust/sedona-spatial-join/src/index.rs
index 4e95527b..3b0a8b32 100644
--- a/rust/sedona-spatial-join/src/index.rs
+++ b/rust/sedona-spatial-join/src/index.rs
@@ -41,6 +41,7 @@ use parking_lot::Mutex;
 use sedona_expr::statistics::GeoStatistics;
 use sedona_functions::st_analyze_aggr::AnalyzeAccumulator;
 use sedona_geo::to_geo::item_to_geometry;
+use sedona_geo_generic_alg::algorithm::Centroid;
 use sedona_schema::datatypes::WKB_GEOMETRY;
 use wkb::reader::Wkb;
 
@@ -587,7 +588,7 @@ impl SpatialIndex {
                 let max_distance = distances_with_indices[k_idx].0;
 
                 // For tie-breakers, create spatial envelope around probe centroid and use rtree.search()
-                use sedona_geo_generic_alg::algorithm::Centroid;
+
                 let probe_centroid = probe_geom.centroid().unwrap_or(Point::new(0.0, 0.0));
                 let probe_x = probe_centroid.x() as f32;
                 let probe_y = probe_centroid.y() as f32;
@@ -1014,9 +1015,13 @@ mod tests {
     use crate::spatial_predicate::{RelationPredicate, SpatialRelationType};
 
     use super::*;
+    use arrow_array::RecordBatch;
+    use arrow_schema::{DataType, Field};
     use datafusion_execution::memory_pool::GreedyMemoryPool;
     use datafusion_physical_expr::expressions::Column;
+    use geo_traits::Dimensions;
     use sedona_common::option::{ExecutionMode, SpatialJoinOptions};
+    use sedona_geometry::wkb_factory::write_wkb_empty_point;
     use sedona_schema::datatypes::WKB_GEOMETRY;
     use sedona_testing::create::create_array;
 
@@ -1053,9 +1058,6 @@ mod tests {
 
     #[test]
     fn test_spatial_index_builder_add_batch() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
             execution_mode: ExecutionMode::PrepareBuild,
@@ -1109,9 +1111,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_execution_with_sample_data() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create a spatial index with sample geometry data
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1207,9 +1206,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_execution_with_different_k_values() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create spatial index with more data points
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1297,9 +1293,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_execution_with_spheroid_distance() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create spatial index
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1393,9 +1386,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_execution_edge_cases() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create spatial index
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1530,9 +1520,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_execution_with_tie_breakers() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create a spatial index with sample geometry data
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1644,9 +1631,6 @@ mod tests {
 
     #[test]
     fn test_query_knn_with_geometry_distance() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create a spatial index with sample geometry data
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1730,9 +1714,6 @@ mod tests {
 
     #[test]
     fn test_query_knn_with_mixed_geometries() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create a spatial index with complex geometries where geometry-based
         // distance should differ from centroid-based distance
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
@@ -1814,9 +1795,6 @@ mod tests {
 
     #[test]
     fn test_query_knn_with_tie_breakers_geometry_distance() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-
         // Create a spatial index with geometries that have identical distances for tie-breaker testing
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
@@ -1909,11 +1887,6 @@ mod tests {
 
     #[test]
     fn test_knn_query_with_empty_geometry() {
-        use arrow_array::RecordBatch;
-        use arrow_schema::{DataType, Field};
-        use geo_traits::Dimensions;
-        use sedona_geometry::wkb_factory::write_wkb_empty_point;
-
         // Create a spatial index with sample geometry data like other tests
         let memory_pool = Arc::new(GreedyMemoryPool::new(1024 * 1024));
         let options = SpatialJoinOptions {
diff --git a/rust/sedona-spatial-join/src/optimizer.rs b/rust/sedona-spatial-join/src/optimizer.rs
index db81641b..e996906c 100644
--- a/rust/sedona-spatial-join/src/optimizer.rs
+++ b/rust/sedona-spatial-join/src/optimizer.rs
@@ -39,6 +39,7 @@ use datafusion_physical_expr::{PhysicalExpr, ScalarFunctionExpr};
 use datafusion_physical_plan::coalesce_partitions::CoalescePartitionsExec;
 use datafusion_physical_plan::joins::utils::ColumnIndex;
 use datafusion_physical_plan::joins::{HashJoinExec, NestedLoopJoinExec};
+use datafusion_physical_plan::projection::ProjectionExec;
 use datafusion_physical_plan::{joins::utils::JoinFilter, ExecutionPlan};
 use sedona_common::{option::SedonaOptions, sedona_internal_err};
 use sedona_expr::utils::{parse_distance_predicate, ParsedDistancePredicate};
@@ -505,9 +506,6 @@ impl SpatialJoinOptimizer {
         expected_schema: &SchemaRef,
         spatial_schema: &SchemaRef,
     ) -> Result<Arc<dyn ExecutionPlan>> {
-        use datafusion_physical_expr::expressions::Column;
-        use datafusion_physical_plan::projection::ProjectionExec;
-
         // The challenge is to map from the expected HashJoinExec schema to SpatialJoinExec schema
         //
         // Expected schema has fields like: [id, name, name] (with duplicates)
@@ -1062,7 +1060,7 @@ mod tests {
     use arrow::datatypes::{DataType, Field, Schema};
     use datafusion_common::{JoinSide, ScalarValue};
     use datafusion_expr::Operator;
-    use datafusion_expr::{ColumnarValue, ScalarUDF, SimpleScalarUDF};
+    use datafusion_expr::{col, lit, ColumnarValue, Expr, ScalarUDF, SimpleScalarUDF};
     use datafusion_physical_expr::expressions::{BinaryExpr, Column, IsNotNullExpr, Literal};
     use datafusion_physical_expr::{PhysicalExpr, ScalarFunctionExpr};
     use datafusion_physical_plan::joins::utils::ColumnIndex;
@@ -2713,9 +2711,6 @@ mod tests {
 
     #[test]
     fn test_is_spatial_predicate() {
-        use datafusion_expr::ColumnarValue;
-        use datafusion_expr::{col, lit, Expr, ScalarUDF, SimpleScalarUDF};
-
         // Test 1: ST_ functions should return true
         let st_intersects_udf = create_dummy_st_intersects_udf();
         let st_intersects_expr = Expr::ScalarFunction(datafusion_expr::expr::ScalarFunction {
diff --git a/rust/sedona/src/context.rs b/rust/sedona/src/context.rs
index e75d5d83..ded65aa4 100644
--- a/rust/sedona/src/context.rs
+++ b/rust/sedona/src/context.rs
@@ -17,6 +17,7 @@
 use std::{collections::VecDeque, sync::Arc};
 
 use crate::exec::create_plan_from_sql;
+use crate::object_storage::ensure_object_store_registered_with_options;
 use crate::{
     catalog::DynamicObjectStoreCatalog,
     random_geometry_provider::RandomGeometryFunction,
@@ -229,7 +230,6 @@ impl SedonaContext {
 
         // Pre-register object store with our custom options before creating GeoParquetReadOptions
         if !urls.is_empty() {
-            use crate::object_storage::ensure_object_store_registered_with_options;
             // Extract the table options from GeoParquetReadOptions for object store registration
             let table_options_map = options.table_options().cloned().unwrap_or_default();
 
diff --git a/rust/sedona/src/object_storage.rs b/rust/sedona/src/object_storage.rs
index f6d9065c..8de36fdf 100644
--- a/rust/sedona/src/object_storage.rs
+++ b/rust/sedona/src/object_storage.rs
@@ -617,16 +617,15 @@ pub(crate) async fn register_object_store_and_config_extensions(
 
 #[cfg(test)]
 mod tests {
-    use crate::context::SedonaContext;
-
-    use super::*;
-
     use datafusion::common::plan_err;
     use datafusion::{
         datasource::listing::ListingTableUrl,
         logical_expr::{DdlStatement, LogicalPlan},
     };
 
+    use super::*;
+    use crate::context::SedonaContext;
+
     #[cfg(feature = "aws")]
     use object_store::{aws::AmazonS3ConfigKey, gcp::GoogleConfigKey};