Validate dimensions in VectorIndex

Author: kalisam

benches/index_performance.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 
 fn bench_vector_index(c: &mut Criterion) {
     // Setup test vectors
-    let dimensions = 128;
+    let dimensions = 60;
     let vector_count = 10000;
     let test_vectors: Vec<Vector> = (0..vector_count)
         .map(|_| Vector::random_normal(dimensions, 0.0, 1.0))
@@ -36,7 +36,7 @@ fn bench_vector_index(c: &mut Criterion) {
                     b.iter_with_setup(
                         || {
                             // Create a new index for each iteration
-                            let index = VectorIndex::new("bench_index", dimensions, metric, None);
+                            let index = VectorIndex::new("bench_index", dimensions, metric, None).unwrap();
                             (index, test_vectors.clone())
                         },
                         |(index, vectors)| {
@@ -66,7 +66,7 @@ fn bench_vector_index(c: &mut Criterion) {
                 |b, _| {
                     // Setup the index with test vectors
                     let rt = tokio::runtime::Runtime::new().unwrap();
-                    let index = VectorIndex::new("bench_index", dimensions, metric, None);
+                    let index = VectorIndex::new("bench_index", dimensions, metric, None).unwrap();
 
                     rt.block_on(async {
                         for vector in &test_vectors {
@@ -97,7 +97,7 @@ fn bench_vector_index(c: &mut Criterion) {
             |b, _| {
                 // Setup the index with test vectors
                 let rt = tokio::runtime::Runtime::new().unwrap();
-                let index = VectorIndex::new("bench_index", dimensions, DistanceMetric::Cosine, None);
+                let index = VectorIndex::new("bench_index", dimensions, DistanceMetric::Cosine, None).unwrap();
 
                 rt.block_on(async {
                     for vector in &test_vectors {

src/main.rs

@@ -75,7 +75,7 @@ async fn main() -> anyhow::Result<()> {
     let shard_id = shard_manager.create_shard("demo_shard").await?;
 
     // Create a vector index
-    let dimensions = 128;
+    let dimensions = 60;
     let index = shard_manager
         .create_vector_index(shard_id, "demo_index", dimensions, DistanceMetric::Cosine)
         .await?;

src/sharding/manager.rs

@@ -118,12 +118,13 @@ impl ShardManager {
 
         // Create the index
         let index = VectorIndex::new(
-            name, 
-            dimensions, 
+            name,
+            dimensions,
             distance_metric,
             Some(self.metrics.clone()),
-        );
-        
+        )
+        .map_err(|e| anyhow!("Failed to create vector index: {}", e))?;
+
         let index = Arc::new(index);
 
         // Store the index

src/sharding/vector_index.rs

@@ -97,30 +97,42 @@ pub struct VectorIndex {
 impl VectorIndex {
     /// Create a new vector index
     pub fn new(
-        name: &str, 
-        dimensions: usize, 
+        name: &str,
+        dimensions: usize,
         distance_metric: DistanceMetric,
         metrics: Option<Arc<MetricsCollector>>,
-    ) -> Self {
-        // Determine bits per dimension based on dimensions
-        // We want to keep the total bits under 64 (for u64 hilbert index)
-        let max_total_bits = 60; // Leave some room for safety
-        let bits_per_dimension = std::cmp::min(
-            10, // Maximum reasonable value
-            max_total_bits / dimensions
-        );
-        
+    ) -> Result<Self, String> {
+        let max_total_bits = 60;
+
+        if dimensions == 0 {
+            return Err("dimensions must be greater than zero".to_string());
+        }
+        if dimensions > max_total_bits {
+            return Err(format!(
+                "dimensions ({}) exceed maximum supported {}",
+                dimensions, max_total_bits
+            ));
+        }
+
+        let bits_per_dimension = std::cmp::min(10, max_total_bits / dimensions);
+        if bits_per_dimension == 0 {
+            return Err(format!(
+                "calculated bits_per_dimension is zero for {} dimensions",
+                dimensions
+            ));
+        }
+
         let hilbert_curve = HilbertCurve::new(dimensions, bits_per_dimension);
-        
-        Self {
+
+        Ok(Self {
             name: name.to_string(),
             vectors: RwLock::new(HashMap::new()),
             hilbert_curve,
             hilbert_map: RwLock::new(HashMap::new()),
             dimensions,
             distance_metric,
             metrics,
-        }
+        })
     }
 
     /// Convert a vector to a Hilbert index
@@ -432,7 +444,7 @@ mod tests {
     use rand::Rng;
 
     async fn create_test_index(vector_count: usize, dimensions: usize) -> VectorIndex {
-        let index = VectorIndex::new("test_index", dimensions, DistanceMetric::Euclidean, None);
+        let index = VectorIndex::new("test_index", dimensions, DistanceMetric::Euclidean, None).unwrap();
 
         // Add random vectors
         for _ in 0..vector_count {
@@ -454,7 +466,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_remove() {
-        let index = VectorIndex::new("test_remove", 3, DistanceMetric::Euclidean, None);
+        let index = VectorIndex::new("test_remove", 3, DistanceMetric::Euclidean, None).unwrap();
 
         // Add a vector
         let vector = Vector::random(3);
@@ -512,7 +524,7 @@ mod tests {
         // Test each metric
         for metric in [DistanceMetric::Euclidean, DistanceMetric::Cosine, 
                       DistanceMetric::Manhattan, DistanceMetric::Hamming].iter() {
-            let index = VectorIndex::new("test_metric", dimensions, *metric, None);
+            let index = VectorIndex::new("test_metric", dimensions, *metric, None).unwrap();
 
             // Add all vectors
             for v in &vectors {