RDBC-889 Add Enable Corax on static index, Add Vector search tests, Fix toggle databases status

Author: poissoncorp

ravendb/documents/indexes/abstract_index_creation_tasks.py

@@ -16,6 +16,7 @@
     SpatialOptions,
     IndexFieldOptions,
     IndexType,
+    SearchEngineType,
 )
 from ravendb.documents.indexes.spatial.configuration import SpatialOptionsFactory
 from ravendb.documents.indexes.vector.options import VectorOptions
@@ -41,13 +42,15 @@ def __init__(
         lock_mode: IndexLockMode = None,
         deployment_mode: IndexDeploymentMode = None,
         state: IndexState = None,
+        search_engine_type: SearchEngineType = None,
     ):
         super().__init__()
         self.conventions = conventions
         self.priority = priority
         self.lock_mode = lock_mode
         self.deployment_mode = deployment_mode
         self.state = state
+        self.search_engine_type = search_engine_type
 
     def execute(self, store: "DocumentStore", conventions: DocumentConventions = None, database: str = None):
         old_conventions = self.conventions
@@ -69,6 +72,11 @@ def execute(self, store: "DocumentStore", conventions: DocumentConventions = Non
             if self.deployment_mode is not None:
                 index_definition.deployment_mode = self.deployment_mode
 
+            if self.search_engine_type is not None:
+                if not index_definition.configuration:
+                    index_definition.configuration = {}
+                index_definition.configuration["Indexing.Static.SearchEngineType"] = self.search_engine_type.__str__()
+
             store.maintenance.for_database(database).send(PutIndexesOperation(index_definition))
 
         finally:

ravendb/documents/indexes/definitions.py

@@ -61,6 +61,14 @@ def __str__(self):
         return self.value
 
 
+class SearchEngineType(Enum):
+    LUCENE = "Lucene"
+    CORAX = "Corax"
+
+    def __str__(self):
+        return self.value
+
+
 class FieldStorage(Enum):
     YES = "Yes"
     NO = "No"
@@ -196,6 +204,7 @@ def __init__(
         pattern_for_output_reduce_to_collection_references: Optional[str] = None,
         pattern_references_collection_name: Optional[str] = None,
         deployment_mode: Optional[IndexDeploymentMode] = None,
+        search_engine_type: Optional[SearchEngineType] = None,
     ):
         super(IndexDefinition, self).__init__(name, priority, state)
         self.lock_mode = lock_mode
@@ -212,6 +221,7 @@ def __init__(
         self.pattern_for_output_reduce_to_collection_references = pattern_for_output_reduce_to_collection_references
         self.pattern_references_collection_name = pattern_references_collection_name
         self.deployment_mode = deployment_mode
+        self.search_engine_type = search_engine_type
 
     @classmethod
     def from_json(cls, json_dict: dict) -> IndexDefinition:
@@ -234,6 +244,8 @@ def from_json(cls, json_dict: dict) -> IndexDefinition:
         index_type = json_dict.get("IndexType", None)
         if index_type is not None:
             result.__index_type = IndexType(index_type)
+        if json_dict["Configuration"] and json_dict["Configuration"]["Indexing.Static.SearchEngineType"]:
+            result.search_engine_type = SearchEngineType(json_dict["Configuration"]["Indexing.Static.SearchEngineType"])
         result.output_reduce_to_collection = json_dict["OutputReduceToCollection"]
         result.reduce_output_index = json_dict["ReduceOutputIndex"]
         result.pattern_for_output_reduce_to_collection_references = json_dict[

ravendb/documents/operations/server_misc.py

@@ -28,7 +28,7 @@ def __init__(self, databases_names: List[str] = None):
             self.databases_names = databases_names
 
         def to_json(self) -> Dict[str, Any]:
-            return {"DatabasesNames": self.databases_names}
+            return {"DatabaseNames": self.databases_names}
 
     def __init__(self, database_name: str, disable: bool):
         if database_name is None:
@@ -50,7 +50,7 @@ def from_parameters(cls, parameters: ToggleDatabasesStateOperation.Parameters, d
             raise ValueError("Parameters cannot be None")
 
         if not parameters.databases_names:
-            raise ValueError("Parameters.DatabasesNames cannot be None or empty")
+            raise ValueError("Parameters.DatabaseNames cannot be None or empty")
 
         this = cls("", disable)
         this._parameters = parameters

ravendb/tests/dotnet_migrated_tests/test_ravenDB_22076.py

@@ -1,18 +1,21 @@
+from datetime import timedelta
 from typing import List
 
 from ravendb import AbstractIndexCreationTask
+from ravendb.documents.indexes.definitions import SearchEngineType
 from ravendb.documents.indexes.vector.embedding import VectorEmbeddingType
 from ravendb.documents.indexes.vector.options import VectorOptions
+from ravendb.documents.operations.server_misc import ToggleDatabasesStateOperation
 from ravendb.tests.test_base import TestBase
 
 
 class Dto:
     def __init__(
         self,
-        embedding_base_64: str,
-        embedding_singles: List[float],
-        embedding_sbytes: List[int],
-        embedding_binary: List[int],
+        embedding_base_64: str = None,
+        embedding_singles: List[float] = None,
+        embedding_sbytes: List[int] = None,
+        embedding_binary: List[int] = None,
     ):
         self.embedding_base_64 = embedding_base_64
         self.embedding_singles = embedding_singles
@@ -24,7 +27,7 @@ class DummyIndex(AbstractIndexCreationTask):
     def __init__(self):
         super().__init__()
         self.map = """
-        from dto in docs.Dtos
+        from dto in docs.Dtoes
         select new 
         { 
             Singles = CreateVector(dto.embedding_singles), 
@@ -34,13 +37,14 @@ def __init__(self):
         """
         self._vector("Integers", VectorOptions(VectorEmbeddingType.INT8))
         self._vector("Binary", VectorOptions(VectorEmbeddingType.BINARY))
+        self.search_engine_type = SearchEngineType.CORAX
 
 
 class IndexWithSetDimensions(AbstractIndexCreationTask):
     def __init__(self):
         super().__init__()
         self.map = """
-        from dto in docs.Dtos
+        from dto in docs.Dtoes
         select new 
         {
             Singles = CreateVector(dto.embedding_singles) 
@@ -53,7 +57,7 @@ class IndexWithSetDimensionsInt8(AbstractIndexCreationTask):
     def __init__(self):
         super().__init__()
         self.map = """
-            from dto in docs.Dtos
+            from dto in docs.Dtoes
             select new 
             { 
                 Sbytes = CreateVector(dto.embedding_singles) 
@@ -91,7 +95,7 @@ def test_rql_generation(self):
             q7 = session.query(object_type=Dto).vector_search_text_i8("TextField", "aaaa")
             self.assertEqual("from 'Dtoes' where vector.search(embedding.text_i8(TextField), $p0)", q7._to_string())
 
-    def test_rql_generation_async(self):
+    def test_rql_generation_2(self):
         with self.store.open_session() as session:
 
             # -- Not applicable for Python - here we just don't have such methods in the API, making this impossible --
@@ -137,3 +141,53 @@ def test_rql_generation_async(self):
                 "EmbeddingBase64", "abcd==", is_exact=True, number_of_candidates=25
             )
             self.assertEqual("from 'Dtoes' where exact(vector.search(EmbeddingBase64, $p0, null, 25))", q8._to_string())
+
+    def test_embedding_dimensions_check(self):
+        with self.store.open_session() as session:
+            dto1 = Dto(embedding_singles=[0.5, -1.0])
+            dto2 = Dto(embedding_singles=[0.2, 0.3])
+
+            session.store(dto1)
+            session.store(dto2)
+
+            session.save_changes()
+
+            index = DummyIndex()
+
+            index.execute(self.store)
+
+            self.wait_for_indexing(self.store)
+
+            database_disable_result = self.store.maintenance.server.send(
+                ToggleDatabasesStateOperation(self.store.database, True)
+            )
+
+            self.assertTrue(database_disable_result.success)
+            self.assertTrue(database_disable_result.disabled)
+            self.assertEqual(database_disable_result.name, self.store.database)
+
+            database_enable_result = self.store.maintenance.server.send(
+                ToggleDatabasesStateOperation(self.store.database, False)
+            )
+
+            self.assertTrue(database_enable_result.success)
+            self.assertFalse(database_enable_result.disabled)
+            self.assertEqual(database_enable_result.name, self.store.database)
+
+            dto3 = Dto(embedding_singles=[0.1, 0.2])
+            session.store(dto3)
+            session.save_changes()
+
+            self.wait_for_indexing(self.store)
+
+            dto4 = Dto(embedding_singles=[0.5, 0.7, 0.9])
+            session.store(dto4)
+            session.save_changes()
+
+            index_errors = self.wait_for_indexing_errors(self.store, timeout=timedelta(seconds=5))
+
+            self.assertEqual(1, len(index_errors))
+            self.assertIn(
+                "Attempted to index embedding with 3 dimensions, but field Singles already contains indexed embedding with 2 dimensions, or was explicitly configured for embeddings with 2 dimensions.",
+                index_errors[0].errors[0].error,
+            )