Is there a way to abstract table schemas or anything that will make this easier to maintain

[Atakku]

Hi diesel users. I'm just beginning with rust and diesel, and I have struck an issue. The project I'm working with has a large table with lots of duplicate rows, and instead of defining a single table definition (57 columns), I've decided to make 8 separate table definitions with exactly the same structure:

// rx_catch
table! {
  #[sql_name = "stats"]
  stats_rx_catch (id) {
    id -> Integer,
    #[sql_name = "tscore_rx_catch"]
    tscore -> Unsigned<BigInt>,
    #[sql_name = "rscore_rx_catch"]
    rscore -> Unsigned<BigInt>,
    #[sql_name = "pp_rx_catch"]
    pp -> Unsigned<Integer>,
    #[sql_name = "plays_rx_catch"]
    plays -> Unsigned<Integer>,
    #[sql_name = "playtime_rx_catch"]
    playtime -> Unsigned<Integer>,
    #[sql_name = "acc_rx_catch"]
    acc -> Float,
    #[sql_name = "max_combo_rx_catch"]
    max_combo -> Unsigned<Integer>,
  }
}
// ap_std
table! {
  #[sql_name = "stats"]
  stats_ap_std (id) {
    id -> Integer,
    #[sql_name = "tscore_ap_std"]
    tscore -> Unsigned<BigInt>,
    #[sql_name = "rscore_ap_std"]
    rscore -> Unsigned<BigInt>,
    #[sql_name = "pp_ap_std"]
    pp -> Unsigned<Integer>,
    #[sql_name = "plays_ap_std"]
    plays -> Unsigned<Integer>,
    #[sql_name = "playtime_ap_std"]
    playtime -> Unsigned<Integer>,
    #[sql_name = "acc_ap_std"]
    acc -> Float,
    #[sql_name = "max_combo_ap_std"]
    max_combo -> Unsigned<Integer>,
  }
  // 6 more similar definitions

This would be fine, until I've struck another problem: Now I have to query 8 tables, and I have no idea how to abstract it, so I don't have to write 8 definitions of this just to do one query on each table:

let data = stats_rx_catch::table
    .inner_join(users::table)
    .filter(stats_rx_catch::pp.gt(0))
    .order(stats_rx_catch::pp.desc())
    .select((
      stats_rx_catch::id,
      users::name,
      stats_rx_catch::tscore,
      stats_rx_catch::rscore,
      stats_rx_catch::pp,
      stats_rx_catch::plays,
      stats_rx_catch::playtime,
      stats_rx_catch::acc,
      stats_rx_catch::max_combo
    )).load::<Leaderboard>(&c);
// Different function

let data = stats_ap_std::table
    .inner_join(users::table)
    .filter(stats_ap_std::pp.gt(0))
    .order(stats_ap_std::pp.desc())
    .select((
      stats_ap_std::id,
      users::name,
      stats_ap_std::tscore,
      stats_ap_std::rscore,
      stats_ap_std::pp,
      stats_ap_std::plays,
      stats_ap_std::playtime,
      stats_ap_std::acc,
      stats_ap_std::max_combo
    )).load::<Leaderboard>(&c);
// and so on

So is there a way to abstract this? Or a better approach? I'm new to Rust, and trying to learn it fast.

[weiznich]

Conceptually there is not much here that can be abstracted away. The select clauses needs to be passed explicitly as each of them refer to a different set of columns. The join, the other filter and the order clause are dependent on the table. Both, the table and the columns are represented as distinct types, so you cannot easily substitute them. That would be like using an i32 in place of a String. In the end that's the price you pay for checking your queries a part of the type system.

The only possibility I see here to improve your code is to refactor your database schema in such a way that you use the same columns for all 8 cases. You could differentiate between them by using a separate column as type.