toasty 0.11.0

An async ORM for Rust supporting SQL and NoSQL databases
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::{Field, Load};
use crate::stmt::{Expr, List, Path};
use toasty_core::{
    Result,
    stmt::{Type, Value},
};

macro_rules! impl_jiff_field {
    ($ty:ty, $name:ident, $lit:literal) => {
        impl Load for $ty {
            type Output = Self;

            fn ty() -> Type {
                Type::$name
            }

            fn load(value: Value) -> Result<Self> {
                match value {
                    Value::$name(v) => Ok(v),
                    _ => Err(toasty_core::Error::type_conversion(value, $lit)),
                }
            }

            fn reload(target: &mut Self, value: Value) -> Result<()> {
                *target = Self::load(value)?;
                Ok(())
            }
        }

        impl Field for $ty {
            type ExprTarget = Self;
            type Path<Origin> = Path<Origin, Self>;
            type ListPath<Origin> = Path<Origin, List<Self::ExprTarget>>;
            type Update<'a> = ();
            type Inner = Self;

            fn new_path<Origin>(path: Path<Origin, Self>) -> Self::Path<Origin> {
                path
            }

            fn new_list_path<Origin>(
                path: Path<Origin, List<Self::ExprTarget>>,
            ) -> Self::ListPath<Origin> {
                path
            }

            fn new_update<'a>(
                _assignments: &'a mut toasty_core::stmt::Assignments,
                _projection: toasty_core::stmt::Projection,
            ) -> Self::Update<'a> {
            }

            fn key_constraint<Origin>(&self, target: Path<Origin, Self::Inner>) -> Expr<bool> {
                target.eq(self)
            }
        }
    };
}

impl_jiff_field!(jiff::Timestamp, Timestamp, "jiff::Timestamp");
impl_jiff_field!(jiff::Zoned, Zoned, "jiff::Zoned");
impl_jiff_field!(jiff::civil::Date, Date, "jiff::civil::Date");
impl_jiff_field!(jiff::civil::Time, Time, "jiff::civil::Time");
impl_jiff_field!(jiff::civil::DateTime, DateTime, "jiff::civil::DateTime");

/// No backend has a time zone column type, so a `TimeZone` has no `stmt::Type`
/// of its own — it is a `String` end to end, and these two functions are the
/// only place the encoding is defined.
///
/// The encoding is the RFC 9557 form a `Zoned` carries in its bracketed
/// annotation: an IANA identifier, a fixed offset, a POSIX TZ string, or
/// `Etc/Unknown`. jiff gives `TimeZone` neither `Display` nor `FromStr`.
static PRINTER: ::jiff::fmt::temporal::DateTimePrinter =
    ::jiff::fmt::temporal::DateTimePrinter::new();

static PARSER: ::jiff::fmt::temporal::DateTimeParser = ::jiff::fmt::temporal::DateTimeParser::new();

/// Printing canonicalizes `america/NEW_YORK` to `America/New_York`, so equal
/// zones store identical text.
///
/// Fails only for a zone with no text form, which jiff produces just for a
/// `TimeZone::system()` read from a non-symlinked `/etc/localtime`.
pub(crate) fn time_zone_to_text(tz: &::jiff::tz::TimeZone) -> Result<String> {
    let mut text = String::new();

    PRINTER.print_time_zone(tz, &mut text).map_err(|_| {
        toasty_core::Error::unsupported_feature(
            "this `jiff::tz::TimeZone` has no IANA identifier, fixed offset, \
             or POSIX rule string, so it cannot be stored",
        )
    })?;

    Ok(text)
}

/// IANA identifiers resolve against jiff's global time zone database, so a
/// zone renamed between tzdb releases fails to load on a host carrying only
/// the other name.
fn time_zone_from_text(text: &str) -> Result<::jiff::tz::TimeZone> {
    PARSER
        .parse_time_zone(text)
        .map_err(|e| toasty_core::Error::from_args(format_args!("invalid time zone {text:?}: {e}")))
}

impl Load for ::jiff::tz::TimeZone {
    type Output = Self;

    fn ty() -> Type {
        Type::String
    }

    fn load(value: Value) -> Result<Self> {
        match value {
            Value::String(text) => time_zone_from_text(&text),
            _ => Err(toasty_core::Error::type_conversion(
                value,
                "jiff::tz::TimeZone",
            )),
        }
    }

    fn reload(target: &mut Self, value: Value) -> Result<()> {
        *target = Self::load(value)?;
        Ok(())
    }
}

impl Field for ::jiff::tz::TimeZone {
    type ExprTarget = Self;
    type Path<Origin> = Path<Origin, Self>;
    type ListPath<Origin> = Path<Origin, List<Self::ExprTarget>>;
    type Update<'a> = ();
    type Inner = Self;

    fn new_path<Origin>(path: Path<Origin, Self>) -> Self::Path<Origin> {
        path
    }

    fn new_list_path<Origin>(path: Path<Origin, List<Self::ExprTarget>>) -> Self::ListPath<Origin> {
        path
    }

    fn new_update<'a>(
        _assignments: &'a mut toasty_core::stmt::Assignments,
        _projection: toasty_core::stmt::Projection,
    ) -> Self::Update<'a> {
    }

    fn key_constraint<Origin>(&self, target: Path<Origin, Self::Inner>) -> Expr<bool> {
        target.eq(self)
    }
}