use std::collections::HashSet;
use std::path::{Path, PathBuf};
use redb::{Database, ReadableDatabase, ReadableTable, ReadableTableMetadata, TableDefinition};
pub const DATABASE_FILE: &str = "cache.redb";
pub const SCHEMA_VERSION: u64 = 1;
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const PROJECTIONS: TableDefinition<u64, &[u8]> = TableDefinition::new("projections");
const SUMMARIES: TableDefinition<(u64, u64, u64), &[u8]> = TableDefinition::new("summaries");
const RENDERINGS: TableDefinition<(u64, u64), &[u8]> = TableDefinition::new("renderings");
const ENVIRONMENTS: TableDefinition<u64, &[u8]> = TableDefinition::new("environments");
const MACROS: TableDefinition<u64, &[u8]> = TableDefinition::new("macros");
const UNITS: TableDefinition<u64, &[u8]> = TableDefinition::new("units");
const UNIT_INDICES: TableDefinition<u64, &[u8]> = TableDefinition::new("unit_indices");
const KEY_SCHEMA: &str = "schema_version";
const KEY_GENERATION: &str = "generation";
const KEY_FINGERPRINT: &str = "reading_fingerprint";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CacheKey {
pub content: u64,
pub config: u64,
pub env: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FileRow {
pub content: u64,
pub config: u64,
pub env: u64,
pub mtime: u64,
pub size: u64,
pub generation: u64,
}
impl FileRow {
fn encode(self) -> Vec<u8> {
let mut bytes = Vec::with_capacity(48);
for value in [
self.content,
self.config,
self.env,
self.mtime,
self.size,
self.generation,
] {
bytes.extend_from_slice(&value.to_le_bytes());
}
bytes
}
fn decode(bytes: &[u8]) -> Option<FileRow> {
if bytes.len() < 48 {
return None;
}
let mut values = [0u64; 6];
for (index, value) in values.iter_mut().enumerate() {
let at = index * 8;
*value = u64::from_le_bytes(bytes[at..at + 8].try_into().ok()?);
}
Some(FileRow {
content: values[0],
config: values[1],
env: values[2],
mtime: values[3],
size: values[4],
generation: values[5],
})
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Collected {
pub summaries: usize,
pub renderings: usize,
pub projections: usize,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct DatabaseSizes {
pub files: usize,
pub summaries: usize,
pub renderings: usize,
pub projections: usize,
pub environments: usize,
pub macros: usize,
pub units: usize,
pub unit_indices: usize,
pub bytes: u64,
}
#[derive(Debug)]
pub enum CacheError {
Database(redb::Error),
Table(redb::TableError),
Storage(redb::StorageError),
Transaction(redb::TransactionError),
Commit(redb::CommitError),
Io(std::io::Error),
Corrupt(&'static str),
}
impl std::fmt::Display for CacheError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CacheError::Database(error) => write!(formatter, "cache database: {error}"),
CacheError::Table(error) => write!(formatter, "cache table: {error}"),
CacheError::Storage(error) => write!(formatter, "cache storage: {error}"),
CacheError::Transaction(error) => write!(formatter, "cache transaction: {error}"),
CacheError::Commit(error) => write!(formatter, "cache commit: {error}"),
CacheError::Io(error) => write!(formatter, "cache io: {error}"),
CacheError::Corrupt(what) => write!(formatter, "cache row is corrupt: {what}"),
}
}
}
impl std::error::Error for CacheError {}
impl From<redb::DatabaseError> for CacheError {
fn from(error: redb::DatabaseError) -> Self {
CacheError::Database(error.into())
}
}
impl From<redb::Error> for CacheError {
fn from(error: redb::Error) -> Self {
CacheError::Database(error)
}
}
impl From<redb::TableError> for CacheError {
fn from(error: redb::TableError) -> Self {
CacheError::Table(error)
}
}
impl From<redb::StorageError> for CacheError {
fn from(error: redb::StorageError) -> Self {
CacheError::Storage(error)
}
}
impl From<redb::TransactionError> for CacheError {
fn from(error: redb::TransactionError) -> Self {
CacheError::Transaction(error)
}
}
impl From<redb::CommitError> for CacheError {
fn from(error: redb::CommitError) -> Self {
CacheError::Commit(error)
}
}
impl From<std::io::Error> for CacheError {
fn from(error: std::io::Error) -> Self {
CacheError::Io(error)
}
}
type Result<T> = std::result::Result<T, CacheError>;
pub struct CacheDb {
database: Database,
directory: PathBuf,
}
impl CacheDb {
pub fn open(directory: &Path, reading_fingerprint: u64) -> Result<CacheDb> {
std::fs::create_dir_all(directory)?;
let path = directory.join(DATABASE_FILE);
let want_schema = SCHEMA_VERSION.to_le_bytes();
let want_fingerprint = reading_fingerprint.to_le_bytes();
let mut database = match Database::create(&path) {
Ok(database) => database,
Err(_) => {
let _ = std::fs::remove_file(&path);
Database::create(&path)?
}
};
let reusable = {
let read = database.begin_read()?;
let table = read.open_table(META);
match table {
Ok(table) => {
let schema = table
.get(KEY_SCHEMA)
.ok()
.flatten()
.map(|value| value.value().to_vec());
let fingerprint = table
.get(KEY_FINGERPRINT)
.ok()
.flatten()
.map(|value| value.value().to_vec());
schema.as_deref() == Some(&want_schema[..])
&& fingerprint.as_deref() == Some(&want_fingerprint[..])
}
Err(redb::TableError::TableDoesNotExist(_)) => true,
Err(error) => return Err(error.into()),
}
};
if !reusable {
drop(database);
for suffix in ["", "-wal", "-shm"] {
let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
}
database = Database::create(&path)?;
}
let write = database.begin_write()?;
{
let mut meta = write.open_table(META)?;
meta.insert(KEY_SCHEMA, &want_schema[..])?;
meta.insert(KEY_FINGERPRINT, &want_fingerprint[..])?;
if meta.get(KEY_GENERATION)?.is_none() {
meta.insert(KEY_GENERATION, &0u64.to_le_bytes()[..])?;
}
write.open_table(FILES)?;
write.open_table(PROJECTIONS)?;
write.open_table(SUMMARIES)?;
write.open_table(RENDERINGS)?;
write.open_table(ENVIRONMENTS)?;
write.open_table(MACROS)?;
write.open_table(UNITS)?;
write.open_table(UNIT_INDICES)?;
}
write.commit()?;
Ok(CacheDb {
database,
directory: directory.to_path_buf(),
})
}
pub fn directory(&self) -> &Path {
&self.directory
}
pub fn generation(&self) -> Result<u64> {
let read = self.database.begin_read()?;
let meta = read.open_table(META)?;
Ok(meta
.get(KEY_GENERATION)?
.map(|value| {
let mut bytes = [0u8; 8];
let value = value.value();
let length = value.len().min(8);
bytes[..length].copy_from_slice(&value[..length]);
u64::from_le_bytes(bytes)
})
.unwrap_or(0))
}
pub fn begin_generation(&self) -> Result<u64> {
let write = self.database.begin_write()?;
let next = {
let mut meta = write.open_table(META)?;
let current = meta
.get(KEY_GENERATION)?
.map(|value| {
let mut bytes = [0u8; 8];
let value = value.value();
let length = value.len().min(8);
bytes[..length].copy_from_slice(&value[..length]);
u64::from_le_bytes(bytes)
})
.unwrap_or(0);
let next = current + 1;
meta.insert(KEY_GENERATION, &next.to_le_bytes()[..])?;
next
};
write.commit()?;
Ok(next)
}
pub fn put_file(&self, path: &Path, row: FileRow) -> Result<()> {
let key = normalise(path);
let write = self.database.begin_write()?;
{
let mut files = write.open_table(FILES)?;
files.insert(&key[..], &row.encode()[..])?;
}
write.commit()?;
Ok(())
}
pub fn file(&self, path: &Path) -> Result<Option<FileRow>> {
let key = normalise(path);
let read = self.database.begin_read()?;
let files = read.open_table(FILES)?;
let Some(value) = files.get(&key[..])? else {
return Ok(None);
};
Ok(FileRow::decode(value.value()))
}
pub fn summary(&self, key: CacheKey) -> Result<Option<Vec<u8>>> {
let read = self.database.begin_read()?;
let summaries = read.open_table(SUMMARIES)?;
let Some(value) = summaries.get((key.content, key.config, key.env))? else {
return Ok(None);
};
Ok(Some(decompress(value.value())?))
}
pub fn put_summary(&self, key: CacheKey, bytes: &[u8]) -> Result<()> {
let packed = compress(bytes);
let write = self.database.begin_write()?;
{
let mut summaries = write.open_table(SUMMARIES)?;
summaries.insert((key.content, key.config, key.env), &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn put_rows(
&self,
summaries: &[(CacheKey, Vec<u8>)],
files: &[(String, FileRow)],
) -> Result<()> {
if summaries.is_empty() && files.is_empty() {
return Ok(());
}
let packed: Vec<((u64, u64, u64), Vec<u8>)> = summaries
.iter()
.map(|(key, bytes)| ((key.content, key.config, key.env), compress(bytes)))
.collect();
let rows: Vec<(String, Vec<u8>)> = files
.iter()
.map(|(path, row)| (normalise(Path::new(path)), row.encode()))
.collect();
let write = self.database.begin_write()?;
{
let mut table = write.open_table(SUMMARIES)?;
for (key, bytes) in &packed {
table.insert(*key, &bytes[..])?;
}
}
{
let mut table = write.open_table(FILES)?;
for (path, bytes) in &rows {
table.insert(&path[..], &bytes[..])?;
}
}
write.commit()?;
Ok(())
}
pub fn put_summaries(&self, rows: &[(CacheKey, Vec<u8>)]) -> Result<()> {
if rows.is_empty() {
return Ok(());
}
let packed: Vec<((u64, u64, u64), Vec<u8>)> = rows
.iter()
.map(|(key, bytes)| ((key.content, key.config, key.env), compress(bytes)))
.collect();
let write = self.database.begin_write()?;
{
let mut summaries = write.open_table(SUMMARIES)?;
for (key, bytes) in &packed {
summaries.insert(*key, &bytes[..])?;
}
}
write.commit()?;
Ok(())
}
pub fn rendering(&self, content: u64, env: u64) -> Result<Option<String>> {
let read = self.database.begin_read()?;
let renderings = read.open_table(RENDERINGS)?;
let Some(value) = renderings.get((content, env))? else {
return Ok(None);
};
Ok(Some(
String::from_utf8_lossy(&decompress(value.value())?).into_owned(),
))
}
pub fn put_rendering(&self, content: u64, env: u64, text: &str) -> Result<()> {
let packed = compress(text.as_bytes());
let write = self.database.begin_write()?;
{
let mut renderings = write.open_table(RENDERINGS)?;
renderings.insert((content, env), &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn projection(&self, content: u64) -> Result<Option<Vec<String>>> {
let read = self.database.begin_read()?;
let projections = read.open_table(PROJECTIONS)?;
let Some(value) = projections.get(content)? else {
return Ok(None);
};
let bytes = decompress(value.value())?;
Ok(Some(
bytes
.split(|byte| *byte == 0)
.filter(|name| !name.is_empty())
.map(|name| String::from_utf8_lossy(name).into_owned())
.collect(),
))
}
pub fn put_projection(&self, content: u64, names: &[String]) -> Result<()> {
let mut joined = Vec::new();
for name in names {
joined.extend_from_slice(name.as_bytes());
joined.push(0);
}
let packed = compress(&joined);
let write = self.database.begin_write()?;
{
let mut projections = write.open_table(PROJECTIONS)?;
projections.insert(content, &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn unit(&self, key: u64) -> Result<Option<crate::RenderedUnit>> {
let read = self.database.begin_read()?;
let units = read.open_table(UNITS)?;
let Some(value) = units.get(key)? else {
return Ok(None);
};
let bytes = decompress(value.value())?;
Ok(crate::unit_codec::decode(&bytes).ok())
}
pub fn put_unit(&self, key: u64, unit: &crate::RenderedUnit) -> Result<()> {
let packed = compress(&crate::unit_codec::encode(unit));
let write = self.database.begin_write()?;
{
let mut units = write.open_table(UNITS)?;
write.open_table(UNIT_INDICES)?;
units.insert(key, &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn indexed_unit(&self, program: u64) -> Result<Option<crate::IndexedUnit>> {
let read = self.database.begin_read()?;
let table = read.open_table(UNIT_INDICES)?;
let Some(value) = table.get(program)? else {
return Ok(None);
};
let bytes = decompress(value.value())?;
Ok(crate::unit_codec::decode_indexed_unit(&bytes).ok())
}
pub fn put_indexed_unit(&self, program: u64, unit: &crate::IndexedUnit) -> Result<()> {
let packed = compress(&crate::unit_codec::encode_indexed_unit(unit));
let write = self.database.begin_write()?;
{
let mut table = write.open_table(UNIT_INDICES)?;
table.insert(program, &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn put_environment(&self, env: u64, bytes: &[u8]) -> Result<()> {
let packed = compress(bytes);
let write = self.database.begin_write()?;
{
let mut environments = write.open_table(ENVIRONMENTS)?;
environments.insert(env, &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn put_macro(&self, body_hash: u64, body: &str) -> Result<()> {
let packed = compress(body.as_bytes());
let write = self.database.begin_write()?;
{
let mut macros = write.open_table(MACROS)?;
write.open_table(UNITS)?;
write.open_table(UNIT_INDICES)?;
macros.insert(body_hash, &packed[..])?;
}
write.commit()?;
Ok(())
}
pub fn collect(&self) -> Result<Collected> {
let (live_summaries, live_renderings, live_contents) = {
let read = self.database.begin_read()?;
let files = read.open_table(FILES)?;
let mut summaries: HashSet<(u64, u64, u64)> = HashSet::new();
let mut renderings: HashSet<(u64, u64)> = HashSet::new();
let mut contents: HashSet<u64> = HashSet::new();
for entry in files.iter()? {
let (_, value) = entry?;
let Some(row) = FileRow::decode(value.value()) else {
continue;
};
summaries.insert((row.content, row.config, row.env));
renderings.insert((row.content, row.env));
contents.insert(row.content);
}
(summaries, renderings, contents)
};
if live_summaries.is_empty() && live_renderings.is_empty() {
return Ok(Collected::default());
}
let mut collected = Collected::default();
let write = self.database.begin_write()?;
{
let mut summaries = write.open_table(SUMMARIES)?;
let dead: Vec<(u64, u64, u64)> = summaries
.iter()?
.filter_map(|entry| entry.ok().map(|(key, _)| key.value()))
.filter(|key| !live_summaries.contains(key))
.collect();
for key in dead {
summaries.remove(key)?;
collected.summaries += 1;
}
}
{
let mut renderings = write.open_table(RENDERINGS)?;
let dead: Vec<(u64, u64)> = renderings
.iter()?
.filter_map(|entry| entry.ok().map(|(key, _)| key.value()))
.filter(|key| !live_renderings.contains(key))
.collect();
for key in dead {
renderings.remove(key)?;
collected.renderings += 1;
}
}
{
let mut projections = write.open_table(PROJECTIONS)?;
let dead: Vec<u64> = projections
.iter()?
.filter_map(|entry| entry.ok().map(|(key, _)| key.value()))
.filter(|key| !live_contents.contains(key))
.collect();
for key in dead {
projections.remove(key)?;
collected.projections += 1;
}
}
write.commit()?;
Ok(collected)
}
pub fn compact(&mut self) -> Result<bool> {
self.database
.compact()
.map_err(|error| CacheError::Io(std::io::Error::other(error)))
}
pub fn sizes(&self) -> Result<DatabaseSizes> {
let read = self.database.begin_read()?;
let count = |length: usize| length;
Ok(DatabaseSizes {
files: count(read.open_table(FILES)?.len()? as usize),
summaries: count(read.open_table(SUMMARIES)?.len()? as usize),
renderings: count(read.open_table(RENDERINGS)?.len()? as usize),
projections: count(read.open_table(PROJECTIONS)?.len()? as usize),
environments: count(read.open_table(ENVIRONMENTS)?.len()? as usize),
macros: count(read.open_table(MACROS)?.len()? as usize),
units: count(read.open_table(UNITS)?.len()? as usize),
unit_indices: count(read.open_table(UNIT_INDICES)?.len()? as usize),
bytes: std::fs::metadata(self.directory.join(DATABASE_FILE))
.map(|metadata| metadata.len())
.unwrap_or(0),
})
}
}
pub struct SummaryCache {
database: CacheDb,
pending: std::sync::Mutex<(Vec<(CacheKey, Vec<u8>)>, Vec<(String, FileRow)>)>,
}
const BATCH: usize = 32;
fn open_handles()
-> &'static std::sync::Mutex<std::collections::HashMap<String, std::sync::Arc<SummaryCache>>> {
static HANDLES: std::sync::OnceLock<
std::sync::Mutex<std::collections::HashMap<String, std::sync::Arc<SummaryCache>>>,
> = std::sync::OnceLock::new();
HANDLES.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
}
pub fn shared(directory: &Path, reading_fingerprint: u64) -> Option<std::sync::Arc<SummaryCache>> {
let key = directory.to_string_lossy().to_lowercase();
let Ok(mut handles) = open_handles().lock() else {
return None;
};
if let Some(handle) = handles.get(key.as_str()) {
return Some(std::sync::Arc::clone(handle));
}
let opened = std::sync::Arc::new(SummaryCache::open(directory, reading_fingerprint)?);
handles.insert(key, std::sync::Arc::clone(&opened));
Some(opened)
}
impl SummaryCache {
pub fn open(directory: &Path, reading_fingerprint: u64) -> Option<SummaryCache> {
match CacheDb::open(directory, reading_fingerprint) {
Ok(database) => Some(SummaryCache {
database,
pending: std::sync::Mutex::new((Vec::new(), Vec::new())),
}),
Err(error) => {
log::warn!("the summary database could not be opened: {error}");
None
}
}
}
pub fn summary(&self, key: crate::cache::SummaryKey) -> Option<crate::FileSummary> {
let cache_key = CacheKey {
content: key.content_hash,
config: key.context_hash,
env: 0,
};
let buffered = self.pending.lock().ok().and_then(|pending| {
pending
.0
.iter()
.rev()
.find(|(held, _)| *held == cache_key)
.map(|(_, bytes)| bytes.clone())
});
let bytes = match buffered {
Some(bytes) => bytes,
None => self.database.summary(cache_key).ok().flatten()?,
};
match crate::summary_codec::decode(&bytes) {
Ok(summary) => Some(summary),
Err(error) => {
log::debug!("a stored summary could not be decoded: {error}");
None
}
}
}
pub fn put(&self, key: crate::cache::SummaryKey, summary: &crate::FileSummary) {
let bytes = crate::summary_codec::encode(summary);
let cache_key = CacheKey {
content: key.content_hash,
config: key.context_hash,
env: 0,
};
let Ok(mut pending) = self.pending.lock() else {
return;
};
pending.0.push((cache_key, bytes));
if pending.0.len() >= BATCH {
flush(&self.database, &mut pending);
}
}
pub fn note_file(&self, path: &Path, content: u64, config: u64, env: u64, generation: u64) {
let (mtime, size) = std::fs::metadata(path)
.map(|metadata| {
let mtime = metadata
.modified()
.ok()
.and_then(|time| time.duration_since(std::time::UNIX_EPOCH).ok())
.map(|since| since.as_millis() as u64)
.unwrap_or(0);
(mtime, metadata.len())
})
.unwrap_or((0, 0));
let row = FileRow {
content,
config,
env,
mtime,
size,
generation,
};
let Ok(mut pending) = self.pending.lock() else {
return;
};
pending.1.push((path.to_string_lossy().to_string(), row));
if pending.0.len() + pending.1.len() >= BATCH {
flush(&self.database, &mut pending);
}
}
pub fn flush(&self) {
if let Ok(mut pending) = self.pending.lock() {
flush(&self.database, &mut pending);
}
}
pub fn collect(&self) -> Option<Collected> {
self.flush();
self.database.collect().ok()
}
pub fn unit(&self, key: u64) -> Result<Option<crate::RenderedUnit>> {
self.database.unit(key)
}
pub fn put_unit(&self, key: u64, unit: &crate::RenderedUnit) -> Result<()> {
self.database.put_unit(key, unit)
}
pub fn indexed_unit(&self, program: u64) -> Result<Option<crate::IndexedUnit>> {
self.database.indexed_unit(program)
}
pub fn put_indexed_unit(&self, program: u64, unit: &crate::IndexedUnit) -> Result<()> {
self.database.put_indexed_unit(program, unit)
}
pub fn begin_generation(&self) -> Result<u64> {
self.database.begin_generation()
}
pub fn collect_and_compact(&mut self) -> Option<(Collected, bool)> {
let collected = self.database.collect().ok()?;
let compacted = self.database.compact().ok()?;
Some((collected, compacted))
}
pub fn sizes(&self) -> Option<DatabaseSizes> {
self.database.sizes().ok()
}
}
impl Drop for SummaryCache {
fn drop(&mut self) {
self.flush();
}
}
fn flush(database: &CacheDb, pending: &mut (Vec<(CacheKey, Vec<u8>)>, Vec<(String, FileRow)>)) {
if pending.0.is_empty() && pending.1.is_empty() {
return;
}
let (summaries, files) = std::mem::take(pending);
if let Err(error) = database.put_rows(&summaries, &files) {
log::warn!("a batch of summaries could not be written: {error}");
}
}
fn normalise(path: &Path) -> String {
path.to_string_lossy().to_lowercase()
}
fn compress(bytes: &[u8]) -> Vec<u8> {
zstd::encode_all(bytes, 3).unwrap_or_else(|_| bytes.to_vec())
}
fn decompress(bytes: &[u8]) -> Result<Vec<u8>> {
zstd::decode_all(bytes).map_err(|_| CacheError::Corrupt("zstd frame"))
}
#[cfg(test)]
mod tests {
use super::*;
fn scratch(name: &str) -> PathBuf {
let directory =
std::env::temp_dir().join(format!("cppls-cache-db-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&directory);
directory
}
fn row(content: u64, env: u64, generation: u64) -> FileRow {
FileRow {
content,
config: 7,
env,
mtime: 1,
size: 2,
generation,
}
}
#[test]
fn a_summary_survives_a_round_trip() {
let directory = scratch("round-trip");
let database = CacheDb::open(&directory, 42).expect("opens");
let key = CacheKey {
content: 1,
config: 2,
env: 3,
};
let body = vec![b'x'; 4_096];
assert!(
database.summary(key).unwrap().is_none(),
"a miss is not an error"
);
database.put_summary(key, &body).unwrap();
assert_eq!(database.summary(key).unwrap().unwrap(), body);
let sizes = database.sizes().unwrap();
assert_eq!(sizes.summaries, 1);
assert!(sizes.bytes > 0);
drop(database);
let _ = std::fs::remove_dir_all(&directory);
}
#[test]
fn collection_keeps_what_a_file_references() {
let directory = scratch("collection");
let database = CacheDb::open(&directory, 42).expect("opens");
let live = CacheKey {
content: 10,
config: 7,
env: 20,
};
let dead = CacheKey {
content: 11,
config: 7,
env: 20,
};
database.put_summary(live, b"live").unwrap();
database.put_summary(dead, b"dead").unwrap();
database
.put_rendering(live.content, live.env, "int x;")
.unwrap();
database
.put_rendering(dead.content, dead.env, "int y;")
.unwrap();
database
.put_projection(live.content, &["_STD".to_string()])
.unwrap();
database
.put_projection(dead.content, &["_HAS_CXX20".to_string()])
.unwrap();
database
.put_file(Path::new("C:/p/live.cpp"), row(live.content, live.env, 1))
.unwrap();
let collected = database.collect().unwrap();
assert_eq!(collected.summaries, 1, "the unreferenced summary is gone");
assert_eq!(
collected.renderings, 1,
"and so is the unreferenced rendering"
);
assert_eq!(collected.projections, 1, "and the unreferenced projection");
assert!(
database.summary(live).unwrap().is_some(),
"the referenced one stays"
);
assert!(database.summary(dead).unwrap().is_none());
drop(database);
let _ = std::fs::remove_dir_all(&directory);
}
#[test]
fn a_batch_is_one_transaction_and_compaction_shrinks() {
let directory = scratch("batch");
let mut database = CacheDb::open(&directory, 42).expect("opens");
let rows: Vec<(CacheKey, Vec<u8>)> = (0..256u64)
.map(|index| {
(
CacheKey {
content: index,
config: 1,
env: 2,
},
vec![b'a'; 4_096],
)
})
.collect();
database.put_summaries(&rows).unwrap();
database
.put_file(
Path::new("C:/p/wanted.cpp"),
FileRow {
content: 0,
config: 1,
env: 2,
mtime: 1,
size: 1,
generation: 1,
},
)
.unwrap();
assert_eq!(database.sizes().unwrap().summaries, 256);
assert_eq!(database.summary(rows[7].0).unwrap().unwrap(), rows[7].1);
let collected = database.collect().unwrap();
assert_eq!(
collected.summaries, 255,
"every summary but the referenced one"
);
assert_eq!(
database.sizes().unwrap().summaries,
1,
"the one a file references stays"
);
let before = database.sizes().unwrap().bytes;
assert!(database.compact().unwrap());
let after = database.sizes().unwrap().bytes;
assert!(
after < before,
"compaction must shrink: {before} -> {after}"
);
drop(database);
let _ = std::fs::remove_dir_all(&directory);
}
#[test]
fn a_foreign_schema_is_replaced() {
let directory = scratch("schema");
let database = CacheDb::open(&directory, 1).expect("opens");
database
.put_summary(
CacheKey {
content: 5,
config: 5,
env: 5,
},
b"body",
)
.unwrap();
drop(database);
let reopened = CacheDb::open(&directory, 2).expect("reopens");
assert!(
reopened
.summary(CacheKey {
content: 5,
config: 5,
env: 5
})
.unwrap()
.is_none(),
"a different fingerprint is a different database"
);
assert_eq!(reopened.generation().unwrap(), 0, "and a fresh generation");
drop(reopened);
let _ = std::fs::remove_dir_all(&directory);
}
#[test]
fn a_generation_is_bumped_once() {
let directory = scratch("generation");
let database = CacheDb::open(&directory, 42).expect("opens");
assert_eq!(database.generation().unwrap(), 0);
assert_eq!(database.begin_generation().unwrap(), 1);
assert_eq!(database.generation().unwrap(), 1);
assert_eq!(database.begin_generation().unwrap(), 2);
database
.put_file(
Path::new("C:/p/a.cpp"),
row(1, 2, database.generation().unwrap()),
)
.unwrap();
assert_eq!(
database
.file(Path::new("c:/P/A.CPP"))
.unwrap()
.unwrap()
.generation,
2
);
drop(database);
let _ = std::fs::remove_dir_all(&directory);
}
}