RDBC-698 TimeSeriesIncludesTest::canLoadAsyncWithIncludeTimeSeries_LastRange_ByCount

Author: poissoncorp

ravendb/documents/commands/crud.py

@@ -250,14 +250,12 @@ def create_request(self, node: ServerNode) -> requests.Request:
             for include in self._includes:
                 path_builder.append(f"&include={include}")
 
-        # todo: counters
         if self._include_all_counters:
             path_builder.append(f"&counter={constants.Counters.ALL}")
         elif self._counters:
             for counter in self._counters:
                 path_builder.append(f"&counter={counter}")
 
-        # todo: time series
         if self._time_series_includes is not None:
             for ts_include in self._time_series_includes:
                 if isinstance(ts_include, TimeSeriesRange):
@@ -279,7 +277,7 @@ def create_request(self, node: ServerNode) -> requests.Request:
                     count_range: TimeSeriesCountRange = ts_include
                     path_builder.append(
                         f"&timeseriescount={count_range.name}"
-                        f"&countType={count_range.type}"
+                        f"&countType={count_range.type.value}"
                         f"&countValue={count_range.count}"
                     )
                 else:

ravendb/documents/session/loaders/include.py

@@ -8,7 +8,12 @@
 from ravendb.primitives.time_series import TimeValue
 from ravendb.tools.utils import CaseInsensitiveDict, CaseInsensitiveSet
 
-from ravendb.documents.session.time_series import TimeSeriesRange, TimeSeriesTimeRange, TimeSeriesRangeType
+from ravendb.documents.session.time_series import (
+    TimeSeriesRange,
+    TimeSeriesTimeRange,
+    TimeSeriesRangeType,
+    TimeSeriesCountRange,
+)
 
 
 class IncludeBuilderBase:
@@ -169,6 +174,33 @@ def _include_time_series_by_range_type_and_time(
         time_range = TimeSeriesTimeRange(name, time, type_)
         hash_set.add(time_range)
 
+    def _include_time_series_by_range_type_and_count(
+        self, alias: str, name: str, type_: TimeSeriesRangeType, count: int
+    ) -> None:
+        self._assert_valid(alias, name)
+        self._assert_valid_type_and_count(type_, count)
+
+        if self.time_series_to_include_by_source_alias is None:
+            self._time_series_to_include_by_source_alias = {}
+
+        hash_set = self._time_series_to_include_by_source_alias.get(alias, None)
+        if hash_set is None:
+            hash_set = set()
+            self._time_series_to_include_by_source_alias[alias] = hash_set
+
+        count_range = TimeSeriesCountRange(name, count, type_)
+        hash_set.add(count_range)
+
+    @staticmethod
+    def _assert_valid_type_and_count(type_: TimeSeriesRangeType, count: int) -> None:
+        if type_ == TimeSeriesRangeType.NONE:
+            raise ValueError("Time range type cannot be set to NONE when time is specified.")
+        elif type_ == TimeSeriesRangeType.LAST:
+            if count <= 0:
+                raise ValueError("Count have to be positive")
+        else:
+            raise ValueError(f"Not supported time range type {type_.value}")
+
     @staticmethod
     def _assert_valid_type(type_: TimeSeriesRangeType, time: TimeValue) -> None:
         if type_ == TimeSeriesRangeType.NONE:
@@ -216,13 +248,19 @@ def include_time_series(
         self._include_time_series_from_to(alias, name, from_date, to_date)
         return self
 
-    def include_time_series_time_value(
+    def include_time_series_by_range_type_and_time(
         self, name: Optional[str], type_: TimeSeriesRangeType, time: TimeValue
-    ) -> IncludeBuilder:
+    ) -> IncludeBuilderBase:
         self._include_time_series_by_range_type_and_time("", name, type_, time)
         return self
 
-    def include_all_time_series(self, type_: TimeSeriesRangeType, time: TimeValue) -> IncludeBuilder:
+    def include_time_series_by_range_type_and_count(
+        self, name: str, type_: TimeSeriesRangeType, count: int
+    ) -> IncludeBuilderBase:
+        self._include_time_series_by_range_type_and_count("", name, type_, count)
+        return self
+
+    def include_all_time_series(self, type_: TimeSeriesRangeType, time: TimeValue) -> IncludeBuilderBase:
         self._include_time_series_by_range_type_and_time("", constants.TimeSeries.ALL, type_, time)
         return self
 

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

@@ -509,7 +509,9 @@ def test_include_time_series_and_merge_with_existing_ranges_in_cache(self):
             user = session.load(
                 document_id,
                 User,
-                lambda i: i.include_time_series_time_value(ts_name, TimeSeriesRangeType.LAST, TimeValue.of_minutes(10)),
+                lambda i: i.include_time_series_by_range_type_and_time(
+                    ts_name, TimeSeriesRangeType.LAST, TimeValue.of_minutes(10)
+                ),
             )
 
             self.assertEqual(8, session.advanced.number_of_requests)
@@ -573,3 +575,49 @@ def test_query_with_include_time_series(self):
             self.assertEqual(tag, vals[0].tag)
             self.assertEqual(67, vals[0].values[0])
             self.assertEqual(base_line + timedelta(minutes=30), vals[180].timestamp)
+
+    def test_can_load_async_with_include_time_series_last_range_by_count(self):
+        company_id = "companies/1-A"
+        order_id = "orders/1-A"
+        base_line = datetime(2023, 8, 20, 21, 30)
+        ts_name = "Heartrate"
+        tag = "watches/fitbit"
+
+        with self.store.open_session() as session:
+            session.store(Company(name="HR"), company_id)
+            session.store(Order(company=company_id), order_id)
+            tsf = session.time_series_for(order_id, ts_name)
+
+            for i in range(15):
+                tsf.append_single(base_line - timedelta(minutes=i), i, tag)
+
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            order = session.load(
+                order_id,
+                Order,
+                lambda i: i.include_documents("company").include_time_series_by_range_type_and_count(
+                    ts_name, TimeSeriesRangeType.LAST, 11
+                ),
+            )
+            self.assertEqual(1, session.advanced.number_of_requests)
+
+            # should not go to server
+
+            company = session.load(order.company, Company)
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+            self.assertEqual("HR", company.name)
+
+            # should not go to server
+            values = session.time_series_for(order_id, ts_name).get(base_line - timedelta(minutes=10), None)
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+            self.assertEqual(11, len(values))
+
+            for i in range(len(values)):
+                self.assertEqual(1, len(values[i].values))
+                self.assertEqual(len(values) - 1 - i, values[i].values[0])
+                self.assertEqual(tag, values[i].tag)
+                self.assertEqual(base_line - timedelta(minutes=len(values) - 1 - i), values[i].timestamp)

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_16060.py

@@ -376,7 +376,7 @@ def test_include_time_series_and_merge_with_existing_ranges_in_cache_typed(self)
             user = session.load(
                 doc_id,
                 User,
-                lambda i: i.include_time_series_time_value(
+                lambda i: i.include_time_series_by_range_type_and_time(
                     "heartRateMeasures", TimeSeriesRangeType.LAST, TimeValue.of_minutes(10)
                 ),
             )