Struct sea_orm::Cursor

pub struct Cursor<S>
where
    S: SelectorTrait,
{ /* private fields */ }

Cursor pagination

Implementations

impl<S> Cursor<S>

where S: SelectorTrait,

pub fn new<C>(query: SelectStatement, table: DynIden, order_columns: C) -> Self

where C: IntoIdentity,

Create a new cursor

pub fn before<V>(&mut self, values: V) -> &mut Self

where V: IntoValueTuple,

Filter paginated result with corresponding column less than the input value

pub fn after<V>(&mut self, values: V) -> &mut Self

where V: IntoValueTuple,

Filter paginated result with corresponding column greater than the input value

pub fn asc(&mut self) -> &mut Self

Use ascending sort order

pub fn desc(&mut self) -> &mut Self

Use descending sort order

pub fn first(&mut self, num_rows: u64) -> &mut Self

Limit result set to only first N rows in ascending order of the order by column

pub fn last(&mut self, num_rows: u64) -> &mut Self

Limit result set to only last N rows in ascending order of the order by column

pub async fn all<C>(&mut self, db: &C) -> Result<Vec<S::Item>, DbErr>

where C: ConnectionTrait,

Fetch the paginated result

pub fn into_model<M>(self) -> Cursor<SelectModel<M>>

where M: FromQueryResult,

Construct a Cursor that fetch any custom struct

pub fn into_partial_model<M>(self) -> Cursor<SelectModel<M>>

where M: PartialModelTrait,

Return a [Selector] from Self that wraps a SelectModel with a PartialModel

pub fn into_json(self) -> Cursor<SelectModel<JsonValue>>

Construct a Cursor that fetch JSON value

pub fn set_secondary_order_by( &mut self, tbl_col: Vec<(DynIden, Identity)>, ) -> &mut Self

Set the cursor ordering for another table when dealing with SelectTwo

Trait Implementations

impl<S> Clone for Cursor<S>

where S: SelectorTrait + Clone,

fn clone(&self) -> Cursor<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Cursor<S>

where S: SelectorTrait + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S> QueryOrder for Cursor<S>

where S: SelectorTrait,

type QueryStatement = SelectStatement

fn query(&mut self) -> &mut SelectStatement

Add the query to perform an ORDER BY operation

fn order_by<C>(self, col: C, ord: Order) -> Self

where C: IntoSimpleExpr,

Add an order_by expression

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

where C: IntoSimpleExpr,

Add an order_by expression (ascending)

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

where C: IntoSimpleExpr,

Add an order_by expression (descending)

fn order_by_with_nulls<C>(self, col: C, ord: Order, nulls: NullOrdering) -> Self

where C: IntoSimpleExpr,

Add an order_by expression with nulls ordering option

impl<S> QuerySelect for Cursor<S>

where S: SelectorTrait,

type QueryStatement = SelectStatement

fn query(&mut self) -> &mut SelectStatement

Add the select SQL statement

fn select_only(self) -> Self

Clear the selection list

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

where C: ColumnTrait,

Add a select column

fn column_as<C, I>(self, col: C, alias: I) -> Self

where C: IntoSimpleExpr, I: IntoIdentity,

Add a select column with alias

fn columns<C, I>(self, cols: I) -> Self

where C: ColumnTrait, I: IntoIterator<Item = C>,

Select columns

fn offset<T>(self, offset: T) -> Self

where T: Into<Option<u64>>,

Add an offset expression. Passing in None would remove the offset.

fn limit<T>(self, limit: T) -> Self

where T: Into<Option<u64>>,

Add a limit expression. Passing in None would remove the limit.

fn group_by<C>(self, col: C) -> Self

where C: IntoSimpleExpr,

Add a group by column

fn having<F>(self, filter: F) -> Self

where F: IntoCondition,

Add an AND HAVING expression

fn distinct(self) -> Self

Add a DISTINCT expression

fn distinct_on<T, I>(self, cols: I) -> Self

where T: IntoColumnRef, I: IntoIterator<Item = T>,

Add a DISTINCT ON expression NOTE: this function is only supported by sqlx-postgres

fn join(self, join: JoinType, rel: RelationDef) -> Self

Join via RelationDef.

fn join_rev(self, join: JoinType, rel: RelationDef) -> Self

Join via RelationDef but in reverse direction. Assume when there exist a relation A to B. You can reverse join B from A.

fn join_as<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self

where I: IntoIden,

Join via RelationDef with table alias.

fn join_as_rev<I>(self, join: JoinType, rel: RelationDef, alias: I) -> Self

where I: IntoIden,

Join via RelationDef with table alias but in reverse direction. Assume when there exist a relation A to B. You can reverse join B from A.

fn lock(self, lock_type: LockType) -> Self

Select lock

fn lock_shared(self) -> Self

Select lock shared

fn lock_exclusive(self) -> Self

Select lock exclusive

fn lock_with_behavior(self, type: LockType, behavior: LockBehavior) -> Self

Row locking with behavior (if supported).

fn expr<T>(self, expr: T) -> Self

where T: Into<SelectExpr>,

Add an expression to the select expression list.

fn exprs<T, I>(self, exprs: I) -> Self

where T: Into<SelectExpr>, I: IntoIterator<Item = T>,

Add select expressions from vector of SelectExpr.

fn expr_as<T, A>(self, expr: T, alias: A) -> Self

where T: Into<SimpleExpr>, A: IntoIdentity,

Select column.

fn expr_as_<T, A>(self, expr: T, alias: A) -> Self

where T: Into<SimpleExpr>, A: IntoIdentity,

Same as expr_as. Here for legacy reasons.

fn tbl_col_as<T, C, A>(self, (tbl, col): (T, C), alias: A) -> Self

where T: IntoIden + 'static, C: IntoIden + 'static, A: IntoIdentity,

Shorthand of expr_as(Expr::col((T, C)), A).