polars-core 0.53.0

Core of the Polars DataFrame library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;
use crate::datatypes::time_unit::TimeUnit;
use crate::prelude::*;

pub type DatetimeChunked = Logical<DatetimeType, Int64Type>;

impl Int64Chunked {
    pub fn into_datetime(self, timeunit: TimeUnit, tz: Option<TimeZone>) -> DatetimeChunked {
        // SAFETY: no invalid states.
        unsafe { DatetimeChunked::new_logical(self, DataType::Datetime(timeunit, tz)) }
    }
}

impl LogicalType for DatetimeChunked {
    fn dtype(&self) -> &DataType {
        &self.dtype
    }

    fn get_any_value(&self, i: usize) -> PolarsResult<AnyValue<'_>> {
        self.phys
            .get_any_value(i)
            .map(|av| av.as_datetime(self.time_unit(), self.time_zone().as_ref()))
    }

    unsafe fn get_any_value_unchecked(&self, i: usize) -> AnyValue<'_> {
        self.phys
            .get_any_value_unchecked(i)
            .as_datetime(self.time_unit(), self.time_zone().as_ref())
    }

    fn cast_with_options(
        &self,
        dtype: &DataType,
        cast_options: CastOptions,
    ) -> PolarsResult<Series> {
        use DataType::*;

        use crate::datatypes::time_unit::TimeUnit::*;

        let out = match dtype {
            Datetime(to_unit, tz) => {
                let from_unit = self.time_unit();
                let (multiplier, divisor) = match (from_unit, to_unit) {
                    // scaling from lower precision to higher precision
                    (Milliseconds, Nanoseconds) => (Some(1_000_000i64), None),
                    (Milliseconds, Microseconds) => (Some(1_000i64), None),
                    (Microseconds, Nanoseconds) => (Some(1_000i64), None),
                    // scaling from higher precision to lower precision
                    (Nanoseconds, Milliseconds) => (None, Some(1_000_000i64)),
                    (Nanoseconds, Microseconds) => (None, Some(1_000i64)),
                    (Microseconds, Milliseconds) => (None, Some(1_000i64)),
                    _ => return self.phys.cast_with_options(dtype, cast_options),
                };
                match multiplier {
                    // scale to higher precision (eg: ms → us, ms → ns, us → ns)
                    Some(m) => Ok((self.phys.as_ref().checked_mul_scalar(m))
                        .into_datetime(*to_unit, tz.clone())
                        .into_series()),
                    // scale to lower precision (eg: ns → us, ns → ms, us → ms)
                    None => match divisor {
                        Some(d) => Ok(self
                            .phys
                            .apply_values(|v| v.div_euclid(d))
                            .into_datetime(*to_unit, tz.clone())
                            .into_series()),
                        None => unreachable!("must always have a time unit divisor here"),
                    },
                }
            },
            #[cfg(feature = "dtype-date")]
            Date => {
                let cast_to_date = |tu_in_day: i64| {
                    let mut dt = self
                        .phys
                        .apply_values(|v| v.div_euclid(tu_in_day))
                        .cast_with_options(&Int32, cast_options)
                        .unwrap()
                        .into_date()
                        .into_series();
                    dt.set_sorted_flag(self.physical().is_sorted_flag());
                    Ok(dt)
                };
                match self.time_unit() {
                    Nanoseconds => cast_to_date(NS_IN_DAY),
                    Microseconds => cast_to_date(US_IN_DAY),
                    Milliseconds => cast_to_date(MS_IN_DAY),
                }
            },
            #[cfg(feature = "dtype-time")]
            Time => {
                let (scaled_mod, multiplier) = match self.time_unit() {
                    Nanoseconds => (NS_IN_DAY, 1i64),
                    Microseconds => (US_IN_DAY, 1_000i64),
                    Milliseconds => (MS_IN_DAY, 1_000_000i64),
                };
                return Ok(self
                    .phys
                    .apply(|v| {
                        let t = (v? % scaled_mod).checked_mul(multiplier)?;
                        t.checked_add(NS_IN_DAY * (t < 0) as i64)
                    })
                    .into_time()
                    .into_series());
            },
            dt if dt.is_primitive_numeric() => {
                return self.phys.cast_with_options(dtype, cast_options);
            },
            dt => {
                polars_bail!(
                    InvalidOperation:
                    "casting from {:?} to {:?} not supported",
                    self.dtype(), dt
                )
            },
        };
        out.map(|mut s| {
            // TODO!; implement the divisions/multipliers above
            // in a checked manner so that we raise on overflow
            s.set_sorted_flag(self.physical().is_sorted_flag());
            s
        })
    }
}