use std::fs::File;
use std::os::unix::fs::FileExt;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use xxhash_rust::xxh3::xxh3_64;
use super::FormatFault;
use super::block::{Found, decode_block, find_in_block};
use super::cache::{CacheItem, SegBlockCache, SegBlockKey};
use super::core::SegShared;
use super::filter::{PartitionedFilter, Probe, probe, probe_matches};
use super::fs::SegFs;
use super::hash::key_hash;
use super::key_index::{KeyRange, SegmentIndex};
use super::manifest::SegRecord;
use super::page_index::{
FilterSkeleton, GroupKeys, GroupSamples, IndexGroup, PROBE_WINDOW, PageIndex, PagedSection,
};
use super::seal::{sdat_name, sidx_name};
use super::sidecar::{
FILE_HEADER_LEN, Properties, SDAT_MAGIC, SECTION_KEY_RANGE, SECTION_PAGE_INDEX,
SECTION_PROPERTIES, SECTION_RECORD_LEN, SIDX_FOOTER_LEN, SIDX_MAGIC, SectionRecord, SegHeader,
Sidecar, check_section_table, parse_footer, parse_table,
};
use super::skeleton::SkeletonCell;
use crate::error::{DbError, DbResult};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Lookup {
Live(Vec<u8>),
Tombstone,
Absent,
}
fn corrupt(rec: &SegRecord, path: &Path, reason: String) -> DbError {
DbError::SegmentCorrupt {
segment_id: rec.segment_id,
block: None,
path: path.to_path_buf(),
reason,
}
}
fn open_checked(rec: &SegRecord, path: &Path, expected_len: u64) -> DbResult<File> {
let file = match File::open(path) {
Ok(file) => file,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Err(DbError::SegmentMissing {
segment_id: rec.segment_id,
path: path.to_path_buf(),
});
}
Err(e) => return Err(e.into()),
};
let len = file.metadata()?.len();
if len != expected_len {
return Err(corrupt(
rec,
path,
format!("file is {len} bytes, the manifest records {expected_len}"),
));
}
Ok(file)
}
fn read_at(file: &File, offset: u64, len: usize) -> std::io::Result<Vec<u8>> {
let mut buf = vec![0u8; len];
file.read_exact_at(&mut buf, offset)?;
Ok(buf)
}
fn check_header(
rec: &SegRecord,
path: &Path,
bytes: &[u8],
magic: [u8; 4],
key_len: u16,
seed: u64,
) -> DbResult<SegHeader> {
let header = SegHeader::decode(bytes, magic)
.map_err(|fault| fault.into_db(rec.segment_id, None, path))?;
let mismatch = if header.segment_id != rec.segment_id {
Some(format!(
"file carries segment id {:#x}, the manifest records {:#x}",
header.segment_id, rec.segment_id
))
} else if header.version != rec.version {
Some(format!(
"file carries version {}, the manifest records {}",
header.version, rec.version
))
} else if header.order != rec.order {
Some("file entry order differs from the manifest".to_owned())
} else if header.key_len != key_len {
Some(format!(
"file has key length {}, the collection has {key_len}",
header.key_len
))
} else if header.seed != seed {
Some("file was written with another seed".to_owned())
} else {
None
};
match mismatch {
Some(reason) => Err(corrupt(rec, path, reason)),
None => Ok(header),
}
}
pub(crate) struct HotMeta {
pub(crate) index: SegmentIndex,
pub(crate) filter: PartitionedFilter,
pub(crate) prefix_filters: Vec<(u16, PartitionedFilter)>,
}
pub(crate) struct SegmentFiles {
pub(crate) record: SegRecord,
pub(crate) header: SegHeader,
pub(crate) props: Properties,
pub(crate) key_range: Option<KeyRange>,
pub(crate) prefix_lens: Vec<u16>,
pub(crate) cost: u64,
data: File,
pub(crate) sidx: OnceLock<File>,
sdat_path: PathBuf,
sidx_path: PathBuf,
seg_dir: PathBuf,
fs: Arc<dyn SegFs>,
pub(crate) shared: Arc<SegShared>,
pub(crate) skeleton: SkeletonCell,
doomed: AtomicBool,
block_reads: AtomicU64,
false_positives: AtomicU64,
}
pub(crate) struct Segment {
pub(crate) files: Arc<SegmentFiles>,
pub(crate) hot: Option<Arc<HotMeta>>,
}
pub(crate) struct CheckedSegment {
data: File,
sidx: File,
header: SegHeader,
records: Vec<SectionRecord>,
pages: Option<PageIndex>,
pub(crate) cost: u64,
}
fn read_section(
file: &File,
section: &SectionRecord,
shared: &SegShared,
rec: &SegRecord,
path: &Path,
) -> DbResult<Vec<u8>> {
let in_sidx = |fault: FormatFault| fault.into_db(rec.segment_id, None, path);
let len = usize::try_from(section.len)
.map_err(|_| in_sidx(FormatFault::corrupt("section length exceeds usize")))?;
let bytes = shared.io.read(file, section.offset, len, 0)?;
if crc32fast::hash(&bytes) != section.crc32 {
return Err(in_sidx(FormatFault::corrupt("section CRC mismatch")));
}
Ok(bytes)
}
fn count_build_failure<T>(
failures: &std::sync::atomic::AtomicU64,
build: impl FnOnce() -> DbResult<T>,
) -> DbResult<T> {
struct FailureGuard<'a> {
failures: &'a std::sync::atomic::AtomicU64,
succeeded: bool,
}
impl Drop for FailureGuard<'_> {
fn drop(&mut self) {
if !self.succeeded {
self.failures.fetch_add(1, Ordering::Relaxed);
}
}
}
let mut guard = FailureGuard {
failures,
succeeded: false,
};
let result = build();
guard.succeeded = result.is_ok();
result
}
impl Segment {
pub(crate) fn check_files(
seg_dir: &Path,
rec: &SegRecord,
key_len: u16,
seed: u64,
shared: &Arc<SegShared>,
) -> DbResult<CheckedSegment> {
let (data, sidx, records) = Self::checked_data_file(seg_dir, rec, key_len, seed, shared)?;
let path = seg_dir.join(sidx_name(rec.segment_id, rec.version));
let header = check_header(
rec,
&path,
&read_at(&sidx, 0, FILE_HEADER_LEN)?,
SIDX_MAGIC,
key_len,
seed,
)?;
let in_sidx = |fault: FormatFault| fault.into_db(rec.segment_id, None, &path);
check_section_table(&records, &header).map_err(in_sidx)?;
let pages = records
.iter()
.find(|r| r.kind == SECTION_PAGE_INDEX)
.map(|r| {
let body = read_section(&sidx, r, shared, rec, &path)?;
PageIndex::decode_known(&body, &records, &header).map_err(in_sidx)
})
.transpose()?
.flatten();
if pages
.as_ref()
.is_some_and(|p| p.index.end_offset != rec.sdat_len)
{
return Err(corrupt(
rec,
&path,
"page index end differs from data length".into(),
));
}
let cost = super::residency::cost(&records, header.order, pages.as_ref());
Ok(CheckedSegment {
data,
sidx,
header,
records,
pages,
cost,
})
}
fn checked_data_file(
seg_dir: &Path,
rec: &SegRecord,
key_len: u16,
seed: u64,
shared: &Arc<SegShared>,
) -> DbResult<(File, File, Vec<SectionRecord>)> {
let sdat_path = seg_dir.join(sdat_name(rec.segment_id, rec.version));
let sidx_path = seg_dir.join(sidx_name(rec.segment_id, rec.version));
let sdat = open_checked(rec, &sdat_path, rec.sdat_len)?;
if rec.sdat_len < FILE_HEADER_LEN as u64 {
return Err(corrupt(rec, &sdat_path, "file has no header".into()));
}
let head = read_at(&sdat, 0, FILE_HEADER_LEN)?;
let data_header = check_header(rec, &sdat_path, &head, SDAT_MAGIC, key_len, seed)?;
let sidx = open_checked(rec, &sidx_path, rec.sidx_len)?;
if rec.sidx_len < (FILE_HEADER_LEN + SIDX_FOOTER_LEN) as u64 {
return Err(corrupt(rec, &sidx_path, "file has no footer".into()));
}
let head = read_at(&sidx, 0, FILE_HEADER_LEN)?;
let sidecar_header = check_header(rec, &sidx_path, &head, SIDX_MAGIC, key_len, seed)?;
if data_header != sidecar_header {
return Err(corrupt(
rec,
&sidx_path,
"data and sidecar headers differ".into(),
));
}
let in_sidx = |fault: FormatFault| fault.into_db(rec.segment_id, None, &sidx_path);
let footer = shared.io.read(
&sidx,
rec.sidx_len - SIDX_FOOTER_LEN as u64,
SIDX_FOOTER_LEN,
0,
)?;
let (table_offset, count, table_crc) =
parse_footer(&footer, rec.sidx_len).map_err(in_sidx)?;
let table = shared
.io
.read(&sidx, table_offset, count as usize * SECTION_RECORD_LEN, 0)?;
let records = parse_table(&table, count, table_crc, table_offset).map_err(in_sidx)?;
Ok((sdat, sidx, records))
}
pub(crate) fn open(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
rec: &SegRecord,
key_len: u16,
seed: u64,
shared: &Arc<SegShared>,
) -> DbResult<Self> {
let checked = Self::check_files(seg_dir, rec, key_len, seed, shared)?;
Self::open_hot_checked(fs, seg_dir, rec, shared, checked)
}
pub(crate) fn open_hot_checked(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
rec: &SegRecord,
shared: &Arc<SegShared>,
checked: CheckedSegment,
) -> DbResult<Self> {
let CheckedSegment {
data,
sidx,
records,
cost,
..
} = checked;
let sdat_path = seg_dir.join(sdat_name(rec.segment_id, rec.version));
let sidx_path = seg_dir.join(sidx_name(rec.segment_id, rec.version));
let sidecar_len = usize::try_from(rec.sidx_len)
.map_err(|_| corrupt(rec, &sidx_path, "sidecar length exceeds usize".into()))?;
let bytes = shared.io.read(&sidx, 0, sidecar_len, 0)?;
let checksum = xxh3_64(&bytes);
if checksum != rec.sidx_checksum {
return Err(corrupt(
rec,
&sidx_path,
format!(
"checksum {checksum:#x} does not match the manifest's {:#x}",
rec.sidx_checksum
),
));
}
let sidecar = Sidecar::parse(&bytes)
.map_err(|fault| fault.into_db(rec.segment_id, None, &sidx_path))?;
let index = sidecar.index;
let end_offset = match &index {
SegmentIndex::Hash(i) => i.end_offset(),
SegmentIndex::Key(i) => i.end_offset(),
};
if end_offset != rec.sdat_len {
return Err(corrupt(
rec,
&sidx_path,
format!(
"block index ends at {}, the data file is {} bytes",
end_offset, rec.sdat_len
),
));
}
if sidecar.props.entries != rec.entries || sidecar.props.tombstones != rec.tombstones {
return Err(corrupt(
rec,
&sidx_path,
"entry counts differ from the manifest".into(),
));
}
let skeleton = Arc::new(match sidecar.page_index {
Some(pages) => pages,
None => PageIndex::derive(&bytes, &records, &sidecar.header)
.map_err(|fault| fault.into_db(rec.segment_id, None, &sidx_path))?,
});
let filter = PartitionedFilter::with_table(
skeleton.filter.table.clone(),
sidecar.filter.into_bytes(),
);
let prefix_filters = sidecar
.prefix_filters
.into_iter()
.map(|(n, filter)| {
let table = skeleton
.prefix_filters
.iter()
.find(|(len, _)| *len == n)
.expect("validated prefix filter")
.1
.table
.clone();
(n, PartitionedFilter::with_table(table, filter.into_bytes()))
})
.collect();
let files = Arc::new(SegmentFiles {
record: rec.clone(),
header: sidecar.header,
props: sidecar.props,
key_range: sidecar.key_range,
prefix_lens: skeleton.prefix_filters.iter().map(|(n, _)| *n).collect(),
cost,
skeleton: SkeletonCell::ready(skeleton),
data,
sidx: OnceLock::new(),
sdat_path,
sidx_path,
seg_dir: seg_dir.to_path_buf(),
fs,
shared: shared.clone(),
doomed: AtomicBool::new(false),
block_reads: AtomicU64::new(0),
false_positives: AtomicU64::new(0),
});
Ok(Self {
files,
hot: Some(Arc::new(HotMeta {
index,
filter,
prefix_filters,
})),
})
}
pub(crate) fn open_cold(
fs: Arc<dyn SegFs>,
seg_dir: &Path,
rec: &SegRecord,
shared: &Arc<SegShared>,
checked: CheckedSegment,
) -> DbResult<Self> {
let CheckedSegment {
data,
sidx,
header,
records,
pages,
cost,
} = checked;
let sdat_path = seg_dir.join(sdat_name(rec.segment_id, rec.version));
let sidx_path = seg_dir.join(sidx_name(rec.segment_id, rec.version));
let in_sidx = |fault: FormatFault| fault.into_db(rec.segment_id, None, &sidx_path);
let read = |kind| -> DbResult<Vec<u8>> {
let record = records
.iter()
.find(|r| r.kind == kind)
.ok_or_else(|| corrupt(rec, &sidx_path, "required section missing".into()))?;
read_section(&sidx, record, shared, rec, &sidx_path)
};
let props = Properties::decode(&read(SECTION_PROPERTIES)?).map_err(in_sidx)?;
if props.entries != rec.entries || props.tombstones != rec.tombstones {
return Err(corrupt(
rec,
&sidx_path,
"entry counts differ from the manifest".into(),
));
}
let key_range = if header.order == super::sidecar::OrderKind::ByKey {
Some(
KeyRange::decode(&read(SECTION_KEY_RANGE)?, header.key_len as usize)
.map_err(in_sidx)?,
)
} else {
None
};
let (skeleton, prefix_lens) = match pages {
Some(pages) => {
let lens = pages.prefix_filters.iter().map(|(n, _)| *n).collect();
(SkeletonCell::ready(Arc::new(pages)), lens)
}
None => {
let mut lens = Vec::new();
if header.order == super::sidecar::OrderKind::ByKey {
for r in records
.iter()
.filter(|r| r.kind == super::sidecar::SECTION_PREFIX_FILTER)
{
let wrapper = shared.io.read(&sidx, r.offset, 8, 0)?;
let len = u16::from_le_bytes([wrapper[0], wrapper[1]]);
if len == 0
|| len >= header.key_len
|| wrapper[2..].iter().any(|b| *b != 0)
|| lens.contains(&len)
{
return Err(corrupt(
rec,
&sidx_path,
"invalid or duplicate prefix length".into(),
));
}
lens.push(len);
}
}
(SkeletonCell::pending(), lens)
}
};
let sidecar = OnceLock::new();
sidecar.set(sidx).expect("new sidecar cell");
Ok(Self {
files: Arc::new(SegmentFiles {
record: rec.clone(),
header,
props,
key_range,
prefix_lens,
cost,
data,
sidx: sidecar,
sdat_path,
sidx_path,
seg_dir: seg_dir.to_path_buf(),
fs,
shared: shared.clone(),
skeleton,
doomed: AtomicBool::new(false),
block_reads: AtomicU64::new(0),
false_positives: AtomicU64::new(0),
}),
hot: None,
})
}
}
impl Segment {
pub(crate) fn lookup(&self, h: u64, key: &[u8], cache: &SegBlockCache) -> DbResult<Lookup> {
if key.len() != self.key_len() {
return Err(DbError::Internal(
"segment lookup: key length differs from the segment's",
));
}
if !self.may_contain(h, Some(cache))? {
return Ok(Lookup::Absent);
}
let mut group = None;
let block = match self.files.record.order {
super::sidecar::OrderKind::ByHash => self.locate_hash_in(h, &mut group, Some(cache))?,
super::sidecar::OrderKind::ByKey => {
if self
.files
.key_range
.as_ref()
.is_some_and(|r| key < r.min.as_slice() || key > r.max.as_slice())
{
None
} else {
Some(self.locate_key_in(key, &mut group, Some(cache))?)
}
}
};
let Some(block) = block else {
self.files.false_positives.fetch_add(1, Ordering::Relaxed);
return Ok(Lookup::Absent);
};
let payload = self.block_payload_in(block, &mut group, Some(cache))?;
let block_no = self.block_no(block)?;
let found = find_in_block(&payload, key).map_err(|fault| {
fault.into_db(
self.files.record.segment_id,
Some(block_no),
&self.files.sdat_path,
)
})?;
Ok(match found {
Some(Found::Live(value)) => Lookup::Live(value),
Some(Found::Tombstone) => Lookup::Tombstone,
None => {
self.files.false_positives.fetch_add(1, Ordering::Relaxed);
Lookup::Absent
}
})
}
#[cfg(test)]
pub(crate) fn block_payload(
&self,
block: usize,
cache: Option<&SegBlockCache>,
) -> DbResult<Arc<[u8]>> {
self.block_payload_in(block, &mut None, cache)
}
pub(crate) fn block_payload_in(
&self,
block: usize,
group: &mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<Arc<[u8]>> {
let block_no = self.block_no(block)?;
let key = SegBlockKey {
segment_id: self.files.record.segment_id,
version: self.files.record.version,
item: CacheItem::Block(block_no),
};
if let Some(cache) = cache
&& let Some(payload) = cache.get(&key)
{
return Ok(payload);
}
let in_block = |reason: String| DbError::SegmentCorrupt {
segment_id: self.files.record.segment_id,
block: Some(block_no),
path: self.files.sdat_path.clone(),
reason,
};
let (offset, len) = self.block_range_in(block, group, cache)?;
let bytes = match read_at(&self.files.data, offset, len) {
Ok(bytes) => bytes,
Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
return Err(in_block(format!(
"block of {len} bytes at {offset} runs past the end of the file"
)));
}
Err(e) => return Err(e.into()),
};
self.files.block_reads.fetch_add(1, Ordering::Relaxed);
let payload: Arc<[u8]> = match decode_block(&bytes) {
Ok(payload) => Arc::from(payload),
Err(FormatFault::Corrupt(reason)) => return Err(in_block(reason)),
Err(fault) => {
return Err(fault.into_db(
self.files.record.segment_id,
Some(block_no),
&self.files.sdat_path,
));
}
};
if let Some(cache) = cache {
cache.insert(key, payload.clone());
}
Ok(payload)
}
fn block_no(&self, block: usize) -> DbResult<u32> {
u32::try_from(block).map_err(|_| DbError::SegmentCorrupt {
segment_id: self.files.record.segment_id,
block: None,
path: self.files.sidx_path.clone(),
reason: format!("block number {block} exceeds u32"),
})
}
pub(crate) fn id(&self) -> u64 {
self.files.record.segment_id
}
pub(crate) fn record(&self) -> &SegRecord {
&self.files.record
}
pub(crate) fn props(&self) -> &Properties {
&self.files.props
}
pub(crate) fn key_range(&self) -> Option<&KeyRange> {
self.files.key_range.as_ref()
}
pub(crate) fn is_hot(&self) -> bool {
self.hot.is_some()
}
pub(crate) fn cooled(&self) -> Self {
Self {
files: self.files.clone(),
hot: None,
}
}
pub(crate) fn skeleton(&self) -> DbResult<Arc<PageIndex>> {
self.skeleton_with_origin(true)
}
pub(crate) fn skeleton_background(&self) -> DbResult<Arc<PageIndex>> {
self.skeleton_with_origin(false)
}
fn skeleton_with_origin(&self, foreground: bool) -> DbResult<Arc<PageIndex>> {
self.files.skeleton.get_or_build(
&self.files.shared.slots,
super::skeleton::now_ms(),
|| {
if foreground {
self.files
.shared
.foreground_builds
.fetch_add(1, Ordering::Relaxed);
}
let result = count_build_failure(&self.files.shared.build_failures, || {
self.build_skeleton()
});
#[cfg(test)]
if result.is_ok() {
crate::sync::lock(&self.files.shared.built).push(self.id());
}
result
},
)
}
fn build_skeleton(&self) -> DbResult<PageIndex> {
let rec = &self.files.record;
let len = usize::try_from(rec.sidx_len)
.map_err(|_| self.corrupt_sidx("sidecar length exceeds usize"))?;
let bytes = self.files.shared.io.read(self.sidx_file()?, 0, len, 0)?;
if xxh3_64(&bytes) != rec.sidx_checksum {
return Err(self.corrupt_sidx("sidecar checksum differs from manifest"));
}
let in_sidx = |fault: FormatFault| fault.into_db(self.id(), None, &self.files.sidx_path);
let parsed = Sidecar::parse(&bytes).map_err(in_sidx)?;
if parsed.header != self.files.header {
return Err(self.corrupt_sidx("sidecar header changed since open"));
}
let footer_at = bytes.len() - SIDX_FOOTER_LEN;
let (at, count, crc) = parse_footer(&bytes[footer_at..], rec.sidx_len).map_err(in_sidx)?;
let records =
parse_table(&bytes[at as usize..footer_at], count, crc, at).map_err(in_sidx)?;
let pages = PageIndex::derive(&bytes, &records, &self.files.header).map_err(in_sidx)?;
if pages.index.end_offset != rec.sdat_len {
return Err(self.corrupt_sidx("page index end differs from data length"));
}
if self.files.header.order == super::sidecar::OrderKind::ByKey
&& pages.prefix_filters.iter().map(|(n, _)| *n).ne(self
.files
.prefix_lens
.iter()
.copied())
{
return Err(self.corrupt_sidx("prefix identities changed since open"));
}
Ok(pages)
}
fn corrupt_sidx(&self, reason: impl Into<String>) -> DbError {
corrupt(&self.files.record, &self.files.sidx_path, reason.into())
}
fn sidx_file(&self) -> DbResult<&File> {
if let Some(file) = self.files.sidx.get() {
return Ok(file);
}
let file = open_checked(
&self.files.record,
&self.files.sidx_path,
self.files.record.sidx_len,
)?;
let bytes = read_at(&file, 0, FILE_HEADER_LEN)?;
let header = SegHeader::decode(&bytes, SIDX_MAGIC)
.map_err(|fault| fault.into_db(self.id(), None, &self.files.sidx_path))?;
if header != self.files.header {
return Err(self.corrupt_sidx("sidecar header changed since open"));
}
let _ = self.files.sidx.set(file);
Ok(self.files.sidx.get().expect("sidecar handle initialized"))
}
fn meta_key(&self, section: &PagedSection, chunk: usize) -> SegBlockKey {
SegBlockKey {
segment_id: self.id(),
version: self.files.record.version,
item: CacheItem::Meta {
kind: section.id.kind,
prefix_len: section.id.prefix_len,
chunk: chunk as u32,
},
}
}
fn read_section(
&self,
section: &PagedSection,
from: u64,
to: u64,
cache: Option<&SegBlockCache>,
) -> DbResult<Vec<u8>> {
if from > to || to > section.len {
return Err(self.corrupt_sidx("metadata range outside section"));
}
if from == to {
return Ok(Vec::new());
}
let chunks = section.chunks_covering(from, to);
let mut parts: Vec<Option<Arc<[u8]>>> = chunks
.clone()
.map(|c| cache.and_then(|cache| cache.get(&self.meta_key(section, c))))
.collect();
if let (Some(lo), Some(hi)) = (
parts.iter().position(Option::is_none),
parts.iter().rposition(Option::is_none),
) {
let (start, _) = section.chunk_range(chunks.start + lo);
let (_, end) = section.chunk_range(chunks.start + hi);
let bytes = self.files.shared.io.read(
self.sidx_file()?,
start,
(end - start) as usize,
hi - lo + 1,
)?;
for (c, part) in parts.iter_mut().enumerate().take(hi + 1).skip(lo) {
if part.is_some() {
continue;
}
let (s, e) = section.chunk_range(chunks.start + c);
let chunk = &bytes[(s - start) as usize..(e - start) as usize];
if crc32fast::hash(chunk) != section.crcs[chunks.start + c] {
return Err(self.corrupt_sidx(format!(
"metadata section {:#x} page {}: CRC mismatch",
section.id.kind,
chunks.start + c
)));
}
let chunk: Arc<[u8]> = Arc::from(chunk);
if let Some(cache) = cache {
cache.insert(self.meta_key(section, chunks.start + c), chunk.clone());
}
*part = Some(chunk);
}
}
let first = section.chunk_range(chunks.start).0 - section.offset;
let capacity = parts
.iter()
.map(|p| p.as_ref().expect("verified chunk").len())
.sum();
let mut joined = Vec::with_capacity(capacity);
for part in parts {
joined.extend_from_slice(&part.expect("verified chunk"));
}
Ok(joined[(from - first) as usize..(to - first) as usize].to_vec())
}
fn probe_cold(
&self,
f: &FilterSkeleton,
h: u64,
cache: Option<&SegBlockCache>,
) -> DbResult<bool> {
let Probe::At { fingerprint, at } = probe(&f.table, h) else {
return Ok(false);
};
let abs = at.map(|p| f.filter_at + p);
let lo = *abs.iter().min().expect("three positions");
let hi = *abs.iter().max().expect("three positions");
let bytes = if hi + 1 - lo <= PROBE_WINDOW {
let window = self.read_section(&f.section, lo, hi + 1, cache)?;
abs.map(|p| window[(p - lo) as usize])
} else {
let mut bytes = [0; 3];
for (i, p) in abs.iter().enumerate() {
bytes[i] = self.read_section(&f.section, *p, p + 1, cache)?[0];
}
bytes
};
Ok(probe_matches(fingerprint, bytes))
}
fn group(&self, g: usize, cache: Option<&SegBlockCache>) -> DbResult<Arc<IndexGroup>> {
let skeleton = self.skeleton()?;
let index = &skeleton.index;
let blocks = index.group_blocks(g);
let (s, e) = (blocks.start, blocks.end);
if s >= e {
return Err(self.corrupt_sidx("index group outside block index"));
}
let invalid = || self.corrupt_sidx(format!("invalid index group {g}"));
let (offsets, keys) = match &index.samples {
GroupSamples::Hash(samples) => {
let to = if e == index.blocks {
e * 24 + 8
} else {
(e + 1) * 24
};
let bytes = self.read_section(&index.section, (s * 24) as u64, to as u64, cache)?;
let at = (e - s) * 24;
let end = if e == index.blocks {
u64::from_le_bytes(bytes[at..at + 8].try_into().expect("end"))
} else {
let next_h =
u64::from_le_bytes(bytes[at..at + 8].try_into().expect("next hash"));
if next_h != samples[g + 1] {
return Err(invalid());
}
u64::from_le_bytes(bytes[at + 8..at + 16].try_into().expect("next offset"))
};
let records = super::sidecar::parse_index_run(&bytes[..at], s, end)
.map_err(|fault| fault.into_db(self.id(), None, &self.files.sidx_path))?;
let hashes: Vec<_> = records.iter().map(|r| r.first_h).collect();
if hashes[0] != samples[g]
|| end > index.end_offset
|| (e == index.blocks && end != index.end_offset)
|| samples
.get(g + 1)
.is_some_and(|&next| *hashes.last().expect("nonempty") >= next)
{
return Err(invalid());
}
let mut offsets: Vec<_> = records.iter().map(|r| r.offset).collect();
offsets.push(end);
(offsets, GroupKeys::Hash(hashes))
}
GroupSamples::Key { starts, separators } => {
let counts_at = 8 + (index.blocks + 1) * 8;
let separators_at = counts_at + index.blocks * 4;
let bytes_at = separators_at + (index.blocks + 1) * 4;
let next = starts
.get(g + 1)
.map_or(index.section.len - bytes_at as u64, |&v| u64::from(v));
let offset_bytes = self.read_section(
&index.section,
(8 + s * 8) as u64,
(8 + (e + 1) * 8) as u64,
cache,
)?;
let sep_bytes = self.read_section(
&index.section,
(separators_at + s * 4) as u64,
(separators_at + (e + 1) * 4) as u64,
cache,
)?;
let bytes = self.read_section(
&index.section,
bytes_at as u64 + u64::from(starts[g]),
bytes_at as u64 + next,
cache,
)?;
let offsets: Vec<_> = offset_bytes
.as_chunks::<8>()
.0
.iter()
.map(|b| u64::from_le_bytes(*b))
.collect();
let raw: Vec<_> = sep_bytes
.as_chunks::<4>()
.0
.iter()
.map(|b| u32::from_le_bytes(*b))
.collect();
if offsets[0] < FILE_HEADER_LEN as u64
|| (s == 0 && offsets[0] != FILE_HEADER_LEN as u64)
|| offsets.windows(2).any(|w| {
w[1] <= w[0]
|| w[1] - w[0] <= super::block::BLOCK_HEADER_LEN as u64
|| u32::try_from(w[1] - w[0]).is_err()
})
|| *offsets.last().expect("closing offset") > index.end_offset
|| (e == index.blocks
&& *offsets.last().expect("closing offset") != index.end_offset)
|| raw[0] != starts[g]
|| u64::from(*raw.last().expect("closing separator")) != next
{
return Err(invalid());
}
let mut previous: Option<&[u8]> = None;
for i in 0..e - s {
let lo = raw[i].checked_sub(starts[g]).ok_or_else(invalid)? as usize;
let hi = raw[i + 1].checked_sub(starts[g]).ok_or_else(invalid)? as usize;
let separator = bytes.get(lo..hi).ok_or_else(invalid)?;
if separator.len() > self.key_len()
|| (s == 0 && i == 0 && !separator.is_empty())
|| (i == 0 && separator != separators[g])
|| previous.is_some_and(|p| p >= separator)
|| separators
.get(g + 1)
.is_some_and(|next| separator >= next.as_slice())
{
return Err(invalid());
}
previous = Some(separator);
}
(
offsets,
GroupKeys::Key {
sep_offsets: raw.into_iter().map(|x| x - starts[g]).collect(),
bytes,
},
)
}
};
Ok(Arc::new(IndexGroup {
group: g,
first_block: s,
offsets,
keys,
}))
}
fn group_in<'a>(
&self,
g: usize,
slot: &'a mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<&'a IndexGroup> {
if slot.as_ref().is_none_or(|group| group.group != g) {
*slot = Some(self.group(g, cache)?);
}
Ok(slot.as_deref().expect("loaded index group"))
}
#[cfg(test)]
pub(crate) fn hot(&self) -> Arc<HotMeta> {
if let Some(hot) = &self.hot {
return hot.clone();
}
let bytes = std::fs::read(self.sidx_path()).expect("fixture sidecar");
assert_eq!(xxh3_64(&bytes), self.record().sidx_checksum);
let original = Sidecar::parse(&bytes).expect("verified fixture metadata");
Arc::new(HotMeta {
index: original.index,
filter: original.filter,
prefix_filters: original.prefix_filters,
})
}
pub(crate) fn prefix_filter_lens(&self) -> &[u16] {
&self.files.prefix_lens
}
pub(crate) fn block_count(&self) -> DbResult<usize> {
Ok(match self.hot.as_deref() {
Some(hot) => match &hot.index {
SegmentIndex::Hash(i) => i.len(),
SegmentIndex::Key(i) => i.len(),
},
None => self.skeleton()?.index.blocks,
})
}
pub(crate) fn block_range_in(
&self,
block: usize,
group: &mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<(u64, usize)> {
if block >= self.block_count()? {
return Err(self.corrupt_sidx("block outside index"));
}
if let Some(hot) = &self.hot {
return Ok(match &hot.index {
SegmentIndex::Hash(i) => i.range(block),
SegmentIndex::Key(i) => i.range(block),
});
}
let g = self.skeleton()?.index.group_of_block(block);
Ok(self.group_in(g, group, cache)?.range(block))
}
pub(crate) fn first_h_in(
&self,
block: usize,
group: &mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<u64> {
if self.files.record.order != super::sidecar::OrderKind::ByHash {
return Err(DbError::Internal("hash index requested for key segment"));
}
if block >= self.block_count()? {
return Err(self.corrupt_sidx("block outside index"));
}
if self.hot.is_none() {
let g = self.skeleton()?.index.group_of_block(block);
return Ok(self.group_in(g, group, cache)?.first_h(block));
}
match &self.hot.as_ref().expect("hot").index {
SegmentIndex::Hash(i) => Ok(i.first_h(block)),
SegmentIndex::Key(_) => Err(DbError::Internal("hash index requested for key segment")),
}
}
pub(crate) fn locate_hash_in(
&self,
h: u64,
group: &mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<Option<usize>> {
if self.files.record.order != super::sidecar::OrderKind::ByHash {
return Err(DbError::Internal("hash index requested for key segment"));
}
if self.hot.is_none() {
let Some(g) = self.skeleton()?.index.group_of_hash(h) else {
return Ok(None);
};
return Ok(self.group_in(g, group, cache)?.locate_hash(h));
}
match &self.hot.as_ref().expect("hot").index {
SegmentIndex::Hash(i) => Ok(i.locate(h)),
SegmentIndex::Key(_) => Err(DbError::Internal("hash index requested for key segment")),
}
}
pub(crate) fn locate_key_in(
&self,
key: &[u8],
group: &mut Option<Arc<IndexGroup>>,
cache: Option<&SegBlockCache>,
) -> DbResult<usize> {
if self.files.record.order != super::sidecar::OrderKind::ByKey {
return Err(DbError::Internal("key index requested for hash segment"));
}
if self.hot.is_none() {
let g = self.skeleton()?.index.group_of_key(key);
return Ok(self.group_in(g, group, cache)?.locate_key(key));
}
match &self.hot.as_ref().expect("hot").index {
SegmentIndex::Key(i) => Ok(i.locate(key)),
SegmentIndex::Hash(_) => Err(DbError::Internal("key index requested for hash segment")),
}
}
pub(crate) fn may_contain(&self, h: u64, cache: Option<&SegBlockCache>) -> DbResult<bool> {
if let Some(hot) = &self.hot {
return Ok(hot.filter.may_contain(h));
}
self.probe_cold(&self.skeleton()?.filter, h, cache)
}
pub(crate) fn prefix_may_contain(
&self,
prefix: &[u8],
cache: Option<&SegBlockCache>,
) -> DbResult<bool> {
let h = key_hash(prefix, self.seed());
if let Some(hot) = &self.hot {
return Ok(hot
.prefix_filters
.iter()
.find(|(n, _)| usize::from(*n) == prefix.len())
.is_none_or(|(_, f)| f.may_contain(h)));
}
let skeleton = self.skeleton()?;
match skeleton
.prefix_filters
.iter()
.find(|(n, _)| usize::from(*n) == prefix.len())
{
Some((_, f)) => self.probe_cold(f, h, cache),
None => Ok(true),
}
}
pub(crate) fn key_len(&self) -> usize {
self.files.header.key_len as usize
}
pub(crate) fn seed(&self) -> u64 {
self.files.header.seed
}
pub(crate) fn sdat_path(&self) -> &Path {
&self.files.sdat_path
}
pub(crate) fn read_original_sidecar(&self) -> DbResult<Vec<u8>> {
let file = File::open(self.sidx_path())?;
let len = usize::try_from(file.metadata()?.len())
.map_err(|_| DbError::Internal("sidecar length exceeds usize"))?;
self.files.shared.io.read(&file, 0, len, 0)
}
pub(crate) fn sidx_path(&self) -> &Path {
&self.files.sidx_path
}
pub(crate) fn data_file(&self) -> &File {
&self.files.data
}
pub(crate) fn hot_bytes(&self) -> usize {
self.hot.as_ref().map_or(0, |h| {
h.filter.resident_bytes()
+ match &h.index {
SegmentIndex::Hash(i) => i.resident_bytes(),
SegmentIndex::Key(i) => i.resident_bytes(),
}
+ h.prefix_filters.capacity() * std::mem::size_of::<(u16, PartitionedFilter)>()
+ h.prefix_filters
.iter()
.map(|(_, f)| f.resident_bytes())
.sum::<usize>()
})
}
pub(crate) fn skeleton_bytes(&self) -> usize {
self.files.skeleton.get().map_or(0, |s| s.resident_bytes())
+ self
.files
.key_range
.as_ref()
.map_or(0, |r| r.min.capacity() + r.max.capacity())
+ self.files.prefix_lens.capacity() * std::mem::size_of::<u16>()
}
pub(crate) fn resident_bytes(&self) -> usize {
self.hot_bytes() + self.skeleton_bytes()
}
pub(crate) fn cost(&self) -> u64 {
self.files.cost
}
#[cfg(test)]
pub(crate) fn shared_io_requests(&self) -> u64 {
self.files.shared.io.requests()
}
pub(crate) fn block_reads(&self) -> u64 {
self.files.block_reads.load(Ordering::Relaxed)
}
pub(crate) fn false_positives(&self) -> u64 {
self.files.false_positives.load(Ordering::Relaxed)
}
pub(crate) fn mark_doomed(&self) {
self.files.doomed.store(true, Ordering::Release);
}
}
impl Drop for SegmentFiles {
fn drop(&mut self) {
if !self.doomed.load(Ordering::Acquire) {
return;
}
for path in [&self.sdat_path, &self.sidx_path] {
if let Err(e) = self.fs.remove_file(path) {
tracing::warn!(error = %e, path = %path.display(), "could not remove a dropped segment file");
}
}
if let Err(e) = self.fs.sync_dir(&self.seg_dir) {
tracing::warn!(error = %e, "could not sync the segment directory after a drop");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::DbError;
use crate::seg::fs::real;
use crate::seg::seal::{SegmentWriter, sdat_name, sidx_name};
use crate::seg::testkit::{self, KEY_LEN, SEED, TestEntry};
struct Fixture {
dir: tempfile::TempDir,
entries: Vec<TestEntry>,
rec: SegRecord,
}
fn fixture(n: u64) -> Fixture {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(n, 1);
let rec = testkit::write_segment(real(), dir.path(), 1, &entries);
Fixture { dir, entries, rec }
}
fn open(f: &Fixture) -> DbResult<Segment> {
Segment::open(
real(),
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
}
fn cold() -> SegBlockCache {
SegBlockCache::new(0)
}
fn open_cold_fixture(f: &Fixture) -> DbResult<Segment> {
let shared = Arc::new(SegShared::new());
let checked = Segment::check_files(f.dir.path(), &f.rec, KEY_LEN as u16, SEED, &shared)?;
Segment::open_cold(real(), f.dir.path(), &f.rec, &shared, checked)
}
#[test]
fn skeleton_build_failures_count_errors_and_panics_once_per_attempt() {
use super::super::skeleton::{BuildSlots, SkeletonCell};
let failures = std::sync::atomic::AtomicU64::new(0);
let slots = BuildSlots::new(2);
let error_cell = SkeletonCell::pending();
assert!(
error_cell
.get_or_build(&slots, 0, || count_build_failure(&failures, || Err(
DbError::Internal("failed")
)))
.is_err()
);
assert_eq!(failures.load(Ordering::Relaxed), 1);
assert!(
error_cell
.get_or_build(&slots, 0, || panic!("backoff reader rebuilt"))
.is_err()
);
assert_eq!(failures.load(Ordering::Relaxed), 1);
let panic_cell = SkeletonCell::pending();
assert!(
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = panic_cell.get_or_build(&slots, 0, || {
count_build_failure(&failures, || panic!("builder panicked"))
});
}))
.is_err()
);
assert_eq!(failures.load(Ordering::Relaxed), 2);
assert!(
panic_cell
.get_or_build(&slots, 0, || panic!("backoff reader rebuilt"))
.is_err()
);
assert_eq!(failures.load(Ordering::Relaxed), 2);
assert!(count_build_failure(&failures, || Ok(())).is_ok());
assert_eq!(failures.load(Ordering::Relaxed), 2);
}
#[test]
fn section_io_errors_remain_io_errors() {
let f = fixture(20);
let checked = Segment::check_files(
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let record = checked
.records
.iter()
.find(|r| r.kind == SECTION_PROPERTIES)
.unwrap();
let empty = tempfile::tempfile().unwrap();
let error =
read_section(&empty, record, &SegShared::new(), &f.rec, f.dir.path()).unwrap_err();
assert!(matches!(error, DbError::Io(_)), "{error:?}");
}
#[test]
fn cold_open_counts_only_structural_metadata() {
for by_key in [false, true] {
let mut f = fixture(5000);
if by_key {
f.rec = testkit::write_key_segment(f.dir.path(), &testkit::ordered_entries(5000));
}
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(f.dir.path(), &f.rec, KEY_LEN as u16, SEED, &shared).unwrap();
let records = checked.records.clone();
let table_len = records.len() * SECTION_RECORD_LEN;
let mut expected = vec![
(f.rec.sidx_len - SIDX_FOOTER_LEN as u64, SIDX_FOOTER_LEN),
(
f.rec.sidx_len - SIDX_FOOTER_LEN as u64 - table_len as u64,
table_len,
),
];
for kind in [SECTION_PAGE_INDEX, SECTION_PROPERTIES, SECTION_KEY_RANGE] {
if let Some(r) = records.iter().find(|r| r.kind == kind) {
expected.push((r.offset, r.len as usize));
}
}
let _cold = Segment::open_cold(real(), f.dir.path(), &f.rec, &shared, checked).unwrap();
assert_eq!(shared.io.requests(), expected.len() as u64);
assert_eq!(
shared.io.bytes(),
expected.iter().map(|(_, len)| *len as u64).sum::<u64>()
);
assert_eq!(shared.io.ranges(), expected);
for pageable in records.iter().filter(|r| {
matches!(
r.kind,
super::super::sidecar::SECTION_FILTER
| super::super::sidecar::SECTION_BLOCK_INDEX
| super::super::sidecar::SECTION_SEPARATOR_INDEX
| super::super::sidecar::SECTION_PREFIX_FILTER
)
}) {
assert!(
shared
.io
.ranges()
.iter()
.all(|(offset, len)| *offset + *len as u64 <= pageable.offset
|| *offset >= pageable.offset + pageable.len)
);
}
}
}
#[test]
fn full_sidecar_open_reads_use_shared_metadata_io() {
for legacy in [false, true] {
let mut f = fixture(500);
if legacy {
f.rec = testkit::rewrite_sections(f.dir.path(), &f.rec, |sections| {
sections.retain(|(kind, _)| *kind != SECTION_PAGE_INDEX);
});
}
for hot in [false, true] {
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(f.dir.path(), &f.rec, KEY_LEN as u16, SEED, &shared)
.unwrap();
let before = shared.io.requests();
let bytes_before = shared.io.bytes();
let props_len = checked
.records
.iter()
.find(|r| r.kind == SECTION_PROPERTIES)
.unwrap()
.len;
let segment = if hot {
Segment::open_hot_checked(real(), f.dir.path(), &f.rec, &shared, checked)
.unwrap()
} else {
Segment::open_cold(real(), f.dir.path(), &f.rec, &shared, checked).unwrap()
};
let full_read = hot;
assert_eq!(shared.io.requests() - before, 1);
assert_eq!(
shared.io.bytes() - bytes_before,
if hot { f.rec.sidx_len } else { props_len }
);
assert_eq!(
shared.io.ranges().contains(&(0, f.rec.sidx_len as usize)),
full_read
);
if legacy && !hot {
assert!(segment.files.skeleton.get().is_none());
let before = shared.io.requests();
segment.skeleton().unwrap();
assert_eq!(shared.io.requests() - before, 1);
assert!(shared.io.ranges().contains(&(0, f.rec.sidx_len as usize)));
}
}
}
}
#[test]
fn legacy_prefix_open_reads_only_wrappers_before_verified_build() {
use crate::seg::sidecar::SECTION_PREFIX_FILTER;
let dir = tempfile::tempdir().unwrap();
let entries = testkit::ordered_entries(500);
let rec = testkit::write_legacy_key_segment(dir.path(), &entries);
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
let wrappers: Vec<_> = checked
.records
.iter()
.filter(|r| r.kind == SECTION_PREFIX_FILTER)
.map(|r| (r.offset, 8))
.collect();
let before = shared.io.requests();
let segment = Segment::open_cold(real(), dir.path(), &rec, &shared, checked).unwrap();
assert_eq!(
shared.io.requests() - before,
4,
"properties, range, two wrappers"
);
assert!(segment.files.skeleton.get().is_none());
assert_eq!(segment.prefix_filter_lens(), &[4, 8]);
for range in wrappers {
assert!(shared.io.ranges().contains(&range));
}
assert!(!shared.io.ranges().contains(&(0, rec.sidx_len as usize)));
let before = shared.io.requests();
segment.skeleton().unwrap();
assert_eq!(shared.io.requests() - before, 1);
assert_eq!(shared.foreground_builds.load(Ordering::Relaxed), 1);
assert_eq!(
segment
.lookup(entries[20].h, &entries[20].key, &cold())
.unwrap(),
Lookup::Live(entries[20].value.clone().unwrap())
);
}
#[test]
fn legacy_build_checks_original_checksum_and_data_end_offset() {
use crate::seg::sidecar::SECTION_BLOCK_INDEX;
for semantic in [false, true] {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(500, 1);
let mut rec = testkit::write_legacy_segment(real(), dir.path(), 1, &entries);
if semantic {
rec = testkit::rewrite_section(dir.path(), &rec, SECTION_BLOCK_INDEX, |body| {
let end = body.len() - 8;
body[end..].copy_from_slice(&(rec.sdat_len + 1).to_le_bytes());
});
}
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
let segment = Segment::open_cold(real(), dir.path(), &rec, &shared, checked).unwrap();
if !semantic {
let path = dir.path().join(sidx_name(1, 1));
let mut bytes = std::fs::read(&path).unwrap();
bytes[FILE_HEADER_LEN] ^= 1;
std::fs::write(path, bytes).unwrap();
}
for _ in 0..2 {
assert!(
matches!(segment.skeleton(), Err(DbError::SegmentCorrupt { reason, .. })
if reason.contains(if semantic { "end" } else { "checksum" }))
);
}
assert_eq!(shared.foreground_builds.load(Ordering::Relaxed), 1);
assert_eq!(shared.build_failures.load(Ordering::Relaxed), 1);
}
}
#[test]
fn legacy_prefix_hints_must_match_the_verified_original_identities() {
use crate::seg::sidecar::SECTION_PREFIX_FILTER;
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_legacy_key_segment(dir.path(), &testkit::ordered_entries(500));
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
let prefix_at = checked
.records
.iter()
.find(|r| r.kind == SECTION_PREFIX_FILTER)
.unwrap()
.offset;
let path = dir.path().join(sidx_name(rec.segment_id, rec.version));
let original = std::fs::read(&path).unwrap();
let mut altered = original.clone();
altered[prefix_at as usize..prefix_at as usize + 2].copy_from_slice(&5u16.to_le_bytes());
std::fs::write(&path, altered).unwrap();
let segment = Segment::open_cold(real(), dir.path(), &rec, &shared, checked).unwrap();
assert_eq!(segment.prefix_filter_lens(), &[5, 8]);
std::fs::write(&path, original).unwrap();
assert!(matches!(segment.prefix_may_contain(&[0; 5], None),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("prefix identities")));
}
#[test]
fn cold_open_section_failpoints_preserve_io_errors() {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_key_segment(dir.path(), &testkit::ordered_entries(5000));
for legacy in [false, true] {
let rec = if legacy {
testkit::rewrite_sections(dir.path(), &rec, |sections| {
sections.retain(|(kind, _)| *kind != SECTION_PAGE_INDEX)
})
} else {
rec.clone()
};
for at in 1..=if legacy { 6 } else { 5 } {
let shared = Arc::new(SegShared::new());
shared.io.fail_read_at(at);
let result = Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared)
.and_then(|checked| {
Segment::open_cold(real(), dir.path(), &rec, &shared, checked)
});
assert!(
matches!(result, Err(DbError::Io(_))),
"read {at}: {:?}",
result.err()
);
assert_eq!(shared.io.requests(), at - 1);
}
}
}
#[test]
fn cold_open_does_not_read_pageable_bodies_and_defers_crc_errors() {
use crate::seg::sidecar::{SECTION_BLOCK_INDEX, SECTION_FILTER};
for kind in [SECTION_FILTER, SECTION_BLOCK_INDEX] {
let f = fixture(5000);
let path = f.dir.path().join(sidx_name(1, 1));
let checked = Segment::check_files(
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let record = checked.records.iter().find(|r| r.kind == kind).unwrap();
let mut bytes = std::fs::read(&path).unwrap();
let range = record.offset as usize..(record.offset + record.len) as usize;
for byte in &mut bytes[range] {
*byte ^= 0xff;
}
std::fs::write(&path, bytes).unwrap();
let shared = Arc::new(SegShared::new());
let before_open = shared.io.requests();
let checked =
Segment::check_files(f.dir.path(), &f.rec, KEY_LEN as u16, SEED, &shared).unwrap();
let cold = Segment::open_cold(real(), f.dir.path(), &f.rec, &shared, checked).unwrap();
assert!(!cold.is_hot());
assert!(cold.files.sidx.get().is_some());
assert_eq!(
cold.shared_io_requests() - before_open,
4,
"counted structural open reads"
);
assert!(matches!(open(&f), Err(DbError::SegmentCorrupt { .. })));
let e = &f.entries[100];
assert!(matches!(
cold.lookup(e.h, &e.key, &self::cold()),
Err(DbError::SegmentCorrupt { .. })
));
}
}
#[test]
fn cold_phase_two_retains_the_checked_files_after_path_replacement() {
for legacy in [false, true] {
let mut f = fixture(500);
if legacy {
f.rec = testkit::rewrite_sections(f.dir.path(), &f.rec, |sections| {
sections.retain(|(kind, _)| *kind != SECTION_PAGE_INDEX);
});
}
let checked = Segment::check_files(
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
for name in [sdat_name(1, 1), sidx_name(1, 1)] {
let path = f.dir.path().join(name);
std::fs::remove_file(&path).unwrap();
std::fs::write(path, b"replacement").unwrap();
}
let seg = Segment::open_cold(
real(),
f.dir.path(),
&f.rec,
&Arc::new(SegShared::new()),
checked,
)
.unwrap();
if legacy {
assert!(seg.files.skeleton.get().is_none());
}
let e = &f.entries[100];
assert_eq!(
seg.lookup(e.h, &e.key, &cold()).unwrap(),
e.value
.as_ref()
.map_or(Lookup::Tombstone, |v| Lookup::Live(v.clone()))
);
}
}
#[test]
fn a_hash_ordered_prefix_section_is_skipped_hot_cold_and_legacy() {
for legacy in [false, true] {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(500, 1);
let rec = if legacy {
testkit::write_legacy_segment(real(), dir.path(), 1, &entries)
} else {
testkit::write_segment(real(), dir.path(), 1, &entries)
};
let plain_cost = {
let shared = Arc::new(SegShared::new());
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared)
.unwrap()
.cost
};
let rec = testkit::rewrite_sections(dir.path(), &rec, |sections| {
sections.push((crate::seg::sidecar::SECTION_PREFIX_FILTER, vec![0; 3]));
});
let f = Fixture { dir, entries, rec };
let hot = open(&f).unwrap();
let cold_segment = open_cold_fixture(&f).unwrap();
assert_eq!(hot.cost(), plain_cost, "a skipped section costs nothing");
assert_eq!(cold_segment.cost(), plain_cost, "legacy {legacy}");
for e in &f.entries {
let expected = e.value.clone().map_or(Lookup::Tombstone, Lookup::Live);
assert_eq!(hot.lookup(e.h, &e.key, &cold()).unwrap(), expected);
assert_eq!(
cold_segment.lookup(e.h, &e.key, &cold()).unwrap(),
expected,
"legacy {legacy}"
);
}
let missing = testkit::key_of(1_000_000);
let h = crate::seg::hash::key_hash(&missing, SEED);
assert_eq!(
cold_segment.lookup(h, &missing, &cold()).unwrap(),
Lookup::Absent
);
}
}
#[test]
fn cold_open_trusts_page_index_filter_identities_and_verify_reports_a_forgery() {
for forge_prefix in [false, true] {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_key_segment(dir.path(), &testkit::key_entries());
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
let mut pages = checked.pages.clone().unwrap();
if forge_prefix {
let (len, filter) = &mut pages.prefix_filters[0];
assert_eq!(*len, 4);
*len = 6;
filter.section.id.prefix_len = 6;
} else {
let table = &pages.filter.table;
let mut parts = table.parts.clone();
let part = parts.iter_mut().find(|p| p.keys > 0).unwrap();
part.params.seed ^= 1;
pages.filter.table = Arc::new(crate::seg::filter::FilterTable {
bits: table.bits,
parts,
});
}
let rec = testkit::rewrite_section(
dir.path(),
&rec,
crate::seg::sidecar::SECTION_PAGE_INDEX,
|body| *body = pages.encode(),
);
let shared = Arc::new(SegShared::new());
assert!(
Segment::open(real(), dir.path(), &rec, KEY_LEN as u16, SEED, &shared).is_err(),
"the hot parser refuses the disagreement"
);
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
let segment = Segment::open_cold(real(), dir.path(), &rec, &shared, checked)
.expect("a cold open trusts the identities");
let mut report = crate::seg::verify::VerifyReport::default();
crate::seg::verify::verify_segment(&segment, &mut report).unwrap();
assert!(
report
.problems
.iter()
.any(|p| p.what.contains("page index")),
"forge_prefix {forge_prefix}: {:?}",
report.problems
);
}
}
#[test]
fn cold_open_checks_small_sections_and_page_index_crc() {
for kind in [SECTION_PROPERTIES, SECTION_PAGE_INDEX] {
let f = fixture(500);
let checked = Segment::check_files(
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let record = checked.records.iter().find(|r| r.kind == kind).unwrap();
let path = f.dir.path().join(sidx_name(1, 1));
let mut bytes = std::fs::read(&path).unwrap();
bytes[record.offset as usize] ^= 1;
std::fs::write(path, bytes).unwrap();
assert!(matches!(
open_cold_fixture(&f),
Err(DbError::SegmentCorrupt { .. })
));
}
}
#[test]
fn cold_open_rejects_manifest_count_and_end_offset_mismatches() {
let mut f = fixture(500);
f.rec.entries += 1;
assert!(
matches!(open_cold_fixture(&f), Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("counts"))
);
f.rec.entries -= 1;
let path = f.dir.path().join(sdat_name(1, 1));
std::fs::OpenOptions::new()
.write(true)
.open(path)
.unwrap()
.set_len(f.rec.sdat_len + 1)
.unwrap();
f.rec.sdat_len += 1;
assert!(
matches!(open_cold_fixture(&f), Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("end"))
);
}
#[test]
fn cold_open_rejects_duplicate_missing_and_unknown_required_sections() {
use crate::seg::sidecar::SECTION_FILTER;
for mode in 0..3 {
let mut f = fixture(500);
f.rec = testkit::rewrite_sections(f.dir.path(), &f.rec, |sections| match mode {
0 => sections.push(
sections
.iter()
.find(|(kind, _)| *kind == SECTION_PROPERTIES)
.unwrap()
.clone(),
),
1 => sections.retain(|(kind, _)| *kind != SECTION_FILTER),
_ => sections.push((99, vec![0])),
});
assert!(open_cold_fixture(&f).is_err());
}
}
#[test]
fn legacy_by_key_cost_stays_conservative_after_skeleton_derivation() {
let dir = tempfile::tempdir().unwrap();
let mut entries = testkit::entries(500, 1);
entries.sort_by_key(|e| e.key);
let rec = testkit::write_legacy_key_segment(dir.path(), &entries);
let shared = Arc::new(SegShared::new());
let checked =
Segment::check_files(dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
assert!(checked.pages.is_none());
let cost = checked.cost;
let cold = Segment::open_cold(real(), dir.path(), &rec, &shared, checked).unwrap();
let hot = Segment::open(real(), dir.path(), &rec, KEY_LEN as u16, SEED, &shared).unwrap();
assert!(cold.files.skeleton.get().is_none());
cold.skeleton().unwrap();
assert_eq!(cold.cost(), cost);
assert_eq!(hot.cost(), cost);
assert!(cost >= hot.hot_bytes() as u64);
assert_eq!(hot.cooled().cost(), cost);
}
#[test]
fn shared_files_are_deleted_once_after_the_last_wrapper() {
use crate::seg::fs::{FsOpKind, TraceFs};
let f = fixture(500);
let fs = TraceFs::new();
let shared = Arc::new(SegShared::new());
let hot = Segment::open(
fs.clone(),
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&shared,
)
.unwrap();
let cold = hot.cooled();
assert!(!cold.is_hot());
assert_eq!(cold.hot_bytes(), 0);
assert_eq!(cold.block_count().unwrap(), hot.block_count().unwrap());
assert!(Arc::ptr_eq(&hot.files, &cold.files));
let another = cold.cooled();
hot.mark_doomed();
drop(hot);
for name in [sdat_name(1, 1), sidx_name(1, 1)] {
assert!(f.dir.path().join(name).exists());
}
drop(cold);
assert!(fs.ops().is_empty());
drop(another);
for name in [sdat_name(1, 1), sidx_name(1, 1)] {
assert!(!f.dir.path().join(&name).exists());
assert_eq!(
fs.ops()
.iter()
.filter(|op| op.kind() == FsOpKind::RemoveFile && op.target().ends_with(&name))
.count(),
1
);
}
}
#[test]
fn cold_sidecar_handle_is_lazy_checked_and_retained() {
let f = fixture(5_000);
let hot = open(&f).unwrap();
let seg = hot.cooled();
assert!(seg.files.sidx.get().is_none());
let e = &f.entries[100];
seg.lookup(e.h, &e.key, &cold()).unwrap();
assert!(seg.files.sidx.get().is_some());
std::fs::remove_file(seg.sidx_path()).unwrap();
drop(hot);
assert_eq!(
seg.lookup(e.h, &e.key, &cold()).unwrap(),
e.value
.as_ref()
.map_or(Lookup::Tombstone, |v| Lookup::Live(v.clone()))
);
let f = fixture(5_000);
let seg = open(&f).unwrap().cooled();
let mut bytes = std::fs::read(seg.sidx_path()).unwrap();
let mut header = seg.files.header;
header.seed += 1;
bytes[..FILE_HEADER_LEN].copy_from_slice(&header.encode(SIDX_MAGIC));
std::fs::write(seg.sidx_path(), bytes).unwrap();
let e = &f.entries[100];
let before_header_check = seg.shared_io_requests();
assert!(matches!(
seg.lookup(e.h, &e.key, &cold()),
Err(DbError::SegmentCorrupt { block: None, .. })
));
assert_eq!(
seg.shared_io_requests() - before_header_check,
0,
"header validation is not metadata I/O"
);
assert!(
seg.files.sidx.get().is_none(),
"a failed header is not retained"
);
}
#[test]
fn cold_metadata_read_errors_propagate_and_can_be_retried() {
let f = fixture(5_000);
let seg = open(&f).unwrap().cooled();
let e = &f.entries[100];
seg.files.shared.io.fail_read_at(1);
let failed = seg.lookup(e.h, &e.key, &cold());
assert!(matches!(failed, Err(DbError::Io(_))), "{failed:?}");
assert_eq!(
seg.lookup(e.h, &e.key, &cold()).unwrap(),
e.value
.as_ref()
.map_or(Lookup::Tombstone, |v| Lookup::Live(v.clone()))
);
}
#[test]
fn single_block_cold_groups_support_empty_key_separator() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::ordered_entries(1);
let key_rec = testkit::write_key_segment(dir.path(), &entries);
let hash_rec = testkit::write_segment(real(), dir.path(), 1, &entries);
for rec in [&key_rec, &hash_rec] {
let hot = Segment::open(
real(),
dir.path(),
rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let seg = hot.cooled();
assert_eq!(seg.block_count().unwrap(), 1);
let before_group = seg.shared_io_requests();
let mut group = None;
assert_eq!(
seg.block_range_in(0, &mut group, None).unwrap(),
hot.block_range_in(0, &mut None, None).unwrap()
);
let reads = seg.shared_io_requests() - before_group;
assert_eq!(
reads,
if rec.order == super::super::sidecar::OrderKind::ByKey {
2
} else {
1
}
);
assert!(group.as_ref().unwrap().resident_bytes() > 0);
assert_eq!(
seg.lookup(entries[0].h, &entries[0].key, &cold()).unwrap(),
Lookup::Live(entries[0].value.clone().unwrap())
);
if rec.order == super::super::sidecar::OrderKind::ByKey {
assert!(group.as_ref().unwrap().separator(0).is_empty());
}
}
}
#[test]
fn cold_groups_reject_valid_crc_semantic_damage() {
use crate::seg::page_index::chunk_crcs;
for tree in [false, true] {
for mutation in 0..if tree { 5 } else { 4 } {
let dir = tempfile::tempdir().unwrap();
let rec = if tree {
testkit::write_key_segment(dir.path(), &testkit::ordered_entries(5_000))
} else {
testkit::write_segment(real(), dir.path(), 1, &testkit::entries(20_000, 1))
};
let mut seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap()
.cooled();
let mut pages = (*seg.skeleton().unwrap()).clone();
let section = &pages.index.section;
let mut file = std::fs::read(seg.sidx_path()).unwrap();
let wire =
&mut file[section.offset as usize..(section.offset + section.len) as usize];
if tree {
let n = pages.index.blocks;
let separators_at = 8 + (n + 1) * 8 + n * 4;
let bytes_at = separators_at + (n + 1) * 4;
match mutation {
0 => wire[8..16].copy_from_slice(&65u64.to_le_bytes()),
1 => wire[16..24].copy_from_slice(&64u64.to_le_bytes()),
2 => wire[separators_at + 128 * 4..separators_at + 129 * 4]
.copy_from_slice(&0u32.to_le_bytes()),
3 => wire[bytes_at + 1] ^= 0xff,
_ => {
let old_end = u64::from_le_bytes(wire[16..24].try_into().unwrap());
let delta = 64 + u64::from(u32::MAX) + 1 - old_end;
for i in 1..=n {
let at = 8 + i * 8;
let offset =
u64::from_le_bytes(wire[at..at + 8].try_into().unwrap());
wire[at..at + 8].copy_from_slice(&(offset + delta).to_le_bytes());
}
pages.index.end_offset += delta;
assert!(
crate::seg::key_index::SeparatorIndex::validate(wire, KEY_LEN)
.is_err()
);
}
}
} else {
match mutation {
0 => wire[8..16].copy_from_slice(&65u64.to_le_bytes()),
1 => wire[16..20].copy_from_slice(&0u32.to_le_bytes()),
2 => wire[128 * 24..128 * 24 + 8].copy_from_slice(&0u64.to_le_bytes()),
_ => wire[24..32].copy_from_slice(&0u64.to_le_bytes()),
}
}
pages.index.section.crcs = chunk_crcs(section.offset, wire);
std::fs::write(seg.sidx_path(), file).unwrap();
Arc::get_mut(&mut seg.files).unwrap().skeleton =
SkeletonCell::ready(Arc::new(pages));
assert!(
matches!(
seg.group(0, None),
Err(DbError::SegmentCorrupt { block: None, .. })
),
"tree={tree}, mutation={mutation}"
);
}
}
}
fn differential_random(state: &mut u64) -> u64 {
*state = state.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut z = *state;
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
z ^ (z >> 31)
}
fn differential_filter_wire(length: u32, state: &mut u64) -> Vec<u8> {
use crate::seg::filter::{FilterTable, FuseParams, PartMeta};
let mut arrays = Vec::new();
let mut parts = Vec::new();
for i in 0..4 {
let params = if i % 2 == 0 {
FuseParams {
seed: differential_random(state),
segment_length: length,
segment_count_length: length * (i + 1),
}
} else {
FuseParams {
seed: 0,
segment_length: 0,
segment_count_length: 0,
}
};
let len = if i % 2 == 0 { params.array_len() } else { 0 };
if len != 0 {
params.validate(len).unwrap();
}
parts.push(PartMeta {
offset: FilterTable::head_len(2) + arrays.len(),
len,
keys: if len == 0 { 0 } else { 100 },
params,
});
arrays.extend((0..len).map(|_| differential_random(state) as u8));
}
let table = FilterTable { bits: 2, parts };
let mut wire = table.encode_head();
wire.extend(arrays);
FilterTable::parse(&wire, wire.len()).unwrap();
wire
}
#[test]
fn cold_filters_match_hot_for_million_random_hashes_and_layout_matrix() {
use crate::seg::sidecar::{OrderKind, SECTION_FILTER, SECTION_PREFIX_FILTER};
const RANDOM_SEED: u64 = 0xd1ff_2026_1005_0040;
let mut rng = RANDOM_SEED;
let mut ordinary_random = 0;
let mut prefix_random = 0;
let mut key_comparisons = 0;
for length in [0, 8192, 16384, 32768, 65536, 131072, 262144] {
let dir = tempfile::tempdir().unwrap();
let mut entries = testkit::ordered_entries(if length == 0 { 5000 } else { 100 });
if length == 0 {
for (i, e) in entries.iter_mut().enumerate() {
e.h = (i / 2) as u64;
}
}
let mut header = testkit::header(41);
header.order = OrderKind::ByKey;
header.block_size = 256;
let mut writer =
SegmentWriter::create_key(real(), dir.path(), header, &[4, 8], 1).unwrap();
if length == 0 {
writer.trust_caller_hash();
}
for e in &entries {
writer.push(e.h, &e.bytes()).unwrap();
}
let mut rec = writer.finish(testkit::times(), 0, 0).unwrap().into_record();
if length != 0 {
rec = testkit::rewrite_sections(dir.path(), &rec, |sections| {
sections.retain(|(kind, _)| *kind != crate::seg::sidecar::SECTION_PAGE_INDEX);
for (kind, bytes) in sections {
if *kind == SECTION_FILTER {
*bytes = differential_filter_wire(length, &mut rng);
} else if *kind == SECTION_PREFIX_FILTER {
bytes.truncate(8);
bytes.extend(differential_filter_wire(length, &mut rng));
}
}
});
}
let hot = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let seg = hot.cooled();
let hash_hot = if length == 0 {
let mut writer =
SegmentWriter::create(real(), dir.path(), testkit::header(42), 1).unwrap();
writer.force_filter_bits(2);
writer.trust_caller_hash();
for e in &entries {
writer.push(e.h, &e.bytes()).unwrap();
}
let rec = writer.finish(testkit::times(), 0, 0).unwrap().into_record();
Some(
Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap(),
)
} else {
None
};
let hash_cold = hash_hot.as_ref().map(Segment::cooled);
let ordinary_hot = hash_hot.as_ref().unwrap_or(&hot);
let ordinary_cold = hash_cold.as_ref().unwrap_or(&seg);
let cache = SegBlockCache::new(32 << 20);
for e in &entries {
let actual = ordinary_cold.may_contain(e.h, Some(&cache)).unwrap();
assert_eq!(
actual,
ordinary_hot.may_contain(e.h, None).unwrap(),
"layout={length} stored hash"
);
if length == 0 {
assert!(actual);
}
key_comparisons += 1;
for len in [4, 8] {
let actual = seg.prefix_may_contain(&e.key[..len], Some(&cache)).unwrap();
assert_eq!(
actual,
hot.prefix_may_contain(&e.key[..len], None).unwrap(),
"layout={length} stored prefix={len}"
);
if length == 0 {
assert!(actual);
}
key_comparisons += 1;
}
}
let samples = if length == 0 { 100_000 } else { 150_000 };
let skeleton = seg.skeleton().unwrap();
let ordinary_skeleton = ordinary_cold.skeleton().unwrap();
let mut empty = 0;
let mut page_crossing = 0;
let mut wide = 0;
let mut narrow = 0;
let mut section_edges = 0;
for i in 0..samples {
let h = differential_random(&mut rng);
assert_eq!(
ordinary_cold.may_contain(h, Some(&cache)).unwrap(),
ordinary_hot.may_contain(h, None).unwrap(),
"layout={length} random ordinary {i} hash={h:#x}"
);
ordinary_random += 1;
let bytes = differential_random(&mut rng).to_be_bytes();
let len = if i % 2 == 0 { 4 } else { 8 };
assert_eq!(
seg.prefix_may_contain(&bytes[..len], Some(&cache)).unwrap(),
hot.prefix_may_contain(&bytes[..len], None).unwrap(),
"layout={length} random prefix={len} {i}"
);
prefix_random += 1;
for (f, hash) in [
(&ordinary_skeleton.filter, h),
(
&skeleton.prefix_filters[usize::from(len == 8)].1,
key_hash(&bytes[..len], SEED),
),
] {
match probe(&f.table, hash) {
Probe::Absent => empty += 1,
Probe::At { at, .. } => {
let lo = *at.iter().min().unwrap() + f.filter_at;
let hi = *at.iter().max().unwrap() + f.filter_at;
page_crossing += usize::from(
(f.section.offset + lo) / 4096 != (f.section.offset + hi) / 4096,
);
wide += usize::from(hi - lo + 1 > PROBE_WINDOW);
narrow += usize::from(hi - lo + 1 <= PROBE_WINDOW);
let part = &f.table.parts
[crate::seg::hash::filter_partition(hash, f.table.bits)];
section_edges += usize::from(at.iter().any(|&p| {
p < (part.offset + 4096) as u64
|| p + 4096 >= (part.offset + part.len) as u64
}));
}
}
}
}
if length != 0 {
assert!(empty > 0 && page_crossing > 0 && section_edges > 0);
if length <= 16384 {
assert!(narrow > 0);
}
if length >= 32768 {
assert!(wide > 0);
}
}
eprintln!(
"seed={RANDOM_SEED:#x} layout={length} random ordinary={samples} prefix={samples} empty={empty} page_crossing={page_crossing} section_edges={section_edges} narrow={narrow} wide={wide}"
);
}
assert_eq!(ordinary_random, 1_000_000);
assert_eq!(prefix_random, 1_000_000);
assert_eq!(key_comparisons, 16_800);
eprintln!(
"totals ordinary_random={ordinary_random} prefix_random={prefix_random} every_key_and_prefix={key_comparisons}"
);
}
#[test]
fn genuinely_wide_validated_filter_probes_read_three_pages() {
use crate::seg::filter::{FilterTable, FuseParams, PartMeta, fuse8_contains};
use crate::seg::sidecar::SECTION_FILTER;
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(100, 1);
let original = testkit::write_legacy_segment(real(), dir.path(), 1, &entries);
let params = FuseParams {
seed: 17,
segment_length: 262_144,
segment_count_length: 262_144,
};
let fingerprints: Vec<_> = (0..params.array_len()).map(|i| (i * 13) as u8).collect();
params.validate(fingerprints.len()).unwrap();
let table = FilterTable {
bits: 0,
parts: vec![PartMeta {
offset: 40,
len: fingerprints.len(),
keys: 100,
params,
}],
};
let mut wire = table.encode_head();
wire.extend_from_slice(&fingerprints);
let rec =
testkit::rewrite_section(dir.path(), &original, SECTION_FILTER, |bytes| *bytes = wire);
let hot = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let seg = hot.cooled();
let h = (0..100_000)
.find(|&h| {
let Probe::At { at, .. } = probe(&table, h) else {
return false;
};
at.iter().max().unwrap() - at.iter().min().unwrap() + 1 > PROBE_WINDOW
&& at.map(|p| p / 4096).windows(2).all(|w| w[0] != w[1])
})
.expect("query whose actual positions span more than PROBE_WINDOW");
let before = seg.shared_io_requests();
assert_eq!(
seg.may_contain(h, None).unwrap(),
fuse8_contains(h, ¶ms, &fingerprints)
);
assert_eq!(seg.shared_io_requests() - before, 3);
let cache = SegBlockCache::new(4 << 20);
seg.may_contain(h, Some(&cache)).unwrap();
let before = seg.shared_io_requests();
seg.may_contain(h, Some(&cache)).unwrap();
assert_eq!(seg.shared_io_requests(), before);
assert_eq!(cache.meta_hits(), 3);
assert_eq!(cache.meta_misses(), 3);
assert_eq!(cache.hits(), 0);
assert_eq!(cache.misses(), 0);
}
#[test]
fn uncached_scans_reuse_exact_groups_for_both_orders() {
let dir = tempfile::tempdir().unwrap();
let rec =
testkit::write_segment_with_filter_bits(dir.path(), 1, &testkit::entries(20_000, 1), 0);
let key_rec = testkit::write_key_segment(dir.path(), &testkit::ordered_entries(5_000));
for (rec, requests_per_group) in [(&rec, 1), (&key_rec, 3)] {
let hot = Segment::open(
real(),
dir.path(),
rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let seg = hot.cooled();
let blocks = seg.block_count().unwrap();
assert!(blocks > 128 && !blocks.is_multiple_of(128));
for reverse in [false, true] {
let mut slot = None;
let before = seg.shared_io_requests();
for i in 0..blocks {
let b = if reverse { blocks - 1 - i } else { i };
assert_eq!(
seg.block_range_in(b, &mut slot, None).unwrap(),
hot.block_range_in(b, &mut None, None).unwrap()
);
let group = slot.as_ref().unwrap();
assert!(group.contains(b));
assert!(!group.contains(group.first_block + group.offsets.len() - 1));
if group.first_block > 0 {
assert!(!group.contains(group.first_block - 1));
}
if rec.order == super::super::sidecar::OrderKind::ByHash {
assert_eq!(
seg.first_h_in(b, &mut slot, None).unwrap(),
hot.first_h_in(b, &mut None, None).unwrap()
);
}
}
assert_eq!(
seg.shared_io_requests() - before,
blocks.div_ceil(128) as u64 * requests_per_group
);
}
}
}
#[test]
fn cold_hash_reads_match_hot_and_reuse_verified_pages() {
let f = fixture(20_000);
let hot = open(&f).unwrap();
let cold_seg = hot.cooled();
let cache = SegBlockCache::new(16 << 20);
for e in f.entries.iter().step_by(7) {
assert_eq!(
cold_seg.lookup(e.h, &e.key, &cache).unwrap(),
hot.lookup(e.h, &e.key, &cold()).unwrap()
);
}
for n in 100_000..102_000 {
let key = testkit::key_of(n);
let h = key_hash(&key, SEED);
assert_eq!(
cold_seg.may_contain(h, None).unwrap(),
hot.may_contain(h, None).unwrap()
);
assert_eq!(
cold_seg.lookup(h, &key, &cold()).unwrap(),
hot.lookup(h, &key, &cold()).unwrap()
);
}
let e = &f.entries[100];
cold_seg.lookup(e.h, &e.key, &cache).unwrap();
let before = cold_seg.shared_io_requests();
cold_seg.lookup(e.h, &e.key, &cache).unwrap();
assert_eq!(cold_seg.shared_io_requests(), before);
drop(hot);
assert_eq!(
cold_seg.lookup(e.h, &e.key, &cold()).unwrap(),
e.value
.as_ref()
.map_or(Lookup::Tombstone, |v| Lookup::Live(v.clone()))
);
}
#[test]
fn cold_key_reads_match_hot_routes_ranges_and_prefixes() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::ordered_entries(5_000);
let rec = testkit::write_key_segment(dir.path(), &entries);
let hot = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let seg = hot.cooled();
let cache = SegBlockCache::new(16 << 20);
for n in 0..6_000 {
let key = testkit::ordered_key(n);
assert_eq!(
seg.locate_key_in(&key, &mut None, Some(&cache)).unwrap(),
hot.locate_key_in(&key, &mut None, None).unwrap()
);
for len in [4, 8] {
assert_eq!(
seg.prefix_may_contain(&key[..len], Some(&cache)).unwrap(),
hot.prefix_may_contain(&key[..len], None).unwrap()
);
}
}
let blocks = hot.block_count().unwrap();
assert!(blocks > 128);
for b in 0..blocks {
assert_eq!(
seg.block_range_in(b, &mut None, Some(&cache)).unwrap(),
hot.block_range_in(b, &mut None, None).unwrap()
);
assert_eq!(
seg.group_in(
b / super::super::page_index::GROUP_BLOCKS,
&mut None,
Some(&cache)
)
.unwrap()
.separator(b),
match &hot.hot().index {
SegmentIndex::Key(index) => index.separator(b),
_ => unreachable!(),
}
);
}
for e in entries.iter().step_by(17) {
assert_eq!(
seg.lookup(e.h, &e.key, &cache).unwrap(),
e.value
.as_ref()
.map_or(Lookup::Tombstone, |v| Lookup::Live(v.clone()))
);
}
}
#[test]
fn cold_hits_count_only_filter_and_group_metadata_requests() {
let f = fixture(20_000);
let seg = open(&f).unwrap().cooled();
let e = &f.entries[100];
let before = seg.shared_io_requests();
seg.lookup(e.h, &e.key, &cold()).unwrap();
assert_eq!(seg.shared_io_requests() - before, 2);
assert_eq!(seg.block_reads(), 1);
let rec = testkit::write_key_segment(f.dir.path(), &testkit::key_entries());
let seg = Segment::open(
real(),
f.dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap()
.cooled();
let key = testkit::ordered_key(50);
let before = seg.shared_io_requests();
seg.lookup(key_hash(&key, SEED), &key, &cold()).unwrap();
assert_eq!(seg.shared_io_requests() - before, 4);
assert_eq!(seg.block_reads(), 1);
}
#[test]
fn damaged_cold_metadata_returns_corruption() {
for tree in [false, true] {
let f = fixture(20_000);
let entries = testkit::key_entries();
let rec = if tree {
testkit::write_key_segment(f.dir.path(), &entries)
} else {
f.rec.clone()
};
let seg = Segment::open(
real(),
f.dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap()
.cooled();
let skeleton = seg.skeleton().unwrap();
for section in [&skeleton.filter.section, &skeleton.index.section] {
let original = std::fs::read(seg.sidx_path()).unwrap();
testkit::corrupt_section_everywhere(f.dir.path(), &rec, section.id.kind);
let e = if tree { &entries[50] } else { &f.entries[100] };
assert!(matches!(
seg.lookup(e.h, &e.key, &cold()),
Err(DbError::SegmentCorrupt { block: None, .. })
));
std::fs::write(seg.sidx_path(), original).unwrap();
}
}
}
#[test]
fn a_hot_segment_reports_its_skeleton_and_cost() {
let f = fixture(5_000);
let key_rec = testkit::write_key_segment(f.dir.path(), &testkit::key_entries());
for (rec, len) in [(&f.rec, KEY_LEN as u16), (&key_rec, 32)] {
let seg = Segment::open(
real(),
f.dir.path(),
rec,
len,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
assert!(seg.is_hot());
assert!(
seg.files.sidx.get().is_none(),
"hot open retains only the data handle"
);
assert_eq!(
seg.skeleton().unwrap().index.blocks,
seg.block_count().unwrap()
);
let skeleton = seg.skeleton().unwrap();
assert!(Arc::ptr_eq(
seg.hot().filter.table(),
&skeleton.filter.table
));
for (n, filter) in &seg.hot().prefix_filters {
let (_, prefix) = skeleton
.prefix_filters
.iter()
.find(|(len, _)| len == n)
.unwrap();
assert!(Arc::ptr_eq(filter.table(), &prefix.table));
}
assert!(seg.skeleton_bytes() > 0);
assert!(
seg.cost() >= seg.hot_bytes() as u64,
"cost {} hot {}",
seg.cost(),
seg.hot_bytes()
);
assert!(seg.cost() <= seg.hot_bytes() as u64 + 1024);
assert_eq!(seg.resident_bytes(), seg.hot_bytes() + seg.skeleton_bytes());
}
}
#[test]
fn a_legacy_hot_segment_derives_its_skeleton_at_open() {
let f = fixture(5_000);
let legacy = testkit::write_legacy_segment(real(), f.dir.path(), 2, &f.entries);
let seg = Segment::open(
real(),
f.dir.path(),
&legacy,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
assert_eq!(
seg.skeleton().unwrap().index.samples,
open(&f).unwrap().skeleton().unwrap().index.samples
);
}
#[test]
fn tree_point_hit_reads_one_block() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::key_entries();
let rec = testkit::write_key_segment(dir.path(), &entries);
let segment = Segment::open(
real(),
dir.path(),
&rec,
32,
testkit::SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
let cache = SegBlockCache::new(1 << 20);
let entry = &entries[50];
let before = segment.block_reads();
assert_eq!(
segment.lookup(entry.h, &entry.key, &cache).unwrap(),
Lookup::Live(entry.value.clone().unwrap())
);
assert_eq!(segment.block_reads() - before, 1);
assert!(segment.prefix_may_contain(&entry.key[..4], None).unwrap());
assert!(
segment.prefix_may_contain(&entry.key[..7], None).unwrap(),
"missing filters are conservative"
);
assert_eq!(segment.key_range().unwrap().max, entries[99].key);
assert_eq!(
segment
.lookup(entries[99].h, &entries[99].key, &cache)
.unwrap(),
Lookup::Tombstone
);
for entry in &entries[..99] {
let before = segment.block_reads();
segment
.lookup(entry.h, &entry.key, &SegBlockCache::new(0))
.unwrap();
assert_eq!(segment.block_reads() - before, 1);
}
}
#[test]
fn by_key_header_order_must_match_record() {
for data in [true, false] {
let dir = tempfile::tempdir().unwrap();
let mut rec = testkit::write_key_segment(dir.path(), &testkit::key_entries());
let path = dir.path().join(if data {
sdat_name(rec.segment_id, rec.version)
} else {
sidx_name(rec.segment_id, rec.version)
});
let mut bytes = std::fs::read(&path).unwrap();
let magic = if data { SDAT_MAGIC } else { SIDX_MAGIC };
let mut header = SegHeader::decode(&bytes[..FILE_HEADER_LEN], magic).unwrap();
header.order = super::super::sidecar::OrderKind::ByHash;
bytes[..FILE_HEADER_LEN].copy_from_slice(&header.encode(magic));
std::fs::write(path, &bytes).unwrap();
if data {
rec.sdat_checksum = xxh3_64(&bytes);
} else {
rec.sidx_checksum = xxh3_64(&bytes);
}
assert!(matches!(
Segment::open(
real(),
dir.path(),
&rec,
32,
testkit::SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new())
),
Err(DbError::SegmentCorrupt { .. }) | Err(DbError::FormatMismatch(_))
));
}
}
#[test]
fn by_key_index_offsets_must_match_actual_data_length() {
for first in [true, false] {
let dir = tempfile::tempdir().unwrap();
let rec = testkit::write_key_segment(dir.path(), &testkit::key_entries());
let rec = testkit::rewrite_key_section(
dir.path(),
&rec,
super::super::sidecar::SECTION_SEPARATOR_INDEX,
|wire| {
let n = u32::from_le_bytes(wire[..4].try_into().unwrap()) as usize;
let at = if first { 8 } else { 8 + n * 8 };
let offset = u64::from_le_bytes(wire[at..at + 8].try_into().unwrap()) + 1;
wire[at..at + 8].copy_from_slice(&offset.to_le_bytes());
},
);
assert!(
Segment::open(
real(),
dir.path(),
&rec,
32,
testkit::SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new())
)
.is_err()
);
}
}
#[test]
fn an_unknown_page_index_version_is_skipped_like_a_legacy_sidecar() {
use crate::seg::sidecar::SECTION_PAGE_INDEX;
let mut f = fixture(5_000);
f.rec = testkit::rewrite_section(f.dir.path(), &f.rec, SECTION_PAGE_INDEX, |body| {
body[0] = 2;
});
let hot = open(&f).unwrap();
let cold = open_cold_fixture(&f).unwrap();
assert!(cold.files.skeleton.get().is_none(), "derived like legacy");
for seg in [&hot, &cold] {
for e in f.entries.iter().step_by(37) {
match (seg.lookup(e.h, &e.key, &self::cold()).unwrap(), &e.value) {
(Lookup::Live(v), Some(expected)) => assert_eq!(&v, expected),
(Lookup::Tombstone, None) => {}
(other, _) => panic!("unexpected {other:?}"),
}
}
}
let original = std::fs::read(f.dir.path().join(sidx_name(1, 1))).unwrap();
assert!(Sidecar::parse(&original).unwrap().page_index.is_none());
}
#[test]
fn every_key_is_found() {
let f = fixture(5_000);
let seg = open(&f).unwrap();
let cache = SegBlockCache::new(8 << 20);
for e in &f.entries {
match (seg.lookup(e.h, &e.key, &cache).unwrap(), &e.value) {
(Lookup::Live(v), Some(expected)) => assert_eq!(&v, expected),
(Lookup::Tombstone, None) => {}
(other, _) => panic!("unexpected {other:?}"),
}
}
}
#[test]
fn a_key_that_was_never_written_is_absent() {
let f = fixture(5_000);
let seg = open(&f).unwrap();
for i in 10_000..12_000u64 {
let key = testkit::key_of(i);
let h = crate::seg::hash::key_hash(&key, SEED);
assert_eq!(seg.lookup(h, &key, &cold()).unwrap(), Lookup::Absent);
}
assert!(seg.false_positives() < 40, "{}", seg.false_positives());
}
#[test]
fn a_false_positive_below_the_first_block_reads_nothing() {
let f = fixture(5_000);
let seg = open(&f).unwrap();
let first_h = seg.hot().index.hash_index().first_h(0);
let h = (0..first_h)
.take(1_000_000)
.find(|&h| seg.hot().filter.may_contain(h))
.expect("a filter false positive below the first hash");
let key = testkit::key_of(1_000_000);
let (reads, misses) = (seg.block_reads(), seg.false_positives());
assert_eq!(seg.lookup(h, &key, &cold()).unwrap(), Lookup::Absent);
assert_eq!(seg.block_reads(), reads, "no block was read");
assert_eq!(seg.false_positives(), misses + 1);
}
#[test]
fn a_key_of_the_wrong_length_is_a_caller_error() {
let f = fixture(100);
let seg = open(&f).unwrap();
let e = &f.entries[0];
assert!(matches!(
seg.lookup(e.h, &e.key[..KEY_LEN - 1], &cold()),
Err(DbError::Internal(_))
));
}
#[test]
fn a_hit_reads_exactly_one_block() {
let f = fixture(5_000);
let seg = open(&f).unwrap();
let e = &f.entries[1_234];
let before = seg.block_reads();
seg.lookup(e.h, &e.key, &cold()).unwrap();
assert_eq!(seg.block_reads() - before, 1);
let cache = SegBlockCache::new(8 << 20);
seg.lookup(e.h, &e.key, &cache).unwrap();
let warm = seg.block_reads();
seg.lookup(e.h, &e.key, &cache).unwrap();
assert_eq!(seg.block_reads(), warm, "a cached block is not read again");
}
#[test]
fn two_keys_with_one_hash_are_both_found() {
let dir = tempfile::tempdir().unwrap();
let mut pair = vec![
TestEntry {
h: 0x4242,
key: testkit::key_of(1),
value: Some(b"first".to_vec()),
gsn: 1,
},
TestEntry {
h: 0x4242,
key: testkit::key_of(2),
value: Some(b"second".to_vec()),
gsn: 2,
},
];
pair.sort_by_key(|x| x.key);
let rec = testkit::write_segment_with_staged_hashes(real(), dir.path(), 1, &pair);
let seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
for e in &pair {
assert_eq!(
seg.lookup(0x4242, &e.key, &cold()).unwrap(),
Lookup::Live(e.value.clone().unwrap())
);
}
}
#[test]
fn resident_memory_is_a_filter_and_a_sparse_index() {
let f = fixture(100_000);
let seg = open(&f).unwrap();
let bound = 100_000 * 95 / 80 + seg.hot().index.hash_index().len() * 16 + 64 * 1024;
assert!(
seg.resident_bytes() <= bound,
"{} resident bytes, bound {bound}",
seg.resident_bytes()
);
}
#[test]
fn a_missing_file_is_reported_as_missing() {
let f = fixture(100);
std::fs::remove_file(f.dir.path().join(sdat_name(1, 1))).unwrap();
assert!(matches!(
open(&f),
Err(DbError::SegmentMissing { segment_id: 1, path }) if path.ends_with(sdat_name(1, 1))
));
let f = fixture(100);
std::fs::remove_file(f.dir.path().join(sidx_name(1, 1))).unwrap();
assert!(matches!(
open(&f),
Err(DbError::SegmentMissing { segment_id: 1, path }) if path.ends_with(sidx_name(1, 1))
));
}
#[test]
fn a_file_of_the_wrong_length_is_corrupt() {
let f = fixture(1_000);
let path = f.dir.path().join(sdat_name(1, 1));
let file = std::fs::OpenOptions::new().write(true).open(&path).unwrap();
file.set_len(f.rec.sdat_len - 100).unwrap();
assert!(matches!(
open(&f),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("manifest records")
));
}
#[test]
fn files_of_another_segment_are_refused() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(100, 1);
let rec2 = testkit::write_segment(real(), dir.path(), 2, &entries);
std::fs::rename(
dir.path().join(sdat_name(2, 1)),
dir.path().join(sdat_name(1, 1)),
)
.unwrap();
std::fs::rename(
dir.path().join(sidx_name(2, 1)),
dir.path().join(sidx_name(1, 1)),
)
.unwrap();
let rec1 = SegRecord {
segment_id: 1,
..rec2
};
assert!(matches!(
Segment::open(real(), dir.path(), &rec1, KEY_LEN as u16, SEED, &std::sync::Arc::new(crate::seg::core::SegShared::new())),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("segment id")
));
}
#[test]
fn a_segment_of_another_collection_is_refused() {
let f = fixture(100);
assert!(matches!(
Segment::open(real(), f.dir.path(), &f.rec, KEY_LEN as u16, SEED + 1, &std::sync::Arc::new(crate::seg::core::SegShared::new())),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("seed")
));
assert!(matches!(
Segment::open(real(), f.dir.path(), &f.rec, 16, SEED, &std::sync::Arc::new(crate::seg::core::SegShared::new())),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("key length")
));
}
#[test]
fn data_and_sidecar_headers_must_have_the_same_block_size() {
let f = fixture(100);
let path = f.dir.path().join(sdat_name(1, 1));
let mut bytes = std::fs::read(&path).unwrap();
bytes[32..36].copy_from_slice(&8192u32.to_le_bytes());
let crc = crc32fast::hash(&bytes[..60]);
bytes[60..64].copy_from_slice(&crc.to_le_bytes());
std::fs::write(&path, bytes).unwrap();
assert!(matches!(
Segment::check_files(f.dir.path(), &f.rec, KEY_LEN as u16, SEED, &Arc::new(SegShared::new())),
Err(DbError::SegmentCorrupt { reason, .. }) if reason.contains("headers differ")
));
}
#[test]
fn a_damaged_sidecar_fails_the_open() {
let f = fixture(1_000);
let path = f.dir.path().join(sidx_name(1, 1));
let mut bytes = std::fs::read(&path).unwrap();
bytes[200] ^= 1;
std::fs::write(&path, bytes).unwrap();
assert!(matches!(open(&f), Err(DbError::SegmentCorrupt { .. })));
}
#[test]
fn checking_files_changes_nothing() {
let f = fixture(1_000);
let before: Vec<_> = [sdat_name(1, 1), sidx_name(1, 1)]
.iter()
.map(|n| std::fs::read(f.dir.path().join(n)).unwrap())
.collect();
Segment::check_files(
f.dir.path(),
&f.rec,
KEY_LEN as u16,
SEED,
&Arc::new(SegShared::new()),
)
.unwrap();
let after: Vec<_> = [sdat_name(1, 1), sidx_name(1, 1)]
.iter()
.map(|n| std::fs::read(f.dir.path().join(n)).unwrap())
.collect();
assert_eq!(before, after);
assert_eq!(std::fs::read_dir(f.dir.path()).unwrap().count(), 2);
}
#[test]
fn a_block_damaged_after_open_is_reported_with_its_number() {
for at in [0usize, 40] {
let f = fixture(5_000);
let seg = open(&f).unwrap();
let e = &f.entries[2_500];
let block = seg.hot().index.hash_index().locate(e.h).unwrap();
let (offset, _) = seg.hot().index.hash_index().range(block);
let mut bytes = std::fs::read(seg.sdat_path()).unwrap();
bytes[offset as usize + at] ^= 1;
std::fs::write(seg.sdat_path(), bytes).unwrap();
match seg.lookup(e.h, &e.key, &cold()).unwrap_err() {
DbError::SegmentCorrupt {
segment_id,
block: reported,
..
} => {
assert_eq!(segment_id, 1);
assert_eq!(reported, Some(block as u32));
}
other => panic!("byte {at}: {other:?}"),
}
}
}
#[test]
fn a_file_truncated_after_open_is_an_error_not_a_panic() {
let f = fixture(5_000);
let seg = open(&f).unwrap();
let file = std::fs::OpenOptions::new()
.write(true)
.open(seg.sdat_path())
.unwrap();
file.set_len(f.rec.sdat_len / 2 + 7).unwrap();
let mut failures = 0;
for e in &f.entries {
match seg.lookup(e.h, &e.key, &cold()) {
Ok(_) => {}
Err(DbError::SegmentCorrupt { .. }) => failures += 1,
Err(other) => panic!("{other:?}"),
}
}
assert!(failures > 0, "the second half of the file is gone");
}
#[test]
fn a_doomed_segment_takes_its_files_with_it() {
let f = fixture(100);
let seg = open(&f).unwrap();
drop(seg);
assert_eq!(std::fs::read_dir(f.dir.path()).unwrap().count(), 2);
let seg = open(&f).unwrap();
seg.mark_doomed();
assert_eq!(
std::fs::read_dir(f.dir.path()).unwrap().count(),
2,
"the files stay while the segment is alive"
);
drop(seg);
assert_eq!(std::fs::read_dir(f.dir.path()).unwrap().count(), 0);
}
#[test]
fn a_writer_and_a_reader_agree_on_the_names() {
let dir = tempfile::tempdir().unwrap();
let entries = testkit::entries(10, 1);
let header = testkit::header(0xabc);
let mut w = SegmentWriter::create(real(), dir.path(), header, 10).unwrap();
for e in &entries {
w.push(e.h, &e.bytes()).unwrap();
}
let rec = w.finish(testkit::times(), 0, 0).unwrap().into_record();
let seg = Segment::open(
real(),
dir.path(),
&rec,
KEY_LEN as u16,
SEED,
&std::sync::Arc::new(crate::seg::core::SegShared::new()),
)
.unwrap();
assert_eq!(seg.id(), 0xabc);
assert!(seg.sdat_path().ends_with("0000000000000abc-0001.sdat"));
}
}