postgres-named-parameters-derive 0.1.0

Derive macros used internally by `postgres-named-parameters`. You should not use this crate directly; instead, use `postgres-named-parameters`.
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

use attribute_derive::FromAttr;
use quote::quote;
use syn::{DeriveInput, Type};

#[derive(FromAttr)]
#[attribute(ident = query)]
struct QueryTraitHelperAttribute {
    #[attribute(example = r#""SELECT * FROM Person WHERE first_name = @name""#)]
    sql: String,
    #[attribute(example = "crate::my_database_tables::Person")]
    row: Type,
}

pub fn derive_query_impl(ast: DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
    let args = QueryTraitHelperAttribute::from_attributes(&ast.attrs)?;
    let syn::Data::Struct(struct_ast) = ast.data else {
        return Err(syn::Error::new(
            ast.ident.span(),
            "#[derive(Query)] can only be used on structs",
        ));
    };
    let named_parameters = crate::util::get_field_names(&struct_ast);
    let parameter_list = crate::util::get_parameter_list(&struct_ast);
    let transformed_sql = match crate::numberify::numberify(args.sql, named_parameters) {
        Ok(sql) => sql,
        Err(err) => {
            let err = format!("Error with SQL provided to #[derive(Query)]: {}", err);
            return Err(syn::Error::new(ast.ident.span(), err));
        }
    };

    let generics = ast.generics;
    let ident = ast.ident;
    let where_clause = &generics.where_clause;
    let row_type = args.row;

    let output = quote! {
        #[automatically_derived]
        impl #generics postgres_named_parameters::Query for #ident #generics #where_clause {
            type Row = #row_type;
            fn query_all(
                &self,
                connection: &mut impl postgres_named_parameters::postgres::GenericClient,
            ) -> Result<Vec<Self::Row>, postgres_named_parameters::postgres::error::Error> {
                let rows = connection.query(#transformed_sql, #parameter_list)?;
                rows
                    .iter()
                    .map(postgres_named_parameters::internal::wrapper_for_derive_macro::try_from_row::<Self::Row>)
                    .collect()
            }

            fn query_opt(
                &self,
                connection: &mut impl postgres_named_parameters::postgres::GenericClient,
            ) -> Result<Option<Self::Row>, postgres_named_parameters::postgres::error::Error> {
                let maybe_row = connection.query_opt(#transformed_sql, #parameter_list)?;
                match maybe_row {
                    None => Ok(None),
                    Some(row) => {
                        let decoded_row = postgres_named_parameters::internal::wrapper_for_derive_macro::try_from_row::<Self::Row>(&row)?;
                        Ok(Some(decoded_row))
                    }
                }
            }

            fn query_one(
                &self,
                connection: &mut impl postgres_named_parameters::postgres::GenericClient,
            ) -> Result<Self::Row, postgres_named_parameters::postgres::error::Error> {
                let row = connection.query_one(#transformed_sql, #parameter_list)?;
                postgres_named_parameters::internal::wrapper_for_derive_macro::try_from_row::<Self::Row>(&row)
            }
        }
    };
    Ok(output.into())
}