RDBC-698 TimeSeriesIncludesTest::queryWithIncludeTimeSeries, TimeSeriesIncludesTest::includeTimeSeriesAndMergeWithExistingRangesInCache

Author: poissoncorp

ravendb/documents/session/document_session.py

@@ -1760,6 +1760,10 @@ def append_single(self, timestamp: datetime, value: float, tag: Optional[str] =
         self.append(timestamp, [value], tag)
 
     def append(self, timestamp: datetime, values: List[float], tag: Optional[str] = None) -> None:
+        if not isinstance(values, List):
+            raise TypeError(
+                f"The 'values' arg must be a list. If you want to append single float use 'append_single(..)' instead."
+            )
         document_info = self.session.documents_by_id.get_value(self.doc_id)
         if document_info is not None and document_info.entity in self.session.deleted_entities:
             self._throw_document_already_deleted_in_session(self.doc_id, self.name)

ravendb/tests/jvm_migrated_tests/client_tests/time_series_tests/test_time_series_includes.py

@@ -1,6 +1,8 @@
 from datetime import datetime, timedelta
 
+from ravendb.documents.session.time_series import TimeSeriesRangeType
 from ravendb.infrastructure.orders import Company, Order
+from ravendb.primitives.time_series import TimeValue
 from ravendb.tests.test_base import TestBase, User
 
 
@@ -273,3 +275,301 @@ def test_include_multiple_time_series(self):
 
             self.assertEqual(base_line + timedelta(minutes=15), vals[0].timestamp)
             self.assertEqual(base_line + timedelta(minutes=25), vals[60].timestamp)
+
+    def test_include_time_series_and_merge_with_existing_ranges_in_cache(self):
+        document_id = "users/gracjan"
+        base_line = datetime(2023, 8, 20, 21, 30)
+        ts_name = "Heartrate"
+
+        with self.store.open_session() as session:
+            session.store(User(name="Gracjan"), document_id)
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            tsf = session.time_series_for(document_id, ts_name)
+            for i in range(360):
+                tsf.append_single(base_line + timedelta(seconds=10 * i), 6, "watches/fitbit")
+
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=2), base_line + timedelta(minutes=10)
+            )
+            self.assertEqual(1, session.advanced.number_of_requests)
+            self.assertEqual(49, len(vals))
+            self.assertEqual(base_line + timedelta(minutes=2), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=10), vals[48].timestamp)
+
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series(
+                    ts_name, base_line + timedelta(minutes=40), base_line + timedelta(minutes=50)
+                ),
+            )
+            self.assertEqual(2, session.advanced.number_of_requests)
+
+            # should not go to server
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=40), base_line + timedelta(minutes=50)
+            )
+            self.assertEqual(2, session.advanced.number_of_requests)
+
+            self.assertEqual(61, len(vals))
+
+            self.assertEqual(base_line + timedelta(minutes=40), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=50), vals[60].timestamp)
+
+            cache = session.time_series_by_doc_id.get(document_id)
+            self.assertIsNotNone(cache)
+            ranges = cache.get(ts_name)
+            self.assertEqual(2, len(ranges))
+
+            self.assertEqual(base_line + timedelta(minutes=2), ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=10), ranges[0].to_date)
+            self.assertEqual(base_line + timedelta(minutes=40), ranges[1].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[1].to_date)
+
+            # we intentionally evict just the document (without it's TS data),
+            # so that Load request will go to server
+
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get [0, 2] and merge it into existing [2, 10]
+            user = session.load(
+                document_id, User, lambda i: i.include_time_series(ts_name, base_line, base_line + timedelta(minutes=2))
+            )
+
+            self.assertEqual(3, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(base_line, base_line + timedelta(minutes=2))
+
+            self.assertEqual(3, session.advanced.number_of_requests)
+
+            self.assertEqual(13, len(vals))
+            self.assertEqual(base_line, vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=2), vals[12].timestamp)
+
+            self.assertEqual(2, len(ranges))
+            self.assertEqual(base_line + timedelta(minutes=0), ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=10), ranges[0].to_date)
+            self.assertEqual(base_line + timedelta(minutes=40), ranges[1].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[1].to_date)
+
+            # evict just the document
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get [10, 16] and merge it into existing [0, 10]
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series(
+                    ts_name, base_line + timedelta(minutes=10), base_line + timedelta(minutes=16)
+                ),
+            )
+
+            self.assertEqual(4, session.advanced.number_of_requests)
+
+            # should not go to server
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=10), base_line + timedelta(minutes=16)
+            )
+            self.assertEqual(4, session.advanced.number_of_requests)
+
+            self.assertEqual(37, len(vals))
+            self.assertEqual(base_line + timedelta(minutes=10), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=16), vals[36].timestamp)
+
+            self.assertEqual(2, len(ranges))
+
+            self.assertEqual(base_line, ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=16), ranges[0].to_date)
+            self.assertEqual(base_line + timedelta(minutes=40), ranges[1].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[1].to_date)
+
+            # evict just the document
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get range [17, 19]
+            # and add it to cache in between [10, 16] and [40, 50]
+
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series(
+                    ts_name, base_line + timedelta(minutes=17), base_line + timedelta(minutes=19)
+                ),
+            )
+
+            self.assertEqual(5, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=17), base_line + timedelta(minutes=19)
+            )
+
+            self.assertEqual(5, session.advanced.number_of_requests)
+
+            self.assertEqual(13, len(vals))
+            self.assertEqual(base_line + timedelta(minutes=17), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=19), vals[12].timestamp)
+
+            self.assertEqual(3, len(ranges))
+            self.assertEqual(base_line, ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=16), ranges[0].to_date)
+            self.assertEqual(base_line + timedelta(minutes=17), ranges[1].from_date)
+            self.assertEqual(base_line + timedelta(minutes=19), ranges[1].to_date)
+            self.assertEqual(base_line + timedelta(minutes=40), ranges[2].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[2].to_date)
+
+            # evict just the document
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get range [19, 40]
+            # and merge the result with existing ranges [17, 19] and [40, 50]
+            # into single range [17, 50]
+
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series(
+                    ts_name, base_line + timedelta(minutes=18), base_line + timedelta(minutes=48)
+                ),
+            )
+
+            self.assertEqual(6, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=18), base_line + timedelta(minutes=48)
+            )
+
+            self.assertEqual(6, session.advanced.number_of_requests)
+
+            self.assertEqual(181, len(vals))
+            self.assertEqual(base_line + timedelta(minutes=18), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=48), vals[180].timestamp)
+
+            self.assertEqual(2, len(ranges))
+            self.assertEqual(base_line, ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=16), ranges[0].to_date)
+            self.assertEqual(base_line + timedelta(minutes=17), ranges[1].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[1].to_date)
+
+            # evict just the document
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get range [12, 22]
+            # and merge the result with existing ranges [0, 16] and [17, 50]
+            # into single range [0, 50]
+
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series(
+                    ts_name, base_line + timedelta(minutes=12), base_line + timedelta(minutes=22)
+                ),
+            )
+
+            self.assertEqual(7, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(
+                base_line + timedelta(minutes=12), base_line + timedelta(minutes=22)
+            )
+
+            self.assertEqual(7, session.advanced.number_of_requests)
+
+            self.assertEqual(61, len(vals))
+            self.assertEqual(base_line + timedelta(minutes=12), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=22), vals[60].timestamp)
+
+            self.assertEqual(1, len(ranges))
+            self.assertEqual(base_line, ranges[0].from_date)
+            self.assertEqual(base_line + timedelta(minutes=50), ranges[0].to_date)
+
+            # evict just the document
+            session.documents_by_entity.evict(user)
+            session.documents_by_id.remove(document_id)
+
+            # should go to server to get range [50, ∞]
+            # and merge the result with existing range [0, 50] into single range [0, ∞]
+
+            user = session.load(
+                document_id,
+                User,
+                lambda i: i.include_time_series_time_value(ts_name, TimeSeriesRangeType.LAST, TimeValue.of_minutes(10)),
+            )
+
+            self.assertEqual(8, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(base_line + timedelta(minutes=50), None)
+
+            self.assertEqual(8, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(base_line + timedelta(minutes=50), None)
+
+            self.assertEqual(8, session.advanced.number_of_requests)
+
+            self.assertEqual(60, len(vals))
+
+            self.assertEqual(base_line + timedelta(minutes=50), vals[0].timestamp)
+            self.assertEqual(base_line + timedelta(minutes=59, seconds=50), vals[59].timestamp)
+
+            self.assertEqual(1, len(ranges))
+            self.assertEqual(base_line, ranges[0].from_date)
+            self.assertEqual(None, ranges[0].to_date)
+
+    def test_query_with_include_time_series(self):
+        document_id = "users/gracjan"
+        base_line = datetime(2023, 8, 20, 21, 30)
+        ts_name = "Heartrate"
+        tag = "watches/fitbit"
+
+        with self.store.open_session() as session:
+            session.store(User(name="Gracjan"), document_id)
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            tsf = session.time_series_for(document_id, ts_name)
+
+            for i in range(360):
+                tsf.append_single(base_line + timedelta(seconds=i * 10), 67, tag)
+
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            query = session.query(object_type=User).include(lambda i: i.include_time_series(ts_name))
+
+            result = list(query)
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+
+            self.assertEqual("Gracjan", result[0].name)
+
+            # should not go to server
+
+            vals = session.time_series_for(document_id, ts_name).get(base_line, base_line + timedelta(minutes=30))
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+
+            self.assertEqual(181, len(vals))
+            self.assertEqual(base_line, vals[0].timestamp)
+            self.assertEqual(tag, vals[0].tag)
+            self.assertEqual(67, vals[0].values[0])
+            self.assertEqual(base_line + timedelta(minutes=30), vals[180].timestamp)