Error Trait "FromStaticSqlRow" is not implemented ... still showing after implementing FromSql and ToSql in custom enum

[stanley355]

I followed the tutorial both from:

1. https://github.com/diesel-rs/diesel/blob/master/diesel_tests/tests/custom_types.rs
2. https://github.com/diesel-rs/diesel/blob/master/examples/postgres/custom_types/src/model.rs
   To implement custom rust type with enum, however on compilation I still had the following error:

error[E0277]: the trait bound `(i32, uuid::Uuid, i32, NaiveDateTime, NaiveDateTime, NaiveDateTime, BigDecimal, subscription_period::SubscriptionPeriod, payment_status::PaymentStatus, std::option::Option<Value>): FromStaticSqlRow<(Integer, diesel::sql_types::Uuid, Integer, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, diesel::sql_types::Numeric, schema::sql_types::SubscriptionPeriod, schema::sql_types::PaymentStatus, diesel::sql_types::Nullable<diesel::sql_types::Jsonb>), Pg>` is not satisfied

 diesel::insert_into(subscription_payments::table).values(insert_values).get_result(conn)
     |                                                                                           ---------- ^^^^ the trait `FromStaticSqlRow<(Integer, diesel::sql_types::Uuid, Integer, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, diesel::sql_types::Timestamp, diesel::sql_types::Numeric, schema::sql_types::SubscriptionPeriod, schema::sql_types::PaymentStatus, diesel::sql_types::Nullable<diesel::sql_types::Jsonb>), Pg>` is not implemented for `(i32, uuid::Uuid, i32, NaiveDateTime, NaiveDateTime, NaiveDateTime, BigDecimal, subscription_period::SubscriptionPeriod, payment_status::PaymentStatus, std::option::Option<Value>)`, which is required by `InsertStatement<subscription_payments::table, query_builder::insert_statement::ValuesClause<(ColumnInsertValue<subscription_payments::columns::user_id, diesel::expression::bound::Bound<diesel::sql_types::Uuid, &uuid::Uuid>>, ColumnInsertValue<subscription_payments::columns::expired_at, diesel::expression::bound::Bound<diesel::sql_types::Timestamp, NaiveDateTime>>, ColumnInsertValue<subscription_payments::columns::subscription_plan_id, diesel::expression::bound::Bound<Integer, &i32>>, ColumnInsertValue<subscription_payments::columns::period, diesel::expression::bound::Bound<schema::sql_types::SubscriptionPeriod, &subscription_period::SubscriptionPeriod>>, ColumnInsertValue<subscription_payments::columns::amount, diesel::expression::bound::Bound<diesel::sql_types::Numeric, &BigDecimal>>), subscription_payments::table>>: LoadQuery<'_, _, _>`

Schema.rs

pub mod sql_types {
    #[derive(diesel::query_builder::QueryId, Clone, diesel::sql_types::SqlType)]
    #[diesel(postgres_type(name = "payment_status"))]
    pub struct PaymentStatus;

    #[derive(diesel::query_builder::QueryId, Clone, diesel::sql_types::SqlType)]
    #[diesel(postgres_type(name = "subscription_period"))]
    pub struct SubscriptionPeriod;
}

diesel::table! {
    use diesel::sql_types::*;
    use super::sql_types::SubscriptionPeriod;
    use super::sql_types::PaymentStatus;

    subscription_payments (id) {
        id -> Int4,
        user_id -> Uuid,
        subscription_plan_id -> Int4,
        created_at -> Timestamp,
        updated_at -> Timestamp,
        expired_at -> Timestamp,
        amount -> Numeric,
        period -> SubscriptionPeriod,
        status -> PaymentStatus,
        doku_response -> Nullable<Jsonb>,
    }
}

Enum.rs that implements to sql and from sql

use diesel::{AsExpression, serialize::{self, IsNull, Output, ToSql}, deserialize::{self, FromSql, FromSqlRow}, pg::{Pg, PgValue}};
use serde::{Deserialize, Serialize};
use crate::schema::sql_types;
use std::io::Write;

#[derive(Deserialize, Serialize, Debug, AsExpression, FromSqlRow, PartialEq, Eq)]
#[diesel(sql_type = sql_types::SubscriptionPeriod)]
pub enum SubscriptionPeriod {
    OneYear,
    ThreeMonths,
    OneMonth,
}

impl ToSql<sql_types::SubscriptionPeriod, Pg> for SubscriptionPeriod {
    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
        match *self {
            SubscriptionPeriod::OneYear => out.write_all(b"one_year")?,
            SubscriptionPeriod::ThreeMonths => out.write_all(b"three_months")?,
            SubscriptionPeriod::OneMonth => out.write_all(b"one_month")?,
        }
        Ok(IsNull::No)
    }
}

impl FromSql<sql_types::SubscriptionPeriod, Pg> for SubscriptionPeriod {
    fn from_sql(bytes: PgValue) -> deserialize::Result<Self> {
        match bytes.as_bytes() {
            b"one_year" => Ok(SubscriptionPeriod::OneYear),
            b"three_months" => Ok(SubscriptionPeriod::ThreeMonths),
            b"one_month" => Ok(SubscriptionPeriod::OneMonth),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}

main.rs

#[derive(Queryable, Deserialize, Insertable)]
#[diesel(table_name = subscription_payments)]
pub(crate) struct CreatePaymentPayload {
    pub subscription_plan_id: i32,
    pub period: SubscriptionPeriod,
}


#[derive(Queryable, Serialize)]
pub(crate) struct SubscriptionPayment {
    id: i32,
    user_id: uuid::Uuid,
   subscription_plan_id: i32,
    created_at: NaiveDateTime,
    updated_at: NaiveDateTime,
    expired_at: NaiveDateTime,
    amount: BigDecimal,
    period: SubscriptionPeriod,
    status: PaymentStatus,
    doku_response: Option<serde_json::Value>
}

impl SubscriptionPayment {
   pub(crate) fn create_checkout(
       pool: &DbPool,
       user_id: &uuid::Uuid,
       expired_at: NaiveDateTime,
       plan: &CreatePaymentPayload,
       amount: &BigDecimal
   ) -> QueryResult<Self> {

       let conn = &mut pool.get().expect("Couldn't get db connection from pool");
      
       let insert_values = (
           subscription_payments::user_id.eq(user_id),
           subscription_payments::expired_at.eq(expired_at),
           subscription_payments::subscription_plan_id.eq(&plan.subscription_plan_id),
           subscription_payments::period.eq(&plan.period),
           subscription_payments::amount.eq(amount),
       );
       
       diesel::insert_into(subscription_payments::table).values(insert_values).get_result(conn)
   }
}

It specifically error when using get_result function:

 diesel::insert_into(subscription_payments::table).values(insert_values).get_result(conn)

Is there something missing or I should implement the Queryable trait following this disucsssion: #3601 ??