Add changelog entries

Author: syvb

Changelog.md

@@ -11,6 +11,9 @@ This changelog should be updated as part of a PR if the work is worth noting (mo
 #### Bug fixes
 
 #### Other notable changes
+- [#692](https://github.com/timescale/timescaledb-toolkit/pull/692): Support specifying a range to `duration_in` to specify a time range to get states in for state aggregates
+- [#692](https://github.com/timescale/timescaledb-toolkit/pull/692): Removed `next` parameter from interpolated state aggregate functions
+- [#692](https://github.com/timescale/timescaledb-toolkit/pull/692): Renamed `state_agg` to `compressed_state_agg` and `timeline_agg` to `state_agg`
 
 #### Shout-outs
 

extension/src/state_aggregate.rs

@@ -306,6 +306,7 @@ pub mod toolkit_experimental {
 
                         // update combined_durations
                         if let Some(combined_durations) = combined_durations.as_mut() {
+                            warning!("updating combined durations");
                             // extend last duration
                             let first_cd = combined_durations
                                 .first_mut()
@@ -345,15 +346,15 @@ pub mod toolkit_experimental {
                 let last_interval = interval_start + interval_len - self.last_time;
                 match durations.get_mut(self.last_state as usize) {
                     None => {
-                        pgx::error!("poorly formed CompressedStateAgg, last_state out of starts")
+                        pgx::error!("poorly formed state aggregate, last_state out of starts")
                     }
                     Some(dis) => {
                         dis.duration += last_interval;
                         if let Some(combined_durations) = combined_durations.as_mut() {
                             // extend last duration
                             combined_durations
                                 .last_mut()
-                                .expect("poorly formed StateAgg, length mismatch")
+                                .expect("poorly formed state aggregate, length mismatch")
                                 .end_time += last_interval;
                         };
                         Record {
@@ -738,23 +739,24 @@ impl CompressedStateAggTransState {
 fn duration_in_inner<'a>(
     state: Option<StateEntry>,
     aggregate: Option<CompressedStateAgg<'a>>,
-    range: Option<(TimestampTz, Option<crate::raw::Interval>)>,
+    range: Option<(i64, Option<i64>)>, // start and interval
 ) -> crate::raw::Interval {
+    warning!("duration_in_inner - range={:?}", range);
     let time: i64 = if let Some((start, interval)) = range {
-        let (start, end) = if let Some(interval) = interval {
-            let interval = crate::datum_utils::interval_to_ms(&start, &interval);
+        let end = if let Some(interval) = interval {
             assert!(interval >= 0, "Interval must not be negative");
-            let start = start.into();
-            (start, start + interval)
+            start + interval
         } else {
-            (start.into(), i64::MAX)
+            i64::MAX
         };
         assert!(end >= start, "End time must be after start time");
         if let (Some(state), Some(agg)) = (state, aggregate) {
             let state = state.materialize(agg.states_as_str());
             let mut total = 0;
             for tis in agg.combined_durations.iter() {
+                warning!("evaluating TIS - range={:?}, tis={:?}", range, tis);
                 if tis.state.materialize(agg.states_as_str()) == state {
+                    warning!("evaluating matching TIS - range={:?}, tis={:?}", range, tis);
                     let tis_start_time = i64::max(tis.start_time, start);
                     let tis_end_time = i64::min(tis.end_time, end);
                     if tis_end_time >= start && tis_start_time <= end {
@@ -872,6 +874,8 @@ pub fn duration_in_range<'a>(
         aggregate.assert_str()
     };
     let aggregate = aggregate.map(StateAgg::as_compressed_state_agg);
+    let interval = interval.map(|interval| crate::datum_utils::interval_to_ms(&start, &interval));
+    let start = start.into();
     duration_in_inner(
         aggregate.as_ref().and_then(|aggregate| {
             StateEntry::try_from_existing_str(aggregate.states_as_str(), &state)
@@ -896,6 +900,8 @@ pub fn duration_in_range_int<'a>(
     if let Some(ref aggregate) = aggregate {
         aggregate.assert_int()
     };
+    let interval = interval.map(|interval| crate::datum_utils::interval_to_ms(&start, &interval));
+    let start = start.into();
     duration_in_inner(
         Some(StateEntry::from_integer(state)),
         aggregate.map(StateAgg::as_compressed_state_agg),
@@ -916,10 +922,11 @@ fn interpolated_duration_in_inner<'a>(
         ),
         Some(aggregate) => {
             let interval = crate::datum_utils::interval_to_ms(&start, &interval);
-            let new_agg = aggregate.interpolate(start.into(), interval, prev);
+            let start = start.into();
+            let new_agg = aggregate.interpolate(start, interval, prev);
             let state_entry =
                 state.and_then(|state| state.try_existing_entry(new_agg.states_as_str()));
-            duration_in_inner(state_entry, Some(new_agg), None)
+            duration_in_inner(state_entry, Some(new_agg), Some((start, Some(interval))))
         }
     }
 }