sqlx reading source_file SQL from build script?

[smklein]

I'm interested in using sqlx from a context where a build.rs file can help with generating SQL, that sqlx can help validate. I have a codebase that includes a fair amount of boilerplate, so writing all SQL by hand is onerous, and I'd like to use Rust code to generate that SQL. However, sqlx's ability to validate query input/output seems quite handy, and I'd also like to make use of that.

Here's the architecture I was considering:

1. Write a SQL query using rust code, and this rust code is emitted as part of a build.rs. This file ends up within concat!(std::env!("OUT_DIR"), "/my_query.sql").
2. To use that SQL query, read that input file in the regular (non-build-script) codebase, using something like:

sqlx::query_file!(concat!(std::env!("OUT_DIR"), "/my_query.sql"));

However, in practice, I've noticed that even though "code generation" of the SQL happens before the sqlx::query_file call, the sqlx macros really want to operate on a string literal path:

query_file!:

sqlx/src/macros/mod.rs

Lines 387 to 396 in 419877d

	#[macro_export]
	#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
	macro_rules! query_file (
	($path:literal) => ({
	$crate::sqlx_macros::expand_query!(source_file = $path)
	});
	($path:literal, $($args:tt)*) => ({
	$crate::sqlx_macros::expand_query!(source_file = $path, args = [$($args)*])
	})
	);

Calls expand_query:

sqlx/sqlx-macros/src/lib.rs

Lines 7 to 23 in 419877d

	#[cfg(feature = "macros")]
	#[proc_macro]
	pub fn expand_query(input: TokenStream) -> TokenStream {
	let input = syn::parse_macro_input!(input as query::QueryMacroInput);
	match query::expand_input(input, FOSS_DRIVERS) {
	Ok(ts) => ts.into(),
	Err(e) => {
	if let Some(parse_err) = e.downcast_ref::<syn::Error>() {
	parse_err.to_compile_error().into()
	} else {
	let msg = e.to_string();
	quote!(::std::compile_error!(#msg)).into()
	}
	}
	}
	}

Parses the input source_file as a literal:

sqlx/sqlx-macros-core/src/query/input.rs

Lines 60 to 62 in 419877d

	} else if key == "source_file" {
	let lit_str = input.parse::<LitStr>()?;
	query_src = Some((QuerySrc::File(lit_str.value()), lit_str.span()));

Is there any consideration for parsing these source_file paths as something other than a literal? If the sqlx proc macros could determine this file path slightly more dynamically, it seems possible to make that handoff from "build script" to "sqlx".

Curious if others have hit this problem too, or if there are other approaches folks have taken to a similar problem.

[smklein]

For what it's worth, I think this problem also applies to the query! macro, if I was trying to generate a string in-line:

sqlx/src/macros/mod.rs

Lines 314 to 330 in 419877d

	macro_rules! query (
	// in Rust 1.45 we can now invoke proc macros in expression position
	($query:expr) => ({
	$crate::sqlx_macros::expand_query!(source = $query)
	});
	// RFC: this semantically should be `$($args:expr),*` (with `$(,)?` to allow trailing comma)
	// but that doesn't work in 1.45 because `expr` fragments get wrapped in a way that changes
	// their hygiene, which is fixed in 1.46 so this is technically just a temp. workaround.
	// My question is: do we care?
	// I was hoping using the `expr` fragment might aid code completion but it doesn't in my
	// experience, at least not with IntelliJ-Rust at the time of writing (version 0.3.126.3220-201)
	// so really the only benefit is making the macros _slightly_ self-documenting, but it's
	// not like it makes them magically understandable at-a-glance.
	($query:expr, $($args:tt)*) => ({
	$crate::sqlx_macros::expand_query!(source = $query, args = [$($args)*])
	})
	);

The source parameter is also being parsed as a LitStr:

sqlx/sqlx-macros-core/src/query/input.rs

Lines 53 to 59 in 419877d

	if key == "source" {
	let span = input.span();
	let query_str = Punctuated::<LitStr, Token![+]>::parse_separated_nonempty(input)?
	.iter()
	.map(LitStr::value)
	.collect();
	query_src = Some((QuerySrc::String(query_str), span));

I would be interested in a way to generate these inputs, which is also sorta discussed within the query! docs:

The query must be a string literal, or concatenation of string literals using + (useful for queries generated by macro), or else it cannot be introspected (and thus cannot be dynamic or the result of another macro).

If I'm trying to have my "query be generated by a macro" -- as that documentation around the + symbol implies -- how would I make that jump from generated SQL to a literal?

I'm worried that e.g. if I wrote my own proc macro to emit a SQL literal, I would need to be cautious to not run afoul of rust-lang/reference#692