use std::path::PathBuf;
use std::sync::Arc;
use parking_lot::ArcMutexGuard;
use crate::concurrency::database::Database;
use crate::concurrency::snapshot::Snapshot;
use crate::error::Result;
use crate::file::{
CommitOutcome, HybridHit, HybridQuery, PutFrame, PutVector, TextQuery, TimeQuery, VectorHit,
};
use crate::format::{
CollectionId, FrameId, VectorId,
catalog::{
AnalyzerDesc, CodecDesc, CollectionDesc, EmbeddingSpaceDesc, FieldSchemaDesc, FrameDesc,
FrameStub, FusionProfileDesc, RetrievalProfileDesc, TextSpaceDesc, VectorDesc,
},
header::Header,
};
use crate::retrieval::Hit;
pub struct ReadConnection {
db: Arc<Database>,
snapshot: Arc<Snapshot>,
}
impl ReadConnection {
pub(crate) fn new(db: Arc<Database>) -> Self {
let snapshot = db.snapshot();
Self { db, snapshot }
}
#[must_use]
pub fn snapshot(&self) -> &Arc<Snapshot> {
&self.snapshot
}
pub fn refresh_snapshot(&mut self) {
self.snapshot = self.db.snapshot();
}
#[must_use]
pub fn database(&self) -> &Arc<Database> {
&self.db
}
pub fn path(&self) -> PathBuf {
self.db.inner.read().path().to_path_buf()
}
pub fn header(&self) -> Header {
self.db.inner.read().header().clone()
}
pub fn collections(&self) -> Vec<CollectionDesc> {
self.snapshot.catalog().collections.clone()
}
pub fn frames(&self) -> Vec<FrameDesc> {
self.snapshot.catalog().frames.clone()
}
pub fn frame_stubs(&self) -> Vec<FrameStub> {
self.snapshot.catalog().frame_stubs.clone()
}
pub fn frame_full(&self, frame_id: FrameId) -> Result<FrameDesc> {
self.snapshot.frame_full(frame_id)
}
pub fn vectors(&self) -> Vec<VectorDesc> {
self.snapshot.catalog().vectors.clone()
}
pub fn embedding_spaces(&self) -> Vec<EmbeddingSpaceDesc> {
self.snapshot.catalog().embedding_spaces.clone()
}
pub fn codecs(&self) -> Vec<CodecDesc> {
self.snapshot.catalog().codecs.clone()
}
pub fn text_spaces(&self) -> Vec<TextSpaceDesc> {
self.snapshot.catalog().text_spaces.clone()
}
pub fn analyzers(&self) -> Vec<AnalyzerDesc> {
self.snapshot.catalog().analyzers.clone()
}
pub fn field_schemas(&self) -> Vec<FieldSchemaDesc> {
self.snapshot.catalog().field_schemas.clone()
}
pub fn retrieval_profiles(&self) -> Vec<RetrievalProfileDesc> {
self.snapshot.catalog().retrieval_profiles.clone()
}
pub fn fusion_profiles(&self) -> Vec<FusionProfileDesc> {
self.snapshot.catalog().fusion_profiles.clone()
}
pub fn read_payload(&self, frame_id: FrameId) -> Result<Vec<u8>> {
self.snapshot.read_payload(frame_id)
}
pub fn read_raw_text(&self, frame_id: FrameId) -> Result<String> {
self.snapshot.read_raw_text(frame_id)
}
pub fn storage_breakdown(&self) -> Vec<(crate::format::segment::SegmentType, u32, u64)> {
self.db.inner.read().storage_breakdown_by_segment_type()
}
pub fn read_vector(
&self,
vector_id: VectorId,
mode: crate::file::Reconstruct,
) -> Result<crate::file::ReadVectorResult> {
self.db.inner.read().read_vector(vector_id, mode)
}
pub fn vector_search(&self, query: crate::file::VectorSearchQuery) -> Result<Vec<VectorHit>> {
self.db.inner.read().vector_search(query)
}
pub fn query_text(&self, query: TextQuery) -> Result<Vec<Hit>> {
self.db.inner.read().query_text(query)
}
pub fn query_hybrid(&self, query: HybridQuery) -> Result<Vec<HybridHit>> {
self.db.inner.read().query_hybrid(query)
}
pub fn time_range_query(&self, query: TimeQuery) -> Vec<FrameId> {
self.db.inner.read().time_range_query(query)
}
pub fn collection_member_frames(&self, collection_id: CollectionId) -> Vec<FrameId> {
self.db
.inner
.read()
.collection_member_frames(collection_id)
.to_vec()
}
pub fn collection_member_vectors(&self, collection_id: CollectionId) -> Vec<VectorId> {
self.db
.inner
.read()
.collection_member_vectors(collection_id)
.to_vec()
}
}
pub struct WriteConnection {
db: Arc<Database>,
_writer_slot: ArcMutexGuard<parking_lot::RawMutex, ()>,
}
impl WriteConnection {
pub(crate) fn new(
db: Arc<Database>,
writer_slot: ArcMutexGuard<parking_lot::RawMutex, ()>,
) -> Self {
Self {
db,
_writer_slot: writer_slot,
}
}
#[must_use]
pub fn database(&self) -> &Arc<Database> {
&self.db
}
pub fn create_collection(&mut self, name: impl Into<String>) -> Result<CollectionId> {
self.db.inner.write().create_collection(name)
}
pub fn put_frame(&mut self, input: PutFrame<'_>) -> Result<FrameId> {
self.db.inner.write().put_frame(input)
}
pub fn put_vector(&mut self, input: PutVector<'_>) -> Result<VectorId> {
self.db.inner.write().put_vector(input)
}
pub fn delete_frame(&mut self, frame_id: FrameId) -> Result<()> {
self.db.inner.write().delete_frame(frame_id)
}
pub fn delete_vector(&mut self, vector_id: VectorId) -> Result<()> {
self.db.inner.write().delete_vector(vector_id)
}
pub fn flush(&mut self) -> Result<()> {
self.db.inner.write().flush()
}
pub fn commit(&mut self) -> Result<CommitOutcome> {
use crate::file::CommitProfile;
let mut profile = CommitProfile::default();
let (prepared, cloned_file, path) = {
let mut valise = self.db.inner.write();
let prep = match valise.commit_phase_writes(&mut profile)? {
crate::file::CommitWritePhaseResult::NoOp(outcome) => {
return Ok(outcome);
}
crate::file::CommitWritePhaseResult::Prepared(p) => p,
};
let (file, path) = valise.prepare_commit_fsync()?;
(prep, file, path)
};
let _ = path;
self.db.pipeline.commit_fsync.fsync(|| {
crate::io::sync_file(&cloned_file, crate::io::Durability::FullSync)?;
Ok(())
})?;
let outcome = {
let mut valise = self.db.inner.write();
valise.commit_phase_publish(prepared, &mut profile)?
};
Ok(outcome)
}
pub fn collections(&self) -> Vec<CollectionDesc> {
self.db.inner.read().collections().to_vec()
}
pub fn frame_stubs(&self) -> Vec<FrameStub> {
self.db.inner.read().frame_stubs().to_vec()
}
pub fn embedding_spaces(&self) -> Vec<EmbeddingSpaceDesc> {
self.db.inner.read().embedding_spaces().to_vec()
}
pub fn frame_full(&self, frame_id: FrameId) -> Result<FrameDesc> {
self.db.inner.read().frame_full(frame_id)
}
pub fn read_payload(&self, frame_id: FrameId) -> Result<Vec<u8>> {
self.db.inner.read().read_payload(frame_id)
}
pub fn read_vector(
&self,
vector_id: VectorId,
mode: crate::file::Reconstruct,
) -> Result<crate::file::ReadVectorResult> {
self.db.inner.read().read_vector(vector_id, mode)
}
pub fn vector_search(&self, query: crate::file::VectorSearchQuery) -> Result<Vec<VectorHit>> {
self.db.inner.read().vector_search(query)
}
pub fn snapshot(&self) -> Arc<Snapshot> {
self.db.inner.read().snapshot()
}
}