use crate::error::Result;
use crate::format::catalog::{FrameRole, VectorMetric};
use crate::format::dtype::{Dtype, DtypeSet};
use crate::format::{CodecId, CollectionId, EmbeddingSpaceId, FrameId};
use crate::io::Durability;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OpenMode {
ReadOnly,
ReadWrite,
}
#[derive(Clone, Debug)]
pub struct CreateOptions {
pub durability: Durability,
pub text: TextMode,
pub vector: VectorContract,
pub auto_promote: AutoPromote,
}
impl Default for CreateOptions {
fn default() -> Self {
Self {
durability: Durability::default(),
text: TextMode::Enabled,
vector: VectorContract::default(),
auto_promote: AutoPromote::default(),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum TextMode {
Enabled,
Disabled,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct VectorContract {
pub max_dim: u32,
pub allowed_dtypes: DtypeSet,
}
impl Default for VectorContract {
fn default() -> Self {
Self {
max_dim: 4096,
allowed_dtypes: DtypeSet::ALL,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AutoPromote {
pub non_f8_threshold: u64,
pub f8_threshold: u64,
}
impl Default for AutoPromote {
fn default() -> Self {
Self {
non_f8_threshold: 200_000,
f8_threshold: 500_000,
}
}
}
impl CreateOptions {
pub(crate) fn build_contract(
&self,
) -> Result<crate::format::create_contract::CreateContractV1> {
let contract = crate::format::create_contract::CreateContractV1 {
schema_version: crate::format::create_contract::SCHEMA_VERSION,
text_enabled: matches!(self.text, TextMode::Enabled),
max_dim: self.vector.max_dim,
allowed_dtypes: self.vector.allowed_dtypes.bits(),
auto_promote_non_f8: self.auto_promote.non_f8_threshold,
auto_promote_f8: self.auto_promote.f8_threshold,
reserved: [0u8; 16],
};
contract.validate_options()?;
Ok(contract)
}
}
#[derive(Clone, Debug)]
pub struct PutFrame<'a> {
pub collection_id: CollectionId,
pub role: FrameRole,
pub payload: &'a [u8],
pub created_at: Option<i64>,
pub updated_at: Option<i64>,
pub parent_frame_id: Option<FrameId>,
pub chunk_index: Option<u32>,
pub chunk_count: Option<u32>,
pub uri: Option<&'a [u8]>,
}
impl<'a> PutFrame<'a> {
#[must_use]
pub fn document(collection_id: CollectionId, payload: &'a [u8]) -> Self {
Self {
collection_id,
role: FrameRole::Document,
payload,
created_at: None,
updated_at: None,
parent_frame_id: None,
chunk_index: None,
chunk_count: None,
uri: None,
}
}
#[must_use]
pub fn with_uri(mut self, uri: &'a [u8]) -> Self {
self.uri = Some(uri);
self
}
}
#[derive(Clone, Debug)]
pub struct PutVector<'a> {
pub owner_frame_id: FrameId,
pub embedding_space_id: EmbeddingSpaceId,
pub values: &'a [f32],
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum VectorFidelity {
Lossy,
Full,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Reconstruct {
StoredBytes,
F32Vector,
}
#[derive(Clone, Debug)]
pub enum ReadVectorResult {
StoredBytes(Vec<u8>),
F32Vector(Vec<f32>),
}
impl ReadVectorResult {
#[must_use]
pub fn expect_f32(self) -> Vec<f32> {
match self {
Self::F32Vector(v) => v,
Self::StoredBytes(_) => {
panic!("ReadVectorResult::expect_f32: got StoredBytes variant")
}
}
}
#[must_use]
pub fn expect_stored_bytes(self) -> Vec<u8> {
match self {
Self::StoredBytes(b) => b,
Self::F32Vector(_) => {
panic!("ReadVectorResult::expect_stored_bytes: got F32Vector variant")
}
}
}
}
#[derive(Clone, Debug)]
pub struct EmbeddingSpaceSpec {
pub provider: String,
pub model: String,
pub dimension: u32,
pub metric: VectorMetric,
pub normalized: bool,
pub dtype: Dtype,
pub primary_codec_id: Option<CodecId>,
pub secondary_codec_id: Option<CodecId>,
}
impl Default for EmbeddingSpaceSpec {
fn default() -> Self {
Self {
provider: String::new(),
model: String::new(),
dimension: 0,
metric: VectorMetric::Cosine,
normalized: false,
dtype: Dtype::F32,
primary_codec_id: None,
secondary_codec_id: None,
}
}
}