Feature Request: Add Field Attribute for Mapping to Different Database Column Names

[cnwzhu]

Currently, the model mapping functionality relies on the model's field names directly corresponding to the database column names. The existing field attributes (#[key], #[auto], #[unique], #[index]) are very useful for defining key constraints and indexing, but they do not address the scenario where the desired model field name differs from the legacy or externally mandated database column name.

This limitation forces developers to name their model fields exactly as they appear in the database, which can lead to violations of application-level naming conventions (e.g., using snake_case in the database vs. camelCase in the model) and reduce the clarity and expressiveness of the model code.

I propose the introduction of a new field attribute that allows developers to explicitly specify the corresponding database column name for a model field. A good candidate for this attribute would be something like #[column("...")] or #[map("...").

This would allow the mapping logic to look for this attribute first and, if present, use the specified name to map to the database column. If the attribute is not present, it would fall back to the current behavior of using the field's name directly.

Example:

Let's say we have a database table users with a column named user_id. In our application code, we would prefer to use id for better readability. With the proposed attribute, we could define our model like this:

struct User {
    #[key]
    #[column("user_id")] // New attribute
    id: i32,

    #[column("user_name")]
    name: String,
    
    // Other fields...
}

[carllerche]

Yep, this makes sense. There already is #[db(...)] for specifying the db column type. That probably is a good way to work it in.

struct User {
    #[db(name = "user_name")]
    name: String,
}

Need to figure out how to combine that with specifying a DB column type.

[TristanWasTaken]

Yep, this makes sense. There already is #[db(...)] for specifying the db column type. That probably is a good way to work it in.

struct User {
#[db(name = "user_name")]
name: String,
}

Need to figure out how to combine that with specifying a DB column type.

EF Core does it as [Column("<fieldName>", TypeName = "<type>")]
https://learn.microsoft.com/en-us/ef/core/modeling/entity-properties?tabs=data-annotations%2Cwith-nrt#column-data-types

public class User
{
    [Column("user_name")]
    public string Username { get; set; }

    [Column("SuperSpecialDateField", TypeName = "timestamp without time zone")]
    public DateTime CreateDate { get; set; }
}

As for the naming

#[db(name = "str", type = "str")]

Tbh I think #[db()] as an attribute name for columns is a bit too generic, compared to e.g. #[column()] :/

On that note as someone who really likes EFCore's data modeling api, #[model(table = str) compared to e.g. #[table(name = "str")] is a bit unexpected too :)

[carllerche]

That makes sense to me:

• #[column("user_name")]
• #[column(type = "varchar(10)")]
• #[column("user_name", type = "varchar(10)")]

Does that work?