Trait Model

pub trait Model:
    Send
    + Sync
    + Debug
    + Serialize
    + for<'de> Deserialize<'de> {
    type PrimaryKey: Clone + Send + Sync + Debug + Display + Default;

    // Required methods
    fn table_name() -> &'static str;
    fn primary_key(&self) -> Option<Self::PrimaryKey>;
    fn set_primary_key(&mut self, key: Self::PrimaryKey);
    fn from_row(row: &PgRow) -> ModelResult<Self>
       where Self: Sized;
    fn to_fields(&self) -> HashMap<String, Value>;

    // Provided methods
    fn primary_key_name() -> &'static str { ... }
    fn uses_timestamps() -> bool { ... }
    fn uses_soft_deletes() -> bool { ... }
    fn created_at(&self) -> Option<DateTime<Utc>> { ... }
    fn set_created_at(&mut self, _timestamp: DateTime<Utc>) { ... }
    fn updated_at(&self) -> Option<DateTime<Utc>> { ... }
    fn set_updated_at(&mut self, _timestamp: DateTime<Utc>) { ... }
    fn deleted_at(&self) -> Option<DateTime<Utc>> { ... }
    fn set_deleted_at(&mut self, _timestamp: Option<DateTime<Utc>>) { ... }
    fn is_soft_deleted(&self) -> bool { ... }
    async fn find(
        pool: &Pool<Postgres>,
        id: Self::PrimaryKey,
    ) -> ModelResult<Option<Self>>
       where Self: Sized { ... }
    async fn find_or_fail(
        pool: &Pool<Postgres>,
        id: Self::PrimaryKey,
    ) -> ModelResult<Self>
       where Self: Sized { ... }
    async fn create(pool: &Pool<Postgres>, model: Self) -> ModelResult<Self>
       where Self: Sized { ... }
    async fn update(&mut self, pool: &Pool<Postgres>) -> ModelResult<()> { ... }
    async fn delete(self, pool: &Pool<Postgres>) -> ModelResult<()> { ... }
    fn bind_json_value<'a>(
        query: Query<'a, Postgres, PgArguments>,
        value: &Value,
    ) -> ModelResult<Query<'a, Postgres, PgArguments>> { ... }
    fn query() -> QueryBuilder<Self>
       where Self: Sized { ... }
    async fn all(pool: &Pool<Postgres>) -> ModelResult<Vec<Self>>
       where Self: Sized { ... }
    async fn count(pool: &Pool<Postgres>) -> ModelResult<i64>
       where Self: Sized { ... }
    async fn where_field<V>(
        pool: &Pool<Postgres>,
        field: &str,
        value: V,
    ) -> ModelResult<Vec<Self>>
       where Self: Sized,
             for<'q> V: Send + Sync + 'static + Encode<'q, Postgres> + Type<Postgres> { ... }
    async fn first_where<V>(
        pool: &Pool<Postgres>,
        field: &str,
        value: V,
    ) -> ModelResult<Option<Self>>
       where Self: Sized,
             for<'q> V: Send + Sync + 'static + Encode<'q, Postgres> + Type<Postgres> { ... }
    fn from_database_row(row: &dyn DatabaseRow) -> ModelResult<Self>
       where Self: Sized { ... }
}

Trait for database models with standard ORM operations

Required Associated Types

type PrimaryKey: Clone + Send + Sync + Debug + Display + Default

The type used for this model’s primary key

Required Methods

fn table_name() -> &'static str

Table name for this model

fn primary_key(&self) -> Option<Self::PrimaryKey>

Get the primary key value for this model instance

fn set_primary_key(&mut self, key: Self::PrimaryKey)

Set the primary key value for this model instance

fn from_row(row: &PgRow) -> ModelResult<Self>

where Self: Sized,

Create a model instance from a database row This will be automatically implemented by the derive macro

fn to_fields(&self) -> HashMap<String, Value>

Convert model to field-value pairs for database operations This will be automatically implemented by the derive macro

Provided Methods

fn primary_key_name() -> &'static str

Primary key field name(s)

fn uses_timestamps() -> bool

Check if this model uses timestamps (created_at, updated_at)

fn uses_soft_deletes() -> bool

Check if this model supports soft deletes

fn created_at(&self) -> Option<DateTime<Utc>>

Get created_at timestamp if available

fn set_created_at(&mut self, _timestamp: DateTime<Utc>)

Set created_at timestamp

fn updated_at(&self) -> Option<DateTime<Utc>>

Get updated_at timestamp if available

fn set_updated_at(&mut self, _timestamp: DateTime<Utc>)

Set updated_at timestamp

fn deleted_at(&self) -> Option<DateTime<Utc>>

Get deleted_at timestamp if available (for soft deletes)

fn set_deleted_at(&mut self, _timestamp: Option<DateTime<Utc>>)

Set deleted_at timestamp (for soft deletes)

fn is_soft_deleted(&self) -> bool

Check if this model instance is soft deleted

async fn find( pool: &Pool<Postgres>, id: Self::PrimaryKey, ) -> ModelResult<Option<Self>>

where Self: Sized,

Find a model by its primary key

async fn find_or_fail( pool: &Pool<Postgres>, id: Self::PrimaryKey, ) -> ModelResult<Self>

where Self: Sized,

Find a model by its primary key or return an error if not found

async fn create(pool: &Pool<Postgres>, model: Self) -> ModelResult<Self>

where Self: Sized,

Create a new model instance in the database with field-based insertion

async fn update(&mut self, pool: &Pool<Postgres>) -> ModelResult<()>

Update this model instance in the database with field-based updates

async fn delete(self, pool: &Pool<Postgres>) -> ModelResult<()>

Delete this model instance from the database

fn bind_json_value<'a>( query: Query<'a, Postgres, PgArguments>, value: &Value, ) -> ModelResult<Query<'a, Postgres, PgArguments>>

Helper method to bind JSON values to SQL queries

fn query() -> QueryBuilder<Self>

where Self: Sized,

Get a query builder for this model

async fn all(pool: &Pool<Postgres>) -> ModelResult<Vec<Self>>

where Self: Sized,

Get all records for this model with proper SQL execution

async fn count(pool: &Pool<Postgres>) -> ModelResult<i64>

where Self: Sized,

Count all records for this model with proper SQL execution

async fn where_field<V>( pool: &Pool<Postgres>, field: &str, value: V, ) -> ModelResult<Vec<Self>>

where Self: Sized, for<'q> V: Send + Sync + 'static + Encode<'q, Postgres> + Type<Postgres>,

Find models by a specific field value with proper parameter binding

async fn first_where<V>( pool: &Pool<Postgres>, field: &str, value: V, ) -> ModelResult<Option<Self>>

where Self: Sized, for<'q> V: Send + Sync + 'static + Encode<'q, Postgres> + Type<Postgres>,

Find the first model by a specific field value

fn from_database_row(row: &dyn DatabaseRow) -> ModelResult<Self>

where Self: Sized,

Create a model instance from a database row (abstracted version) This will replace from_row in the future

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors