Diesel Rust Query: 'the trait bound not satisfied' error when mapping query result to struct

Question

the trait bound (diesel::sql_types::Integer, Text, Text, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, Text): load_dsl::private::CompatibleType<User, Mysql> is not satisfied

use diesel::prelude::*;
use bcrypt::{hash, DEFAULT_COST, verify};

use crate::orm::users::{User, NewUser };
use crate::orm::users::users::{table as users_table, phone};

pub struct UserService;

impl UserService {
    pub fn register_user(
        phone_input: String, 
        password: String, 
        invitation_code: String,
        conn: &mut MysqlConnection
    ) -> Result<usize, diesel::result::Error> {
        // 密码加密
        let hashed_password = hash(password, DEFAULT_COST).unwrap();
    
        // 创建一个用于插入的新用户对象
        let new_user = NewUser {
            phone: phone_input,
            password: hashed_password,
            invitation_code: if invitation_code.is_empty() { None } else { Some(invitation_code) },
        };
    
        // 插入新用户到数据库并返回插入的 User 对象
        diesel::insert_into(users_table) // 确保这是正确的表引用
            .values(&new_user)
            .execute(conn) // 这将返回 Result<User, diesel::result::Error>
    }

    pub fn login_user(
        phone_input: String, 
        password: String, 
        conn: &MysqlConnection
    ) -> Result<User, diesel::result::Error> {
        // 从数据库获取用户
        let user = users_table
            .filter(phone.eq(&phone_input))
            .first::<User>(conn)
            .map_err(|_| diesel::result::Error::NotFound)?;  // 如果找不到用户，返回 NotFound 错误
    
        // 验证密码
        match verify(&password, &user.password) {
            Ok(valid) => {
                if valid {
                    Ok(user)
                } else {
                    // 密码不正确
                    Err(diesel::result::Error::NotFound) // 或者其他更合适的错误
                }
            },
            Err(_) => {
                // 处理验证过程中的错误
                Err(diesel::result::Error::NotFound) // 或者其他更合适的错误
            }
        }
    }
}

use diesel::prelude::*;
use diesel::table;

table! {
    users (id) {
        id -> Integer,
        phone -> Varchar,
        password -> Varchar,
        ctime -> Timestamp,
        mtime -> Timestamp,
        invitation_code -> Varchar,
    }
}

#[derive(Insertable)]
#[table_name = "users"]
pub struct NewUser {
    pub phone: String,
    pub password: String,
    pub invitation_code: Option<String>,
    // 不包括 id, ctime, mtime
}

#[derive(Queryable, AsChangeset, Debug)]
#[table_name="users"]
pub struct User {
    pub id: i32,
    pub phone: String,
    pub password: String,
    pub ctime: chrono::NaiveDateTime,
    pub mtime: chrono::NaiveDateTime,
    pub invitation_code: Option<String>,
}

I attempted to load user data from a MySQL database using Diesel ORM. I was expecting the first::(conn) method to query and return a User instance based on the provided phone number. Given the Diesel documentation and the definition of my User struct, this query should work correctly as my struct fields completely match the columns in the database table.

However, when executing this query, the compiler threw an error indicating a mismatch between the User struct and the SQL types:

the trait bound `(diesel::sql_types::Integer, Text, Text, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, Text): load_dsl::private::CompatibleType<User, Mysql>` is not satisfied

I expected the query to execute without errors and return a matching User object, but what actually happened was a compiler error preventing the execution of my query. I have tried confirming whether my User struct correctly implements the Queryable trait and ensuring that all field types match the SQL types defined in the table! macro. The error persists, and I am unsure how to resolve it.