polars_time/
truncate.rs

1use polars_arrow::legacy::time_zone::Tz;
2use polars_arrow::temporal_conversions::MILLISECONDS_IN_DAY;
3use polars_core::prelude::arity::broadcast_try_binary_elementwise;
4use polars_core::prelude::*;
5use polars_defs::time::duration::Duration;
6use polars_utils::cache::LruCache;
7
8use crate::prelude::*;
9
10pub trait PolarsTruncate {
11    fn truncate(&self, tz: Option<&Tz>, every: &StringChunked) -> PolarsResult<Self>
12    where
13        Self: Sized;
14}
15
16#[inline(always)]
17pub(crate) fn fast_truncate(t: i64, every: i64) -> i64 {
18    let remainder = t % every;
19    t - (remainder + every * (remainder < 0) as i64)
20}
21
22impl PolarsTruncate for DatetimeChunked {
23    fn truncate(&self, tz: Option<&Tz>, every: &StringChunked) -> PolarsResult<Self> {
24        polars_ensure!(
25            self.len() == every.len() || self.len() == 1 || every.len() == 1,
26            length_mismatch = "dt.truncate",
27            self.len(),
28            every.len()
29        );
30
31        let time_zone = self.time_zone();
32        let offset = Duration::new(0);
33
34        // Let's check if we can use a fastpath...
35        if every.len() == 1 {
36            if let Some(every) = every.get(0) {
37                let every_parsed = Duration::try_parse(every)?;
38                if every_parsed.negative {
39                    polars_bail!(ComputeError: "cannot truncate a Datetime to a negative duration")
40                }
41                if (time_zone.is_none() || time_zone.as_ref() == Some(&TimeZone::UTC))
42                    && (every_parsed.months() == 0 && every_parsed.weeks() == 0)
43                {
44                    // ... yes we can! Weeks, months, and time zones require extra logic.
45                    // But in this simple case, it's just simple integer arithmetic.
46                    let every = every_parsed.duration(self.time_unit());
47                    if every == 0 {
48                        return Ok(self.clone());
49                    }
50                    return Ok(self
51                        .physical()
52                        .apply_values(|t| fast_truncate(t, every))
53                        .into_datetime(self.time_unit(), time_zone.clone()));
54                } else {
55                    let w = Window::new(every_parsed, every_parsed, offset);
56                    let out = self
57                        .physical()
58                        .try_apply_nonnull_values_generic(|t| w.truncate(self.time_unit(), t, tz));
59                    return Ok(out?.into_datetime(self.time_unit(), self.time_zone().clone()));
60                }
61            } else {
62                return Ok(Int64Chunked::full_null(self.name().clone(), self.len())
63                    .into_datetime(self.time_unit(), self.time_zone().clone()));
64            }
65        }
66
67        // A sqrt(n) cache is not too small, not too large.
68        let mut duration_cache = LruCache::with_capacity((every.len() as f64).sqrt() as usize);
69
70        let out = broadcast_try_binary_elementwise(
71            self.physical(),
72            every,
73            |opt_timestamp, opt_every| match (opt_timestamp, opt_every) {
74                (Some(timestamp), Some(every)) => {
75                    let every =
76                        *duration_cache.try_get_or_insert_with(every, Duration::try_parse)?;
77
78                    if every.negative {
79                        polars_bail!(ComputeError: "cannot truncate a Datetime to a negative duration")
80                    }
81
82                    let w = Window::new(every, every, offset);
83                    w.truncate(self.time_unit(), timestamp, tz).map(Some)
84                },
85                _ => Ok(None),
86            },
87        );
88        Ok(out?.into_datetime(self.time_unit(), self.time_zone().clone()))
89    }
90}
91
92impl PolarsTruncate for DateChunked {
93    fn truncate(&self, _tz: Option<&Tz>, every: &StringChunked) -> PolarsResult<Self> {
94        polars_ensure!(
95            self.len() == every.len() || self.len() == 1 || every.len() == 1,
96            length_mismatch = "dt.truncate",
97            self.len(),
98            every.len()
99        );
100
101        let offset = Duration::new(0);
102        let out = match every.len() {
103            1 => {
104                if let Some(every) = every.get(0) {
105                    let every = Duration::try_parse(every)?;
106                    if every.negative {
107                        polars_bail!(ComputeError: "cannot truncate a Date to a negative duration")
108                    }
109                    let w = Window::new(every, every, offset);
110                    self.physical().try_apply_nonnull_values_generic(|t| {
111                        Ok((w.truncate(
112                            TimeUnit::Milliseconds,
113                            MILLISECONDS_IN_DAY * t as i64,
114                            None,
115                        )? / MILLISECONDS_IN_DAY) as i32)
116                    })
117                } else {
118                    Ok(Int32Chunked::full_null(self.name().clone(), self.len()))
119                }
120            },
121            _ => {
122                // A sqrt(n) cache is not too small, not too large.
123                let mut duration_cache =
124                    LruCache::with_capacity((every.len() as f64).sqrt() as usize);
125                broadcast_try_binary_elementwise(self.physical(), every, |opt_t, opt_every| match (
126                    opt_t, opt_every,
127                ) {
128                    (Some(t), Some(every)) => {
129                        let every =
130                            *duration_cache.try_get_or_insert_with(every, Duration::try_parse)?;
131
132                        if every.negative {
133                            polars_bail!(ComputeError: "cannot truncate a Date to a negative duration")
134                        }
135
136                        let w = Window::new(every, every, offset);
137                        Ok(Some(
138                            (w.truncate(
139                                TimeUnit::Milliseconds,
140                                MILLISECONDS_IN_DAY * t as i64,
141                                None,
142                            )? / MILLISECONDS_IN_DAY) as i32,
143                        ))
144                    },
145                    _ => Ok(None),
146                })
147            },
148        };
149        Ok(out?.into_date())
150    }
151}
polars_time/truncate.rs

polars_time/
truncate.rs
