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) -> Self where
    T: IntoColumnRef, 

Construct a new WindowStatement with PARTITION BY column

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

Construct a new WindowStatement with PARTITION BY custom

pub fn order_by<T>(col: T, order: Order) -> Self where
    T: IntoColumnRef, 

Construct a new WindowStatement with ORDER BY column

pub fn order_by_custom<T>(col: T, order: Order) -> Self where
    T: ToString, 

Construct a new WindowStatement with ORDER 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

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() -> Self

Returns the “default value” for a type.

impl OrderedStatement for WindowStatement

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

Order by column.

fn order_by_tbl<T, C>(&mut self, table: T, col: C, order: Order) -> &mut Self where
    T: IntoIden,
    C: IntoIden, 

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by] with a tuple as [ColumnRef]

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

Order by SimpleExpr.

fn order_by_customs<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
    T: ToString, 

Order by custom string.

fn order_by_columns<T>(&mut self, cols: Vec<(T, Order)>) -> &mut Self where
    T: IntoColumnRef, 

Order by vector of columns.

fn order_by_table_columns<T, C>(
    &mut self,
    cols: Vec<(T, C, Order)>
) -> &mut Self where
    T: IntoIden,
    C: IntoIden, 

👎 Deprecated since 0.9.0:

Please use the [OrderedStatement::order_by_columns] with a tuple as [ColumnRef]

fn order_by_with_nulls<T>(
    &mut self,
    col: T,
    order: Order,
    nulls: NullOrdering
) -> &mut Self where
    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<T>(
    &mut self,
    cols: Vec<(T, Order, NullOrdering)>
) -> &mut Self where
    T: ToString, 

Order by custom string with nulls order option.

fn order_by_columns_with_nulls<T>(
    &mut self,
    cols: Vec<(T, Order, NullOrdering)>
) -> &mut Self where
    T: IntoColumnRef, 

Order by vector of columns with nulls order option.

impl OverStatement for WindowStatement

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

Partition by column.

fn partition_by_customs<T>(&mut self, cols: Vec<T>) -> &mut Self where
    T: ToString, 

Partition by custom string.

fn partition_by_columns<T>(&mut self, cols: Vec<T>) -> &mut Self where
    T: IntoColumnRef, 

Partition by vector of columns.