use super::{config::SegConfig, query::SegRange, testkit::*};
use std::{ops::Bound, sync::Arc};
fn roomy() -> SegConfig {
SegConfig {
seal_max_keys: 100_000,
seal_max_bytes: 32 << 20,
max_file_size: 16 << 20,
max_frozen_generations: 64,
..SegConfig::test()
}
}
#[test]
fn ordered_newest_wins_in_both_directions() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 1..=3 {
core.put(&ordered_key(i), b"old").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
core.delete(&ordered_key(2)).unwrap();
core.put(&ordered_key(3), b"newest").unwrap();
for rev in [false, true] {
let q = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let rows = core
.ordered_iter(q, true, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap();
assert_eq!(
rows.iter().map(|r| r.0).collect::<Vec<_>>(),
if rev {
vec![ordered_key(3), ordered_key(1)]
} else {
vec![ordered_key(1), ordered_key(3)]
}
);
assert_eq!(
rows.iter().find(|r| r.0 == ordered_key(3)).unwrap().1,
b"newest"
);
}
assert_eq!(core.count_exact().unwrap(), 2);
}
#[test]
fn ordered_hint_prunes_layers_not_rows() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(100);
let core = open_tree_core(dir.path(), roomy(), clock.clone(), &[]);
for i in 1..=3 {
core.put(&ordered_key(i), b"old").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
clock.set(200);
core.put(&ordered_key(1), b"new").unwrap();
core.delete(&ordered_key(2)).unwrap();
core.seal().unwrap();
let rows = core
.ordered_iter(SegRange::all().written_since(150), true, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap();
assert_eq!(rows, vec![(ordered_key(1), b"new".to_vec())]);
}
#[test]
fn ordered_errors_are_terminal() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..800 {
core.put(&ordered_key(i), b"v").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
let segment = core.view().sealed[0].clone();
let (offset, _) = segment
.block_range_in(segment.block_count().unwrap() - 1, &mut None, None)
.unwrap();
std::fs::OpenOptions::new()
.write(true)
.open(segment.sdat_path())
.unwrap()
.set_len(offset)
.unwrap();
let mut iter = core.ordered_iter(SegRange::all(), true, false);
let mut good = 0;
loop {
match iter.next() {
Some(Ok(_)) => good += 1,
Some(Err(_)) => break,
None => panic!("missing corruption"),
}
}
assert!(good > 0);
assert!(iter.next().is_none());
}
#[test]
fn ordered_invisible_stretch_advances_consumed_cursor() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..4200 {
core.put(&ordered_key(i), b"v").unwrap();
core.delete(&ordered_key(i)).unwrap();
}
core.put(&ordered_key(4200), b"end").unwrap();
assert_eq!(
core.ordered_iter(SegRange::all(), false, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap(),
vec![(ordered_key(4200), vec![])]
);
assert_eq!(
core.ordered_iter(SegRange::all().rev(), false, true)
.count(),
1
);
}
#[test]
fn ordered_batch_bounds_allow_one_oversized_value() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(
dir.path(),
SegConfig {
write_buffer_size: 4 << 20,
..roomy()
},
TestClock::new(100),
&[],
);
core.put(&ordered_key(0), &vec![7; (1 << 20) + 1]).unwrap();
for i in 1..600 {
core.put(&ordered_key(i), &vec![8; 5000]).unwrap();
}
let mut iter = core.ordered_iter(SegRange::all(), true, true);
assert_eq!(iter.next().unwrap().unwrap().1.len(), (1 << 20) + 1);
assert_eq!(iter.buffered_stats(), (0, 0));
let mut n = 1;
while let Some(row) = iter.next() {
row.unwrap();
n += 1;
let (rows, bytes) = iter.buffered_stats();
assert!(rows <= 255);
assert!(bytes <= 1 << 20);
}
assert_eq!(n, 600);
let mut keys = core.ordered_iter(SegRange::all(), false, true);
keys.next().unwrap().unwrap();
assert_eq!(keys.buffered_stats(), (255, 0));
}
#[test]
fn ordered_idle_iterators_release_layers_across_seals() {
for rev in [false, true] {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
let mut idle = Vec::new();
for wave in 0..3 {
for i in 0..600 {
core.put(&ordered_key(i + wave * 1000), b"v").unwrap();
}
let (weak, path) = {
let view = core.view();
(
Arc::downgrade(&view.active),
view.active.dir().to_path_buf(),
)
};
let q = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut iter = core.ordered_iter(q, true, true);
iter.next().unwrap().unwrap();
idle.push(iter);
core.seal().unwrap();
core.seal_oldest().unwrap();
assert!(weak.upgrade().is_none());
assert!(!path.exists());
}
}
}
#[test]
fn ordered_idle_iterators_do_not_pin_retained_files() {
for rev in [false, true] {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..600 {
core.put(&ordered_key(i), b"v").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
let (weak, data, index) = {
let v = core.view();
let s = &v.sealed[0];
(
Arc::downgrade(s),
s.sdat_path().to_path_buf(),
s.sidx_path().to_path_buf(),
)
};
let q = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut iter = core.ordered_iter(q, true, true);
iter.next().unwrap().unwrap();
core.drop_segments_before(101).unwrap();
assert!(weak.upgrade().is_none());
assert!(!data.exists() && !index.exists());
}
}
#[test]
fn ordered_refill_survives_view_changes_without_duplicates() {
for rev in [false, true] {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..900 {
core.put(&ordered_key(i), b"v").unwrap();
}
let q = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut iter = core.ordered_iter(q, true, true);
let mut keys = vec![iter.next().unwrap().unwrap().0];
core.seal().unwrap();
core.seal_oldest().unwrap();
keys.extend(iter.map(|r| r.unwrap().0));
let mut expected = (0..900).map(ordered_key).collect::<Vec<_>>();
if rev {
expected.reverse();
}
assert_eq!(keys, expected);
}
}
#[test]
fn ordered_prefix_and_common_bound_prefix_prune_before_io() {
let dir = tempfile::tempdir().unwrap();
let core = open_raw_tree_core(dir.path(), roomy(), TestClock::new(100), &[8, 16]);
for i in [1, 1000] {
core.put(&raw_ordered_key(i), b"v").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
let segment = core.view().sealed[0].clone();
let probe = (2..1000)
.map(raw_ordered_key)
.find(|k| {
!segment
.prefix_may_contain(&k.as_bytes()[..8], None)
.unwrap()
})
.unwrap();
let mut end = probe;
end.as_bytes_mut()[8] = 255;
let before = segment.block_reads();
assert!(
core.ordered_iter(SegRange::prefix(&probe.as_bytes()[..8]), true, true)
.next()
.is_none()
);
assert!(
core.ordered_iter(
SegRange::range(Bound::Included(&probe), Bound::Included(&end)),
true,
true
)
.next()
.is_none()
);
assert!(
core.ordered_iter(
SegRange::prefix(&raw_ordered_key(2000).as_bytes()[..8]),
true,
true
)
.next()
.is_none()
);
assert_eq!(segment.block_reads(), before);
}
use crate::key::Key;
#[test]
fn ordered_user_cache_and_internal_scans() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..400 {
core.put(&ordered_key(i), b"value").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
let before = (core.cache.hits(), core.cache.misses());
let mut rows = Vec::new();
core.scan(&mut |row| {
rows.push(row.unwrap());
std::ops::ControlFlow::Continue(())
});
assert_eq!(rows.len(), 400);
assert!(rows.windows(2).all(|w| w[0].0 < w[1].0));
assert_eq!(core.count_exact().unwrap(), 400);
let mut keys = Vec::new();
core.scan_keys(&mut |key| {
keys.push(key.unwrap());
std::ops::ControlFlow::Continue(())
});
assert_eq!(keys, rows.iter().map(|r| r.0).collect::<Vec<_>>());
assert_eq!((core.cache.hits(), core.cache.misses()), before);
assert_eq!(core.ordered_iter(SegRange::all(), true, true).count(), 400);
let hits = core.cache.hits();
assert_eq!(
core.ordered_iter(SegRange::all().rev(), true, true).count(),
400
);
assert!(core.cache.hits() > hits);
}
#[test]
fn ordered_journal_errors_terminal_and_keys_skip_values() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..400 {
core.put(&ordered_key(i), b"v").unwrap();
}
core.flush().unwrap();
let _unreadable = UnreadableJournals::new(dir.path());
assert_eq!(core.ordered_iter(SegRange::all(), false, true).count(), 400);
let mut iter = core.ordered_iter(SegRange::all(), true, true);
assert!(matches!(iter.next(), Some(Err(_))));
assert!(iter.next().is_none());
}
#[test]
fn ordered_missing_prefix_filter_is_readable_after_reopen() {
let dir = tempfile::tempdir().unwrap();
{
let core = open_raw_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 1..4 {
core.put(&raw_ordered_key(i), b"v").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
let core = open_raw_tree_core(dir.path(), roomy(), TestClock::new(100), &[8, 16]);
assert_eq!(
core.ordered_iter(
SegRange::prefix(&raw_ordered_key(2).as_bytes()[..8]),
true,
true
)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap(),
vec![(raw_ordered_key(2), b"v".to_vec())]
);
}
#[test]
fn ordered_retention_preserves_unchanged_keys_ahead_of_cursor() {
for rev in [false, true] {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(100);
let core = open_tree_core(dir.path(), roomy(), clock.clone(), &[]);
for i in 400..600 {
core.put(&ordered_key(i), b"old").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
clock.set(200);
for i in (0..400).chain(600..1000) {
core.put(&ordered_key(i), b"keep").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
let q = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut iter = core.ordered_iter(q, true, true);
let first = iter.next().unwrap().unwrap().0;
core.drop_segments_before(150).unwrap();
let mut keys = vec![first];
keys.extend(iter.map(|r| r.unwrap().0));
let retained = keys
.iter()
.filter(|k| **k < ordered_key(400) || **k >= ordered_key(600))
.copied()
.collect::<Vec<_>>();
let mut expected = (0..400)
.chain(600..1000)
.map(ordered_key)
.collect::<Vec<_>>();
if rev {
expected.reverse();
}
assert_eq!(retained, expected);
let unique = keys
.iter()
.copied()
.collect::<std::collections::BTreeSet<_>>();
assert_eq!(unique.len(), keys.len());
}
}
#[test]
fn ordered_entry_crc_is_checked_even_with_valid_block_crc() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
core.put(&ordered_key(1), b"v").unwrap();
core.seal().unwrap();
core.seal_oldest().unwrap();
let segment = core.view().sealed[0].clone();
let (offset, len) = segment.block_range_in(0, &mut None, None).unwrap();
let mut bytes = std::fs::read(segment.sdat_path()).unwrap();
let block = &mut bytes[offset as usize..offset as usize + len];
block[super::block::BLOCK_HEADER_LEN] ^= 1;
let mut hasher = crc32fast::Hasher::new();
hasher.update(&block[..12]);
hasher.update(&block[super::block::BLOCK_HEADER_LEN..]);
block[12..16].copy_from_slice(&hasher.finalize().to_le_bytes());
std::fs::write(segment.sdat_path(), bytes).unwrap();
let mut iter = core.ordered_iter(SegRange::all(), true, false);
assert!(matches!(
iter.next(),
Some(Err(crate::error::DbError::SegmentCorrupt { .. }))
));
assert!(iter.next().is_none());
}
#[test]
fn ordered_refill_metric_counts_stream_rebuilds_not_buffered_rows() {
use metrics::{
Counter, CounterFn, Gauge, GaugeFn, Histogram, Key, KeyName, Metadata, Recorder,
SharedString, Unit,
};
use std::sync::atomic::{AtomicU64, Ordering};
struct Sink(AtomicU64);
impl CounterFn for Sink {
fn increment(&self, n: u64) {
self.0.fetch_add(n, Ordering::Relaxed);
}
fn absolute(&self, n: u64) {
self.0.store(n, Ordering::Relaxed);
}
}
impl GaugeFn for Sink {
fn increment(&self, n: f64) {
self.0.fetch_add(n as u64, Ordering::Relaxed);
}
fn decrement(&self, n: f64) {
self.0.fetch_sub(n as u64, Ordering::Relaxed);
}
fn set(&self, n: f64) {
self.0.store(n as u64, Ordering::Relaxed);
}
}
struct Capture(Arc<Sink>, Arc<Sink>, Arc<Sink>);
impl Recorder for Capture {
fn describe_counter(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_gauge(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_histogram(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn register_counter(&self, key: &Key, _: &Metadata<'_>) -> Counter {
if key.name() == "armdb.seg.ordered_refills" {
assert!(
key.labels()
.any(|l| l.key() == "collection" && l.value() == meta().name)
);
Counter::from_arc(self.0.clone())
} else if key.name() == "armdb.seg.ordered_reseeks" {
assert!(
key.labels()
.any(|l| l.key() == "collection" && l.value() == meta().name)
);
Counter::from_arc(self.1.clone())
} else {
Counter::noop()
}
}
fn register_gauge(&self, key: &Key, _: &Metadata<'_>) -> Gauge {
if key.name() == "armdb.seg.block_cache_weight_bytes" {
assert!(
key.labels()
.any(|l| l.key() == "collection" && l.value() == meta().name)
);
Gauge::from_arc(self.2.clone())
} else {
Gauge::noop()
}
}
fn register_histogram(&self, _: &Key, _: &Metadata<'_>) -> Histogram {
Histogram::noop()
}
}
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..600 {
core.put(&ordered_key(i), b"v").unwrap();
}
let sink = Arc::new(Sink(AtomicU64::new(0)));
let seeks = Arc::new(Sink(AtomicU64::new(0)));
let cache_weight = Arc::new(Sink(AtomicU64::new(0)));
let recorder = Capture(sink.clone(), seeks.clone(), cache_weight.clone());
metrics::with_local_recorder(&recorder, || {
let mut iter = core.ordered_iter(SegRange::all(), true, true);
for _ in 0..256 {
iter.next().unwrap().unwrap();
assert_eq!(sink.0.load(Ordering::Relaxed), 1);
}
iter.next().unwrap().unwrap();
assert_eq!(sink.0.load(Ordering::Relaxed), 2);
assert_eq!(iter.count(), 343);
assert_eq!(sink.0.load(Ordering::Relaxed), 3);
assert!(
core.ordered_iter(SegRange::prefix(&[0; 33]), false, true)
.next()
.is_none()
);
assert_eq!(sink.0.load(Ordering::Relaxed), 3);
assert_eq!(
seeks.0.load(Ordering::Relaxed),
0,
"generation seeks excluded"
);
});
let filtered_dir = tempfile::tempdir().unwrap();
let filtered = open_raw_tree_core(filtered_dir.path(), roomy(), TestClock::new(100), &[8]);
for i in [1, 1000] {
filtered.put(&raw_ordered_key(i), b"v").unwrap();
}
filtered.seal().unwrap();
filtered.seal_oldest().unwrap();
let segment = filtered.view().sealed[0].clone();
let absent = (2..1000)
.map(raw_ordered_key)
.find(|k| {
!segment
.prefix_may_contain(&k.as_bytes()[..8], None)
.unwrap()
})
.unwrap();
metrics::with_local_recorder(&recorder, || {
assert!(
filtered
.ordered_iter(SegRange::prefix(&absent.as_bytes()[..8]), true, true)
.next()
.is_none()
);
assert_eq!(
seeks.0.load(Ordering::Relaxed),
0,
"prefix-pruned segment has no seek"
);
assert!(
filtered
.ordered_iter(SegRange::all().written_since(101), true, true)
.next()
.is_none()
);
assert_eq!(
seeks.0.load(Ordering::Relaxed),
0,
"hint-pruned segment has no seek"
);
assert!(
filtered
.ordered_iter(
SegRange::prefix(&raw_ordered_key(2000).as_bytes()[..8]),
true,
true
)
.next()
.is_none()
);
assert_eq!(
seeks.0.load(Ordering::Relaxed),
0,
"range-pruned segment has no seek"
);
let key = raw_ordered_key(1);
let mut iter = filtered.ordered_iter(SegRange::prefix(&key.as_bytes()[..8]), true, true);
assert_eq!(iter.next().unwrap().unwrap().0, key);
assert_eq!(seeks.0.load(Ordering::Relaxed), 1);
assert!(iter.next().is_none());
assert_eq!(
seeks.0.load(Ordering::Relaxed),
1,
"buffered/end calls have no seek"
);
let stats = filtered.stats();
assert!(stats.cache_misses > 0);
assert!(
cache_weight.0.load(Ordering::Relaxed) > 0,
"filled cache weight is reported"
);
});
let disabled_dir = tempfile::tempdir().unwrap();
let mut disabled_config = roomy();
disabled_config.block_cache_bytes = 0;
let disabled = open_raw_tree_core(
disabled_dir.path(),
disabled_config,
TestClock::new(100),
&[],
);
disabled.put(&raw_ordered_key(1), b"v").unwrap();
disabled.seal().unwrap();
disabled.seal_oldest().unwrap();
metrics::with_local_recorder(&recorder, || {
assert!(
disabled
.ordered_iter(SegRange::all(), true, true)
.next()
.is_some()
);
let stats = disabled.stats();
assert_eq!(stats.cache_hits, 0);
assert_eq!(stats.cache_misses, 0);
assert_eq!(
cache_weight.0.load(Ordering::Relaxed),
0,
"disabled cache resets gauge to zero"
);
});
}
#[test]
fn ordered_internal_scan_reads_each_block_about_once() {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig {
block_size: 16 << 10,
..roomy()
};
let core = open_tree_core(dir.path(), config, TestClock::new(100), &[]);
let segments = 8u64;
let per_segment = 4_000u64;
for s in 0..segments {
for i in 0..per_segment {
core.put(&ordered_key(i * segments + s), &[s as u8; 8])
.unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
let view = core.view();
assert_eq!(view.sealed.len(), segments as usize);
let blocks: u64 = view
.sealed
.iter()
.map(|s| s.block_count().unwrap() as u64)
.sum();
let reads = || view.sealed.iter().map(|s| s.block_reads()).sum::<u64>();
let refills = (segments * per_segment).div_ceil(256);
assert!(
refills * segments > 2 * blocks,
"the fixture must make per-refill rereads visible"
);
for want_values in [true, false] {
let before = reads();
let mut n = 0u64;
let mut visit = |row: crate::DbResult<(TestKey, Vec<u8>)>| {
row.unwrap();
n += 1;
std::ops::ControlFlow::Continue(())
};
if want_values {
core.scan(&mut visit);
} else {
core.scan_keys(&mut |k| visit(k.map(|k| (k, Vec::new()))));
}
assert_eq!(n, segments * per_segment);
let read = reads() - before;
assert!(
read >= blocks && read <= 2 * blocks,
"{read} block reads for {blocks} blocks"
);
}
}
#[test]
fn ordered_limited_refill_buffers_only_the_wanted_rows() {
let dir = tempfile::tempdir().unwrap();
let core = open_tree_core(dir.path(), roomy(), TestClock::new(100), &[]);
for i in 0..600 {
core.put(&ordered_key(i), b"value").unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
for i in 600..1200 {
core.put(&ordered_key(i), b"value").unwrap();
}
for (q, first) in [(SegRange::all(), 0), (SegRange::all().rev(), 1199)] {
let mut iter = core.ordered_iter(q.clone(), true, true);
iter.limit_rows(1);
assert_eq!(iter.next().unwrap().unwrap().0, ordered_key(first));
assert_eq!(iter.buffered_stats().0, 0);
let mut iter = core.ordered_iter(q.clone(), true, true);
iter.limit_rows(50);
assert_eq!(iter.next().unwrap().unwrap().0, ordered_key(first));
assert_eq!(iter.buffered_stats().0, 49);
let mut iter = core.ordered_iter(q, true, true);
iter.limit_rows(7);
let keys = iter.map(|r| r.unwrap().0).collect::<Vec<_>>();
assert_eq!(keys.len(), 1200);
assert!(keys.windows(2).all(|w| (w[0] < w[1]) == (first == 0)));
}
}
fn cold_ordered_config() -> SegConfig {
SegConfig {
resident_metadata_bytes: Some(0),
block_cache_bytes: 0,
block_size: 256,
..roomy()
}
}
#[test]
fn public_cache_path_carries_a_ready_group_across_refills() {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig {
block_size: 16 << 10,
..cold_ordered_config()
};
let core = open_tree_core(dir.path(), config.clone(), TestClock::new(100), &[]);
for i in 0..400 {
core.put(&ordered_key(i), &[7; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
drop(core);
let core = open_tree_core(dir.path(), config, TestClock::new(100), &[]);
let view = core.view();
assert_eq!(view.sealed.len(), 1);
assert_eq!(view.sealed[0].block_count().unwrap().div_ceil(128), 1);
for values in [false, true] {
for rev in [false, true] {
let query = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let before = core.stats().meta_requests;
let actual = core
.ordered_iter(query, values, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap();
let mut expected: Vec<_> = (0..400)
.map(|i| (ordered_key(i), if values { vec![7; 80] } else { vec![] }))
.collect();
if rev {
expected.reverse();
}
assert_eq!(actual, expected);
assert_eq!(
core.stats().meta_requests - before,
3,
"values={values}, rev={rev}"
);
}
}
}
#[test]
fn a_multi_refill_cold_scan_reads_each_group_once() {
for (layers, rows, block_size) in [
(1, 400, 16 << 10),
(1, 1280, 256),
(1, 1350, 256),
(3, 900, 16 << 10),
(3, 900, 256),
] {
let dir = tempfile::tempdir().unwrap();
let config = SegConfig {
block_size,
..cold_ordered_config()
};
let core = open_tree_core(dir.path(), config.clone(), TestClock::new(100), &[]);
for layer in 0..layers {
for i in 0..rows {
core.put(&ordered_key(i * layers + layer), &[7; 80])
.unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
drop(core);
let core = open_tree_core(dir.path(), config, TestClock::new(100), &[]);
let view = core.view();
let groups: u64 = view
.sealed
.iter()
.map(|s| s.block_count().unwrap().div_ceil(128) as u64)
.sum();
let blocks: u64 = view
.sealed
.iter()
.map(|s| s.block_count().unwrap() as u64)
.sum();
assert!(view.sealed.iter().all(|s| s.hot.is_none()));
if layers == 1 && rows == 1280 {
assert_eq!(groups, 10);
}
for rev in [false, true] {
let before = view.sealed[0].shared_io_requests();
let before_blocks: u64 = view.sealed.iter().map(|s| s.block_reads()).sum();
let query = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let actual = if rev {
core.ordered_iter(query, false, false)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap()
} else {
let mut rows = Vec::new();
core.scan_keys(&mut |row| {
rows.push((row.unwrap(), Vec::new()));
std::ops::ControlFlow::Continue(())
});
rows
};
let mut expected: Vec<_> = (0..rows * layers)
.map(|i| (ordered_key(i), vec![]))
.collect();
if rev {
expected.reverse();
}
assert_eq!(actual, expected);
assert_eq!(
view.sealed[0].shared_io_requests() - before,
3 * groups,
"layers={layers}, rows={rows}, rev={rev}"
);
let reads = view.sealed.iter().map(|s| s.block_reads()).sum::<u64>() - before_blocks;
assert!(
reads >= blocks && reads <= 2 * blocks,
"{reads} for {blocks}"
);
}
}
}
#[test]
fn a_group_error_ends_the_iterator() {
let dir = tempfile::tempdir().unwrap();
let config = cold_ordered_config();
let core = open_tree_core(dir.path(), config.clone(), TestClock::new(100), &[]);
for i in 0..800 {
core.put(&ordered_key(i), &[7; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
drop(core);
let core = open_tree_core(dir.path(), config, TestClock::new(100), &[]);
core.shared.io.fail_read_at(4);
let mut iter = core.ordered_iter(SegRange::all(), false, false);
let mut good = 0;
loop {
match iter.next() {
Some(Ok(_)) => good += 1,
Some(Err(crate::DbError::Io(_))) => break,
other => panic!("unexpected {other:?}"),
}
}
core.shared.io.fail_read_at(0);
assert_eq!(good, 128);
assert!(iter.next().is_none());
assert!(iter.next().is_none());
}
#[test]
fn an_excluded_pending_corrupt_segment_is_never_touched() {
let dir = tempfile::tempdir().unwrap();
let clock = TestClock::new(100);
let config = cold_ordered_config();
let core = open_raw_tree_core(dir.path(), config.clone(), clock.clone(), &[4]);
for wave in 0..3 {
clock.set(100 + wave * 100);
for i in 0..600 {
core.put(&raw_ordered_key(i), &[wave as u8; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
}
let mut manifest = core.manifest.lock().clone();
for rec in &mut manifest.segments {
*rec = rewrite_sections(&dir.path().join("seg"), rec, |sections| {
sections.retain(|(kind, _)| *kind != super::sidecar::SECTION_PAGE_INDEX);
});
}
drop(core);
super::manifest::publish(&*super::fs::real(), dir.path(), &manifest).unwrap();
let core = open_raw_tree_core(dir.path(), config, clock, &[4]);
let view = core.view();
let oldest = view
.sealed
.iter()
.find(|s| s.record().frozen_at_ms == 100)
.unwrap();
let newest = view
.sealed
.iter()
.find(|s| s.record().frozen_at_ms == 300)
.unwrap();
assert!(view.sealed.iter().all(|s| s.files.skeleton.get().is_none()));
corrupt_prefix_fingerprints(&dir.path().join("seg"), oldest.record(), 4);
newest.skeleton().unwrap();
let prefix = ordered_key(0)[..4].to_vec();
let query: SegRange<RawTestKey> = SegRange::prefix(&prefix);
assert!(view.sealed.iter().all(|s| {
let range = s.key_range().unwrap();
query.overlaps(&range.min, &range.max) && s.prefix_filter_lens().contains(&4)
}));
let before = newest.shared_io_requests();
let rows = core
.ordered_iter(SegRange::prefix(&prefix).written_since(300), true, false)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap();
assert_eq!(rows.len(), 600);
assert!(rows.iter().all(|(_, v)| v == &[2; 80]));
assert!(oldest.files.skeleton.get().is_none());
assert!(
view.sealed
.iter()
.find(|s| s.record().frozen_at_ms == 200)
.unwrap()
.files
.skeleton
.get()
.is_none()
);
assert_eq!(newest.shared_io_requests() - before, 15 + 1);
assert!(matches!(
core.ordered_iter(SegRange::prefix(&prefix), false, false)
.collect::<crate::DbResult<Vec<_>>>(),
Err(crate::DbError::SegmentCorrupt { .. })
));
}
#[test]
fn cold_ordered_refills_release_files_and_survive_seal_and_drop() {
for rev in [false, true] {
let dir = tempfile::tempdir().unwrap();
let config = cold_ordered_config();
let clock = TestClock::new(100);
let core = open_tree_core(dir.path(), config.clone(), clock.clone(), &[]);
for i in 0..900 {
core.put(&ordered_key(i), &[7; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
drop(core);
let core = open_tree_core(dir.path(), config, clock.clone(), &[]);
let (weak, files, data, index) = {
let view = core.view();
let s = &view.sealed[0];
(
Arc::downgrade(s),
Arc::downgrade(&s.files),
s.sdat_path().to_path_buf(),
s.sidx_path().to_path_buf(),
)
};
let query = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut iter = core.ordered_iter(query, true, false);
let first = iter.next().unwrap().unwrap();
clock.set(200);
for i in 0..900 {
core.put(&ordered_key(i), &[7; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
core.drop_segments_before(150).unwrap();
assert!(weak.upgrade().is_none());
assert!(files.upgrade().is_none());
assert!(!data.exists() && !index.exists());
let actual: Vec<_> = std::iter::once(first)
.chain(iter.map(Result::unwrap))
.collect();
let mut expected: Vec<_> = (0..900).map(|i| (ordered_key(i), vec![7; 80])).collect();
if rev {
expected.reverse();
}
assert_eq!(actual, expected);
}
}
#[test]
fn cold_scans_cross_groups_in_both_directions() {
let dir = tempfile::tempdir().unwrap();
let config = cold_ordered_config();
let hot = open_tree_core(
dir.path(),
SegConfig {
resident_metadata_bytes: None,
..config.clone()
},
TestClock::new(100),
&[],
);
for i in 0..900 {
hot.put(&ordered_key(i), &[7; 80]).unwrap();
}
hot.seal().unwrap();
hot.seal_oldest().unwrap();
let asc = hot
.ordered_iter(SegRange::all(), true, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap();
drop(hot);
let cold = open_tree_core(dir.path(), config, TestClock::new(100), &[]);
for rev in [false, true] {
let query = if rev {
SegRange::all().rev()
} else {
SegRange::all()
};
let mut expected = asc.clone();
if rev {
expected.reverse();
}
assert_eq!(
cold.ordered_iter(query, true, true)
.collect::<crate::DbResult<Vec<_>>>()
.unwrap(),
expected
);
}
}
#[test]
fn a_corrupt_cold_prefix_page_is_a_terminal_error() {
let dir = tempfile::tempdir().unwrap();
let config = cold_ordered_config();
let core = open_raw_tree_core(dir.path(), config.clone(), TestClock::new(100), &[4]);
for i in 0..600 {
core.put(&raw_ordered_key(i), &[7; 80]).unwrap();
}
core.seal().unwrap();
core.seal_oldest().unwrap();
drop(core);
let core = open_raw_tree_core(dir.path(), config, TestClock::new(100), &[4]);
let segment = core.view().sealed[0].clone();
assert!(segment.hot.is_none());
assert!(segment.files.skeleton.get().is_some());
corrupt_prefix_fingerprints(&dir.path().join("seg"), segment.record(), 4);
let before = segment.shared_io_requests();
let mut iter = core.ordered_iter(SegRange::prefix(&ordered_key(0)[..4]), false, false);
assert!(matches!(
iter.next(),
Some(Err(crate::DbError::SegmentCorrupt { .. }))
));
assert_eq!(segment.shared_io_requests() - before, 1);
assert!(iter.next().is_none());
}