#[derive(PgEnum, Debug, PartialEq)]
#[DieselType = "Foo_status"]
#[warn(non_camel_case_types)]
pub enum FooStatus {
    Active,
    Inactive,
}

table! {
    use diesel::sql_types::{Int4};
    use super::Foo_status;
    foo (foo_id) {
        foo_id -> Int4,
        status -> Foo_status,
    }
}

#[derive(Queryable)]
pub struct Foo {
    pub foo_id: i32,
    pub status: FooStatus,
}
    let results = foo
        .filter(status.eq(FooStatus::Active))
        .limit(5)
        .load::<Foo>(&connection)
        .expect("Error loading posts");

diesel::insert_into(db_schema::contacts::table).values(&contact).execute(&*db);

#[derive(Serialize, Deserialize, Identifiable, Queryable, Insertable, Clone, Debug)]
#[table_name = "contacts"]
pub struct Contact{
    pub id: Uuid,
    pub gender: Option<Gender>,
    pub given_name: Option<String>,
    pub family_name: Option<String>,
    pub company_name: Option<String>,
    pub title: Option<String>,
    pub phone_landline: Option<String>,
    pub phone_mobile: Option<String>,
    pub email: Option<String>,
    pub birthday: Option<NaiveDate>,
    pub address_id: Option<Uuid>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(PgEnum, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
pub enum Gender {
    Male,
    Female,
    Other,
}

#[derive(Serialize, Deserialize, Identifiable, Queryable, Insertable, Clone, Debug)]
#[table_name = "contacts"]
pub struct Contact{
    pub id: Uuid,
    pub gender: Option<Gender>,
    pub given_name: Option<String>,
    pub family_name: Option<String>,
    pub company_name: Option<String>,
    pub title: Option<String>,
    pub phone_landline: Option<String>,
    pub phone_mobile: Option<String>,
    pub email: Option<String>,
    pub birthday: Option<NaiveDate>,
    pub address_id: Option<Uuid>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

table! {
    use diesel::pg::types::sql_types::*;
    use diesel::sql_types::*;
    use db::types::GenderMapping;

    contacts (id) {
        id -> Uuid,
        gender -> Nullable<GenderMapping>,
        given_name -> Nullable<Text>,
        family_name -> Nullable<Text>,
        company_name -> Nullable<Text>,
        title -> Nullable<Text>,
        phone_landline -> Nullable<Text>,
        phone_mobile -> Nullable<Text>,
        email -> Nullable<Text>,
        birthday -> Nullable<Date>,
        address_id -> Nullable<Uuid>,
        created_at -> Timestamptz,
        updated_at -> Timestamptz,
    }
}

table! {
    use diesel::sql_types::*;
    use crate::db::enums::episode::*;

    /// Representation of the `heroes` table.
    ///
    /// (Automatically generated by Diesel.)
    heroes (id) {
        /// The `id` column of the `heroes` table.
        ///
        /// Its SQL type is `Int4`.
        ///
        /// (Automatically generated by Diesel.)
        id -> Int4,
        /// The `name` column of the `heroes` table.
        ///
        /// Its SQL type is `Varchar`.
        ///
        /// (Automatically generated by Diesel.)
        name -> Varchar,
        /// The `appears_in` column of the `heroes` table.
        ///
        /// Its SQL type is `Array<EpisodeMapping>`.
        ///
        /// (Automatically generated by Diesel.)
        appears_in -> Array<EpisodeMapping>,
        /// The `home_planet` column of the `heroes` table.
        ///
        /// Its SQL type is `Varchar`.
        ///
        /// (Automatically generated by Diesel.)
        home_planet -> Varchar,
    }
}

error[E0412]: cannot find type `EpisodeMapping` in this scope
   --> src/db/schema.rs:335:29
    |
335 |         appears_in -> Array<EpisodeMapping>,
    |                             ^^^^^^^^^^^^^^ not found in this scope
    |
    = note: possible candidate is found in another module, you can import it into scope:
            crate::db::enums::episode::db_enum_impl_Episode::EpisodeMapping

error: aborting due to previous error

#[derive(Debug, PartialEq, DbEnum, Clone, GraphQLEnum)]
#[PgType = "episode_enum"]
pub enum Episode {
    NewHope,
    Empire,
    Jedi,
}

#[derive(Debug, diesel_derive_enum::DbEnum, diesel::SqlType)]
pub enum A {}

impl<DB: Backend> ToSql<AMapping, DB> for A {
    fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> serialize::Result {
        match *self {}
        Ok(IsNull::No) // <- that one is unreachable
    }
}

#[derive(Debug, PartialEq, DbEnum)]
pub enum Flow {
    CreditOnly,
    DebitOnly,
    DebitCredit
}

    sistemas_de_equipamento.inner_join(avaria)
        .filter(AvariaId.eq(avaria_id))
        .first(&*conn)

#[derive(Serialize, Queryable, Deserialize)]
pub struct AvariaJson {
    pub id: i32,
    pub tag: String,
    pub descricao: String,
    pub flag: f64,
    pub taxa: f64,
    pub valor: f64,
    pub id_sistema: Option<i32>
}

#[derive(Serialize, Queryable, Deserialize)]
pub struct SistemaJson {
    pub id: i32,
    pub codigo_sistema: String,
    pub fxml: String,
    pub grupo: TipoGrupo,
    pub nome: String
}

#[derive(DbEnum, Serialize, Deserialize)]
#[derive(Debug)]
pub enum TipoGrupo {
    PROPULSAO, AUXILIAR, ELETRICA
}

PgTypeMetadata { oid: 0, array_oid: 0 }

 impl HasSqlType<#diesel_mapping> for Pg { 
     fn metadata(lookup: &Self::MetadataLookup) -> Self::TypeMetadata { 
         Self::TypeMetadata { oid: 0, array_oid: 0 }
     } 
 } 

use diesel_derive_enum::DbEnum;

#[derive(Debug, Clone, PartialEq, Eq, DbEnum)]
#[DbValueStyle = "PascalCase"]
#[PgType = "TransactionStatus"]
#[DieselType = "TransactionStatusMapping"]
pub enum TransactionStatus {
    Sucess,
    Failure,
}

pub mod transaction_status {
  use diesel_derive_enum::DbEnum;
  #[DbValueStyle = "PascalCase"]
  #[PgType = "TransactionStatus"]
  #[DieselType = "TransactionStatusMapping"]
  pub enum TransactionStatus {
      Sucess,
      Failure,
  }
  #[automatically_derived]
  impl ::core::fmt::Debug for TransactionStatus {
      fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
          match self {
              TransactionStatus::Sucess => {
                  ::core::fmt::Formatter::write_str(f, "Sucess")
              }
              TransactionStatus::Failure => {
                  ::core::fmt::Formatter::write_str(f, "Failure")
              }
          }
      }
  }
  #[automatically_derived]
  impl ::core::clone::Clone for TransactionStatus {
      #[inline]
      fn clone(&self) -> TransactionStatus {
          match self {
              TransactionStatus::Sucess => TransactionStatus::Sucess,
              TransactionStatus::Failure => TransactionStatus::Failure,
          }
      }
  }
  impl ::core::marker::StructuralPartialEq for TransactionStatus {}
  #[automatically_derived]
  impl ::core::cmp::PartialEq for TransactionStatus {
      #[inline]
      fn eq(&self, other: &TransactionStatus) -> bool {
          let __self_tag = ::core::intrinsics::discriminant_value(self);
          let __arg1_tag = ::core::intrinsics::discriminant_value(other);
          __self_tag == __arg1_tag
      }
  }
  impl ::core::marker::StructuralEq for TransactionStatus {}
  #[automatically_derived]
  impl ::core::cmp::Eq for TransactionStatus {
      #[inline]
      #[doc(hidden)]
      #[no_coverage]
      fn assert_receiver_is_total_eq(&self) -> () {}
  }
  pub use self::db_enum_impl_TransactionStatus::TransactionStatusMapping;
  #[allow(non_snake_case)]
  mod db_enum_impl_TransactionStatus {
      use super::*;
      use diesel::Queryable;
      use diesel::backend::Backend;
      use diesel::expression::AsExpression;
      use diesel::expression::bound::Bound;
      use diesel::row::Row;
      use diesel::sql_types::*;
      use diesel::serialize::{self, ToSql, IsNull, Output};
      use diesel::deserialize::{self, FromSql, FromSqlRow};
      use diesel::query_builder::QueryId;
      use std::io::Write;
      pub struct TransactionStatusMapping;
      #[automatically_derived]
      impl ::core::clone::Clone for TransactionStatusMapping {
          #[inline]
          fn clone(&self) -> TransactionStatusMapping {
              TransactionStatusMapping
          }
      }
      impl QueryId for TransactionStatusMapping {
          type QueryId = TransactionStatusMapping;
          const HAS_STATIC_QUERY_ID: bool = true;
      }
      impl NotNull for TransactionStatusMapping {}
      impl SingleValue for TransactionStatusMapping {}
      impl AsExpression<TransactionStatusMapping> for TransactionStatus {
          type Expression = Bound<TransactionStatusMapping, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl AsExpression<Nullable<TransactionStatusMapping>> for TransactionStatus {
          type Expression = Bound<Nullable<TransactionStatusMapping>, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl<'a> AsExpression<TransactionStatusMapping> for &'a TransactionStatus {
          type Expression = Bound<TransactionStatusMapping, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl<'a> AsExpression<Nullable<TransactionStatusMapping>>
      for &'a TransactionStatus {
          type Expression = Bound<Nullable<TransactionStatusMapping>, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl<'a, 'b> AsExpression<TransactionStatusMapping>
      for &'a &'b TransactionStatus {
          type Expression = Bound<TransactionStatusMapping, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl<'a, 'b> AsExpression<Nullable<TransactionStatusMapping>>
      for &'a &'b TransactionStatus {
          type Expression = Bound<Nullable<TransactionStatusMapping>, Self>;
          fn as_expression(self) -> Self::Expression {
              Bound::new(self)
          }
      }
      impl<DB: Backend> ToSql<TransactionStatusMapping, DB> for TransactionStatus {
          fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> serialize::Result {
              match *self {
                  TransactionStatus::Sucess => out.write_all(b"Sucess")?,
                  TransactionStatus::Failure => out.write_all(b"Failure")?,
              }
              Ok(IsNull::No)
          }
      }
      impl<DB> ToSql<Nullable<TransactionStatusMapping>, DB> for TransactionStatus
      where
          DB: Backend,
          Self: ToSql<TransactionStatusMapping, DB>,
      {
          fn to_sql<W: ::std::io::Write>(
              &self,
              out: &mut Output<W, DB>,
          ) -> serialize::Result {
              ToSql::<TransactionStatusMapping, DB>::to_sql(self, out)
          }
      }
  }
}

use crate::schema::liquidation_state_transitions;
use crate::schema::obligation_accounts;
use crate::schema::user_farm_accounts;
use crate::schema::user_farm_manager_accounts;
use diesel::prelude::*;
use diesel_derive_enum;

#[derive(Queryable, Clone)]
pub struct ObligationAccount {
    pub id: i32,
    pub pubkey: String,
    pub authority: String,
    pub liquidated: bool,
}
#[derive(Queryable, Clone)]
pub struct UserFarmAccount {
    pub id: i32,
    pub pubkey: String,
    pub authority: String,
    pub farm_manager: String,
    pub obligations: Vec<String>,
    pub obligation_indexes: Vec<i32>,
}

#[derive(Queryable, Clone)]
pub struct UserFarmManagerAccount {
    pub id: i32,
    pub pubkey: String,
    pub authority: String,
    pub farm_key: i32,
}

#[derive(Debug, PartialEq, Clone, diesel_derive_enum::DbEnum)]
#[PgType = "Liquidation_state_enum"]
#[DieselType = "Liquidation_state_enum"]
pub enum LiquidationStateEnum {
    Start,
    Pull,
    Repay,
    Remove,
    Liquidate,
    End,
}

#[derive(Queryable, PartialEq, Clone)]
pub struct LiquidationStateTransistion {
    pub id: i32,
    pub temp_liquidation_account: String,
    pub authority: String,
    pub user_farm: String,
    pub obligation: String,
    pub liquidation_state: LiquidationStateEnum,
}

#[derive(Insertable)]
#[table_name = "obligation_accounts"]
pub struct NewObligationAccount<'a> {
    pub pubkey: &'a str,
    pub authority: &'a str,
    pub liquidated: bool,
}

#[derive(Insertable)]
#[table_name = "user_farm_manager_accounts"]
pub struct NewUserFarmManagerAccount<'a> {
    pub pubkey: &'a str,
    pub authority: &'a str,
    pub farm_key: i32,
}

#[derive(Insertable)]
#[table_name = "user_farm_accounts"]
pub struct NewUserFarmAccount<'a> {
    pub pubkey: &'a str,
    pub authority: &'a str,
    pub farm_manager: &'a str,
    pub obligations: Option<Vec<String>>,
    pub obligation_indexes: Option<Vec<i32>>,
}

#[derive(Insertable)]
#[table_name = "liquidation_state_transitions"]
pub struct NewLiquidationStateTransition<'a> {
    pub temp_liquidation_account: &'a str,
    pub authority: &'a str,
    pub user_farm: &'a str,
    pub obligation: &'a str,
    pub liquidation_state: LiquidationStateEnum,
}

table! {
    use diesel::sql_types::*;
    use crate::models::Liquidation_state_enum;

    liquidation_state_transitions (id) {
        id -> Int4,
        temp_liquidation_account -> Varchar,
        authority -> Varchar,
        user_farm -> Varchar,
        obligation -> Varchar,
        liquidation_state -> Liquidation_state_enum,
    }
}

table! {
    use diesel::sql_types::*;
    use crate::models::Liquidation_state_enum;

    obligation_accounts (id) {
        id -> Int4,
        pubkey -> Varchar,
        authority -> Varchar,
        liquidated -> Bool,
    }
}

table! {
    use diesel::sql_types::*;
    use crate::models::Liquidation_state_enum;

    user_farm_accounts (id) {
        id -> Int4,
        pubkey -> Varchar,
        authority -> Varchar,
        farm_manager -> Varchar,
        obligations -> Array<Text>,
        obligation_indexes -> Array<Int4>,
    }
}

table! {
    use diesel::sql_types::*;
    use crate::models::Liquidation_state_enum;

    user_farm_manager_accounts (id) {
        id -> Int4,
        pubkey -> Varchar,
        authority -> Varchar,
        farm_key -> Int4,
    }
}

allow_tables_to_appear_in_same_query!(
    liquidation_state_transitions,
    obligation_accounts,
    user_farm_accounts,
    user_farm_manager_accounts,
);

    |
126 | #[derive(DbEnum, Serialize, Deserialize, Debug, PartialEq, Clone)]
    |          ^^^^^^ Use of undeclared type or module `TipoInterface`

use diesel::prelude::*;
use diesel_derive_enum::*;

#[derive(Debug, PartialEq, DbEnum)]
#[DieselType = "LanguageEnum"]
#[PgType = "language"]
pub enum Language {
    De,
    Fr,
    It,
    En,
}

#[derive(Insertable, Queryable, Identifiable, Debug, PartialEq)]
#[table_name = "evacuateobjects"]
pub struct EvacuateObjectDB {
    pub id: String,
    pub status: EvacuateObjectStatus,
}

#[derive(DbEnum, Debug, PartialEq, Clone)]
pub enum EvacuateObjectStatus {
    Unprocessed,
    Processing,
    Skipped,
    Failed,
    Retrying,
}

#[derive(Insertable, Queryable, Identifiable, Debug, PartialEq)]
#[table_name = "evacuateobjects"]
pub struct EvacuateObjectDB {
    pub id: String,
    pub status: EvacuateObjectStatus,
}

#[derive(DbEnum, Debug, PartialEq, Clone)]
pub enum SkippedReason {
    Retry,
    Persistent,
}
#[derive(DbEnum, Debug, PartialEq, Clone)]
pub enum EvacuateObjectStatus {
    Unprocessed,
    Processing,
    Skipped(SkippedReason),
    Failed,
    Retrying,
}

#[derive(DbEnum, Debug, PartialEq, Clone)]
pub enum ObjectStatus {
    Unprocessed,
    Processing,
    Skipped,
    Failed,
    Retrying,
}

#[derive(Insertable, Queryable, Identifiable, Debug, PartialEq)]
#[table_name = "evacuateobjects"]
pub struct Object {
    pub id: i32,
    pub status: ObjectStatus,
}

    conn.execute(
        r#"
        CREATE TABLE evacuateobjects(
            id SERIAL PRIMARY KEY,
            status TEXT CHECK(status IN ('Unprocessed', 'Processing', 'Skipped', 'Failed', 'Retrying')) NOT NULL
        );
    "#,
    ).unwrap();

table! {
    user (id) {
        id -> Uuid,
    }
}
table! {
    use diesel::sql_types::*;
    use super::Server_status;
    server (id) {
        id -> Uuid,
        user_id -> Uuid,
        status -> Server_status,
    }
}

joinable!(server -> user (user_id));
allow_tables_to_appear_in_same_query!(user, server);

#[derive(DbEnum, Clone)]
#[DieselType = "Server_status"]
enum ServerStatus { Stopped, Starting, Running, Stopping, Stopped }

#[derive(Queryable)]
#[table_name = "user"]
struct User {
    id: Uuid,
}

#[derive(Queryable, Associations)]
#[belongs_to(User)]
#[table_name = "server"]
struct Server {
    id: Uuid,
    user_id: Uuid,
    status: ServerStatus,
}

let user_and_server = user
    .find(Uuid::new_v4())
    .left_join(
        server
            .on(server::dsl::user_id.eq(user::dsl::id.nullable())
                .and(server::dsl::status.eq(ServerStatus::Running))
        )
    )
    .first::<(User, Option<Server>)>(&conn)?;

impl Clone for Server_status {
    fn clone(&self) -> Self { Self }
}

#[derive(Debug, PartialEq, DbEnum, Clone, Serialize, Deserialize)]
#[PgType = "permission"]
#[DieselType = "Permission"]
pub enum PermissionEnum {
    #[serde(rename = "admin")]
    #[db_rename = "mod"] // with or without both fails
    Admin,
}

#[derive(Queryable, Serialize, Identifiable)]
#[table_name = "user"]
pub struct User {
    pub id: Uuid,
    pub permissions: Vec<PermissionEnum>,
}

dsl::user
    .find(user_id)
    .get_result::<R>(&conn)