oxirs-vec 0.2.4

Vector index abstractions for semantic similarity and AI-augmented querying
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Core types for compaction system

use serde::{Deserialize, Serialize};
use std::time::{Duration, SystemTime};

/// Compaction state
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CompactionState {
    /// Idle, not compacting
    Idle,
    /// Currently compacting
    Running,
    /// Paused (can be resumed)
    Paused,
    /// Failed (error occurred)
    Failed,
    /// Completed successfully
    Completed,
}

/// Result of a compaction operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompactionResult {
    /// Start time of compaction
    pub start_time: SystemTime,
    /// End time of compaction
    pub end_time: SystemTime,
    /// Duration of compaction
    pub duration: Duration,
    /// Number of vectors processed
    pub vectors_processed: usize,
    /// Number of vectors removed (deleted/duplicates)
    pub vectors_removed: usize,
    /// Bytes reclaimed
    pub bytes_reclaimed: u64,
    /// Fragmentation before compaction
    pub fragmentation_before: f64,
    /// Fragmentation after compaction
    pub fragmentation_after: f64,
    /// Success flag
    pub success: bool,
    /// Error message if failed
    pub error: Option<String>,
}

/// Compaction statistics
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CompactionStatistics {
    /// Total number of compactions performed
    pub total_compactions: u64,
    /// Successful compactions
    pub successful_compactions: u64,
    /// Failed compactions
    pub failed_compactions: u64,
    /// Total vectors processed
    pub total_vectors_processed: usize,
    /// Total vectors removed
    pub total_vectors_removed: usize,
    /// Total bytes reclaimed
    pub total_bytes_reclaimed: u64,
    /// Current fragmentation ratio (0.0 - 1.0)
    pub current_fragmentation: f64,
    /// Average compaction duration
    pub avg_compaction_duration: Duration,
    /// Last compaction time
    pub last_compaction_time: Option<SystemTime>,
    /// Last compaction result
    pub last_compaction_result: Option<CompactionResult>,
}

/// Fragment information
#[derive(Debug, Clone)]
pub struct FragmentInfo {
    /// Offset in the index
    pub offset: usize,
    /// Size of the fragment
    pub size: usize,
    /// Is this fragment free (deleted)?
    pub is_free: bool,
    /// Age of the fragment (time since creation)
    pub age: Duration,
}

/// Compaction phase
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CompactionPhase {
    /// Analyzing fragmentation
    Analyzing,
    /// Identifying candidates for compaction
    IdentifyingCandidates,
    /// Moving vectors
    MovingVectors,
    /// Updating indices
    UpdatingIndices,
    /// Reclaiming space
    ReclaimingSpace,
    /// Verifying integrity
    Verifying,
    /// Completed
    Completed,
}

/// Compaction progress
#[derive(Debug, Clone)]
pub struct CompactionProgress {
    /// Current phase
    pub phase: CompactionPhase,
    /// Progress within current phase (0.0 - 1.0)
    pub phase_progress: f64,
    /// Overall progress (0.0 - 1.0)
    pub overall_progress: f64,
    /// Estimated time remaining
    pub estimated_time_remaining: Option<Duration>,
    /// Current throughput (vectors/sec)
    pub throughput: f64,
}

/// Compaction candidate (vector to be compacted)
#[derive(Debug, Clone)]
pub struct CompactionCandidate {
    /// Vector ID
    pub vector_id: String,
    /// Current offset
    pub current_offset: usize,
    /// Size in bytes
    pub size_bytes: usize,
    /// Priority (higher = more important to compact)
    pub priority: f64,
    /// Reason for compaction
    pub reason: CompactionReason,
}

/// Reason for compaction
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CompactionReason {
    /// Fragmentation
    Fragmentation,
    /// Deleted vector cleanup
    DeletedCleanup,
    /// Duplicate removal
    DuplicateRemoval,
    /// Size optimization
    SizeOptimization,
    /// Manual trigger
    Manual,
}

/// Compaction batch
#[derive(Debug, Clone)]
pub struct CompactionBatch {
    /// Batch ID
    pub batch_id: u64,
    /// Candidates in this batch
    pub candidates: Vec<CompactionCandidate>,
    /// Total size of batch in bytes
    pub total_size_bytes: usize,
    /// Estimated processing time
    pub estimated_duration: Duration,
}