cake - v0.8.0

cake/select

A DSL to build SELECT queries.

Types

Direction

</>

Defines the direction of an OrderBy.

pub type Direction {
  Asc
  Desc
}

Constructors 

  • Asc
  • Desc

Functions

alias

</> 
pub fn alias(
  value vl: SelectValue,
  alias als: String,
) -> SelectValue

Creates an alias off a String.

all

</> 
pub fn all(query qry: Select) -> Select

Sets the kind of the Select query to return duplicates which is the default.

bool

</> 
pub fn bool(value vl: Bool) -> SelectValue

Creates a boolean Param off a Bool.

col

</> 
pub fn col(name nm: String) -> SelectValue

Creates a column identifier off a String.

comment

</> 
pub fn comment(
  query qry: Select,
  comment cmmnt: String,
) -> Select

Appends a Comment to the Select query.

distinct

</> 
pub fn distinct(query qry: Select) -> Select

Sets the kind of the Select query to return distinct rows only.

epilog

</> 
pub fn epilog(query qry: Select, epilog eplg: String) -> Select

Appends an Epilog to the Select query.

float

</> 
pub fn float(value vl: Float) -> SelectValue

Creates a float Param off a Float.

fragment

</> 
pub fn fragment(fragment frgmt: Fragment) -> SelectValue

Creates a SelectFragment off a Fragment.

from_sub_query

</> 
pub fn from_sub_query(
  query qry: Select,
  sub_query sb_qry: Query,
  alias als: String,
) -> Select

Sets the FROM clause of the Select query to an aliased sub-query.

from_table

</> 
pub fn from_table(
  query qry: Select,
  name tbl_nm: String,
) -> Select

Sets the FROM clause of the Select query to a table name.

get_comment

</> 
pub fn get_comment(query qry: Select) -> Comment

Gets the Comment from the Select query.

get_epilog

</> 
pub fn get_epilog(query qry: Select) -> Epilog

Gets the Epilog from the Select query.

get_from

</> 
pub fn get_from(query qry: Select) -> From

Gets the FROM clause of the Select query.

get_group_by

</> 
pub fn get_group_by(query qry: Select) -> GroupBy

Gets GroupBy in the Select query.

get_having

</> 
pub fn get_having(query qry: Select) -> Where

GetsHAVING in the Select query.

See function having on details why this returns a Where.

get_joins

</> 
pub fn get_joins(query qry: Select) -> Joins

Gets the Joins of the Select query.

get_kind

</> 
pub fn get_kind(
  query qry: Select,
  kind knd: SelectKind,
) -> Select

Gets the kind of the Select query.

get_limit

</> 
pub fn get_limit(query qry: Select) -> Limit

Gets Limit in the Select query.

get_offset

</> 
pub fn get_offset(query qry: Select) -> Offset

Gets Offset in the Select query.

get_order_by

</> 
pub fn get_order_by(query qry: Select) -> OrderBy

Gets the OrderBy from the Select query.

get_select

</> 
pub fn get_select(query qry: Select) -> Selects

Gets the SelectValues of the Select query.

get_where

</> 
pub fn get_where(query qry: Select) -> Where

Gets the Where of the Select query.

group_by

</> 
pub fn group_by(
  query qry: Select,
  group_by grpb: String,
) -> Select

Sets or appends GroupBy a single into an existing GroupBy.

group_bys

</> 
pub fn group_bys(
  query qry: Select,
  group_bys grpbs: List(String),
) -> Select

Sets or appends a list of GroupBy into an existing GroupBy.

having

</> 
pub fn having(query qry: Select, having whr: Where) -> Select

Sets an AndWhere or appends into an existing AndWhere.

  • If the outermost Where is an AndWhere, the new Where is appended to the list within AndWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an AndWhere.

NOTICE: HAVING allows to specify constraints much like WHERE, but filters the results after GROUP BY is applied instead of before. Because HAVING uses the same semantics as WHERE, it takes a Where.

int

</> 
pub fn int(value vl: Int) -> SelectValue

Creates an integer Param off an Int.

join

</> 
pub fn join(query qry: Select, join jn: Join) -> Select

Adds a Join to the Select query.

joins

</> 
pub fn joins(query qry: Select, joins jns: List(Join)) -> Select

Adds Joins to the Select query.

limit

</> 
pub fn limit(query qry: Select, limit lmt: Int) -> Select

Sets a Limit in the Select query.

new

</> 
pub fn new() -> Select

Creates an empty Select query.

no_comment

</> 
pub fn no_comment(query qry: Select) -> Select

Removes the Comment from the Select query.

no_epilog

</> 
pub fn no_epilog(query qry: Select) -> Select

Removes the Epilog from the Select query.

no_from

</> 
pub fn no_from(query qry: Select) -> Select

Removes the FROM clause of the Select query.

no_group_by

</> 
pub fn no_group_by(query qry: Select) -> Select

Removes GroupBy from the Select query.

no_having

</> 
pub fn no_having(query qry: Select) -> Select

Removes HAVING from the Select query.

no_join

</> 
pub fn no_join(query qry: Select) -> Select

Removes any Joins from the Select query.

no_limit

</> 
pub fn no_limit(query qry: Select) -> Select

Removes Limit from the Select query.

no_offset

</> 
pub fn no_offset(query qry: Select) -> Select

Removes Offset from the Select query.

no_order_by

</> 
pub fn no_order_by(query qry: Select) -> Select

Removes the OrderBy from the Select query.

no_where

</> 
pub fn no_where(query qry: Select) -> Select

Removes the Where from the Select query.

offset

</> 
pub fn offset(query qry: Select, offst offst: Int) -> Select

Sets an Offset in the Select query.

or_having

</> 
pub fn or_having(query qry: Select, having whr: Where) -> Select

Sets an OrWhere or appends into an existing OrWhere.

  • If the outermost Where is an OrWhere, the new Where is appended to the list within OrWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an OrWhere.

See function having on details why this takes a Where.

or_where

</> 
pub fn or_where(query qry: Select, where whr: Where) -> Select

Sets an OrWhere or appends into an existing OrWhere.

  • If the outermost Where is an OrWhere, the new Where is appended to the list within OrWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an OrWhere.

order_by

</> 
pub fn order_by(
  query qry: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

Creates or appends an OrderBy a column with a direction.

The direction can either ASC or DESC.

order_by_asc

</> 
pub fn order_by_asc(query qry: Select, by ordb: String) -> Select

Creates or appends an ascending OrderBy.

order_by_asc_nulls_first

</> 
pub fn order_by_asc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

Creates or appends an ascending OrderBy with NULLS FIRST.

NOTICE: MariaDB/MySQL do not support NULLS FIRST out of the box.

order_by_asc_nulls_last

</> 
pub fn order_by_asc_nulls_last(
  query qry: Select,
  by ordb: String,
) -> Select

Creates or appends an ascending OrderBy with NULLS LAST.

NOTICE: MariaDB/MySQL do not support NULLS LAST out of the box.

order_by_desc

</> 
pub fn order_by_desc(
  query qry: Select,
  by ordb: String,
) -> Select

Creates or appends a descending OrderBy.

order_by_desc_nulls_first

</> 
pub fn order_by_desc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

Creates or appends a descending order with NULLS FIRST.

NOTICE: MariaDB/MySQL do not support NULLS FIRST out of the box.

order_by_desc_nulls_last

</> 
pub fn order_by_desc_nulls_last(
  query qry: Select,
  by ordb: String,
) -> Select

Creates or appends a descending OrderBy with NULLS LAST.

NOTICE: MariaDB/MySQL do not support NULLS LAST out of the box.

replace_group_by

</> 
pub fn replace_group_by(
  query qry: Select,
  group_by grpb: String,
) -> Select

Replaces GroupBy with a single GroupBy.

replace_group_bys

</> 
pub fn replace_group_bys(
  query qry: Select,
  group_bys grpbs: List(String),
) -> Select

Replaces GroupBy with a list of GroupBys.

replace_having

</> 
pub fn replace_having(
  query qry: Select,
  having whr: Where,
) -> Select

Replaces HAVING in the Select query.

See function having on details why this takes a Where.

replace_join

</> 
pub fn replace_join(query qry: Select, join jn: Join) -> Select

Replaces any Joins of the Select query with a signle Join.

replace_joins

</> 
pub fn replace_joins(
  query qry: Select,
  joins jns: List(Join),
) -> Select

Replaces any Joins of the Select query with the given Joins.

replace_order_by

</> 
pub fn replace_order_by(
  query qry: Select,
  by ordb: String,
  direction dir: Direction,
) -> Select

Replaces the OrderBy a column with a direction.

replace_order_by_asc

</> 
pub fn replace_order_by_asc(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy.

replace_order_by_asc_nulls_first

</> 
pub fn replace_order_by_asc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy with NULLS FIRST.

NOTICE: MariaDB/MySQL do not support NULLS FIRST out of the box.

replace_order_by_asc_nulls_last

</> 
pub fn replace_order_by_asc_nulls_last(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single ascending OrderBy with NULLS LAST.

NOTICE: MariaDB/MySQL do not support NULLS LAST out of the box.

replace_order_by_desc

</> 
pub fn replace_order_by_desc(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending order.

replace_order_by_desc_nulls_first

</> 
pub fn replace_order_by_desc_nulls_first(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending order with NULLS FIRST.

NOTICE: MariaDB/MySQL do not support NULLS FIRST out of the box.

replace_order_by_desc_nulls_last

</> 
pub fn replace_order_by_desc_nulls_last(
  query qry: Select,
  by ordb: String,
) -> Select

Replaces the OrderBy a single descending OrderBy with NULLS LAST.

NOTICE: MariaDB/MySQL do not support NULLS LAST out of the box.

replace_select

</> 
pub fn replace_select(
  query qry: Select,
  select_value sv: SelectValue,
) -> Select

Add a SelectValues to the Select query.

If the query already has any SelectValues, they are replaced.

replace_selects

</> 
pub fn replace_selects(
  query qry: Select,
  select_values svs: List(SelectValue),
) -> Select

Adds SelectValues to the Select query.

If the query already has any SelectValues, they are replaced.

replace_where

</> 
pub fn replace_where(
  query qry: Select,
  where whr: Where,
) -> Select

Replaces the Where in the Select query.

select

</> 
pub fn select(
  query qry: Select,
  select_value sv: SelectValue,
) -> Select

Add a SelectValue to the Select query.

If the query already has any SelectValues, the new one is appended.

selects

</> 
pub fn selects(
  query qry: Select,
  select_values svs: List(SelectValue),
) -> Select

Adds SelectValues to the Select query.

If the query already has any SelectValues, the new ones are appended.

string

</> 
pub fn string(value vl: String) -> SelectValue

Creates a string Param off a String.

to_query

</> 
pub fn to_query(query qry: Select) -> Query

Creates a Query from a Select query.

where

</> 
pub fn where(query qry: Select, where whr: Where) -> Select

Sets an AndWhere or appends into an existing AndWhere.

  • If the outermost Where is an AndWhere, the new Where is appended to the list within AndWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an AndWhere.

xor_having

</> 
pub fn xor_having(query qry: Select, having whr: Where) -> Select

Sets an XorWhere or appends into an existing XorWhere.

  • If the outermost Where is an XorWhere, the new Where is appended to the list within XorWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an XorWhere.

See function having on details why this takes a Where.

NOTICE: This operator does not exist in Postgres or SQLite, and Cake generates equivalent SQL using OR and AND and NOT. This operator exists in MariaDB/MySQL.

xor_where

</> 
pub fn xor_where(query qry: Select, where whr: Where) -> Select

Sets an XorWhere or appends into an existing XorWhere.

  • If the outermost Where is an XorWhere, the new Where is appended to the list within XorWhere.
  • If the query does not have a Where clause, the given Where is set instead.
  • If the outermost Where is any other kind of Where, this and the current outermost Where are wrapped in an XorWhere.

NOTICE: This operator does not exist in Postgres or SQLite, and Cake generates equivalent SQL using OR and AND and NOT. This operator exists in MariaDB/MySQL.

✨ Search Document