Trait QueryOrder 

pub trait QueryOrder: Sized {
    type QueryStatement: OrderedStatement;

    // Required method
    fn query(&mut self) -> &mut SelectStatement;

    // Provided methods
    fn order_by<C>(self, col: C, ord: Order) -> Self
       where C: IntoSimpleExpr { ... }
    fn order_by_asc<C>(self, col: C) -> Self
       where C: IntoSimpleExpr { ... }
    fn order_by_desc<C>(self, col: C) -> Self
       where C: IntoSimpleExpr { ... }
    fn order_by_with_nulls<C>(
        self,
        col: C,
        ord: Order,
        nulls: NullOrdering,
    ) -> Self
       where C: IntoSimpleExpr { ... }
}

Performs ORDER BY operations

Required Associated Types

type QueryStatement: OrderedStatement

Required Methods

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

Add the query to perform an ORDER BY operation

Provided Methods

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

where C: IntoSimpleExpr,

Add an order_by expression

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .order_by(cake::Column::Id, Order::Asc)
        .order_by(cake::Column::Name, Order::Desc)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC, `cake`.`name` DESC"
);

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

where C: IntoSimpleExpr,

Add an order_by expression (ascending)

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .order_by_asc(cake::Column::Id)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC"
);

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

where C: IntoSimpleExpr,

Add an order_by expression (descending)

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find()
        .order_by_desc(cake::Column::Id)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` DESC"
);

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

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};
use sea_query::NullOrdering;

assert_eq!(
    cake::Entity::find()
        .order_by_with_nulls(cake::Column::Id, Order::Asc, NullOrdering::First)
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."id", "cake"."name" FROM "cake" ORDER BY "cake"."id" ASC NULLS FIRST"#
);

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

impl<E> QueryOrder for Select<E>

where E: EntityTrait,

type QueryStatement = SelectStatement

impl<E, F> QueryOrder for SelectTwo<E, F>

where E: EntityTrait, F: EntityTrait,

type QueryStatement = SelectStatement

impl<E, F> QueryOrder for SelectTwoMany<E, F>

where E: EntityTrait, F: EntityTrait,

type QueryStatement = SelectStatement

impl<E, F, G, H, I, J, TOP> QueryOrder for SelectSix<E, F, G, H, I, J, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, H: EntityTrait, I: EntityTrait, J: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

impl<E, F, G, H, I, TOP> QueryOrder for SelectFive<E, F, G, H, I, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, H: EntityTrait, I: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

impl<E, F, G, H, TOP> QueryOrder for SelectFour<E, F, G, H, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, H: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement

impl<E, F, G, TOP> QueryOrder for SelectThree<E, F, G, TOP>

where E: EntityTrait, F: EntityTrait, G: EntityTrait, TOP: Topology,

type QueryStatement = SelectStatement