RDBC-766 Indexes

poissoncorp · poissoncorp · commit 49dd5460a51c · 2023-12-07T15:56:04.000+01:00
diff --git a/ravendb/documents/indexes/time_series.py b/ravendb/documents/indexes/time_series.py
@@ -11,6 +11,8 @@
     FieldStorage,
     FieldIndexing,
     FieldTermVector,
+    IndexFieldOptions,
+    IndexType,
 )
 from ravendb.documents.indexes.index_creation import AbstractIndexCreationTaskBase, AbstractIndexDefinitionBuilder
 from ravendb.documents.indexes.spatial.configuration import SpatialOptions, SpatialOptionsFactory
@@ -188,3 +190,81 @@ def create_index_definition(self) -> Union[IndexDefinition, _T_IndexDefinition]:
         index_definition.maps = set(self.maps)
 
         return index_definition
+
+
+class AbstractJavaScriptTimeSeriesIndexCreationTask(AbstractIndexCreationTaskBase[TimeSeriesIndexDefinition]):
+    def __init__(
+        self,
+        conventions: DocumentConventions = None,
+        priority: IndexPriority = None,
+        lock_mode: IndexLockMode = None,
+        deployment_mode: IndexDeploymentMode = None,
+        state: IndexState = None,
+    ):
+        super().__init__(conventions, priority, lock_mode, deployment_mode, state)
+        self._definition = TimeSeriesIndexDefinition()
+
+    @property
+    def maps(self) -> Set[str]:
+        return self._definition.maps
+
+    @maps.setter
+    def maps(self, maps: Set[str]):
+        self._definition.maps = maps
+
+    @property
+    def fields(self) -> Dict[str, IndexFieldOptions]:
+        return self._definition.fields
+
+    @fields.setter
+    def fields(self, fields: Dict[str, IndexFieldOptions]):
+        self._definition.fields = fields
+
+    @property
+    def reduce(self) -> str:
+        return self._definition.reduce
+
+    @reduce.setter
+    def reduce(self, reduce: str):
+        self._definition.reduce = reduce
+
+    def is_map_reduce(self) -> bool:
+        return self.reduce is not None
+
+    @property
+    def output_reduce_to_collection(self) -> str:
+        return self._definition.output_reduce_to_collection
+
+    @output_reduce_to_collection.setter
+    def output_reduce_to_collection(self, output_reduce_to_collection: str):
+        self._definition.output_reduce_to_collection = output_reduce_to_collection
+
+    @property
+    def pattern_references_collection_name(self) -> str:
+        return self._definition.pattern_references_collection_name
+
+    @pattern_references_collection_name.setter
+    def pattern_references_collection_name(self, pattern_references_collection_name: str):
+        self._definition.pattern_references_collection_name = pattern_references_collection_name
+
+    @property
+    def pattern_for_output_reduce_to_collection_references(self) -> str:
+        return self._definition.pattern_for_output_reduce_to_collection_references
+
+    @pattern_for_output_reduce_to_collection_references.setter
+    def pattern_for_output_reduce_to_collection_references(self, pattern_for_output_reduce_to_collection_references):
+        self._definition.pattern_for_output_reduce_to_collection_references = (
+            pattern_for_output_reduce_to_collection_references
+        )
+
+    def create_index_definition(self) -> TimeSeriesIndexDefinition:
+        self._definition.name = self.index_name
+        self._definition.type = IndexType.JAVA_SCRIPT_MAP_REDUCE if self.is_map_reduce() else IndexType.JAVA_SCRIPT_MAP
+        self._definition.additional_sources = self.additional_sources or {}
+        self._definition.additional_assemblies = self.additional_assemblies or set()
+        self._definition.configuration = self.configuration
+        self._definition.lock_mode = self.lock_mode
+        self._definition.priority = self.priority
+        self._definition.state = self.state
+        self._definition.deployment_mode = self.deployment_mode
+        return self._definition
diff --git a/ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/time_series_tests/test_basic_time_series_indexes_java_script.py b/ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/time_series_tests/test_basic_time_series_indexes_java_script.py
@@ -1,8 +1,10 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from ravendb import GetTermsOperation
 from ravendb.documents.indexes.index_creation import AbstractJavaScriptIndexCreationTask
-from ravendb.infrastructure.orders import Company
+from ravendb.documents.indexes.time_series import AbstractJavaScriptTimeSeriesIndexCreationTask
+from ravendb.infrastructure.entities import User
+from ravendb.infrastructure.orders import Company, Employee, Address
 from ravendb.tests.test_base import TestBase
 from ravendb.tools.raven_test_helper import RavenTestHelper
 
@@ -58,3 +60,252 @@ def test_time_series_names_for(self):
         terms = self.store.maintenance.send(GetTermsOperation(index.index_name, "names_IsArray", None))
         self.assertEqual(1, len(terms))
         self.assertIn("true", terms)
+
+    def test_basic_map_index_with_load(self):
+        now1 = datetime.utcnow()
+        now2 = now1 + timedelta(seconds=1)
+
+        with self.store.open_session() as session:
+            employee = Employee(first_name="John")
+            session.store(employee, "employees/1")
+            company = Company()
+            session.store(company, "companies/1")
+
+            session.time_series_for_entity(company, "HeartRate").append_single(now1, 7.0, employee.Id)
+
+            company2 = Company()
+            session.store(company2, "companies/11")
+
+            session.time_series_for_entity(company2, "HeartRate").append_single(now1, 11.0, employee.Id)
+
+            session.save_changes()
+
+        time_series_index = MyTsIndex_Load()
+        index_name = time_series_index.index_name
+        index_definition = time_series_index.create_index_definition()
+
+        time_series_index.execute(self.store)
+
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "employee", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("john", terms)
+
+        with self.store.open_session() as session:
+            employee = session.load("employees/1", Employee)
+            employee.first_name = "Bob"
+            session.save_changes()
+
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "employee", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("bob", terms)
+
+        with self.store.open_session() as session:
+            session.delete("employees/1")
+            session.save_changes()
+
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "employee", None))
+        self.assertEqual(0, len(terms))
+
+    def test_basic_map_reduce_index_with_load(self):
+        today = RavenTestHelper.utc_today()
+
+        with self.store.open_session() as session:
+            address = Address()
+            address.city = "NY"
+
+            session.store(address, "addresses/1")
+
+            user = User(address_id=address.Id)
+            session.store(user, "users/1")
+
+            for i in range(10):
+                session.time_series_for_entity(user, "heartRate").append_single(
+                    today + timedelta(hours=i), 180 + i, address.Id
+                )
+
+            session.save_changes()
+
+        time_series_index = AverageHeartRateDaily_ByDateAndCity()
+        index_name = time_series_index.index_name
+        index_definition = time_series_index.create_index_definition()
+
+        time_series_index.execute(self.store)
+
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "heart_beat", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("184.5", terms)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "date", None))
+        self.assertEqual(1, len(terms))
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "city", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("ny", terms)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "count", None))
+        self.assertEqual(1, len(terms))
+        self.assertEqual("10", terms[0])
+
+        with self.store.open_session() as session:
+            address = session.load("addresses/1", Address)
+            address.city = "LA"
+            session.save_changes()
+
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation(index_name, "city", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("la", terms)
+
+    def test_can_map_all_time_series_from_collection(self):
+        now1 = datetime.utcnow()
+        now2 = now1 + timedelta(seconds=1)
+
+        with self.store.open_session() as session:
+            company = Company()
+            session.store(company, "companies/1")
+            session.time_series_for_entity(company, "heartRate").append_single(now1, 7.0, "tag1")
+            session.time_series_for_entity(company, "likes").append_single(now1, 3.0, "tag2")
+
+            session.save_changes()
+
+        MyTsIndex_AllTimeSeries().execute(self.store)
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation("MyTsIndex/AllTimeSeries", "heart_beat", None))
+        self.assertEqual(2, len(terms))
+        self.assertIn("7", terms)
+        self.assertIn("3", terms)
+
+    def test_basic_multi_map_index(self):
+        now = RavenTestHelper.utc_today()
+
+        time_series_index = MyMultiMapTsIndex()
+        time_series_index.execute(self.store)
+        with self.store.open_session() as session:
+            company = Company()
+            session.store(company)
+
+            session.time_series_for_entity(company, "heartRate").append_single(now, 2.5, "tag1")
+            session.time_series_for_entity(company, "heartRate2").append_single(now, 3.5, "tag2")
+
+            user = User()
+            session.store(user)
+            session.time_series_for_entity(user, "heartRate").append_single(now, 4.5, "tag3")
+
+            session.save_changes()
+
+        self.wait_for_indexing(self.store)
+
+        with self.store.open_session() as session:
+            results = list(session.query_index_type(MyMultiMapTsIndex, MyMultiMapTsIndex.Result))
+            self.assertEqual(3, len(results))
+
+
+class MyTsIndex_Load(AbstractJavaScriptTimeSeriesIndexCreationTask):
+    def __init__(self):
+        super().__init__()
+        self.maps = [
+            "timeSeries.map('Companies', 'HeartRate', function (ts) {\n"
+            + "return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Value,\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        user: ts.DocumentId,\n"
+            + "        employee: load(entry.Tag, 'Employees').first_name\n"
+            + "    }));\n"
+            + "})"
+        ]
+
+
+class MyTsIndex_AllTimeSeries(AbstractJavaScriptTimeSeriesIndexCreationTask):
+    def __init__(self):
+        super().__init__()
+        self.maps = [
+            "timeSeries.map('Companies', function (ts) {\n"
+            + " return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Values[0],\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        user: ts.documentId\n"
+            + "    }));\n"
+            + " })"
+        ]
+
+
+class AverageHeartRateDaily_ByDateAndCity(AbstractJavaScriptTimeSeriesIndexCreationTask):
+    class Result:
+        def __init__(self, heart_beat: float = None, date: datetime = None, city: str = None, count: int = None):
+            self.heart_beat = heart_beat
+            self.date = date
+            self.city = city
+            self.count = count
+
+    def __init__(self):
+        super(AverageHeartRateDaily_ByDateAndCity, self).__init__()
+        self.maps = [
+            "timeSeries.map('Users', 'heartRate', function (ts) {\n"
+            + "return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Value,\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        city: load(entry.Tag, 'Addresses').city,\n"
+            + "        count: 1\n"
+            + "    }));\n"
+            + "})"
+        ]
+
+        self.reduce = (
+            "groupBy(r => ({ date: r.date, city: r.city }))\n"
+            " .aggregate(g => ({\n"
+            "     heart_beat: g.values.reduce((total, val) => val.heart_beat + total, 0) / g.values.reduce((total, val) => val.count + total, 0),\n"
+            "     date: g.key.date,\n"
+            "     city: g.key.city\n"
+            "     count: g.values.reduce((total, val) => val.count + total, 0)\n"
+            " }))"
+        )
+
+
+class MyMultiMapTsIndex(AbstractJavaScriptTimeSeriesIndexCreationTask):
+    class Result:
+        def __init__(self, heart_beat: float = None, date: datetime = None, user: str = None):
+            self.heart_beat = heart_beat
+            self.date = date
+            self.user = user
+
+    def __init__(self):
+        super(MyMultiMapTsIndex, self).__init__()
+        self.maps = set()
+        self.maps.add(
+            "timeSeries.map('Companies', 'HeartRate', function (ts) {\n"
+            + "return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Values[0],\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        user: ts.DocumentId\n"
+            + "    }));\n"
+            + "})"
+        )
+
+        self.maps.add(
+            "timeSeries.map('Companies', 'HeartRate2', function (ts) {\n"
+            + "return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Values[0],\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        user: ts.DocumentId\n"
+            + "    }));\n"
+            + "})"
+        )
+        self.maps.add(
+            "timeSeries.map('Users', 'HeartRate', function (ts) {\n"
+            + "return ts.Entries.map(entry => ({\n"
+            + "        heart_beat: entry.Values[0],\n"
+            + "        date: new Date(entry.Timestamp.getFullYear(), entry.Timestamp.getMonth(), entry.Timestamp.getDate()),\n"
+            + "        user: ts.DocumentId\n"
+            + "    }));\n"
+            + "})"
+        )
diff --git a/ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/time_series_tests/test_basic_time_series_indexes_mixed_syntax.py b/ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/time_series_tests/test_basic_time_series_indexes_mixed_syntax.py
@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from ravendb import PutIndexesOperation, GetTermsOperation
+from ravendb.documents.indexes.time_series import TimeSeriesIndexDefinition
+from ravendb.infrastructure.orders import Company
+from ravendb.tests.test_base import TestBase
+
+
+class TestBasicTimeSeriesIndexes_MixedSyntax(TestBase):
+    def setUp(self):
+        super(TestBasicTimeSeriesIndexes_MixedSyntax, self).setUp()
+
+    def test_basic_map_index(self):
+        now1 = datetime.utcnow()
+
+        with self.store.open_session() as session:
+            company = Company()
+            session.store(company, "companies/1")
+            session.time_series_for_entity(company, "HeartRate").append_single(now1, 7, "tag")
+            session.save_changes()
+
+        time_series_index_definition = TimeSeriesIndexDefinition()
+        time_series_index_definition.name = "MyTsIndex"
+        time_series_index_definition.maps = [
+            "from ts in timeSeries.Companies.HeartRate.Where(x => true) "
+            + "from entry in ts.Entries "
+            + "select new { "
+            + "   heartBeat = entry.Values[0], "
+            + "   date = entry.Timestamp.Date, "
+            + "   user = ts.DocumentId "
+            + "}"
+        ]
+
+        self.store.maintenance.send(PutIndexesOperation(time_series_index_definition))
+        self.wait_for_indexing(self.store)
+
+        terms = self.store.maintenance.send(GetTermsOperation("MyTsIndex", "heartBeat", None))
+        self.assertEqual(1, len(terms))
+        self.assertIn("7", terms)
