to_sql_condition 0.2.1

a simple genreate sql condition proc macro
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
153
154
155
156
157

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    AngleBracketedGenericArguments, Data, DataStruct, DeriveInput, Field, Fields, FieldsNamed,
    GenericArgument, PathArguments::AngleBracketed, Type, TypePath,
};

pub fn impl_to_sql_condition(input: DeriveInput) -> TokenStream {
    let name = input.ident;

    // get the fields of the struct
    let fields = if let Data::Struct(DataStruct {
        fields: Fields::Named(FieldsNamed { named, .. }),
        ..
    }) = input.data
    {
        named
    } else {
        panic!("Only structs with named fields are supported");
    };

    // traverse the fields and generate the code
    let mut limit_clause = quote! {};
    let mut where_clause = quote! {};

    for field in fields {
        let field_name = field.ident.as_ref().unwrap();
        let (is_option, is_number) = field_is_option_and_get_type(&field);
        if is_option {
            match field_name.to_string().as_str() {
                "offset" => {
                    limit_clause = quote! {
                        #limit_clause
                        if let Some(field_value) = &self.#field_name {
                            limit_clause.push_str(&format!(" OFFSET {}", field_value));
                        }
                    };
                }
                "limit" => {
                    limit_clause = quote! {
                        #limit_clause
                        if let Some(field_value) = &self.#field_name {
                            limit_clause.push_str(&format!(" LIMIT {}", field_value));
                        }
                    };
                }
                _ => {
                    where_clause = quote! {
                        #where_clause
                        if let Some(field_value) = &self.#field_name {
                            if #is_number {
                                where_clause.push_str(&format!(" AND {} = {}", stringify!(#field_name), field_value));
                            } else {
                                where_clause.push_str(&format!(" AND {} = '{}'", stringify!(#field_name), field_value));
                            }
                        }
                    };
                }
            }
        } else {
            match field_name.to_string().as_str() {
                "offset" => {
                    limit_clause = quote! {
                        #limit_clause
                        limit_clause.push_str(&format!(" OFFSET {}", self.#field_name));
                    };
                }
                "limit" => {
                    limit_clause = quote! {
                        #limit_clause
                        limit_clause.push_str(&format!(" LIMIT {}", self.#field_name));
                    };
                }
                _ => {
                    where_clause = quote! {
                        #where_clause
                        if #is_number {
                            where_clause.push_str(&format!(" AND {} = {}", stringify!(#field_name), self.#field_name));
                        } else {
                        where_clause.push_str(&format!(" AND {} = '{}'", stringify!(#field_name), self.#field_name));
                        }
                    };
                }
            }
        }
    }

    let output = quote! {
        impl #name {
            pub fn to_sql_condition(&self) -> String {
                let mut sql = String::new();
                let mut where_clause = String::new();
                let mut limit_clause = String::new();
                // generate the where clause
                #where_clause

                if !where_clause.is_empty() {
                    sql.push_str(" WHERE ");
                    // remove the first " AND "
                    sql.push_str(&where_clause[5..]);
                }

                // generate the limit clause
                #limit_clause
                sql.push_str(&limit_clause);

                sql
            }
        }
    };

    output.into()
}

// judge whether the field is Option
fn field_is_option_and_get_type(field: &Field) -> (bool, bool) {
    if let syn::Type::Path(TypePath { path, .. }) = &field.ty {
        if let Some(segment) = path.segments.last() {
            if segment.ident == "Option" {
                if let AngleBracketed(AngleBracketedGenericArguments { args, .. }) =
                    &segment.arguments
                {
                    if let Some(GenericArgument::Type(Type::Path(TypePath { path, .. }))) =
                        args.first()
                    {
                        if let Some(segment) = path.segments.first() {
                            return (true, field_is_number(&segment.ident.to_string()));
                        }
                    }
                }
            } else {
                return (false, field_is_number(&segment.ident.to_string()));
            }
        }
    }
    return (false, field_is_number("unknown"));
}

// judge whether is a number
fn field_is_number(field_type: &str) -> bool {
    if field_type == "i8"
        || field_type == "i16"
        || field_type == "i32"
        || field_type == "i64"
        || field_type == "i128"
        || field_type == "u8"
        || field_type == "u16"
        || field_type == "u32"
        || field_type == "u64"
        || field_type == "u128"
        || field_type == "f32"
        || field_type == "f64"
    {
        return true;
    }
    return false;
}