Clippy

Author: abhi-airspace-intelligence

etl-destinations/src/delta/client.rs

@@ -124,7 +124,7 @@ impl DeltaLakeClient {
         table: Arc<DeltaTable>,
         delete_predicate: Option<&str>,
         record_batches: Vec<RecordBatch>,
-        app_transaction_id: Option<&str>,
+        _app_transaction_id: Option<&str>,
     ) -> DeltaResult<Arc<DeltaTable>> {
         // todo(abhi): Implement atomic delete+append transaction
         // todo(abhi): Use Delta transaction features for atomicity
@@ -162,6 +162,7 @@ impl DeltaLakeClient {
     }
 
     /// Run OPTIMIZE operation on the table
+    #[allow(unused)]
     pub async fn optimize_table(
         &self,
         table: Arc<DeltaTable>,

etl-destinations/src/delta/core.rs

@@ -250,7 +250,7 @@ where
         &self,
         table_id: TableId,
         upserts_by_pk: &HashMap<String, TableRow>,
-        delete_pks: &HashSet<String>,
+        _delete_pks: &HashSet<String>,
     ) -> EtlResult<()> {
         // todo(abhi): Implement the transaction logic from PLAN.md
         // todo(abhi): Delete rows with PK in affected set
@@ -281,6 +281,7 @@ where
     }
 
     /// Run table optimization (OPTIMIZE)
+    #[allow(unused)]
     async fn optimize_table(&self, _table_path: &str) -> EtlResult<()> {
         // todo(abhi): Implement OPTIMIZE operation using delta-rs
         // todo(abhi): Small file compaction and Z-ordering

etl-destinations/src/delta/encoding.rs

@@ -44,12 +44,11 @@ impl TableRowEncoder {
 
         let arrow_schema = Schema::new(fields);
 
-        let result = RecordBatch::try_new(Arc::new(arrow_schema), arrays);
-
-        result
+        RecordBatch::try_new(Arc::new(arrow_schema), arrays)
     }
 
     /// Convert Delta schema to Arrow schema
+    #[allow(unused)]
     fn delta_schema_to_arrow(
         delta_schema: &deltalake::kernel::StructType,
     ) -> Result<Schema, ArrowError> {
@@ -60,24 +59,24 @@ impl TableRowEncoder {
             .fields()
             .map(|field| {
                 // Convert Delta DataType to Arrow DataType
-                let arrow_type = match field.data_type() {
-                    &deltalake::kernel::DataType::BOOLEAN => DataType::Boolean,
-                    &deltalake::kernel::DataType::STRING => DataType::Utf8,
-                    &deltalake::kernel::DataType::INTEGER => DataType::Int32,
-                    &deltalake::kernel::DataType::LONG => DataType::Int64,
-                    &deltalake::kernel::DataType::SHORT => DataType::Int16,
-                    &deltalake::kernel::DataType::FLOAT => DataType::Float32,
-                    &deltalake::kernel::DataType::DOUBLE => DataType::Float64,
-                    &deltalake::kernel::DataType::DATE => DataType::Date32,
-                    &deltalake::kernel::DataType::TIMESTAMP => DataType::Timestamp(
+                let arrow_type = match *field.data_type() {
+                    deltalake::kernel::DataType::BOOLEAN => DataType::Boolean,
+                    deltalake::kernel::DataType::STRING => DataType::Utf8,
+                    deltalake::kernel::DataType::INTEGER => DataType::Int32,
+                    deltalake::kernel::DataType::LONG => DataType::Int64,
+                    deltalake::kernel::DataType::SHORT => DataType::Int16,
+                    deltalake::kernel::DataType::FLOAT => DataType::Float32,
+                    deltalake::kernel::DataType::DOUBLE => DataType::Float64,
+                    deltalake::kernel::DataType::DATE => DataType::Date32,
+                    deltalake::kernel::DataType::TIMESTAMP => DataType::Timestamp(
                         deltalake::arrow::datatypes::TimeUnit::Microsecond,
                         Some("UTC".into()),
                     ),
-                    &deltalake::kernel::DataType::TIMESTAMP_NTZ => DataType::Timestamp(
+                    deltalake::kernel::DataType::TIMESTAMP_NTZ => DataType::Timestamp(
                         deltalake::arrow::datatypes::TimeUnit::Microsecond,
                         None,
                     ),
-                    &deltalake::kernel::DataType::BINARY => DataType::Binary,
+                    deltalake::kernel::DataType::BINARY => DataType::Binary,
                     // Default to string for complex/unsupported types
                     _ => DataType::Utf8,
                 };
@@ -184,6 +183,7 @@ impl TableRowEncoder {
     }
 
     /// Convert Cell values to specific Arrow array types
+    #[allow(unused)]
     fn convert_bool_column(cells: Vec<&Cell>) -> Result<ArrayRef, ArrowError> {
         // todo(abhi): Extract boolean values from cells, handle nulls
         let values: Vec<Option<bool>> = cells
@@ -198,6 +198,7 @@ impl TableRowEncoder {
         Ok(Arc::new(BooleanArray::from(values)))
     }
 
+    #[allow(unused)]
     fn convert_string_column(cells: Vec<&Cell>) -> Result<ArrayRef, ArrowError> {
         // todo(abhi): Extract string values from cells, handle nulls and conversions
         let values: Vec<Option<String>> = cells
@@ -213,6 +214,7 @@ impl TableRowEncoder {
         Ok(Arc::new(StringArray::from(values)))
     }
 
+    #[allow(unused)]
     fn convert_int32_column(cells: Vec<&Cell>) -> Result<ArrayRef, ArrowError> {
         // todo(abhi): Extract i32 values from cells, handle nulls and conversions
         let values: Vec<Option<i32>> = cells
@@ -228,6 +230,7 @@ impl TableRowEncoder {
         Ok(Arc::new(Int32Array::from(values)))
     }
 
+    #[allow(unused)]
     fn convert_array_column(cells: Vec<&Cell>) -> Result<ArrayRef, ArrowError> {
         // todo(abhi): Convert ArrayCell variants to Arrow ListArray
         // todo(abhi): Handle nested arrays properly with element type detection

etl-destinations/tests/common/delta.rs

@@ -34,6 +34,7 @@ fn random_warehouse_path() -> String {
 ///
 /// Provides a unified interface for Delta Lake operations in tests, automatically
 /// handling setup of test warehouse locations using minio as the object storage backend.
+#[allow(unused)]
 pub struct DeltaLakeDatabase {
     warehouse_path: String,
     s3_base_uri: String,
@@ -43,6 +44,7 @@ pub struct DeltaLakeDatabase {
     bucket: String,
 }
 
+#[allow(unused)]
 impl DeltaLakeDatabase {
     /// Creates a new Delta Lake database instance.
     ///
@@ -144,38 +146,3 @@ impl Drop for DeltaLakeDatabase {
 pub async fn setup_delta_connection() -> DeltaLakeDatabase {
     DeltaLakeDatabase::new().await
 }
-
-/// Test data structures for Delta Lake integration tests
-/// These mirror the BigQuery test structures but are designed for Delta Lake
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct DeltaUser {
-    pub id: i32,
-    pub name: String,
-    pub age: i32,
-}
-
-impl DeltaUser {
-    pub fn new(id: i32, name: &str, age: i32) -> Self {
-        Self {
-            id,
-            name: name.to_owned(),
-            age,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct DeltaOrder {
-    pub id: i32,
-    pub description: String,
-}
-
-impl DeltaOrder {
-    pub fn new(id: i32, description: &str) -> Self {
-        Self {
-            id,
-            description: description.to_owned(),
-        }
-    }
-}