prqlx 0.2.1

A procedural macro for using PRQL in sqlx
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    parse_macro_input,
    punctuated::Punctuated,
    Expr, ExprLit, Lit, Path, Token,
};

struct QueryInput {
    /// The SQL query to execute
    query: Expr,
    /// Any extra arguments to pass to [`sqlx::query`]
    args: Punctuated<Expr, Token![,]>,
}

impl Parse for QueryInput {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let query: Expr = input.parse()?;
        let args = if input.is_empty() {
            Punctuated::new()
        } else {
            let _: Token![,] = input.parse()?;
            input.parse_terminated(Expr::parse, Token![,])?
        };

        Ok(Self { query, args })
    }
}

struct QueryAsInput {
    /// The type to parse the query as
    ty: Path,
    /// The SQL query to execute
    query: Expr,
    /// Any extra arguments to pass to [`sqlx::query`]
    args: Punctuated<Expr, Token![,]>,
}

impl Parse for QueryAsInput {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let ty: Path = input.parse()?;
        let _: Token![,] = input.parse()?;
        let query: Expr = input.parse()?;
        let args = if input.is_empty() {
            Punctuated::new()
        } else {
            let _: Token![,] = input.parse()?;
            input.parse_terminated(Expr::parse, Token![,])?
        };

        Ok(Self { ty, query, args })
    }
}

fn to_sql(query: Expr) -> String {
    let prql_string = match query {
        Expr::Lit(ExprLit {
            lit: Lit::Str(lit_str),
            ..
        }) => lit_str.value(),
        _ => panic!("query! requires a string for the query"),
    };

    let opts = prql_compiler::Options::default().no_format().no_signature();
    match prql_compiler::compile(&prql_string, &opts) {
        Ok(r) => r,
        Err(err) => {
            panic!("{}", err)
        }
    }
}

#[proc_macro]
/// Combines a PRQL query with a call to [`sqlx::query`].
pub fn query(input: TokenStream) -> TokenStream {
    let parsed = parse_macro_input!(input as QueryInput);

    let sql_string = to_sql(parsed.query);

    if parsed.args.is_empty() {
        let tokens = quote! {
            sqlx::query!(#sql_string)
        };

        tokens.into()
    } else {
        let args = parsed.args.iter();
        let tokens = quote! {
            sqlx::query!(#sql_string, #(#args),*)
        };

        tokens.into()
    }
}

#[proc_macro]
/// Combines a PRQL query with a call to [`sqlx::query_as`].
pub fn query_as(input: TokenStream) -> TokenStream {
    let parsed = parse_macro_input!(input as QueryAsInput);

    let sql_string = to_sql(parsed.query);
    let ty = parsed.ty.require_ident().unwrap();

    if parsed.args.is_empty() {
        let tokens = quote! {
            sqlx::query_as!(#ty, #sql_string)
        };

        tokens.into()
    } else {
        let args = parsed.args.iter();
        let tokens = quote! {
            sqlx::query_as!(#ty, #sql_string, #(#args),*)
        };

        tokens.into()
    }
}