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

//! Internal types referenced by code generated by `#[derive(Model)]` and the
//! `create!` / `update!` / `query!` macros. Not part of the public API; the
//! contents may change between releases.

#![doc(hidden)]

pub mod auto;
pub mod index;
pub mod newtype;
pub mod shared_column;
pub mod storage;
pub mod version;
pub mod via;

pub use crate::schema::inventory;
pub use crate::{
    Db, Error, Executor, Result, Statement,
    schema::{
        Auto, Deferred, DiscoverItem, Document, Embed, Field, Load, Model, QueryMany, QueryOne,
        QueryOptionOne, RelationManyField, RelationOneField, Scalar, Scope, ViaMany, ViaManyField,
        ViaPath, ViaTarget, generate_unique_id,
    },
    stmt::CreateMany,
    stmt::{self, Assign, Expr, IntoExpr, IntoInsert, IntoStatement, List, Path},
    update_target::UpdateTarget,
};
#[cfg(feature = "serde")]
pub use serde_json;
pub use std::{clone::Clone, convert::Into, default::Default, option::Option};

pub use self::version::Version;
pub use toasty_core as core;

/// The expression-level type that a create/update setter accepts for a field
/// of type `F`. This is just [`Field::ExprTarget`], but naming it keeps the
/// long `<F as Field>::ExprTarget` projection out of generated setter
/// signatures (and out of the compiler errors they produce).
pub type FieldExprTarget<F> = <F as Field>::ExprTarget;

/// Infer the [`Scope`] type from a scope expression and return its fields
/// path.
///
/// The `create!` macro uses this in the scoped form (`in expr { ... }`) to
/// obtain the field struct for nested builders. Because the macro has no
/// type information, it cannot call `S::new_path_root()` directly — this function
/// lets Rust infer `S` from the scope argument.
pub fn scope_fields<S: Scope>(_scope: &S) -> S::Path<S::Item> {
    S::new_path_root()
}

/// Create a record inside a scoped create target.
pub fn create_in_scope<S: Scope>(scope: S) -> S::Create {
    S::create_in_scope(scope)
}

/// Convert a value into an untyped [`core::stmt::Expr`] via the typed
/// [`IntoExpr<T>`] trait.
///
/// Generated code (`#[derive(Model)]`, `#[derive(Embed)]`) splices this in
/// instead of inlining the `let expr: Expr<T> = value.into_expr(); expr.into()`
/// pattern at every field site. The explicit `T` type parameter
/// disambiguates which `IntoExpr` impl to use.
pub fn into_untyped_expr<T, V: IntoExpr<T>>(value: V) -> core::stmt::Expr {
    let expr: stmt::Expr<T> = value.into_expr();
    expr.into()
}

/// Continue a `has_many` traversal from `query` along `path`.
///
/// If `query` was already scoped from a relation traversal, append
/// `field_offset` to that traversal's path so the result remains a single
/// chained association. Otherwise build a fresh `Association::many` rooted
/// at `query`. Used by generated `.field()` chain methods on the per-model
/// `Query<List<Source>>` for `has_many` relations.
pub fn chain_or_build_many<Source, Target>(
    mut query: stmt::Query<List<Source>>,
    field_offset: usize,
    path: stmt::Path<Source, List<Target>>,
) -> stmt::Association<List<Target>>
where
    Source: Model,
    Target: Model,
{
    match query.take_via_assoc() {
        Some(untyped) => stmt::Association::<List<Source>>::from_untyped(untyped)
            .chain_field::<Target>(field_offset),
        None => stmt::Association::many(query, path),
    }
}

/// Continue a `belongs_to` / `has_one` traversal from `query` along `path`.
///
/// Mirrors [`chain_or_build_many`] for singular relation steps: when no
/// existing traversal is present the fresh association is built via
/// [`stmt::Association::many_via_one`].
pub fn chain_or_build_many_via_one<Source, Target>(
    mut query: stmt::Query<List<Source>>,
    field_offset: usize,
    path: stmt::Path<Source, Target>,
) -> stmt::Association<List<Target>>
where
    Source: Model,
    Target: Model,
{
    match query.take_via_assoc() {
        Some(untyped) => stmt::Association::<List<Source>>::from_untyped(untyped)
            .chain_field::<Target>(field_offset),
        None => stmt::Association::many_via_one(query, path),
    }
}