From 0c215c01fb2989c55eaa6450b7d7e90ca67aa434 Mon Sep 17 00:00:00 2001
From: Vlad Velicu <vlad_vel@yahoo.com>
Date: Tue, 5 Mar 2024 01:03:14 +0000
Subject: [PATCH] CBL-5433: Tests for Vector Index API 11-20 Obj-C (#3246)

* update words db

* add new tests

* disable another tests
---
 .../vectorsearch/words_db.cblite2/db.sqlite3  | Bin 1560576 -> 1576960 bytes
 Objective-C/Tests/VectorSearchTest.m          | 364 +++++++++++++++++-
 2 files changed, 344 insertions(+), 20 deletions(-)

diff --git a/Objective-C/Tests/Support/databases/vectorsearch/words_db.cblite2/db.sqlite3 b/Objective-C/Tests/Support/databases/vectorsearch/words_db.cblite2/db.sqlite3
index 9e6e8b918d711f056197a2499aeabf79066d3b1f..fdd0bcc0dbf30fdcd11f06f90243aa7fe9e665bb 100644
GIT binary patch
delta 14322
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

delta 12037
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

diff --git a/Objective-C/Tests/VectorSearchTest.m b/Objective-C/Tests/VectorSearchTest.m
index e242598e9..b32f563c3 100644
--- a/Objective-C/Tests/VectorSearchTest.m
+++ b/Objective-C/Tests/VectorSearchTest.m
@@ -68,55 +68,67 @@ - (void) testVectorIndexConfigurationSettersAndGetters {
     AssertEqual(config.maxTrainingSize, 200);
 }
 
-- (void) testDimensionsValidation {
+// CBL-5462
+- (void) _testDimensionsValidation {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
     CBLVectorIndexConfiguration* config1 = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
                                                                                         dimensions: 1
                                                                                          centroids: 20];
     AssertNotNil(config1);
+    Assert([collection createIndexWithName: @"words_index_1" config: config1 error: &error]);
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index_1"]);
     
     CBLVectorIndexConfiguration* config2 = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
                                                                                         dimensions: 2048
                                                                                          centroids: 20];
     AssertNotNil(config2);
+    Assert([collection createIndexWithName: @"words_index_2" config: config2 error: &error]);
+    names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index_2"]);
     
     [self expectException: NSInvalidArgumentException in:^{
         (void) [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
                                                             dimensions: 0 
                                                              centroids: 20];
-        NSLog(@"Invalid Argument test for dimensions = 0");
     }];
     
     [self expectException: NSInvalidArgumentException in:^{
         (void) [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector" 
                                                             dimensions: 2049 
                                                              centroids: 20];
-        NSLog(@"Invalid Argument test for dimensions = 2049");
     }];
 }
 
-- (void) testCentroidsValidation {
+// CBL-5463
+- (void) _testCentroidsValidation {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
     CBLVectorIndexConfiguration* config1 = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
                                                                                         dimensions: 300
                                                                                          centroids: 1];
     AssertNotNil(config1);
+    Assert([collection createIndexWithName: @"words_index_1" config: config1 error: &error]);
     
     CBLVectorIndexConfiguration* config2 = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
                                                                                         dimensions: 300
                                                                                          centroids: 64000];
     AssertNotNil(config2);
+    Assert([collection createIndexWithName: @"words_index_2" config: config2 error: &error]);
     
     [self expectException: NSInvalidArgumentException in:^{
         (void) [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector" 
                                                             dimensions: 300
                                                              centroids: 0];
-        NSLog(@"Invalid Argument test for centroids = 0");
     }];
     
     [self expectException: NSInvalidArgumentException in:^{
         (void) [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector" 
                                                             dimensions: 300
                                                              centroids: 64001];
-        NSLog(@"Invalid Argument test for centroids = 64001");
     }];
 }
 
@@ -129,8 +141,7 @@ - (void) testCreateVectorIndex {
     Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
     
     NSArray* names = [collection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, (@[@"words_index"]));
+    Assert([names containsObject: @"words_index"]);
     
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
     CBLQuery* q = [_db createQuery: sql error: &error];
@@ -159,9 +170,9 @@ - (void) testUpdateVectorIndex {
     Assert([wordsCollection createIndexWithName: @"words_index" config: config error: &error]);
     
     NSArray* names = [wordsCollection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, (@[@"words_index"]));
+    Assert([names containsObject: @"words_index"]);
     
+    // Query
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 350)";
     CBLQuery* q = [_db createQuery: sql error: &error];
     
@@ -210,11 +221,11 @@ - (void) _testCreateVectorIndexWithInvalidVectors {
     
     auxDoc = [[collection documentWithID: @"word2" error: &error] toMutable];
     [auxDoc setString: @"string" forKey: @"vector"];
-    [collection saveDocument:auxDoc error:&error];
+    [collection saveDocument: auxDoc error: &error];
     
     auxDoc = [[collection documentWithID: @"word3" error: &error] toMutable];
     [auxDoc removeValueForKey: @"vector"];
-    [collection saveDocument:auxDoc error:&error];
+    [collection saveDocument: auxDoc error: &error];
     
     // CBL-5444
     auxDoc = [[collection documentWithID: @"word4" error: &error] toMutable];
@@ -229,8 +240,7 @@ - (void) _testCreateVectorIndexWithInvalidVectors {
     Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
 
     NSArray* names = [collection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, (@[@"words_index"]));
+    Assert([names containsObject: @"words_index"]);
     
     // Query:
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 350)";
@@ -256,6 +266,7 @@ - (void) _testCreateVectorIndexWithInvalidVectors {
 }
 
 - (void) testCreateVectorIndexUsingPredictionModel {
+    CBLDatabase.log.console.level = kCBLLogLevelVerbose;
     NSError* error;
     
     CBLCollection* wordsCollection = [_db collectionWithName: @"words" scope: nil error: &error];
@@ -271,8 +282,7 @@ - (void) testCreateVectorIndexUsingPredictionModel {
     Assert([wordsCollection createIndexWithName: @"words_pred_index" config: config error: &error]);
     
     NSArray* names = [wordsCollection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, ((@[@"words_pred_index"])));
+    Assert([names containsObject: @"words_pred_index"]);
     
     // Query:
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_pred_index, $vector, 350)";
@@ -350,8 +360,7 @@ - (void) _testCreateVectorIndexUsingPredictionModelWithInvalidVectors {
     Assert([collection createIndexWithName: @"words_pred_index" config: config error: &error]);
     
     NSArray* names = [collection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, ((@[@"words_pred_index"])));
+    Assert([names containsObject:@"words_pred_index"]);
 
     // Query:
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_pred_index, $vector, 350)";
@@ -391,8 +400,7 @@ - (void) testCreateVectorIndexWithSQ {
     Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
     
     NSArray* names = [collection indexes: &error];
-    AssertEqual(names.count, 1u);
-    AssertEqualObjects(names, ((@[@"words_index"])));
+    Assert([names containsObject:@"words_index"]);
     
     // Query:
     NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
@@ -428,4 +436,320 @@ - (void) testCreateVectorIndexWithSQ {
     allObjects = rs.allObjects;
     AssertEqual(allObjects.count, 20);
 }
+
+- (void) testCreateVectorIndexWithNoneEncoding {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.encoding = [CBLVectorEncoding none];
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allObjects;
+    AssertEqual(allObjects.count, 20);
+}
+
+- (void) testCreateVectorIndexWithPQ {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    int bitsValues[3] = {8, 4, 12};
+    for (size_t i = 0; i < sizeof(bitsValues)/sizeof(int); i++) {
+        // Create vector index
+        CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                           dimensions: 300
+                                                                                            centroids: 20];
+        config.encoding = [CBLVectorEncoding productQuantizerWithSubquantizers: 5
+                                                                          bits: bitsValues[i]];
+        Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+        
+        NSArray* names = [collection indexes: &error];
+        Assert([names containsObject: @"words_index"]);
+        
+        // Query:
+        NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
+        CBLQuery* q = [_db createQuery: sql error: &error];
+        
+        CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+        [parameters setValue: kDinnerVector forName: @"vector"];
+        [q setParameters: parameters];
+        
+        NSString* explain = [q explain: &error];
+        Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+        CBLQueryResultSet* rs = [q execute: &error];
+        NSArray* allObjects = rs.allObjects;
+        AssertEqual(allObjects.count, 20);
+        
+        // Delete index
+        [collection deleteIndexWithName: @"words_index" error: &error];
+    }
+}
+
+// CBL-5459
+- (void) testSubquantizersValidation {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.encoding = [CBLVectorEncoding productQuantizerWithSubquantizers: 2
+                                                                      bits: 8];
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Check if valid values
+    int goodValues[17] = {2, 3, 4, 5, 6, 10, 12, 15, 20, 25, 30, 50, 60, 75, 100, 150, 300};
+    for (size_t i = 0; i < sizeof(goodValues)/sizeof(int); i++) {
+        [collection deleteIndexWithName: @"words_index" error: &error];
+        config.encoding = [CBLVectorEncoding productQuantizerWithSubquantizers: goodValues[i]
+                                                                          bits: 8];
+        Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    }
+    
+    // Check if exception thrown for wrong values
+    [self expectException: NSInvalidArgumentException in:^{
+        int wrongValues[2] = {0, 7};
+        for (size_t i = 0; i < sizeof(wrongValues)/sizeof(int); i++) {
+            [collection deleteIndexWithName: @"words_index" error: nil];
+            config.encoding = [CBLVectorEncoding productQuantizerWithSubquantizers: wrongValues[i]
+                                                                              bits: 8];
+            [collection createIndexWithName: @"words_index" config: config error: nil];
+        }
+    }];
+}
+
+- (void) testeCreateVectorIndexWithFixedTrainingSize {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.minTrainingSize = 100;
+    config.maxTrainingSize = 100;
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allObjects;
+    AssertEqual(allObjects.count, 20);
+}
+
+- (void) testValidateMinMaxTrainingSize {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.minTrainingSize = 1;
+    config.maxTrainingSize = 100;
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Check if exception thrown for wrong values
+    [self expectException: NSInvalidArgumentException in:^{
+        int minTrainingValues[3] = {0, 0, 10};
+        int maxTrainingValues[3] = {0, 100, 9};
+        for (size_t i = 0; i < sizeof(minTrainingValues)/sizeof(int); i++) {
+            [collection deleteIndexWithName: @"words_index" error: nil];
+            config.minTrainingSize = minTrainingValues[i];
+            config.maxTrainingSize = maxTrainingValues[i];
+            [collection createIndexWithName: @"words_index" config: config error: nil];
+        }
+    }];
+}
+
+- (void) testQueryUntrainedVectorIndex {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    // out of bounds (300 words in db)
+    config.minTrainingSize = 400;
+    config.maxTrainingSize = 500;
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allObjects;
+    AssertEqual(allObjects.count, 20);
+}
+
+- (void) testCreateVectorIndexWithCosineDistance {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.metric = kCBLDistanceMetricCosine;
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word, vector_distance(words_index) from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allResults;
+    AssertEqual(allObjects.count, 20);
+    
+    for(CBLQueryResult* result in rs){
+        // doubleAtIndex: vector_distance(words_index)
+        Assert([result doubleAtIndex: 3] > 0);
+        Assert([result doubleAtIndex: 3] < 1);
+    }
+}
+
+- (void) testCreateVectorIndexWithEuclideanDistance {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create vector index
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    config.metric = kCBLDistanceMetricEuclidean;
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject:@"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word, vector_distance(words_index) from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allResults;
+    AssertEqual(allObjects.count, 20);
+    
+    for(CBLQueryResult* result in rs){
+        // doubleAtIndex: vector_distance(words_index)
+        Assert([result doubleAtIndex: 3] > 0);
+    }
+}
+
+- (void) testCreateVectorIndexWithExistingName {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create and recreate vector index using the same config
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    // Recreate index with same name using different config
+    CBLVectorIndexConfiguration* config2 = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vectors"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    Assert([collection createIndexWithName: @"words_index" config: config2 error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject: @"words_index"]);
+}
+
+- (void) testDeleteVectorIndex {
+    NSError* error;
+    CBLCollection* collection = [_db collectionWithName: @"words" scope: nil error: &error];
+    
+    // Create and recreate vector index using the same config
+    CBLVectorIndexConfiguration* config = [[CBLVectorIndexConfiguration alloc] initWithExpression: @"vector"
+                                                                                       dimensions: 300
+                                                                                        centroids: 20];
+    Assert([collection createIndexWithName: @"words_index" config: config error: &error]);
+    
+    NSArray* names = [collection indexes: &error];
+    Assert([names containsObject:@"words_index"]);
+    
+    // Query:
+    NSString* sql = @"select meta().id, word, vector_distance(words_index) from _default.words where vector_match(words_index, $vector, 20)";
+    CBLQuery* q = [_db createQuery: sql error: &error];
+    
+    CBLQueryParameters* parameters = [[CBLQueryParameters alloc] init];
+    [parameters setValue: kDinnerVector forName: @"vector"];
+    [q setParameters: parameters];
+    
+    NSString* explain = [q explain: &error];
+    Assert([explain rangeOfString: @"SCAN kv_.words:vector:words_index"].location != NSNotFound);
+    CBLQueryResultSet* rs = [q execute: &error];
+    NSArray* allObjects = rs.allResults;
+    AssertEqual(allObjects.count, 20);
+    
+    // Delete index
+    [collection deleteIndexWithName: @"words_index" error: &error];
+    
+    names = [collection indexes: &error];
+    AssertEqual(names.count, 0);
+}
+
 @end