Struct sea_query::query::WindowStatement

pub struct WindowStatement { /* private fields */ }

Window expression

References:

1. https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
2. https://www.sqlite.org/windowfunctions.html
3. https://www.postgresql.org/docs/current/tutorial-window.html

Implementations

impl WindowStatement

pub fn new() -> Self

Construct a new WindowStatement

pub fn take(&mut self) -> Self

pub fn partition_by<T>(col: T) -> Selfwhere T: IntoColumnRef,

Construct a new WindowStatement with PARTITION BY column

pub fn partition_by_custom<T>(col: T) -> Selfwhere T: ToString,

Construct a new WindowStatement with PARTITION BY custom

pub fn frame_start(&mut self, type: FrameType, start: Frame) -> &mut Self

frame clause for frame_start

Examples:

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_as(
        Expr::col(Char::Character),
        WindowStatement::partition_by(Char::FontSize)
            .frame_start(FrameType::Rows, Frame::UnboundedPreceding)
            .take(),
        Alias::new("C"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER ( PARTITION BY `font_size` ROWS UNBOUNDED PRECEDING ) AS `C` FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ROWS UNBOUNDED PRECEDING ) AS "C" FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ROWS UNBOUNDED PRECEDING ) AS "C" FROM "character""#
);

pub fn frame_between( &mut self, type: FrameType, start: Frame, end: Frame ) -> &mut Self

frame clause for BETWEEN frame_start AND frame_end

Examples:

use sea_query::{tests_cfg::*, *};

let query = Query::select()
    .from(Char::Table)
    .expr_window_as(
        Expr::col(Char::Character),
        WindowStatement::partition_by(Char::FontSize)
            .frame_between(FrameType::Rows, Frame::UnboundedPreceding, Frame::UnboundedFollowing)
            .take(),
        Alias::new("C"))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"SELECT `character` OVER ( PARTITION BY `font_size` ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS `C` FROM `character`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS "C" FROM "character""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"SELECT "character" OVER ( PARTITION BY "font_size" ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING ) AS "C" FROM "character""#
);

pub fn frame( &mut self, type: FrameType, start: Frame, end: Option<Frame> ) -> &mut Self

frame clause

impl WindowStatement

pub fn add_order_by(&mut self, order: OrderExpr) -> &mut Self

See OrderedStatement::add_order_by

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

See OrderedStatement::clear_order_by

pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut Selfwhere T: IntoColumnRef,

See OrderedStatement::order_by

pub fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self

See OrderedStatement::order_by_expr

pub fn order_by_customs<I, T>(&mut self, cols: I) -> &mut Selfwhere T: ToString, I: IntoIterator<Item = (T, Order)>,

See OrderedStatement::order_by_customs

pub fn order_by_columns<I, T>(&mut self, cols: I) -> &mut Selfwhere T: IntoColumnRef, I: IntoIterator<Item = (T, Order)>,

See OrderedStatement::order_by_columns

pub fn order_by_with_nulls<T>( &mut self, col: T, order: Order, nulls: NullOrdering ) -> &mut Selfwhere T: IntoColumnRef,

See OrderedStatement::order_by_with_nulls

pub fn order_by_expr_with_nulls( &mut self, expr: SimpleExpr, order: Order, nulls: NullOrdering ) -> &mut Self

See OrderedStatement::order_by_expr_with_nulls

pub fn order_by_customs_with_nulls<I, T>(&mut self, cols: I) -> &mut Selfwhere T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

See OrderedStatement::order_by_customs_with_nulls

pub fn order_by_columns_with_nulls<I, T>(&mut self, cols: I) -> &mut Selfwhere T: IntoColumnRef, I: IntoIterator<Item = (T, Order, NullOrdering)>,

See OrderedStatement::order_by_columns_with_nulls

Trait Implementations

impl Clone for WindowStatement

fn clone(&self) -> WindowStatement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WindowStatement

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

Formats the value using the given formatter.

impl Default for WindowStatement

fn default() -> WindowStatement

Returns the “default value” for a type.

impl OrderedStatement for WindowStatement

fn clear_order_by(&mut self) -> &mut Self

Clear order expressions

fn order_by<T>(&mut self, col: T, order: Order) -> &mut Selfwhere T: IntoColumnRef,

Order by column.

fn order_by_expr(&mut self, expr: SimpleExpr, order: Order) -> &mut Self

Order by SimpleExpr.

fn order_by_customs<I, T>(&mut self, cols: I) -> &mut Selfwhere T: ToString, I: IntoIterator<Item = (T, Order)>,

Order by custom string.

fn order_by_columns<I, T>(&mut self, cols: I) -> &mut Selfwhere T: IntoColumnRef, I: IntoIterator<Item = (T, Order)>,

Order by vector of columns.

fn order_by_with_nulls<T>( &mut self, col: T, order: Order, nulls: NullOrdering ) -> &mut Selfwhere T: IntoColumnRef,

Order by column with nulls order option.

fn order_by_expr_with_nulls( &mut self, expr: SimpleExpr, order: Order, nulls: NullOrdering ) -> &mut Self

Order by SimpleExpr with nulls order option.

fn order_by_customs_with_nulls<I, T>(&mut self, cols: I) -> &mut Selfwhere T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by custom string with nulls order option.

fn order_by_columns_with_nulls<I, T>(&mut self, cols: I) -> &mut Selfwhere T: IntoColumnRef, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by vector of columns with nulls order option.

impl OverStatement for WindowStatement

fn partition_by<T>(&mut self, col: T) -> &mut Selfwhere T: IntoColumnRef,

Partition by column.

fn partition_by_customs<I, T>(&mut self, cols: I) -> &mut Selfwhere T: ToString, I: IntoIterator<Item = T>,

Partition by custom string.

fn partition_by_columns<I, T>(&mut self, cols: I) -> &mut Selfwhere T: IntoColumnRef, I: IntoIterator<Item = T>,

Partition by vector of columns.

impl PartialEq<WindowStatement> for WindowStatement

fn eq(&self, other: &WindowStatement) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for WindowStatement