Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

vecdb: fail the key reads on a closed handle

laurenspriema24ec3619bd6
diff --git a/rust/bindings/frb/photos/src/api/vecdb_api.rs b/rust/bindings/frb/photos/src/api/vecdb_api.rs
index a75b35e5f5..4555f25139 100644
--- a/rust/bindings/frb/photos/src/api/vecdb_api.rs
+++ b/rust/bindings/frb/photos/src/api/vecdb_api.rs
@@ -243,16 +243,20 @@ impl VecDb {
Ok(self.inner.bulk_add_with_attrs(&keys, &vectors, &attrs)?)
}
- pub fn get_attrs(&self, key: String) -> Option<Vec<VecDbAttr>> {
- self.inner.get_attrs(&key).map(to_api_attrs)
+ pub fn get_attrs(&self, key: String) -> Result<Option<Vec<VecDbAttr>>, RustVecDbError> {
+ Ok(self.inner.get_attrs(&key)?.map(to_api_attrs))
}
- pub fn bulk_get_attrs(&self, keys: Vec<String>) -> Vec<Option<Vec<VecDbAttr>>> {
- self.inner
- .bulk_get_attrs(&keys)
+ pub fn bulk_get_attrs(
+ &self,
+ keys: Vec<String>,
+ ) -> Result<Vec<Option<Vec<VecDbAttr>>>, RustVecDbError> {
+ Ok(self
+ .inner
+ .bulk_get_attrs(&keys)?
.into_iter()
.map(|entry| entry.map(to_api_attrs))
- .collect()
+ .collect())
}
pub fn approx_search_vectors_within_similarity(
@@ -333,8 +337,14 @@ impl VecDb {
.collect())
}
- pub fn bulk_get_vectors(&self, keys: Vec<String>) -> Vec<Option<Vec<f32>>> {
- keys.iter().map(|key| self.inner.get(key)).collect()
+ pub fn bulk_get_vectors(
+ &self,
+ keys: Vec<String>,
+ ) -> Result<Vec<Option<Vec<f32>>>, RustVecDbError> {
+ Ok(keys
+ .iter()
+ .map(|key| self.inner.get(key))
+ .collect::<Result<_, _>>()?)
}
pub fn bulk_remove_vectors(&self, keys: Vec<String>) -> Result<u32, RustVecDbError> {
@@ -484,7 +494,7 @@ mod tests {
db.bulk_add_vectors(vec![key("b"), key("c")], vec![basis(1), basis(2)])
.unwrap();
assert_eq!(
- db.bulk_get_vectors(vec![key("c"), key("missing")]),
+ db.bulk_get_vectors(vec![key("c"), key("missing")]).unwrap(),
vec![Some(basis(2)), None]
);
let matches = db.search(basis(0), Some(2), None, true, None).unwrap();
@@ -748,7 +758,7 @@ mod tests {
},
];
db.add_vector_with_attrs(key("a"), basis(0), attrs).unwrap();
- let fetched = db.get_attrs(key("a")).unwrap();
+ let fetched = db.get_attrs(key("a")).unwrap().unwrap();
assert_eq!(fetched.len(), 4);
assert!(matches!(
&fetched[0],
@@ -779,7 +789,9 @@ mod tests {
],
)
.unwrap();
- let bulk = db.bulk_get_attrs(vec![key("b"), key("c"), key("missing")]);
+ let bulk = db
+ .bulk_get_attrs(vec![key("b"), key("c"), key("missing")])
+ .unwrap();
assert_eq!(bulk.len(), 3);
assert!(matches!(
bulk[0].as_deref(),
@@ -788,7 +800,7 @@ mod tests {
assert!(bulk[1].is_none());
assert!(bulk[2].is_none());
db.add_vector(key("a"), basis(0)).unwrap();
- assert!(db.get_attrs(key("a")).is_none());
+ assert!(db.get_attrs(key("a")).unwrap().is_none());
assert!(matches!(
db.add_vector_with_attrs(
key("a"),
@@ -885,7 +897,7 @@ mod tests {
let max_abs = vector
.iter()
.fold(0.0f32, |acc, value| acc.max(value.abs()));
- let fetched = db.bulk_get_vectors(vec![key("a"), key("missing")]);
+ let fetched = db.bulk_get_vectors(vec![key("a"), key("missing")]).unwrap();
assert!(fetched[1].is_none());
for (restored, original) in fetched[0].as_ref().unwrap().iter().zip(&vector) {
assert!((restored - original).abs() <= max_abs / 254.0 + 1.0e-6);
diff --git a/rust/crates/vecdb/src/store.rs b/rust/crates/vecdb/src/store.rs
index 75dfb61af4..32423db79d 100644
--- a/rust/crates/vecdb/src/store.rs
+++ b/rust/crates/vecdb/src/store.rs
@@ -618,30 +618,38 @@ impl VecDb {
Ok(count)
}
- pub fn contains(&self, key: &str) -> bool {
- self.shared.state_read().arena.slot_of_key(key).is_some()
+ pub fn contains(&self, key: &str) -> Result<bool, VecDbError> {
+ Ok(self.open_state()?.arena.slot_of_key(key).is_some())
}
- pub fn get(&self, key: &str) -> Option<Vec<f32>> {
- let st = self.shared.state_read();
- let slot = st.arena.slot_of_key(key)?;
- Some(st.arena.vector_values(slot))
+ pub fn get(&self, key: &str) -> Result<Option<Vec<f32>>, VecDbError> {
+ let st = self.open_state()?;
+ Ok(st
+ .arena
+ .slot_of_key(key)
+ .map(|slot| st.arena.vector_values(slot)))
}
- pub fn get_attrs(&self, key: &str) -> Option<Vec<Attribute>> {
- let st = self.shared.state_read();
- let slot = st.arena.slot_of_key(key)?;
- st.attrs.get(slot).map(<[Attribute]>::to_vec)
+ pub fn get_attrs(&self, key: &str) -> Result<Option<Vec<Attribute>>, VecDbError> {
+ let st = self.open_state()?;
+ Ok(st
+ .arena
+ .slot_of_key(key)
+ .and_then(|slot| st.attrs.get(slot).map(<[Attribute]>::to_vec)))
}
- pub fn bulk_get_attrs(&self, keys: &[String]) -> Vec<Option<Vec<Attribute>>> {
- let st = self.shared.state_read();
- keys.iter()
+ pub fn bulk_get_attrs(
+ &self,
+ keys: &[String],
+ ) -> Result<Vec<Option<Vec<Attribute>>>, VecDbError> {
+ let st = self.open_state()?;
+ Ok(keys
+ .iter()
.map(|key| {
let slot = st.arena.slot_of_key(key)?;
st.attrs.get(slot).map(<[Attribute]>::to_vec)
})
- .collect()
+ .collect())
}
pub fn search(&self, query: &[f32], params: &SearchParams) -> Result<Vec<Match>, VecDbError> {
@@ -882,12 +890,19 @@ impl VecDb {
})
}
- pub fn len(&self) -> usize {
- self.shared.state_read().arena.live_count()
+ pub fn len(&self) -> Result<usize, VecDbError> {
+ Ok(self.open_state()?.arena.live_count())
+ }
+
+ pub fn is_empty(&self) -> Result<bool, VecDbError> {
+ Ok(self.open_state()?.arena.is_empty())
}
- pub fn is_empty(&self) -> bool {
- self.shared.state_read().arena.is_empty()
+ fn open_state(&self) -> Result<RwLockReadGuard<'_, SearchState>, VecDbError> {
+ self.shared.ensure_open()?;
+ let st = self.shared.state_read();
+ self.shared.ensure_open()?;
+ Ok(st)
}
fn writable_half(&self) -> Result<MutexGuard<'_, WriterHalf>, VecDbError> {
@@ -1750,7 +1765,7 @@ mod tests {
for open in [VecDb::open, VecDb::open_read_only] {
let reopened = open(&path, 32, None).unwrap();
assert_eq!(reopened.stats().unwrap().storage, StorageKind::I8);
- assert!(reopened.contains("kept"));
+ assert!(reopened.contains("kept").unwrap());
}
};
verify();
@@ -1817,7 +1832,7 @@ mod tests {
assert_eq!(fs::read(snapshot_path(&path)).unwrap(), snapshot_before);
let reopened = open(&path, 32, Some(storage)).unwrap();
assert_eq!(reopened.stats().unwrap().storage, storage);
- assert!(reopened.contains("kept"));
+ assert!(reopened.contains("kept").unwrap());
if let Some(live) = live {
assert!(Arc::ptr_eq(&live.shared, &reopened.shared));
}
@@ -1843,7 +1858,7 @@ mod tests {
let stats = reader.stats().unwrap();
assert_eq!(stats.dims, dims);
assert_eq!(stats.storage, storage);
- assert!(reader.is_empty());
+ assert!(reader.is_empty().unwrap());
assert!(matches!(
reader.add("no", &seeded_unit_vector(1, dims)),
Err(VecDbError::ReadOnly)
@@ -1859,7 +1874,7 @@ mod tests {
writer.add("kept", &seeded_unit_vector(1, dims)).unwrap();
drop(writer);
let reopened = VecDb::open_read_only(&path, dims, Some(storage)).unwrap();
- assert!(reopened.contains("kept"));
+ assert!(reopened.contains("kept").unwrap());
assert_eq!(reopened.stats().unwrap().storage, storage);
}
}
@@ -1950,7 +1965,7 @@ mod tests {
.all(|found| found.distance == 1.0)
);
}
- assert_eq!(db.get("aligned").unwrap(), vector(2.0, 0.0));
+ assert_eq!(db.get("aligned").unwrap().unwrap(), vector(2.0, 0.0));
}
}
@@ -2137,6 +2152,27 @@ mod tests {
assert!(matches[0].distance.abs() < 1.0e-3);
}
+ fn assert_key_reads_open(db: &VecDb, key: &str, live: usize) {
+ assert_eq!(db.len().unwrap(), live);
+ assert!(!db.is_empty().unwrap());
+ assert!(db.contains(key).unwrap());
+ assert!(db.get(key).unwrap().is_some());
+ assert!(db.get_attrs(key).unwrap().is_none());
+ assert_eq!(db.bulk_get_attrs(&[key.to_string()]).unwrap(), vec![None]);
+ }
+
+ fn assert_key_reads_closed(db: &VecDb) {
+ assert!(matches!(db.contains("key-0"), Err(VecDbError::Closed)));
+ assert!(matches!(db.get("key-0"), Err(VecDbError::Closed)));
+ assert!(matches!(db.get_attrs("key-0"), Err(VecDbError::Closed)));
+ assert!(matches!(
+ db.bulk_get_attrs(&["key-0".to_string()]),
+ Err(VecDbError::Closed)
+ ));
+ assert!(matches!(db.len(), Err(VecDbError::Closed)));
+ assert!(matches!(db.is_empty(), Err(VecDbError::Closed)));
+ }
+
fn search_shapes(allowed: Vec<String>) -> Vec<SearchParams> {
vec![
SearchParams {
@@ -2190,14 +2226,17 @@ mod tests {
let db = open_writer(&path);
bulk_add(&db, &bulk_entries(0, 150, 100)).unwrap();
db.add("probe", &probe).unwrap();
- assert_eq!(db.len(), 151);
- assert!(!db.is_empty());
- assert!(db.contains("probe"));
- assert!(db.contains("key-42"));
- assert!(!db.contains("key-999"));
- assert_eq!(db.get("probe").unwrap(), probe);
- assert_eq!(db.get("key-7").unwrap(), seeded_unit_vector(107, DIMS));
- assert!(db.get("missing").is_none());
+ assert_eq!(db.len().unwrap(), 151);
+ assert!(!db.is_empty().unwrap());
+ assert!(db.contains("probe").unwrap());
+ assert!(db.contains("key-42").unwrap());
+ assert!(!db.contains("key-999").unwrap());
+ assert_eq!(db.get("probe").unwrap().unwrap(), probe);
+ assert_eq!(
+ db.get("key-7").unwrap().unwrap(),
+ seeded_unit_vector(107, DIMS)
+ );
+ assert!(db.get("missing").unwrap().is_none());
let stats = db.stats().unwrap();
assert_eq!(stats.live_count, 151);
assert_eq!(stats.dead_count, 0);
@@ -2239,8 +2278,8 @@ mod tests {
index += 1;
}
}
- assert_eq!(reopened.len(), 151);
- assert_eq!(read_only.len(), 151);
+ assert_eq!(reopened.len().unwrap(), 151);
+ assert_eq!(read_only.len().unwrap(), 151);
}
#[test]
@@ -2306,10 +2345,10 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 6, 40)).unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 10);
+ assert_eq!(reopened.len().unwrap(), 10);
for index in 0..4u64 {
assert_eq!(
- reopened.get(&format!("solo-{index}")).unwrap(),
+ reopened.get(&format!("solo-{index}")).unwrap().unwrap(),
seeded_unit_vector(index, DIMS)
);
}
@@ -2326,16 +2365,16 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 6, 60)).unwrap();
fs::copy(&path, &copy).unwrap();
let copied = open_writer(&copy);
- assert_eq!(copied.len(), 6);
+ assert_eq!(copied.len().unwrap(), 6);
for index in 0..6 {
assert_eq!(
- copied.get(&format!("key-{index}")).unwrap(),
+ copied.get(&format!("key-{index}")).unwrap().unwrap(),
seeded_unit_vector(60 + index as u64, DIMS)
);
}
db.add("late", &seeded_unit_vector(999, DIMS)).unwrap();
- assert!(db.contains("late"));
- assert!(!copied.contains("late"));
+ assert!(db.contains("late").unwrap());
+ assert!(!copied.contains("late").unwrap());
}
#[test]
@@ -2350,7 +2389,7 @@ mod tests {
bytes.extend_from_slice(&[0xFF; 41]);
fs::write(&path, &bytes).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 4);
+ assert_eq!(reopened.len().unwrap(), 4);
assert_own_nearest(&reopened, "key-1", &seeded_unit_vector(21, DIMS));
drop(reopened);
assert_eq!(fs::metadata(&path).unwrap().len(), clean_len);
@@ -2369,8 +2408,8 @@ mod tests {
bytes.extend_from_slice(&[1, 6, 0, b'a', b'b']);
fs::write(&path, &bytes).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 4);
- assert!(reopened.contains("key-3"));
+ assert_eq!(reopened.len().unwrap(), 4);
+ assert!(reopened.contains("key-3").unwrap());
drop(reopened);
assert_eq!(fs::metadata(&path).unwrap().len(), clean_len);
}
@@ -2408,8 +2447,8 @@ mod tests {
assert_corrupt_open_preserves(&path);
fs::write(&path, &clean).unwrap();
let recovered = open_writer(&path);
- assert_eq!(recovered.len(), 2);
- assert!(recovered.contains("second"));
+ assert_eq!(recovered.len().unwrap(), 2);
+ assert!(recovered.contains("second").unwrap());
}
#[test]
@@ -2532,7 +2571,7 @@ mod tests {
assert_corrupt_open_preserves(&path);
fs::write(&path, &clean).unwrap();
let recovered = open_writer(&path);
- assert_eq!(recovered.len(), 5);
+ assert_eq!(recovered.len().unwrap(), 5);
assert_own_nearest(&recovered, "key-1", &seeded_unit_vector(301, DIMS));
}
@@ -2565,7 +2604,7 @@ mod tests {
assert_corrupt_open_preserves(&path);
assert!(!snapshot_exists(&path));
fs::write(&path, &clean).unwrap();
- assert_eq!(open_writer(&path).len(), 4);
+ assert_eq!(open_writer(&path).len().unwrap(), 4);
}
#[test]
@@ -2613,13 +2652,13 @@ mod tests {
bytes[last_start + 10] ^= 0x01;
fs::write(&path, &bytes).unwrap();
let read_only = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
- assert_eq!(read_only.len(), 3);
- assert!(!read_only.contains("key-3"));
+ assert_eq!(read_only.len().unwrap(), 3);
+ assert!(!read_only.contains("key-3").unwrap());
drop(read_only);
assert_eq!(fs::read(&path).unwrap(), bytes);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 3);
- assert!(!reopened.contains("key-3"));
+ assert_eq!(reopened.len().unwrap(), 3);
+ assert!(!reopened.contains("key-3").unwrap());
assert_own_nearest(&reopened, "key-2", &seeded_unit_vector(382, DIMS));
drop(reopened);
assert_eq!(fs::metadata(&path).unwrap().len(), last_start as u64);
@@ -2651,7 +2690,7 @@ mod tests {
assert_eq!(fs::read(&path).unwrap(), bytes);
assert_eq!(fs::read(snapshot_path(&path)).unwrap(), snapshot_bytes);
fs::write(&path, &clean).unwrap();
- assert_eq!(open_writer(&path).len(), 3);
+ assert_eq!(open_writer(&path).len().unwrap(), 3);
}
#[test]
@@ -2664,7 +2703,7 @@ mod tests {
drop(db);
fs::remove_file(snapshot_path(&path)).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 8);
+ assert_eq!(reopened.len().unwrap(), 8);
assert_own_nearest(&reopened, "key-5", &seeded_unit_vector(55, DIMS));
assert!(snapshot_exists(&path));
}
@@ -2680,14 +2719,14 @@ mod tests {
let stale_snapshot = fs::read(snapshot_path(&path)).unwrap();
fs::remove_file(&path).unwrap();
let db = open_writer(&path);
- assert!(db.is_empty());
+ assert!(db.is_empty().unwrap());
db.add("fresh", &seeded_unit_vector(1, DIMS)).unwrap();
drop(db);
fs::write(snapshot_path(&path), &stale_snapshot).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
- assert!(reopened.contains("fresh"));
- assert!(!reopened.contains("key-0"));
+ assert_eq!(reopened.len().unwrap(), 1);
+ assert!(reopened.contains("fresh").unwrap());
+ assert!(!reopened.contains("key-0").unwrap());
assert_own_nearest(&reopened, "fresh", &seeded_unit_vector(1, DIMS));
}
@@ -2703,7 +2742,7 @@ mod tests {
bytes[20] ^= 0x5A;
fs::write(snapshot_path(&path), &bytes).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 5);
+ assert_eq!(reopened.len().unwrap(), 5);
assert_own_nearest(&reopened, "key-4", &seeded_unit_vector(94, DIMS));
}
@@ -2718,13 +2757,13 @@ mod tests {
fs::write(temp_sibling(&path), [0xAB; 100]).unwrap();
let db = open_writer(&path);
assert!(!temp_sibling(&path).exists());
- assert_eq!(db.len(), 5);
+ assert_eq!(db.len().unwrap(), 5);
drop(db);
fs::copy(&path, temp_sibling(&path)).unwrap();
let db = open_writer(&path);
assert!(!temp_sibling(&path).exists());
- assert_eq!(db.len(), 5);
- assert!(db.contains("key-2"));
+ assert_eq!(db.len().unwrap(), 5);
+ assert!(db.contains("key-2").unwrap());
}
#[test]
@@ -2735,9 +2774,9 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 3, 120)).unwrap();
let joined = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(Arc::ptr_eq(&db.shared, &joined.shared));
- assert_eq!(joined.len(), 3);
+ assert_eq!(joined.len().unwrap(), 3);
joined.add("joined", &seeded_unit_vector(9, DIMS)).unwrap();
- assert!(db.contains("joined"));
+ assert!(db.contains("joined").unwrap());
assert!(matches!(
WriterLock::acquire(&path),
Err(VecDbError::Locked(_))
@@ -2745,8 +2784,8 @@ mod tests {
drop(db);
drop(joined);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 4);
- assert!(reopened.contains("joined"));
+ assert_eq!(reopened.len().unwrap(), 4);
+ assert!(reopened.contains("joined").unwrap());
}
#[test]
@@ -2759,15 +2798,15 @@ mod tests {
let via_first = seeded_unit_vector(11, DIMS);
let via_second = seeded_unit_vector(22, DIMS);
first.add("via-first", &via_first).unwrap();
- assert!(second.contains("via-first"));
- assert_eq!(second.get("via-first").unwrap(), via_first);
+ assert!(second.contains("via-first").unwrap());
+ assert_eq!(second.get("via-first").unwrap().unwrap(), via_first);
assert_eq!(
second.search(&via_first, &limit_params(1)).unwrap()[0].key,
"via-first"
);
second.add("via-second", &via_second).unwrap();
- assert!(first.contains("via-second"));
- assert_eq!(first.len(), 2);
+ assert!(first.contains("via-second").unwrap());
+ assert_eq!(first.len().unwrap(), 2);
assert!(matches!(
VecDb::open(&path, DIMS + 8, Some(StorageKind::F32)),
Err(VecDbError::DimensionMismatch {
@@ -2795,14 +2834,14 @@ mod tests {
let reader = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
first.add("first", &basis_vector(0)).unwrap();
second.add("second", &basis_vector(1)).unwrap();
- assert!(reader.contains("first"));
- assert!(reader.contains("second"));
+ assert!(reader.contains("first").unwrap());
+ assert!(reader.contains("second").unwrap());
drop(reader);
drop(second);
drop(first);
let reopened = open_writer(&path);
- assert!(reopened.contains("first"));
- assert!(reopened.contains("second"));
+ assert!(reopened.contains("first").unwrap());
+ assert!(reopened.contains("second").unwrap());
}
#[cfg(unix)]
@@ -2827,10 +2866,11 @@ mod tests {
VecDb::open_read_only(&alias, I8_DIMS, Some(StorageKind::I8))
.unwrap()
.is_empty()
+ .unwrap()
);
drop(holder);
let writer = open_writer(&alias);
- assert!(writer.is_empty());
+ assert!(writer.is_empty().unwrap());
writer.add("first", &basis_vector(0)).unwrap();
}
@@ -2849,11 +2889,11 @@ mod tests {
let result = VecDb::open(&path, DIMS, Some(StorageKind::F32));
assert!(matches!(result, Err(VecDbError::Locked(_))));
let reader = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
- assert!(reader.contains("first"));
+ assert!(reader.contains("first").unwrap());
}
"write" => {
let writer = open_writer(&path);
- assert!(writer.contains("first"));
+ assert!(writer.contains("first").unwrap());
writer.add("next", &basis_vector(1)).unwrap();
}
action => panic!("unexpected hard-link test action: {action}"),
@@ -2890,13 +2930,13 @@ mod tests {
first.add("first", &basis_vector(0)).unwrap();
fs::hard_link(&path, &alias).unwrap();
run_hard_link_writer_process(&alias, "blocked");
- assert_eq!(first.len(), 1);
+ assert_eq!(first.len().unwrap(), 1);
drop(first);
run_hard_link_writer_process(&alias, "write");
let reader = VecDb::open_read_only(&alias, DIMS, Some(StorageKind::F32)).unwrap();
- assert_eq!(reader.len(), 2);
- assert!(reader.contains("first"));
- assert!(reader.contains("next"));
+ assert_eq!(reader.len().unwrap(), 2);
+ assert!(reader.contains("first").unwrap());
+ assert!(reader.contains("next").unwrap());
}
#[cfg(unix)]
@@ -2927,17 +2967,17 @@ mod tests {
Err(VecDbError::Locked(_))
));
let reader = VecDb::open_read_only(&alias, DIMS, Some(StorageKind::F32)).unwrap();
- assert!(reader.contains("first"));
+ assert!(reader.contains("first").unwrap());
drop(reader);
run_hard_link_writer_process(&alias, "blocked");
first.add("after", &basis_vector(2)).unwrap();
drop(first);
run_hard_link_writer_process(&alias, "write");
let reopened = open_writer(&alias);
- assert_eq!(reopened.len(), 3);
- assert!(reopened.contains("first"));
- assert!(reopened.contains("after"));
- assert!(reopened.contains("next"));
+ assert_eq!(reopened.len().unwrap(), 3);
+ assert!(reopened.contains("first").unwrap());
+ assert!(reopened.contains("after").unwrap());
+ assert!(reopened.contains("next").unwrap());
}
}
}
@@ -2952,9 +2992,9 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 10, 800)).unwrap();
fs::hard_link(&path, &alias).unwrap();
let observer = VecDb::open_read_only(&alias, DIMS, Some(StorageKind::F32)).unwrap();
- assert_eq!(observer.len(), 10);
+ assert_eq!(observer.len().unwrap(), 10);
compact(&db.shared, &mut db.shared.writer_half()).unwrap();
- assert_eq!(db.len(), 10);
+ assert_eq!(db.len().unwrap(), 10);
fs::remove_file(&alias).unwrap();
fs::hard_link(&path, &alias).unwrap();
assert!(matches!(
@@ -2969,8 +3009,8 @@ mod tests {
VecDb::open(&alias, DIMS, Some(StorageKind::F32)),
Err(VecDbError::Locked(_))
));
- assert_eq!(db.len(), 1);
- assert_eq!(observer.len(), 10);
+ assert_eq!(db.len().unwrap(), 1);
+ assert_eq!(observer.len().unwrap(), 10);
}
#[test]
@@ -2985,8 +3025,8 @@ mod tests {
assert!(Arc::ptr_eq(&first.shared, &second.shared));
let vector = seeded_unit_vector(5, DIMS);
first.add("shared", &vector).unwrap();
- assert!(second.contains("shared"));
- assert_eq!(second.get("shared").unwrap(), vector);
+ assert!(second.contains("shared").unwrap());
+ assert_eq!(second.get("shared").unwrap().unwrap(), vector);
}
#[test]
@@ -2997,7 +3037,7 @@ mod tests {
let second = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
first.add("kept", &seeded_unit_vector(3, DIMS)).unwrap();
drop(first);
- assert!(second.contains("kept"));
+ assert!(second.contains("kept").unwrap());
second
.add("still-open", &seeded_unit_vector(4, DIMS))
.unwrap();
@@ -3005,9 +3045,9 @@ mod tests {
let key = registry_key_for(&path).unwrap();
assert!(!registry().contains_key(&key));
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 2);
- assert!(reopened.contains("kept"));
- assert!(reopened.contains("still-open"));
+ assert_eq!(reopened.len().unwrap(), 2);
+ assert!(reopened.contains("kept").unwrap());
+ assert!(reopened.contains("still-open").unwrap());
let again = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(Arc::ptr_eq(&reopened.shared, &again.shared));
}
@@ -3029,7 +3069,7 @@ mod tests {
barrier.wait();
for _ in 0..CYCLES {
let db = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
- assert!(db.contains("seed"));
+ assert!(db.contains("seed").unwrap());
drop(db);
}
})
@@ -3039,7 +3079,7 @@ mod tests {
churner.join().unwrap();
}
let reopened = open_writer(&path);
- assert!(reopened.contains("seed"));
+ assert!(reopened.contains("seed").unwrap());
}
#[test]
@@ -3133,7 +3173,7 @@ mod tests {
reopened
.add("fresh", &seeded_unit_vector(78, DIMS))
.unwrap();
- assert_eq!(reopened.len(), 1);
+ assert_eq!(reopened.len().unwrap(), 1);
assert!(lock_slot(&slot).holds_live());
}
@@ -3151,7 +3191,7 @@ mod tests {
assert!(lock_slot(&slot).live.is_none());
let fresh = open_writer(&path);
fresh.add("anew", &seeded_unit_vector(79, DIMS)).unwrap();
- assert_eq!(fresh.len(), 1);
+ assert_eq!(fresh.len().unwrap(), 1);
}
#[test]
@@ -3181,7 +3221,7 @@ mod tests {
reopened
.add("fresh", &seeded_unit_vector(81, DIMS))
.unwrap();
- assert_eq!(reopened.len(), 1);
+ assert_eq!(reopened.len().unwrap(), 1);
}
}
@@ -3221,7 +3261,7 @@ mod tests {
.collect();
let other = open_writer(&other_path);
other.add("other", &seeded_unit_vector(1, DIMS)).unwrap();
- assert_eq!(other.len(), 1);
+ assert_eq!(other.len().unwrap(), 1);
drop(build_in_progress);
let handles: Vec<VecDb> = stalled_openers
.into_iter()
@@ -3232,8 +3272,8 @@ mod tests {
handles[0]
.add("stalled", &seeded_unit_vector(2, DIMS))
.unwrap();
- assert!(handles[1].contains("stalled"));
- assert!(!other.contains("stalled"));
+ assert!(handles[1].contains("stalled").unwrap());
+ assert!(!other.contains("stalled").unwrap());
}
#[test]
@@ -3267,9 +3307,9 @@ mod tests {
db.add("post", &seeded_unit_vector(7, DIMS)).unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 57);
- assert!(reopened.contains("post"));
- assert!(!reopened.contains("key-0"));
+ assert_eq!(reopened.len().unwrap(), 57);
+ assert!(reopened.contains("post").unwrap());
+ assert!(!reopened.contains("key-0").unwrap());
}
#[test]
@@ -3285,8 +3325,8 @@ mod tests {
));
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
- assert!(reopened.contains("fresh"));
+ assert_eq!(reopened.len().unwrap(), 1);
+ assert!(reopened.contains("fresh").unwrap());
}
#[test]
@@ -3297,12 +3337,12 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 3, 130)).unwrap();
let read_only = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(Arc::ptr_eq(&db.shared, &read_only.shared));
- assert_eq!(read_only.len(), 3);
- assert!(read_only.contains("key-1"));
+ assert_eq!(read_only.len().unwrap(), 3);
+ assert!(read_only.contains("key-1").unwrap());
let later = seeded_unit_vector(9, DIMS);
db.add("later", &later).unwrap();
- assert!(read_only.contains("later"));
- assert_eq!(read_only.get("later").unwrap(), later);
+ assert!(read_only.contains("later").unwrap());
+ assert_eq!(read_only.get("later").unwrap().unwrap(), later);
assert_own_nearest(&read_only, "later", &later);
assert!(matches!(
read_only.add("x", &later),
@@ -3320,7 +3360,7 @@ mod tests {
assert!(matches!(read_only.reset(), Err(VecDbError::ReadOnly)));
let another = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(matches!(another.delete(), Err(VecDbError::ReadOnly)));
- assert!(db.contains("later"));
+ assert!(db.contains("later").unwrap());
assert!(path.exists());
}
@@ -3330,10 +3370,10 @@ mod tests {
let dir = TempDir::new().unwrap();
let path = dir.path().join("absent");
let db = VecDb::open_read_only(&path, DIMS, Some(StorageKind::I8)).unwrap();
- assert_eq!(db.len(), 0);
- assert!(db.is_empty());
- assert!(!db.contains("anything"));
- assert!(db.get("anything").is_none());
+ assert_eq!(db.len().unwrap(), 0);
+ assert!(db.is_empty().unwrap());
+ assert!(!db.contains("anything").unwrap());
+ assert!(db.get("anything").unwrap().is_none());
assert!(
db.search(&seeded_unit_vector(1, DIMS), &limit_params(3))
.unwrap()
@@ -3387,7 +3427,7 @@ mod tests {
));
assert!(matches!(read_only.flush(), Err(VecDbError::ReadOnly)));
assert!(matches!(read_only.reset(), Err(VecDbError::ReadOnly)));
- assert!(read_only.contains("kept"));
+ assert!(read_only.contains("kept").unwrap());
assert!(matches!(read_only.delete(), Err(VecDbError::ReadOnly)));
assert!(path.exists());
}
@@ -3400,7 +3440,7 @@ mod tests {
bulk_add(&db, &bulk_entries(0, 100, 140)).unwrap();
drop(db);
let snapshot_view = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
- assert_eq!(snapshot_view.len(), 100);
+ assert_eq!(snapshot_view.len().unwrap(), 100);
let db = open_writer(&path);
assert!(!Arc::ptr_eq(&snapshot_view.shared, &db.shared));
let generation_before = generation_of(&path);
@@ -3408,22 +3448,22 @@ mod tests {
assert!(db.remove(&format!("key-{index}")).unwrap());
}
assert_ne!(generation_of(&path), generation_before);
- assert_eq!(db.len(), 68);
+ assert_eq!(db.len().unwrap(), 68);
assert_eq!(db.stats().unwrap().dead_count, 0);
db.add("fresh", &seeded_unit_vector(7, DIMS)).unwrap();
assert_own_nearest(&db, "key-50", &seeded_unit_vector(190, DIMS));
- assert_eq!(snapshot_view.len(), 100);
- assert!(snapshot_view.contains("key-5"));
- assert!(!snapshot_view.contains("fresh"));
+ assert_eq!(snapshot_view.len().unwrap(), 100);
+ assert!(snapshot_view.contains("key-5").unwrap());
+ assert!(!snapshot_view.contains("fresh").unwrap());
assert_own_nearest(&snapshot_view, "key-5", &seeded_unit_vector(145, DIMS));
let live_view = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(Arc::ptr_eq(&live_view.shared, &db.shared));
- assert!(live_view.contains("fresh"));
+ assert!(live_view.contains("fresh").unwrap());
drop(db);
let fresh_view = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
- assert_eq!(fresh_view.len(), 69);
- assert!(!fresh_view.contains("key-5"));
- assert!(fresh_view.contains("fresh"));
+ assert_eq!(fresh_view.len().unwrap(), 69);
+ assert!(!fresh_view.contains("key-5").unwrap());
+ assert!(fresh_view.contains("fresh").unwrap());
}
#[test]
@@ -3439,8 +3479,8 @@ mod tests {
let query = basis_vector(0);
assert_own_nearest(&db, "near", &query);
db.add("near", &negated(&basis_vector(0))).unwrap();
- assert_eq!(db.len(), 11);
- assert_eq!(db.get("near").unwrap(), negated(&basis_vector(0)));
+ assert_eq!(db.len().unwrap(), 11);
+ assert_eq!(db.get("near").unwrap().unwrap(), negated(&basis_vector(0)));
let checks = |db: &VecDb| {
assert_ne!(db.search(&query, &limit_params(1)).unwrap()[0].key, "near");
let exact = SearchParams {
@@ -3460,7 +3500,10 @@ mod tests {
checks(&db);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.get("near").unwrap(), negated(&basis_vector(0)));
+ assert_eq!(
+ reopened.get("near").unwrap().unwrap(),
+ negated(&basis_vector(0))
+ );
checks(&reopened);
}
@@ -3476,9 +3519,9 @@ mod tests {
assert_own_nearest(&db, "key-4", &query);
assert!(db.remove("key-4").unwrap());
assert!(!db.remove("key-4").unwrap());
- assert_eq!(db.len(), 9);
- assert!(!db.contains("key-4"));
- assert!(db.get("key-4").is_none());
+ assert_eq!(db.len().unwrap(), 9);
+ assert!(!db.contains("key-4").unwrap());
+ assert!(db.get("key-4").unwrap().is_none());
assert_eq!(db.stats().unwrap().dead_count, 2);
assert_ne!(db.search(&query, &limit_params(1)).unwrap()[0].key, "key-4");
let exact_all = SearchParams {
@@ -3501,11 +3544,11 @@ mod tests {
};
assert!(db.search(&query, &filtered).unwrap().is_empty());
db.add("key-4", &basis_vector(4)).unwrap();
- assert_eq!(db.len(), 10);
+ assert_eq!(db.len().unwrap(), 10);
assert_own_nearest(&db, "key-4", &query);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 10);
+ assert_eq!(reopened.len().unwrap(), 10);
assert_own_nearest(&reopened, "key-4", &query);
}
@@ -3525,9 +3568,9 @@ mod tests {
"nope".to_string(),
];
assert_eq!(db.bulk_remove(&removals).unwrap(), 2);
- assert_eq!(db.len(), 3);
- assert!(!db.contains("key-1"));
- assert!(!db.contains("key-3"));
+ assert_eq!(db.len().unwrap(), 3);
+ assert!(!db.contains("key-1").unwrap());
+ assert!(!db.contains("key-3").unwrap());
assert_eq!(
db.stats().unwrap().log_bytes,
log_bytes + 2 * TOMBSTONE_RECORD_LEN
@@ -3709,9 +3752,9 @@ mod tests {
}
};
let verify = |db: &VecDb| {
- assert_eq!(db.len(), 90);
+ assert_eq!(db.len().unwrap(), 90);
for index in 90..120 {
- assert!(!db.contains(&format!("key-{index}")));
+ assert!(!db.contains(&format!("key-{index}")).unwrap());
}
for index in 0..90u64 {
assert_own_nearest(db, &format!("key-{index}"), &live_vector(index));
@@ -3755,9 +3798,9 @@ mod tests {
}
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1042);
- assert!(!reopened.contains("key-0"));
- assert!(reopened.contains("key-58"));
+ assert_eq!(reopened.len().unwrap(), 1042);
+ assert!(!reopened.contains("key-0").unwrap());
+ assert!(reopened.contains("key-58").unwrap());
}
#[test]
@@ -3840,7 +3883,7 @@ mod tests {
assert!(st.graph.is_none());
assert_eq!(st.arena.slot_count(), 180);
}
- assert_eq!(db.len(), 180);
+ assert_eq!(db.len().unwrap(), 180);
assert_eq!(db.search(&query, &approx).unwrap(), expected);
assert_eq!(db.search(&query, &exact).unwrap(), expected);
assert_eq!(
@@ -3856,12 +3899,12 @@ mod tests {
for index in 0..200i64 {
let key = format!("key-{index}");
if index % 9 == 0 && index <= 171 {
- assert!(!db.contains(&key));
- assert_eq!(db.get_attrs(&key), None);
+ assert!(!db.contains(&key).unwrap());
+ assert_eq!(db.get_attrs(&key).unwrap(), None);
} else if index % 3 == 0 {
- assert_eq!(db.get_attrs(&key).unwrap(), sample_attrs(index));
+ assert_eq!(db.get_attrs(&key).unwrap().unwrap(), sample_attrs(index));
} else {
- assert_eq!(db.get_attrs(&key), None);
+ assert_eq!(db.get_attrs(&key).unwrap(), None);
}
}
}
@@ -3880,10 +3923,10 @@ mod tests {
drop(db);
fs::write(snapshot_path(&path), &stale_snapshot).unwrap();
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 56);
+ assert_eq!(reopened.len().unwrap(), 56);
for index in 64..120u64 {
assert_eq!(
- reopened.get(&format!("key-{index}")).unwrap(),
+ reopened.get(&format!("key-{index}")).unwrap().unwrap(),
seeded_unit_vector(210 + index, DIMS)
);
}
@@ -3902,12 +3945,12 @@ mod tests {
let partial = [0x45u8, 0x56, 0x44, 0x42, 0x01, 0x00, 0x00];
fs::write(&path, partial).unwrap();
let db = open_writer(&path);
- assert!(db.is_empty());
+ assert!(db.is_empty().unwrap());
assert_eq!(db.stats().unwrap().log_bytes, 32);
db.add("fresh", &seeded_unit_vector(11, DIMS)).unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
+ assert_eq!(reopened.len().unwrap(), 1);
assert_own_nearest(&reopened, "fresh", &seeded_unit_vector(11, DIMS));
}
@@ -3918,7 +3961,7 @@ mod tests {
let partial = [0x45u8, 0x56, 0x44, 0x42, 0x01, 0x00, 0x00];
fs::write(&path, partial).unwrap();
let db = VecDb::open_read_only(&path, I8_DIMS, Some(StorageKind::I8)).unwrap();
- assert!(db.is_empty());
+ assert!(db.is_empty().unwrap());
assert_eq!(db.stats().unwrap().log_bytes, 0);
assert_eq!(fs::read(&path).unwrap(), partial);
assert!(!snapshot_exists(&path));
@@ -3999,11 +4042,11 @@ mod tests {
WriterLock::acquire(&path),
Err(VecDbError::Locked(_))
));
- assert_eq!(db.len(), 4);
+ assert_eq!(db.len().unwrap(), 4);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 4);
- assert!(reopened.contains("after"));
+ assert_eq!(reopened.len().unwrap(), 4);
+ assert!(reopened.contains("after").unwrap());
}
#[test]
@@ -4029,13 +4072,13 @@ mod tests {
let mut half = db.shared.writer_half();
restore_writer_mode(&db.shared, &mut half, lock, None, 0, checkpoint).unwrap();
}
- assert!(db.contains("foreign"));
+ assert!(db.contains("foreign").unwrap());
assert_own_nearest(&db, "foreign", &basis_vector(1));
db.add("after", &basis_vector(2)).unwrap();
db.flush().unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 3);
+ assert_eq!(reopened.len().unwrap(), 3);
assert_own_nearest(&reopened, "foreign", &basis_vector(1));
}
@@ -4065,14 +4108,14 @@ mod tests {
let mut half = db.shared.writer_half();
restore_writer_mode(&db.shared, &mut half, lock, None, 0, checkpoint).unwrap();
}
- assert!(!db.contains("first"));
+ assert!(!db.contains("first").unwrap());
assert_own_nearest(&db, "other", &basis_vector(1));
db.add("after", &basis_vector(2)).unwrap();
db.flush().unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 2);
- assert!(!reopened.contains("first"));
+ assert_eq!(reopened.len().unwrap(), 2);
+ assert!(!reopened.contains("first").unwrap());
assert_own_nearest(&reopened, "other", &basis_vector(1));
}
@@ -4105,8 +4148,8 @@ mod tests {
foreign.add("after", &basis_vector(2)).unwrap();
drop(foreign);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 3);
- assert!(!reopened.contains("lost"));
+ assert_eq!(reopened.len().unwrap(), 3);
+ assert!(!reopened.contains("lost").unwrap());
assert_own_nearest(&reopened, "after", &basis_vector(2));
}
@@ -4177,9 +4220,9 @@ mod tests {
db.add("more", &seeded_unit_vector(2, DIMS)).unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 2);
- assert!(reopened.contains("seed"));
- assert!(reopened.contains("more"));
+ assert_eq!(reopened.len().unwrap(), 2);
+ assert!(reopened.contains("seed").unwrap());
+ assert!(reopened.contains("more").unwrap());
}
#[test]
@@ -4208,10 +4251,10 @@ mod tests {
assert_ne!(generation_of(&path), generation_before);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 37);
- assert!(reopened.contains("probe"));
- assert!(reopened.contains("key-64"));
- assert!(!reopened.contains("key-0"));
+ assert_eq!(reopened.len().unwrap(), 37);
+ assert!(reopened.contains("probe").unwrap());
+ assert!(reopened.contains("key-64").unwrap());
+ assert!(!reopened.contains("key-0").unwrap());
}
#[test]
@@ -4231,9 +4274,9 @@ mod tests {
assert_eq!(db.stats().unwrap().records_since_snapshot, 36);
drop(db);
let blocked = open_writer(&path);
- assert_eq!(blocked.len(), 36);
- assert!(blocked.contains("key-64"));
- assert!(!blocked.contains("key-0"));
+ assert_eq!(blocked.len().unwrap(), 36);
+ assert!(blocked.contains("key-64").unwrap());
+ assert!(!blocked.contains("key-0").unwrap());
assert_eq!(blocked.stats().unwrap().records_since_snapshot, 36);
fs::remove_dir(snapshot_path(&path)).unwrap();
blocked.flush().unwrap();
@@ -4241,7 +4284,7 @@ mod tests {
assert!(snapshot_exists(&path));
drop(blocked);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 36);
+ assert_eq!(reopened.len().unwrap(), 36);
assert_own_nearest(&reopened, "key-99", &seeded_unit_vector(970 + 99, DIMS));
}
@@ -4254,7 +4297,7 @@ mod tests {
drop(db);
fs::create_dir(snapshot_path(&path)).unwrap();
let db = open_writer(&path);
- assert_eq!(db.len(), 5);
+ assert_eq!(db.len().unwrap(), 5);
assert_own_nearest(&db, "key-2", &seeded_unit_vector(302, DIMS));
assert!(matches!(db.flush(), Err(VecDbError::Io { .. })));
drop(db);
@@ -4272,7 +4315,7 @@ mod tests {
db.flush().unwrap();
let generation_before = generation_of(&path);
db.reset().unwrap();
- assert!(db.is_empty());
+ assert!(db.is_empty().unwrap());
assert!(!snapshot_exists(&path));
assert_ne!(generation_of(&path), generation_before);
assert_eq!(fs::metadata(&path).unwrap().len(), 32);
@@ -4292,9 +4335,9 @@ mod tests {
assert_own_nearest(&db, "again", &seeded_unit_vector(2, DIMS));
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
- assert!(reopened.contains("again"));
- assert!(!reopened.contains("key-0"));
+ assert_eq!(reopened.len().unwrap(), 1);
+ assert!(reopened.contains("again").unwrap());
+ assert!(!reopened.contains("key-0").unwrap());
}
#[test]
@@ -4304,14 +4347,14 @@ mod tests {
let first = open_writer(&path);
let second = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
bulk_add(&first, &bulk_entries(0, 10, 220)).unwrap();
- assert_eq!(second.len(), 10);
+ assert_eq!(second.len().unwrap(), 10);
second.reset().unwrap();
- assert!(first.is_empty());
- assert!(!first.contains("key-0"));
+ assert!(first.is_empty().unwrap());
+ assert!(!first.contains("key-0").unwrap());
let fresh = seeded_unit_vector(6, DIMS);
first.add("fresh", &fresh).unwrap();
- assert!(second.contains("fresh"));
- assert_eq!(second.len(), 1);
+ assert!(second.contains("fresh").unwrap());
+ assert_eq!(second.len().unwrap(), 1);
assert_own_nearest(&second, "fresh", &fresh);
}
@@ -4324,9 +4367,9 @@ mod tests {
fs::create_dir(snapshot_path(&path)).unwrap();
assert!(matches!(db.reset(), Err(VecDbError::Io { .. })));
assert!(!path.exists());
- assert!(db.is_empty());
- assert_eq!(db.len(), 0);
- assert!(!db.contains("key-0"));
+ assert!(db.is_empty().unwrap());
+ assert_eq!(db.len().unwrap(), 0);
+ assert!(!db.contains("key-0").unwrap());
assert_eq!(db.stats().unwrap().log_bytes, 0);
let vector = seeded_unit_vector(1, DIMS);
assert!(matches!(db.add("x", &vector), Err(VecDbError::ReadOnly)));
@@ -4334,7 +4377,7 @@ mod tests {
drop(db);
fs::remove_dir(snapshot_path(&path)).unwrap();
let reopened = open_writer(&path);
- assert!(reopened.is_empty());
+ assert!(reopened.is_empty().unwrap());
}
#[cfg(unix)]
@@ -4352,15 +4395,15 @@ mod tests {
let Err(VecDbError::Io { .. }) = outcome else {
return;
};
- assert_eq!(db.len(), 5);
- assert!(db.contains("key-0"));
+ assert_eq!(db.len().unwrap(), 5);
+ assert!(db.contains("key-0").unwrap());
assert_eq!(db.stats().unwrap().records_since_snapshot, 5);
db.add("after", &seeded_unit_vector(6, DIMS)).unwrap();
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 6);
- assert!(reopened.contains("key-4"));
- assert!(reopened.contains("after"));
+ assert_eq!(reopened.len().unwrap(), 6);
+ assert!(reopened.contains("key-4").unwrap());
+ assert!(reopened.contains("after").unwrap());
}
#[test]
@@ -4382,17 +4425,17 @@ mod tests {
let mut half = db.shared.writer_half();
recover_after_failed_reset(&db.shared, &mut half, lock, old_checkpoint, 5);
}
- assert!(db.is_empty());
- assert!(!db.contains("key-0"));
+ assert!(db.is_empty().unwrap());
+ assert!(!db.contains("key-0").unwrap());
assert_eq!(db.stats().unwrap().log_bytes, 32);
assert_eq!(db.stats().unwrap().records_since_snapshot, 0);
db.add("fresh", &seeded_unit_vector(7, DIMS)).unwrap();
- assert_eq!(db.len(), 1);
+ assert_eq!(db.len().unwrap(), 1);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
- assert!(reopened.contains("fresh"));
- assert!(!reopened.contains("key-0"));
+ assert_eq!(reopened.len().unwrap(), 1);
+ assert!(reopened.contains("fresh").unwrap());
+ assert!(!reopened.contains("key-0").unwrap());
}
#[test]
@@ -4427,7 +4470,7 @@ mod tests {
fs::metadata(lock_path(&path)).unwrap().ino()
};
let reopened = open_writer(&path);
- assert!(reopened.is_empty());
+ assert!(reopened.is_empty().unwrap());
assert!(matches!(
WriterLock::acquire(&path),
Err(VecDbError::Locked(_))
@@ -4440,8 +4483,8 @@ mod tests {
reopened.add("fresh", &seeded_unit_vector(3, DIMS)).unwrap();
drop(reopened);
let third = open_writer(&path);
- assert_eq!(third.len(), 1);
- assert!(third.contains("fresh"));
+ assert_eq!(third.len().unwrap(), 1);
+ assert!(third.contains("fresh").unwrap());
assert!(lock_path(&path).exists());
}
@@ -4480,6 +4523,9 @@ mod tests {
first.flush().unwrap();
let survivor = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
let observer = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
+ assert_key_reads_open(&first, "key-0", 5);
+ assert_key_reads_open(&survivor, "key-0", 5);
+ assert_key_reads_open(&observer, "key-0", 5);
first.delete().unwrap();
assert!(!path.exists());
assert!(!snapshot_exists(&path));
@@ -4510,14 +4556,13 @@ mod tests {
observer.search(&query, &limit_params(3)),
Err(VecDbError::Closed)
));
- assert_eq!(survivor.len(), 0);
- assert!(!survivor.contains("key-0"));
- assert!(survivor.get("key-0").is_none());
+ assert_key_reads_closed(&survivor);
+ assert_key_reads_closed(&observer);
assert!(matches!(survivor.delete(), Err(VecDbError::Closed)));
let fresh = open_writer(&path);
- assert!(fresh.is_empty());
+ assert!(fresh.is_empty().unwrap());
fresh.add("anew", &query).unwrap();
- assert_eq!(fresh.len(), 1);
+ assert_key_reads_open(&fresh, "anew", 1);
}
#[test]
@@ -4547,7 +4592,7 @@ mod tests {
loop {
let found = handle.search(&query, &limit_params(8)).unwrap();
for entry in &found {
- let vector = handle.get(&entry.key).unwrap();
+ let vector = handle.get(&entry.key).unwrap().unwrap();
assert_eq!(&vector, expected.get(&entry.key).unwrap());
}
iterations += 1;
@@ -4581,13 +4626,13 @@ mod tests {
for reader in readers {
let (handle, iterations) = reader.join().unwrap();
assert!(iterations > 0);
- assert_eq!(handle.len(), 50 + BULK);
- assert!(handle.contains("key-0"));
- assert!(handle.contains(&format!("key-{}", BULK - 1)));
- assert!(handle.contains("key-10000"));
+ assert_eq!(handle.len().unwrap(), 50 + BULK);
+ assert!(handle.contains("key-0").unwrap());
+ assert!(handle.contains(&format!("key-{}", BULK - 1)).unwrap());
+ assert!(handle.contains("key-10000").unwrap());
}
assert!(flusher.join().unwrap() > 0);
- assert_eq!(writer.len(), 50 + BULK);
+ assert_eq!(writer.len().unwrap(), 50 + BULK);
assert_eq!(writer.stats().unwrap().live_count, 50 + BULK);
}
@@ -4634,8 +4679,8 @@ mod tests {
assert_eq!(stats.dead_count, 0);
assert_eq!(stats.live_count, 270);
assert_eq!(db.search(&query, &exact).unwrap(), before);
- assert!(!db.contains("key-0"));
- assert!(db.contains("key-30"));
+ assert!(!db.contains("key-0").unwrap());
+ assert!(db.contains("key-30").unwrap());
}
#[test]
@@ -4652,7 +4697,7 @@ mod tests {
db.add("bad", &bad),
Err(VecDbError::InvalidVector(_))
));
- assert!(!db.contains("bad"));
+ assert!(!db.contains("bad").unwrap());
}
let mut infected = bulk_entries(10, 3, 200);
infected[1].1[0] = f32::INFINITY;
@@ -4660,15 +4705,15 @@ mod tests {
bulk_add(&db, &infected),
Err(VecDbError::InvalidVector(_))
));
- assert_eq!(db.len(), 1);
- assert!(!db.contains("key-10"));
- assert!(!db.contains("key-12"));
+ assert_eq!(db.len().unwrap(), 1);
+ assert!(!db.contains("key-10").unwrap());
+ assert!(!db.contains("key-12").unwrap());
assert_eq!(db.stats().unwrap().log_bytes, log_bytes);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.len(), 1);
- assert!(reopened.contains("key-0"));
- assert!(!reopened.contains("bad"));
+ assert_eq!(reopened.len().unwrap(), 1);
+ assert!(reopened.contains("key-0").unwrap());
+ assert!(!reopened.contains("bad").unwrap());
}
#[test]
@@ -4683,8 +4728,8 @@ mod tests {
.map(|(key, vector)| (key, scaled(&vector, 0.5)))
.collect();
bulk_add(&db, &batch).unwrap();
- assert!(db.contains("half"));
- assert_eq!(db.len(), 4);
+ assert!(db.contains("half").unwrap());
+ assert_eq!(db.len().unwrap(), 4);
}
#[test]
@@ -4974,8 +5019,8 @@ mod tests {
vectors: 1
})
));
- assert_eq!(db.len(), 1);
- assert!(!db.contains("x"));
+ assert_eq!(db.len().unwrap(), 1);
+ assert!(!db.contains("x").unwrap());
assert_eq!(db.stats().unwrap().log_bytes, log_bytes);
let read_only = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(matches!(
@@ -4994,6 +5039,9 @@ mod tests {
fs::write(temp_sibling(&path), [7u8; 10]).unwrap();
let survivor = VecDb::open(&path, DIMS, Some(StorageKind::F32)).unwrap();
let observer = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
+ assert_key_reads_open(&first, "key-0", 5);
+ assert_key_reads_open(&survivor, "key-0", 5);
+ assert_key_reads_open(&observer, "key-0", 5);
VecDb::purge(&path).unwrap();
assert!(!path.exists());
assert!(!snapshot_exists(&path));
@@ -5030,11 +5078,14 @@ mod tests {
Err(VecDbError::Closed)
));
assert!(matches!(first.stats(), Err(VecDbError::Closed)));
+ assert_key_reads_closed(&first);
+ assert_key_reads_closed(&survivor);
+ assert_key_reads_closed(&observer);
assert!(matches!(survivor.delete(), Err(VecDbError::Closed)));
let fresh = open_writer(&path);
- assert!(fresh.is_empty());
+ assert!(fresh.is_empty().unwrap());
fresh.add("anew", &query).unwrap();
- assert_eq!(fresh.len(), 1);
+ assert_key_reads_open(&fresh, "anew", 1);
}
#[test]
@@ -5060,9 +5111,9 @@ mod tests {
VecDb::purge(&never_created).unwrap();
assert!(lock_path(&never_created).exists());
let fresh = open_writer(&path);
- assert!(fresh.is_empty());
+ assert!(fresh.is_empty().unwrap());
fresh.add("fresh", &seeded_unit_vector(3, DIMS)).unwrap();
- assert_eq!(fresh.len(), 1);
+ assert_eq!(fresh.len().unwrap(), 1);
}
#[test]
@@ -5104,14 +5155,14 @@ mod tests {
via_alias
.add("through-alias", &seeded_unit_vector(6, DIMS))
.unwrap();
- assert!(via_path.contains("through-alias"));
- assert!(via_alias.contains("through-real"));
- assert_eq!(via_path.len(), 2);
+ assert!(via_path.contains("through-alias").unwrap());
+ assert!(via_alias.contains("through-real").unwrap());
+ assert_eq!(via_path.len().unwrap(), 2);
assert!(lock_path(&path).exists());
assert!(!lock_path(&alias).exists());
let read_alias = VecDb::open_read_only(&alias, DIMS, Some(StorageKind::F32)).unwrap();
via_path.add("late", &seeded_unit_vector(7, DIMS)).unwrap();
- assert!(read_alias.contains("late"));
+ assert!(read_alias.contains("late").unwrap());
}
#[cfg(unix)]
@@ -5209,7 +5260,7 @@ mod tests {
assert_eq!(fs::read(&path).unwrap(), log_before);
assert_eq!(fs::read(snapshot_path(&path)).unwrap(), snapshot_before);
db.add("after", &seeded_unit_vector(7, DIMS)).unwrap();
- assert!(db.contains("after"));
+ assert!(db.contains("after").unwrap());
assert_own_nearest(&db, "after", &seeded_unit_vector(7, DIMS));
}
@@ -5291,14 +5342,14 @@ mod tests {
writer
})
};
- assert_eq!(joined.get("key-0").unwrap(), entries[0].1);
+ assert_eq!(joined.get("key-0").unwrap().unwrap(), entries[0].1);
assert!(!adder.is_finished());
assert!(!opener.is_finished());
drop(pin);
let opened = opener.join().unwrap();
assert!(snapshot_exists(&path));
let writer = adder.join().unwrap();
- assert_eq!(writer.get("key-0").unwrap(), replacement);
+ assert_eq!(writer.get("key-0").unwrap().unwrap(), replacement);
{
let st = joined.shared.state_read();
assert_eq!(
@@ -5350,23 +5401,23 @@ mod tests {
let db = open_writer(&dir.path().join("db"));
let vector = seeded_unit_vector(1, DIMS);
db.add_with_attrs("k", &vector, &sample_attrs(1)).unwrap();
- assert_eq!(db.get_attrs("k").unwrap(), sample_attrs(1));
- assert_eq!(db.get("k").unwrap(), vector);
+ assert_eq!(db.get_attrs("k").unwrap().unwrap(), sample_attrs(1));
+ assert_eq!(db.get("k").unwrap().unwrap(), vector);
db.add_with_attrs("k", &vector, &[attr("only", AttrValue::Bool(true))])
.unwrap();
assert_eq!(
- db.get_attrs("k").unwrap(),
+ db.get_attrs("k").unwrap().unwrap(),
vec![attr("only", AttrValue::Bool(true))]
);
db.add("k", &vector).unwrap();
- assert_eq!(db.get_attrs("k"), None);
+ assert_eq!(db.get_attrs("k").unwrap(), None);
db.add_with_attrs("k", &vector, &sample_attrs(2)).unwrap();
- assert_eq!(db.get_attrs("k").unwrap(), sample_attrs(2));
+ assert_eq!(db.get_attrs("k").unwrap().unwrap(), sample_attrs(2));
db.add_with_attrs("k", &vector, &[]).unwrap();
- assert_eq!(db.get_attrs("k"), None);
+ assert_eq!(db.get_attrs("k").unwrap(), None);
db.add("plain", &vector).unwrap();
- assert_eq!(db.get_attrs("plain"), None);
- assert_eq!(db.get_attrs("missing"), None);
+ assert_eq!(db.get_attrs("plain").unwrap(), None);
+ assert_eq!(db.get_attrs("missing").unwrap(), None);
assert!(matches!(
db.add_with_attrs(
"k",
@@ -5389,22 +5440,22 @@ mod tests {
db.add_with_attrs("a", &vector, &sample_attrs(10)).unwrap();
db.add_with_attrs("b", &vector, &sample_attrs(11)).unwrap();
assert!(db.remove("a").unwrap());
- assert_eq!(db.get_attrs("a"), None);
+ assert_eq!(db.get_attrs("a").unwrap(), None);
db.add("c", &vector).unwrap();
assert_eq!(db.shared.state_read().arena.slot_of_key("c"), Some(0));
- assert_eq!(db.get_attrs("c"), None);
+ assert_eq!(db.get_attrs("c").unwrap(), None);
assert!(db.remove("b").unwrap());
db.add_with_attrs("d", &vector, &sample_attrs(12)).unwrap();
assert_eq!(db.shared.state_read().arena.slot_of_key("d"), Some(1));
- assert_eq!(db.get_attrs("d").unwrap(), sample_attrs(12));
+ assert_eq!(db.get_attrs("d").unwrap().unwrap(), sample_attrs(12));
db.add("a", &vector).unwrap();
- assert_eq!(db.get_attrs("a"), None);
+ assert_eq!(db.get_attrs("a").unwrap(), None);
drop(db);
let reopened = open_writer(&path);
- assert_eq!(reopened.get_attrs("a"), None);
- assert_eq!(reopened.get_attrs("b"), None);
- assert_eq!(reopened.get_attrs("c"), None);
- assert_eq!(reopened.get_attrs("d").unwrap(), sample_attrs(12));
+ assert_eq!(reopened.get_attrs("a").unwrap(), None);
+ assert_eq!(reopened.get_attrs("b").unwrap(), None);
+ assert_eq!(reopened.get_attrs("c").unwrap(), None);
+ assert_eq!(reopened.get_attrs("d").unwrap().unwrap(), sample_attrs(12));
}
#[test]
@@ -5431,11 +5482,11 @@ mod tests {
db.flush().unwrap();
drop(db);
let verify = |db: &VecDb| {
- assert_eq!(db.get_attrs("plain"), None);
- assert_eq!(db.get_attrs("rich").unwrap(), ordered);
- assert_eq!(db.get_attrs("cleared"), None);
- assert_eq!(db.get_attrs("removed"), None);
- assert_eq!(db.get_attrs("recycled").unwrap(), sample_attrs(22));
+ assert_eq!(db.get_attrs("plain").unwrap(), None);
+ assert_eq!(db.get_attrs("rich").unwrap().unwrap(), ordered);
+ assert_eq!(db.get_attrs("cleared").unwrap(), None);
+ assert_eq!(db.get_attrs("removed").unwrap(), None);
+ assert_eq!(db.get_attrs("recycled").unwrap().unwrap(), sample_attrs(22));
};
let read_only = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
verify(&read_only);
@@ -5466,13 +5517,13 @@ mod tests {
for index in 64..120i64 {
let key = format!("key-{index}");
if index % 2 == 0 {
- assert_eq!(db.get_attrs(&key).unwrap(), sample_attrs(index));
+ assert_eq!(db.get_attrs(&key).unwrap().unwrap(), sample_attrs(index));
} else {
- assert_eq!(db.get_attrs(&key), None);
+ assert_eq!(db.get_attrs(&key).unwrap(), None);
}
}
for index in 0..64 {
- assert_eq!(db.get_attrs(&format!("key-{index}")), None);
+ assert_eq!(db.get_attrs(&format!("key-{index}")).unwrap(), None);
}
};
verify(&db);
@@ -5500,12 +5551,12 @@ mod tests {
let verify = |db: &VecDb| {
for index in 64..120i64 {
assert_eq!(
- db.get_attrs(&format!("key-{index}")).unwrap(),
+ db.get_attrs(&format!("key-{index}")).unwrap().unwrap(),
sample_attrs(index)
);
}
for index in 0..64 {
- assert_eq!(db.get_attrs(&format!("key-{index}")), None);
+ assert_eq!(db.get_attrs(&format!("key-{index}")).unwrap(), None);
}
};
verify(&db);
@@ -5562,8 +5613,8 @@ mod tests {
db.bulk_add_with_attrs(&keys, &vectors, &poisoned),
Err(VecDbError::InvalidAttributes(_))
));
- assert_eq!(db.len(), 1);
- assert!(!db.contains("x"));
+ assert_eq!(db.len().unwrap(), 1);
+ assert!(!db.contains("x").unwrap());
assert_eq!(db.stats().unwrap().log_bytes, log_bytes);
let valid = vec![Some(sample_attrs(7)), None];
db.bulk_add_with_attrs(&keys, &vectors, &valid).unwrap();
@@ -5573,10 +5624,11 @@ mod tests {
"missing".to_string(),
"y".to_string(),
"seed".to_string()
- ]),
+ ])
+ .unwrap(),
vec![Some(sample_attrs(7)), None, None, None]
);
- assert_eq!(db.get_attrs("x").unwrap(), sample_attrs(7));
+ assert_eq!(db.get_attrs("x").unwrap().unwrap(), sample_attrs(7));
let read_only = VecDb::open_read_only(&path, DIMS, Some(StorageKind::F32)).unwrap();
assert!(matches!(
read_only.bulk_add_with_attrs(&keys, &vectors, &[None]),
@@ -5595,11 +5647,11 @@ mod tests {
let vector = seeded_unit_vector(6, DIMS);
db.add_with_attrs("k", &vector, &sample_attrs(30)).unwrap();
db.reset().unwrap();
- assert_eq!(db.get_attrs("k"), None);
+ assert_eq!(db.get_attrs("k").unwrap(), None);
db.add("k", &vector).unwrap();
- assert_eq!(db.get_attrs("k"), None);
+ assert_eq!(db.get_attrs("k").unwrap(), None);
db.add_with_attrs("k", &vector, &sample_attrs(31)).unwrap();
- assert_eq!(db.get_attrs("k").unwrap(), sample_attrs(31));
+ assert_eq!(db.get_attrs("k").unwrap().unwrap(), sample_attrs(31));
}
#[test]
@@ -5788,7 +5840,7 @@ mod tests {
assert_eq!(VecDb::open_cost(&i8_path), OpenCost::Ready);
let standalone = VecDb::open_read_only(&i8_path, I8_DIMS, Some(StorageKind::I8)).unwrap();
assert_eq!(standalone.stats().unwrap().storage, StorageKind::I8);
- assert!(standalone.contains("i"));
+ assert!(standalone.contains("i").unwrap());
assert_own_nearest_i8(&standalone, "i", &vector);
drop(standalone);
assert!(matches!(
@@ -5800,7 +5852,7 @@ mod tests {
));
let detected = VecDb::open(&i8_path, I8_DIMS, Some(StorageKind::I8)).unwrap();
assert_eq!(detected.stats().unwrap().storage, StorageKind::I8);
- assert!(detected.contains("i"));
+ assert!(detected.contains("i").unwrap());
assert_own_nearest_i8(&detected, "i", &vector);
assert!(matches!(
VecDb::open(&dir.path().join("narrow"), 16, Some(StorageKind::I8)),
@@ -5837,8 +5889,8 @@ mod tests {
.collect();
assert_same_stored(&logged_add_records(&path, I8_DIMS), &expected);
assert_same_stored(&stored_vectors(&db), &expected);
- assert_eq!(db.get_attrs("single").unwrap(), sample_attrs(1));
- let restored = db.get("single").unwrap();
+ assert_eq!(db.get_attrs("single").unwrap().unwrap(), sample_attrs(1));
+ let restored = db.get("single").unwrap().unwrap();
let StoredVector::I8 { scale, .. } = &expected[0].1 else {
panic!("expected i8 storage");
};
@@ -6031,7 +6083,7 @@ mod tests {
assert!(i8_stats.approximate_memory_bytes < f32_stats.approximate_memory_bytes / 3);
assert!(i8_stats.log_bytes < f32_stats.log_bytes / 3);
let key = "key-7".to_string();
- let restored = i8_db.get(&key).unwrap();
+ let restored = i8_db.get(&key).unwrap().unwrap();
let original = &entries[7].1;
let max_abs = original
.iter()
@@ -6039,7 +6091,7 @@ mod tests {
for (original, restored) in original.iter().zip(&restored) {
assert!((original - restored).abs() <= max_abs / 254.0 + 1.0e-6);
}
- assert_eq!(f32_db.get(&key).unwrap(), *original);
+ assert_eq!(f32_db.get(&key).unwrap().unwrap(), *original);
assert_own_nearest_i8(&i8_db, &key, original);
i8_db.reset().unwrap();
assert_eq!(i8_db.stats().unwrap().storage, StorageKind::I8);