实体的几个 trait

pub mod post {
  use sea_orm::entity::prelude::*;

  #[sea_orm::model]
  #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
  #[sea_orm(table_name = "post")]
  pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i32,
    pub title: String,
    pub body: Option<String>,
  }

  impl ActiveModelBehavior for ActiveModel {}
}

    pub struct Entity;

pub trait IdenStatic: Iden + Copy + Debug + Send + Sync + 'static {
    /// Method to call to get the static string identity
    fn as_str(&self) -> &'static str;
}

// ...
pub trait EntityName: IdenStatic + Default {
    /// Method to get the name for the schema, defaults to [Option::None] if not set
    fn schema_name(&self) -> Option<&str> {
        None
    }

    /// Method to get the comment for the schema, defaults to [Option::None] if not set
    fn comment(&self) -> Option<&str> {
        None
    }

    /// Get the name of the table
    fn table_name(&self) -> &'static str;

    /// Get the [TableRef] from invoking the `self.schema_name()`
    fn table_ref(&self) -> TableRef {
        match self.schema_name() {
            Some(schema) => (schema.to_owned(), self.into_iden()).into_table_ref(),
            None => self.into_table_ref(),
        }
    }
}

let sql = Query::select().column(post::Column::Title).from(post::Entity).to_string(PostgresQueryBuilder);
println!("sea-query: {sql}");

sea-query: SELECT "title" FROM "post"

pub trait Iden {
    // ...
    fn quoted(&self) -> Cow<'static, str> {
        Cow::Owned(self.to_string())
    }
    // ...
    fn to_string(&self) -> String {
        self.unquoted().to_owned()
    }
    // ...
    fn unquoted(&self) -> &str;
}

let kind = |c: Cow<'static, str>| if matches!(c, Cow::Borrowed(_)) { "Borrowed" } else { "Owned" };
println!("Entity       -> {}", kind(post::Entity.into_iden().inner()));
println!("Column::Title -> {}", kind(post::Column::Title.into_iden().inner()));
println!("PrimaryKey::Id -> {}", kind(post::PrimaryKey::Id.into_iden().inner()));

Entity       -> Owned
Column::Title -> Borrowed
PrimaryKey::Id -> Borrowed

pub trait EntityTrait: EntityName {
    #[allow(missing_docs)]
    type Model: ModelTrait<Entity = Self> + FromQueryResult;

    #[allow(missing_docs)]
    type ModelEx: ModelTrait<Entity = Self>;

    #[allow(missing_docs)]
    type ActiveModel: ActiveModelBehavior<Entity = Self>;

    // ...
    type ActiveModelEx: ActiveModelTrait<Entity = Self>;

    #[allow(missing_docs)]
    type Column: ColumnTrait;

    #[allow(missing_docs)]
    type Relation: RelationTrait;

    #[allow(missing_docs)]
    type PrimaryKey: PrimaryKeyTrait + PrimaryKeyToColumn<Column = Self::Column>;

    impl sea_orm::entity::EntityTrait for Entity {
        type Model = Model;
        type ModelEx = Model;
        type ActiveModel = ActiveModel;
        type ActiveModelEx = ActiveModel;
        type Column = Column;
        type PrimaryKey = PrimaryKey;
        type Relation = Relation;
    }

    fn find_by_id<T>(values: T) -> Select<Self>
    where
        T: Into<<Self::PrimaryKey as PrimaryKeyTrait>::ValueType>,
    {
        let mut select = Self::find();
        let mut keys = Self::PrimaryKey::iter();
        for v in values.into().into_value_tuple() {
            if let Some(key) = keys.next() {
                let col = key.into_column();
                select = select.filter(col.eq(v));
            } else {
                unreachable!("primary key arity mismatch");
            }
        }
        select
    }

fn main() {
  let _ = post::Entity::find_by_id((1, 2));
  let _ = post::Entity::find_by_id("1");
}

error[E0277]: the trait bound `i32: From<({integer}, {integer})>` is not satisfied
   --> src/bin/pk_arity.rs:5:36
    |
  5 |   let _ = post::Entity::find_by_id((1, 2));
    |           ------------------------ ^^^^^^ the trait `From<({integer}, {integer})>` is not implemented for `i32`
    |           |
    |           required by a bound introduced by this call
...
    = note: required for `({integer}, {integer})` to implement `Into<i32>`
note: required by a bound in `find_by_id`
   --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sea-orm-2.0.4/src/entity/base_entity.rs:323:12
...
error[E0277]: the trait bound `i32: From<&str>` is not satisfied
   --> src/bin/pk_arity.rs:6:36
    |
  6 |   let _ = post::Entity::find_by_id("1");
    |           ------------------------ ^^^ the trait `From<&str>` is not implemented for `i32`
...

pub trait ColumnTrait: IdenStatic + Iterable + FromStr {
    #[allow(missing_docs)]
    type EntityName: EntityName;

    /// Get the column definition with SQL attributes
    fn def(&self) -> ColumnDef;

    // ...
    fn enum_type_name(&self) -> Option<&'static str> {
        None
    }

    /// Get the name of the entity the column belongs to
    fn entity_name(&self) -> DynIden {
        SeaRc::new(Self::EntityName::default())
    }

    /// Get the table.column reference
    fn as_column_ref(&self) -> (DynIden, DynIden) {
        (self.entity_name(), SeaRc::new(*self))
    }

let cols: Vec<&str> = post::Column::iter().map(|c| c.as_str()).collect();
println!("Column::iter() = {cols:?}");
println!("from_str(\"title\") = {:?}, from_str(\"Title\") = {:?}", post::Column::from_str("title"), post::Column::from_str("Title"));

Column::iter() = ["id", "title", "body"]
from_str("title") = Ok(Title), from_str("Title") = Err(ColumnFromStrErr("Title"))

pub trait PrimaryKeyTrait: IdenStatic + Iterable {
    #[allow(missing_docs)]
    type ValueType: Sized
        + Send
        + Debug
        + PartialEq
        + IntoValueTuple
        + FromValueTuple
        + TryGetableMany
        + TryFromU64
        + PrimaryKeyArity;

    /// Method to determine if Primary Key is not auto_increment
    fn auto_increment() -> bool;
}

entity!(tag_link, "tag_link", {
  #[sea_orm(primary_key)] pub post_id: i32,
  #[sea_orm(primary_key)] pub tag_id: i32,
});

let stmt = tag_link::Entity::find_by_id((1, 2)).build(DbBackend::Postgres);
println!("find_by_id((1, 2)): {} {:?}", stmt.sql, stmt.values.map(|v| v.0).unwrap_or_default());

find_by_id((1, 2)): SELECT "tag_link"."post_id", "tag_link"."tag_id" FROM "tag_link" WHERE "tag_link"."post_id" = $1 AND "tag_link"."tag_id" = $2 [Int(Some(1)), Int(Some(2))]

pub trait ModelTrait: Clone + Send + Debug {
    #[allow(missing_docs)]
    type Entity: EntityTrait;

    /// Get the [Value] of a column from a Model
    fn get(&self, c: <Self::Entity as EntityTrait>::Column) -> Value;

    // ...
    fn get_value_type(c: <Self::Entity as EntityTrait>::Column) -> ArrayType;

    // ...
    fn try_set(&mut self, c: <Self::Entity as EntityTrait>::Column, v: Value) -> Result<(), DbErr>;

pub trait FromQueryResult: Sized {
    // ...
    fn from_query_result(res: &QueryResult, pre: &str) -> Result<Self, DbErr>;

    // ...
    fn from_query_result_optional(res: &QueryResult, pre: &str) -> Result<Option<Self>, DbErr> {
        Ok(Self::from_query_result(res, pre).ok())
        // ...
    }

    // ...
    fn from_query_result_nullable(res: &QueryResult, pre: &str) -> Result<Self, TryGetError> {
        Self::from_query_result(res, pre).map_err(TryGetError::DbErr)
    }

auto_increment: i32=true Uuid=false String=false i64(manual)=false (i32,i32)=false