pg_interval 0.5.0

A native PostgreSQL interval type
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

use crate::interval_norm::IntervalNorm;

impl IntervalNorm {
    fn format_time(
        hours: i64,
        minutes: i64,
        seconds: i64,
        microseconds: i64,
        sign: bool,
    ) -> String {
        let sign_str = if sign { "-" } else { "" };
        let time_str = format!(
            "{}{}:{:02}:{:02}",
            sign_str,
            super::safe_abs_u64(hours),
            super::safe_abs_u64(minutes),
            super::safe_abs_u64(seconds)
        );

        if microseconds != 0 {
            format!("{}.{:06}", time_str, super::safe_abs_u64(microseconds))
        } else {
            time_str
        }
    }

    pub fn into_sql(self) -> String {
        let has_negative = self.has_negative();
        let has_positive = self.has_positive();

        let has_year_month = self.is_year_month_present();
        let has_day_time = self.is_day_present() || self.is_time_present();

        let sql_standard_value = !(has_negative && has_positive || has_year_month && has_day_time);

        if !has_negative && !has_positive {
            return "0".to_owned();
        }

        if !sql_standard_value {
            let year_sign = if self.years < 0 || self.months < 0 {
                '-'
            } else {
                '+'
            };
            let day_sign = if self.days < 0 { '-' } else { '+' };
            let sec_sign = if self.hours < 0
                || self.minutes < 0
                || self.seconds < 0
                || self.microseconds < 0
            {
                '-'
            } else {
                '+'
            };

            let time_str = format!(
                "{}{}:{:02}:{:02}",
                sec_sign,
                super::safe_abs_u64(self.hours),
                super::safe_abs_u64(self.minutes),
                super::safe_abs_u64(self.seconds)
            );

            let time_str = if self.microseconds != 0 {
                format!("{}.{:06}", time_str, super::safe_abs_u64(self.microseconds))
            } else {
                time_str
            };

            format!(
                "{}{}-{} {}{} {}",
                year_sign,
                self.years.abs(),
                self.months.abs(),
                day_sign,
                self.days.abs(),
                time_str
            )
        } else if has_year_month {
            format!("{}-{}", self.years, super::safe_abs_u32(self.months))
        } else if self.days != 0 {
            format!(
                "{} {}",
                self.days,
                Self::format_time(
                    self.hours,
                    self.minutes,
                    self.seconds,
                    self.microseconds,
                    false
                )
            )
        } else {
            Self::format_time(
                self.hours,
                self.minutes,
                self.seconds,
                self.microseconds,
                has_negative,
            )
        }
    }
}