📖 Complete API Reference

Find a single record by primary key

let user = User::find(1).await?;

Returns: Result<Model>

Errors: NotFound if record doesn't exist

Get all records without conditions

let users = User::all().await?;

Returns: Result<Vec<Model>>

Create a new query builder

User::query()
    .where_eq("active", true)
    .get()
    .await?

Returns: QueryBuilder

Add equality condition (=)

.where_eq("status", "active")

Add inequality condition (!=)

.where_not("deleted_at", null)

Greater than condition (>)

.where_gt("age", 18)

Greater than or equal (>=)

.where_gte("score", 100)

Less than condition (<)

.where_lt("price", 50)

Less than or equal (<=)

.where_lte("quantity", 10)

Pattern matching (LIKE)

.where_like("name", "%John%")

Multiple value matching (IN)

.where_in("id", vec![1, 2, 3, 4, 5])

Check for NULL values

.where_null("deleted_at")

Check for non-NULL values

.where_not_null("email")

Sort results by column

.order_by("created_at", Order::Desc)
.then_order_by("name", Order::Asc)

Limit number of results

.limit(10)

Skip first N records

.offset(20)

Paginate results and get total count

let (users, total) = User::query()
    .paginate(page: 1, per_page: 10)
    .await?;

Returns: Result<(Vec<Model>, i64)>

Execute query and get all results

let users = User::query()
    .where_eq("active", true)
    .get()
    .await?;

Returns: Result<Vec<Model>>

Execute query and get first result

let user = User::query()
    .where_eq("email", "test@example.com")
    .first()
    .await?;

Returns: Result<Model>

Count matching records

let count = User::query()
    .where_eq("active", true)
    .count()
    .await?;

Returns: Result<i64>

Insert a new record into database

let user = User {
    id: 0,
    email: "john@example.com".to_string(),
    name: "John Doe".to_string(),
    ...
};
let user = user.save().await?;

Note: Primary key must be 0 or default for new records

Create builder for fluent insertion

let user = User::create()
    .email("john@example.com")
    .name("John Doe")
    .active(true)
    .save()
    .await?;

Update an existing record

let mut user = User::find(1).await?;
user.name = "Jane Doe".to_string();
let user = user.update().await?;

Batch update records

User::query()
    .where_eq("active", false)
    .update()
    .set("active", true)
    .execute()
    .await?;

Delete a single record

let user = User::find(1).await?;
user.delete().await?;

Delete records matching conditions

User::query()
    .where_eq("active", false)
    .delete()
    .await?;

Mark record as deleted (soft delete)

let user = user.soft_delete().await?;

Note: Model must have deleted_at field and soft_delete enabled

Define belongs-to relationship

#[belongs_to(User)]
pub user_id: i64,

Define has-one relationship

#[has_one(Profile)]
pub profile: Option<Profile>,

Define has-many relationship

#[has_many(Post)]
pub posts: Vec<Post>,

Eager load relations

let posts = Post::with_relations(["author", "comments"])
    .get()
    .await?;

TideORM provides specific error types for different scenarios: