Support user-defined types with the query_as! and query_file_as! macros

[mehcode]

An example of what I would like to see for usage

#[derive(sqlx::Type)]
enum Role { Admin, Staff, Normal, Advisor }

#[sqlx::record] 
struct User { id: i32, name: String, role: Role }

let usr: User = sqlx::query_as!("SELECT id, name FROM user")
    .fetch_one(&mut conn).await?;

• The #[sqlx::record] is merely saying I would be okay with requiring a proc attribute here if we need to inspect the struct and attach additional metadata to inspect later ( which I think we do )

---

I think this is blocked on Rust stabilizing const_panic and const_if. I can't think of another clean way to support this apart from generating a series of const _: () = { ... } blocks where we enforce the type equivalence (between the SQL result type and the given Rust type).

I'm definitely open to other suggestions though. What @abonander and I don't want though is to significantly degrade the errors.

[mehcode]

An idea that I just had.

sqlx::query_as!(User {
    // field "role" is assigned the SQL result column "role"
    // and force cast to the type Role
    role: "role" as Role,
    
    // other fields are default
    ..
},
    r#"
SELECT
    id,
    name,
    role

FROM users

ORDER BY created_at DESC
LIMIT 25
    "#,
);

The { ... } would become an optional block after the type name in query_as! and query_file_as!.

This would allow:

• Forcing the use of a specific Rust type ( assuming the proper Encode/Decode impls exist )
• Override the Rust field name <-> SQL name mapping

Ideally we evolve query_as! to make user-defined types, type-safe but this would make a reasonable stop gap until we can reach that.

[Freax13]

how about a derive for sqlx::FromRow? Isn't that basically what you need?

[mehcode]

@Freax13 I actually just added one to master. However that would only be for query_as().

The output verification in query_as! additionally provides:

• Compile-time guarantees on output type with errors like expected i32; found bool.

• Compile-time guarantees on matching column names with rust field names without the overhead of run-time column name lookup.

[phated]

I just ran into this issue too. I'm experimenting with query_as_unchecked! but it doesn't quite give me the type safety I am looking for.