/// A marker trait for SQL types
///
/// # Deriving
///
/// This trait is automatically implemented by [`#[derive(SqlType)]`](derive@SqlType)
/// which sets `IsNull` to [`is_nullable::NotNull`]
///
pub trait SqlType: 'static {
    /// Is this type nullable?
    ///
    /// This type should always be one of the structs in the ['is_nullable`]
    /// module. See the documentation of those structs for more details.
    ///
    /// ['is_nullable`]: is_nullable
    type IsNull: OneIsNullable<is_nullable::IsNullable> + OneIsNullable<is_nullable::NotNull>;
}

/// The integer SQL type.
///
/// ### [`ToSql`](crate::serialize::ToSql) impls
///
/// - [`i32`][i32]
///
/// ### [`FromSql`](crate::deserialize::FromSql) impls
///
/// - [`i32`][i32]
///
/// [i32]: https://doc.rust-lang.org/nightly/std/primitive.i32.html
#[derive(Debug, Clone, Copy, Default, QueryId, SqlType)] // 实现 SqlType
#[diesel(postgres_type(oid = 23, array_oid = 1007))] // 各种 DB Backend 实现的字段类型
#[diesel(sqlite_type(name = "Integer"))]
#[diesel(mysql_type(name = "Long"))]
pub struct Integer;

pub type Int4 = Integer;

// CREATE TABLE posts (
//   id INTEGER AUTO_INCREMENT PRIMARY KEY,
//   title VARCHAR(255) NOT NULL,
//   body TEXT NOT NULL,
//   published BOOLEAN NOT NULL DEFAULT FALSE
// );

// diecel 自动生成的 src/schema.rs 文件
diesel::table! {
    posts (id) {
    id -> Integer,
    title -> Varchar, // SQL VARCHAR(N) 类型对应 diesel 的 Varchar 类型
    body -> Text,     // SQL TEXT 类型对应 diesel 的 Text 类型
    published -> Bool,
    }
}

// Struct diesel::sql_types::Integer
pub struct Integer;

// 每种 DB Backend 都定义了自己的 ToSql 和 FromSql 实现，用于 sql_type 和 Rust 类型类型的转换
impl ToSql<Integer, Mysql> for i32
impl ToSql<Integer, Pg> for i32
impl ToSql<Integer, Sqlite> for i32

impl FromSql<Integer, Mysql> for i32
impl FromSql<Integer, Pg> for i32
impl FromSql<Integer, Sqlite> for i32

// https://github.com/diesel-rs/diesel/tree/2.2.x/examples/postgres/custom_types
// https://github.com/marvin-hansen/bazel-diesel-postgres?tab=readme-ov-file

// up.sql
// CREATE TYPE Language AS ENUM (
//     'en', 'ru', 'de'
// );

// CREATE TABLE translations (
//     word_id INTEGER NOT NULL,
//     translation_id INTEGER NOT NULL,
//     language Language NOT NULL,

//     PRIMARY KEY (word_id, translation_id)
// )


// @generated automatically by Diesel CLI.

// 自动在项目的 schema.rs 的 sql_types module 中自动生成一个名为 Language 的自定义 diesel SqlType 类型
// 1. 使用 #[derive(diesel::sql_types::SqlType)] 来为 Language 实现 SqlType trait;
pub mod sql_types {
    #[derive(diesel::sql_types::SqlType)] // 使用 derive macro 实现 SqlType
    #[diesel(postgres_type(name = "language"))] // 关联的 PG 字段类型名称
    pub struct Language;
}
// 自动生成的 schema.rs 中 table!() 中使用该类型
diesel::table! {
    use diesel::sql_types::*;
    use super::sql_types::Language; // 导入自定义 diesel SqlType 类型

    translations (word_id, translation_id) {
        word_id -> Int4,
        translation_id -> Int4,
        language -> Language, // 使用该类型
    }
}


use diesel::deserialize::{self, FromSql, FromSqlRow};
use diesel::expression::AsExpression;
use diesel::pg::{Pg, PgValue};
use diesel::serialize::{self, IsNull, Output, ToSql};
use std::io::Write;

// 再为 sql_types 类型绑定一个 Rust 类型，它需要实现 AsExpression、FromSqlRow、ToSql 和 FromSql
// 1. 实现 ToSql 的同时需要实现 AsExpression
// 2. 实现 FromSql 的同时需要实现 FromSqlRow
#[derive(Debug, AsExpression, FromSqlRow)]
#[diesel(sql_type = crate::schema::sql_types::Language)] // 关联 diesel SqlType 类型
pub enum Language {
    En,
    Ru,
    De,
}

impl ToSql<crate::schema::sql_types::Language, Pg> for Language {
    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
        match *self {
            Language::En => out.write_all(b"en")?,
            Language::Ru => out.write_all(b"ru")?,
            Language::De => out.write_all(b"de")?,
        }
        Ok(IsNull::No)
    }
}

impl FromSql<crate::schema::sql_types::Language, Pg> for Language {
    fn from_sql(bytes: PgValue) -> deserialize::Result<Self> {
        match bytes.as_bytes() {
            b"en" => Ok(Language::En),
            b"ru" => Ok(Language::Ru),
            b"de" => Ok(Language::De),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}

// main.rs
use self::schema::translations;
use diesel::prelude::*;

mod model;
mod schema;

#[derive(Debug, Queryable, Insertable)]
#[diesel(table_name = translations)]
pub struct Translation {
    word_id: i32,
    translation_id: i32,
    language: model::Language, // 使用自定义类型
}

fn main() {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let conn = &mut PgConnection::establish(&database_url)
        .unwrap_or_else(|e| panic!("Error connecting to {}: {}", database_url, e));

    let _ = diesel::insert_into(translations::table)
        .values(&Translation {
            word_id: 1,
            translation_id: 1,
            language: model::Language::En,
        })
        .execute(conn);

    let t = translations::table
        .select((
            translations::word_id,
            translations::translation_id,
            translations::language,
        ))
        .get_results::<Translation>(conn)
        .expect("select");
    println!("{t:?}");
}

use diesel::deserialize::{self, FromSql};
use diesel::pg::Pg;

#[derive(FromSqlRow, AsExpression)]
#[diesel(sql_type = diesel::sql_types::Text)] // 已有的 SqlType 类型，自动实现了 ToSql trait
struct Email(String);

// 但还是需要实现 FromSql trait
impl FromSql<diesel::sql_types::Text, Pg> for Email {
    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
        let s = <String as FromSql<diesel::sql_types::Text, Pg>>::from_sql(bytes)?;
        if is_valid_email(&s) {
            Ok(Email(s))
        } else {
            Err("Invalid email format".into())
        }
    }
}

pub trait Expression {
    /// The type that this expression represents in SQL
    type SqlType: TypedExpressionType; // 实际约束为实现 SqlType trait 的任意类型
}

// TypedExpressionType 是一个标记 trait
pub trait TypedExpressionType {}
// ST 最终需要实现 diesel::sql_types::SqlType
impl<ST> TypedExpressionType for ST where ST: SingleValue {}
// SingleValue 也是一个标记 trait
pub trait SingleValue: SqlType {}

diesel::table! {
    posts (id) {
        id -> Int4,
        title -> Varchar,
        body -> Text,
        published -> Bool,
    }
}
// 以 id 字段为例，展开 table!() 宏后，diesel 为 id 实现了 Expression
impl diesel::expression::Expression for id {
    type SqlType = Int4;
}

pub trait AsExpression<T> where T: SqlType + TypedExpressionType,
{
    /// The expression being returned
    type Expression: Expression<SqlType = T>;

    /// Perform the conversion
    #[allow(clippy::wrong_self_convention)]
    // That's public API we cannot change it to appease clippy
    fn as_expression(self) -> Self::Expression; // 消耗 self
}

use crate::sql_types::{
    self, BigInt, Binary, Bool, Double, Float, Integer, SingleValue, SmallInt, Text,
};

#[allow(dead_code)]
mod foreign_impls {
    use super::*;
    use crate::deserialize::FromSqlRow;

    #[derive(AsExpression, FromSqlRow)] // 自动实现 AsExpression, FromSqlRow
    #[diesel(foreign_derive)]
    #[diesel(sql_type = Bool)] // 对应 SqlType 类型是 Bool
    struct BoolProxy(bool);

    #[derive(FromSqlRow)]
    #[cfg_attr(feature = "mysql_backend", derive(AsExpression))]
    #[diesel(foreign_derive)]
    #[cfg_attr(feature = "mysql_backend", diesel(sql_type = crate::sql_types::TinyInt))]
    struct I8Proxy(i8);

    //...
    
    #[derive(AsExpression)]
    #[diesel(foreign_derive, not_sized)]
    #[diesel(sql_type = Text)]
    #[cfg_attr(feature = "sqlite", diesel(sql_type = crate::sql_types::Date))]
    #[cfg_attr(feature = "sqlite", diesel(sql_type = crate::sql_types::Time))]
    #[cfg_attr(feature = "sqlite", diesel(sql_type = crate::sql_types::Timestamp))]
    #[cfg_attr(feature = "postgres_backend", diesel(sql_type = crate::sql_types::Citext))]
    struct StrProxy(str);

    #[derive(FromSqlRow)]
    #[diesel(foreign_derive)]
    struct VecProxy<T>(Vec<T>);
    
    //...
}

#[derive(Debug, AsExpression)]
#[diesel(sql_type = crate::schema::sql_types::Language)] // 关联 diesel SqlType 类型
pub enum Language {
  En,
  Ru,
  De,
}

// Trait diesel::expression_methods::ExpressionMethods
pub trait ExpressionMethods: Expression + Sized {
    fn eq<T>(self, other: T) -> Eq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn ne<T>(self, other: T) -> NotEq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn eq_any<T>(self, values: T) -> EqAny<Self, T> where Self::SqlType: SqlType, T: AsInExpression<Self::SqlType>
    fn ne_all<T>(self, values: T) -> NeAny<Self, T> where Self::SqlType: SqlType, T: AsInExpression<Self::SqlType>
   //...
}

// 示例： eq() 方法使用实现 AsExpression 的 Rust 基本类型 &str
users.filter(name.eq("Sean")).filter(hair_color.eq("black"))

impl<T, ST> AsExpression<ST> for T
where
    T: Expression<SqlType = ST>,
    ST: SqlType + TypedExpressionType,
    
// 示例：    
let names = users::table.select("The Amazing ".as_expression::<Text>().concat(users::name)).load(conn);

/// Converts a type to its representation for use in Diesel's query builder.
///
/// This trait only exists to make usage of `AsExpression` more ergonomic when
/// the `SqlType` cannot be inferred. It is generally used when you need to use
/// a Rust value as the left hand side of an expression, or when you want to
/// select a constant value.
///
/// # Example
///
/// # include!("../doctest_setup.rs");
/// # use schema::users;
/// #
/// # fn main() {
/// use diesel::sql_types::Text;
/// #   let conn = &mut establish_connection();
/// let names = users::table
///     .select("The Amazing ".into_sql::<Text>().concat(users::name))
///     .load(conn);
/// let expected_names = vec![
///     "The Amazing Sean".to_string(),
///     "The Amazing Tess".to_string(),
/// ];
/// assert_eq!(Ok(expected_names), names);
/// # }
/// 
pub trait IntoSql {
    /// Convert `self` to an expression for Diesel's query builder.
    ///
    /// There is no difference in behavior between `x.into_sql::<Y>()` and
    /// `AsExpression::<Y>::as_expression(x)`.
    fn into_sql<T>(self) -> AsExprOf<Self, T> where Self: AsExpression<T> + Sized, T: SqlType + TypedExpressionType,
    {
        self.as_expression()
    }

    /// Convert `&self` to an expression for Diesel's query builder.
    ///
    /// There is no difference in behavior between `x.as_sql::<Y>()` and
    /// `AsExpression::<Y>::as_expression(&x)`.
    fn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T> where &'a Self: AsExpression<T>, T: SqlType + TypedExpressionType,
    {
        <&'a Self as AsExpression<T>>::as_expression(self)
    }
}

// 为任意类型 T 实现 IntoSql
impl<T> IntoSql for T {}

let names = users::table.select("The Amazing ".as_expression::<Text>().concat(users::name)).load(conn);
let names = users::table.select("The Amazing ".into_sql::<Text>().concat(users::name)).load(conn);

// diesel 为 Expression 实现了 ExpressionMethods
impl<T> ExpressionMethods for T where T: Expression, T::SqlType: SingleValue

// table!() 为表字段 name 实现了 Expression，而 eq() 是应用于 Expression 的方法
let seans_id = users.filter(name.eq("Sean")).select(id).first(connection);

// Trait diesel::expression_methods::ExpressionMethods
pub trait ExpressionMethods: Expression + Sized {
    // 指定的值， T 需要实现 AsExpression，diesel 为 Rust 基本类型实现了改 trait，故可以传入对应的字面量
    fn eq<T>(self, other: T) -> Eq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn ne<T>(self, other: T) -> NotEq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn eq_any<T>(self, values: T) -> EqAny<Self, T> where Self::SqlType: SqlType, T: AsInExpression<Self::SqlType>
    fn ne_all<T>(self, values: T) -> NeAny<Self, T> where Self::SqlType: SqlType, T: AsInExpression<Self::SqlType>

    // 是否为 null
    fn is_null(self) -> IsNull<Self>
    fn is_not_null(self) -> IsNotNull<Self>

    // 大小
    fn gt<T>(self, other: T) -> Gt<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn ge<T>(self, other: T) -> GtEq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn lt<T>(self, other: T) -> Lt<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    fn le<T>(self, other: T) -> LtEq<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>

    // 范围
    fn between<T, U>(self, lower: T, upper: U) -> Between<Self, T, U> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>, U: AsExpression<Self::SqlType>
    fn not_between<T, U>(self, lower: T, upper: U) -> NotBetween<Self, T, U> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>, U: AsExpression<Self::SqlType>

    // 排序
    fn desc(self) -> Desc<Self>
    fn asc(self) -> Asc<Self>
}

// Trait diesel::expression_methods::TextExpressionMethods
pub trait TextExpressionMethods: Expression + Sized {
    // Provided methods
    fn concat<T>(self, other: T) -> Concat<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
        
    // This method is case insensitive for SQLite and MySQL. On PostgreSQL, LIKE is case
    // sensitive. You may use ilike() for case insensitive comparison on PostgreSQL.
    fn like<T>(self, other: T) -> Like<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
    
    fn not_like<T>(self, other: T) -> NotLike<Self, T> where Self::SqlType: SqlType, T: AsExpression<Self::SqlType>
}

// Trait diesel::expression_methods::BoolExpressionMethods
pub trait BoolExpressionMethods: Expression + Sized {
    // Provided methods
    fn and<T, ST>(self, other: T) -> And<Self, T, ST> where Self::SqlType: SqlType, ST: SqlType + TypedExpressionType, T: AsExpression<ST>, And<Self, T::Expression>: Expression 

    fn or<T, ST>(self, other: T) -> Or<Self, T, ST> where Self::SqlType: SqlType, ST: SqlType + TypedExpressionType, T: AsExpression<ST>, Or<Self, T::Expression>: Expression
}
impl<T> BoolExpressionMethods for T where T: Expression, T::SqlType: BoolOrNullableBool,
impl BoolOrNullableBool for Bool
impl BoolOrNullableBool for Nullable<Bool>

// text 字段实现了 TextExpressionMethods，故可以使用 concat() 方法
let names = users::table.select( "The Amazing ".into_sql::<Text>().concat(users::name)).load(conn);

// species.eq("ferret") 返回的 Eq 类型实现了 BoolExpressionMethods，故可以使用 and() 方法
let data = animals.select((species, name))
.filter(species.eq("ferret").and(name.eq("Jack")))
.load(connection)?;

impl diesel::expression::Expression for published {
    type SqlType = Bool;
}

// 这些类型都是两个参数来调用 infix_operator!() 宏，所以它们都实现了 BoolExpressionMethods
// /Users/alizj/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/diesel-2.3.3/src/expression/operators.rs
infix_operator!(Eq, " = ");
infix_operator!(And, " AND ");
infix_operator!(Or, " OR ");
infix_operator!(Escape, " ESCAPE ");
infix_operator!(Eq, " = ");
infix_operator!(Gt, " > ");
infix_operator!(GtEq, " >= ");
infix_operator!(Lt, " < ");
infix_operator!(LtEq, " <= ");
infix_operator!(NotEq, " != ");
infix_operator!(NotLike, " NOT LIKE ");
infix_operator!(Between, " BETWEEN ");
infix_operator!(NotBetween, " NOT BETWEEN ");

// /Users/alizj/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/diesel-2.3.3/src/expression/operators.rs
#[macro_export]
macro_rules! infix_operator {
    ($name:ident, $operator:expr) => {
        $crate::infix_operator!($name, $operator, $crate::sql_types::Bool);
    };

    // infix_operator!(Eq, " = "); 只有两个参数，所以匹配该 branch，第三个参数默认为  Bool
    ($name:ident, $operator:expr, backend: $backend:ty) => {
        $crate::infix_operator!($name, $operator, $crate::sql_types::Bool, backend: $backend);
    };

    ($name:ident, $operator:expr, $($return_ty:tt)::*) => {
        $crate::__diesel_infix_operator!(
            name = $name,
            operator = $operator,
            return_ty = NullableBasedOnArgs ($($return_ty)::*),
            backend_ty_params = (DB,),
            backend_ty = DB,
        );
    };

    // 再次匹配该 branch
    ($name:ident, $operator:expr, $($return_ty:tt)::*, backend: $backend:ty) => {
        $crate::__diesel_infix_operator!(
            name = $name,
            operator = $operator,
            return_ty = NullableBasedOnArgs ($($return_ty)::*),
            backend_ty_params = (),
            backend_ty = $backend,
        );
    };

}

// 而 __diesel_infix_operator! 最终会调用 __diesel_operator_body!() 宏，而该宏为 Eq 实现了 Expression，而且 SqlType 为 Bool，
// 所以，最终 Eq 也实现了 BoolExpressionMethods
// /Users/alizj/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/diesel-2.3.3/src/expression/operators.rs
macro_rules! __diesel_operator_body { 
    impl<$($ty_param,)+ $($expression_ty_params,)*> $crate::expression::Expression for $name<$($ty_param,)+> where
        $($expression_bounds)*
    {
        type SqlType = $($return_ty)*;
    }
}

// 以 eq() 返回的 Eq 为例, 它是 Grouped 类型别名, 而 Grouped 实现了 Expression trait
pub type Eq<Lhs, Rhs> = Grouped<Eq<Lhs, AsExpr<Rhs, Lhs>>>;

// https://docs.diesel.rs/2.2.x/src/diesel/expression/grouped.rs.html
#[derive(Debug, Copy, Clone, QueryId, Default, DieselNumericOps, ValidGrouping)]
pub struct Grouped<T>(pub T);

// Grouped 也实现了 Expression
impl<T: Expression> Expression for Grouped<T> {
    type SqlType = T::SqlType;
}

// 示例：
// name 是 Expression，实现了 ExpressionMethods，它的 eq() 方法参数是 AsExpression，所以可以传入 Rust 基本类型。
// eq() 返回值类型 Eq 也是 Expression, 所以可以作为 filter() 的参数。
let seans_id = users.filter(name.eq("Sean")).select(id).first(connection);

// species.eq("ferret") 的结果 Eq 实现了 Expression、BoolExpressionMethods，故可以调用 .and()/or() 方法，结果还是 Expression, 所以可以作为 filter() 的参数。
let data = animals.select((species, name))
    .filter(species.eq("ferret").and(name.eq("Jack")))
    .load(connection)?;
let expected = vec![ (String::from("ferret"), Some(String::from("Jack"))), ];
assert_eq!(expected, data);

// 导入 table!() 宏使用的 SqlType
use diesel::sql_types::*;

diesel::table! {
    posts (id) { // id 为默认 PK
        id -> Int4,
        title -> Varchar, // 字段默认是 NOT NULL
        body -> Text,
        published -> Bool,
    }
}

diesel::table! {
    users {
        id -> Integer,
        name -> VarChar,
        favorite_color -> Nullable<VarChar>, // 使用 Nullable 来设置可以为 NULL 的字段，对应的 struct model 是 Option<T> 类型
    }
}

diesel::table! {
    users (non_standard_primary_key) { // 如果 PK 不是默认的字段 id，则需要手动指定
        non_standard_primary_key -> Integer,
        name -> VarChar,
        favorite_color -> Nullable<VarChar>,
        last_used_at -> Nullable<Timestamp>,   // 可以使用 Json、Jsonb、Timestamp、UUID 等类型
        crate_scopes -> Nullable<Array<Text>>, // 可以是数组 Array 类型，对应 struct model 是 Option<Vec<T>> 类型
    }
    
    followings (user_id, post_id) { // 手动指定组合 PK
        user_id -> Integer,
        post_id -> Integer,
        favorited -> Bool,  
    }    
}

// 手动为自动生成的 table 添加注释（注意是 cargo doc 注释类型，后续会保留）
diesel::table! {
    /// The table containing all blog posts
    posts {
        /// The post's unique id
        id -> Integer,
        /// The post's title
        title -> Text,
        /// This column is named `mytype` but references the table `type` column.
        #[sql_name = "type"] // table 中字段名为 type，避免 Rust 关键字冲突
        mytype -> Text,        
    }
}

#[allow(unused_imports,dead_code,unreachable_pub)]
pub mod posts {
    pub use self::columns:: * ; // 导出各 field 字段对应的类型,如 id, title, body 等

    // 后续一般被外部代码 use posts::dsl::* 导入使用的表字段和表类型
    pub mod dsl {
        pub use super::columns::id;
        pub use super::columns::title;
        pub use super::columns::body;
        pub use super::columns::published;
        pub use super::table as posts; // table 别名为 posts
    }

    pub const all_columns:(id,title,body,published,) = (id,title,body,published,);

    // 固定类型 table
    pub struct table;
    impl table {
        pub fn star(&self) -> star {
            star // star 是在后续 self::columns 中定义的 pub struct star;
        }
    }

    // all_columns 对应的字段类型
    pub type SqlType = (Int4,Varchar,Text,Bool,);

    pub type BoxedQuery<'a,DB,ST = SqlType>

    // 为 table 实现各种 trait
    impl diesel::QuerySource for table
    impl <DB>diesel::query_builder::QueryFragment<DB>for table
    impl diesel::query_builder::AsQuery for table
    impl diesel::Table for table
    impl diesel::associations::HasTable for table
    impl diesel::query_builder::IntoUpdateTarget for table
    impl diesel::query_source::AppearsInFromClause<table>for table
    impl <T>diesel::insertable::Insertable<T>for table

    #[doc = r" Contains all of the columns of this table"]
    pub mod columns {
        use super::table;

        // start 用于 users.* 查询
        pub struct star;
        // star 实现了各种 trait
        impl <__GB>diesel::expression::ValidGrouping<__GB> for star
        impl diesel::Expression for star {
        impl <DB:diesel::backend::Backend>diesel::query_builder::QueryFragment<DB> for star
        impl diesel::SelectableExpression<table> for star
        impl diesel::AppearsOnTable<table> for star

        // 每一个 struct 成员对对应一个类型
        
        // 这里以 id 为例：
        #[allow(non_camel_case_types,dead_code)]
        #[derive(Debug,Clone,Copy,diesel::query_builder::QueryId,Default)]
        pub struct id;

        // 每个成员类型都实现了 Expression, 在 select 中使用.
        impl diesel::expression::Expression for id {
            type SqlType = Int4; // 决定了 ExpressionMethods 可以使用的方法
        }
        impl <DB>diesel::query_builder::QueryFragment<DB>for id
        impl diesel::SelectableExpression<super::table>for id

        // delete/update 等的 filter() 等使用
        impl <QS>diesel::AppearsOnTable<QS>for id

        impl <Left,Right>diesel::SelectableExpression<diesel::internal::table_macro::Join<Left,Right,diesel::internal::table_macro::LeftOuter> , >for id

        impl diesel::query_source::Column for id

        // 根据 id 的类型, 自动为它实现了各种 trait
        // 如为 int 类型实现了 EqAll 和 std::ops::*，为 text 类型实现 TextExpressionMethods（提供了 like、not_like 等方法）
        impl <T>diesel::EqAll<T>for id
        impl <Rhs> ::std::ops::Add<Rhs>for id
        impl <Rhs> ::std::ops::Sub<Rhs>for id
        impl <Rhs> ::std::ops::Div<Rhs>for id
        impl <Rhs> ::std::ops::Mul<Rhs>for id
}        

// 不建议:
users::table.filter(users::name.eq("Sean")).filter(users::hair_color.eq("black"))
// 建议: 
users.filter(name.eq("Sean")).filter(hair_color.eq("black"))

fn main() {
    use self::schema::posts::dsl::posts; // 建议：导入 posts table
    // ...
    let post = posts
        .find(post_id)
        .select(Post::as_select())
        .first(connection)
        .optional(); // This allows for returning an Option<Post>, otherwise it will throw an error
    // ...
}

// 如果要使用 star, 则可以调用 users 的 star() 方法。

use diesel::prelude::*;

#[derive(Queryable, Selectable)]
// table_name 是 Selectable 所需要的，默认为 struct 全小写名称加 s。
// check_for_backend 用于编译时静态检查，即检查 struct 成员类型和数据库表定义是否完全一致。
#[diesel(table_name = crate::schema::posts)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct Post {
    pub id: i32, // 默认表的 PK 是 id 字段。
    pub title: String,
    pub body: String,
    pub published: bool,
}

// 用于 diesel::insert_into(table).values() 的参数，需要实现 Insertable，
// 如果使用 &str, 则需要为 struct 指定 lifetime
#[derive(Insertable)]
#[diesel(table_name = posts)]
pub struct NewPost<'a> {
    pub title: &'a str,
    pub body: &'a str,
}

let new_post = NewPost { title, body };
diesel::insert_into(posts::table)
    .values(&new_post)
    .returning(Post::as_returning()) // Selectable 可以作为 returning() 的参数
    .get_result(conn)
    .expect("Error saving new post");

let post = posts
    .find(post_id)
    .select(Post::as_select()) // Selectable 也可以作为 select() 的参数
    .first(connection)
    .optional(); // This allows for returning an Option<Post>, otherwise it will throw an error

// 对于有缺省值的列，对应的数据库 schema 定义类似于 `NOT NULL DEFAULT 'Green'`.
#[derive(Insertable)]
#[diesel(table_name = brands)]
struct NewBrand {
    color: Option<String>,  // Option<T> 表示该字段是可选的，在传入 None 时使用缺省值。
}

let new_brand = NewBrand { color: Some("Red".into()) };
diesel::insert_into(brands)
    .values(&new_brand) // values() 的参数值是 Insertable
    .execute(connection)
    .unwrap();

// Insert the default color
let new_brand = NewBrand { color: None }; // 对于 Option<T> 类型的字段，如果在 insert 时值为 None，则 diesel 插入该字段的缺省值。
diesel::insert_into(brands)
    .values(&new_brand)
    .execute(connection)
    .unwrap();

use schema::{users, posts};
#[derive(Debug, PartialEq, Queryable, Selectable)]
struct User {
    id: i32,
    name: String,
}

#[derive(Debug, PartialEq, Queryable, Selectable)]
struct Post {
    id: i32,
    user_id: i32,
    title: String,
}
let (first_user, first_post) = users::table
    .inner_join(posts::table)
    .select(<(User, Post)>::as_select()) // tuple 也实现了 Selectable
    .first(connection)?;


#[derive(Debug, PartialEq, Queryable, Selectable)]
struct User {
    id: i32,
    name: String,
}

#[derive(Debug, PartialEq, Queryable, Selectable)]
#[diesel(table_name = posts)]
struct PostTitle {
    title: String,
}

#[derive(Debug, PartialEq, Queryable, Selectable)]
struct UserPost {
    #[diesel(embed)]
    user: User, // 支持嵌入字段
    #[diesel(embed)]
    post_title: PostTitle,
}

let first_user_post = users::table
    .inner_join(posts::table)
    .select(UserPost::as_select())
    .first(connection)?;

let expected_user_post = UserPost {
    user: User {
        id: 1,
        name: "Sean".into(),
    },
    post_title: PostTitle {
        title: "My first post".into(),
    },
};
assert_eq!(expected_user_post, first_user_post);

// Identifiable 可以作为 update() 的参数， 需要有作为 PK 的 id 字段。
// AsChangeset 可以作为 set() 的参数,
#[derive(Queryable, Identifiable, AsChangeset)]
#[diesel(table_name = posts)]
pub struct Post {
    pub id: i64,
    pub title: String,
    pub body: String,
    pub draft: bool,
    pub publish_at: SystemTime,
    pub visit_count: i32,
}

diesel::update(post) // post 是上面的实现了 Identifiable 的 Post 类型值, 必须要设置 id 字段.
    .set(posts::draft.eq(false))
    .execute(conn)

update(post)
// 等效于
update(posts.find(post.id))
// 或
update(posts.filter(id.eq(post.id))).

#[derive(Queryable, Identifiable, Selectable, Debug, PartialEq)]
#[diesel(table_name = books)]
pub struct Book {
    pub id: i32,
    pub title: String,
}

// Associations 关联表
#[derive(Queryable, Selectable, Identifiable, Associations, Debug, PartialEq)]
#[diesel(belongs_to(Book, foreign_key = book_id))] // foreign_key 默认为 {table}_id 字段
#[diesel(table_name = pages)]
pub struct Page {
    pub id: i32,
    pub page_number: i32,
    pub content: String,
    pub book_id: i32, // 外键
}

// Trait diesel::query_dsl::QueryDsl
pub trait QueryDsl: Sized {

    // 唯一性
    fn distinct(self) -> Distinct<Self> where Self: DistinctDsl
    fn distinct_on<Expr>(self, expr: Expr) -> DistinctOn<Self, Expr> where Self: DistinctOnDsl<Expr>

    // 指定返回的字段
    fn select<Selection>(self, selection: Selection) -> Select<Self, Selection where Selection: Expression, Self: SelectDsl<Selection>

    // 计数
    fn count(self) -> Select<Self, CountStar> where Self: SelectDsl<CountStar>

    // join 查询
    fn inner_join<Rhs>(self, rhs: Rhs) -> InnerJoin<Self, Rhs>
    fn left_outer_join<Rhs>(self, rhs: Rhs) -> LeftJoin<Self, Rhs>
    fn left_join<Rhs>(self, rhs: Rhs) -> LeftJoin<Self, Rhs>

    // 过滤，泛型参数 Predicte 类型由 FilterDsl 来限制
    fn filter<Predicate>(self, predicate: Predicate) -> Filter<Self, Predicate> where Self: FilterDsl<Predicate>
    fn or_filter<Predicate>( self, predicate: Predicate, ) -> OrFilter<Self, Predicate> where Self: OrFilterDsl<Predicate>

    // 使用主键值查找一条记录
    fn find<PK>(self, id: PK) -> Find<Self, PK> where Self: FindDsl<PK>

    // 排序字段
    fn order<Expr>(self, expr: Expr) -> Order<Self, Expr> where Expr: Expression, Self: OrderDsl<Expr>
    fn order_by<Expr>(self, expr: Expr) -> OrderBy<Self, Expr> where Expr: Expression, Self: OrderDsl<Expr>
    fn then_order_by<Order>(self, order: Order) -> ThenOrderBy<Self, Order> where Self: ThenOrderDsl<Order>

    // 限制返回条数
    fn limit(self, limit: i64) -> Limit<Self> where Self: LimitDsl
    fn offset(self, offset: i64) -> Offset<Self> where Self: OffsetDsl

    // 聚合
    fn group_by<GB>(self, group_by: GB) -> GroupBy<Self, GB> where GB: Expression, Self: GroupByDsl<GB>

    // 聚合过滤
    fn having<Predicate>(self, predicate: Predicate) -> Having<Self, Predicate> where Self: HavingDsl<Predicate>

    fn for_update(self) -> ForUpdate<Self> where Self: LockingDsl<ForUpdate>
    fn for_no_key_update(self) -> ForNoKeyUpdate<Self> where Self: LockingDsl<ForNoKeyUpdate>
    fn for_share(self) -> ForShare<Self> where Self: LockingDsl<ForShare>
    fn for_key_share(self) -> ForKeyShare<Self> where Self: LockingDsl<ForKeyShare>
    fn skip_locked(self) -> SkipLocked<Self> where Self: ModifyLockDsl<SkipLocked>
    fn no_wait(self) -> NoWait<Self> where Self: ModifyLockDsl<NoWait>
    fn into_boxed<'a, DB>(self) -> IntoBoxed<'a, Self, DB> where DB: Backend, Self: BoxedDsl<'a, DB>

    fn single_value(self) -> SingleValue<Self> where Self: SingleValueDsl
    fn nullable(self) -> NullableSelect<Self> where Self: SelectNullableDsl
}

// Table 和 SelectStatement 都实现了 QueryDsl
impl<'a, ST, QS, DB, GB> QueryDsl for BoxedSelectStatement<'a, ST, QS, DB, GB>
impl<F, S, D, W, O, LOf, G, H, LC> QueryDsl for SelectStatement<F, S, D, W, O, LOf, G, H, LC>
impl<S: AliasSource> QueryDsl for Alias<S>
impl<T: Table> QueryDsl for T  // Table 实现了 QueryDsl