Is there any plan to allow using other macros in `query!()`?

[qwfy]

Often, you need to write similar but distinct sqls (eg. all sqls have the same columns but different wheres) based on the inputs, (note all combinations of inputs are known at the development time, so this in theory can be done at compile time), it would reduce code duplication (thus reduce the burden of maintaining and testing), this could be done via code like this:

if condition1() {
  sqlx::query!(generate_sql_and_args!(condition1 = true, value)...
} else {
  sqlx::query!(generate_sql_and_args!(condition2 = true)...

// generate_sql_and_args!(condition1 = true) would expand to:
// "select col from tab where col = $1", value
// the the first query! becomes:
sqlx::query!("select col from tab where col = $1", value)
}

This (semi-dynamic query) is something that we use quite often, it would be wonderful that this can be expressed in a type safe manner.

[raftario]

This isn't currently possible because the macros need to access the SQL query and proc macros are expanded before macro_rules macros, so using anything but a literal or file won't work.

[NyxCode]

This is possible, query! can be used like this: query!(".." + "..").
I use this for reusing big column lists in select queries. I've got a select! macro which takes a literal and expands to query!("SELECT ... FROM ..." + $argument), which I can use like this: select!("WHERE .. ORDER BY .. )

[abonander]

We debated adding support for stringify!() and concat!() since we can reimplement those manually, however it may end up just being more confusing because we can't support all macros. User-defined macros are right-out, and we can't support include_str!() because it uses compiler-private APIs to resolve paths relative to the current file.

[NyxCode]

I have been hacking around for a few days now trying to solve this problem of dynamic queries dependent on inputs.
Here is how far I got using decl macros:

let filter = Some("asdf");
let limit = Some(3);
let query = conditional_query!(
    "SELECT * FROM users"
    Some(f) = filter => {
        "WHERE name LIKE" ?(f)
    }
    Some(l) = limit => {
        "LIMIT" ?(l)
    }
);

currently, this expands to

let query = loop  {
    if let Some(f) = filter {
        if let Some(l) = limit {
            break  sqlx::query!("SELECT * FROM users WHERE name LIKE ? LIMIT ?", f, l);
        }
    };
    if let Some(l) = limit {
        break sqlx::query!("SELECT * FROM users LIMIT ?", l) ;
    };
    if let Some(f) = filter {
        break sqlx::query!("SELECT * FROM users WHERE name LIKE ?", f) ;
    };
    break sqlx::query!("SELECT * FROM users ") ;
    unreachable!();
};

In practice, this doesn't work yet, since the return type of sqlx::query! differs between the branches, so i'll have to find a way around that.

[NyxCode]

figured something out, here is a working example and here are the docs.
Like @qwfy noted, every possible query will be checked at compile time.

[abonander]

Instead of hand-rolling support for macros in the input, I would prefer to have something like rust-lang/rfcs#2320 which was unfortunately just postponed.

It looks like some workarounds have been found that don't require it though so I'm closing this for now.