sql-macros-derive 0.5.0

Auto generate sql queries for CRUD on sqlx
Documentation
//! `SqlUpdateManyColumns`: for callers who already have the batch built
//! column-wise (one `Vec<T>` per field) rather than row-wise — skips
//! `SqlUpdateMany`'s transpose-and-clone step, binding each field's `Vec`
//! straight into `UNNEST(...)`. Otherwise identical: one
//! `update_many_by_<field>` method per `#[table(update)]` field (never
//! silently combined with another marked field), `op` on that field
//! ignored (a batch key match is always `=`), `spec_columns`/
//! `return_type`/`return_fields` work the same, `fetch_all` (not
//! `SqlUpdate`'s `fetch_one`) since a batch can affect several rows, and
//! `RETURNING t.*` by default (not bare `*` — see `update_many.rs`'s
//! module doc for why).
//!
//! No length check across the column `Vec`s — if they're different
//! lengths, `UNNEST` zips them, padding the short ones with `NULL` up to
//! the longest. A `NOT NULL` column turns that into a loud database
//! error; a nullable one won't, so mismatched lengths there are the
//! caller's own responsibility to get right.

use quote::quote;

use crate::model::{self, TableModel};

fn generate_method(
    method_name: &syn::Ident,
    table_name: &str,
    spec_columns: Option<&str>,
    return_type: Option<&syn::Type>,
    return_fields: Option<&str>,
    key: &model::Column,
    set_columns: &[&model::Column],
) -> darling::Result<proc_macro2::TokenStream> {
    let ordered: Vec<&model::Column> = std::iter::once(key).chain(set_columns.iter().copied()).collect();
    let placeholders = model::unnest_placeholders(&ordered)?;
    let bind_args = model::self_bind_ref_tokens(&ordered);
    let key_ident = &key.ident;

    let data_columns = ordered
        .iter()
        .map(|c| c.ident.to_string())
        .collect::<Vec<_>>()
        .join(", ");

    let sql_set = model::sql_set_clause_from(set_columns, "data");
    let spec_columns_clause = spec_columns.map(|s| format!(", {s}")).unwrap_or_default();

    let query = format!(
        "UPDATE {table_name} AS t\nSET {sql_set}{spec_columns_clause}\nFROM UNNEST({placeholders}) AS data({data_columns})\nWHERE t.{key_ident} = data.{key_ident}"
    );
    let returning = return_fields.unwrap_or("t.*");

    let tokens = if let Some(return_type) = return_type {
        let query = format!("{query}\nRETURNING {returning}");
        let doc = model::sql_doc(&query);
        quote! {
            #[doc = #doc]
            pub async fn #method_name<'e, E>(&self, executor: E) -> Result<Vec<#return_type>, sqlx::Error>
            where
                E: sqlx::PgExecutor<'e>,
            {
                if self.#key_ident.is_empty() {
                    return Ok(Vec::new());
                }

                let objects = sqlx::query_as!(#return_type, #query, #bind_args)
                    .fetch_all(executor)
                    .await?;
                Ok(objects)
            }
        }
    } else {
        let doc = model::sql_doc(&query);
        quote! {
            #[doc = #doc]
            pub async fn #method_name<'e, E>(&self, executor: E) -> Result<sqlx::any::AnyQueryResult, sqlx::Error>
            where
                E: sqlx::PgExecutor<'e>,
            {
                if self.#key_ident.is_empty() {
                    return Ok(Default::default());
                }

                let result = sqlx::query!(#query, #bind_args).execute(executor).await?;
                Ok(result.into())
            }
        }
    };

    Ok(tokens)
}

pub fn expand(model: &TableModel) -> darling::Result<proc_macro2::TokenStream> {
    let struct_name = &model.struct_name;
    let mut errors = darling::Error::accumulator();
    let mut methods = Vec::new();

    for column in model.columns.iter().filter(|c| c.is_update_filter) {
        let method_name =
            syn::Ident::new(&format!("update_many_by_{}", column.ident), column.ident.span());

        let set_columns: Vec<&model::Column> = model
            .columns
            .iter()
            .filter(|c| c.ident != column.ident && !c.is_insert_only)
            .collect();

        if set_columns.is_empty() {
            errors.push(
                darling::Error::custom(format!(
                    "`{method_name}` has no columns left to SET: every field is the key"
                ))
                .with_span(&method_name),
            );
            continue;
        }

        if let Some(tokens) = errors.handle(generate_method(
            &method_name,
            &model.table_name,
            model.spec_columns.as_deref(),
            model.return_type.as_ref(),
            model.return_fields.as_deref(),
            column,
            &set_columns,
        )) {
            methods.push(tokens);
        }
    }

    errors.finish()?;

    Ok(quote! {
        impl #struct_name {
            #(#methods)*
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use quote::quote as q;

    fn parse(tokens: proc_macro2::TokenStream) -> syn::DeriveInput {
        syn::parse2(tokens).expect("failed to parse test struct")
    }

    #[test]
    fn no_update_filter_marked_generates_no_method() {
        let input = parse(q! {
            struct UserColumns { id: Vec<i32>, email: Vec<String> }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(!tokens.contains("fn update_many"));
    }

    #[test]
    fn binds_fields_directly_with_no_transpose() {
        let input = parse(q! {
            #[table(name = "users")]
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                email: Vec<String>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(!tokens.contains(".clone()"));
        assert!(!tokens.contains("items"));
        assert!(tokens.contains("fn update_many_by_id"));
        assert!(tokens.contains(
            "UPDATE users AS t\\nSET email=data.email\\n\
             FROM UNNEST($1::int4[],$2::text[]) AS data(id, email)\\n\
             WHERE t.id = data.id"
        ));
        assert!(tokens.contains("self . id"));
        assert!(tokens.contains("self . email"));
    }

    #[test]
    fn no_column_length_check_generated() {
        // Deliberate: mismatched-length column `Vec`s are the caller's
        // own responsibility — `UNNEST` just pads the short one with
        // `NULL`, which a `NOT NULL` column already turns into a loud
        // database error on its own.
        let input = parse(q! {
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                email: Vec<String>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(!tokens.contains("Configuration"));
        assert!(!tokens.contains(". len ()"));
    }

    #[test]
    fn op_on_an_update_filter_field_is_ignored() {
        let input = parse(q! {
            struct UserColumns {
                #[table(update, op = ["gt", "lt"])]
                id: Vec<i32>,
                email: Vec<String>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(tokens.contains("fn update_many_by_id"));
        assert!(!tokens.contains("fn update_many_by_id_gt"));
        assert!(!tokens.contains("fn update_many_by_id_lt"));
    }

    #[test]
    fn two_update_filter_fields_generate_two_independent_methods() {
        let input = parse(q! {
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                #[table(update)]
                email: Vec<String>,
                is_active: Vec<bool>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(tokens.contains("fn update_many_by_id"));
        assert!(tokens.contains("fn update_many_by_email"));
    }

    #[test]
    fn with_return_type_uses_fetch_all_not_fetch_one() {
        let input = parse(q! {
            #[table(return_type = User)]
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                email: Vec<String>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(tokens.contains("fetch_all"));
        assert!(!tokens.contains("fetch_one"));
        assert!(tokens.contains("RETURNING t.*"));
    }

    #[test]
    fn nullable_column_vec_option_detects_its_type_and_binds_with_as_cast() {
        // Full expand(), not just `unnest_array_type` in isolation —
        // same reasoning as `insert_many_columns.rs`'s version.
        let input = parse(q! {
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                priority: Vec<Option<i32>>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(tokens.contains("UNNEST($1::int4[],$2::int4[])"));
        assert!(tokens.contains("& self . priority as _"));
    }

    #[test]
    fn every_field_as_key_is_an_error() {
        let input = parse(q! {
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let err = expand(&model).unwrap_err();
        assert!(err.to_string().contains("no columns left to SET"));
    }

    #[test]
    fn insert_only_field_is_excluded_from_the_set_clause() {
        let input = parse(q! {
            struct UserColumns {
                #[table(update)]
                id: Vec<i32>,
                #[table(insert_only)]
                created_by: Vec<i32>,
                email: Vec<String>,
            }
        });
        let model = TableModel::from_derive_input(&input).unwrap();
        let tokens = expand(&model).unwrap().to_string();
        assert!(tokens.contains("SET email=data.email"));
        assert!(!tokens.contains("created_by"));
    }
}