mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-17 02:12:56 +00:00
ff5cbe2694
This introduces a new tree data structure for holding intervals, and queries of the form "which intervals contain the given point?". It then uses that to store the Layers in the layer map, instead of the BTreeMap. While we don't currently create overlapping layers in the page server, that situation might arise in the future if we start to create extra layers for performance purposes, or as part of some multi-stage garbage collection operation that creates new layers in some interval and then removes old ones. The situation might also arise if you have multiple page servers running on the same timeline, freezing layers at different points, and both uploading them to S3. So even though overlapping layers might not happen currently, let's avoid getting confused if it does happen for some reason. Fixes https://github.com/zenithdb/zenith/issues/517.
34 lines
973 B
Rust
34 lines
973 B
Rust
/// A helper to "accumulate" a value similar to `Iterator::reduce`, but lets you
|
|
/// feed the accumulated values by calling the 'accum' function, instead of having an
|
|
/// iterator.
|
|
///
|
|
/// For example, to calculate the smallest value among some integers:
|
|
///
|
|
/// ```
|
|
/// use zenith_utils::accum::Accum;
|
|
///
|
|
/// let values = [1, 2, 3];
|
|
///
|
|
/// let mut min_value: Accum<u32> = Accum(None);
|
|
/// for new_value in &values {
|
|
/// min_value.accum(std::cmp::min, *new_value);
|
|
/// }
|
|
///
|
|
/// assert_eq!(min_value.0.unwrap(), 1);
|
|
/// ```
|
|
pub struct Accum<T>(pub Option<T>);
|
|
impl<T: Copy> Accum<T> {
|
|
pub fn accum<F>(&mut self, func: F, new_value: T)
|
|
where
|
|
F: FnOnce(T, T) -> T,
|
|
{
|
|
// If there is no previous value, just store the new value.
|
|
// Otherwise call the function to decide which one to keep.
|
|
self.0 = Some(if let Some(accum) = self.0 {
|
|
func(accum, new_value)
|
|
} else {
|
|
new_value
|
|
});
|
|
}
|
|
}
|