display RangeFrameBounds

Signed-off-by: Richard Chien <[email protected]>

Author: stdrc

src/expr/core/src/window_function/call.rs

@@ -15,13 +15,15 @@
 use std::fmt::Display;
 
 use enum_as_inner::EnumAsInner;
+use parse_display::Display;
 use risingwave_common::bail;
 use risingwave_common::types::{
-    DataType, Datum, ScalarImpl, ScalarRefImpl, Sentinelled, ToDatumRef, ToOwnedDatum,
+    DataType, Datum, ScalarImpl, ScalarRefImpl, Sentinelled, ToDatumRef, ToOwnedDatum, ToText,
 };
 use risingwave_common::util::sort_util::{Direction, OrderType};
 use risingwave_pb::expr::window_frame::{PbBound, PbExclusion};
 use risingwave_pb::expr::{PbWindowFrame, PbWindowFunction};
+use FrameBound::{CurrentRow, Following, Preceding, UnboundedFollowing, UnboundedPreceding};
 
 use super::WindowFuncKind;
 use crate::aggregate::AggArgs;
@@ -185,7 +187,12 @@ pub struct RangeFrameBounds {
 
 impl Display for RangeFrameBounds {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "RANGE BETWEEN {:?} AND {:?}", self.start, self.end)?; // TODO(): display
+        write!(
+            f,
+            "RANGE BETWEEN {} AND {}",
+            self.start.for_display(),
+            self.end.for_display()
+        )?;
         Ok(())
     }
 }
@@ -311,22 +318,23 @@ impl RangeFrameBounds {
     }
 }
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, EnumAsInner)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, EnumAsInner, Display)]
+#[display(style = "TITLE CASE")]
 pub enum FrameBound<T> {
-    UnboundedPreceding, /* TODO(rc): maybe we can merge `UnboundedPreceding` and `UnboundedFollowing` */
+    UnboundedPreceding,
+    #[display("{0} PRECEDING")]
     Preceding(T),
     CurrentRow,
+    #[display("{0} FOLLOWING")]
     Following(T),
     UnboundedFollowing,
 }
 
 impl<T> FrameBound<T> {
     fn offset_value(&self) -> Option<&T> {
         match self {
-            FrameBound::UnboundedPreceding
-            | FrameBound::UnboundedFollowing
-            | FrameBound::CurrentRow => None,
-            FrameBound::Preceding(offset) | FrameBound::Following(offset) => Some(offset),
+            UnboundedPreceding | UnboundedFollowing | CurrentRow => None,
+            Preceding(offset) | Following(offset) => Some(offset),
         }
     }
 
@@ -336,15 +344,14 @@ impl<T> FrameBound<T> {
         offset_checker: impl Fn(&T) -> Result<()>,
     ) -> Result<()> {
         match (start, end) {
-            (_, FrameBound::UnboundedPreceding) => bail!("frame end cannot be UNBOUNDED PRECEDING"),
-            (FrameBound::UnboundedFollowing, _) => {
+            (_, UnboundedPreceding) => bail!("frame end cannot be UNBOUNDED PRECEDING"),
+            (UnboundedFollowing, _) => {
                 bail!("frame start cannot be UNBOUNDED FOLLOWING")
             }
-            (FrameBound::Following(_), FrameBound::CurrentRow)
-            | (FrameBound::Following(_), FrameBound::Preceding(_)) => {
+            (Following(_), CurrentRow) | (Following(_), Preceding(_)) => {
                 bail!("frame starting from following row cannot have preceding rows")
             }
-            (FrameBound::CurrentRow, FrameBound::Preceding(_)) => {
+            (CurrentRow, Preceding(_)) => {
                 bail!("frame starting from current row cannot have preceding rows")
             }
             _ => {}
@@ -366,11 +373,11 @@ where
 {
     fn reverse(self) -> FrameBound<T> {
         match self {
-            FrameBound::UnboundedPreceding => FrameBound::UnboundedFollowing,
-            FrameBound::Preceding(offset) => FrameBound::Following(offset),
-            FrameBound::CurrentRow => FrameBound::CurrentRow,
-            FrameBound::Following(offset) => FrameBound::Preceding(offset),
-            FrameBound::UnboundedFollowing => FrameBound::UnboundedPreceding,
+            UnboundedPreceding => UnboundedFollowing,
+            Preceding(offset) => Following(offset),
+            CurrentRow => CurrentRow,
+            Following(offset) => Preceding(offset),
+            UnboundedFollowing => UnboundedPreceding,
         }
     }
 }
@@ -413,27 +420,14 @@ impl FrameBound<usize> {
     }
 }
 
-impl Display for FrameBound<usize> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FrameBound::UnboundedPreceding => write!(f, "UNBOUNDED PRECEDING")?,
-            FrameBound::Preceding(n) => write!(f, "{} PRECEDING", n)?,
-            FrameBound::CurrentRow => write!(f, "CURRENT ROW")?,
-            FrameBound::Following(n) => write!(f, "{} FOLLOWING", n)?,
-            FrameBound::UnboundedFollowing => write!(f, "UNBOUNDED FOLLOWING")?,
-        }
-        Ok(())
-    }
-}
-
 impl FrameBound<usize> {
     /// Convert the bound to sized offset from current row. `None` if the bound is unbounded.
     pub fn to_offset(&self) -> Option<isize> {
         match self {
-            FrameBound::UnboundedPreceding | FrameBound::UnboundedFollowing => None,
-            FrameBound::CurrentRow => Some(0),
-            FrameBound::Preceding(n) => Some(-(*n as isize)),
-            FrameBound::Following(n) => Some(*n as isize),
+            UnboundedPreceding | UnboundedFollowing => None,
+            CurrentRow => Some(0),
+            Preceding(n) => Some(-(*n as isize)),
+            Following(n) => Some(*n as isize),
         }
     }
 
@@ -451,11 +445,21 @@ impl FrameBound<usize> {
 impl FrameBound<ScalarImpl> {
     fn as_ref(&self) -> FrameBound<ScalarRefImpl<'_>> {
         match self {
-            FrameBound::UnboundedPreceding => FrameBound::UnboundedPreceding,
-            FrameBound::Preceding(offset) => FrameBound::Preceding(offset.as_scalar_ref_impl()),
-            FrameBound::CurrentRow => FrameBound::CurrentRow,
-            FrameBound::Following(offset) => FrameBound::Following(offset.as_scalar_ref_impl()),
-            FrameBound::UnboundedFollowing => FrameBound::UnboundedFollowing,
+            UnboundedPreceding => UnboundedPreceding,
+            Preceding(offset) => Preceding(offset.as_scalar_ref_impl()),
+            CurrentRow => CurrentRow,
+            Following(offset) => Following(offset.as_scalar_ref_impl()),
+            UnboundedFollowing => UnboundedFollowing,
+        }
+    }
+
+    fn for_display(&self) -> FrameBound<String> {
+        match self {
+            UnboundedPreceding => UnboundedPreceding,
+            Preceding(offset) => Preceding(offset.as_scalar_ref_impl().to_text()),
+            CurrentRow => CurrentRow,
+            Following(offset) => Following(offset.as_scalar_ref_impl().to_text()),
+            UnboundedFollowing => UnboundedFollowing,
         }
     }
 }
@@ -464,11 +468,11 @@ impl FrameBound<ScalarRefImpl<'_>> {
     fn bound_of(self, order_value: impl ToDatumRef, order_type: OrderType) -> Sentinelled<Datum> {
         let order_value = order_value.to_datum_ref();
         match (self, order_type.direction()) {
-            (FrameBound::UnboundedPreceding, _) => Sentinelled::Smallest,
-            (FrameBound::UnboundedFollowing, _) => Sentinelled::Largest,
-            (FrameBound::CurrentRow, _) => Sentinelled::Normal(order_value.to_owned_datum()),
-            (FrameBound::Preceding(offset), Direction::Ascending)
-            | (FrameBound::Following(offset), Direction::Descending) => {
+            (UnboundedPreceding, _) => Sentinelled::Smallest,
+            (UnboundedFollowing, _) => Sentinelled::Largest,
+            (CurrentRow, _) => Sentinelled::Normal(order_value.to_owned_datum()),
+            (Preceding(offset), Direction::Ascending)
+            | (Following(offset), Direction::Descending) => {
                 // should SUBTRACT the offset
                 if let Some(value) = order_value {
                     let res = match (value, offset) {
@@ -490,8 +494,8 @@ impl FrameBound<ScalarRefImpl<'_>> {
                     Sentinelled::Normal(None)
                 }
             }
-            (FrameBound::Following(offset), Direction::Ascending)
-            | (FrameBound::Preceding(offset), Direction::Descending) => {
+            (Following(offset), Direction::Ascending)
+            | (Preceding(offset), Direction::Descending) => {
                 // should ADD the offset
                 if let Some(value) = order_value {
                     let res = match (value, offset) {

src/stream/src/executor/over_window/general.rs

@@ -246,6 +246,7 @@ impl<S: StateStore> OverWindowExecutor<S> {
                 bounds @ risingwave_expr::window_function::FrameBounds::Range(..) => bounds,
             };
             call.frame.bounds = test_frame_bounds;
+            println!("[rc] new frame: {}", call.frame);
             call
         });