ormer-derive 0.2.9

A minimalist ORM framework that supports SQLite, PostgreSQL, MySQL, and SqlServer
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

mod db_value;
mod model;
mod model_enum;
mod raw;

use proc_macro::TokenStream;

#[proc_macro_derive(
    Model,
    attributes(
        table,
        column,
        primary,
        unique,
        index,
        foreign,
        data_type,
        default,
        check,
        hypertable,
        compress,
        mysql,
        postgresql,
        mssql,
        clickhouse,
        has_many,
        belongs_to,
        has_one,
        through,
        embed,
        field,
        filter,
        version,
        ormer_ignore
    )
)]
pub fn derive_model(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model::derive_model(input).into()
}

#[proc_macro_derive(Embed, attributes(column, data_type))]
pub fn derive_embed(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model::derive_embed(input).into()
}

#[proc_macro_derive(ViewModel, attributes(table, column, data_type))]
pub fn derive_view_model(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model::derive_view_model(input).into()
}

#[proc_macro_derive(ModelEnum, attributes(db_type, column))]
pub fn derive_model_enum(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model_enum::derive_model_enum(input).into()
}

#[proc_macro_derive(FieldType, attributes(db_type, column))]
pub fn derive_field_type(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model_enum::derive_field_type(input).into()
}

#[proc_macro_derive(DbValue, attributes(db_type))]
pub fn derive_db_value(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    db_value::derive_db_value(input).into()
}

#[proc_macro_derive(InsertModel, attributes(table, column))]
pub fn derive_insert_model(input: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    model::derive_insert_model(input).into()
}

#[proc_macro]
pub fn raw(input: TokenStream) -> TokenStream {
    raw::expand(input.into()).into()
}