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() {
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() {
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"));
}
}