From bcc4f4d76f80c730ca81e695c719ca970876cbdc Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Tue, 10 Nov 2026 18:18:26 +0000 Subject: [PATCH 1/9] Test-only helpers leave production builds --- hyperbytedb-proxy/src/pool.rs | 3 +++ hyperbytedb/src/adapters/chdb/native_adapter.rs | 4 ++++ hyperbytedb/src/adapters/cluster/hinted_handoff.rs | 1 + hyperbytedb/src/adapters/cluster/replication_log.rs | 2 ++ hyperbytedb/src/adapters/wal/rocksdb_wal.rs | 1 + hyperbytedb/src/application/columnar_msgpack.rs | 3 +++ hyperbytedb/src/application/continuous_query_service.rs | 3 +++ hyperbytedb/src/application/flush_service.rs | 1 + hyperbytedb/src/application/forward_coalescer.rs | 3 +++ hyperbytedb/src/application/replication_apply.rs | 2 ++ hyperbytedb/src/application/shard_scheduler.rs | 3 +++ hyperbytedb/src/domain/chdb_naming.rs | 3 +++ hyperbytedb/src/domain/prepared_wal.rs | 2 ++ hyperbytedb/src/ports/query.rs | 3 +++ hyperbytedb/src/timeseriesql/ast.rs | 1 + 15 files changed, 35 insertions(+) diff --git a/hyperbytedb-proxy/src/pool.rs b/hyperbytedb-proxy/src/pool.rs index d51ffd0..859f3fa 100644 --- a/hyperbytedb-proxy/src/pool.rs +++ b/hyperbytedb-proxy/src/pool.rs @@ -81,6 +81,9 @@ impl BackendPool { } /// Replace the backend snapshot (tests and benchmarks only). + /// + /// Test support. + #[doc(hidden)] #[doc(hidden)] pub async fn set_backends_for_test(&self, backends: Vec>) { let mut guard = self.backends.write().await; diff --git a/hyperbytedb/src/adapters/chdb/native_adapter.rs b/hyperbytedb/src/adapters/chdb/native_adapter.rs index 19e00ec..68cb866 100644 --- a/hyperbytedb/src/adapters/chdb/native_adapter.rs +++ b/hyperbytedb/src/adapters/chdb/native_adapter.rs @@ -71,6 +71,7 @@ use crate::ports::points_sink::{PointsSinkPort, WriteAck}; /// Default threshold when no `[chdb].tag_low_cardinality_max` or cardinality /// config is available (e.g. unit tests constructing the adapter directly). +#[cfg(test)] pub const DEFAULT_TAG_LOW_CARDINALITY_MAX: usize = 100_000; /// Column kind for tags and fields. Tags use `LowCardinality(String)` only @@ -476,6 +477,9 @@ impl ChdbNativeAdapter { /// True if `series_id` is already registered (dimension row inserted + /// persisted) for this table. /// How many times `ensure_table` has probed the engine's columns. + /// + /// Test support. + #[doc(hidden)] #[doc(hidden)] pub fn engine_probe_count(&self) -> u64 { self.engine_probes diff --git a/hyperbytedb/src/adapters/cluster/hinted_handoff.rs b/hyperbytedb/src/adapters/cluster/hinted_handoff.rs index ddf00eb..e1061d7 100644 --- a/hyperbytedb/src/adapters/cluster/hinted_handoff.rs +++ b/hyperbytedb/src/adapters/cluster/hinted_handoff.rs @@ -216,6 +216,7 @@ impl HintedHandoff { } /// Total pending hints across all peers. O(peers). + #[cfg(test)] pub fn total_pending(&self) -> Result { let counts = self.counts.lock().unwrap_or_else(|e| e.into_inner()); Ok(counts.values().sum()) diff --git a/hyperbytedb/src/adapters/cluster/replication_log.rs b/hyperbytedb/src/adapters/cluster/replication_log.rs index a44db36..11c900a 100644 --- a/hyperbytedb/src/adapters/cluster/replication_log.rs +++ b/hyperbytedb/src/adapters/cluster/replication_log.rs @@ -184,6 +184,7 @@ impl ReplicationLog { /// **Note:** Only considers peers that already have a `repl_ack` key. Peers that /// have never successfully acked are omitted, which can overstate the minimum. /// Prefer [`Self::min_max_wal_ack_for_peers`] for flush truncation decisions. + #[cfg(test)] pub fn min_wal_ack(&self) -> Result, HyperbytedbError> { let cf = self .db @@ -256,6 +257,7 @@ impl ReplicationLog { } /// Read mutation log entries from a given sequence. + #[cfg(test)] pub fn read_mutations_from( &self, from_seq: u64, diff --git a/hyperbytedb/src/adapters/wal/rocksdb_wal.rs b/hyperbytedb/src/adapters/wal/rocksdb_wal.rs index 5b33501..56a4ebf 100644 --- a/hyperbytedb/src/adapters/wal/rocksdb_wal.rs +++ b/hyperbytedb/src/adapters/wal/rocksdb_wal.rs @@ -355,6 +355,7 @@ impl RocksDbWal { } /// Synchronous group-commit append for the dedicated WAL writer thread. + #[cfg(test)] pub fn append_batch_sync(&self, entries: Vec) -> Result, HyperbytedbError> { let bundles: Vec = entries .into_iter() diff --git a/hyperbytedb/src/application/columnar_msgpack.rs b/hyperbytedb/src/application/columnar_msgpack.rs index 645f5c5..4247d6b 100644 --- a/hyperbytedb/src/application/columnar_msgpack.rs +++ b/hyperbytedb/src/application/columnar_msgpack.rs @@ -100,6 +100,9 @@ pub fn columnar_wire_to_line_protocol( } /// Parses columnar msgpack map into `Vec` (`precision` matches `/write` query param). +/// +/// Test support. +#[doc(hidden)] pub fn parse_columnar_msgpack_to_points( body: &[u8], precision: Option<&str>, diff --git a/hyperbytedb/src/application/continuous_query_service.rs b/hyperbytedb/src/application/continuous_query_service.rs index 1d66100..c353b68 100644 --- a/hyperbytedb/src/application/continuous_query_service.rs +++ b/hyperbytedb/src/application/continuous_query_service.rs @@ -66,6 +66,9 @@ impl ContinuousQueryService { } /// Run one scheduler iteration at `now` (exposed for tests). + /// + /// Test support. + #[doc(hidden)] pub async fn tick_once_at( &self, now: chrono::DateTime, diff --git a/hyperbytedb/src/application/flush_service.rs b/hyperbytedb/src/application/flush_service.rs index 846be02..7790bd5 100644 --- a/hyperbytedb/src/application/flush_service.rs +++ b/hyperbytedb/src/application/flush_service.rs @@ -146,6 +146,7 @@ impl FlushServiceImpl { self } + #[cfg(test)] pub fn with_sharded_wal_retention_bytes(mut self, bytes: u64) -> Self { self.sharded_wal_retention_bytes = bytes; self diff --git a/hyperbytedb/src/application/forward_coalescer.rs b/hyperbytedb/src/application/forward_coalescer.rs index 1531d1c..dd0f27d 100644 --- a/hyperbytedb/src/application/forward_coalescer.rs +++ b/hyperbytedb/src/application/forward_coalescer.rs @@ -78,7 +78,10 @@ impl ForwardCoalescer { } /// Destinations with a lane (one per node forwarded to so far). + /// + /// Test support. #[must_use] + #[doc(hidden)] pub fn lane_count(&self) -> usize { self.lanes.lock().len() } diff --git a/hyperbytedb/src/application/replication_apply.rs b/hyperbytedb/src/application/replication_apply.rs index c79003e..841bc83 100644 --- a/hyperbytedb/src/application/replication_apply.rs +++ b/hyperbytedb/src/application/replication_apply.rs @@ -180,6 +180,8 @@ impl ReplicationApplyQueue { Arc::new(Self { tx }) } + /// Test support. + #[doc(hidden)] pub fn with_defaults( metadata: Arc, wal: Arc, diff --git a/hyperbytedb/src/application/shard_scheduler.rs b/hyperbytedb/src/application/shard_scheduler.rs index f844873..466228a 100644 --- a/hyperbytedb/src/application/shard_scheduler.rs +++ b/hyperbytedb/src/application/shard_scheduler.rs @@ -766,6 +766,9 @@ impl ShardScheduler { /// The series count this scheduler holds for `(region_id, node_id)`, or /// `None` if it never recorded one. Test support for the heartbeat /// handler, which has no other externally visible effect. + /// + /// Test support. + #[doc(hidden)] pub async fn recorded_heartbeat_series(&self, region_id: u64, node_id: u64) -> Option { self.heartbeats .read() diff --git a/hyperbytedb/src/domain/chdb_naming.rs b/hyperbytedb/src/domain/chdb_naming.rs index 08f81c0..d845142 100644 --- a/hyperbytedb/src/domain/chdb_naming.rs +++ b/hyperbytedb/src/domain/chdb_naming.rs @@ -16,6 +16,7 @@ use std::collections::HashSet; use std::fmt; use crate::domain::column_mapping::tag_column_name as map_tag_column_name; +#[cfg(test)] use crate::error::HyperbytedbError; /// Sanitized unquoted ClickHouse identifier (`[A-Za-z0-9_]`). @@ -66,6 +67,7 @@ impl fmt::Display for QuotedTableName { } /// Reject control characters in identifiers before quoting. +#[cfg(test)] fn reject_control_chars(ident: &str) -> Result<(), HyperbytedbError> { if ident.chars().any(char::is_control) { return Err(HyperbytedbError::QueryParse(format!( @@ -148,6 +150,7 @@ pub fn quote_backticks(ident: &str) -> String { } /// Like [`quote_backticks`], but rejects control characters first. +#[cfg(test)] pub fn quote_backticks_validated(ident: &str) -> Result { reject_control_chars(ident)?; Ok(quote_backticks(ident)) diff --git a/hyperbytedb/src/domain/prepared_wal.rs b/hyperbytedb/src/domain/prepared_wal.rs index fb19e9f..a75001a 100644 --- a/hyperbytedb/src/domain/prepared_wal.rs +++ b/hyperbytedb/src/domain/prepared_wal.rs @@ -28,6 +28,8 @@ pub struct PreparedWalSlot { } impl PreparedWalSlot { + /// Test support. + #[doc(hidden)] pub fn total_rows(&self) -> usize { self.measurements.iter().map(|m| m.row_count).sum() } diff --git a/hyperbytedb/src/ports/query.rs b/hyperbytedb/src/ports/query.rs index 23488d6..2bc39f4 100644 --- a/hyperbytedb/src/ports/query.rs +++ b/hyperbytedb/src/ports/query.rs @@ -17,6 +17,9 @@ pub type ArrowBatchStream = tokio::sync::mpsc::Receiver>; /// A stream with no batches: an empty result. +/// +/// Test support. +#[doc(hidden)] pub fn empty_arrow_stream() -> ArrowBatchStream { let (_tx, rx) = tokio::sync::mpsc::channel(1); rx diff --git a/hyperbytedb/src/timeseriesql/ast.rs b/hyperbytedb/src/timeseriesql/ast.rs index 960f5da..3e68aa8 100644 --- a/hyperbytedb/src/timeseriesql/ast.rs +++ b/hyperbytedb/src/timeseriesql/ast.rs @@ -451,6 +451,7 @@ impl MeasurementSource { } } + #[cfg(test)] pub fn as_concrete(&self) -> Option<&Measurement> { match self { MeasurementSource::Concrete(m) => Some(m), From 8b337e9f44c7e32e577fc3f5c558f587fd3f3387 Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Tue, 10 Nov 2026 18:35:53 +0000 Subject: [PATCH 2/9] Fix clippy performance findings --- .../src/adapters/chdb/native_adapter.rs | 13 ++--- hyperbytedb/src/adapters/http/router.rs | 2 +- hyperbytedb/src/adapters/wal/batching_wal.rs | 3 ++ .../src/application/replication_apply.rs | 2 +- .../application/runtime/region_write_stats.rs | 12 +++-- .../src/application/shard_scheduler.rs | 2 +- .../src/application/statement_summary.rs | 2 + hyperbytedb/src/composition/bootstrap.rs | 8 ++-- hyperbytedb/src/config.rs | 4 +- .../src/domain/sharding/location_cache.rs | 47 ++++++++++--------- hyperbytedb/src/domain/sharding/ops/apply.rs | 4 +- .../src/domain/sharding/query_merge.rs | 4 +- hyperbytedb/src/server.rs | 28 ++++++----- .../to_clickhouse/materialized_view.rs | 2 +- 14 files changed, 74 insertions(+), 59 deletions(-) diff --git a/hyperbytedb/src/adapters/chdb/native_adapter.rs b/hyperbytedb/src/adapters/chdb/native_adapter.rs index 68cb866..227e8e1 100644 --- a/hyperbytedb/src/adapters/chdb/native_adapter.rs +++ b/hyperbytedb/src/adapters/chdb/native_adapter.rs @@ -778,16 +778,11 @@ impl ChdbNativeAdapter { let tag_ddl_needed = tag_phys .iter() .any(|(_, phys, kind)| series_cached.columns.get(phys).copied() != Some(*kind)); - let missing_fields: Vec<&(String, String, u8)> = field_phys + let fields_missing = field_phys .iter() - .filter(|(_, phys, d)| !cached.knows(phys, ColumnKind::Field(*d))) - .collect(); + .any(|(_, phys, d)| !cached.knows(phys, ColumnKind::Field(*d))); - if cached.materialized - && series_cached.materialized - && !tag_ddl_needed - && missing_fields.is_empty() - { + if cached.materialized && series_cached.materialized && !tag_ddl_needed && !fields_missing { if probed { // Nothing missing: the cache already holds every engine column. let mut guard = self.schemas.write(); @@ -1357,7 +1352,7 @@ impl ChdbNativeAdapter { measurements: vec![PreparedMeasurementBatch { measurement: wire.measurement.clone(), table_name: ensured.table.clone(), - series_table_name: ensured.series_table.clone(), + series_table_name: ensured.series_table, batch: Arc::new(batch), row_count: n, min_time, diff --git a/hyperbytedb/src/adapters/http/router.rs b/hyperbytedb/src/adapters/http/router.rs index 7c8778f..40c05b6 100644 --- a/hyperbytedb/src/adapters/http/router.rs +++ b/hyperbytedb/src/adapters/http/router.rs @@ -202,7 +202,7 @@ pub fn build_router(state: Arc) -> Router { .route( "/api/v1/chdb", post(chdb::handle_chdb).layer(axum::middleware::from_fn_with_state( - auth_state.clone(), + auth_state, auth_middleware::auth_layer, )), ); diff --git a/hyperbytedb/src/adapters/wal/batching_wal.rs b/hyperbytedb/src/adapters/wal/batching_wal.rs index d2fc732..c1c8949 100644 --- a/hyperbytedb/src/adapters/wal/batching_wal.rs +++ b/hyperbytedb/src/adapters/wal/batching_wal.rs @@ -127,6 +127,9 @@ impl BatchingWal { Instant, oneshot::Sender>, )>::with_capacity(batch_len); + // `drain`, not `into_iter`: `batch` is reused across loop turns + // and keeps its allocation. + #[allow(clippy::iter_with_drain)] for req in batch.drain(..) { bundles.push(req.bundle); pre_encoded.push(req.pre_encoded); diff --git a/hyperbytedb/src/application/replication_apply.rs b/hyperbytedb/src/application/replication_apply.rs index 841bc83..257d7f1 100644 --- a/hyperbytedb/src/application/replication_apply.rs +++ b/hyperbytedb/src/application/replication_apply.rs @@ -140,7 +140,7 @@ impl ReplicationApplyQueue { let sem = Arc::new(Semaphore::new(num_workers)); let schema_cache = Arc::new(IngestSchemaCache::new()); - let dispatch_sem = sem.clone(); + let dispatch_sem = sem; tokio::spawn(async move { loop { let job = match rx.recv().await { diff --git a/hyperbytedb/src/application/runtime/region_write_stats.rs b/hyperbytedb/src/application/runtime/region_write_stats.rs index 6fe285b..877dfbd 100644 --- a/hyperbytedb/src/application/runtime/region_write_stats.rs +++ b/hyperbytedb/src/application/runtime/region_write_stats.rs @@ -19,14 +19,20 @@ impl RegionWriteStats { return; } let mut guard = self.inner.lock().unwrap_or_else(|e| e.into_inner()); - let entry = guard.entry(region_id).or_insert((0, Instant::now())); + let entry = guard + .entry(region_id) + .or_insert_with(|| (0, Instant::now())); entry.0 = entry.0.saturating_add(points); } /// Returns writes-per-second over the elapsed window and resets the counter. pub fn take_qps(&self, region_id: u64, window: Duration) -> u64 { - let mut guard = self.inner.lock().unwrap_or_else(|e| e.into_inner()); - let Some((count, started)) = guard.remove(®ion_id) else { + let removed = self + .inner + .lock() + .unwrap_or_else(|e| e.into_inner()) + .remove(®ion_id); + let Some((count, started)) = removed else { return 0; }; let secs = started.elapsed().max(window).as_secs_f64(); diff --git a/hyperbytedb/src/application/shard_scheduler.rs b/hyperbytedb/src/application/shard_scheduler.rs index 466228a..c785bc2 100644 --- a/hyperbytedb/src/application/shard_scheduler.rs +++ b/hyperbytedb/src/application/shard_scheduler.rs @@ -200,7 +200,7 @@ fn choose_split_key( let inside = |k: &u64| *k > start && *k < end; peer_hint .filter(inside) - .or(local_median.filter(inside)) + .or_else(|| local_median.filter(inside)) .unwrap_or(start + (end - start) / 2) .max(start.saturating_add(1)) .min(end.saturating_sub(1)) diff --git a/hyperbytedb/src/application/statement_summary.rs b/hyperbytedb/src/application/statement_summary.rs index 56a2d2a..592f1c1 100644 --- a/hyperbytedb/src/application/statement_summary.rs +++ b/hyperbytedb/src/application/statement_summary.rs @@ -153,6 +153,8 @@ impl StatementSummary { }) .map(|e| e.to_summary()) .collect(); + // Sort without the lock, so recording statements is not held up. + drop(map); entries.sort_by(|a, b| { let cmp = match sort_by { diff --git a/hyperbytedb/src/composition/bootstrap.rs b/hyperbytedb/src/composition/bootstrap.rs index 4aaf146..20c2e75 100644 --- a/hyperbytedb/src/composition/bootstrap.rs +++ b/hyperbytedb/src/composition/bootstrap.rs @@ -321,9 +321,11 @@ impl ClusterBootstrap { // write tasks under saturation, and heartbeats arrived late enough // to trigger elections (~70 in a one-minute run on n3). let node_id = config.node_id; - let raft = crate::application::runtime::control::on_control(async move { - HyperbytedbRaft::new(node_id, raft_config, network, log_store, state_machine).await - }) + let raft = Box::pin(crate::application::runtime::control::on_control( + async move { + HyperbytedbRaft::new(node_id, raft_config, network, log_store, state_machine).await + }, + )) .await .map_err(|e| anyhow::anyhow!("failed to initialize raft: {e}"))?; diff --git a/hyperbytedb/src/config.rs b/hyperbytedb/src/config.rs index 6a959c1..3348f78 100644 --- a/hyperbytedb/src/config.rs +++ b/hyperbytedb/src/config.rs @@ -563,13 +563,13 @@ impl ChdbConfig { pub fn resolved_query_pool_size(&self) -> usize { self.query_pool_size - .or((self.pool_size > 0).then_some(self.pool_size)) + .or_else(|| (self.pool_size > 0).then_some(self.pool_size)) .unwrap_or_else(crate::adapters::chdb::connection_pool::default_query_pool_size) } pub fn resolved_write_pool_size(&self) -> usize { self.write_pool_size - .or((self.pool_size > 0).then_some(self.pool_size)) + .or_else(|| (self.pool_size > 0).then_some(self.pool_size)) .unwrap_or(crate::adapters::chdb::connection_pool::DEFAULT_WRITE_POOL_SIZE) } diff --git a/hyperbytedb/src/domain/sharding/location_cache.rs b/hyperbytedb/src/domain/sharding/location_cache.rs index 39d22d3..512efc1 100644 --- a/hyperbytedb/src/domain/sharding/location_cache.rs +++ b/hyperbytedb/src/domain/sharding/location_cache.rs @@ -235,16 +235,15 @@ impl ShardLocationCache { } let region = map.locate(db, rp, measurement, series_id)?.clone(); - let mut inner = self.write_inner(); if let Some(space) = map.space(db, rp, measurement) { + // Built before the lock: only the insert needs it. + let cached = CachedMeasurement { + map_version: map.map_version, + regions: materialise_serving(&space.regions), + }; + let mut inner = self.write_inner(); inner.map_version = inner.map_version.max(map.map_version); - inner.by_measurement.insert( - cache_key, - CachedMeasurement { - map_version: map.map_version, - regions: materialise_serving(&space.regions), - }, - ); + inner.by_measurement.insert(cache_key, cached); } Some(region) } @@ -282,16 +281,15 @@ impl ShardLocationCache { primary: region.primary, self_is_peer: region.peers.contains(&self_id), }; - let mut inner = self.write_inner(); if let Some(space) = map.space(db, rp, measurement) { + // Built before the lock: only the insert needs it. + let cached = CachedMeasurement { + map_version: map.map_version, + regions: materialise_serving(&space.regions), + }; + let mut inner = self.write_inner(); inner.map_version = inner.map_version.max(map.map_version); - inner.by_measurement.insert( - cache_key, - CachedMeasurement { - map_version: map.map_version, - regions: materialise_serving(&space.regions), - }, - ); + inner.by_measurement.insert(cache_key, cached); } Some(route) } @@ -306,11 +304,18 @@ impl ShardLocationCache { epoch: ShardEpoch, ) -> bool { let cache_key = Self::measurement_key(db, rp, measurement); - let inner = self.read_inner(); - if let Some(cached) = inner.by_measurement.get(&cache_key) - && cached.map_version == map.map_version - { - return locate_in_regions(&cached.regions, series_id).is_some_and(|r| r.epoch == epoch); + let cached_hit = { + let inner = self.read_inner(); + inner + .by_measurement + .get(&cache_key) + .filter(|cached| cached.map_version == map.map_version) + .map(|cached| { + locate_in_regions(&cached.regions, series_id).is_some_and(|r| r.epoch == epoch) + }) + }; + if let Some(hit) = cached_hit { + return hit; } map.locate(db, rp, measurement, series_id) .is_some_and(|r| r.epoch == epoch) diff --git a/hyperbytedb/src/domain/sharding/ops/apply.rs b/hyperbytedb/src/domain/sharding/ops/apply.rs index 74cd07b..a71f4eb 100644 --- a/hyperbytedb/src/domain/sharding/ops/apply.rs +++ b/hyperbytedb/src/domain/sharding/ops/apply.rs @@ -13,7 +13,7 @@ pub(super) fn apply_bootstrap_measurement_presplit( return Err(ShardMapApplyError::SpaceExists { db: key.db.clone(), rp: key.rp.clone(), - measurement: key.measurement.clone(), + measurement: key.measurement, }); } let mut ids = std::collections::HashSet::new(); @@ -51,7 +51,7 @@ pub(super) fn apply_bootstrap_measurement( return Err(ShardMapApplyError::SpaceExists { db: key.db.clone(), rp: key.rp.clone(), - measurement: key.measurement.clone(), + measurement: key.measurement, }); } if map.spaces.values().any(|space| { diff --git a/hyperbytedb/src/domain/sharding/query_merge.rs b/hyperbytedb/src/domain/sharding/query_merge.rs index 36f9480..6c6ceea 100644 --- a/hyperbytedb/src/domain/sharding/query_merge.rs +++ b/hyperbytedb/src/domain/sharding/query_merge.rs @@ -314,7 +314,7 @@ fn rewrite_field_for_region( "FIRST" => { let _source = aggregate_source_field_name(func)?; let time_col = format!("{output}__sel_time"); - plan.first_partials.insert(output.clone(), time_col.clone()); + plan.first_partials.insert(output, time_col.clone()); Ok(vec![ field.clone(), field_with_call("min", "time", Some(time_col)), @@ -323,7 +323,7 @@ fn rewrite_field_for_region( "LAST" => { let _source = aggregate_source_field_name(func)?; let time_col = format!("{output}__sel_time"); - plan.last_partials.insert(output.clone(), time_col.clone()); + plan.last_partials.insert(output, time_col.clone()); Ok(vec![ field.clone(), field_with_call("max", "time", Some(time_col)), diff --git a/hyperbytedb/src/server.rs b/hyperbytedb/src/server.rs index c18de06..cf648ab 100644 --- a/hyperbytedb/src/server.rs +++ b/hyperbytedb/src/server.rs @@ -33,7 +33,7 @@ pub async fn serve( if config.cluster.enabled { control::install()?; } - let result = serve_inner(config, log_level).await; + let result = Box::pin(serve_inner(config, log_level)).await; control::shutdown(); result } @@ -168,17 +168,19 @@ async fn serve_inner( ) .await?; Some( - c.start_raft( - &config.cluster, - app_state.metadata.clone(), - app_state.mv_service.clone(), - app_state.points_sink.clone(), - app_state.wal.clone(), - rocks_shard_map - .as_ref() - .zip(Some(app_state.shard_location_cache.clone())) - .map(|(m, cache)| (m.clone(), cache)), - app_state.shard_routing.clone(), + Box::pin( + c.start_raft( + &config.cluster, + app_state.metadata.clone(), + app_state.mv_service.clone(), + app_state.points_sink.clone(), + app_state.wal.clone(), + rocks_shard_map + .as_ref() + .zip(Some(app_state.shard_location_cache.clone())) + .map(|(m, cache)| (m.clone(), cache)), + app_state.shard_routing.clone(), + ), ) .await?, ) @@ -308,7 +310,7 @@ async fn serve_inner( let interval = Duration::from_secs(config.sharding.heartbeat_interval_secs.max(1)); let rx = service_shutdown_rx.clone(); - let sched = scheduler.clone(); + let sched = scheduler; let hb_handle = { let pc = peer_client.clone(); let node_id = config.cluster.node_id; diff --git a/hyperbytedb/src/timeseriesql/to_clickhouse/materialized_view.rs b/hyperbytedb/src/timeseriesql/to_clickhouse/materialized_view.rs index 8936d34..42112fe 100644 --- a/hyperbytedb/src/timeseriesql/to_clickhouse/materialized_view.rs +++ b/hyperbytedb/src/timeseriesql/to_clickhouse/materialized_view.rs @@ -169,7 +169,7 @@ pub fn translate_materialized_view_select_with_source_filter( ]; select_parts.extend(sorted_field_strs); - let mut group_parts = vec![time_bucket.clone()]; + let mut group_parts = vec![time_bucket]; for tag in &grouped_tags { group_parts.push(format!( "s.{}", From 985270c9eb6426dcb63caa5da2f9947ab2534c7c Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Tue, 10 Nov 2026 18:54:26 +0000 Subject: [PATCH 3/9] Enable clippy performance lints --- hyperbytedb-cli/Cargo.toml | 9 +++++++++ hyperbytedb-proxy/Cargo.toml | 9 +++++++++ hyperbytedb/Cargo.toml | 9 +++++++++ hyperbytedb/benches/ingestion_columnar.rs | 14 +++++++------- hyperbytedb/benches/ingestion_line_protocol.rs | 10 +++++----- hyperbytedb/benches/support/mod.rs | 5 ++--- hyperbytedb/src/adapters/chdb/native_adapter.rs | 2 +- hyperbytedb/src/application/cluster/drain.rs | 2 +- hyperbytedb/src/application/mv_handoff.rs | 2 +- hyperbytedb/src/application/shard_routing.rs | 5 +---- hyperbytedb/src/domain/sharding/location_cache.rs | 8 ++++---- hyperbytedb/src/domain/sharding/ops/mod.rs | 8 ++++---- hyperbytedb/src/domain/sharding/query_merge.rs | 2 +- hyperbytedb/tests/compat/main.rs | 6 +++++- hyperbytedb/tests/integration.rs | 8 ++++---- hyperbytedb/tests/sharding_integration.rs | 2 +- .../tests/sharding_placement_integration.rs | 2 +- 17 files changed, 65 insertions(+), 38 deletions(-) diff --git a/hyperbytedb-cli/Cargo.toml b/hyperbytedb-cli/Cargo.toml index 835e240..c0d6b19 100644 --- a/hyperbytedb-cli/Cargo.toml +++ b/hyperbytedb-cli/Cargo.toml @@ -39,3 +39,12 @@ axum = "0.8" serial_test = "3" tempfile = "3" tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] } + +[lints.clippy] +# Performance lints CI enforces through -D warnings. significant_drop_tightening +# stays off: too many false positives. +redundant_clone = "warn" +large_futures = "warn" +needless_collect = "warn" +iter_with_drain = "warn" +or_fun_call = "warn" diff --git a/hyperbytedb-proxy/Cargo.toml b/hyperbytedb-proxy/Cargo.toml index 3581a27..c407a13 100644 --- a/hyperbytedb-proxy/Cargo.toml +++ b/hyperbytedb-proxy/Cargo.toml @@ -43,3 +43,12 @@ futures = "0.3" criterion = { version = "0.5", features = ["html_reports"] } tokio = { version = "1", features = ["rt-multi-thread", "macros"] } + +[lints.clippy] +# Performance lints CI enforces through -D warnings. significant_drop_tightening +# stays off: too many false positives. +redundant_clone = "warn" +large_futures = "warn" +needless_collect = "warn" +iter_with_drain = "warn" +or_fun_call = "warn" diff --git a/hyperbytedb/Cargo.toml b/hyperbytedb/Cargo.toml index 3f31c69..cca473a 100644 --- a/hyperbytedb/Cargo.toml +++ b/hyperbytedb/Cargo.toml @@ -149,3 +149,12 @@ harness = false [dev-dependencies] criterion = { version = "0.5", features = ["html_reports"] } serial_test = "3" + +[lints.clippy] +# Performance lints CI enforces through -D warnings. significant_drop_tightening +# stays off: too many false positives. +redundant_clone = "warn" +large_futures = "warn" +needless_collect = "warn" +iter_with_drain = "warn" +or_fun_call = "warn" diff --git a/hyperbytedb/benches/ingestion_columnar.rs b/hyperbytedb/benches/ingestion_columnar.rs index b6b0a5b..9036c36 100644 --- a/hyperbytedb/benches/ingestion_columnar.rs +++ b/hyperbytedb/benches/ingestion_columnar.rs @@ -103,7 +103,7 @@ fn bench_metadata(c: &mut Criterion) { std::fs::create_dir_all(&meta_dir).unwrap(); let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -139,7 +139,7 @@ fn bench_wal(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -210,7 +210,7 @@ fn bench_metadata_fast(c: &mut Criterion) { std::fs::create_dir_all(&meta_dir).unwrap(); let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -244,7 +244,7 @@ fn bench_wal_fast(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -323,7 +323,7 @@ fn bench_metadata_concurrent(c: &mut Criterion) { std::fs::create_dir_all(&meta_dir).unwrap(); let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let cache = Arc::new(IngestSchemaCache::new()); let limits = IngestCardinalityLimits::default(); @@ -377,7 +377,7 @@ fn bench_wal_concurrent(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let cache = Arc::new(IngestSchemaCache::new()); let limits = IngestCardinalityLimits::default(); @@ -452,7 +452,7 @@ fn bench_wal_batched_concurrent(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let raw_wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; // `BatchingWal::new` spawns a background `batcher_loop` task; it // must be created inside a tokio runtime context. let wal: Arc = diff --git a/hyperbytedb/benches/ingestion_line_protocol.rs b/hyperbytedb/benches/ingestion_line_protocol.rs index be8a82c..752138f 100644 --- a/hyperbytedb/benches/ingestion_line_protocol.rs +++ b/hyperbytedb/benches/ingestion_line_protocol.rs @@ -83,7 +83,7 @@ fn bench_metadata(c: &mut Criterion) { std::fs::create_dir_all(&meta_dir).unwrap(); let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -118,7 +118,7 @@ fn bench_wal(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let limits = IngestCardinalityLimits::default(); let cache = IngestSchemaCache::new(); @@ -198,7 +198,7 @@ fn bench_metadata_concurrent(c: &mut Criterion) { std::fs::create_dir_all(&meta_dir).unwrap(); let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let cache = Arc::new(IngestSchemaCache::new()); let limits = IngestCardinalityLimits::default(); @@ -254,7 +254,7 @@ fn bench_wal_concurrent(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let cache = Arc::new(IngestSchemaCache::new()); let limits = IngestCardinalityLimits::default(); @@ -329,7 +329,7 @@ fn bench_wal_batched_concurrent(c: &mut Criterion) { let metadata: Arc = Arc::new(RocksDbMetadata::open(&meta_dir).unwrap()); let raw_wal: Arc = Arc::new(RocksDbWal::open(&wal_dir).unwrap()); rt.block_on(metadata.create_database("benchdb")).unwrap(); - let meta_port: Arc = metadata.clone(); + let meta_port: Arc = metadata; let wal: Arc = rt.block_on(async { BatchingWal::new(raw_wal.clone(), 2048, 512, Duration::ZERO, 0) }); let cache = Arc::new(IngestSchemaCache::new()); diff --git a/hyperbytedb/benches/support/mod.rs b/hyperbytedb/benches/support/mod.rs index d750aba..b432b50 100644 --- a/hyperbytedb/benches/support/mod.rs +++ b/hyperbytedb/benches/support/mod.rs @@ -110,7 +110,7 @@ pub fn setup_flush(profile: DatasetProfile) -> FlushBenchEnv { let shared = SharedSession::new_eager(chdb_dir.to_str().unwrap(), 1).unwrap(); let points_sink: Arc = Arc::new(ChdbNativeAdapter::new(shared)); - let ingestion = IngestionServiceImpl::new(wal.clone(), metadata.clone(), 100_000, 10_000, 0); + let ingestion = IngestionServiceImpl::new(wal.clone(), metadata, 100_000, 10_000, 0); let flush_service = Arc::new(FlushServiceImpl::new(wal, 0, points_sink)); FlushBenchEnv { @@ -173,8 +173,7 @@ pub fn setup(profile: DatasetProfile) -> BenchEnv { let ingestion = IngestionServiceImpl::new(wal.clone(), metadata.clone(), 100_000, 10_000, 0); let flush_service = FlushServiceImpl::new(wal.clone(), 0, points_sink.clone()); - let query_service = - QueryServiceImpl::new(query_port, metadata.clone(), wal.clone(), 120, points_sink); + let query_service = QueryServiceImpl::new(query_port, metadata, wal, 120, points_sink); seed_dataset(&rt, &ingestion, &flush_service, profile); diff --git a/hyperbytedb/src/adapters/chdb/native_adapter.rs b/hyperbytedb/src/adapters/chdb/native_adapter.rs index 227e8e1..cafd910 100644 --- a/hyperbytedb/src/adapters/chdb/native_adapter.rs +++ b/hyperbytedb/src/adapters/chdb/native_adapter.rs @@ -2999,7 +2999,7 @@ mod tests { "DDL must sort field columns by physical name, got: {ddl}" ); - let mut sorted = field_phys.clone(); + let mut sorted = field_phys; sorted.sort_by(|a, b| a.1.cmp(&b.1)); let ensured = EnsuredTable { table: "`db_rp_cpu`".to_string(), diff --git a/hyperbytedb/src/application/cluster/drain.rs b/hyperbytedb/src/application/cluster/drain.rs index c029574..55061b7 100644 --- a/hyperbytedb/src/application/cluster/drain.rs +++ b/hyperbytedb/src/application/cluster/drain.rs @@ -384,7 +384,7 @@ mod tests { }, ); } - let dests = std::collections::HashSet::from([dest.clone()]); + let dests = std::collections::HashSet::from([dest]); let mut got: Vec<(String, u64, bool)> = primaries_to_hand_off(&map, 1, &dests) .into_iter() .map(|(k, r, copy)| (k.measurement.clone(), r.region_id, copy)) diff --git a/hyperbytedb/src/application/mv_handoff.rs b/hyperbytedb/src/application/mv_handoff.rs index ab53abf..36a3611 100644 --- a/hyperbytedb/src/application/mv_handoff.rs +++ b/hyperbytedb/src/application/mv_handoff.rs @@ -381,7 +381,7 @@ mod tests { map.spaces.insert( raw.clone(), MeasurementShardSpace { - key: raw.clone(), + key: raw, regions: vec![region(vec![1, 2])], }, ); diff --git a/hyperbytedb/src/application/shard_routing.rs b/hyperbytedb/src/application/shard_routing.rs index d9b467f..ab96fde 100644 --- a/hyperbytedb/src/application/shard_routing.rs +++ b/hyperbytedb/src/application/shard_routing.rs @@ -1927,10 +1927,7 @@ mod presplit_tests { assert!( crate::domain::sharding::ops::apply_shard_map_op( &mut map, - ShardMapOp::BootstrapMeasurementPresplit { - key: key.clone(), - regions, - }, + ShardMapOp::BootstrapMeasurementPresplit { key, regions }, ) .is_err(), "a second bootstrap of the same space must be refused" diff --git a/hyperbytedb/src/domain/sharding/location_cache.rs b/hyperbytedb/src/domain/sharding/location_cache.rs index 512efc1..1c757e5 100644 --- a/hyperbytedb/src/domain/sharding/location_cache.rs +++ b/hyperbytedb/src/domain/sharding/location_cache.rs @@ -466,7 +466,7 @@ mod tests { apply_shard_map_op( &mut map, ShardMapOp::BootstrapMeasurement { - key: key.clone(), + key, region: sample_region(1, 0, u64::MAX), }, ) @@ -485,7 +485,7 @@ mod tests { apply_shard_map_op( &mut map, ShardMapOp::BootstrapMeasurement { - key: key.clone(), + key, region: sample_region(1, 0, u64::MAX), }, ) @@ -526,7 +526,7 @@ mod tests { apply_shard_map_op( &mut map, ShardMapOp::Split { - key: key.clone(), + key, region_id: 1, split_key, epoch: ShardEpoch::default(), @@ -573,7 +573,7 @@ mod tests { apply_shard_map_op( &mut map_b, ShardMapOp::BootstrapMeasurement { - key: key_b.clone(), + key: key_b, region: sample_region(2, 0, u64::MAX), }, ) diff --git a/hyperbytedb/src/domain/sharding/ops/mod.rs b/hyperbytedb/src/domain/sharding/ops/mod.rs index 7778801..3d307b0 100644 --- a/hyperbytedb/src/domain/sharding/ops/mod.rs +++ b/hyperbytedb/src/domain/sharding/ops/mod.rs @@ -388,7 +388,7 @@ mod tests { let err = apply_shard_map_op( &mut map, ShardMapOp::Merge { - key: key.clone(), + key, left_region_id: 1, right_region_id: 2, epoch: stale, @@ -427,7 +427,7 @@ mod tests { split_key, epoch: ShardEpoch::default(), left: left.clone(), - right: right.clone(), + right, }, ) .unwrap(); @@ -788,7 +788,7 @@ mod tests { apply_shard_map_op( &mut map, ShardMapOp::Split { - key: cpu_key.clone(), + key: cpu_key, region_id: 1, split_key, epoch: ShardEpoch::default(), @@ -1297,7 +1297,7 @@ mod tests { let err = apply_shard_map_op( &mut map, ShardMapOp::PromotePeer { - key: key.clone(), + key, region_id: 1, peer: 999, epoch, diff --git a/hyperbytedb/src/domain/sharding/query_merge.rs b/hyperbytedb/src/domain/sharding/query_merge.rs index 6c6ceea..ee13950 100644 --- a/hyperbytedb/src/domain/sharding/query_merge.rs +++ b/hyperbytedb/src/domain/sharding/query_merge.rs @@ -1917,7 +1917,7 @@ mod tests { ("SLIMIT", with(&|s| s.slimit = Some(2)), Some("ms"), day), ( "too many buckets", - stmt.clone(), + stmt, Some("ms"), (Some(0), Some(i64::MAX / 2)), ), diff --git a/hyperbytedb/tests/compat/main.rs b/hyperbytedb/tests/compat/main.rs index d89924c..5a9a265 100644 --- a/hyperbytedb/tests/compat/main.rs +++ b/hyperbytedb/tests/compat/main.rs @@ -2,6 +2,10 @@ //! //! Uses the project's internal APIs directly (not HTTP) plus HTTP-level tests. +// Tests collect names into a Vec to assert on them; clearer than the +// iterator forms the lint would want, and not on any hot path. +#![allow(clippy::needless_collect)] + mod cluster_replication_tests; mod combination_tests; mod concurrent_tests; @@ -112,7 +116,7 @@ impl TestContext { let query_port: Arc = Arc::new(ChdbQueryAdapter::from_shared(shared.clone(), 0)); let points_sink: Arc = Arc::new(ChdbNativeAdapter::with_metadata( - shared.clone(), + shared, Some(metadata.clone()), )); diff --git a/hyperbytedb/tests/integration.rs b/hyperbytedb/tests/integration.rs index 5034d48..6a4407d 100644 --- a/hyperbytedb/tests/integration.rs +++ b/hyperbytedb/tests/integration.rs @@ -92,7 +92,7 @@ fn setup(dir: &tempfile::TempDir) -> (Arc, Arc) { query: query_service, query_port: chdb.clone(), metadata: metadata.clone(), - wal: wal.clone(), + wal, points_sink: points_sink.clone(), mv_service: test_mv_service( &(metadata.clone() as Arc), @@ -100,7 +100,7 @@ fn setup(dir: &tempfile::TempDir) -> (Arc, Arc) { &points_sink, ), auth: Arc::new(hyperbytedb::adapters::auth::MetadataAuthAdapter::new( - metadata.clone(), + metadata, )), peer_client: None, membership: None, @@ -831,11 +831,11 @@ async fn admission_app(permits: usize) -> (tempfile::TempDir, Arc) { query: query_service, query_port: chdb.clone(), metadata: metadata.clone(), - wal: wal.clone(), + wal, points_sink: sink.clone(), mv_service: test_mv_service(&(metadata.clone() as Arc), &chdb, &sink), auth: Arc::new(hyperbytedb::adapters::auth::MetadataAuthAdapter::new( - metadata.clone(), + metadata, )), peer_client: None, membership: None, diff --git a/hyperbytedb/tests/sharding_integration.rs b/hyperbytedb/tests/sharding_integration.rs index 4a8266a..b40b4be 100644 --- a/hyperbytedb/tests/sharding_integration.rs +++ b/hyperbytedb/tests/sharding_integration.rs @@ -213,7 +213,7 @@ fn merge_op_consolidates_adjacent_regions() { split_key, epoch: ShardEpoch::default(), left: left.clone(), - right: right.clone(), + right, }, ) .unwrap(); diff --git a/hyperbytedb/tests/sharding_placement_integration.rs b/hyperbytedb/tests/sharding_placement_integration.rs index 4d62b7b..c7bc3c4 100644 --- a/hyperbytedb/tests/sharding_placement_integration.rs +++ b/hyperbytedb/tests/sharding_placement_integration.rs @@ -92,7 +92,7 @@ fn convergence_walks_a_split_child_to_its_hash_target() { ); let mut peers = child.peers.clone(); peers.sort_unstable(); - let mut want = target.clone(); + let mut want = target; want.sort_unstable(); assert_eq!(peers, want, "child did not reach its hash target"); } From 44fbe451590aa6b42f1f9662a4ad61245adbca0b Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:06:24 +0000 Subject: [PATCH 4/9] Drain fails a primary handoff the apply refused consensus.propose returns Ok for a committed op that the apply refused (a stale epoch). Drain ignored ClusterResponse.ok, so a refused TransferPrimary counted as handed off. Check it, as the shard scheduler does. --- hyperbytedb/src/application/cluster/drain.rs | 66 ++++++++++++++++++-- 1 file changed, 61 insertions(+), 5 deletions(-) diff --git a/hyperbytedb/src/application/cluster/drain.rs b/hyperbytedb/src/application/cluster/drain.rs index 55061b7..bee1393 100644 --- a/hyperbytedb/src/application/cluster/drain.rs +++ b/hyperbytedb/src/application/cluster/drain.rs @@ -233,17 +233,13 @@ impl DrainService { .await?; } - use crate::domain::cluster::raft_request::ClusterRequest; let tp = ShardMapOp::TransferPrimary { key: key.clone(), region_id: region.region_id, new_primary, epoch: region.epoch, }; - consensus - .propose(ClusterRequest::ShardMapMutation(Box::new(tp))) - .await - .map_err(|e| HyperbytedbError::ShardMap(e.to_string().into()))?; + propose_handoff(consensus.as_ref(), tp).await?; } Ok(()) } @@ -294,6 +290,27 @@ impl DrainService { } /// The measurements materialized views write into. +/// Propose one primary handoff. A committed op the apply refused (a stale +/// epoch) moved nothing, so it is an error, as in the shard scheduler. +async fn propose_handoff( + consensus: &dyn ConsensusPort, + op: ShardMapOp, +) -> Result<(), HyperbytedbError> { + use crate::domain::cluster::raft_request::ClusterRequest; + let resp = consensus + .propose(ClusterRequest::ShardMapMutation(Box::new(op))) + .await + .map_err(|e| HyperbytedbError::ShardMap(e.to_string().into()))?; + if !resp.ok { + return Err(HyperbytedbError::ShardMap( + resp.message + .unwrap_or_else(|| "primary handoff refused".to_string()) + .into(), + )); + } + Ok(()) +} + async fn view_destinations( metadata: &dyn MetadataPort, ) -> Result, HyperbytedbError> { @@ -399,6 +416,45 @@ mod tests { ); } + /// A consensus whose apply refuses every op, as a stale epoch does. + struct RefusingConsensus; + + impl crate::ports::leadership::LeadershipPort for RefusingConsensus { + fn current_leader(&self) -> Option { + Some(1) + } + } + + #[async_trait] + impl ConsensusPort for RefusingConsensus { + async fn propose( + &self, + _req: crate::domain::cluster::raft_request::ClusterRequest, + ) -> Result + { + Ok(crate::domain::cluster::raft_request::ClusterResponse { + ok: false, + message: Some("stale epoch".into()), + }) + } + } + + /// A TransferPrimary the apply refused moved nothing: the handoff fails + /// instead of counting the region as handed off. + #[tokio::test] + async fn a_refused_primary_handoff_is_an_error() { + let op = ShardMapOp::TransferPrimary { + key: MeasurementKey::new("db", "autogen", "cpu"), + region_id: 1, + new_primary: 2, + epoch: Default::default(), + }; + let err = propose_handoff(&RefusingConsensus, op) + .await + .expect_err("a refused handoff must fail"); + assert!(err.to_string().contains("stale epoch"), "{err}"); + } + fn make_node(id: u64, state: NodeState) -> NodeInfo { NodeInfo { node_id: id, From b308938592a29da93d40edc1db71cc4760c5b8a9 Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:08:08 +0000 Subject: [PATCH 5/9] A reopened WAL reports its truncated entries flushed flushed_through started at 0 on open, while last_sequence is restored from disk. Only the flush truncates, so every entry below the oldest one left was flushed. With the mark at 0, every DELETE and DROP SERIES on a restarted node that had nothing left to flush waited the full 15 s for it, inside the Raft apply on replicated nodes. --- hyperbytedb/src/adapters/wal/rocksdb_wal.rs | 28 ++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/hyperbytedb/src/adapters/wal/rocksdb_wal.rs b/hyperbytedb/src/adapters/wal/rocksdb_wal.rs index 56a4ebf..e410a16 100644 --- a/hyperbytedb/src/adapters/wal/rocksdb_wal.rs +++ b/hyperbytedb/src/adapters/wal/rocksdb_wal.rs @@ -243,7 +243,9 @@ impl RocksDbWal { Ok(Self { db, seq: Arc::new(AtomicU64::new(seq)), - flushed_through: AtomicU64::new(0), + // Only the flush truncates, so every entry below the oldest one + // left was flushed. + flushed_through: AtomicU64::new(first.saturating_sub(1)), truncated_through: Arc::new(AtomicU64::new(first)), range_deletes_unflushed: Arc::new(AtomicU64::new(0)), sizes: Arc::new(std::sync::Mutex::new(std::collections::VecDeque::new())), @@ -800,6 +802,30 @@ mod tests { } } + /// Only the flush truncates the WAL, so every entry below the oldest one + /// left was flushed. A reopened WAL says so: a DELETE on a restarted + /// node waits for `flushed_through` to reach `last_sequence`, and with + /// nothing left to flush it waited its full 15 s every time. + #[tokio::test] + async fn a_reopened_wal_reports_truncated_entries_flushed() { + let dir = TempDir::new().unwrap(); + { + let wal = RocksDbWal::open(dir.path()).unwrap(); + for _ in 0..5 { + wal.append(cpu_entry(1)).await.unwrap(); + } + wal.truncate_before(4).await.unwrap(); + } + let wal = RocksDbWal::open(dir.path()).unwrap(); + assert_eq!(wal.flushed_through(), 3); + // All flushed and truncated: caught up with the last sequence. + wal.truncate_before(6).await.unwrap(); + drop(wal); + let wal = RocksDbWal::open(dir.path()).unwrap(); + assert_eq!(wal.flushed_through(), wal.last_sequence().await.unwrap()); + assert_eq!(wal.flushed_through(), 5); + } + fn memtable_counts(wal: &RocksDbWal) -> (u64, u64) { let cf = wal.db.cf_handle(WAL_CF).unwrap(); let get = |p: &str| wal.db.property_int_value_cf(&cf, p).unwrap().unwrap(); From af9fc153abb0fd7569e903fcb228278d1e06291a Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:10:47 +0000 Subject: [PATCH 6/9] DROP SERIES checks its condition before dropping series drop_series wiped the measurement's series metadata, then built the delete predicate, which refuses a field or an unknown tag. A refused DROP SERIES returned an error and left SHOW SERIES empty. Build every predicate first. DROP SERIES with no FROM deleted rows only on a sharded node; on a single node it dropped the series and kept every row, which tombstones no longer hide. It now deletes them everywhere. --- .../query_service/statements/delete.rs | 11 ++-- hyperbytedb/tests/compat/ddl_tests.rs | 59 +++++++++++++++++++ 2 files changed, 66 insertions(+), 4 deletions(-) diff --git a/hyperbytedb/src/application/query_service/statements/delete.rs b/hyperbytedb/src/application/query_service/statements/delete.rs index e2dc1ff..caab6f5 100644 --- a/hyperbytedb/src/application/query_service/statements/delete.rs +++ b/hyperbytedb/src/application/query_service/statements/delete.rs @@ -100,11 +100,11 @@ pub(in crate::application::query_service) async fn drop_series( String::new() }; if measurement.is_some() || !predicate_sql.is_empty() { - svc.metadata - .delete_series_matching(target_db, &rp, measurement.as_deref(), &predicate_sql) - .await?; // The series' rows are deleted; points written to them later // stay. A tombstone used to hide those too. + // + // The predicates are built (and a field or unknown tag refused) + // before anything is dropped: an error must leave the series. let mut targets: Vec<(String, String)> = Vec::new(); if let Some(ref meas) = measurement { let pred = crate::application::predicate_sql::build_delete_predicate( @@ -116,7 +116,7 @@ pub(in crate::application::query_service) async fn drop_series( ) .await?; targets.push((meas.clone(), pred)); - } else if svc.shard_routing.is_some() { + } else { // Every measurement that has the condition's tags. for meas in svc.metadata.list_measurements(target_db).await? { if let Ok(pred) = crate::application::predicate_sql::build_delete_predicate( @@ -132,6 +132,9 @@ pub(in crate::application::query_service) async fn drop_series( } } } + svc.metadata + .delete_series_matching(target_db, &rp, measurement.as_deref(), &predicate_sql) + .await?; for (meas, pred) in targets { if let Some(ctx) = svc.shard_routing.as_ref() { scatter_delete_to_regions( diff --git a/hyperbytedb/tests/compat/ddl_tests.rs b/hyperbytedb/tests/compat/ddl_tests.rs index 4ca90e6..85e6207 100644 --- a/hyperbytedb/tests/compat/ddl_tests.rs +++ b/hyperbytedb/tests/compat/ddl_tests.rs @@ -483,6 +483,65 @@ async fn drop_series_keeps_points_written_after_it() { assert_eq!(values(&ctx, "SELECT value FROM cpu").await, vec![2.0, 3.0]); } +/// A refused DROP SERIES changes nothing. It used to wipe every series of +/// the measurement before the condition was checked, so SHOW SERIES came +/// back empty after an error. +#[tokio::test] +#[serial(chdb)] +async fn a_refused_drop_series_keeps_the_series() { + let Some(ctx) = chdb_context() else { return }; + ctx.metadata.create_database("testdb").await.unwrap(); + ctx.write_and_flush( + "testdb", + "cpu,host=a value=1.0 1000000000\ncpu,host=b value=2.0 2000000000", + ) + .await + .unwrap(); + for q in [ + "DROP SERIES FROM cpu WHERE value > 0", + "DROP SERIES FROM cpu WHERE nosuchtag = 'x'", + ] { + let failed = match ctx.query("testdb", q).await { + Err(_) => true, + Ok(resp) => resp.results[0].error.is_some(), + }; + assert!(failed, "{q} must be refused"); + let series = ctx + .metadata + .list_series("testdb", "autogen", "cpu") + .await + .unwrap(); + assert_eq!(series.len(), 2, "{q} dropped series"); + } +} + +/// DROP SERIES with no FROM deletes the matching rows of every measurement +/// that has the tag, on a single node as in a cluster. +#[tokio::test] +#[serial(chdb)] +async fn drop_series_without_from_deletes_the_rows() { + let Some(ctx) = chdb_context() else { return }; + ctx.metadata.create_database("testdb").await.unwrap(); + ctx.write_and_flush( + "testdb", + "cpu,host=a value=1.0 1000000000\ncpu,host=b value=2.0 2000000000\n\ + mem,host=a value=3.0 1000000000", + ) + .await + .unwrap(); + let resp = ctx + .query("testdb", r#"DROP SERIES WHERE "host" = 'a'"#) + .await + .unwrap(); + assert!( + resp.results[0].error.is_none(), + "{:?}", + resp.results[0].error + ); + assert_eq!(values(&ctx, "SELECT value FROM cpu").await, vec![2.0]); + assert!(values(&ctx, "SELECT value FROM mem").await.is_empty()); +} + #[tokio::test] #[serial(chdb)] async fn drop_measurement_clears_its_tombstones() { From 4dede2dc38cedc2e0f6db2794177c9e15c390ae8 Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:13:08 +0000 Subject: [PATCH 7/9] Sharded DELETE: one request per primary, timed to the flush wait A peer deletes a DELETE's rows from its whole table after waiting up to 15 s for its WAL to flush. The coordinator sent one request per region on the 5 s peer timeout: a peer leading K regions ran K full-table deletes, and under steady ingest the coordinator timed out and reported a failed delete that the peer then carried out. Send each primary one request, with the flush wait plus the peer timeout to answer in. --- hyperbytedb/src/application/predicate_sql.rs | 2 +- hyperbytedb/src/application/shard_routing.rs | 81 +++++++++++++++++++- 2 files changed, 81 insertions(+), 2 deletions(-) diff --git a/hyperbytedb/src/application/predicate_sql.rs b/hyperbytedb/src/application/predicate_sql.rs index e144c76..eaef164 100644 --- a/hyperbytedb/src/application/predicate_sql.rs +++ b/hyperbytedb/src/application/predicate_sql.rs @@ -194,7 +194,7 @@ pub async fn delete_rows( /// Longest wait for the flush service to write the WAL's current entries: /// past one flush interval (10 s by default), well inside the query /// timeout (30 s by default). -const DELETE_FLUSH_WAIT: std::time::Duration = std::time::Duration::from_secs(15); +pub(crate) const DELETE_FLUSH_WAIT: std::time::Duration = std::time::Duration::from_secs(15); async fn wait_for_flush(wal: &dyn crate::ports::wal::WalPort) -> Result<(), HyperbytedbError> { let target = wal.last_sequence().await?; diff --git a/hyperbytedb/src/application/shard_routing.rs b/hyperbytedb/src/application/shard_routing.rs index ab96fde..bc222ed 100644 --- a/hyperbytedb/src/application/shard_routing.rs +++ b/hyperbytedb/src/application/shard_routing.rs @@ -999,6 +999,12 @@ pub async fn scatter_delete_to_regions( let mut outcome = ShardDeleteOutcome::default(); // One delete removes the rows of every local region. let mut deleted_locally = false; + // Likewise on a peer: it deletes from its whole table, so each primary + // gets one request however many regions it leads. + let mut deleted_on: HashSet = HashSet::new(); + // The peer first waits for its WAL to flush, then runs the mutation. + let peer_timeout = Duration::from_millis(ctx.config.scatter_peer_timeout_ms.max(1)); + let timeout = crate::application::predicate_sql::DELETE_FLUSH_WAIT + peer_timeout; for region in &space.regions { if region.primary == ctx.node_id { @@ -1030,6 +1036,11 @@ pub async fn scatter_delete_to_regions( outcome.applied += 1; continue; } + if deleted_on.contains(®ion.primary) { + counter!("hyperbytedb_shard_delete_applied_total").increment(1); + outcome.applied += 1; + continue; + } let membership = ctx.membership.read().await; if !is_serving_node(&membership, region.primary) { @@ -1065,7 +1076,6 @@ pub async fn scatter_delete_to_regions( Some(predicate.to_string()) }, }; - let timeout = Duration::from_millis(ctx.config.scatter_peer_timeout_ms.max(1)); use crate::domain::cluster::peer_rpc::PeerRpcError; match ctx.peer_rpc.shard_delete(&addr, &req, timeout).await { Err(PeerRpcError::Status { code: 409, .. }) => { @@ -1099,6 +1109,7 @@ pub async fn scatter_delete_to_regions( ); } Ok(()) => { + deleted_on.insert(region.primary); outcome.applied += 1; } } @@ -1363,6 +1374,74 @@ mod scatter_tests { new_shared(m) } + /// A peer deletes a DELETE's rows from its whole table, after waiting + /// for its WAL to flush (up to 15 s), so: one request per primary, not + /// per region, and a timeout that covers the wait. Each region used to + /// get its own request on the 5 s peer timeout: the coordinator reported + /// a failed delete that the peer then carried out. + #[tokio::test] + async fn a_delete_reaches_each_primary_once_and_waits_for_it() { + use crate::domain::sharding::{MeasurementKey, ShardMapOp}; + let hits = Arc::new(AtomicUsize::new(0)); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap().to_string(); + let h = { + let hits = hits.clone(); + let app = Router::new().route( + "/internal/shard/delete", + post(move || { + let hits = hits.clone(); + async move { + hits.fetch_add(1, Ordering::SeqCst); + // Longer than the peer timeout, as a WAL flush wait is. + tokio::time::sleep(Duration::from_millis(400)).await; + StatusCode::OK + } + }), + ); + tokio::spawn(async move { axum::serve(listener, app).await.unwrap() }) + }; + let config = ShardingConfig { + scatter_peer_timeout_ms: 100, + ..Default::default() + }; + let ctx = test_ctx(membership_with(&[(2, &addr)]), config, 1); + let key = MeasurementKey::new("db", "autogen", "cpu"); + let region = |id: u64, start: u64, end: u64| ShardRegion { + region_id: id, + start, + end, + peers: vec![2], + primary: 2, + ..sample_region() + }; + ctx.shard_map + .apply_op(ShardMapOp::BootstrapMeasurementPresplit { + key, + regions: vec![region(1, 0, 1 << 63), region(2, 1 << 63, u64::MAX)], + }) + .await + .unwrap(); + let dir = tempfile::tempdir().unwrap(); + let metadata = + crate::adapters::metadata::rocksdb_meta::RocksDbMetadata::open(dir.path()).unwrap(); + + let outcome = scatter_delete_to_regions( + &ctx, + &metadata, + None, + "db", + "autogen", + "cpu", + "`series_id` = 1", + ) + .await + .expect("the delete completes"); + assert_eq!(hits.load(Ordering::SeqCst), 1, "one request per primary"); + assert_eq!(outcome.applied, 2); + h.abort(); + } + #[tokio::test] async fn scatter_invokes_callback_with_peer_addrs() { let (addr1, h1) = spawn_mock_peer(StatusCode::INTERNAL_SERVER_ERROR, "fail").await; From d4da0688e1b42c18a1aa8d4672dedfbb79354b5f Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:14:26 +0000 Subject: [PATCH 8/9] Match chDB error codes exactly in delete fallbacks is_unknown_table matched "Code: 60", which codes 600-609 also start with, and a delete that failed with one reported success. is_unknown_column matched "Code: 47" (470-479), and a replica stored such a failed delete as a tombstone. Match "Code: 60." and "Code: 47.". --- .../src/adapters/chdb/native_adapter.rs | 14 +++++++++++++- .../src/application/schema_mutation_apply.rs | 19 ++++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/hyperbytedb/src/adapters/chdb/native_adapter.rs b/hyperbytedb/src/adapters/chdb/native_adapter.rs index cafd910..f62d6e5 100644 --- a/hyperbytedb/src/adapters/chdb/native_adapter.rs +++ b/hyperbytedb/src/adapters/chdb/native_adapter.rs @@ -141,7 +141,7 @@ fn table_schema_from_measurement_meta( /// A chDB error for a table that does not exist. fn is_unknown_table(msg: &str) -> bool { - msg.contains("UNKNOWN_TABLE") || msg.contains("Code: 60") || msg.contains("doesn't exist") + msg.contains("UNKNOWN_TABLE") || msg.contains("Code: 60.") || msg.contains("doesn't exist") } fn tag_column_kind(distinct_values: usize, threshold: usize) -> ColumnKind { @@ -2688,6 +2688,18 @@ mod tests { use arrow::array::Float64Array; use std::collections::BTreeMap; + /// A delete that fails for another reason must not read as "no table, + /// nothing to delete": codes 600-609 start with "Code: 60" too. + #[test] + fn only_code_60_is_an_unknown_table() { + assert!(is_unknown_table( + "Code: 60. DB::Exception: Unknown table expression identifier 'x'. (UNKNOWN_TABLE)" + )); + assert!(!is_unknown_table( + "Code: 603. DB::Exception: Cannot open file. (CANNOT_OPEN_FILE)" + )); + } + fn make_point(ts: i64, tags: &[(&str, &str)], fields: &[(&str, FieldValue)]) -> Point { let mut tag_map = BTreeMap::new(); for (k, v) in tags { diff --git a/hyperbytedb/src/application/schema_mutation_apply.rs b/hyperbytedb/src/application/schema_mutation_apply.rs index ad7145a..930a2d6 100644 --- a/hyperbytedb/src/application/schema_mutation_apply.rs +++ b/hyperbytedb/src/application/schema_mutation_apply.rs @@ -165,7 +165,7 @@ pub(crate) fn is_unknown_column(msg: &str) -> bool { msg.contains("UNKNOWN_IDENTIFIER") || msg.contains("Unknown identifier") || msg.contains("Missing columns") - || msg.contains("Code: 47") + || msg.contains("Code: 47.") } async fn apply_schema_mutation_inner( @@ -401,6 +401,23 @@ pub async fn revoke_privilege( } } +#[cfg(test)] +mod unknown_column_tests { + use super::is_unknown_column; + + /// Only code 47 is a missing column; 470-479 are other failures and a + /// replica must report them, not store the delete as a tombstone. + #[test] + fn only_code_47_is_an_unknown_column() { + assert!(is_unknown_column( + "Code: 47. DB::Exception: Unknown expression identifier `host`. (UNKNOWN_IDENTIFIER)" + )); + assert!(!is_unknown_column( + "Code: 473. DB::Exception: Possible deadlock avoided. (DEADLOCK_AVOIDED)" + )); + } +} + #[cfg(test)] mod drop_space_tests { use super::drop_space_for; From 1b80236e582062429e8dbd18c24a80da5a9c29a4 Mon Sep 17 00:00:00 2001 From: Austin Barrington Date: Fri, 20 Nov 2026 05:15:04 +0000 Subject: [PATCH 9/9] Docs name CatchUpService; tidy doc attributes The deep-dive and developer guides still pointed at adapters/cluster/sync_client.rs, which became CatchUpService in application/cluster/catch_up.rs. Also drop a repeated #[doc(hidden)] and a repeated doc line, and move apply_shard_map_op's doc comment from `mod apply;` onto the function. --- docs/deep-dive/README.md | 2 +- docs/deep-dive/deep-dive-clustering.md | 12 ++++++------ docs/deep-dive/deep-dive-self-repair.md | 2 +- docs/developer-guide/architecture.md | 2 +- docs/developer-guide/internals/core-modules.md | 2 +- docs/developer-guide/system-architecture.md | 2 +- hyperbytedb/src/adapters/chdb/native_adapter.rs | 1 - hyperbytedb/src/application/shard_scheduler.rs | 2 -- hyperbytedb/src/domain/sharding/ops/mod.rs | 2 +- 9 files changed, 12 insertions(+), 15 deletions(-) diff --git a/docs/deep-dive/README.md b/docs/deep-dive/README.md index bcdcd3a..ad9d62b 100644 --- a/docs/deep-dive/README.md +++ b/docs/deep-dive/README.md @@ -8,6 +8,6 @@ Subsystem walkthroughs with pointers to source files. When a deep dive disagrees | [Read path](deep-dive-read-path.md) | TimeseriesQL → ClickHouse SQL → chDB | `timeseriesql/`, `application/query_service.rs`, `adapters/chdb/` | | [Clustering](deep-dive-clustering.md) | Replication, Raft, sync, hinted handoff, **series sharding** | `domain/cluster/`, `application/cluster/`, `application/shard_*.rs`, `adapters/cluster/` | | [Compaction](deep-dive-compaction.md) | MergeTree background merges | chDB / ClickHouse engine | -| [Self-repair](deep-dive-self-repair.md) | Peer convergence via replication and sync | `adapters/cluster/sync_client.rs`, `replication_log.rs` | +| [Self-repair](deep-dive-self-repair.md) | Peer convergence via replication and sync | `application/cluster/catch_up.rs`, `replication_log.rs` | Replication peer sends use exponential backoff starting at 1s, capped at 30s, up to `replication_max_retries` attempts. diff --git a/docs/deep-dive/deep-dive-clustering.md b/docs/deep-dive/deep-dive-clustering.md index d2c485b..2d729f5 100644 --- a/docs/deep-dive/deep-dive-clustering.md +++ b/docs/deep-dive/deep-dive-clustering.md @@ -145,10 +145,10 @@ Called during application startup when `cluster.enabled = true`. ### `run_startup_sync(config, metadata, wal, data_dir)` 1. Set node state to `Syncing`. -2. Build a `SyncClient`. +2. Build a `CatchUpService`. 3. Determine if this is a new node (no existing data) or reconnect: - - **New node:** Call `sync_client.join_and_sync()`. - - **Existing node:** Call `sync_client.reconnect_sync()`. + - **New node:** Call `catch_up.join_and_sync()`. + - **Existing node:** Call `catch_up.reconnect_sync()`. 4. Retry up to 5 times on failure. 5. On success: set state to `Active`. 6. On failure after retries: set state to `Active` with `needs_sync = true` (allows the node to operate but flags it for later re-sync). @@ -157,7 +157,7 @@ Called during application startup when `cluster.enabled = true`. ## 4. Startup Sync -**File:** `src/adapters/cluster/sync_client.rs` +**File:** `src/application/cluster/catch_up.rs` (`CatchUpService`; it reaches peers through the `PeerRpc` port, `src/adapters/cluster/http_peer_rpc.rs`) ### `join_and_sync()` -- Full join flow for new nodes @@ -178,7 +178,7 @@ Called during application startup when `cluster.enabled = true`. ## 5. Reconnect Sync -**File:** `src/adapters/cluster/sync_client.rs` +**File:** `src/application/cluster/catch_up.rs` (`CatchUpService`; it reaches peers through the `PeerRpc` port, `src/adapters/cluster/http_peer_rpc.rs`) ### `reconnect_sync()` -- For existing nodes reconnecting after downtime @@ -457,7 +457,7 @@ This ensures peers that are catching up can still read needed WAL entries. Peers stay aligned through three mechanisms: 1. **Write replication** — after local WAL append, the coordinator fans out line protocol to peers (`ReplicationPort` / `PeerClient`). -2. **Startup and reconnect sync** — `SyncClient` exchanges metadata snapshots and WAL tail entries via `/internal/sync/{manifest,metadata,wal}`. +2. **Startup and reconnect sync** — `CatchUpService` exchanges metadata snapshots and WAL tail entries via `/internal/sync/{manifest,metadata,wal}`. 3. **Local flush** — each peer replays its WAL (including replicated entries) into local MergeTree tables via `PointsSinkPort`. There is no separate file-repair loop. chDB storage on each node is derived from the shared WAL + metadata contract. diff --git a/docs/deep-dive/deep-dive-self-repair.md b/docs/deep-dive/deep-dive-self-repair.md index 605379e..3bfabc7 100644 --- a/docs/deep-dive/deep-dive-self-repair.md +++ b/docs/deep-dive/deep-dive-self-repair.md @@ -3,7 +3,7 @@ In clustered deployments, replicas converge through: 1. **Write replication** — line protocol fan-out after each local WAL append. -2. **Metadata + WAL sync** — startup and reconnect paths in `SyncClient` (`/internal/sync/manifest`, `/internal/sync/metadata`, `/internal/sync/wal`). +2. **Metadata + WAL sync** — startup and reconnect paths in `CatchUpService` (`/internal/sync/manifest`, `/internal/sync/metadata`, `/internal/sync/wal`). 3. **Local flush** — each node replays WAL entries (including replicated writes) into its own MergeTree tables. Peer ack tracking in `ReplicationLog` informs safe WAL truncation so lagging nodes can catch up. diff --git a/docs/developer-guide/architecture.md b/docs/developer-guide/architecture.md index 4a496d6..8fe4606 100644 --- a/docs/developer-guide/architecture.md +++ b/docs/developer-guide/architecture.md @@ -68,7 +68,7 @@ graph TB RocksWAL["RocksDB WAL"] RocksMeta["RocksDB Metadata"] ChDBAdapter["chDB query + native sink"] - ClusterIO["cluster/ peer_client, sync_client, raft"] + ClusterIO["cluster/ peer_client, http_peer_rpc, raft"] end InboundAdapters --> App diff --git a/docs/developer-guide/internals/core-modules.md b/docs/developer-guide/internals/core-modules.md index 0b5c4a5..e7293e8 100644 --- a/docs/developer-guide/internals/core-modules.md +++ b/docs/developer-guide/internals/core-modules.md @@ -120,7 +120,7 @@ Axum handlers, router (`AppState`), middleware, auth, internal cluster/Raft endp | File / dir | Description | |------------|-------------| | `peer_client.rs` | Outbound replication HTTP client. Implements `ReplicationPort`. | -| `sync_client.rs` | Join/reconnect sync: metadata + WAL catch-up. | +| `http_peer_rpc.rs` | `PeerRpc` over HTTP. Join/reconnect sync itself is `CatchUpService` in `application/cluster/catch_up.rs`. | | `replication_log.rs` | RocksDB-backed per-peer WAL/mutation ack tracking. | | `hinted_handoff.rs` | Per-peer queued hints for unreachable peers. | | `transport.rs` | Shared HTTP transport abstraction for cluster I/O. | diff --git a/docs/developer-guide/system-architecture.md b/docs/developer-guide/system-architecture.md index 80e7ecc..3a57ba4 100644 --- a/docs/developer-guide/system-architecture.md +++ b/docs/developer-guide/system-architecture.md @@ -152,7 +152,7 @@ src/ ├── http/ Axum handlers + internal cluster endpoints ├── chdb/ QueryPort + PointsSinkPort (native adapter) ├── wal/, metadata/, auth.rs - └── cluster/ peer_client, sync_client, replication_log, raft/ + └── cluster/ peer_client, http_peer_rpc, replication_log, raft/ ``` --- diff --git a/hyperbytedb/src/adapters/chdb/native_adapter.rs b/hyperbytedb/src/adapters/chdb/native_adapter.rs index f62d6e5..960f76e 100644 --- a/hyperbytedb/src/adapters/chdb/native_adapter.rs +++ b/hyperbytedb/src/adapters/chdb/native_adapter.rs @@ -480,7 +480,6 @@ impl ChdbNativeAdapter { /// /// Test support. #[doc(hidden)] - #[doc(hidden)] pub fn engine_probe_count(&self) -> u64 { self.engine_probes .load(std::sync::atomic::Ordering::Relaxed) diff --git a/hyperbytedb/src/application/shard_scheduler.rs b/hyperbytedb/src/application/shard_scheduler.rs index c785bc2..2c89272 100644 --- a/hyperbytedb/src/application/shard_scheduler.rs +++ b/hyperbytedb/src/application/shard_scheduler.rs @@ -766,8 +766,6 @@ impl ShardScheduler { /// The series count this scheduler holds for `(region_id, node_id)`, or /// `None` if it never recorded one. Test support for the heartbeat /// handler, which has no other externally visible effect. - /// - /// Test support. #[doc(hidden)] pub async fn recorded_heartbeat_series(&self, region_id: u64, node_id: u64) -> Option { self.heartbeats diff --git a/hyperbytedb/src/domain/sharding/ops/mod.rs b/hyperbytedb/src/domain/sharding/ops/mod.rs index 3d307b0..3c47491 100644 --- a/hyperbytedb/src/domain/sharding/ops/mod.rs +++ b/hyperbytedb/src/domain/sharding/ops/mod.rs @@ -235,9 +235,9 @@ fn sort_space_regions(space: &mut super::types::MeasurementShardSpace) { space.regions.sort_by_key(|r| r.start); } -/// Apply `op` to an in-memory map snapshot (used by Raft apply and unit tests). mod apply; +/// Apply `op` to an in-memory map snapshot (used by Raft apply and unit tests). pub fn apply_shard_map_op( map: &mut super::types::ShardMap, op: ShardMapOp,