RDBC-766 RDBC_501Test::shouldProperlyMapTypedEntries

poissoncorp · poissoncorp · commit 6041e81c4c02 · 2023-12-07T17:10:05.000+01:00
diff --git a/ravendb/documents/queries/time_series.py b/ravendb/documents/queries/time_series.py
@@ -1,7 +1,10 @@
 from __future__ import annotations
+
+import datetime
 from typing import Optional, Dict, Any, List, Type, TypeVar, Generic
 
-from ravendb.documents.session.time_series import TimeSeriesEntry, TypedTimeSeriesEntry
+from ravendb.documents.session.time_series import TimeSeriesEntry, TypedTimeSeriesEntry, TimeSeriesValuesHelper
+from ravendb.tools.utils import Utils
 
 _T_TS_Bindable = TypeVar("_T_TS_Bindable")
 
@@ -47,3 +50,139 @@ def from_json(cls, json_dict: Dict[str, Any]) -> TimeSeriesQueryResult:
             json_dict["Count"],
             [TypedTimeSeriesEntry.from_json(typed_ts_entry_json) for typed_ts_entry_json in json_dict["Results"]],
         )
+
+
+class TimeSeriesQueryBuilder:
+    def __init__(self, query: str = None):
+        self._query = query
+
+    @property
+    def query_text(self):
+        return self._query
+
+    def raw(self, query_text: str) -> TimeSeriesQueryResult:
+        self._query = query_text
+        return None
+
+
+class TimeSeriesRangeAggregation:
+    def __init__(
+        self,
+        count: List[int] = None,
+        max: List[float] = None,
+        min: List[float] = None,
+        last: List[float] = None,
+        first: List[float] = None,
+        average: List[float] = None,
+        sum: List[float] = None,
+        to_date: datetime.datetime = None,
+        from_date: datetime.datetime = None,
+    ):
+        self.count = count
+        self.max = max
+        self.min = min
+        self.last = last
+        self.first = first
+        self.average = average
+        self.sum = sum
+        self.to_date = to_date
+        self.from_date = from_date
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> TimeSeriesRangeAggregation:
+        return cls(
+            json_dict["Count"] if "Count" in json_dict else None,
+            json_dict["Max"] if "Max" in json_dict else None,
+            json_dict["Min"] if "Min" in json_dict else None,
+            json_dict["Last"] if "Last" in json_dict else None,
+            json_dict["First"] if "First" in json_dict else None,
+            json_dict["Average"] if "Average" in json_dict else None,
+            json_dict["Sum"] if "Sum" in json_dict else None,
+            Utils.string_to_datetime(json_dict["To"]),
+            Utils.string_to_datetime(json_dict["From"]),
+        )
+
+    def as_typed_entry(
+        self, ts_bindable_object_type: Type[_T_TS_Bindable]
+    ) -> TypedTimeSeriesRangeAggregation[_T_TS_Bindable]:
+        typed_entry = TypedTimeSeriesRangeAggregation()
+
+        typed_entry.from_date = self.from_date
+        typed_entry.to_date = self.to_date
+        typed_entry.min = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.min, False) if self.min else None
+        )
+        typed_entry.max = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.max, False) if self.max else None
+        )
+        typed_entry.first = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.first, False) if self.first else None
+        )
+        typed_entry.last = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.last, False) if self.last else None
+        )
+        typed_entry.sum = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.sum, False) if self.sum else None
+        )
+        counts = [float(count) for count in self.count]
+        typed_entry.count = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, counts, False) if self.count else None
+        )
+        typed_entry.average = (
+            TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, self.average, False) if self.average else None
+        )
+
+        return typed_entry
+
+
+class TypedTimeSeriesRangeAggregation(Generic[_T_TS_Bindable]):
+    def __init__(
+        self,
+        count: _T_TS_Bindable = None,
+        max: _T_TS_Bindable = None,
+        min: _T_TS_Bindable = None,
+        last: _T_TS_Bindable = None,
+        first: _T_TS_Bindable = None,
+        average: _T_TS_Bindable = None,
+        sum: _T_TS_Bindable = None,
+        to_date: datetime.datetime = None,
+        from_date: datetime.datetime = None,
+    ):
+        self.count = count
+        self.max = max
+        self.min = min
+        self.last = last
+        self.first = first
+        self.average = average
+        self.sum = sum
+        self.to_date = to_date
+        self.from_date = from_date
+
+
+class TypedTimeSeriesAggregationResult(TimeSeriesQueryResult, Generic[_T_TS_Bindable]):
+    def __init__(
+        self, count: Optional[int] = None, results: List[TypedTimeSeriesRangeAggregation[_T_TS_Bindable]] = None
+    ):
+        super(TypedTimeSeriesAggregationResult, self).__init__(count)
+        self.results = results
+
+
+class TimeSeriesAggregationResult(TimeSeriesQueryResult):
+    def __init__(self, count: Optional[int] = None, results: Optional[List[TimeSeriesRangeAggregation]] = None):
+        super().__init__(count)
+        self.results = results
+
+    def as_typed_result(
+        self, ts_bindable_object_type: Type[_T_TS_Bindable]
+    ) -> TypedTimeSeriesAggregationResult[_T_TS_Bindable]:
+        result = TypedTimeSeriesAggregationResult()
+        result.count = self.count
+        result.results = [x.as_typed_entry(ts_bindable_object_type) for x in self.results]
+        return result
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> TimeSeriesQueryResult:
+        json_dict = json_dict["__timeSeriesQueryFunction"]
+        return cls(
+            json_dict["Count"], [TimeSeriesRangeAggregation.from_json(result) for result in json_dict["Results"]]
+        )
diff --git a/ravendb/documents/session/query.py b/ravendb/documents/session/query.py
@@ -19,6 +19,7 @@
     TYPE_CHECKING,
 )
 
+from ravendb.documents.queries.time_series import TimeSeriesQueryBuilder
 from ravendb.documents.session.time_series import TimeSeriesRange
 from ravendb.primitives import constants
 from ravendb.documents.conventions import DocumentConventions
@@ -93,6 +94,7 @@
 _T = TypeVar("_T")
 _TResult = TypeVar("_TResult")
 _TProjection = TypeVar("_TProjection")
+_T_TS_Bindable = TypeVar("_T_TS_Bindable")
 if TYPE_CHECKING:
     from ravendb.documents.store.definition import Lazy
     from ravendb.documents.session.document_session import DocumentSession
@@ -1298,8 +1300,13 @@ def _get_source_alias_if_exists(object_type: type, query_data: QueryData, fields
 
         return possible_alias
 
-    # todo: def _create_time_series_query_data(time_series_query: Callable[[TimeSeriesQueryBuilder], None])
-    #  -> QueryData:
+    def _create_time_series_query_data(self, time_series_query: Callable[[TimeSeriesQueryBuilder], None]) -> QueryData:
+        builder = TimeSeriesQueryBuilder()
+        time_series_query(builder)
+
+        fields = [constants.TimeSeries.SELECT_FIELD_NAME + "(" + builder.query_text + ")"]
+        projections = [constants.TimeSeries.QUERY_FUNCTION]
+        return QueryData(fields, projections)
 
     def _add_before_query_executed_listener(self, action: Callable[[IndexQuery], None]) -> None:
         self._before_query_executed_callback.append(action)
@@ -1741,7 +1748,11 @@ def __init__(
             is_project_into,
         )
 
-    # todo: selectTimeSeries
+    def select_time_series(
+        self, ts_bindable_object_type: Type[_T_TS_Bindable], time_series_query: Callable[[TimeSeriesQueryBuilder], None]
+    ) -> DocumentQuery[_T_TS_Bindable]:
+        query_data = self._create_time_series_query_data(time_series_query)
+        return self.select_fields_query_data(ts_bindable_object_type, query_data)
 
     def distinct(self) -> DocumentQuery[_T]:
         self._distinct()
diff --git a/ravendb/tests/jvm_migrated_tests/issues_tests/test_RDBC_501.py b/ravendb/tests/jvm_migrated_tests/issues_tests/test_RDBC_501.py
@@ -0,0 +1,87 @@
+from datetime import timedelta
+from typing import Dict, Tuple, Optional
+
+from ravendb.documents.queries.time_series import TimeSeriesAggregationResult
+from ravendb.documents.session.time_series import ITimeSeriesValuesBindable
+from ravendb.tests.test_base import TestBase
+from ravendb.tools.raven_test_helper import RavenTestHelper
+
+
+class MarkerSymbol:
+    def __init__(self, Id: str = None):
+        self.Id = Id
+
+
+class SymbolPrice(ITimeSeriesValuesBindable):
+    def __init__(self, open: float = None, close: float = None, high: float = None, low: float = None):
+        self.open = open
+        self.close = close
+        self.high = high
+        self.low = low
+
+    def get_time_series_mapping(self) -> Dict[int, Tuple[str, Optional[str]]]:
+        return {
+            0: ("open", None),
+            1: ("close", None),
+            2: ("high", None),
+            3: ("low", None),
+        }
+
+
+class TestRDBC501(TestBase):
+    def setUp(self):
+        super(TestRDBC501, self).setUp()
+
+    def test_should_properly_map_typed_entries(self):
+        base_line = RavenTestHelper.utc_today()
+        with self.store.open_session() as session:
+            symbol = MarkerSymbol()
+            session.store(symbol, "markerSymbols/1-A")
+
+            price1 = SymbolPrice(4, 7, 10, 1)
+            price2 = SymbolPrice(24, 27, 210, 21)
+            price3 = SymbolPrice(34, 37, 310, 321)
+
+            tsf = session.typed_time_series_for_entity(SymbolPrice, symbol, "history")
+            tsf.append(base_line + timedelta(hours=1), price1)
+            tsf.append(base_line + timedelta(hours=2), price2)
+            tsf.append(base_line + timedelta(days=2), price3)
+
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            aggregated_history_query_result = (
+                session.query(object_type=MarkerSymbol)
+                .select_time_series(
+                    TimeSeriesAggregationResult,
+                    lambda b: b.raw(
+                        "from history\n"
+                        + "          group by '1 days'\n"
+                        + "          select first(), last(), min(), max()"
+                    ),
+                )
+                .first()
+            )
+
+            self.assertEqual(2, len(aggregated_history_query_result.results))
+
+            typed = aggregated_history_query_result.as_typed_result(SymbolPrice)
+
+            self.assertEqual(2, len(typed.results))
+
+            first_result = typed.results[0]
+            self.assertEqual(4, first_result.min.open)
+            self.assertEqual(7, first_result.min.close)
+            self.assertEqual(1, first_result.min.low)
+            self.assertEqual(10, first_result.min.high)
+
+            self.assertEqual(4, first_result.first.open)
+            self.assertEqual(7, first_result.first.close)
+            self.assertEqual(1, first_result.first.low)
+            self.assertEqual(10, first_result.first.high)
+
+            second_result = typed.results[1]
+            self.assertEqual(34, second_result.min.open)
+            self.assertEqual(37, second_result.min.close)
+            self.assertEqual(321, second_result.min.low)
+            self.assertEqual(310, second_result.min.high)
