sqlc-gen-sqlx 0.2.1

A sqlc plugin that generates type-safe sqlx Rust code from SQL queries.
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

use crate::{
    catalog, config::Config, emit::FileEmitter, error::Error, plugin::GenerateRequestView,
    types::TypeMap,
};

mod batch;
mod composites;
mod copyfrom;
mod enums;
pub(crate) mod lifetimes;
mod query;

pub fn generate(request: &GenerateRequestView<'_>, config: &Config) -> Result<String, Error> {
    let mut type_map = TypeMap::new(&config.overrides, &config.copy_cheap_types);
    let catalog_info = catalog::walk(request, &mut type_map)?;
    let col_overrides = crate::types::build_column_overrides(&config.overrides);
    let mut emitter = FileEmitter::new(request.sqlc_version, env!("CARGO_PKG_VERSION"));

    // Emit the AsExecutor trait + impls up front so query functions can reference it.
    emitter.push(quote::quote! {
        pub trait AsExecutor {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres>;
        }

        impl AsExecutor for sqlx::PgPool {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                &*self
            }
        }

        impl AsExecutor for &sqlx::PgPool {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                *self
            }
        }

        impl AsExecutor for sqlx::PgConnection {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                &mut *self
            }
        }

        impl AsExecutor for sqlx::Transaction<'_, sqlx::Postgres> {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                &mut **self
            }
        }

        impl AsExecutor for sqlx::pool::PoolConnection<sqlx::Postgres> {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                &mut **self
            }
        }

        impl<T: AsExecutor + ?Sized> AsExecutor for &mut T {
            fn as_executor(&mut self) -> impl sqlx::Executor<'_, Database = sqlx::Postgres> {
                (**self).as_executor()
            }
        }
    });

    // Emit type definitions before query code.
    for info in &catalog_info.enums {
        emitter.push(enums::gen_enum(info, &config.enum_derives)?);
    }
    for info in &catalog_info.composites {
        emitter.push(composites::gen_composite(info, &config.composite_derives)?);
    }

    for q in request.queries.iter() {
        let tokens = match q.cmd {
            ":exec" => query::gen_exec(q, &type_map, config, &col_overrides)?,
            ":execrows" => query::gen_execrows(q, &type_map, config, &col_overrides)?,
            ":execresult" => query::gen_execresult(q, &type_map, config, &col_overrides)?,
            ":execlastid" => query::gen_execlastid(q, &type_map, config, &col_overrides)?,
            ":batchexec" => batch::gen_batchexec(q, &type_map, config, &col_overrides)?,
            ":batchone" => batch::gen_batchone(q, &type_map, config, &col_overrides)?,
            ":batchmany" => batch::gen_batchmany(q, &type_map, config, &col_overrides)?,
            ":copyfrom" => copyfrom::gen_copyfrom(q, &type_map, config, &col_overrides)?,
            ":one" => query::gen_one(q, &type_map, config, &col_overrides)?,
            ":many" => query::gen_many(q, &type_map, config, &col_overrides)?,
            cmd => {
                eprintln!("sqlc-gen-sqlx: skipping unsupported annotation {cmd}");
                continue;
            }
        };
        emitter.push(tokens);
    }

    emitter.finish()
}