kosame_dsl 0.3.0

Macro-based Rust ORM focused on developer ergonomics
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

use crate::{
    inferred_type::InferredType,
    pretty::{PrettyPrint, Printer},
    scopes::ScopeId,
};

use super::Visit;
use proc_macro2::{Span, TokenStream};
use quote::{ToTokens, quote};
use syn::{
    Ident, Token,
    parse::{Parse, ParseStream},
};

pub struct ColumnRef {
    pub correlation: Option<Correlation>,
    pub name: Ident,
}

impl ColumnRef {
    #[must_use]
    pub fn infer_name(&self) -> Option<&Ident> {
        Some(&self.name)
    }

    #[must_use]
    pub fn infer_type(&self, scope_id: ScopeId) -> Option<InferredType<'_>> {
        Some(InferredType::Scope {
            scope_id,
            table: self
                .correlation
                .as_ref()
                .map(|correlation| &correlation.name),
            column: &self.name,
        })
    }

    #[must_use]
    pub fn span(&self) -> Span {
        if let Some(correlation) = &self.correlation {
            correlation
                .name
                .span()
                .join(self.name.span())
                .unwrap_or(self.name.span())
        } else {
            self.name.span()
        }
    }
}

pub fn visit_column_ref<'a>(_visit: &mut (impl Visit<'a> + ?Sized), _column_ref: &'a ColumnRef) {}

impl Parse for ColumnRef {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let ident1 = input.parse::<Ident>()?;
        if input.peek(Token![.]) {
            let correlation = Correlation {
                name: ident1,
                period_token: input.parse()?,
            };
            Ok(Self {
                correlation: Some(correlation),
                name: input.parse()?,
            })
        } else {
            Ok(Self {
                correlation: None,
                name: ident1,
            })
        }
    }
}

impl PrettyPrint for ColumnRef {
    fn pretty_print(&self, printer: &mut Printer) {
        self.correlation.pretty_print(printer);
        self.name.pretty_print(printer);
    }
}

impl ToTokens for ColumnRef {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let name = &self.name;
        let scope_id = ScopeId::of_scope();
        match &self.correlation {
            Some(correlation) => {
                let correlation = &correlation.name;
                quote! {
                    ::kosame::repr::expr::ColumnRef::new(
                        Some(scopes::#scope_id::tables::#correlation::TABLE_NAME),
                        scopes::#scope_id::tables::#correlation::columns::#name::COLUMN_NAME
                    )
                }
                .to_tokens(tokens);
            }
            None => quote! {
                ::kosame::repr::expr::ColumnRef::new(
                    ::core::option::Option::None,
                    scopes::#scope_id::columns::#name::COLUMN_NAME
                )
            }
            .to_tokens(tokens),
        }
    }
}

pub struct Correlation {
    pub name: Ident,
    pub period_token: Token![.],
}

impl PrettyPrint for Correlation {
    fn pretty_print(&self, printer: &mut Printer) {
        self.name.pretty_print(printer);
        self.period_token.pretty_print(printer);
    }
}