interim commit: add local approx percentile

src/stream/src/executor/approx_percentile/local.rs

@@ -0,0 +1,94 @@
+// Copyright 2024 RisingWave Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::HashMap;
+use risingwave_common::array::Op;
+use risingwave_common::util::chunk_coalesce::DataChunkBuilder;
+use risingwave_pb::expr::InputRef;
+
+use crate::executor::prelude::*;
+
+pub struct LocalApproxPercentile {
+    _ctx: ActorContextRef,
+    pub input: Executor,
+    pub base: f64,
+    pub percentile_col: InputRef,
+    pub schema: Schema,
+}
+
+impl LocalApproxPercentile {
+    pub fn new(
+        _ctx: ActorContextRef,
+        input: Executor,
+        base: f64,
+        percentile_col: InputRef,
+        schema: Schema,
+    ) -> Self {
+        Self {
+            _ctx,
+            input,
+            base,
+            percentile_col,
+            schema,
+        }
+    }
+
+    #[try_stream(ok = Message, error = StreamExecutorError)]
+    async fn execute_inner(mut self) {
+        let index = self.percentile_col.index as usize;
+        #[for_await]
+        for message in self.input.execute() {
+            match message {
+                Message::Chunk(chunk) => {
+                    yield calculate_count_per_bucket(percentile_index, chunk);
+                }
+                _ => yield message,
+            }
+        }
+    }
+
+    // TODO(kwannoel): Perhaps we can batch and only flush the count per bucket downstream
+    // once some threshold is reached / once per epoch.
+    // FIXME(kwannoel): handle negative values.
+    fn calculate_count_per_bucket(base: f64, percentile_index: usize, chunk: StreamChunk) -> Message {
+        let chunk = chunk.project(&[percentile_index]);
+        let mut counts = HashMap::new();
+        for (op, row) in chunk.rows() {
+            let value = row.datum_at(0).unwrap();
+            let value: f64 = value.as_f64();
+            let bucket = value.log(base).floor() as i32;
+            let count = counts.entry(bucket).or_insert(0);
+            match op {
+                Op::Insert | Op::UpdateInsert => *count += 1,
+                Op::Delete | Op::UpdateDelete => *count -= 1,
+            }
+        }
+        // NOTE(kwannoel): The op here is simply ignored.
+        // The downstream global_approx_percentile will always just update its bucket counts.
+        let op = vec![Op::Insert; counts.len()];
+        let mut bucket_col: Datum = Vec::with_capacity(counts.len());
+        let mut count_col: Datum = Vec::with_capacity(counts.len());
+        for (bucket, count) in counts {
+            bucket_col.push(Some(ScalarImpl::Int32(bucket)));
+            count_col.push(Some(ScalarImpl::Int32(count)));
+        }
+        StreamChunk::from_columns(vec![bucket_col, count_col], op)
+    }
+}
+
+impl Execute for LocalApproxPercentile {
+    fn execute(self: Box<Self>) -> BoxedMessageStream {
+        self.execute_inner().boxed()
+    }
+}

src/stream/src/executor/approx_percentile/mod.rs

@@ -0,0 +1,15 @@
+// Copyright 2024 RisingWave Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod local;

src/stream/src/executor/mod.rs

@@ -103,6 +103,8 @@ mod watermark;
 mod watermark_filter;
 mod wrapper;
 
+mod approx_percentile;
+
 #[cfg(test)]
 mod integration_tests;
 pub mod test_utils;