Struct Query 

pub struct Query<'db, E>
where
    E: EntityTrait,
{ /* private fields */ }

A typed query bound to an explicit &Db, over a SeaORM entity E.

Construct on the golden path with QueryModel::query:

use arcature_data::QueryModel;
let posts = post::Entity::query(db)
    .filter(post::Column::UserId.eq(7))
    .order_by_desc(post::Column::CreatedAt)
    .all()
    .await?;

Or construct directly with Query::new. The builder carries the &Db for the lifetime of the query, so terminal methods need no extra argument.

Implementations

impl<'db, E> Query<'db, E>

where E: EntityTrait,

pub fn new(db: &'db Db) -> Self

Construct a query over all rows of E, bound to db.

pub fn filter<C>(self, condition: C) -> Self

where C: IntoCondition,

Add a filter condition. Accepts anything SeaORM’s Select::filter accepts — typically Column::X.eq(v) or a built Condition.

post::Entity::query(db).filter(post::Column::Active.eq(true))

pub fn order_by<C>(self, column: C, order: Order) -> Self

where C: IntoSimpleExpr,

Add an ORDER BY clause on a column with an explicit direction.

pub fn order_by_asc<C>(self, column: C) -> Self

where C: IntoSimpleExpr,

Add an ascending ORDER BY clause on a column.

pub fn order_by_desc<C>(self, column: C) -> Self

where C: IntoSimpleExpr,

Add a descending ORDER BY clause on a column.

pub fn limit(self, n: u64) -> Self

Limit the number of rows returned.

pub fn offset(self, n: u64) -> Self

Skip the first n rows.

pub fn paginate(self, per_page: u64) -> Paginated<'db, E>

Begin pagination with the given per-page size (must be >= 1). Chain .page(n) (1-based) and then .fetch() to run the count + page query.

pub async fn all(self) -> Result<Vec<E::Model>, DataError>

Execute the query and return all matching rows.

Errors

Returns DataError::Database if the underlying SeaORM query fails.

pub async fn one(self) -> Result<Option<E::Model>, DataError>

Execute the query and return the first matching row, if any.

Errors

Returns DataError::Database if the underlying SeaORM query fails.

impl<'db, E> Query<'db, E>

where E: EntityTrait,

pub async fn with<R>( self, _relation: Relation<R>, ) -> Result<Vec<(E::Model, Option<R::Model>)>, DataError>

where R: EntityTrait + Default, E: Related<R>,

Eager-load a related entity R alongside each row of E, returning (parent, Option<related>) pairs. Delegates to SeaORM’s find_also_related.

let rows = post::Entity::query(db)
    .with(arcature_data::Relation::of::<user::Entity>())
    .await?; // Vec<(post::Model, Option<user::Model>)>

R must be Default — SeaORM’s generated Entity is a unit struct that derives Default, so this is satisfied by every #[derive(DeriveEntityModel)] entity without extra work.

Errors

Returns DataError::Database if the underlying SeaORM query fails.