hyperstreamdb 0.2.4__tar.gz → 0.2.5__tar.gz

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/Cargo.lock

@@ -3375,7 +3375,7 @@ dependencies = [
 
 [[package]]
 name = "hyperstreamdb"
-version = "0.2.4"
+version = "0.2.5"
 dependencies = [
  "ahash 0.8.12",
  "anyhow",
@@ -7141,6 +7141,16 @@ dependencies = [
  "web-time",
 ]
 
+[[package]]
+name = "tracing-serde"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
 [[package]]
 name = "tracing-subscriber"
 version = "0.3.23"
@@ -7151,12 +7161,15 @@ dependencies = [
  "nu-ansi-term",
  "once_cell",
  "regex-automata",
+ "serde",
+ "serde_json",
  "sharded-slab",
  "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
  "tracing-log",
+ "tracing-serde",
 ]
 
 [[package]]

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hyperstreamdb"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2021"
 license = "MIT AND Apache-2.0"
 description = "HyperStreamDB - Serverless Index-Streaming Database with Overlay Indexing and Vector Search"
@@ -102,7 +102,7 @@ anyhow = "1.0"
 
 # logging
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 url = "2.5"
 uuid = { version = "1.10", features = ["v4", "fast-rng", "macro-diagnostics"] }
 chrono = "0.4"

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperstreamdb
-Version: 0.2.4
+Version: 0.2.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Rust

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/compaction.rs

@@ -510,7 +510,7 @@ mod tests {
         // - Manifests v1, v2, v3
         // - The 3 original data files (since they are ONLY in v1-v3)
         let deleted = table.vacuum_async(1).await?;
-        println!("Vacuum deleted {} files", deleted);
+        tracing::info!("Vacuum deleted {} files", deleted);
         
         // We expect at least 3 data files + 3 manifest files = 6 files deleted
         assert!(deleted >= 6);

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/ffi.rs

@@ -108,7 +108,7 @@ pub extern "system" fn Java_com_hyperstreamdb_trino_HyperStreamDBPageSource_open
             Box::into_raw(Box::new(session)) as jlong
         },
         Err(e) => {
-            eprintln!("FFI Error opening session: {}", e);
+            tracing::error!("FFI Error opening session: {}", e);
             0
         }
     }
@@ -196,7 +196,7 @@ pub extern "system" fn Java_com_hyperstreamdb_trino_HyperStreamDBSplitManager_ge
             }
         },
         Err(e) => {
-             eprintln!("FFI Error creating table: {}", e);
+             tracing::error!("FFI Error creating table: {}", e);
              "[]".to_string()
         }
     };
@@ -234,7 +234,7 @@ pub extern "system" fn Java_com_hyperstreamdb_spark_HyperStreamScanBuilder_listD
             }
         },
         Err(e) => {
-             eprintln!("FFI Error creating table: {}", e);
+             tracing::error!("FFI Error creating table: {}", e);
              "[]".to_string()
         }
     };
@@ -267,7 +267,7 @@ fn open_session_helper(mut env: JNIEnv, path: JString) -> jlong {
     match HyperStreamSession::new(&path_str) {
         Ok(session) => Box::into_raw(Box::new(session)) as jlong,
         Err(e) => {
-            eprintln!("FFI Error opening session: {}", e);
+            tracing::error!("FFI Error opening session: {}", e);
             0
         }
     }

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/iceberg.rs

@@ -1240,19 +1240,24 @@ impl IcebergWriter {
                  s if s.starts_with("truncate[") => r#"["null", "string"]"#,
                  "identity" => {
                      let source_id = field.source_ids.first().copied().or(field.source_id);
-                     if let Some(id) = source_id {
-                         if let Some(source_field) = schema.fields.iter().find(|f| f.id == id) {
-                             match source_field.type_str.as_str() {
-                                 "Int32" | "int" => r#"["null", "int"]"#,
-                                 "Int64" | "long" => r#"["null", "long"]"#,
-                                 "Float32" | "float" => r#"["null", "float"]"#,
-                                 "Float64" | "double" => r#"["null", "double"]"#,
-                                 "Boolean" | "bool" | "boolean" => r#"["null", "boolean"]"#,
-                                 "string" | "utf8" | "utf-8" | "String" | "Utf8" => r#"["null", "string"]"#,
-                                 _ => r#"["null", "string"]"#,
-                             }
+                     // Robustness: Prioritize Name-based resolution, fallback to ID (Name-First strategy)
+                     let resolved_field = schema.fields.iter().find(|sf| sf.name == field.name).cloned().or_else(|| {
+                         if let Some(id) = source_id {
+                             schema.fields.iter().find(|f| f.id == id).cloned()
                          } else {
-                             r#"["null", "string"]"#
+                             None
+                         }
+                     });
+
+                     if let Some(f) = resolved_field {
+                         match f.type_str.as_str() {
+                             "Int32" | "int" => r#"["null", "int"]"#,
+                             "Int64" | "long" => r#"["null", "long"]"#,
+                             "Float32" | "float" => r#"["null", "float"]"#,
+                             "Float64" | "double" => r#"["null", "double"]"#,
+                             "Boolean" | "bool" | "boolean" => r#"["null", "boolean"]"#,
+                             "string" | "utf8" | "utf-8" | "String" | "Utf8" => r#"["null", "string"]"#,
+                             _ => r#"["null", "string"]"#,
                          }
                      } else {
                          r#"["null", "string"]"#

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/manifest.rs

@@ -1628,15 +1628,19 @@ impl PartitionSpec {
         for i in 0..batch.num_rows() {
             let mut key = Vec::with_capacity(self.fields.len());
             for field in &self.fields {
-                // Determine source columns
+                                // Determine source columns
                 let source_ids = field.get_source_ids();
                 let mut cols = Vec::new();
                 
-                // Try finding by name first
+                // Prioritize finding by Name (most intuitive for users)
+                let mut found = false;
                 if let Ok(idx) = batch.schema().index_of(&field.name) {
                     cols.push(batch.column(idx));
-                } else {
-                    // Search by Iceberg IDs
+                    found = true;
+                }
+
+                // Fallback to Iceberg IDs only if name lookup failed
+                if !found {
                     for id in &source_ids {
                         let idx = batch.schema().fields().iter().position(|f| {
                             f.metadata().get("iceberg.id")

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/merge.rs

@@ -126,7 +126,7 @@ impl MergePlanner {
     ) -> Result<Vec<(Option<SegmentId>, SegmentId)>> 
     where F: Fn(&SegmentId, &str) -> Result<Option<RoaringBitmap>>
     {
-        println!("Executing Merge on {} candidates", candidate_segments.len());
+        tracing::info!("Executing Merge on {} candidates", candidate_segments.len());
         
         let mut updates_by_segment: HashMap<SegmentId, Vec<usize>> = HashMap::new();
         let mut unmatched_rows: Vec<usize> = Vec::new();
@@ -198,7 +198,7 @@ impl MergePlanner {
         
         // 2. Process Updates (Copy-on-Write)
         for (seg_id, source_row_indices) in updates_by_segment {
-            println!("Updating Segment {} with {} rows", seg_id, source_row_indices.len());
+            tracing::info!("Updating Segment {} with {} rows", seg_id, source_row_indices.len());
             
             // A. Read Original Segment
             // Use empty base path for reader configuration because store is already rooted at base_path
@@ -276,7 +276,7 @@ impl MergePlanner {
         
         // 3. Process Inserts (Unmatched)
         if !unmatched_rows.is_empty() {
-            println!("Inserting {} new rows", unmatched_rows.len());
+            tracing::info!("Inserting {} new rows", unmatched_rows.len());
             let indices_arr = arrow::array::UInt32Array::from(unmatched_rows.iter().map(|&x| x as u32).collect::<Vec<u32>>());
             let inserts_batch = arrow::compute::take_record_batch(source_batch, &indices_arr)?;
             

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/segment.rs

@@ -124,9 +124,7 @@ impl HybridSegmentWriter {
             }
         }
         
-        if !index_files.is_empty() {
-            eprintln!("DEBUG: to_manifest_entry: segment_id={}, generated index_files={:?}", self.config.segment_id, index_files);
-        }
+
 
         ManifestEntry {
             file_path: self.config.parquet_path.clone().unwrap_or(parquet_file),
@@ -346,7 +344,7 @@ impl HybridSegmentWriter {
             files.push(path.to_str().unwrap().to_string());
         }
 
-        println!("Written data to {} ({} rows)", path.display(), batch.num_rows());
+        tracing::info!("Written data to {} ({} rows)", path.display(), batch.num_rows());
         self.record_count.fetch_add(batch.num_rows(), std::sync::atomic::Ordering::Relaxed);
         
         Ok(())
@@ -409,7 +407,7 @@ impl HybridSegmentWriter {
     /// Build indexes for a batch (can be called asynchronously after write_batch).
     /// This is the expensive operation that should run in background.
     pub fn build_indexes(&self, batch: &RecordBatch) -> Result<()> {
-        println!("Building indexes for batch of {} rows", batch.num_rows());
+        tracing::info!("Building indexes for batch of {} rows", batch.num_rows());
         let schema = batch.schema();
         let _fields = schema.fields();
 
@@ -439,20 +437,20 @@ impl HybridSegmentWriter {
     pub fn index_column(&self, col_name: &str, col_array: &std::sync::Arc<dyn Array>) -> Result<()> {
         // Apply per-column device override if specified
         if let Some(device_str) = self.config.column_devices.get(col_name) {
-            println!("Applying device override for column {}: {}", col_name, device_str);
+            tracing::info!("Applying device override for column {}: {}", col_name, device_str);
             if let Ok(ctx) = ComputeContext::from_device_str(device_str) {
-                println!("Successfully set global GPU context to {:?} for column {}", ctx.backend, col_name);
+                tracing::info!("Successfully set global GPU context to {:?} for column {}", ctx.backend, col_name);
                 set_global_gpu_context(Some(ctx));
             } else {
-                println!("Failed to parse device string: {}", device_str);
+                tracing::warn!("Failed to parse device string: {}", device_str);
             }
         } else if let Some(ref device_str) = self.config.default_device {
-            println!("Applying default device for column {}: {}", col_name, device_str);
+            tracing::info!("Applying default device for column {}: {}", col_name, device_str);
             if let Ok(ctx) = ComputeContext::from_device_str(device_str) {
-                println!("Successfully set global GPU context to {:?} for column {}", ctx.backend, col_name);
+                tracing::info!("Successfully set global GPU context to {:?} for column {}", ctx.backend, col_name);
                 set_global_gpu_context(Some(ctx));
             } else {
-                println!("Failed to parse default device string: {}", device_str);
+                tracing::warn!("Failed to parse default device string: {}", device_str);
             }
         }
 
@@ -487,7 +485,7 @@ impl HybridSegmentWriter {
         match col_array.data_type() {
                 // Scalar Indexing (RoaringBitmap for Int32)
                 arrow::datatypes::DataType::Int32 => {
-                    println!("Indexing Int32 column: {}", col_name);
+                    tracing::info!("Indexing Int32 column: {}", col_name);
                     let _array = col_array.as_any().downcast_ref::<arrow::array::Int32Array>().unwrap();
                     
                     // Scalar index (.idx) is removed for Int32 as we use more precise Inverted Index
@@ -568,7 +566,7 @@ impl HybridSegmentWriter {
 
                 arrow::datatypes::DataType::List(inner) | arrow::datatypes::DataType::FixedSizeList(inner, _) => {
                      if *inner.data_type() == arrow::datatypes::DataType::Float32 {
-                        println!("Indexing Vector column: {} (type={:?})", col_name, col_array.data_type());
+                        tracing::info!("Indexing Vector column: {} (type={:?})", col_name, col_array.data_type());
                         
                         let vectors: Vec<Vec<f32>> = match col_array.data_type() {
                             arrow::datatypes::DataType::FixedSizeList(_, _) => {
@@ -604,9 +602,9 @@ impl HybridSegmentWriter {
                         if self.config.index_all || in_config {
                             let use_pq = vectors.len() > 5_000;
                             if use_pq {
-                                println!("Auto-enabling PQ for segment ({} vectors)", vectors.len());
+                                tracing::info!("Auto-enabling PQ for segment ({} vectors)", vectors.len());
                             }
-                            println!("Building HNSW-IVF index (blocking): {} vectors, {} dims, use_pq={}", vectors.len(), _dim, use_pq);
+                            tracing::info!("Building HNSW-IVF index (blocking): {} vectors, {} dims, use_pq={}", vectors.len(), _dim, use_pq);
                             let hnsw_ivf_index = HnswIvfIndex::build(vectors, crate::core::index::VectorMetric::L2, None, None, use_pq)
                                 .map_err(|e| anyhow::anyhow!("HNSW-IVF build failed: {}", e))?;
                             
@@ -619,12 +617,12 @@ impl HybridSegmentWriter {
                                 files.extend(saved_files);
                             }
                         } else {
-                            println!("Skipping vector indexing for column {} (delayed/background mode)", col_name);
+                            tracing::info!("Skipping vector indexing for column {} (delayed/background mode)", col_name);
                         }
                      }
                 },
                 arrow::datatypes::DataType::Int64 => {
-                    println!("Indexing Int64 column: {}", col_name);
+                    tracing::info!("Indexing Int64 column: {}", col_name);
                     let _array = col_array.as_any().downcast_ref::<arrow::array::Int64Array>().unwrap();
                     
                     // No mock .idx for Int64
@@ -700,7 +698,7 @@ impl HybridSegmentWriter {
                 },
 
                 arrow::datatypes::DataType::Float64 => {
-                    println!("Indexing Float64 column: {}", col_name);
+                    tracing::info!("Indexing Float64 column: {}", col_name);
                     let _array = col_array.as_any().downcast_ref::<arrow::array::Float64Array>().unwrap();
                     
                     // No mock .idx for Float64
@@ -777,7 +775,7 @@ impl HybridSegmentWriter {
                 },
 
                 arrow::datatypes::DataType::Float32 => {
-                    println!("Indexing Float32 column: {}", col_name);
+                    tracing::info!("Indexing Float32 column: {}", col_name);
                     let array = col_array.as_any().downcast_ref::<arrow::array::Float32Array>().unwrap();
                     
                     // No mock .idx for Float32
@@ -834,7 +832,7 @@ impl HybridSegmentWriter {
                 
                 // String/Utf8 Inverted Index - for category/tag filtering
                 arrow::datatypes::DataType::Utf8 | arrow::datatypes::DataType::LargeUtf8 => {
-                    println!("Indexing String column: {}", col_name);
+                    tracing::info!("Indexing String column: {}", col_name);
                     
                     // Unified handling: cast to Utf8 to reuse existing logic
                     let casted_array = arrow::compute::cast(col_array, &arrow::datatypes::DataType::Utf8)
@@ -857,7 +855,7 @@ impl HybridSegmentWriter {
                         }
                     }
                     
-                    println!("  Found {} unique values", inverted_map.len());
+                    tracing::info!("  Found {} unique values", inverted_map.len());
                     
                     // Build Arrow Arrays for Parquet
                     let mut key_builder = arrow::array::StringBuilder::new();
@@ -901,13 +899,13 @@ impl HybridSegmentWriter {
                         files.push(inv_path.to_str().unwrap().to_string());
                     }
                     
-                    println!("String Inverted Index written to {}", inv_path.to_str().unwrap());
+                    tracing::info!("String Inverted Index written to {}", inv_path.to_str().unwrap());
                 },
                 
                 // Date32 Inverted Index - for date equality/range filtering
                 // Date32 = days since Unix epoch (1970-01-01)
                 arrow::datatypes::DataType::Date32 => {
-                    println!("Indexing Date32 column: {}", col_name);
+                    tracing::info!("Indexing Date32 column: {}", col_name);
                     let array = col_array.as_any().downcast_ref::<arrow::array::Date32Array>().unwrap();
                     
                     // Build inverted index: Date -> RowIDs
@@ -918,7 +916,7 @@ impl HybridSegmentWriter {
                         }
                     }
                     
-                    println!("  Found {} unique dates", inverted_map.len());
+                    tracing::info!("  Found {} unique dates", inverted_map.len());
                     
                     // Build Arrow Arrays for Parquet
                     let mut key_builder = arrow::array::Date32Builder::new();
@@ -960,13 +958,13 @@ impl HybridSegmentWriter {
                         files.push(inv_path.to_str().unwrap().to_string());
                     }
                     
-                    println!("Date32 Inverted Index written to {}", inv_path.to_str().unwrap());
+                    tracing::info!("Date32 Inverted Index written to {}", inv_path.to_str().unwrap());
                 },
                 
                 // Timestamp Inverted Index - truncate to day for practical indexing
                 // High-cardinality timestamps are truncated to day granularity
                 arrow::datatypes::DataType::Timestamp(_, _) => {
-                    println!("Indexing Timestamp column: {} (truncated to day)", col_name);
+                    tracing::info!("Indexing Timestamp column: {} (truncated to day)", col_name);
                     
                     // Truncate timestamps to day granularity for indexing
                     // This makes the inverted index practical (365 keys/year vs millions)
@@ -995,7 +993,7 @@ impl HybridSegmentWriter {
                         inverted_map.entry(day).or_default().push(row_i as u32);
                     }
                     
-                    println!("  Found {} unique days", inverted_map.len());
+                    tracing::info!("  Found {} unique days", inverted_map.len());
                     
                     // Build Arrow Arrays (store as Date32 for the index key)
                     let mut key_builder = arrow::array::Date32Builder::new();
@@ -1037,12 +1035,12 @@ impl HybridSegmentWriter {
                         files.push(inv_path.to_str().unwrap().to_string());
                     }
                     
-                    println!("Timestamp Inverted Index (day granularity) written to {}", inv_path.to_str().unwrap());
+                    tracing::info!("Timestamp Inverted Index (day granularity) written to {}", inv_path.to_str().unwrap());
                 },
                 
                 // Keep default
                 arrow::datatypes::DataType::Boolean => {
-                    println!("Indexing Boolean column: {} (native boolean index)", col_name);
+                    tracing::info!("Indexing Boolean column: {} (native boolean index)", col_name);
                      // Build inverted index: Boolean -> RowIDs (true/false as native booleans)
                     let mut inverted_map: std::collections::HashMap<bool, Vec<u32>> = std::collections::HashMap::new();
 
@@ -1094,12 +1092,12 @@ impl HybridSegmentWriter {
                         let mut files = self.generated_files.lock().unwrap();
                         files.push(inv_path.to_str().unwrap().to_string());
                     }
-                    println!("Boolean Inverted Index written to {}", inv_path.to_str().unwrap());
+                    tracing::info!("Boolean Inverted Index written to {}", inv_path.to_str().unwrap());
                 },
 
                 // Time32 (s/ms) -> Int32 keys
                 arrow::datatypes::DataType::Time32(unit) => {
-                    println!("Indexing Time32 column: {}", col_name);
+                    tracing::info!("Indexing Time32 column: {}", col_name);
                     let mut inverted_map: std::collections::HashMap<i32, Vec<u32>> = std::collections::HashMap::new();
                     
                     match unit {
@@ -1173,7 +1171,7 @@ impl HybridSegmentWriter {
 
                 // Time64 (us/ns) -> Int64 keys
                 arrow::datatypes::DataType::Time64(unit) => {
-                    println!("Indexing Time64 column: {}", col_name);
+                    tracing::info!("Indexing Time64 column: {}", col_name);
                     let mut inverted_map: std::collections::HashMap<i64, Vec<u32>> = std::collections::HashMap::new();
                     
                     match unit {
@@ -1247,7 +1245,7 @@ impl HybridSegmentWriter {
 
                 // Binary / LargeBinary / FixedSizeBinary -> Key is Vec<u8>
                 arrow::datatypes::DataType::Binary | arrow::datatypes::DataType::LargeBinary | arrow::datatypes::DataType::FixedSizeBinary(_) => {
-                     println!("Indexing Binary column: {}", col_name);
+                     tracing::info!("Indexing Binary column: {}", col_name);
                      // Cast to BinaryArray for uniform handling (if possible, else matching works)
                      // Simple handling: Iterate as BinaryArray (works for large and regular if we cast, or just use generics. 
                      // arrow::compute::cast to Binary is easiest)
@@ -1291,7 +1289,7 @@ impl HybridSegmentWriter {
 
                 // Decimal128
                 arrow::datatypes::DataType::Decimal128(precision, scale) => {
-                     println!("Indexing Decimal128 column: {}", col_name);
+                     tracing::info!("Indexing Decimal128 column: {}", col_name);
                      let array = col_array.as_any().downcast_ref::<arrow::array::Decimal128Array>().unwrap();
                      
                      let mut inverted_map: std::collections::HashMap<i128, Vec<u32>> = std::collections::HashMap::new();
@@ -1331,7 +1329,7 @@ impl HybridSegmentWriter {
 
                 // Dictionary Types (Recursive)
                 arrow::datatypes::DataType::Dictionary(_, value_type) => {
-                    println!("Indexing Dictionary column: {} (unpacking to {:?})", col_name, value_type.as_ref());
+                    tracing::info!("Indexing Dictionary column: {} (unpacking to {:?})", col_name, value_type.as_ref());
                     // Cast to value type to unpack
                     let casted = arrow::compute::cast(col_array, value_type)
                         .map_err(|e| anyhow::anyhow!("Failed to unpack dictionary: {}", e))?;
@@ -1341,7 +1339,7 @@ impl HybridSegmentWriter {
 
                 _ => {
                     // Skip unsupported
-                    eprintln!("Warning: Skipping indexing for unsupported type: {:?}", col_array.data_type());
+                    tracing::warn!("Skipping indexing for unsupported type: {:?}", col_array.data_type());
                 }
             }
 
@@ -1384,7 +1382,7 @@ impl HybridSegmentWriter {
              let mut files = self.generated_files.lock().unwrap();
              files.push(inv_path.to_str().unwrap().to_string());
         }
-        println!("Inverted Index written to {}", inv_path.display());
+        tracing::info!("Inverted Index written to {}", inv_path.display());
         Ok(())
     }
 }

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/table/mod.rs

@@ -1340,7 +1340,7 @@ impl Table {
         
         let candidates = planner.prune_entries(&all_entries, Some(&expr), None);
         let candidate_paths: std::collections::HashSet<String> = candidates.iter().map(|(e, _)| e.file_path.clone()).collect();
-        eprintln!("DEBUG: delete_async: filter='{}', potential candidates: {}", filter, candidates.len());
+        tracing::debug!("delete_async: filter='{}', potential candidates: {}", filter, candidates.len());
         
         let mut all_updated_entries = Vec::new();
 
@@ -1351,7 +1351,7 @@ impl Table {
                 continue;
             }
 
-            eprintln!("DEBUG: delete_async: processing segment {}", entry.file_path);
+            tracing::debug!("delete_async: processing segment {}", entry.file_path);
             let file_path_str = entry.file_path.clone();
             
             // Fix path resolution: find correct physical subdirectory
@@ -1538,7 +1538,7 @@ impl Table {
                                 let deleted = reader.load_merged_deletes().await?;
                                 let alive_bm = bm.clone() - deleted.clone();
                                 
-                                println!("DEBUG: PK Check for {}: Index bits: {}, Deleted bits: {}, Alive bits: {}", 
+                                tracing::debug!("PK Check for {}: Index bits: {}, Deleted bits: {}, Alive bits: {}", 
                                     f.column, bm.len(), deleted.len(), alive_bm.len());
                                 
                                 if let Some(current) = bitmap_opt {
@@ -2527,7 +2527,7 @@ mod tests {
         table.truncate_async().await?;
         let batches = table.read_async(None, None, None).await?;
         let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
-        println!("After truncate, read {} records in {} batches", total_rows, batches.len());
+        tracing::info!("After truncate, read {} records in {} batches", total_rows, batches.len());
         assert!(total_rows == 0, "Table should be empty after truncate, but found {} rows!", total_rows);
 
         // 4. Autocommit

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/table/read.rs

@@ -442,7 +442,7 @@ impl Table {
                 Ok(b_vec) => {
                      all_batches.extend(b_vec);
                 },
-                Err(e) => eprintln!("Error reading batch {}: {}", i, e),
+                Err(e) => tracing::error!("Error reading batch {}: {}", i, e),
             }
         }
 
@@ -609,7 +609,7 @@ impl Table {
                     }
                 }
                 Err(e) => {
-                    eprintln!("DEBUG: Failed to evaluate filter expression on batch: {}", e);
+                    tracing::error!("Failed to evaluate filter expression on batch: {}", e);
                 }
             }
         }

{hyperstreamdb-0.2.4 → hyperstreamdb-0.2.5}/src/core/table/schema.rs

@@ -51,7 +51,7 @@ impl Table {
         
         // Commit Metadata Only Change
         manifest_manager.update_schema(manifest.schemas, manifest.current_schema_id, Some(new_id)).await?;
-        println!("Schema Evolution: Added column '{}' (Schema ID: {})", name, new_schema_id);
+        tracing::info!("Schema Evolution: Added column '{}' (Schema ID: {})", name, new_schema_id);
         
         let new_arrow_schema = current_schema.to_arrow();
         let mut lock = self.schema.write().unwrap();
@@ -113,7 +113,7 @@ impl Table {
         };
         
         manifest_manager.commit(&[], &[], metadata).await?;
-        println!("Partition Evolution: New spec ID {} with {} fields", new_spec_id, fields.len());
+        tracing::info!("Partition Evolution: New spec ID {} with {} fields", new_spec_id, fields.len());
         
         Ok(())
     }
@@ -139,7 +139,7 @@ impl Table {
         manifest.schemas.push(current_schema.clone());
         manifest.current_schema_id = new_schema_id;
         manifest_manager.update_schema(manifest.schemas, manifest.current_schema_id, Some(manifest.last_column_id)).await?;
-        println!("Schema Evolution: Dropped column '{}' (Schema ID: {})", name, new_schema_id);
+        tracing::info!("Schema Evolution: Dropped column '{}' (Schema ID: {})", name, new_schema_id);
         
         let new_arrow_schema = current_schema.to_arrow();
         let mut lock = self.schema.write().unwrap();
@@ -167,7 +167,7 @@ impl Table {
         manifest.schemas.push(current_schema.clone());
         manifest.current_schema_id = new_schema_id;
         manifest_manager.update_schema(manifest.schemas, manifest.current_schema_id, Some(manifest.last_column_id)).await?;
-        println!("Schema Evolution: Renamed '{}' -> '{}' (Schema ID: {})", old_name, new_name, new_schema_id);
+        tracing::info!("Schema Evolution: Renamed '{}' -> '{}' (Schema ID: {})", old_name, new_name, new_schema_id);
         
         let new_arrow_schema = current_schema.to_arrow();
         let mut lock = self.schema.write().unwrap();
@@ -200,7 +200,7 @@ impl Table {
         manifest.current_schema_id = new_schema_id;
         
         manifest_manager.update_schema(manifest.schemas, manifest.current_schema_id, Some(manifest.last_column_id)).await?;
-        println!("Schema Evolution: Updated column type '{}' to '{}' (Schema ID: {})", name, new_type, new_schema_id);
+        tracing::info!("Schema Evolution: Updated column type '{}' to '{}' (Schema ID: {})", name, new_type, new_schema_id);
         
         let new_arrow_schema = current_schema.to_arrow();
         let mut lock = self.schema.write().unwrap();
@@ -249,7 +249,7 @@ impl Table {
         manifest.current_schema_id = new_schema_id;
         
         manifest_manager.update_schema(manifest.schemas, manifest.current_schema_id, Some(manifest.last_column_id)).await?;
-        println!("Schema Evolution: Moved column '{}' to index {} (Schema ID: {})", name, new_index, new_schema_id);
+        tracing::info!("Schema Evolution: Moved column '{}' to index {} (Schema ID: {})", name, new_index, new_schema_id);
         
         let new_arrow_schema = current_schema.to_arrow();
         let mut lock = self.schema.write().unwrap();