Unsatisfied Trait Bound When Inserting

[xFGhoul]

Setup

I am trying to use a struct to insert new models into my database, but I am running into trait issues when compiling

Versions

• Rust: rustc 1.86.0-nightly (824759493 2025-01-09)
• Diesel: 2.2.6
• Database: PostgreSQL
• Operating System Windows 11

Feature Flags

• diesel: postgres, uuid, chrono, numeric, ipnet-address

Problem Description

What are you trying to accomplish?

I am trying to do:

        diesel::insert_into(profiles::table)
            .values(&profile)
            .get_result::<Profile>(connection)
            .await

and make it work, &profile being a NewProfile struct:

#[derive(Debug, Clone, Insertable, Serialize, Deserialize)]
#[diesel(table_name = profiles)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct NewProfile {
    pub user_id: Uuid,
    pub first_name: String,
    pub last_name: String,
    pub email: String,
    pub age: i32,
    pub gender: Gender
}

What is the expected output?

Data is created with sufficient data as well as default values (ones omitted from profile and new profile) are created

What is the actual output?

Compile Time Errors: https://pastebin.com/F6mV9BR9

Are you seeing any additional errors?

Steps to reproduce

Profile:

#[derive(Clone, Debug, PartialEq, Queryable, Selectable, QueryableByName, Serialize, Deserialize, Identifiable, Insertable, Associations)]
#[diesel(table_name = profiles)]
#[diesel(check_for_backend(diesel::pg::Pg))]
#[diesel(belongs_to(User))]
pub struct Profile {
    pub id: i32,
    pub user_id: Uuid,
    pub first_name: String,
    pub last_name: String,
    pub email: String,
    pub age: i32,
    pub gender: Gender,
    pub weight: f64,
    pub height: f64,
    pub preferred_weight_unit: PreferredWeight,
    pub preferred_height_unit: PreferredHeight,
    pub public: bool,
    pub bio: String,
    pub avatar_url: String,
    pub fitness_goal: FitnessGoal,
    pub created_at: NaiveDateTime,
    pub updated_at: NaiveDateTime,
}

!table:

diesel::table! {
    use diesel::sql_types::*;
    use super::sql_types::Gender;
    use super::sql_types::Preferredweight;
    use super::sql_types::Preferredheight;
    use super::sql_types::Fitnessgoal;

    profiles (id) {
        id -> Int4,
        user_id -> Uuid,
        #[max_length = 255]
        first_name -> Varchar,
        #[max_length = 255]
        last_name -> Varchar,
        #[max_length = 255]
        email -> Varchar,
        age -> Int4,
        weight -> Float8,
        height -> Float8,
        gender -> Gender,
        preferred_weight_unit -> Preferredweight,
        preferred_height_unit -> Preferredheight,
        public -> Bool,
        bio -> Text,
        avatar_url -> Text,
        fitness_goal -> Fitnessgoal,
        created_at -> Timestamp,
        updated_at -> Timestamp,
    }
}

Relevant Code:

    pub async fn create(profile: NewProfile, connection: &mut DatabaseConnection) -> Result<Profile, MyError> {
        diesel::insert_into(profiles::table)
            .values(&profile)
            .get_result::<Profile>(connection)
            .await
            .map_err(|e| MyError(e.to_string()))
    }

Checklist

• [ x ] I have already looked over the issue tracker and the discussion forum for similar possible closed issues.

• [ x ] This issue can be reproduced on Rust's stable channel. (Your issue will be
  closed if this is not the case)
• This issue can be reproduced without requiring a third party crate

[xFGhoul]

I've just realized this should be a discussion, not an issue, I apologize, is there any way to convert?

[wowinter13]

@xFGhoul hello there, converted

[xFGhoul]

thanks a lot, adding some more information here as well
Enums:

#[derive(DbEnum, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[ExistingTypePath = "crate::schema::sql_types::Gender"]
pub enum Gender {
    Male,
    Female,
}

#[derive(DbEnum, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[ExistingTypePath = "crate::schema::sql_types::Preferredweight"]
pub enum PreferredWeight {
    Kg,
    Lbs,
}

#[derive(DbEnum, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[ExistingTypePath = "crate::schema::sql_types::Preferredheight"]
pub enum PreferredHeight {
    Cm,
    In,
}

#[derive(DbEnum, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[ExistingTypePath = "crate::schema::sql_types::Fitnessgoal"]
pub enum FitnessGoal {
    WeightLoss,
    MuscleGain,
    Maintenance,
    Endurance,
    Strength,
}

Raw SQL

CREATE TYPE Gender AS ENUM (
    'male',
    'female'
);

CREATE TYPE PreferredWeight AS ENUM (
    'kg',
    'lbs'
);

CREATE TYPE PreferredHeight AS ENUM (
    'cm',
    'in'
);

CREATE TYPE Role AS ENUM (
    'developer',
    'admin',
    'trainer',
    'user'
);

CREATE TYPE FitnessGoal AS ENUM (
    'weight_loss',
    'muscle_gain',
    'maintenance',
    'endurance',
    'strength'
);

CREATE TABLE profiles (
    "id" SERIAL PRIMARY KEY,
    "user_id" UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    "first_name" VARCHAR(255) NOT NULL,
    "last_name" VARCHAR(255) NOT NULL,
    "email" VARCHAR(255) NOT NULL,
    "age" INT NOT NULL,
    "weight" FLOAT NOT NULL DEFAULT ('100.0'), -- lbs
    "height" FLOAT NOT NULL DEFAULT ('150.0'), -- centimeters
    "gender" Gender NOT NULL,
    "preferred_weight_unit" PreferredWeight NOT NULL DEFAULT ('lbs'),
    "preferred_height_unit" PreferredHeight NOT NULL DEFAULT ('cm'),
    "public" BOOLEAN NOT NULL DEFAULT (FALSE),
    "bio" TEXT NOT NULL DEFAULT (''),
    "avatar_url" TEXT NOT NULL DEFAULT (''),
    "fitness_goal" FitnessGoal NOT NULL DEFAULT ('muscle_gain'),
    "created_at" TIMESTAMP NOT NULL DEFAULT now(),
    "updated_at" TIMESTAMP NOT NULL DEFAULT now()
);

[weiznich]

This error is not related to inserting the data, but to loading the result via get_result(). Such errors indicate a mismatch between what your query returns and what the rust side expects it to return. In this case it seems like the field order between your table! macro and your Profile type is off. The error message should also contain a note that says that you can get a better error message by adding .select(Profile::as_select()) or .returning(Profile::as_returning()) to your query. The later variant will in fact fix your problem.

[xFGhoul]

The field order was the issue the entire time, gender was off by about 3 indexes, simply matching the same order fixed and I was able to compile, wow, I did not know that this was required for compilations, are there any links to these weird quirks that I should keep in mind?, I also did see the note saying but since the order was off the error message was the same actually

[weiznich]

This specific issue is explicitly called out in the documentation of the Queryable derive and also in the documentation linked before. Also the guides use the variant with an .returning(Type::as_returning()) function call, which would have avoided this issue. We are open to improve the documentation further, but it's really unclear for us how to make this even more explicit.