toasty 0.4.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

use super::{Load, Relation, Scope};

use toasty_core::stmt::Value;

use std::fmt;

/// A lazily-loaded has-many association.
///
/// `HasMany<T>` wraps an optional `Vec<T>` that is populated when the
/// association is eagerly loaded (via `include`) or accessed through a
/// generated relation accessor. Before loading, calling
/// [`get`](HasMany::get) panics.
///
/// This type appears as a field on model structs for has-many relations.
#[derive(Clone)]
pub struct HasMany<T> {
    values: Option<Vec<T>>,
}

impl<T: Relation> Load for HasMany<T> {
    type Output = Self;

    fn ty() -> toasty_core::stmt::Type {
        toasty_core::stmt::Type::list(T::ty())
    }

    fn load(input: Value) -> crate::Result<Self> {
        match input {
            Value::List(items) => {
                let mut values = vec![];

                for value in items {
                    values.push(T::load_relation(value)?);
                }

                Ok(Self {
                    values: Some(values),
                })
            }
            Value::Null => Ok(Self::default()),
            _ => todo!("unexpected input: input={:#?}", input),
        }
    }
}

impl<T: Relation> HasMany<T> {
    /// Returns a slice of the loaded associated records.
    ///
    /// # Panics
    ///
    /// Panics if the association has not been loaded.
    #[track_caller]
    pub fn get(&self) -> &[T] {
        self.values
            .as_ref()
            .expect("association not loaded")
            .as_slice()
    }

    /// Returns `true` if the association has not been loaded yet.
    pub fn is_unloaded(&self) -> bool {
        self.values.is_none()
    }

    /// Clear the loaded values, returning this association to the unloaded
    /// state.
    pub fn unload(&mut self) {
        self.values = None;
    }
}

impl<T: Relation> Relation for HasMany<T> {
    type Model = T::Model;
    type Expr = T::Expr;
    type Query = T::Query;
    type Create = T::Create;
    type Many = T::Many;
    type ManyField<__Origin> = T::ManyField<__Origin>;
    type One = T::One;
    type OneField<__Origin> = T::OneField<__Origin>;
    type OptionOne = T::OptionOne;

    fn new_many_field<__Origin>(
        path: crate::stmt::Path<__Origin, crate::stmt::List<Self::Model>>,
    ) -> Self::ManyField<__Origin> {
        T::new_many_field(path)
    }

    fn field_name_to_id(name: &str) -> toasty_core::schema::app::FieldId {
        T::field_name_to_id(name)
    }

    fn nullable() -> bool {
        T::nullable()
    }
}

impl<T: Relation> Scope for HasMany<T> {
    type Item = crate::stmt::List<T::Model>;
    type Path<Origin> = T::ManyField<Origin>;
    type Create = T::Create;

    fn new_path<Origin>(path: crate::stmt::Path<Origin, Self::Item>) -> Self::Path<Origin> {
        T::new_many_field(path)
    }

    fn new_create() -> Self::Create {
        T::new_create()
    }

    fn new_path_root() -> Self::Path<Self::Item> {
        T::new_many_field(crate::stmt::Path::from_model_list())
    }
}

impl<T> Default for HasMany<T> {
    fn default() -> Self {
        Self { values: None }
    }
}

impl<T: fmt::Debug> fmt::Debug for HasMany<T> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.values.as_ref() {
            Some(t) => t.fmt(fmt),
            None => {
                write!(fmt, "<not loaded>")?;
                Ok(())
            }
        }
    }
}

#[cfg(feature = "serde")]
impl<T: serde_core::Serialize> serde_core::Serialize for HasMany<T> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.values.serialize(serializer)
    }
}